diff --git a/.bumpversion.cfg b/.bumpversion.cfg
new file mode 100644
index 0000000..54b6c97
--- /dev/null
+++ b/.bumpversion.cfg
@@ -0,0 +1,10 @@
+[bumpversion]
+current_version = 0.0.2
+commit = true
+tag = false
+tag_name = v{new_version}
+message = Bump version: {current_version} → {new_version}
+
+[bumpversion:file:pyproject.toml]
+search = version = "{current_version}"
+replace = version = "{new_version}"
\ No newline at end of file
diff --git a/.claude/CLAUDE.md b/.claude/CLAUDE.md
new file mode 100644
index 0000000..f1ef708
--- /dev/null
+++ b/.claude/CLAUDE.md
@@ -0,0 +1,78 @@
+---
+last_updated: 2026-07-23
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# CLAUDE.md
+
+This file provides guidance to Claude Code (claude.ai/code) when working with code in this repository.
+
+## Project Overview
+
+`py-MathTools` is the **Tier 3 math implementation layer** of the foundation
+math tiers defined in py-foundationTools' `mathTypeTiers.md`: it subclasses
+the Tier-2 `foundation_abc.math.*` ABCs, chooses numpy-backed storage, and
+implements arithmetic, composition, interpolation, DSP, and trajectory
+generation on top of the Tier-1 `foundationTypes.mathTypes` data carriers.
+Unlike `pyFoundationTools` (zero-dependency by policy), this repo depends on
+a curated set of mature numeric packages rather than reimplementing them.
+
+## Packages and layering
+
+Two top-level snake_case packages under `src/`, one-way dependency:
+
+```
+math_plot_helpers  →  math_tools  →  pyFoundationTools  →  stdlib
+       (matplotlib)      (numpy, scipy, numpy-quaternion)
+```
+
+`math_tools` never imports `math_plot_helpers` or `matplotlib`; only
+`math_plot_helpers` imports `matplotlib`. This is enforced by
+`tests/test_package_layering.py` (static AST scan of `src/`).
+
+## Commands
+
+All workflows go through the Makefile (`make help` lists them); **the
+Makefile is the source of truth for tooling**, not this file or the README.
+The `uv-` prefixed targets are the primary path. Key ones:
+
+- `make uv-fullCheck` — CI gate: `uv-lint` + `uv-typecheck` + `uv-test`. Run
+  this before considering work done.
+- `make uv-lint` — ruff check
+- `make uv-format` — `ruff format` + `ruff check --fix --unsafe-fixes`
+- `make uv-typecheck` — strict `mypy` over `src/` + `tests/`
+- `make uv-test` — sync deps then run pytest
+- `make uv-refresh` — clean cache + reinstall from `requirements.txt` +
+  upgrade editable dev install (required after a `pyFoundationTools` pin
+  changes; a stale `.venv` makes the gate meaningless)
+
+## Specs
+
+`.claude/specs/` is the authoritative contract for this repo's architecture
+and every module's behavior. Consult the relevant spec before extending a
+module; if implementation forces a contract change, the spec is updated in
+the same change and its `semver` bumped.
+
+- [mathToolsArchitecture.md](specs/mathToolsArchitecture.md) — umbrella:
+  layering, package layout, dependency policy, shared conventions, error
+  semantics
+- [templateConformance.md](specs/templateConformance.md) — template
+  migration: packaging, Makefile/CI parity, rename, governance docs
+- [precisionTimeMath.md](specs/precisionTimeMath.md) — `PrecisionTimeInterval`,
+  `PrecisionTimestamp`
+- [spatialMath.md](specs/spatialMath.md) — `Position`, `Quaternion`,
+  `SpatialPose`
+- [waveformCore.md](specs/waveformCore.md) — `Waveform1D` + aggregate
+  waveform containers
+- [waveformDsp.md](specs/waveformDsp.md) — DSP families, scipy mapping,
+  support types
+- [polynomials.md](specs/polynomials.md) — polynomial type + analytic root
+  solvers
+- [otg.md](specs/otg.md) — online trajectory generation (Ruckig port)
+
+## Tests
+
+Tests live in `tests/`, `unittest.TestCase` style run under pytest
+(`test*.py` files, `test_*` methods), mirroring the package layout under
+`src/` (e.g. `tests/spatial/test_position.py`).
diff --git a/.claude/archive/math-tools-port/00-overview.md b/.claude/archive/math-tools-port/00-overview.md
new file mode 100644
index 0000000..e820701
--- /dev/null
+++ b/.claude/archive/math-tools-port/00-overview.md
@@ -0,0 +1,195 @@
+---
+plan: math-tools-port
+status: complete
+last_updated: 2026-07-23
+semver: 0.1.2
+author: Nicholas Bergantz
+---
+
+# Action Plan — Template Migration + Swift Math Port
+
+**Goal:** bring py-MathTools onto the py-foundationTools template conventions
+and port the Swift `FoundationMathTypes` capability set (spatial SE(3) types,
+precision time, waveforms + DSP, polynomials/roots, OTG trajectory
+generation) as the Tier-3 math layer, per the accepted specs in
+[`../specs/`](../specs/mathToolsArchitecture.md).
+
+**Usability north star:** a robotics/DSP engineer in a notebook can build a
+waveform or pose, do the obvious math, and reach scipy-grade analysis with
+minimal ceremony — well-typed numpy-adjacent Python, not translated Swift.
+
+## Conventions every chunk inherits (do not restate per chunk)
+
+1. **Spec is authoritative.** Each chunk lists its governing spec section(s).
+   If implementation forces a contract change, update the spec in the same
+   chunk and bump its `semver`.
+2. **TDD:** write the failing tests first, implement, then run the gate.
+3. **Gate:** `make uv-fullCheck` (ruff lint + mypy strict + pytest) must pass
+   at the end of every chunk. Test layout mirrors the package
+   (`tests/<subpkg>/test_<module>.py`), `unittest.TestCase` style, `test_*`
+   methods.
+4. **Stay in scope:** touch ONLY the files the chunk lists. Adjacent
+   problems get reported in the chunk's completion notes, not fixed.
+5. **Frontmatter:** every chunk carries `status: pending` → set
+   `in_progress` while working, then `complete` when done (not `done`
+   — `complete` is the convention actually used across every chunk file
+   in this repo); bump `last_updated`.
+6. **Swift reference roots** (read-only, for faithful-port chunks):
+   - `SWIFT_MATH` = `/Users/nbergantz/__Workspaces__/spmWorkspaces/spmMathTools/spm/Sources/spmMathTools/FoundationMathTypes`
+   - `SWIFT_TYPES` = `/Users/nbergantz/__Workspaces__/spmWorkspaces/spmFoundationTools/spm/Sources/FoundationTypes`
+   - `SWIFT_TESTS` = `/Users/nbergantz/__Workspaces__/spmWorkspaces/spmMathTools/spm/Tests/spmMathToolsTests`
+7. **Shared API idioms** (umbrella spec "API idioms"): `normalized()` method
+   / `normalize()` in-place; `isclose(rtol, atol)`; `__array__`;
+   `__hash__ = None` on mutable numpy-backed classes; snake_case throughout.
+8. Do not commit; the human reviews and commits per track.
+
+## Dependency graph
+
+```
+Track A (template)      01 ──► 02 ──► 03
+                         │
+        ┌────────────────┴───────────────────────────────┐
+Track B │  04 ─► 05          06 ─► 07 ─► 08      09   10 │ (02 before all B)
+        │   └──────┬──────────┘└───┬────┘              │ │
+Track C │          ▼               │                   │ │
+        │  11 ─► {12, 13, 14}      │                   │ │
+        │   │        │             ▼                   │ │
+        │   │        │   15(◄06) 16(◄07) ─► 17(◄08,15,16)│
+Track D │   │        ▼                                 │ │
+        │   │   18..29 (one per mixin; 26 also ◄19)    │ │
+        │   │        └────────► 30 (compose)           │ │
+Track E │   └──────────────────────────────────────────┘ │
+        │  31(◄10) ─► 32                                 │
+        │  31 ─► 33 ─► 34 ─► {35, 36, 37, 38, 39}        │
+        │  {32,35..39} ─► 40 ─► 41 ─► 42                 │
+        └────────────────────────────────────────────────┘
+```
+
+Tracks B/C/D/E parallelize after 01–02; within a track, run in numeric
+order unless the graph says otherwise. Chunk 43 (public surface) runs last,
+after 09, 17, 30, and 42.
+
+## Chunk index
+
+| # | Chunk | Track | Depends on | Spec |
+|---|---|---|---|---|
+| 01 | [template-rename-and-refresh](01-template-rename-and-refresh.md) | A | — | templateConformance |
+| 02 | [errors-and-layering](02-errors-and-layering.md) | A | 01 | umbrella, templateConformance §5 |
+| 03 | [governance-and-readme](03-governance-and-readme.md) | A | 02 | templateConformance §3–4 |
+| 04 | [precision-time-interval](04-precision-time-interval.md) | B | 02 | precisionTimeMath |
+| 05 | [precision-timestamp](05-precision-timestamp.md) | B | 04 | precisionTimeMath |
+| 06 | [position](06-position.md) | B | 02 | spatialMath |
+| 07 | [quaternion-additions](07-quaternion-additions.md) | B | 06 | spatialMath |
+| 08 | [spatial-pose](08-spatial-pose.md) | B | 07 | spatialMath |
+| 09 | [univariate-polynomial](09-univariate-polynomial.md) | B | 02 | polynomials |
+| 10 | [roots-kernel](10-roots-kernel.md) | B | 02 | polynomials |
+| 11 | [waveform1d-core](11-waveform1d-core.md) | C | 05 | waveformCore |
+| 12 | [waveform1d-operators](12-waveform1d-operators.md) | C | 11 | waveformCore |
+| 13 | [waveform1d-generators](13-waveform1d-generators.md) | C | 11 | waveformCore |
+| 14 | [dsp-support-and-protocol](14-dsp-support-and-protocol.md) | C | 11 | waveformDsp |
+| 15 | [waveform-position](15-waveform-position.md) | C | 11, 06 | waveformCore |
+| 16 | [waveform-quaternion](16-waveform-quaternion.md) | C | 11, 07 | waveformCore |
+| 17 | [waveform-spatial-pose](17-waveform-spatial-pose.md) | C | 08, 15, 16 | waveformCore |
+| 18 | [dsp-calc](18-dsp-calc.md) | D | 14 | waveformDsp |
+| 19 | [dsp-correlation](19-dsp-correlation.md) | D | 14 | waveformDsp |
+| 20 | [dsp-envelope](20-dsp-envelope.md) | D | 14 | waveformDsp |
+| 21 | [dsp-spectral](21-dsp-spectral.md) | D | 14 | waveformDsp |
+| 22 | [dsp-filtering](22-dsp-filtering.md) | D | 14 | waveformDsp |
+| 23 | [dsp-peaks](23-dsp-peaks.md) | D | 14 | waveformDsp |
+| 24 | [dsp-phase](24-dsp-phase.md) | D | 14 | waveformDsp |
+| 25 | [dsp-resampling](25-dsp-resampling.md) | D | 14 | waveformDsp |
+| 26 | [dsp-time-alignment](26-dsp-time-alignment.md) | D | 14, 19 | waveformDsp |
+| 27 | [dsp-triggers](27-dsp-triggers.md) | D | 14 | waveformDsp |
+| 28 | [dsp-windowing](28-dsp-windowing.md) | D | 14 | waveformDsp |
+| 29 | [dsp-zero-crossings](29-dsp-zero-crossings.md) | D | 14 | waveformDsp |
+| 30 | [dsp-compose](30-dsp-compose.md) | D | 18–29 | waveformDsp |
+| 31 | [otg-enums-and-errors](31-otg-enums-and-errors.md) | E | 10 | otg |
+| 32 | [otg-input-parameter](32-otg-input-parameter.md) | E | 31 | otg |
+| 33 | [otg-profile](33-otg-profile.md) | E | 31 | otg |
+| 34 | [otg-block-brake-bound](34-otg-block-brake-bound.md) | E | 33 | otg |
+| 35 | [otg-trajectory-and-output](35-otg-trajectory-and-output.md) | E | 34 | otg |
+| 36 | [otg-velocity-steps](36-otg-velocity-steps.md) | E | 34 | otg |
+| 37 | [otg-position-first-second-steps](37-otg-position-first-second-steps.md) | E | 34 | otg |
+| 38 | [otg-position-third-step1](38-otg-position-third-step1.md) | E | 34 | otg |
+| 39 | [otg-position-third-step2](39-otg-position-third-step2.md) | E | 34 | otg |
+| 40 | [otg-calculator-target](40-otg-calculator-target.md) | E | 32, 35–39 | otg |
+| 41 | [otg-driver](41-otg-driver.md) | E | 40 | otg |
+| 42 | [otg-oracle-suites](42-otg-oracle-suites.md) | E | 41 | otg |
+| 43 | [public-surface](43-public-surface.md) | A | 30, 42, 09, 17 | umbrella |
+
+---
+
+# Corrective actions — 2026-07-22 post-audit
+
+Chunks 01–43 were audited against their governing specs by five parallel
+skeptical auditors (one per track), with the top findings independently
+reproduced at runtime and source level before being recorded here.
+
+**Verdict: substantially complete.** `make uv-fullCheck` is green (exit 0) and
+the port is faithful in the large — the 31-case OTG numeric truth table was
+re-derived from the Swift source with 0 mismatches, no test in the repo is
+skipped or xfail'd, and no unsolved algorithm case, stub, or swallowed `None`
+was found in the solvers. The confirmed gaps are specific and are chunked below.
+
+Chunks 44–57 form **Track F**. They are corrective, not new capability.
+
+## Confirmed defect summary
+
+| Class | Count | Where |
+|---|---|---|
+| (c) drift / correctness | 8 | OTG solvers, spatial/time accessors, waveform indexing |
+| (a) not implemented | 6 | aggregate API idioms, subpackage exports, roots degeneracy |
+| (b) implemented, untested | ~45 | concentrated in DSP mixins and OTG oracles |
+| (e) docs/convention drift | 14 | dead workflow refs, stale tolerances, boilerplate |
+| (d) out-of-scope violations | **0** | — none found in any track |
+
+The single most consequential finding is a **transcription defect** at
+`position_third_order_step2.py:1731,1752,1763` (`j·tf⁴` where Swift has
+`j·tf³`), confirmed by direct comparison against
+`PositionThirdOrderStep2.swift:1279,1286,1289`. It changes profile-branch
+selection in ~0.57% of prescribed-duration Step2 solves and is invisible to the
+current gate — because the entire 1,784-case OTG oracle corpus is 1-DOF, which
+takes a fast path that **never invokes Step2 at all** (measured: 0 invocations).
+
+## Dependency graph
+
+```
+Track F (corrective)
+
+  OTG code fixes        44   45   46
+                         └────┴────┴──────► 56 (OTG oracle closure)
+
+  Track B/C code fixes  47   48   49 ─► 50   51
+                                    └────┴────┴─► 54 (B/C test closure)
+
+  Surface / conventions 52        53 ─────────────► 55 (DSP test closure)
+
+  Everything above ───────────────────────────────► 57 (docs sweep, last)
+```
+
+44–49, 51, 52, 53 are mutually independent and may run in parallel.
+50 waits on 49. The three closure chunks wait on their code fixes. 57 runs last
+so it reconciles docs against the post-fix repo.
+
+## Corrective chunk index
+
+| # | Chunk | Kind | Depends on | Origin |
+|---|---|---|---|---|
+| 44 | [otg-step2-udud-discriminant](44-otg-step2-udud-discriminant.md) | fix | — | E-1 |
+| 45 | [otg-trivial-profile-length](45-otg-trivial-profile-length.md) | fix | — | E-2 |
+| 46 | [otg-step1-sqrt-guard](46-otg-step1-sqrt-guard.md) | fix | — | E-3 |
+| 47 | [position-tolerance-and-timestamp-accessors](47-position-tolerance-and-timestamp-accessors.md) | fix | — | B-1, B-2 |
+| 48 | [roots-degenerate-cases](48-roots-degenerate-cases.md) | fix | — | B-7, B-14 |
+| 49 | [waveform-spatial-pose-indexing](49-waveform-spatial-pose-indexing.md) | fix | — | C-4, C-5 |
+| 50 | [aggregate-container-api-idioms](50-aggregate-container-api-idioms.md) | fix | 49 | C-1, C-2, C-3, C-7 |
+| 51 | [waveform-generator-phase-conventions](51-waveform-generator-phase-conventions.md) | fix | — | C-15 |
+| 52 | [subpackage-public-surface](52-subpackage-public-surface.md) | fix | — | A-1, A-2 |
+| 53 | [window-convention-reconciliation](53-window-convention-reconciliation.md) | fix | — | D-windowing |
+| 54 | [test-closure-tracks-bc](54-test-closure-tracks-bc.md) | tests | 47–51 | 11 (b) findings |
+| 55 | [test-closure-dsp](55-test-closure-dsp.md) | tests | 53 | 23 (b) findings |
+| 56 | [test-closure-otg-oracles](56-test-closure-otg-oracles.md) | tests | 44, 45, 46 | 8 (b) findings |
+| 57 | [docs-and-convention-sweep](57-docs-and-convention-sweep.md) | docs | 44–56 | 14 (e) findings |
+
+Findings deliberately **not** actioned (B-4, B-5, B-6, A-7, D-cross-cutting,
+D-spectral-(c), E-10) are recorded with rationale in chunk 57's
+"Recorded — no action" section, so the decisions are not relitigated.
diff --git a/.claude/archive/math-tools-port/01-template-rename-and-refresh.md b/.claude/archive/math-tools-port/01-template-rename-and-refresh.md
new file mode 100644
index 0000000..2d09849
--- /dev/null
+++ b/.claude/archive/math-tools-port/01-template-rename-and-refresh.md
@@ -0,0 +1,123 @@
+---
+chunk: 01-template-rename-and-refresh
+track: A
+status: complete
+depends_on: []
+spec: ../specs/templateConformance.md §Gap 1, §Gap 2.4; ../specs/spatialMath.md §Modules (ABC re-parent)
+last_updated: 2026-07-11
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 01 — Package rename + environment refresh
+
+**Deliverable:** the repo builds and gates green under the new snake_case
+package names against the pinned foundation branch. Mechanical migration —
+no behavior changes beyond the required ABC re-parent.
+
+## Files
+
+- `git mv src/pyMathTools src/math_tools`; inside it:
+  `git mv src/math_tools/spatial/Quaternion.py src/math_tools/spatial/quaternion.py`,
+  `git mv src/math_tools/spherical/sphericalGenerators.py src/math_tools/spherical/spherical_generators.py`,
+  `git mv src/math_tools/spherical/sphericalTransforms.py src/math_tools/spherical/spherical_transforms.py`
+  (`constructors.py`, `hints.py` keep their names).
+- `git mv src/pyMathToolsPlotHelpers src/math_plot_helpers`;
+  `git mv src/math_plot_helpers/plotUnitSpherical.py src/math_plot_helpers/plot_unit_spherical.py`.
+- Edit: `src/math_tools/spatial/quaternion.py` (imports/base only, see below),
+  every `__init__.py` touched by moves, `tests/test_quaternion.py`,
+  `examples/sphericalPlotting/plotArcs.py`,
+  `examples/sphericalPlotting/plotQuatUnitCircles.py`, `Makefile` (mypy
+  package list if it names packages), `.env` if it names packages.
+- Add: `py.typed` in `src/math_tools/` and `src/math_plot_helpers/` roots
+  (keep the existing ones in subpackages).
+
+## Design constraints
+
+1. **First action:** `make uv-refresh` so `.venv` matches the
+   `requirements.txt` branch pin (the stale install has the pre-template ABC
+   layout; nothing imports correctly until this runs).
+2. **ABC re-parent (the one semantic edit):** in `quaternion.py`, replace
+   `from foundationTypes.mathTypes.quaternionABC import QuaternionABC` with
+   `from foundation_abc.math.spatialABCs import QuaternionABC`. The old ABC
+   carried `DataModelHelper`; the new one is ABC-only with a concrete
+   `to_dict`. In `tests/test_quaternion.py`, update the serialization tests'
+   base-class assertions (`DataModelHelper` inheritance assertion → the new
+   ABC) — assertions on `to_dict`/`from_dict` *values* stay untouched. If any
+   other import from the old layout exists (grep `foundationTypes.mathTypes.`
+   across `src/`), re-point to `foundation_abc.math.*` /
+   `foundationTypes.mathTypes.MathTypes` equivalents.
+3. All other edits are import-path text substitutions
+   (`pyMathTools` → `math_tools`, `pyMathToolsPlotHelpers` →
+   `math_plot_helpers`, moved module filenames).
+4. `pyproject.toml`: update `description` only if trivially co-located; the
+   deps list changes in chunk 03, not here.
+
+## TDD steps
+
+1. `make uv-refresh`; run `make uv-test` to record the pre-existing pass/fail
+   baseline (the ABC import may already be broken — note it).
+2. Perform moves + edits.
+3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] `grep -rn "pyMathTools" src/ tests/ examples/ Makefile .env pyproject.toml` → no hits
+- [x] `grep -rn "foundationTypes.mathTypes.quaternionABC" src/ tests/` → no hits
+- [x] `git log --follow --oneline src/math_tools/spatial/quaternion.py` shows history (moves were `git mv`) — verified via `git status`/`git diff --staged` showing `renamed: src/pyMathTools/spatial/Quaternion.py -> src/math_tools/spatial/quaternion.py`; `--follow` itself needs a commit to walk, which this chunk intentionally leaves to the supervising process
+- [x] All ~90 quaternion tests pass (89 collected/passed); diff to `tests/test_quaternion.py` contains only import lines, base-class assertion lines, and their two adjacent docstring lines (see Resolution notes)
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+`errors.py`, layering test, README, `.claude/CLAUDE.md`, pyproject dependency
+list, any new math code, any `__init__.py` re-export curation beyond fixing
+broken imports.
+
+## Resolution notes
+
+- `make uv-refresh` pulled the pinned foundation branch fresh; pre-move
+  `make uv-test` baseline reproduced the expected pre-existing break
+  (`ModuleNotFoundError: foundationTypes.mathTypes.quaternionABC`), confirming
+  the venv was stale before this chunk and the gate is meaningful after.
+- Moves done via `git mv` as specified. `git status`/`git diff --staged`
+  correctly report `quaternion.py` as a rename from `Quaternion.py`; git's
+  similarity heuristic cross-matched some of the (byte-identical, empty)
+  `__init__.py` files to different-but-equivalent old empty `__init__.py`
+  paths — cosmetic only, every file's on-disk destination was verified
+  directly with `find`, and it does not affect `--follow` on the files that
+  matter (confirmed for `quaternion.py`).
+- The old-layout ABC repoint (design constraint 2) turned out to reach beyond
+  `quaternion.py`: `foundationTypes.mathTypes.unitSphericalArcABC` and
+  `unitSphericalSmallCircleABC` (imported by `spherical_generators.py`,
+  `spherical_transforms.py`, `constructors.py`, `plot_unit_spherical.py`)
+  were also deleted from the pinned foundation branch and now live at
+  `foundation_abc.math.sphericalABCs`. Re-pointed all of them per the chunk's
+  explicit "grep `foundationTypes.mathTypes.` across `src/`" instruction —
+  required for `make uv-fullCheck` (mypy strict) to pass, since mypy scans
+  all of `src/`, not just the quaternion module. `foundationTypes.mathTypes.MathTypes.*`
+  imports (the codegen `*Type` classes) were left untouched — that module
+  still exists unchanged in the new layout.
+  This is a scope note, not a spec deviation: constraint 2's own text
+  authorized exactly this action; the "Files" list section above just didn't
+  enumerate every file it touched.
+- `examples/sphericalPlotting/plotArcs.py` and `plotQuatUnitCircles.py` got
+  only the mechanical package-name substitution, per constraint 3 and Gap 4's
+  explicit ownership of their pre-existing broken `foundationTypes.mathTypes.UnitSphericalArc`
+  / `UnitSphericalSmallCircle` imports (not part of this chunk's scope, and
+  not scanned by `make uv-typecheck` since `PY_EXAMPLES` is unset in `.env`).
+- `tests/test_quaternion.py`: `test_inheritance_from_data_model_helper`
+  asserted `isinstance(q, DataModelHelper)`, which is no longer true (the new
+  `QuaternionABC` is ABC-only). Repointed the import and assertion to
+  `QuaternionABC` per constraint 2's directive, and updated that test's and
+  the class's docstrings by one line each so the docstrings don't contradict
+  the assertion right below them — the only lines in this diff beyond raw
+  import-path substitution. No `to_dict`/`from_dict` value assertions were
+  touched.
+- Added `py.typed` at `src/math_tools/` and `src/math_plot_helpers/` package
+  roots (subpackage ones already existed).
+- No `Makefile`/`.env` edits were needed — neither names packages explicitly
+  (both scope quality targets via path variables, not package names).
+- `pyproject.toml` `description` left untouched — no trivially co-located
+  edit was applicable in this chunk; still boilerplate text, tracked as Gap 4
+  (chunk 03).
diff --git a/.claude/archive/math-tools-port/02-errors-and-layering.md b/.claude/archive/math-tools-port/02-errors-and-layering.md
new file mode 100644
index 0000000..78fdbfb
--- /dev/null
+++ b/.claude/archive/math-tools-port/02-errors-and-layering.md
@@ -0,0 +1,74 @@
+---
+chunk: 02-errors-and-layering
+track: A
+status: complete
+depends_on: [01]
+spec: ../specs/mathToolsArchitecture.md §Error semantics; ../specs/templateConformance.md §Gap 5
+last_updated: 2026-07-11
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 02 — Exception hierarchy + package layering test
+
+**Deliverable:** `math_tools/errors.py` and the AST-based layering test.
+
+## Files
+
+- Create: `src/math_tools/errors.py`
+- Create: `tests/test_package_layering.py`
+- Create: `tests/test_errors.py`
+
+## Design constraints
+
+1. `errors.py` defines exactly (each with a one-line docstring):
+   `MathToolsError(Exception)`, `WaveformCompatibilityError(MathToolsError)`,
+   `TimestampComparisonError(MathToolsError)`,
+   `PolynomialSolveError(MathToolsError)`.
+2. Layering test pattern: copy the approach of py-foundationTools
+   `tests/test_package_layering.py` (AST-walk every module under `src/`,
+   collect `import`/`from` roots). Assertions per templateConformance §Gap 5:
+   `math_tools` imports neither `math_plot_helpers` nor `matplotlib`;
+   only `math_plot_helpers` imports `matplotlib`.
+3. Additionally assert `math_tools.otg` (once it exists) does not import
+   `numpy` — write the rule now, guarded to skip if the package dir is
+   absent, so OTG chunks inherit enforcement for free.
+
+## TDD steps
+
+1. Write `tests/test_errors.py` (hierarchy, catchability as `MathToolsError`)
+   and `tests/test_package_layering.py`; watch errors test fail.
+2. Implement `errors.py`; layering test must pass against the current tree.
+3. Temporarily add `import matplotlib` to a `math_tools` module and confirm
+   the layering test fails; revert. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] All four exception classes exist and subclass as specified
+- [x] Layering test fails on an injected `import matplotlib` in `math_tools` (verified then reverted)
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Any consumer of the exceptions; OTG's `OtgError` (lives in `otg/errors.py`,
+chunk 31); README/CLAUDE.md.
+
+## Resolution notes
+
+- `errors.py` implements exactly the four classes from the spec, each a
+  one-line docstring, no added behavior.
+- `test_package_layering.py` follows the py-foundationTools AST-scan pattern
+  (`tests/test_package_layering.py` there) rather than executing imports, so
+  it can't be defeated by import side effects. Four checks: `math_tools` ↛
+  `math_plot_helpers`, `math_tools` ↛ `matplotlib`, only `math_plot_helpers`
+  → `matplotlib` (scans all of `src/` excluding that package), and the
+  guarded `math_tools.otg` ↛ `numpy` rule (currently a no-op skip since
+  `otg/` doesn't exist yet — will activate automatically once chunk 31 lands).
+- Verification step 3 (inject `import matplotlib` into `math_tools/errors.py`,
+  confirm two layering assertions fail, revert) was done live against the
+  actual gate, not simulated; file diffed back to the original after.
+- One ruff fix needed: the injected-violation assertion message exceeded the
+  100-char line limit in `test_only_math_plot_helpers_imports_matplotlib`'s
+  sibling test; wrapped the f-string across two lines.
+- No spec changes were required — the chunk's design constraints matched the
+  umbrella spec's Error semantics section exactly.
diff --git a/.claude/archive/math-tools-port/03-governance-and-readme.md b/.claude/archive/math-tools-port/03-governance-and-readme.md
new file mode 100644
index 0000000..804cdab
--- /dev/null
+++ b/.claude/archive/math-tools-port/03-governance-and-readme.md
@@ -0,0 +1,106 @@
+---
+chunk: 03-governance-and-readme
+track: A
+status: complete
+depends_on: [02]
+spec: ../specs/templateConformance.md §Gap 2, §Gap 3, §Gap 4
+last_updated: 2026-07-11
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 03 — Governance docs, README, dependency names
+
+**Deliverable:** `.claude/CLAUDE.md`, real README, pyproject dependency
+names, fixed examples.
+
+## Files
+
+- Create: `.claude/CLAUDE.md`
+- Edit: `README.md`, `pyproject.toml` (deps + description only),
+  `examples/sphericalPlotting/plotArcs.py`,
+  `examples/sphericalPlotting/plotQuatUnitCircles.py`
+
+## Design constraints
+
+1. `.claude/CLAUDE.md` follows the shape of py-foundationTools
+   `.claude/CLAUDE.md` but stays short: repo role (Tier 3 of foundation's
+   `mathTypeTiers.md`), the two-package layering diagram, gate command,
+   Makefile-is-source-of-truth note, and a linked index of every spec in
+   `.claude/specs/`. Reference specs; never duplicate their content.
+2. `pyproject.toml` `dependencies` = names only:
+   `pyFoundationTools`, `numpy`, `scipy`, `numpy-quaternion`, `matplotlib`.
+   Replace the boilerplate `description`.
+3. README per templateConformance Gap 4: describe only what exists at
+   execution time (quaternion, spherical utilities, template workflows);
+   sections: title → Features → Installation → Quick Start → Development
+   Workflows → Requirements. Quick Start snippets must actually run.
+4. `plotArcs.py`: fix the dead
+   `foundationTypes.mathTypes.UnitSphericalArc.UnitSphericalArc` import to
+   the real generated type in `foundationTypes.mathTypes.MathTypes`
+   (verify the class name by reading that module).
+
+## TDD steps
+
+1. Add a test `tests/test_governance.py`: `.claude/CLAUDE.md` exists and its
+   text links every `*.md` in `.claude/specs/`; `README.md` contains no
+   "Boilerplate". Watch it fail.
+2. Write the docs; run both example scripts manually
+   (`uv run python examples/sphericalPlotting/plotArcs.py` with a
+   non-interactive matplotlib backend) to prove imports resolve.
+3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] `tests/test_governance.py` passes
+- [x] `pyproject.toml` deps are exactly the five names, unpinned
+- [x] Both example scripts import-run without error
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Makefile/CI edits; requirements pin changes; any `src/` code beyond the
+example imports.
+
+## Resolution notes
+
+- `tests/test_governance.py` added: asserts `.claude/CLAUDE.md` exists and
+  its text contains the filename of every `.claude/specs/*.md` file, and
+  that `README.md` contains no `"Boilerplate"` text. Confirmed it failed
+  before the docs existed, passed after.
+- `.claude/CLAUDE.md` written to the shape of py-foundationTools'
+  `.claude/CLAUDE.md` (Project Overview → layering → Commands → Specs index
+  → Tests) but scoped to what exists in this repo today: Tier 3 role, the
+  two-package layering diagram, the gate command, a Makefile-is-source-of-
+  truth note, and a linked index of all 7 specs in `.claude/specs/`.
+- `README.md` rewritten per Gap 4's section shape (title → Features →
+  Installation → Quick Start → Development Workflows → Requirements),
+  describing only what exists at execution time: `Quaternion`, the
+  spherical arc/small-circle utilities, `errors.py`, and the
+  `math_plot_helpers` plotting package. Both Quick Start snippets
+  (quaternion arithmetic/conversion, spherical arc construction +
+  endpoint) were executed directly to confirm they run as written.
+- `pyproject.toml`: `dependencies` set to the five names
+  (`pyFoundationTools`, `numpy`, `scipy`, `numpy-quaternion`, `matplotlib`)
+  — the prior list was missing `numpy`/`scipy` and had an unrelated stray
+  order; `description` replaced with a one-line Tier-3 summary.
+- `examples/sphericalPlotting/plotArcs.py`: fixed the dead
+  `foundationTypes.mathTypes.UnitSphericalArc.UnitSphericalArc` import to
+  `foundationTypes.mathTypes.MathTypes.UnitSphericalArcType` (verified the
+  real class name by reading the installed `MathTypes.py`) and updated the
+  two local usages/type hints accordingly.
+- `examples/sphericalPlotting/plotQuatUnitCircles.py`: same dead-import
+  pattern existed for `UnitSphericalSmallCircle` (not called out by name in
+  the chunk's design constraint 4, but the file was listed for edit and the
+  acceptance criterion requires *both* scripts to import-run without
+  error) — fixed to `foundationTypes.mathTypes.MathTypes.UnitSphericalSmallCircleType`.
+- Both example scripts verified to run end-to-end with
+  `MPLBACKEND=Agg PYTHONPATH=src .venv/bin/python examples/sphericalPlotting/<script>.py`
+  — exit 0, only a benign "FigureCanvasAgg is non-interactive" UserWarning
+  from `show_plot=True` under a non-interactive backend. Examples are not
+  wired into `make uv-fullCheck` (`PY_EXAMPLES` is unset in `.env`), so
+  this was a manual verification step, not a gate addition (out of scope
+  per this chunk: "Makefile/CI edits").
+- Gate: `make uv-fullCheck` passes — ruff clean, `mypy src tests` strict
+  clean (16 source files), pytest 106 passed (includes the new
+  `tests/test_governance.py`).
diff --git a/.claude/archive/math-tools-port/04-precision-time-interval.md b/.claude/archive/math-tools-port/04-precision-time-interval.md
new file mode 100644
index 0000000..17397c2
--- /dev/null
+++ b/.claude/archive/math-tools-port/04-precision-time-interval.md
@@ -0,0 +1,109 @@
+---
+chunk: 04-precision-time-interval
+track: B
+status: complete
+depends_on: [02]
+spec: ../specs/precisionTimeMath.md §Representation, §PrecisionTimeInterval, §Compliance 1–6, 10
+last_updated: 2026-07-13
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 04 — `PrecisionTimeInterval`
+
+**Deliverable:** the immutable attosecond-exact interval type.
+
+## Files
+
+- Create: `src/math_tools/precision_time/__init__.py` (re-export
+  `PrecisionTimeInterval`; `PrecisionTimestamp` added by chunk 05),
+  `src/math_tools/precision_time/py.typed`,
+  `src/math_tools/precision_time/precision_time_interval.py`
+- Create: `tests/precision_time/__init__.py`,
+  `tests/precision_time/test_precision_time_interval.py`
+
+## Design constraints
+
+1. Subclass `foundation_abc.math.precisionTimeABC.PrecisionTimeIntervalABC`;
+   enums from `foundation_abc.math.mathEnums`. Use the ABC's
+   `ATTOSECONDS_PER_SECOND`, never a new literal.
+2. Storage: one private signed `int` of total attoseconds (spec
+   §Representation shows the derived accessors — implement exactly that).
+3. Immutable + hashable: no public setters; implement `__hash__` from the
+   total; all arithmetic returns new instances; foreign operand types return
+   `NotImplemented`.
+4. Full surface per spec: constructors (`__init__` ABC-shaped with
+   normalization/carry, `from_seconds`, `from_attoseconds`, `from_string`),
+   constants (`ZERO`, `ONE_SECOND`, `ONE_DECISECOND`, `ONE_MILLISECOND`,
+   `ONE_MICROSECOND`), accessors (`total_attoseconds`, `seconds_as_float`),
+   arithmetic (`+ - neg pos abs`, scalar `* /` rounding to nearest
+   attosecond, interval `/` interval → float), total ordering, `bool`,
+   `to_dict`/`from_dict` on the ABC wire shape, `repr`.
+5. Swift reference for semantics questions:
+   `SWIFT_TYPES/PrecisionTime/PrecisionTimeInterval.swift` (+`+Arithmetic`)
+   — but NO saturation/wrapping ops (spec divergence).
+
+## TDD steps
+
+1. Failing tests covering spec compliance items 2–6 and 10 (interval half)
+   plus hashability and `NotImplemented` fallback (e.g. `interval + 1.0`
+   raises `TypeError`).
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Spec compliance items 2, 3, 4, 5, 6 each have a named test and pass
+- [x] Round-trip with `foundationTypes.mathTypes.MathTypes.PrecisionTimeIntervalType` wire dicts (compliance 1, interval half)
+- [x] `isinstance(x, PrecisionTimeIntervalABC)` and `hash(x)` both work
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+`PrecisionTimestamp` (chunk 05); waveform usage; any datetime interop.
+
+## Resolution notes
+
+- Storage is a single signed `int` (`_total_atto`) on `__slots__`; `seconds`,
+  `attoseconds`, `sign` are all derived properties (single source of truth —
+  the constructor never stores the caller's `sign` verbatim, it re-derives
+  sign from the normalized magnitude so a contradictory input like
+  `sign=NEGATIVE` with zero magnitude can't produce an inconsistent state).
+- Scalar `*`/`/` by `float` round to nearest attosecond via exact
+  `fractions.Fraction` arithmetic (`Fraction(value)` captures the float64
+  value exactly, so no precision is lost beyond what the float already
+  cost) and Python's built-in `round()` (round-half-to-even on `Fraction`)
+  — pinned test cases use binary-exact scalars (`2.5`, `2.0`) so the
+  half-to-even tie-break is deterministic and spelled out in the test.
+  `int` scalar mult/div stays exact (no `Fraction` needed).
+  `from_seconds(float)` uses the same `Fraction` approach.
+  `from_string` raises `ValueError` (not truncate, unlike the Swift
+  `secondsString:attosecondsString:` initializer) per the spec's explicit
+  "ValueError if >18 digits or non-numeric" — the lossless behavior is
+  Swift's separate `fractionalString` initializer, ported here as
+  `from_string`.
+  `__add__`/`__sub__`/`__lt__`/`__le__`/`__gt__`/`__ge__`/`__mul__`/
+  `__rmul__` are typed to their real operand types (not bare `object`) so
+  misuse is a static mypy error, matching the existing `Quaternion` idiom;
+  `__eq__` stays typed `object` (narrowing it would violate the `object`
+  override-compatibility check mypy enforces for `__eq__`/`__ne__`).
+  `__truediv__` uses `@overload` (`PrecisionTimeInterval -> float`,
+  `int | float -> PrecisionTimeInterval`) to type both return shapes
+  precisely.
+- **Session interruption**: this chunk was executed in two passes across a
+  session boundary. Pass 1 wrote the implementation, tests, and reasoned
+  through every test case by hand (a transient outage in the harness's Bash
+  safety classifier blocked running the gate directly). Pass 2 (this
+  resumption) found `make uv-lint` failing with 27 ruff errors — 26 UP037
+  ("remove quotes from type annotation," since `from __future__ import
+  annotations` makes the quoted forward-refs on `PrecisionTimeInterval`
+  redundant) and 1 B015 ("pointless comparison" on the bare
+  `interval < 1.0` statement inside `assertRaises(TypeError)`). Fixed via
+  `ruff check --fix --unsafe-fixes` for the 26 UP037s, and by assigning the
+  comparison to `_` (`_ = interval < 1.0  # type: ignore[operator]`) for the
+  B015 — preserves the test's intent (still executes the comparison,
+  mypy still flags the deliberate misuse, `assertRaises` still catches the
+  resulting `TypeError`). A separate mypy `[type-arg]` error (bare `dict`
+  in a test helper's signature) surfaced only under the full gate and was
+  fixed by annotating `dict[str, Any]`. `make uv-fullCheck` is green: ruff
+  clean, mypy strict clean (20 source files), 178 tests passed (71 new).
+- No files were touched outside this chunk's file list.
diff --git a/.claude/archive/math-tools-port/05-precision-timestamp.md b/.claude/archive/math-tools-port/05-precision-timestamp.md
new file mode 100644
index 0000000..76a0ba2
--- /dev/null
+++ b/.claude/archive/math-tools-port/05-precision-timestamp.md
@@ -0,0 +1,84 @@
+---
+chunk: 05-precision-timestamp
+track: B
+status: complete
+depends_on: [04]
+spec: ../specs/precisionTimeMath.md §PrecisionTimestamp, §Compliance 1, 7–10
+last_updated: 2026-07-13
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 05 — `PrecisionTimestamp`
+
+**Deliverable:** the attosecond-exact epoch-referenced timestamp with
+metadata-validated comparison.
+
+## Files
+
+- Create: `src/math_tools/precision_time/precision_timestamp.py`
+- Edit: `src/math_tools/precision_time/__init__.py` (add export)
+- Create: `tests/precision_time/test_precision_timestamp.py`
+
+## Design constraints
+
+1. Subclass `PrecisionTimestampABC`; composes a `PrecisionTimeInterval`
+   offset plus `timescale`/`reference_frame`/`uncertainty` (all optional,
+   `None` default). Immutable + hashable (metadata included in hash/eq).
+2. Full surface per spec: constructors (`__init__`, `from_interval`,
+   `from_datetime` — tz-aware required, `ValueError` on naive —, `now`,
+   `from_days`, `EPOCH`), accessors (`interval`, `days_since_epoch`,
+   `seconds_of_day`, `as_datetime` UTC lossy-to-µs), arithmetic
+   (`ts ± interval`, `interval + ts`, `ts - ts → interval`), ordering
+   (offsets only), `==` (includes metadata).
+3. `can_compare` / `compare_validated` semantics EXACTLY per spec (verified
+   against `SWIFT_TYPES/PrecisionTime/Extensions/PrecisionTimestamp+Comparable.swift`):
+   `can_compare` = both-specified timescale/frame equality only;
+   `compare_validated` additionally raises `TimestampComparisonError`
+   (from `math_tools.errors`) on uncertainty overlap when BOTH carry
+   uncertainty and `|delta| <= u1 + u2` (boundary equality raises).
+4. Metadata propagation on `ts ± interval`: carried from the timestamp.
+
+## TDD steps
+
+1. Failing tests: spec compliance 7 (cross-epoch subtraction exact), 8 (all
+   `compare_validated` branches incl. the `delta == combined` boundary and
+   the None-metadata compatibility rules), 9 (datetime round-trip incl.
+   pre-epoch), plus hash/eq-with-metadata.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Spec compliance items 7, 8, 9 each have named tests and pass
+- [x] Round-trip with `PrecisionTimestampType` wire dicts (camelCase optional keys)
+- [x] `isinstance` of the ABC; `EPOCH.is_epoch` is True
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Waveform usage; timezone conversion beyond UTC; leap-second/timescale math
+(metadata is carried, never interpreted).
+
+## Resolution notes
+
+- Storage: `PrecisionTimestamp` composes a `PrecisionTimeInterval` (offset
+  from Unix epoch) plus the three optional metadata fields, mirroring the
+  Swift `PrecisionTimestamp` struct's delegation to its `interval` for all
+  comparison/arithmetic.
+- `from_datetime`/`as_datetime` use exact integer microsecond arithmetic
+  (`datetime` subtraction/addition, never `timestamp()`/float math) so the
+  round-trip is exact to the microsecond rather than merely "close" —
+  stricter than the spec's minimum bar but costs nothing and removes a
+  float-precision failure mode for far-future/far-past dates.
+- `compare_validated`/`can_compare` ported directly from
+  `PrecisionTimestamp+Comparable.swift`: timescale/frame checks first (both
+  sides must specify and differ to fail), then uncertainty overlap
+  (`delta <= combined`, so boundary equality raises), matching Swift's
+  `Result` semantics via a raised `TimestampComparisonError`.
+- Added a defensive `ValueError` on negative `uncertainty` in `__init__`
+  (not explicitly required by the spec text, but consistent with the
+  existing unsigned-magnitude validation pattern on `PrecisionTimeInterval`
+  and cheap to add); flagging here per stay-in-scope discipline rather than
+  silently expanding the contract.
+- No spec changes were needed; the implementation matched the spec as
+  written.
diff --git a/.claude/archive/math-tools-port/06-position.md b/.claude/archive/math-tools-port/06-position.md
new file mode 100644
index 0000000..367e301
--- /dev/null
+++ b/.claude/archive/math-tools-port/06-position.md
@@ -0,0 +1,89 @@
+---
+chunk: 06-position
+track: B
+status: complete
+depends_on: [02]
+spec: ../specs/spatialMath.md §Cross-cutting conventions, §Position, §Compliance 1–3, 10
+last_updated: 2026-07-13
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 06 — `Position`
+
+**Deliverable:** the numpy-backed 3D position type.
+
+## Files
+
+- Create: `src/math_tools/spatial/position.py`
+- Edit: `src/math_tools/spatial/__init__.py` (export `Position` alongside
+  the existing `Quaternion`)
+- Create: `tests/spatial/__init__.py`, `tests/spatial/test_position.py`
+
+## Design constraints
+
+1. Subclass `foundation_abc.math.spatialABCs.PositionABC`. Storage: private
+   `(3,)` float64 ndarray; `x/y/z` are settable properties into it.
+2. Full surface per spec §Position: constructors (`__init__(x, y, z)`,
+   `from_vector(ArrayLike)`, `from_components(x, y, z)` scalars,
+   `from_cylindrical`, `from_spherical`, `from_spherical_iso`,
+   `origin/unit_x/unit_y/unit_z`, `from_dict`), NamedTuple inverse
+   accessors (`cylindrical`, `spherical`, `spherical_iso`), operators
+   (`+ - * /` with scalar broadcast both orders, in-place, unary),
+   `dot`/`cross`/`distance`/`distance_squared`,
+   `magnitude`/`magnitude_squared`/`norm`/`__abs__`/`is_unit`,
+   `normalize()`/`normalized()` (`ValueError` on zero vector),
+   `==`/`isclose(rtol, atol)`/`repr`/`to_dict`, `__array__`,
+   `__hash__ = None`.
+3. Coordinate conventions per spec §Coordinate conventions — the two
+   spherical variants are distinct; reuse the ISO docstring language from
+   `math_tools/spherical/spherical_generators.py` by reference, not copy.
+4. Style-match the incumbent `spatial/quaternion.py` (dataclass-flavored,
+   docstrings, classmethod constructors).
+
+## TDD steps
+
+1. Failing tests: coordinate init/accessor inverse grids (compliance 2),
+   `unit_x × unit_y == unit_z` (compliance 3), operator algebra, zero-vector
+   normalize `ValueError`, `__hash__ is None`, `np.asarray(p)` shape.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Round-trip with `foundationTypes` `PositionType` wire dicts (compliance 1)
+- [x] Both spherical conventions inverse-tested over a radius/angle grid, atol 1e-12
+- [x] `hash` raises `TypeError`; `np.asarray(p)` returns the `(3,)` vector
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+`SpatialPose` (08); Quaternion changes (07); any use in waveforms.
+
+## Resolution notes
+
+- `spatial/__init__.py` was empty (0 bytes) before this chunk — `Quaternion`
+  was never exported there (tests import it directly from
+  `math_tools.spatial.quaternion`). "Export `Position` alongside the existing
+  `Quaternion`" was read as: populate `__init__.py` with both, since that's
+  the first time the package `__init__` gets real content.
+- Inverse-coordinate `NamedTuple`s are named `CylindricalCoordinates`,
+  `SphericalCoordinates`, `SphericalIsoCoordinates` (module-level in
+  `position.py`) — the spec only names the properties, not the tuple types.
+- `distance`/`distance_squared` use parameter name `to` (matching the Swift
+  `distance(to:)` label and the spec's literal `distance(to)` signature)
+  rather than `other`.
+- `__array__` implements the newer NEP 51 two-arg signature
+  (`dtype`, `copy`) for numpy 2.x compatibility (installed: numpy 2.5.1) and
+  always returns a defensive copy regardless of the `copy` argument, to keep
+  the private `_vector` unaliased — same rationale as the `vector` property.
+- Division is scalar-only, forward direction only (`position / scalar`); per
+  spec, only `*` gets both left/right scalar orders, `/` does not get an
+  `__rtruediv__`. Confirmed by literal spec wording and the Swift source
+  (`Position+Arithmetic.swift` has no `Double / Position` overload).
+- `normalize()`/`normalized()` raise `ValueError` on the zero vector — this is
+  a deliberate, spec-pinned deviation from the Swift source, which silently
+  zeroes the vector instead of raising. No spec change needed; the chunk's
+  design constraints already called this out explicitly.
+- No `errors.py` changes: `ValueError`/`TypeError` (stdlib) fully cover this
+  chunk's failure modes per `mathToolsArchitecture.md` §Error semantics; no
+  new `MathToolsError` subtype was warranted.
diff --git a/.claude/archive/math-tools-port/07-quaternion-additions.md b/.claude/archive/math-tools-port/07-quaternion-additions.md
new file mode 100644
index 0000000..9427bcb
--- /dev/null
+++ b/.claude/archive/math-tools-port/07-quaternion-additions.md
@@ -0,0 +1,84 @@
+---
+chunk: 07-quaternion-additions
+track: B
+status: complete
+depends_on: [06]
+spec: ../specs/spatialMath.md §Quaternion additions, §Cross-cutting conventions
+last_updated: 2026-07-13
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 07 — `Quaternion` additions
+
+**Deliverable:** the five spec'd additions to the existing class — nothing
+else changes.
+
+## Files
+
+- Edit: `src/math_tools/spatial/quaternion.py`
+- Create: `tests/spatial/test_quaternion_additions.py` (existing
+  `tests/test_quaternion.py` is untouched)
+
+## Design constraints
+
+Per spec §Quaternion additions, add exactly:
+
+1. `dot(other: Quaternion) -> float` — 4-component dot.
+2. `rotation_matrix_elements` property → new frozen dataclass
+   `RotationMatrixElements` (fields `xx…zz`, float) defined in the same
+   module, derived by delegating to the existing `to_rotation_matrix()`
+   (single source — do not re-derive from components).
+3. `rotate_position(p: Position) -> Position` — wraps the existing
+   `rotate_vector`; import `Position` from `.position`.
+4. `__array__(dtype=None)` → `[w, x, y, z]` float64.
+5. Aliases `from_numpy_quaternion` / `to_unit_spherical_small_circle`
+   delegating to the camelCase originals; originals get a "deprecated
+   spelling" docstring line, no removal, no warning machinery.
+
+Existing behavior is authoritative — if a change to an existing method seems
+needed, STOP and report instead.
+
+## TDD steps
+
+1. Failing tests: `dot` (orthogonal → 0, self → norm²),
+   `rotation_matrix_elements` equals `to_rotation_matrix()` entries,
+   `rotate_position` matches `rotate_vector` on the same input,
+   `np.asarray(q)` order `[w,x,y,z]`, aliases are the same functions.
+2. Implement. 3. `make uv-fullCheck` green (all ~90 legacy tests still pass).
+
+## Acceptance criteria
+
+- [x] Diff to `quaternion.py` is additive only (no modified existing lines except imports)
+- [x] Legacy `tests/test_quaternion.py` passes unmodified in this chunk
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Renaming/refactoring existing members; `SpatialPose`; double-cover changes.
+
+## Resolution notes
+
+- Implemented all five spec'd additions: `dot`, `rotation_matrix_elements`
+  (+ new frozen `RotationMatrixElements` dataclass), `rotate_position`,
+  `__array__`, and the `from_numpy_quaternion` / `to_unit_spherical_small_circle`
+  aliases.
+- Aliases are implemented as class-body assignment (`from_numpy_quaternion =
+  fromNumpyQuaternion`, `to_unit_spherical_small_circle =
+  to_unitSphericalSmallCircle`) so both names reference the exact same
+  underlying function object (`is` identity), rather than thin delegating
+  wrappers — simpler and satisfies "delegating to the camelCase originals"
+  literally.
+- One line beyond pure addition: the pre-existing empty docstring `""" """`
+  on `to_unitSphericalSmallCircle` was replaced with the "deprecated
+  spelling" note the spec explicitly requires for both camelCase originals
+  (§Quaternion additions item 5); `fromNumpyQuaternion` had no docstring
+  before, so its note is a pure addition. No other existing line was
+  touched besides the new `import numpy.typing as npt` and
+  `from math_tools.spatial.position import Position` import lines.
+- `rotate_position` and the new `Position` import introduce a
+  `quaternion.py -> position.py` dependency within `spatial/`; `position.py`
+  has no reverse import, so no cycle.
+- Verified: 13 new tests in `tests/spatial/test_quaternion_additions.py`
+  pass; all ~90 legacy tests in `tests/test_quaternion.py` pass unmodified;
+  full suite (336 tests) green; ruff and mypy strict clean.
diff --git a/.claude/archive/math-tools-port/08-spatial-pose.md b/.claude/archive/math-tools-port/08-spatial-pose.md
new file mode 100644
index 0000000..ed3f23e
--- /dev/null
+++ b/.claude/archive/math-tools-port/08-spatial-pose.md
@@ -0,0 +1,98 @@
+---
+chunk: 08-spatial-pose
+track: B
+status: complete
+depends_on: [07]
+spec: ../specs/spatialMath.md §SpatialPose, §Compliance 4–8
+last_updated: 2026-07-13
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 08 — `SpatialPose`
+
+**Deliverable:** the SE(3) pose type composing `Position` + `Quaternion`.
+
+## Files
+
+- Create: `src/math_tools/spatial/spatial_pose.py`
+- Edit: `src/math_tools/spatial/__init__.py` (export)
+- Create: `tests/spatial/test_spatial_pose.py`
+
+## Design constraints
+
+1. Subclass `foundation_abc.math.spatialABCs.SpatialTransformABC` — the
+   ABC's rotation accessor name is `orientation` (not `quaternion`).
+2. Full surface per spec §SpatialPose: constructors (`__init__(position,
+   orientation)` with identity defaults, `from_components(x,y,z,qw,qx,qy,qz)`
+   w-first, `from_homogeneous((4,4))` with rigid-bottom-row `ValueError`,
+   `from_denavit_hartenberg(a, alpha, d, theta)`, `identity()`, `from_dict`),
+   passthrough properties, `homogeneous` (orientation normalized on export),
+   operators (`pose * pose` composition, `pose * position` = full SE(3)
+   apply = `transform(p)`), `translated(by)`, `inverse`,
+   `relative_pose(to)`, `interpolate(to, t)` (lerp + existing `slerp`,
+   unclamped t), `position_distance(_squared)`, `angular_distance`
+   (double-cover safe via `|dot|`), `normalize()`/`normalized()`,
+   `==`/`isclose`/`repr`/`to_dict`, `__hash__ = None`.
+3. Composition recipe (pin exact form):
+   `(a * b).position == a.position + a.orientation.rotate_position(b.position)`,
+   `(a * b).orientation == a.orientation * b.orientation`.
+4. DH reference: `SWIFT_MATH/Spatial/Constructors/SpatialPose+DenavitHartenberg.swift`
+   (standard DH matrix; the precomputed-cos/sin overload collapses into the
+   one Python signature).
+
+## TDD steps
+
+1. Failing tests: spec compliance 4 (two published DH sets — use a 2-link
+   planar arm: `a1=a2=1, alpha=d=0`, θ=(90°, 0°) → end effector (0, 2, 0)
+   via chained poses, plus one non-planar set with alpha≠0 computed by hand
+   in the test comment), 5 (composition algebra), 6 (interpolate endpoints +
+   half-angle midpoint), 7 (`angular_distance(q, -q) == 0`), 8 (homogeneous
+   round-trip incl. non-normalized input).
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Spec compliance items 4–8 each have named tests and pass
+- [x] Round-trip with `foundationTypes` `SpatialTransformType` wire dicts
+- [x] `pose * position` equals `transform(position)` exactly
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Waveform containers; velocity/twist (se(3)) math; ROS/URDF interop.
+
+## Resolution notes
+
+- `SpatialPose` composes a copied `Position` (mutable, so copied on
+  construction to prevent aliasing) and an aliased `Quaternion` (immutable,
+  safe to alias) per the ABC's `position`/`orientation` accessor names.
+- `*` is deliberately the only operator ported from Swift's pose algebra:
+  `pose * pose` composes, `pose * position` applies the full transform
+  (identical to `transform()`). Swift's `pose ± position` were intentionally
+  not ported (silent rotation-dropping footgun); `translated()` is the named
+  replacement.
+- Composition recipe pinned exactly per the spec:
+  `(a * b).position == a.position + a.orientation.rotate_position(b.position)`,
+  `(a * b).orientation == a.orientation * b.orientation`.
+- `homogeneous` always normalizes the orientation on export (Swift parity),
+  even when the stored orientation isn't currently unit; verified live with
+  a non-normalized `Quaternion.from_components(2,0,0,0)` round-tripping
+  through `from_homogeneous` to a unit orientation.
+- `angular_distance` uses `|dot|` for double-cover safety; verified live
+  that `angular_distance(pose_with_q, pose_with_-q)` is ~0 (float noise,
+  not exactly 0, consistent with floating-point rotation composition).
+- DH: verified the two-link planar arm (`a1=a2=1, alpha=d=0`,
+  `theta=(90°, 0°)`) chains to end-effector `(0, 2, 0)` within float
+  tolerance; `to_dict`/`from_dict` round-trip verified against
+  `foundationTypes.mathTypes.MathTypes.SpatialTransformType`.
+- One lint fix during review: `from_homogeneous`'s `ValueError` message
+  exceeded the 100-char line limit; wrapped across two string literals with
+  no change in message content.
+- No spec changes were needed — the implementation matches
+  `spatialMath.md` §SpatialPose as written.
+- Note: this chunk's implementation/tests were originally drafted in an
+  earlier session pass that was interrupted before the gate was run to
+  green; this pass fixed the one outstanding lint error, independently
+  re-verified every acceptance criterion against the running code, and
+  confirmed no other chunk's files were touched.
diff --git a/.claude/archive/math-tools-port/09-univariate-polynomial.md b/.claude/archive/math-tools-port/09-univariate-polynomial.md
new file mode 100644
index 0000000..e139be9
--- /dev/null
+++ b/.claude/archive/math-tools-port/09-univariate-polynomial.md
@@ -0,0 +1,106 @@
+---
+chunk: 09-univariate-polynomial
+track: B
+status: complete
+depends_on: [02]
+spec: ../specs/polynomials.md §UnivariatePolynomial, §Compliance 1, 7
+last_updated: 2026-07-13
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 09 — `UnivariatePolynomial`
+
+**Deliverable:** the numpy-backed general polynomial class.
+
+## Files
+
+- Create: `src/math_tools/functional/__init__.py` (export),
+  `src/math_tools/functional/py.typed`,
+  `src/math_tools/functional/polynomial.py`
+- Create: `tests/functional/__init__.py`,
+  `tests/functional/test_polynomial.py`
+
+## Design constraints
+
+1. One immutable class per spec: ascending-degree `coefficients`
+   (float64 ndarray, trailing zeros trimmed), `degree`, `coefficient_at`,
+   `__call__` (scalar and array via
+   `numpy.polynomial.polynomial.polyval`), `derivative`,
+   `integrate(constant=0.0)`, `real_roots(tolerance=...)` (companion-matrix,
+   imag-filtered, sorted ascending; zero polynomial →
+   `PolynomialSolveError` from `math_tools.errors`; nonzero constant → `[]`),
+   `==`, human-readable `repr`.
+2. `real_roots` returns ALL real roots — the deliberate contrast with the
+   OTG kernel (chunk 10) is stated in both docstrings.
+3. Tolerance default is `POLYNOMIAL_ZERO_THRESHOLD`; import it from
+   `math_tools.functional.roots` if chunk 10 has landed, else define the
+   module constant here and chunk 10 re-homes it (note which happened).
+
+## TDD steps
+
+1. Failing tests: spec compliance 1 (`[−1, 0, 1]` → roots `[−1, 1]`,
+   derivative/integrate round-trip, vector `__call__` vs Horner), trimming
+   (`degree([1, 0, 0]) == 0`), zero-poly raise, repr shape, immutability.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Compliance item 1 tests pass; multiplicity case (e.g. `(x−1)²`) returns the duplicated root
+- [x] Zero polynomial raises `PolynomialSolveError`
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+The analytic root kernel (chunk 10); polynomial arithmetic between
+polynomials (not in spec); fitting.
+
+## Resolution notes
+
+- `POLYNOMIAL_ZERO_THRESHOLD` is defined in `functional/polynomial.py`
+  (chunk 10 / `functional/roots.py` had not landed at execution time). The
+  module docstring and the constant's own docstring both note that chunk 10
+  will re-home it and that this module should then import it from there
+  instead of defining it — per design constraint 3.
+- `real_roots` uses `np.roots` on the descending-order coefficients
+  (`coefficients[::-1]`), filters by `abs(root.imag) <= tolerance`, and
+  returns `sorted(...)` ascending; the zero-polynomial case
+  (`degree == 0 and coefficients[0] == 0.0`) raises `PolynomialSolveError`
+  before ever calling `np.roots`; nonzero-constant (`degree == 0`, nonzero)
+  returns `[]` without calling `np.roots`.
+- `__call__` normalizes `x` via `np.asarray(x, dtype=np.float64)` before
+  calling `numpy.polynomial.polynomial.polyval`, then branches on
+  `arr.ndim == 0` to return a plain `float` for scalar input vs. an
+  `npt.NDArray[np.float64]` for array input — this was required to satisfy
+  mypy strict against numpy's `_FuncVal` overload set (a bare
+  `float | ArrayLike` union does not resolve cleanly against
+  `numpy.polynomial.polynomial.polyval`'s overloads).
+- `__init__` accepts `Sequence[float] | npt.NDArray[np.floating[Any]]`
+  (rather than `Sequence[float]` alone, as sketched in the design
+  constraints) because `derivative`/`integrate` construct new instances
+  directly from `numpy.polynomial.polynomial.polyder`/`polyint` output,
+  whose mypy-inferred dtype is `floating[Any]`, not concretely `float64`.
+  Storage itself is still always coerced/copied to `float64` internally, so
+  behavior is unaffected — this is a type-signature widening only, not a
+  spec/contract change.
+- Immutability: `__slots__ = ("_coefficients",)`, no property setters; the
+  `coefficients` property and the constructor both copy the array
+  (`np.array(..., dtype=np.float64)` / `np.asarray(...)` followed by
+  trimming into a fresh array) so neither construction-time aliasing nor
+  post-hoc mutation of a returned array can affect internal state.
+  `__hash__ = None` per the repo-wide mutable/immutable numpy-backed idiom
+  (documented as "only the immutable precision-time types are hashable" in
+  the umbrella spec, but every existing numpy-backed class sets
+  `__hash__ = None` regardless of the class's own immutability, so this
+  class follows the same idiom rather than special-casing itself as
+  hashable).
+- `repr` follows the spec's literal example format (`"3.0·x² − 1.0"`) —
+  bare expression text, no `UnivariatePolynomial(...)` wrapper — using the
+  Unicode minus sign `−` (U+2212, not ASCII hyphen) and Unicode superscript
+  digits for degree ≥ 2. Pinned by five new tests (constant, linear,
+  two-term, negative-leading-term, zero-polynomial).
+- No spec change was needed; implementation matches `polynomials.md`
+  §UnivariatePolynomial as written.
+- Verified: 38 new tests in `tests/functional/test_polynomial.py`, full
+  suite 418 tests green, ruff clean, mypy strict clean
+  (`make uv-fullCheck`).
diff --git a/.claude/archive/math-tools-port/10-roots-kernel.md b/.claude/archive/math-tools-port/10-roots-kernel.md
new file mode 100644
index 0000000..0a963c6
--- /dev/null
+++ b/.claude/archive/math-tools-port/10-roots-kernel.md
@@ -0,0 +1,128 @@
+---
+chunk: 10-roots-kernel
+track: B
+status: complete
+depends_on: [02]
+spec: ../specs/polynomials.md §functional/roots.py, §Compliance 2–6
+last_updated: 2026-07-14
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 10 — Analytic root kernel (faithful port)
+
+**Deliverable:** `functional/roots.py` — the OTG numeric substrate. This is
+a FAITHFUL port of `SWIFT_MATH/Functional/Roots.swift` + `Utils.swift`:
+translate the algorithms line-by-line; do not substitute numpy/closed-form
+"improvements".
+
+## Files
+
+- Create: `src/math_tools/functional/roots.py`
+- Edit: `src/math_tools/functional/__init__.py` (export the public names)
+- Create: `tests/functional/test_roots.py`
+
+## Design constraints
+
+1. Exact surface per spec §functional/roots.py: constants
+   (`EPS16 = 16 * sys.float_info.epsilon` — NOT 1e-16 —,
+   `POLYNOMIAL_TOLERANCE = 1e-14`, `POLYNOMIAL_ZERO_THRESHOLD = 1e-9`),
+   `solve_cubic`, `solve_resolvent -> (roots, real_root_count)`,
+   `solve_quartic_monic(a, b, c, d)`, `evaluate_polynomial`,
+   `polynomial_derivative`, `polynomial_monic_derivative`,
+   `shrink_interval`, `integrate_jerk`.
+2. **Non-negative-only filtering** (Swift `insertIfPositive`, `val >= 0`)
+   is load-bearing: preserve it, and document it in the module + function
+   docstrings ("OTG time-domain kernel; NOT a general root finder — see
+   UnivariatePolynomial.real_roots").
+3. In the quartic, consult `solve_resolvent`'s real-root count before
+   reading slots 1–2 (the 1-real-root case stores an imaginary part in
+   slot 2 — Swift `Roots.swift:234` guard).
+4. Imports: `math` + `sys` + stdlib ONLY (numpy allowed in tests only).
+5. If chunk 09 defined `POLYNOMIAL_ZERO_THRESHOLD` locally, re-home it here
+   and update 09's import.
+
+## TDD steps
+
+1. Failing tests per spec compliance 2a (≥15 literal hand-computed vectors —
+   include: 3 distinct positive roots; mixed-sign roots pinning the filter
+   drops negatives; repeated root; complex pair; `a≈0` cubic→quadratic
+   fallback; all-negative → `[]`), 2b (seeded random coefficients vs the
+   non-negative real subset of `np.roots`, atol 1e-8), 3 (`shrink_interval`
+   quintic bracket), 4 (`integrate_jerk` analytic), 5 (`EPS16` value pin).
+2. Translate the Swift, function by function. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Compliance items 2a, 2b, 3, 4, 5 pass
+- [x] `grep -E "import (numpy|scipy)" src/math_tools/functional/roots.py` → no hits (compliance 6)
+- [x] `solve_resolvent` returns the count; quartic honors it (a test with a 1-real-root resolvent case)
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+OTG modules; `UnivariatePolynomial` changes beyond the constant re-home;
+performance work.
+
+## Resolution notes
+
+- Faithful line-by-line port of `Roots.swift` / `Utils.swift`: `solve_cubic`,
+  `solve_resolvent`, `solve_quartic_monic`, `evaluate_polynomial`,
+  `polynomial_derivative`, `polynomial_monic_derivative`, `shrink_interval`,
+  `integrate_jerk`. `roots.py` imports only `math`, `sys`, and
+  `collections.abc.Sequence` — no numpy/scipy, verified both by grep and by
+  an AST-based test (`TestRootsModuleImportsOnlyStdlib`).
+- **One intentional arithmetic correction, documented inline and in
+  `polynomials.md`:** `solve_cubic`'s `halfq` term is scaled by `inva *
+  invaa` (`1/a³`), not the literal Swift source's `invaa * invaa` (`1/a⁴`,
+  `Roots.swift:70`). The standard depressed-cubic resolvent `R = (2A³ − 9AB
+  + 27C) / 54` scales as `1/a³`; the `1/a⁴` in the Swift source is a latent
+  bug that's inert at both of its call sites because they only ever pass a
+  monic cubic (`a == 1`). It is not inert for general coefficients, and
+  Compliance 2b (randomized non-monic cubics vs. `np.roots`, atol 1e-8)
+  requires the corrected scaling to pass. Verified by hand: `p` matches the
+  standard `B − A²/3` under `1/a²` scaling (unchanged from the Swift
+  source); re-deriving `halfq = (2b³ − 9abc + 27a²d) / (54a³)` from the
+  textbook resolvent confirms `1/a³` is correct. `polynomials.md` §rules for
+  `functional/roots.py` gained a new rule 5 documenting this deviation
+  (`semver` 0.0.2 → 0.0.3).
+- `solve_resolvent`'s 1-real-root case (slot 2 holds an imaginary-part
+  scratch value, not a root) is explicitly guarded in
+  `solve_quartic_monic` (`if number_of_zeroes != 1`) before slots 1–2 are
+  read, per Swift `Roots.swift:234`; pinned by
+  `TestSolveResolvent.test_one_real_root_case` +
+  `test_complex_pair_and_one_real_resolvent_root`.
+  `EPS16 = 16 * sys.float_info.epsilon` is pinned exactly (not `1e-16`) by
+  `TestConstants.test_eps16_pinned_to_16_times_float_epsilon`.
+- `POLYNOMIAL_ZERO_THRESHOLD` re-homed from `polynomial.py` (chunk 09) into
+  `roots.py` per design constraint 5. `polynomial.py`'s only edit was
+  replacing its local definition with
+  `from math_tools.functional.roots import POLYNOMIAL_ZERO_THRESHOLD as
+  POLYNOMIAL_ZERO_THRESHOLD` — the explicit-reexport idiom, required by
+  strict mypy (`implicit_reexport = False`) since `tests/functional/
+  test_polynomial.py` (chunk 09, out of scope for this chunk) still imports
+  the constant from `polynomial`.
+- Two strict-mypy fixes applied during review, both type-narrowing only, no
+  behavior change: (1) `_cbrt`'s `x ** (1.0 / 3.0)` wrapped in `float(...)`
+  — typeshed's `float.__pow__` returns `Any` because a negative base with a
+  fractional exponent can produce a `complex` at runtime; both call sites in
+  `_cbrt` guarantee a non-negative base, so the cast is safe. (2) the
+  `POLYNOMIAL_ZERO_THRESHOLD` re-export idiom above.
+- `__init__.py` exports the full public surface (`EPS16`,
+  `POLYNOMIAL_TOLERANCE`, `POLYNOMIAL_ZERO_THRESHOLD`, and all eight
+  functions) alongside the existing `UnivariatePolynomial`.
+- Verified live (beyond the test suite): `EPS16` exact value, non-monic
+  random cubics against `np.roots` for `a ∈ {2.0, 0.5, −3.0}`, the
+  1-real-root resolvent guard on both `solve_resolvent` and
+  `solve_quartic_monic`, non-negative-only filtering
+  (`solve_cubic(1,6,11,6) == []`), and `polynomial.POLYNOMIAL_ZERO_THRESHOLD
+  is roots.POLYNOMIAL_ZERO_THRESHOLD` (same object, confirming the re-home).
+- Verified: 60 new tests (39 in `test_roots.py`, `test_polynomial.py`
+  unaffected in count), full suite 457 tests green, ruff clean, mypy strict
+  clean (`make uv-fullCheck`).
+- This chunk's implementation was originally drafted by a Sonnet subagent
+  that hit a session-limit API error mid-task (interrupted while retrying
+  its own test run). This pass independently re-verified every acceptance
+  criterion against the running code, fixed the two outstanding mypy
+  strict-mode errors (`_cbrt`'s `Any` returns, the re-export idiom), and
+  confirmed no file outside this chunk's declared scope was touched.
diff --git a/.claude/archive/math-tools-port/11-waveform1d-core.md b/.claude/archive/math-tools-port/11-waveform1d-core.md
new file mode 100644
index 0000000..d488ac0
--- /dev/null
+++ b/.claude/archive/math-tools-port/11-waveform1d-core.md
@@ -0,0 +1,130 @@
+---
+chunk: 11-waveform1d-core
+track: C
+status: complete
+depends_on: [05]
+spec: ../specs/waveformCore.md §ABC accessor, §Instantiability, §Time axis, §Waveform1D (constructors/statistics/indexing/mutation), §Compliance 1, 3, 5–7, 11
+last_updated: 2026-07-14
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 11 — `Waveform1D` core container
+
+**Deliverable:** the scalar waveform container (no operators, no generators,
+no DSP — those are chunks 12, 13, 18–30).
+
+## Files
+
+- Create: `src/math_tools/waveforms/__init__.py` (export `Waveform1D`),
+  `src/math_tools/waveforms/py.typed`,
+  `src/math_tools/waveforms/waveform1d.py`
+- Create: `tests/waveforms/__init__.py`,
+  `tests/waveforms/test_waveform1d_core.py`
+
+## Design constraints
+
+1. `class Waveform1D(Waveform1dABC)` — base list is EXACTLY this (DSP mixins
+   are composed by chunk 30, not here). Implement the ABC accessor
+   `waveform -> Sequence[float]`; numpy bulk on `values: npt.NDArray`
+   (copy-in on construction; dtype preserved, float64 default).
+2. Time axis per spec: `dt: PrecisionTimeInterval` (strictly positive),
+   `t0: PrecisionTimestamp = EPOCH`; `dt_seconds: float = 1.0` is the
+   default path so `Waveform1D(values)` is legal; `t0_seconds` convenience;
+   `TypeError` when both a precision and a seconds form are given.
+   Computed: `duration` (`dt * (n-1)`, ZERO when n ≤ 1),
+   `duration_seconds`, `sampling_frequency_hz`, `nyquist_frequency_hz`,
+   `sample_count`/`__len__`, `time_axis()`.
+3. Statistics properties (None-on-empty per spec), indexing/slicing
+   (`w[i]`, `w[a:b]` with attosecond-exact t0 shift, step≠1 `ValueError`),
+   `subset_time`, `value_at_index`/`value_at_time` (linear interp,
+   `ValueError` out of range), mutation API (`append`, `append_values`,
+   `prepend`, `prepend_values` with t0 back-shift, `insert`, `replace`,
+   `replace_range`, `pop(i=-1)` → `IndexError` on empty, `clear()`),
+   `==` (samples exact + dt + t0), `__iter__`, `__array__`, `repr`,
+   `to_dict`/`from_dict`.
+4. Pin the population-variance choice: implement `variance` as ddof=0 and
+   pin with a literal expected value (spec compliance 5).
+
+## TDD steps
+
+1. Failing tests for spec compliance 1 (`ScalarWaveformType` round-trip),
+   3 (slice t0 attosecond-exact), 5 (stats literals), 6 (value_at_time
+   midpoint), 7 (mutation semantics), 11 (`Waveform1D(values)` constructs;
+   `__abstractmethods__` empty; `np.asarray`; iteration).
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Named tests for compliance 1, 3, 5, 6, 7, 11 pass
+- [x] `w[2:5].t0 - w.t0 == w.dt * 2` exactly (PrecisionTime equality, not float)
+- [x] Integer-dtype input preserves dtype; float input is float64
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Arithmetic/comparison operators (12), generators (13), DSP (18–30),
+aggregate containers (15–17).
+
+## Resolution notes
+
+- `class Waveform1D(Waveform1dABC)` with no DSP mixin bases; pinned by a
+  test asserting `Waveform1D.__abstractmethods__ == frozenset()` and that a
+  bare `Waveform1D(values)` construction succeeds.
+- Time axis is attosecond-exact throughout: `dt`/`t0` are the Tier-3
+  `PrecisionTimeInterval`/`PrecisionTimestamp` types, not floats. `dt`
+  strictly positive (`ValueError`), `t0` defaults to
+  `PrecisionTimestamp.EPOCH`, `dt_seconds`/`t0_seconds` are the seconds
+  convenience forms, each pair mutually exclusive (`TypeError`). Verified
+  live: `w[2:5].t0 - w.t0 == w.dt * 2` holds via exact
+  `PrecisionTimeInterval` equality (`PrecisionTimeInterval(seconds=2,
+  attoseconds=0, ...)` on both sides), not float comparison.
+- Dtype policy, verified live and by dedicated tests: an ndarray with an
+  explicit integer dtype (e.g. `np.array([1,2,3], dtype=np.int32)`)
+  preserves that exact dtype; a Python list of ints (e.g. `[1, 2, 3]`) is
+  also treated as integer-dtype input (via `np.asarray`'s natural int64
+  inference) and preserved as integer, not upcast; any non-integer input
+  (Python floats, or an explicit float ndarray) becomes float64. This is a
+  literal reading of "integer-dtype input preserves dtype" — the dtype the
+  input resolves to via `np.asarray`, not merely "explicitly-typed numpy
+  arrays" — and is pinned by
+  `test_python_list_of_ints_preserves_integer_dtype`.
+  `counter()`'s output is integer when `start_value`/`increment` are
+  integers, matching this policy.
+  `constant()` similarly does not force a dtype, so `Waveform1D.constant(n,
+  value=5)` yields an integer-dtype waveform (int follows the same rule).
+- All 22 generator classmethods are sample-count (`n`) based, matching this
+  repo's other constructors — a deliberate, documented departure from the
+  Swift duration/samplingRate-based generator API (module docstring + chunk
+  spec explicitly call this a "fresh numpy-idiomatic implementation," not a
+  faithful port).
+- `variance`/`standard_deviation` pinned to population statistics
+  (`ddof=0`, i.e. plain `np.var`/`np.std`); spec compliance 5 requires a
+  literal expected value in the test, not just agreement with a numpy
+  reference — verified live: `Waveform1D([1,2,3,4]).variance == 1.25`
+  exactly.
+- `value_at_time`/`value_at_index` linear interpolation verified live at an
+  exact midpoint (`value_at_time(0.5)` between samples `0.0` and `10.0`
+  spaced 1s apart returns `5.0`).
+- `subset_time` is half-open (`start <= t < end`) via
+  `np.searchsorted(..., side="left")` on both bounds, raising `ValueError`
+  on an empty or invalid (`end <= start`) range.
+- Wire round-trip verified live end-to-end:
+  `Waveform1D.to_dict()`/`.from_dict()` round-trips to an equal instance,
+  and `foundationTypes.mathTypes.MathTypes.ScalarWaveformType.from_dict()`
+  accepts the same dict without error (spec compliance 1).
+- One spec/reality collision flagged by the implementing agent, not a bug:
+  waveformCore.md's Operators section says `__array__` support makes
+  `np.mean(w)` "work," but numpy's `np.mean()` tries `w.mean` as a callable
+  before falling back to `__array__`, and the spec also mandates `mean` as
+  a *property* — so `np.mean(w)` directly raises `TypeError` for this and
+  every other stats-named property (`sum`, etc). `np.asarray(w)` (the form
+  chunk 11's own compliance item 11 actually pins) is unaffected and is the
+  correct interop path. No acceptance criterion here requires bare
+  `np.mean(w)` to work, so no code changed; worth a one-line spec
+  clarification if the DSP chunks (12+) run into the same collision.
+- No spec change was needed; implementation matches waveformCore.md's core
+  (non-aggregate, non-DSP) sections as written.
+- Verified: 91 new tests in `tests/waveforms/test_waveform1d_core.py`, full
+  suite 555 tests green, ruff clean, mypy strict clean
+  (`make uv-fullCheck`).
diff --git a/.claude/archive/math-tools-port/12-waveform1d-operators.md b/.claude/archive/math-tools-port/12-waveform1d-operators.md
new file mode 100644
index 0000000..704571c
--- /dev/null
+++ b/.claude/archive/math-tools-port/12-waveform1d-operators.md
@@ -0,0 +1,97 @@
+---
+chunk: 12-waveform1d-operators
+track: C
+status: complete
+depends_on: [11]
+spec: ../specs/waveformCore.md §Waveform1D Operators, §Compliance 2
+last_updated: 2026-07-14
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 12 — `Waveform1D` operators & comparison
+
+**Deliverable:** the elementwise operator surface.
+
+## Files
+
+- Edit: `src/math_tools/waveforms/waveform1d.py`
+- Create: `tests/waveforms/test_waveform1d_operators.py`
+
+## Design constraints
+
+1. Per spec §Operators: `+ - * / // %` (waveform⊕waveform requires equal
+   `dt` AND length else `WaveformCompatibilityError`; scalar both orders),
+   in-place variants (mutate), bitwise `& | ^ << >> ~` integer-dtype-only
+   (`TypeError` with a clear message otherwise), unary `- + abs`,
+   `elements_equal` / `elements_less_than` / `elements_greater_than`
+   (→ bool ndarray), `isclose_elementwise(other, rtol=1e-9, atol=0.0)`,
+   whole-object `isclose(other, rtol, atol)`.
+2. Results carry `dt`/`t0` from the left operand; binary op result dtype
+   follows numpy promotion.
+3. Foreign types → `NotImplemented` (so `np.float64 + w` behaves).
+
+## TDD steps
+
+1. Failing tests: dt-mismatch and length-mismatch raise
+   `WaveformCompatibilityError` (spec compliance 2); scalar both orders;
+   in-place mutates in place (identity check); bitwise on float raises
+   `TypeError`; int `%` and `<<`; `isclose_elementwise` tolerance behavior;
+   `isclose` False on differing `t0`.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Compliance item 2 named test passes
+- [x] `(w + 1.0).t0 == w.t0` and `is not w`
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Generators, DSP, aggregate operators (aggregates have none).
+
+## Resolution notes
+
+- Added the full elementwise operator surface: `+ - * / // %` (forward,
+  reflected, in-place — 18 methods), bitwise `& | ^ << >> ~` (integer-dtype
+  only, numpy's own `TypeError` surfaced unwrapped since its message was
+  already clear), unary `- + abs`, and the comparison producers
+  (`elements_equal`, `elements_less_than`, `elements_greater_than`,
+  `isclose_elementwise(rtol, atol)`, whole-waveform `isclose(rtol, atol)`).
+  `Waveform1D op Waveform1D` requires equal `dt` AND length
+  (`WaveformCompatibilityError` otherwise, via a shared
+  `_check_compatible` helper); results carry `dt`/`t0` from the left
+  operand; foreign right-hand types return `NotImplemented`.
+  `WaveformCompatibilityError` extended to the comparison producers too
+  (not just arithmetic), reading spec compliance 2's "any binary ... op"
+  literally — a judgment call, not a deviation.
+- **One real bug found and fixed during review, not by the implementing
+  agent's own tests:** `Waveform1D` defines `__array__`, which makes numpy
+  treat any bare `numpy.float64`/`numpy.ndarray` operand as array-like and
+  handle the operation via its own ufunc machinery — bypassing Python's
+  normal operator protocol entirely, so `w.__radd__` was never called.
+  Concretely, `np.float64(2.0) + w` (and `np.array([...]) * w`) silently
+  returned a bare `ndarray` (samples only, `dt`/`t0` discarded) instead of
+  a `Waveform1D`, even though `2.0 + w` (a plain Python float) worked
+  correctly. This directly contradicted this chunk's own design constraint
+  3, which names `np.float64 + w` as the motivating example for the
+  `NotImplemented` convention. Fixed with the standard idiom for this
+  problem: `__array_ufunc__ = None` on the class, which forces numpy to
+  return `NotImplemented` for any binop against a foreign array/scalar,
+  handing control back to Python's operator protocol (and this class's
+  reflected dunders). Verified live: `np.float64(2.0) + w` now returns a
+  `Waveform1D` with `dt`/`t0` preserved; `np.asarray(w)` (chunk 11's
+  `__array__` contract) is unaffected since it doesn't go through the
+  ufunc path. Added a regression test
+  (`test_numpy_scalar_reflected_add_returns_waveform_not_bare_ndarray`).
+  Plain-`ndarray`-as-operand (e.g. `np.array([1,2,3]) * w`) now correctly
+  raises `TypeError` rather than silently returning a bare array — this is
+  in spec (operands are `Waveform1D | scalar` only, general ndarray
+  broadcasting was never a declared operand kind).
+- Verified live: `(w + 1.0).t0 == w.t0` and `is not w`; dt-mismatch raises
+  `WaveformCompatibilityError` for `+`; foreign-type `w + object()` raises
+  `TypeError`.
+- Verified: 35 tests in `tests/waveforms/test_waveform1d_operators.py`
+  (34 from the implementing agent + 1 regression test added during
+  review), full suite 590 tests green, ruff clean, mypy strict clean
+  (`make uv-fullCheck`).
diff --git a/.claude/archive/math-tools-port/13-waveform1d-generators.md b/.claude/archive/math-tools-port/13-waveform1d-generators.md
new file mode 100644
index 0000000..0204fce
--- /dev/null
+++ b/.claude/archive/math-tools-port/13-waveform1d-generators.md
@@ -0,0 +1,105 @@
+---
+chunk: 13-waveform1d-generators
+track: C
+status: complete
+depends_on: [11]
+spec: ../specs/waveformCore.md §Waveform1D Constructors (generators), §Compliance 4
+last_updated: 2026-07-14
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 13 — `Waveform1D` signal generators
+
+**Deliverable:** the 21 generator classmethods.
+
+## Files
+
+- Edit: `src/math_tools/waveforms/waveform1d.py` (or a
+  `waveforms/_generators.py` helper module the classmethods delegate to, if
+  the class file is getting long — your call, but the public surface is the
+  classmethods)
+- Create: `tests/waveforms/test_waveform1d_generators.py`
+
+## Design constraints
+
+1. Classmethods per spec: `sine`, `cosine`, `square`, `triangle`,
+   `sawtooth`, `chirp`, `exponential_decay`, `exponential_growth`,
+   `polynomial(coefficients)`, `linear_ramp`, `logarithm`, `logarithm10`,
+   `square_root`, `heaviside`, `relu`, `sigmoid`, `white_noise(seed)`,
+   `constant`, `impulse`, `damped_sinusoid`, `counter`, `digital_square`.
+   Common signature prefix `(n: int, *, dt=None, dt_seconds=None, t0=None,
+   t0_seconds=None, ...)` + per-shape params (frequency_hz, amplitude,
+   phase, etc.).
+2. Argument names/meanings follow the Swift reference
+   (`SWIFT_MATH/Waveform1D/Extensions/Waveform1D+Generators.swift`); each
+   body is a numpy one-liner over `time_axis()`.
+3. `white_noise` uses `np.random.default_rng(seed)`; `square`/`sawtooth`/
+   `triangle` may use `scipy.signal` waveforms.
+
+## TDD steps
+
+1. Failing tests (spec compliance 4): `sine` matches `np.sin(2π·f·t)` on the
+   time axis; `white_noise(seed=k)` reproducible and differs for k+1;
+   `impulse` sums to one amplitude; `counter` is `arange`; `chirp`
+   instantaneous frequency endpoints (coarse check via zero-crossing counts
+   in the first/last quarter).
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] All 21+ generators exist with `n`/time-axis prefix signature and pass their shape test
+- [x] `Waveform1D.sine(n=1000)` works with no time args (dt = 1 s)
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+DSP analysis; generator variants Swift doesn't have.
+
+## Resolution notes
+
+- **This chunk's deliverable (the 22 generator classmethods themselves) was
+  already implemented in chunk 11**, not here. The umbrella spec
+  (waveformCore.md §`Waveform1D`) groups the generators under
+  "Constructors" alongside the base `__init__`, and this chunk's own
+  supervising delegation for chunk 11 included the full generator list in
+  that scope by extension (a scope-widening judgment call made at that
+  time, since chunk 11's design constraints didn't name generators
+  explicitly but the spec section it cites does). Rather than
+  re-implementing or duplicating shape-test coverage that already exists
+  and passes in `tests/waveforms/test_waveform1d_core.py::TestGenerators`,
+  this chunk's actual incremental work was: (1) a real bug fix — see below
+  — and (2) the dedicated `tests/waveforms/test_waveform1d_generators.py`
+  file this chunk's "Files" section calls for, scoped to the specific
+  named compliance-4 checks (sine vs. `np.sin`, seeded white-noise
+  reproducibility/divergence, impulse summation, counter as
+  `arange`-based, chirp instantaneous-frequency endpoints via zero-crossing
+  count) plus an all-22-generators existence check — not a duplicate of
+  chunk 11's broader per-generator shape tests.
+- **One real bug found and fixed:** both waveformCore.md's §Time axis
+  section and this chunk's own acceptance criteria literally pin
+  `Waveform1D.sine(n=1000)` as legal with no other arguments (`dt = 1 s`
+  implied). The chunk-11 implementation gave `sine`'s `frequency` parameter
+  no default, so that exact call raised `TypeError: missing 1 required
+  positional argument: 'frequency'`. Fixed by giving `frequency: float =
+  1.0` a default on `sine` only (the one generator the criterion literally
+  names) — not applied blanket-style to the other frequency-taking
+  generators (`cosine`, `square`, `triangle`, `sawtooth`, `chirp`,
+  `digital_square`), since no acceptance criterion pins those, and the
+  Swift reference (`Waveform1D-Generators.swift`) requires `frequency` on
+  all of them with no default, matching this repo's existing choice for
+  those. Verified live: `Waveform1D.sine(n=1000)` now constructs a
+  1000-sample, 1 Hz waveform; regression-covered by
+  `TestSineNoTimeArgs.test_sine_n_only_constructs_with_dt_one_second`.
+- Verified live: `sine` matches `2*np.sin(2*pi*3.0*t)` for
+  `amplitude=2.0, frequency=3.0` exactly (atol 1e-12); `white_noise(seed=7)`
+  reproducible, `seed=8` differs; `impulse` sums to exactly one sample of
+  the given amplitude at the given index; `counter` matches
+  `start + increment * arange(n)`; `chirp` shows more zero-crossings in its
+  last quarter than its first (low-to-high sweep).
+- No spec change was needed; the generators as built (chunk 11 + this
+  chunk's one default-value fix) match waveformCore.md's Constructors
+  section and Compliance 4 as written.
+- Verified: 8 new tests in `tests/waveforms/test_waveform1d_generators.py`,
+  full suite 598 tests green, ruff clean, mypy strict clean
+  (`make uv-fullCheck`).
diff --git a/.claude/archive/math-tools-port/14-dsp-support-and-protocol.md b/.claude/archive/math-tools-port/14-dsp-support-and-protocol.md
new file mode 100644
index 0000000..11447d4
--- /dev/null
+++ b/.claude/archive/math-tools-port/14-dsp-support-and-protocol.md
@@ -0,0 +1,128 @@
+---
+chunk: 14-dsp-support-and-protocol
+track: C
+status: complete
+depends_on: [11]
+spec: ../specs/waveformDsp.md §Support descriptor types, §Organization (protocol), §Compliance 3
+last_updated: 2026-07-14
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 14 — DSP support types + mixin protocol
+
+**Deliverable:** the shared substrate every DSP mixin chunk builds on.
+
+## Files
+
+- Create: `src/math_tools/waveforms/support.py`,
+  `src/math_tools/waveforms/dsp/__init__.py`,
+  `src/math_tools/waveforms/dsp/py.typed`,
+  `src/math_tools/waveforms/dsp/_protocol.py`,
+  `src/math_tools/waveforms/dsp/_common.py`
+- Edit: `src/math_tools/waveforms/__init__.py` (export support types)
+- Create: `tests/waveforms/test_support.py`
+
+## Design constraints
+
+1. `support.py`: ALL enums and descriptor dataclasses listed in the spec
+   §Support descriptor types — string-valued `Enum`s;
+   `@dataclass(frozen=True, slots=True)` with **`eq=False` on every
+   ndarray-bearing descriptor** (`WaveformSpectrum`, `WaveformSpectrogram`,
+   `WaveformMelSpectrogram`, `WaveformInstantaneousFrequency`,
+   `WaveformFilterCoefficients`); scalar-only descriptors keep default eq.
+2. `_protocol.py`:
+
+```python
+class WaveformProtocol(Protocol):
+    @property
+    def values(self) -> npt.NDArray[Any]: ...
+    @property
+    def dt(self) -> PrecisionTimeInterval: ...
+    @property
+    def t0(self) -> PrecisionTimestamp: ...
+    @property
+    def sampling_frequency_hz(self) -> float: ...
+    def _with_values(self, values: npt.NDArray[Any]) -> "Waveform1D": ...
+```
+
+   `_with_values(values)` (same dt/t0, new samples) must be added to
+   `Waveform1D` here — the one edit to `waveform1d.py` this chunk makes.
+   Adjust member names ONLY to match what `Waveform1D` actually exposes.
+3. `_common.py`: `float_seconds(interval) -> float` and any helper two or
+   more mixins would otherwise duplicate; starts minimal.
+
+## TDD steps
+
+1. Failing tests: every enum member exists; frozen mutation raises;
+   ndarray descriptors — construct two equal-content instances, `==`
+   evaluates without raising (compliance 3); `Waveform1D` structurally
+   satisfies `WaveformProtocol` (assign to a protocol-typed variable under
+   mypy + a runtime `isinstance` check via `runtime_checkable`).
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] All spec-listed enums/dataclasses exist; ndarray ones have `eq=False`
+- [x] `Waveform1D._with_values` returns a new instance sharing dt/t0
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Any mixin; composing anything into `Waveform1D`.
+
+## Resolution notes
+
+- `support.py`: all 12 enums (11 from the spec's list + `WaveformTriggerType`,
+  see below) as `str, enum.Enum` with snake_case string values, and all 15
+  frozen dataclasses (`@dataclass(frozen=True, slots=True)`). `eq=False`
+  applied to exactly the 5 ndarray-bearing descriptors the spec names
+  (`WaveformSpectrum`, `WaveformSpectrogram`, `WaveformMelSpectrogram`,
+  `WaveformInstantaneousFrequency`, `WaveformFilterCoefficients`); the
+  remaining 10 scalar-only descriptors keep default `eq=True`, including
+  `WaveformWithEvents` (wraps a `Waveform1D`, whose own `__eq__` already
+  compares arrays safely and returns a plain `bool`, so the
+  dataclass-generated tuple-eq never touches a raw ndarray directly).
+- **`WaveformTriggerType` resolved via the Swift source, as instructed:**
+  the Python spec text references `WaveformTrigger(kind:
+  WaveformTriggerType, ...)` without enumerating that enum's members. The
+  Swift original (`Support/WaveformTriggerType.swift`) is a generic enum
+  with four associated-value cases (`edge`/`level`/`window`/`pattern`,
+  each carrying its own thresholds). Flattened to a plain 4-member string
+  enum (the case names) with the associated payload moved onto
+  `WaveformTrigger`'s optional fields (`level`, `lower`, `upper`,
+  `pattern`, `tolerance`, `minimum_interval`) — consistent with every
+  other "kind" discriminator enum in this module. Documented inline in
+  `support.py`'s module docstring and `WaveformTrigger`'s own docstring.
+- `dsp/_protocol.py`: `WaveformProtocol` (`@runtime_checkable`) declares
+  `values`, `dt`, `t0`, `sampling_frequency_hz`, `_with_values`. One
+  judgment-call deviation from the chunk doc's literal code block:
+  `_with_values` returns `WaveformProtocol` (self-type) rather than a
+  quoted `"Waveform1D"` forward reference, since resolving that forward
+  reference under mypy strict would require importing `Waveform1D` into
+  `_protocol.py` (even under `TYPE_CHECKING`), reintroducing exactly the
+  `dsp/` → `waveforms/waveform1d.py` coupling the Protocol pattern exists
+  to avoid — and future mixins (which only ever need a
+  `WaveformProtocol`-satisfying result) are unaffected either way.
+  `Waveform1D._with_values -> Waveform1D` remains a valid covariant
+  implementation of the protocol method. Verified this doesn't just
+  typecheck but actually holds at runtime:
+  `isinstance(Waveform1D(...), WaveformProtocol)` is `True`.
+- `dsp/_common.py`: only `float_seconds(interval) -> float` (thin wrapper
+  over the existing `PrecisionTimeInterval.seconds_as_float`), per "starts
+  minimal."
+- `waveform1d.py`'s only edit: added `_with_values(self, values) ->
+  Waveform1D`, returning a new instance with the same `dt`/`t0`. Verified
+  live: `w._with_values(new_array) is not w`, and the new instance's `dt`/
+  `t0` equal the original's exactly.
+- No spec change was needed; `WaveformTriggerType`'s flattening is
+  documented in code (module + class docstrings) rather than requiring a
+  spec edit, since the Python spec text never enumerated its members in
+  the first place (no existing spec statement was contradicted).
+- Verified live (beyond the test suite): frozen-dataclass mutation raises
+  `dataclasses.FrozenInstanceError`; `WaveformSpectrum(...) ==
+  WaveformSpectrum(...)` (equal-content, `eq=False`) evaluates to `False`
+  without raising; `isinstance(Waveform1D(...), WaveformProtocol)` is
+  `True`.
+- Verified: 20 new tests in `tests/waveforms/test_support.py`, full suite
+  618 tests green, ruff clean, mypy strict clean (`make uv-fullCheck`).
diff --git a/.claude/archive/math-tools-port/15-waveform-position.md b/.claude/archive/math-tools-port/15-waveform-position.md
new file mode 100644
index 0000000..39fe1da
--- /dev/null
+++ b/.claude/archive/math-tools-port/15-waveform-position.md
@@ -0,0 +1,96 @@
+---
+chunk: 15-waveform-position
+track: C
+status: complete
+depends_on: [11, 06]
+spec: ../specs/waveformCore.md §ABC accessor, §Aggregate containers, §Compliance 1, 2, 8, 10
+last_updated: 2026-07-23
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 15 — `WaveformPosition`
+
+**Deliverable:** the position time-series container.
+
+## Files
+
+- Create: `src/math_tools/waveforms/waveform_position.py`
+- Edit: `src/math_tools/waveforms/__init__.py` (export)
+- Create: `tests/waveforms/test_waveform_position.py`
+
+## Design constraints
+
+1. Subclass `PositionWaveformABC`. Storage `(n, 3)` float64
+   `positions_array`; ABC accessor `positions -> Sequence[PositionABC]`
+   materializes `Position` objects on access. Time axis identical to
+   `Waveform1D` (same shared behavior — extract a private helper/mixin from
+   `waveform1d.py` ONLY if it avoids real duplication; copying the ~6 small
+   time properties is acceptable).
+2. Per spec §Aggregate containers with `Element = Position`: constructors
+   (element list, `from_components(x, y, z)` from `Waveform1D`s with
+   count/dt `ValueError`), element access (`w[i]`, `w[a:b]`, `get(i)`,
+   `__iter__`), `component_waveforms -> NamedTuple(x, y, z)`,
+   `are_all_unit`, `normalize()`/`normalized()` (`ValueError` on
+   zero-magnitude element), mutation verbs with `Position` payloads,
+   `extend`/`concatenate` (`WaveformCompatibilityError` on dt mismatch),
+   `==`/`repr`/`to_dict`/`from_dict`.
+3. Bulk paths (normalize, component split) are vectorized over
+   `positions_array` — never loop over materialized `Position`s
+   (spec compliance 10).
+
+## TDD steps
+
+1. Failing tests: `PositionWaveformType` wire round-trip (compliance 1);
+   dt-mismatch raises (2); `component_waveforms` → `from_components`
+   round-trip (8); slice materialization; normalize on a zero row raises.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Compliance 1, 2, 8 named tests pass
+- [x] `w[i]` returns a `Position` equal to the stored row
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Quaternion/pose containers (16, 17); DSP on components.
+
+## Resolution notes
+
+- `WaveformPosition(PositionWaveformABC)`: `(n, 3)` float64 storage in
+  `_positions`; `positions_array` bulk accessor (copied on read); the
+  ABC-required `positions` accessor materializes a fresh `Position` list
+  on each access, while `normalize`/`normalized`/`component_waveforms`
+  stay fully vectorized over `_positions` and never construct per-element
+  objects internally (compliance 10).
+- Time-axis properties (`dt`, `t0`, `duration(_seconds)`,
+  `sampling_frequency_hz`, `nyquist_frequency_hz`, `sample_count`/
+  `__len__`, `time_axis()`) are copied from `Waveform1D`'s implementation
+  rather than shared via a base class, per this chunk's own explicit
+  "copying the ~6 small time properties is acceptable" constraint — a
+  premature shared base was correctly avoided.
+- `from_components(x, y, z)` validates length and `dt` equality (raising
+  `ValueError` on either mismatch, replacing Swift's optional-returning
+  `init?`); `t0` is taken from `x` alone (not cross-checked), which is
+  sufficient for an exact round-trip since `component_waveforms` always
+  produces `x`/`y`/`z` sharing the source waveform's own `t0`.
+  `extend`/`concatenate` compat-check only `dt` (not length) since these
+  are concatenation ops, matching the spec's literal "dt mismatch" wording
+  (contrast with `Waveform1D`'s elementwise operators, which check both).
+- `are_all_unit` uses the same `atol=1e-12` tolerance as `Position.is_unit`,
+  for parity with the non-waveform type. The zero-magnitude `ValueError` in
+  `normalize()` does NOT use that tolerance — it is an exact `norms == 0.0`
+  check, matching `Position.normalize()`'s own exact `magnitude == 0.0`
+  check (corrected 2026-07-23: this note previously and incorrectly claimed
+  `atol=1e-12` applied there too).
+- Verified live: `w[i]` returns a `Position` equal to the stored row;
+  `to_dict()`/`from_dict()` round-trips to an equal instance, and
+  `foundationTypes.mathTypes.MathTypes.PositionWaveformType.from_dict()`
+  accepts the same dict without error (compliance 1).
+- No spec change was needed; implementation matches waveformCore.md's
+  §Aggregate containers section (Element = Position) as written.
+- Verified: 66 new tests in `tests/waveforms/test_waveform_position.py`
+  (including two 100,000-sample compliance-10 smoke tests for `normalize`
+  and `component_waveforms`, each asserted under 5s), full suite 684 tests
+  green, ruff clean, mypy strict clean (`make uv-fullCheck`).
diff --git a/.claude/archive/math-tools-port/16-waveform-quaternion.md b/.claude/archive/math-tools-port/16-waveform-quaternion.md
new file mode 100644
index 0000000..a693530
--- /dev/null
+++ b/.claude/archive/math-tools-port/16-waveform-quaternion.md
@@ -0,0 +1,94 @@
+---
+chunk: 16-waveform-quaternion
+track: C
+status: complete
+depends_on: [11, 07]
+spec: ../specs/waveformCore.md §ABC accessor, §Aggregate containers, §Compliance 1, 2, 8
+last_updated: 2026-07-23
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 16 — `WaveformQuaternion`
+
+**Deliverable:** the quaternion time-series container.
+
+## Files
+
+- Create: `src/math_tools/waveforms/waveform_quaternion.py`
+- Edit: `src/math_tools/waveforms/__init__.py` (export)
+- Create: `tests/waveforms/test_waveform_quaternion.py`
+
+## Design constraints
+
+1. Subclass `QuaternionWaveformABC`. Storage `(n, 4)` float64
+   `quaternions_array` in **`(w, x, y, z)` order** (pinned repo-wide); ABC
+   accessor `quaternions -> Sequence[QuaternionABC]` materializes
+   `Quaternion` objects.
+2. Mirror chunk 15's structure with `Element = Quaternion`:
+   `from_components(w, x, y, z)` (w-first),
+   `component_waveforms -> NamedTuple(w, x, y, z)` (w-first — NOT the Swift
+   x-first order), `are_all_unit` (unit stem, not "normalized"),
+   `normalize()`/`normalized()`, element access/iteration, mutation verbs,
+   `extend`/`concatenate`, `==`/`repr`/`to_dict`/`from_dict`.
+3. Vectorized normalization: row-wise norm over the array; `ValueError` on a
+   zero row.
+
+## TDD steps
+
+1. Failing tests: `QuaternionWaveformType` wire round-trip (compliance 1;
+   note wire dicts are per-element `{"w","x","y","z"}`); dt-mismatch (2);
+   `component_waveforms` → `from_components` exact round-trip with the
+   w-first order pinned by name access (compliance 8); `are_all_unit` flips
+   after appending a non-unit element.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Compliance 1, 2, 8 named tests pass; tuple field names are `(w, x, y, z)`
+- [x] `w[i]` returns a `Quaternion` equal to the stored row
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Pose container (17); slerp/orientation interpolation on series (not in spec).
+
+## Resolution notes
+
+- `WaveformQuaternion(QuaternionWaveformABC)` mirrors `WaveformPosition`'s
+  (chunk 15) structure exactly, with `Element = Quaternion` and `(n, 4)`
+  storage in **`(w, x, y, z)` order** — pinned repo-wide, NOT Swift's
+  x-first order. `component_waveforms`'s `NamedTuple` fields are literally
+  named `w`, `x`, `y`, `z` in that order; `from_components(w, x, y, z)` is
+  w-first. Time-axis properties copied (not shared via a base class),
+  matching chunk 15's own precedent.
+- `_quaternions_to_array` / element materialization use `Quaternion`'s
+  real `as_float_array()`/`from_float_array()` methods (chunk 07's
+  `__array__`-adjacent additions), not invented ones.
+- `are_all_unit` mirrors `WaveformPosition`'s exact tolerance
+  (`atol=1e-12`). `normalize()`'s zero-magnitude `ValueError` does NOT use
+  that tolerance — like `WaveformPosition`, it is an exact `norms == 0.0`
+  check (corrected 2026-07-23: this note previously and incorrectly
+  claimed `atol=1e-12` applied there too) — with matching message style
+  (`"cannot normalize a zero-magnitude quaternion at index {i}"`) — a
+  judgment call since `Quaternion` itself has no `normalize()` method
+  (only `normalized()`, no explicit zero-magnitude raise), so
+  `WaveformPosition`/`Position.normalize`'s convention was the correct
+  precedent to follow, not `Quaternion`'s.
+  `are_all_unit`'s flip-after-append-non-unit behavior (an explicit TDD
+  step in this chunk) is covered by
+  `test_are_all_unit_flips_after_appending_non_unit`.
+- `extend`/`concatenate` compat-check only `dt` (not length), matching
+  chunk 15's precedent for concatenation ops.
+- Verified live: `w[i]` returns a `Quaternion` equal to the stored row;
+  `component_waveforms.w/x/y/z` (by name, not tuple position) matches the
+  stored `(w,x,y,z)` order exactly; `to_dict()`/`from_dict()` round-trips
+  to an equal instance; `foundationTypes.mathTypes.MathTypes.
+  QuaternionWaveformType.from_dict()` accepts the same dict; the wire
+  dict's per-element shape is confirmed to be exactly `{"w","x","y","z"}`
+  (compliance 1).
+- No spec change was needed; implementation matches waveformCore.md's
+  §Aggregate containers section (Element = Quaternion) as written.
+- Verified: 68 new tests in `tests/waveforms/test_waveform_quaternion.py`
+  (including two 100,000-element compliance-10 smoke tests), full suite
+  752 tests green, ruff clean, mypy strict clean (`make uv-fullCheck`).
diff --git a/.claude/archive/math-tools-port/17-waveform-spatial-pose.md b/.claude/archive/math-tools-port/17-waveform-spatial-pose.md
new file mode 100644
index 0000000..d82df57
--- /dev/null
+++ b/.claude/archive/math-tools-port/17-waveform-spatial-pose.md
@@ -0,0 +1,107 @@
+---
+chunk: 17-waveform-spatial-pose
+track: C
+status: complete
+depends_on: [08, 15, 16]
+spec: ../specs/waveformCore.md §Aggregate containers, §Compliance 1, 2, 8, 9
+last_updated: 2026-07-14
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 17 — `WaveformSpatialPose`
+
+**Deliverable:** the 6-DOF pose time-series container (parallel arrays).
+
+## Files
+
+- Create: `src/math_tools/waveforms/waveform_spatial_pose.py`
+- Edit: `src/math_tools/waveforms/__init__.py` (export)
+- Create: `tests/waveforms/test_waveform_spatial_pose.py`
+
+## Design constraints
+
+1. Subclass `WaveformSpatialABC`. Parallel `positions_array (n,3)` +
+   `quaternions_array (n,4)` (w-first); ABC accessors `positions` and
+   `quaternions` materialize.
+2. Per spec: constructors (component arrays, `from_poses(list[SpatialPose],
+   dt/dt_seconds, t0)`, `from_waveforms(position_waveform,
+   quaternion_waveform)` with count/dt `ValueError`), element access
+   returns `SpatialPose`, `component_waveforms` (nested
+   position+quaternion NamedTuples), `position_waveform`,
+   `quaternion_waveform`, `are_all_positions_unit` /
+   `are_all_quaternions_unit`, `normalize()`/`normalized()`, mutation with
+   `SpatialPose` payloads, `extend`/`concatenate`, `==`/`repr`/
+   `to_dict`/`from_dict`.
+3. **Subtle Swift parity (spec compliance 9):** `is_valid` = equal array
+   lengths; `sample_count` = `min(len(positions), len(quaternions))`. Both
+   behaviors kept even though constructors validate — direct array
+   manipulation in tests constructs the unequal state.
+
+## TDD steps
+
+1. Failing tests: `SpatialTransformWaveformType` wire round-trip
+   (compliance 1); dt-mismatch (2); pose round-trip
+   `from_poses` → `w[i]` (8); unequal-arrays `is_valid`/`sample_count`
+   pinned (9); `position_waveform`/`quaternion_waveform` slices match.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Compliance 1, 2, 8, 9 named tests pass
+- [x] `from_waveforms(w.position_waveform, w.quaternion_waveform) == w`
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Trajectory math on pose series; interpolation between samples.
+
+## Resolution notes
+
+- `WaveformSpatialPose(WaveformSpatialABC)` is backed by TWO independent
+  parallel arrays — `_positions` `(n,3)` and `_quaternions` `(n,4)`
+  w-first — rather than composing `WaveformPosition`/`WaveformQuaternion`
+  instances internally. `component_waveforms` returns a nested
+  `SpatialPoseComponentWaveforms(position, quaternion)` NamedTuple reusing
+  `PositionComponentWaveforms`/`QuaternionComponentWaveforms` from chunks
+  15/16 directly rather than redefining them.
+- **The compliance-9 subtlety, resolved as the chunk doc anticipated:**
+  the primary `__init__` does NOT require `positions`/`quaternions` to
+  have equal length — only `from_waveforms` validates count (and `dt`)
+  equality, raising `ValueError`. `is_valid` is `len(positions) ==
+  len(quaternions)`; `sample_count`/`__len__` is `min(...)`, not one
+  array's raw length. Every other size-dependent property (`duration`,
+  `time_axis()`, slice bounds, `get`/iteration) is derived from
+  `sample_count` rather than either array's raw length, so an
+  unequal-length instance behaves as a well-defined "valid prefix"
+  everywhere rather than only at the two pinned accessors — a
+  correctness improvement beyond the letter of the compliance item, not
+  just satisfying it narrowly. Verified live:
+  `WaveformSpatialPose([3 positions], [2 quaternions]).is_valid is False`
+  and `.sample_count == 2`.
+- `extend`/`concatenate` raise `WaveformCompatibilityError` on `dt`
+  mismatch (matching chunks 15/16's precedent); `from_waveforms` raises
+  plain `ValueError` on count or `dt` mismatch (matching this chunk's own
+  design constraint 2's literal wording) — the two constructors
+  deliberately use different exception types for different reasons
+  (compatibility-of-concatenation vs. malformed-construction-input), and
+  the test suite pins that `from_waveforms`'s `dt` mismatch is `ValueError`
+  and NOT `WaveformCompatibilityError`
+  (`test_from_waveforms_dt_mismatch_is_not_compatibility_error`).
+- `normalize()` checks both arrays for zero-magnitude rows BEFORE mutating
+  either, so a failure (either array) leaves the whole waveform unchanged
+  — verified by
+  `test_normalize_zero_position_leaves_quaternions_unmodified`.
+- Verified live: `WaveformSpatialPose.from_waveforms(w.position_waveform,
+  w.quaternion_waveform) == w` for a `from_poses`-built `w` (the literal
+  acceptance criterion); `to_dict()`/`from_dict()` round-trips, and
+  `foundationTypes.mathTypes.MathTypes.SpatialTransformWaveformType.
+  from_dict()` accepts the same dict (compliance 1).
+- No spec change was needed; implementation matches waveformCore.md's
+  §Aggregate containers section (`WaveformSpatialPose`) as written.
+- Verified: 83 new tests in `tests/waveforms/test_waveform_spatial_pose.py`
+  (including 100,000-element compliance-10 smoke tests), full suite 835
+  tests green, ruff clean, mypy strict clean (`make uv-fullCheck`).
+- **This completes Track C (chunks 11-17)** — `Waveform1D` core/operators/
+  generators, the DSP support substrate, and all three aggregate spatial
+  waveform containers.
diff --git a/.claude/archive/math-tools-port/18-dsp-calc.md b/.claude/archive/math-tools-port/18-dsp-calc.md
new file mode 100644
index 0000000..d536bae
--- /dev/null
+++ b/.claude/archive/math-tools-port/18-dsp-calc.md
@@ -0,0 +1,138 @@
+---
+chunk: 18-dsp-calc
+track: D
+status: complete
+depends_on: [14]
+spec: ../specs/waveformDsp.md §Family contracts (CalcMixin), §Numerical conventions, §Compliance 1–2
+last_updated: 2026-07-17
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 18 — `CalcMixin` (integrate / derivative)
+
+**Deliverable:** `math_tools/waveforms/dsp/_calc.py` + tests. Swift
+reference: `SWIFT_MATH/Waveform1D/Extensions/Waveform1D+Calc.swift`.
+
+## Files
+
+Create `src/math_tools/waveforms/dsp/_calc.py`,
+`tests/waveforms/dsp/__init__.py`, `tests/waveforms/dsp/test_calc.py`.
+Do NOT touch `waveform1d.py` (mixins compose in chunk 30). Tests exercise
+the mixin via a local test subclass `class _W(CalcMixin, Waveform1D): pass`
+— this pattern applies to every DSP chunk.
+
+## Design constraints
+
+- `class CalcMixin(WaveformProtocol)`; methods per spec table:
+  `integrate(initial_value=0.0) -> Waveform1D` (cumulative trapezoid scaled
+  by `dt` seconds, first sample = initial_value),
+  `derivative() -> Waveform1D` (`np.gradient` over the time axis).
+- Results built via `self._with_values(...)`; imports: scipy/numpy +
+  `._protocol`/`._common` only (no sibling mixin imports — repo layering
+  test extended here if not already covering `dsp/`).
+
+## TDD steps
+
+1. Failing tests (spec compliance 1): derivative of a linear ramp is
+   constant (atol 1e-9); `integrate` of a constant is a ramp;
+   `integrate().derivative()` recovers a smooth signal interior
+   (rtol 1e-6).
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] The three analytic tests pass
+- [x] `grep "from math_tools.waveforms.dsp._" src/math_tools/waveforms/dsp/_calc.py` shows only `_protocol`/`_common`
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Any other mixin; composing into `Waveform1D`.
+
+## Resolution notes
+
+- **Real runtime bug found in chunk 14's design, fixed here (spec bumped
+  0.0.2 → 0.0.3):** the chunk's literal design constraint `class CalcMixin
+  (WaveformProtocol)` combined with its own mandated test pattern
+  `class _W(CalcMixin, Waveform1D): pass` is broken at runtime. Explicitly
+  subclassing a `typing.Protocol` (without also listing `Protocol` as a
+  base) turns its stub property bodies (`...`, so the getter implicitly
+  returns `None`) into concrete inherited implementations; C3
+  linearization for `_W(CalcMixin, Waveform1D)` places `WaveformProtocol`
+  (reached via `CalcMixin`) ahead of `Waveform1D` in the MRO, so
+  `self.values` silently returned `None` instead of the sample array —
+  caught immediately by the TDD tests (`AttributeError: 'NoneType' object
+  has no attribute 'shape'`), not by inspection. Fixed by switching to
+  mypy's documented "mixin classes" idiom: `CalcMixin` is now a plain class
+  (`class CalcMixin:`, no runtime base) that types `self` as
+  `WaveformProtocol` on each method (`def integrate(self: WaveformProtocol,
+  ...) -> WaveformProtocol`). Verified this composes correctly at runtime
+  (`_W(CalcMixin, Waveform1D)`'s MRO no longer contains `WaveformProtocol`,
+  `self.values` resolves to `Waveform1D`'s real property) and still passes
+  `mypy --strict`. `waveformDsp.md` §Organization and
+  `dsp/_protocol.py`'s module docstring were both updated to document the
+  corrected pattern so chunks 19–29 don't repeat it.
+- **`integrate`/`derivative` return `WaveformProtocol`, not `Waveform1D`:**
+  both are built via `self._with_values(...)`, whose declared return type
+  is `WaveformProtocol` (chunk 14's own established pattern, to avoid
+  importing `Waveform1D` into `dsp/`). A consequence for the mandated
+  `_W(CalcMixin, Waveform1D)` test pattern: `Waveform1D._with_values`
+  always constructs a bare `Waveform1D` (not `type(self)(...)`), so a
+  single-mixin test subclass loses `CalcMixin`'s methods on the result of
+  its own method — `w.integrate()` cannot be chained directly into
+  `.derivative()`. Tests rewrap the intermediate result into `_W` before
+  calling the next mixin method (see `_wrap` helper in `test_calc.py`);
+  this is an inherent property of the "one mixin composed at a time" test
+  pattern the chunk doc itself specifies, not something chunk 18 changes.
+- **`integrate`:** cumulative trapezoid via
+  `scipy.integrate.cumulative_trapezoid(values, dx=dt_seconds, initial=0.0)`,
+  then the whole result is offset by `+ initial_value` (this scipy version
+  rejects a nonzero `initial=`; `ValueError: initial must be None or 0`).
+  This reproduces the Swift semantics exactly: `first sample ==
+  initial_value`, each subsequent sample is `initial_value +` the
+  accumulated trapezoidal area — pinned by an exact (`atol=1e-9`, not just
+  `rtol`) test against a constant signal, where the closed form is exact.
+  Raises `ValueError` on an empty waveform (0 samples) per waveformDsp.md
+  §Numerical conventions ("methods that need a minimum length raise
+  ValueError... except detectors"); a single-sample waveform is valid
+  (result is `[initial_value]`).
+- **`derivative`:** `np.gradient(values, dt_seconds)` (central differences
+  interior, one-sided at the edges) — this differs from the Swift source's
+  hand-rolled central-difference loop only in the boundary formula
+  (`np.gradient` uses a second-order-accurate one-sided estimate at the
+  edges; Swift uses a first-order forward/backward difference), which is a
+  documented, deliberate divergence per waveformDsp.md's preamble ("scipy
+  semantics win... documented in the method docstring") rather than an
+  oversight. Raises `ValueError` for fewer than 2 samples (`np.gradient`'s
+  own minimum), including the empty case, rather than the Swift source's
+  silent-empty-result.
+- **`make uv-fullCheck` surfaced two gaps unrelated to `_calc.py` itself,
+  both fixed in this chunk since nothing downstream of this DSP-mixin
+  track could pass the gate otherwise:**
+  1. `scipy` ships no inline type stubs (first scipy import in this repo);
+     `mypy --install-types` offers `scipy-stubs`, but the latest published
+     version (1.15.3.0) lags the pinned scipy (1.16.3) enough that pinning
+     it felt like trading one type-safety gap for a version-skew one for no
+     real benefit this chunk. Added a narrowly-scoped
+     `[[tool.mypy.overrides]] module = "scipy.*"` /
+     `ignore_missing_imports = true` block to `pyproject.toml` instead —
+     every other third-party import stays strict/unignored. Every future
+     scipy-backed DSP chunk (19–29) inherits this for free.
+  2. waveformDsp.md §Compliance 2 ("no sibling mixin imports... pinned by a
+     layering test") and chunk 18's own design constraint ("repo layering
+     test extended here if not already covering `dsp/`") were not yet
+     satisfied — `tests/test_package_layering.py` had no `dsp/`-specific
+     check. Added `test_dsp_mixins_do_not_import_sibling_mixins` (guarded
+     to skip if `waveforms/dsp` doesn't exist, mirroring the existing
+     `test_otg_does_not_import_numpy` pattern): scans every `dsp/_*.py`
+     module's `ast.ImportFrom` nodes (absolute and relative forms) for
+     sibling `dsp/_*` imports outside `{_protocol, _common}`. Currently
+     vacuous for `_calc.py` (it only imports `_protocol`/`_common`) but
+     enforced going forward for chunks 19–29.
+- Verified live (beyond the test suite): `_W([1.0,2.0,3.0]).integrate()`
+  and the resulting value's `.values`/`.dt`/`.t0` before writing this note
+  reproduced the `NoneType` bug pre-fix and its absence post-fix;
+  `_W.__mro__` post-fix no longer contains `WaveformProtocol`/`Protocol`.
+- Full suite: 848 tests green (12 new in `tests/waveforms/dsp/test_calc.py`),
+  ruff clean, mypy strict clean (`make uv-fullCheck`).
diff --git a/.claude/archive/math-tools-port/19-dsp-correlation.md b/.claude/archive/math-tools-port/19-dsp-correlation.md
new file mode 100644
index 0000000..a3d0f8d
--- /dev/null
+++ b/.claude/archive/math-tools-port/19-dsp-correlation.md
@@ -0,0 +1,108 @@
+---
+chunk: 19-dsp-correlation
+track: D
+status: complete
+depends_on: [14]
+spec: ../specs/waveformDsp.md §Family contracts (CorrelationMixin), §Compliance 1–2
+last_updated: 2026-07-17
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 19 — `CorrelationMixin`
+
+**Deliverable:** `dsp/_correlation.py` + tests. Swift reference:
+`SWIFT_MATH/Waveform1D/Extensions/Waveform1D+Correlation.swift`; test ideas:
+`SWIFT_TESTS/Waveform1DCorrelationTests.swift` (39 tests — port the
+representative cases).
+
+## Files
+
+Create `src/math_tools/waveforms/dsp/_correlation.py`,
+`tests/waveforms/dsp/test_correlation.py`. Test-subclass pattern per
+chunk 18.
+
+## Design constraints
+
+- Methods per spec table: `auto_correlation(max_lag=None, normalized=True)`,
+  `cross_correlation(other, max_lag=None, normalized=True)` (dt mismatch →
+  `WaveformCompatibilityError`), `find_max_correlation(other, max_lag=None)
+  -> WaveformTimeLag`. Backing `scipy.signal.correlate`/`correlation_lags`.
+- Normalized autocorrelation is 1.0 at lag 0; `WaveformTimeLag` carries
+  `lag_samples`, `lag_seconds` (= lag · dt seconds), `correlation`.
+
+## TDD steps
+
+1. Failing tests: autocorrelation of white noise ≈ δ (lag-0 dominates);
+   `find_max_correlation` of a signal vs itself shifted by k samples
+   returns lag k (exact) with correlation ≈ 1; dt mismatch raises.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Known-shift lag recovery exact for k ∈ {0, 3, 17}
+- [x] Import-fence grep per chunk 18
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Time alignment (chunk 26 consumes this); phase coherence (24).
+
+## Resolution notes
+
+- **Lag sign convention diverges from the Swift reference (documented in
+  `_correlation.py`'s module docstring, not silently).** Swift's hand-rolled
+  `findMaxCorrelation` computes `actualLag = maxIndex - (other.count - 1)`
+  ("other's index minus self's"); empirically verifying
+  `scipy.signal.correlate`/`correlation_lags` against Swift's own
+  `findMaxCorrelationShifted` test fixture (`original`/`shifted` arrays)
+  showed scipy's native lag is the exact negation of Swift's for the same
+  input. Per waveformDsp.md's preamble ("parity is judged per capability,
+  not per Swift overload... scipy semantics win and the divergence is
+  documented"), this module keeps scipy's native sign rather than negating
+  it post-hoc: `other` trailing `self` by `k` samples
+  (`other[i] == self[i - k]`) yields `lag_samples == -k`. Verified exact
+  (not approximate) lag recovery at `n=2000` for `k ∈ {0, 3, 17}` via
+  `np.roll`-shifted white noise, correlation ≥ 0.99 in all three cases.
+- **Python surface intentionally narrower than Swift's:** the spec's
+  `cross_correlation(other, max_lag=None, normalized=True)` signature has no
+  `mode` parameter, so only scipy's `mode="full"` is implemented — Swift's
+  `WaveformCorrelationMode` (`valid`/`same`) overloads are not ported
+  (YAGNI; add with a caller that needs them). `max_lag` trims the full-mode
+  result to `abs(lag) <= max_lag` for both `cross_correlation` and
+  `find_max_correlation`, which is this repo's addition (Swift's
+  `crossCorrelation` has no lag cap; its `findMaxCorrelation` has a
+  `searchRange` instead — `max_lag` is the simpler, symmetric analogue the
+  Python spec actually asks for).
+- **Empty-input / dt-mismatch handling:** `auto_correlation` and
+  `cross_correlation` raise `ValueError` naming the requirement on an empty
+  waveform (waveformDsp.md §Numerical conventions — correlation is not a
+  `detect_*`/`zero_crossings` detector, so it doesn't get the empty-result
+  exemption Swift's `nil`-returning Optionals use instead).
+  `cross_correlation`/`find_max_correlation` raise
+  `WaveformCompatibilityError` on `other.dt != self.dt`, per the chunk's
+  design constraint.
+- **Zero-variance signal parity:** ported Swift's `autoCorrelation`
+  zero-variance special case exactly — a nonzero constant signal normalizes
+  to `1.0` at every lag, an all-zero signal to `0.0` at every lag (both
+  pinned by tests).
+- **`WaveformTimeLag` import from `waveforms/support.py`, not `dsp/_*`:**
+  the family contract requires `find_max_correlation -> WaveformTimeLag`,
+  a descriptor type support.py already defines (chunk 14). Importing it
+  does not trip `test_dsp_mixins_do_not_import_sibling_mixins` (verified —
+  that test only flags `math_tools.waveforms.dsp.*`/relative-within-`dsp/`
+  imports, not `waveforms/support.py`, which lives outside the `dsp/`
+  package) and introduces no import cycle at this chunk (`support.py`
+  already imports `waveform1d.py`, which imports nothing from `dsp/`).
+  Flagging for whichever chunk composes `Waveform1D`'s final mixin list
+  (30): `support.py` importing `waveform1d.py` while `waveform1d.py` will
+  need to import every mixin (including this one, which imports
+  `support.py`) is a latent cycle that chunk 30 will need to resolve (e.g.
+  a lazy/`TYPE_CHECKING` import in `support.py`, or moving `Waveform1D`
+  aggregate-referencing descriptors elsewhere) — not a chunk 19 problem
+  since no mixin is composed into `Waveform1D` yet, but worth knowing going
+  in; `TriggerMixin` (chunk 27, `WaveformWithEvents`) will hit the same
+  shape of dependency.
+- Full suite: 872 tests green (24 new in
+  `tests/waveforms/dsp/test_correlation.py`), ruff clean, mypy strict clean
+  (`make uv-fullCheck`).
diff --git a/.claude/archive/math-tools-port/20-dsp-envelope.md b/.claude/archive/math-tools-port/20-dsp-envelope.md
new file mode 100644
index 0000000..ddafbd0
--- /dev/null
+++ b/.claude/archive/math-tools-port/20-dsp-envelope.md
@@ -0,0 +1,106 @@
+---
+chunk: 20-dsp-envelope
+track: D
+status: complete
+depends_on: [14]
+spec: ../specs/waveformDsp.md §Family contracts (EnvelopeMixin), §Compliance 1–2
+last_updated: 2026-07-17
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 20 — `EnvelopeMixin`
+
+**Deliverable:** `dsp/_envelope.py` + tests. Swift reference:
+`SWIFT_MATH/Waveform1D/Extensions/Waveform1D+Envelope.swift`.
+
+## Files
+
+Create `src/math_tools/waveforms/dsp/_envelope.py`,
+`tests/waveforms/dsp/test_envelope.py`. Test-subclass pattern per chunk 18.
+
+## Design constraints
+
+- Methods per spec table: `amplitude_envelope()` (Hilbert magnitude),
+  `upper_lower_envelopes() -> tuple[Waveform1D, Waveform1D]` (peak/valley
+  interpolation), `instantaneous_amplitude(method:
+  WaveformInstantaneousMethod)` dispatching HILBERT / RMS (windowed) /
+  PEAK (interp). Backing `scipy.signal.hilbert`, `find_peaks`, `np.interp`.
+- Minimum-length `ValueError` with requirement in message (spec
+  §Numerical conventions).
+
+## TDD steps
+
+1. Failing tests: envelope of `A·sin` is ≈ A on the interior (rtol 5e-2,
+   edges excluded); envelope of a damped sinusoid tracks `A·exp(−λt)`
+   (interior, rtol 0.1); upper ≥ lower everywhere; each
+   `WaveformInstantaneousMethod` returns the right length.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Analytic sine/damped tests pass; import-fence grep per chunk 18
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Phase analysis (24); spectral features (21).
+
+## Resolution notes
+
+- **Mixin typing follows the chunk-18 fix, not this chunk's own literal
+  code block** (this chunk file predates chunk 18): `EnvelopeMixin` is a
+  plain class (no runtime base beyond `object`) that types `self` as
+  `WaveformProtocol` on each method — the pattern in `dsp/_calc.py` /
+  `dsp/_correlation.py`. Tests use the mandated `class _W(EnvelopeMixin,
+  Waveform1D): pass` subclass with a `_wrap` rewrap helper, matching
+  `test_calc.py`/`test_correlation.py`.
+- **Backing implementation intentionally diverges from the Swift
+  reference** (`Waveform1D+Envelope.swift`), per waveformDsp.md's
+  preamble ("parity is judged per capability, not per Swift overload"):
+  the Swift source approximates the Hilbert transform with a hand-rolled
+  fixed-window "quadrature filter" and finds extrema via a windowed
+  `allSatisfy` scan. This module uses the real `scipy.signal.hilbert`
+  analytic signal for `amplitude_envelope`/`instantaneous_amplitude`
+  (`HILBERT`), and `scipy.signal.find_peaks` + `np.interp` for
+  `upper_lower_envelopes` and `instantaneous_amplitude(PEAK)` — the chunk
+  file's own "Design constraints" section already specified this backing
+  explicitly, so no spec-authored capability was skipped, only the Swift
+  extension's specific (weaker) algorithm.
+- **`upper_lower_envelopes` boundary handling:** local maxima/minima come
+  from `find_peaks(values)` / `find_peaks(-values)`; the first and last
+  sample indices are always added as extra interpolation anchors (sorted,
+  deduplicated via `np.unique`) so a signal with no interior extrema (a
+  monotonic ramp, pinned by `test_boundary_samples_are_anchored`) still
+  produces an envelope spanning the full waveform via a straight line
+  between the two boundary samples, instead of `find_peaks` returning
+  nothing and the envelope being degenerate. This differs from the Swift
+  reference's `windowSize`-gated constant-envelope fallback (which returns
+  a flat `min`/`max`-valued envelope for short inputs) — the boundary-anchor
+  approach works uniformly for every input length without a separate
+  short-input branch, and is simpler.
+- **`instantaneous_amplitude(RMS)` is a `window_size`-parameterized
+  centered moving-window RMS** (edge-padded `np.convolve`, not a scipy
+  call — the spec's family-contract row lists `find_peaks`/`hilbert`/
+  `np.interp` as the family's backing implementations collectively, and
+  RMS is the one path with no natural scipy primitive; `FilteringMixin`'s
+  `moving_average_filter` in the same family-contract table is also
+  `np.convolve`-backed, so this keeps the same idiom rather than adding a
+  new dependency). Defaults to `window_size=5`; raises `ValueError` naming
+  the requirement for `window_size < 1`.
+- **Minimum-length `ValueError`** on all three methods for an empty input
+  waveform (0 samples), each naming the requirement in the message — none
+  of these are in the `detect_*`/`zero_crossings` empty-result-exempt
+  family (waveformDsp.md §Numerical conventions).
+- **Damped-sinusoid test tuning:** the TDD step's rtol-0.1 interior check
+  needed a `time_constant` large enough relative to the signal's 1-second
+  span that the tail doesn't decay into the amplitude range where the
+  Hilbert envelope's relative error blows up (small absolute differences
+  read as large relative ones once the true amplitude is near zero) —
+  `time_constant=1.5` (decay to ~51% by t=1s) passes cleanly at rtol=0.1
+  over the interior `[100:-100]` slice; `time_constant=0.5` (decay to
+  ~13.5%) did not. This is a test-tuning choice, not an implementation
+  change — the same `amplitude_envelope()` call is exercised either way.
+- Full suite: 893 tests green (21 new in
+  `tests/waveforms/dsp/test_envelope.py`), ruff clean, mypy strict clean
+  (`make uv-fullCheck`).
diff --git a/.claude/archive/math-tools-port/21-dsp-spectral.md b/.claude/archive/math-tools-port/21-dsp-spectral.md
new file mode 100644
index 0000000..f93f8d9
--- /dev/null
+++ b/.claude/archive/math-tools-port/21-dsp-spectral.md
@@ -0,0 +1,99 @@
+---
+chunk: 21-dsp-spectral
+track: D
+status: complete
+depends_on: [14]
+spec: ../specs/waveformDsp.md §Family contracts (SpectralMixin), §Compliance 1–2
+last_updated: 2026-07-17
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 21 — `SpectralMixin` (FFT / PSD / spectrogram / mel / features)
+
+**Deliverable:** `dsp/_spectral.py` + tests. Swift references:
+`Waveform1D+FFT.swift`, `+Spectrogram.swift` under
+`SWIFT_MATH/Waveform1D/Extensions/`.
+
+## Files
+
+Create `src/math_tools/waveforms/dsp/_spectral.py`,
+`tests/waveforms/dsp/test_spectral.py`. Test-subclass pattern per chunk 18.
+
+## Design constraints
+
+- Methods per spec table: `fft() -> WaveformSpectrum` (rfft; frequencies in
+  Hz from `sampling_frequency_hz`), `power_spectral_density(window=...,
+  scaling: WaveformPSDScaling = DENSITY, nperseg=None) -> WaveformSpectrum`
+  (`scipy.signal.welch`), `spectrogram(window=..., nperseg=..., overlap=...)
+  -> WaveformSpectrogram` (`scipy.signal.ShortTimeFFT` or
+  `scipy.signal.spectrogram`), `mel_spectrogram(n_mels=..., ...) ->
+  WaveformMelSpectrogram` (hand-built triangular filterbank over the
+  spectrogram — numpy), `spectral_features() -> WaveformSpectralFeatures`
+  (centroid, spread, rolloff, flatness — match the Swift field set from
+  `extractSpectralFeatures`; read the Swift struct first and mirror its
+  fields exactly).
+- Minimum-length `ValueError` per §Numerical conventions.
+
+## TDD steps
+
+1. Failing tests (spec compliance 1): `fft` of a pure 10 Hz sine
+   (fs = 1 kHz, n = 1000) peaks at the 10 Hz bin; Parseval sanity
+   (`sum(|X|²)` vs `sum(x²)`, rtol 1e-6); PSD of white noise is flat within
+   a loose band; spectrogram of a chirp has monotonically increasing
+   argmax-frequency per column; mel filterbank rows sum ≈ 1 where fully
+   inside the band; spectral centroid of the 10 Hz sine ≈ 10 Hz (rtol 5e-2).
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Peak-bin, chirp-monotone, and centroid tests pass
+- [x] All four descriptor types round out of the methods without eq/hash errors
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Filtering (22), phase (24), windows themselves (28 — take `window`
+parameters as `WaveformWindowType` and map via `scipy.signal.get_window`
+directly here; chunk 28's helpers are for user-facing window utilities).
+
+## Resolution notes
+
+- **`spectral_features` field-set decision.** This chunk's own bullet said
+  to "mirror the Swift `extractSpectralFeatures` struct's fields exactly,"
+  but that Swift struct (`Waveform1D/Support/WaveformSpectralFeatures.swift`)
+  is a *per-time-frame* result derived from a spectrogram
+  (`spectralCentroids`/`spectralRolloffs`/`spectralFluxes`/`timeFrames`,
+  all arrays) — not the four scalars (`centroid`, `spread`, `rolloff`,
+  `flatness`) the same bullet names. The Python `WaveformSpectralFeatures`
+  dataclass already shipped in `waveforms/support.py` from chunk 14 (merged
+  before this chunk) uses that scalar shape, and waveformDsp.md §Support
+  descriptor types already documents it that way — both predate this chunk
+  and already agree with each other, so no spec or `support.py` change was
+  needed. Implemented `spectral_features()` against the existing scalar
+  shape (whole-spectrum summary over the FFT magnitude spectrum) rather than
+  reopening `support.py` for a per-frame shape; documented the reasoning in
+  `_spectral.py`'s module docstring. Only the chunk doc's own bullet was
+  stale/self-contradictory — no other spec drift found.
+- `WaveformSpectrogramScaling` (LINEAR/DB/MEL, defined in `support.py` from
+  chunk 14) is not consumed by this chunk: the design-constraints bullet for
+  `spectrogram()` lists only `window`/`nperseg`/`overlap`, no `scaling`
+  parameter, and `MEL` isn't a coherent magnitude-scaling option anyway
+  (it's a frequency-axis warp). Left unconsumed per YAGNI; a later chunk can
+  wire it up if a caller needs it.
+- `KAISER` window support needed a shape parameter (`beta`) that the family
+  contract doesn't expose; fixed a default (`beta=14.0`) documented inline
+  in `_spectral.py` rather than adding a beta parameter no other window
+  needs.
+- Window arguments are mapped to concrete arrays via `scipy.signal.get_window`
+  directly in `_spectral.py` (not through a shared `dsp/_common.py` helper),
+  per this chunk's own design-constraint text ("map ... directly here").
+- Mel filterbank rows are normalized to sum to ~1 by construction (each row
+  divided by its own weight sum) rather than the usual peak-height-1
+  triangle — satisfies the TDD step's "rows sum ≈ 1" requirement directly;
+  documented as a deliberate choice, not a Slaney-style bandwidth
+  normalization.
+- No deviation from the chunk 18 mixin-typing pattern was needed: this
+  chunk's own code was written fresh following `_calc.py`/`_correlation.py`/
+  `_envelope.py` (self-typed `self: WaveformProtocol`, no nominal Protocol
+  inheritance).
diff --git a/.claude/archive/math-tools-port/22-dsp-filtering.md b/.claude/archive/math-tools-port/22-dsp-filtering.md
new file mode 100644
index 0000000..c757293
--- /dev/null
+++ b/.claude/archive/math-tools-port/22-dsp-filtering.md
@@ -0,0 +1,127 @@
+---
+chunk: 22-dsp-filtering
+track: D
+status: complete
+depends_on: [14]
+spec: ../specs/waveformDsp.md §Family contracts (FilteringMixin), §Numerical conventions, §Compliance 1–2
+last_updated: 2026-07-17
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 22 — `FilteringMixin`
+
+**Deliverable:** `dsp/_filtering.py` + tests. Swift reference:
+`SWIFT_MATH/Waveform1D/Extensions/Waveform1D+Filtering.swift`.
+
+## Files
+
+Create `src/math_tools/waveforms/dsp/_filtering.py`,
+`tests/waveforms/dsp/test_filtering.py`. Test-subclass pattern per chunk 18.
+
+## Design constraints
+
+- Methods per spec table: `low_pass_filter(cutoff_hz, order=4)`,
+  `high_pass_filter(cutoff_hz, order=4)`, `band_pass_filter(low_hz,
+  high_hz, order=4)`, generic `filtered(filter_type: WaveformFilterType,
+  ...)` dispatching to the above (+ BAND_STOP), `moving_average_filter(
+  window_size)`, `exponential_filter(alpha)`,
+  `savitzky_golay_filter(window_length, polyorder, deriv=0)`,
+  `whittaker_henderson_filter(lam, order=2)` (sparse difference-matrix
+  solve via `scipy.sparse` + `spsolve`), `frequency_response(...) ->
+  WaveformSpectrum`.
+- Butterworth designs zero-phase via `filtfilt` (spec: zero-phase unless a
+  `causal=` flag). Cutoffs validated against Nyquist (`ValueError`).
+
+## Whittaker–Henderson recipe (the one clever bit)
+
+```python
+n = len(v); D = sparse.eye(n, format="csc")
+for _ in range(order): D = D[1:] - D[:-1]          # order-th difference matrix
+z = spsolve((sparse.eye(n) + lam * D.T @ D).tocsc(), v)
+```
+
+## TDD steps
+
+1. Failing tests (spec compliance 1): 5 Hz + 200 Hz mix (fs = 2 kHz) →
+   `low_pass_filter(50)` attenuates the 200 Hz component ≥ 40 dB while the
+   5 Hz amplitude survives (rtol 5e-2), measured via chunk-local rfft;
+   high-pass mirror; band-pass keeps only the in-band tone; moving average
+   of a constant is identity; savgol on a noiseless cubic reproduces it
+   (atol 1e-8); Whittaker–Henderson with `lam→0` ≈ identity and large `lam`
+   ≈ linear trend.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] The ≥ 40 dB attenuation test and savgol-cubic test pass
+- [x] Nyquist-violation cutoff raises `ValueError`
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Resampling (25); windowing utilities (28).
+
+## Resolution notes
+
+- Followed the chunk-18 self-typed-mixin pattern throughout (`FilteringMixin`
+  is a plain class, no `WaveformProtocol` base); this chunk's own code
+  samples didn't show the broken nominal-inheritance pattern, so no
+  correction was needed there.
+- The chunk doc's design-constraints bullet gives `filtered(filter_type:
+  WaveformFilterType, ...)` with an elided `...`; resolved the omitted
+  signature as `filtered(filter_type, cutoff_hz=None, low_hz=None,
+  high_hz=None, order=4, causal=False)` — the union of the args the four
+  dispatched Butterworth families need, with per-branch `ValueError` when
+  the wrong ones are missing. `low_pass_filter`/`high_pass_filter`/
+  `band_pass_filter`/`filtered` all funnel through one private
+  `_butter_coefficients` design helper so validation and design parameters
+  can't drift between the dedicated methods and the dispatcher.
+  `frequency_response` reuses the same helper against `scipy.signal.freqz`.
+- `causal: bool = False` was added (not explicitly named in the chunk file,
+  but required by the spec's own line: "Butterworth designs zero-phase via
+  `filtfilt` unless a `causal=` flag" — §Numerical conventions). Zero-phase
+  `filtfilt` is the default; `causal=True` switches to a single
+  `scipy.signal.lfilter` pass.
+- Deviated from the Swift reference's silent-no-op-on-invalid-input
+  behavior (e.g. `guard windowSize > 0 ... else { return self }`): every
+  invalid parameter (bad `window_size`, `alpha` outside `(0, 1]`, bad
+  `savgol` window/polyorder/deriv combination, `order < 1`, Nyquist
+  violations, missing dispatch args) raises `ValueError` naming the
+  requirement instead, per waveformDsp.md §Numerical conventions (already
+  the convention every prior DSP mixin chunk follows) and the spec's
+  "parity is judged per capability, not per Swift overload" policy.
+- `moving_average_filter` implements a centered average whose window
+  shrinks (not zero-pads) at the edges — closest Python-idiomatic
+  equivalent of the Swift reference's clamped-index behavior — via a
+  vectorized cumulative-sum formulation (no explicit Python loop).
+- `exponential_filter` is a genuinely sequential recursion
+  (`y[i]` depends on `y[i-1]`); implemented as a plain Python loop since a
+  vectorized closed form would need `alpha*(1-alpha)**arange(n)` weights
+  convolved against `values`, which is a real de-vectorization win only at
+  large `n` and adds nontrivial complexity — correctness/clarity outrank
+  that here (tenets: Correctness/Clarity > Performance; no evidence this is
+  ever a bottleneck for typical waveform sizes).
+- `savitzky_golay_filter` passes `delta=dt_seconds` to
+  `scipy.signal.savgol_filter` only when `deriv > 0` (scipy scales
+  derivative estimates by `1/delta**deriv`; passing a real `delta` for
+  `deriv=0` is harmless but pointless) so the returned derivative carries
+  proper physical units — not explicit in the chunk file, inferred from
+  waveformDsp.md's general "scale by dt seconds" convention used by
+  `CalcMixin`.
+- `whittaker_henderson_filter` implements the chunk's own sparse
+  difference-matrix recipe verbatim (`D = D[1:] - D[:-1]` applied `order`
+  times, then `spsolve(I + lam * D^T @ D, v)`).
+- No spec changes were needed — implementation matched
+  `waveformDsp.md`'s family-contract row and numerical conventions as
+  written; only the elided `filtered(...)` signature and the `causal=`
+  parameter required interpretation, and both are already licensed by the
+  spec text itself (§Numerical conventions) rather than contradicting it.
+- Test coverage exceeds the two acceptance-box-named cases (40 dB
+  attenuation, savgol-cubic) to satisfy the repo-wide §Compliance 1 ("every
+  mixin method tested against an analytically known signal"): all 9 public
+  methods have dedicated tests, including the TDD step's high-pass mirror,
+  band-pass in-band-survival, moving-average identity, and
+  Whittaker-Henderson `lam→0`/`lam→∞` cases.
+- `dsp/__init__.py` and `waveform1d.py` were not touched (mixin composition
+  is chunk 30's job per waveformDsp.md's "Composition phasing").
diff --git a/.claude/archive/math-tools-port/23-dsp-peaks.md b/.claude/archive/math-tools-port/23-dsp-peaks.md
new file mode 100644
index 0000000..18999b4
--- /dev/null
+++ b/.claude/archive/math-tools-port/23-dsp-peaks.md
@@ -0,0 +1,91 @@
+---
+chunk: 23-dsp-peaks
+track: D
+status: complete
+depends_on: [14]
+spec: ../specs/waveformDsp.md §Family contracts (PeakMixin), §Compliance 1–2
+last_updated: 2026-07-17
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 23 — `PeakMixin`
+
+**Deliverable:** `dsp/_peaks.py` + tests. Swift references:
+`SWIFT_MATH/Waveform1D/Extensions/Waveform1D+Peak.swift`;
+`SWIFT_TESTS/Waveform1DPeakTests.swift` (27 tests — port representative
+cases).
+
+## Files
+
+Create `src/math_tools/waveforms/dsp/_peaks.py`,
+`tests/waveforms/dsp/test_peaks.py`. Test-subclass pattern per chunk 18.
+
+## Design constraints
+
+- Methods per spec table: `detect_peaks(min_height=None, min_distance=None,
+  min_prominence=None) -> list[WaveformPeak]`, `detect_valleys(...)`
+  (negate + detect_peaks), `find_most_prominent_peaks(count,
+  min_distance=None) -> list[WaveformPeakWithProminence]`. Backing
+  `scipy.signal.find_peaks` / `peak_prominences`.
+- `WaveformPeak.time_seconds` = `index * dt` seconds; empty list on no-hit
+  (never raise for no peaks).
+
+## TDD steps
+
+1. Failing tests (spec compliance 1): `sine(n, f, fs)` yields exactly
+   `⌊n·f/fs⌋` peaks (choose n, f, fs so the count is unambiguous);
+   valleys mirror peaks under negation; prominence ordering on a two-tone
+   signal (big + small bumps) returns the big ones first; flat signal → [].
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Sine peak-count and prominence-order tests pass
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Trigger detection (27); zero crossings (29).
+
+## Resolution notes
+
+- Implemented `PeakMixin` (`detect_peaks`, `detect_valleys`,
+  `find_most_prominent_peaks`) exactly per the mixin table in
+  `waveformDsp.md` §Family contracts, backed by `scipy.signal.find_peaks` /
+  `peak_prominences`. No spec changes were needed — this chunk's design
+  constraints already matched the spec verbatim (no divergence to
+  reconcile).
+- Followed the chunk-18 typing fix (self-typed `WaveformProtocol`, no
+  nominal `Protocol` inheritance) throughout; `_peaks.py` imports only
+  `scipy`/`numpy` plus `dsp/_protocol.py`, `dsp/_common.py`, and
+  `waveforms/support.py` (for `WaveformPeak`/`WaveformPeakWithProminence`),
+  so the pre-existing generic sibling-import layering test
+  (`tests/test_package_layering.py::test_dsp_mixins_do_not_import_sibling_mixins`)
+  covers it automatically — no new layering-test code required.
+- `detect_valleys` is implemented as an exact negate/detect_peaks/negate
+  round-trip through a shared module-level helper
+  (`_detect_peaks_in_array`), matching the "valleys mirror peaks under
+  negation" TDD requirement literally: `min_height`/`min_prominence` are
+  forwarded unchanged to the negated-signal search (so `min_height` bounds
+  the original `value` from *above*, not below — documented in the
+  docstring since this is a semantic choice the chunk left implicit).
+- `find_most_prominent_peaks` treated as part of the same detector family
+  as `detect_peaks`/`detect_valleys` for the empty-result convention
+  (returns `[]` for `count <= 0`, an empty waveform, or no interior peaks,
+  rather than raising `ValueError`) — the spec's §Numerical conventions
+  ValueError-vs-empty-list split is keyed off the `detect_*`/
+  `zero_crossings` name prefix, but `find_most_prominent_peaks` is built
+  directly on `detect_peaks`'s results and documented as the same family in
+  the mixin table, so the empty-list contract was extended to it for
+  consistency; flagging this as a judgment call in case a future chunk
+  wants it spec'd explicitly.
+- Swift `Waveform1D+Peak.swift`'s hand-rolled `threshold`/`prominence`/
+  `minDistance`/`edgePeaks` local-maxima scan was **not** ported
+  literally — the chunk's own "Design constraints" section already pins
+  the Python surface to `min_height`/`min_distance`/`min_prominence`
+  scipy-style kwargs, so `Waveform1DPeakTests.swift`'s 27 cases were used
+  only for behavioral inspiration (mirrored valleys, prominence ordering,
+  flat/empty edge cases), not transliterated.
+- Gate: `make uv-fullCheck` green — ruff clean, mypy strict clean (64
+  source files), 971 tests passed (18 new in `test_peaks.py`).
diff --git a/.claude/archive/math-tools-port/24-dsp-phase.md b/.claude/archive/math-tools-port/24-dsp-phase.md
new file mode 100644
index 0000000..65ecc60
--- /dev/null
+++ b/.claude/archive/math-tools-port/24-dsp-phase.md
@@ -0,0 +1,94 @@
+---
+chunk: 24-dsp-phase
+track: D
+status: complete
+depends_on: [14]
+spec: ../specs/waveformDsp.md §Family contracts (PhaseMixin), §Compliance 1–2
+last_updated: 2026-07-17
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 24 — `PhaseMixin`
+
+**Deliverable:** `dsp/_phase.py` + tests. Swift reference:
+`SWIFT_MATH/Waveform1D/Extensions/Waveform1D+PhaseAnalysis.swift`.
+
+## Files
+
+Create `src/math_tools/waveforms/dsp/_phase.py`,
+`tests/waveforms/dsp/test_phase.py`. Test-subclass pattern per chunk 18.
+
+## Design constraints
+
+- Methods per spec table: `instantaneous_phase(unwrapped=True)` (Hilbert
+  angle), `unwrap_phase(threshold=π)` (`np.unwrap` on already-phase data),
+  `instantaneous_frequency() -> WaveformInstantaneousFrequency` (phase
+  gradient / 2π), `phase_difference(other)`, `phase_coherence(other,
+  window=...)`, `phase_synchronization_index(other) -> float` (PLV, in
+  [0, 1]), `group_delay(...)`. dt mismatch on binary methods →
+  `WaveformCompatibilityError`.
+
+## TDD steps
+
+1. Failing tests (spec compliance 1): unwrapped phase of a chirp is
+   monotone increasing; instantaneous frequency of a pure f-Hz sine ≈ f on
+   the interior (rtol 1e-2); PLV of a signal with itself == 1.0 and with an
+   independent seeded-noise signal < 0.3; `phase_difference` of `sin` vs
+   `cos` ≈ π/2 interior.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Chirp-monotone and PLV tests pass
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Envelope (20); spectral (21).
+
+## Resolution notes
+
+- Backed `instantaneous_phase`/`phase_difference`/`phase_coherence`/
+  `phase_synchronization_index` with `scipy.signal.hilbert`'s analytic-signal
+  angle rather than the Swift reference's hand-rolled "quadrature filter"
+  finite-difference approximation — allowed explicitly by the spec's opening
+  note ("parity is judged per capability... scipy semantics win").
+- `phase_difference` wraps its result into `(-pi, pi]` via
+  `np.angle(np.exp(1j * diff))` rather than a raw subtraction, avoiding a
+  spurious near-±π discontinuity; verified against the sin-vs-cos ≈π/2
+  compliance test.
+- Binary methods (`phase_difference`, `phase_coherence`,
+  `phase_synchronization_index`) raise `WaveformCompatibilityError` on
+  **both** dt mismatch (per the chunk's explicit design constraint) and
+  sample-count mismatch — the latter isn't literally named in the chunk
+  text, but `errors.py`'s `WaveformCompatibilityError` docstring scopes it to
+  "dt/shape mismatch", and these are element-wise phase-difference ops that
+  are undefined across differing lengths.
+- `phase_coherence(other, window=...)`: the chunk's design-constraint bullet
+  gives only the two named parameters, so the implementation is a minimal
+  non-overlapping-window PLV (no `overlap` parameter, unlike the Swift
+  reference) — window size defaults to `min(256, max(1, n // 4))`, mirroring
+  the Swift default. Its result reuses `self`'s `dt`/`t0` as inherited
+  metadata (not physically accurate for the new, coarser sample spacing);
+  this follows the precedent already set by `CorrelationMixin.auto_correlation`
+  (chunk 19), which does the same for its differently-spaced lag output —
+  `WaveformProtocol._with_values` has no other way to construct a result.
+- `group_delay(...)`: the chunk's method-list bullet leaves the signature as
+  `group_delay(...)`, and the Swift reference itself never touches
+  `self.values` (it operates purely on caller-supplied `frequencies`/`phases`
+  arrays). Ported as a `@staticmethod` taking exactly those two arrays and
+  returning group delay in seconds (`-d(unwrap(phases))/d(frequencies) /
+  (2*pi)`, via `np.gradient` — replacing the Swift version's manual
+  central-difference-plus-duplicated-boundary loop with numpy's own
+  boundary handling, a capability-preserving scipy/numpy-idiomatic
+  simplification). No cross-mixin dependency on `SpectralMixin`/
+  `FilteringMixin` was introduced (both are out of scope for this chunk).
+- No spec changes were needed: `waveformDsp.md`'s `PhaseMixin` row and
+  `WaveformInstantaneousFrequency` descriptor (already in `support.py` since
+  chunk 14) matched the implementation as written.
+- Gate: `make uv-fullCheck` green — ruff clean, mypy strict clean (66 source
+  files), 999 tests passed (28 new in `tests/waveforms/dsp/test_phase.py`).
+  The pre-existing generic sibling-import layering test
+  (`tests/test_package_layering.py::test_dsp_mixins_do_not_import_sibling_mixins`)
+  covers `_phase.py` automatically — no test-file changes were needed there.
diff --git a/.claude/archive/math-tools-port/25-dsp-resampling.md b/.claude/archive/math-tools-port/25-dsp-resampling.md
new file mode 100644
index 0000000..3007139
--- /dev/null
+++ b/.claude/archive/math-tools-port/25-dsp-resampling.md
@@ -0,0 +1,107 @@
+---
+chunk: 25-dsp-resampling
+track: D
+status: complete
+depends_on: [14]
+spec: ../specs/waveformDsp.md §Family contracts (ResamplingMixin), §Compliance 1–2
+last_updated: 2026-07-17
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 25 — `ResamplingMixin`
+
+**Deliverable:** `dsp/_resampling.py` + tests. Swift reference:
+`SWIFT_MATH/Waveform1D/Extensions/Waveform1D+Resampling.swift`.
+
+## Files
+
+Create `src/math_tools/waveforms/dsp/_resampling.py`,
+`tests/waveforms/dsp/test_resampling.py`. Test-subclass pattern per
+chunk 18.
+
+## Design constraints
+
+- Methods per spec table: `decimated(factor)` (`scipy.signal.decimate`),
+  `interpolated(factor, method: WaveformInterpolationMethod = LINEAR)`,
+  `resampled(target_frequency_hz)` (`scipy.signal.resample` /
+  `resample_poly`), `resampled_to_match(other)`,
+  `polyphase_resampled(up, down)` (`resample_poly`).
+- **dt bookkeeping is the tricky bit:** integer factor paths compute the new
+  `dt` exactly in PrecisionTime (`dt * factor` / `dt / factor` rounding to
+  nearest attosecond); `resampled(hz)` derives dt from the achieved rate.
+  New `t0` is unchanged.
+- `factor < 1` or non-int factor → `ValueError`.
+
+## TDD steps
+
+1. Failing tests (spec compliance 1): `interpolated(2).decimated(2)`
+   round-trips a smooth signal interior (rtol 1e-3); `decimated(4).dt ==
+   dt * 4` exactly (PrecisionTime equality); `resampled_to_match` yields
+   matching `dt` and length within ±1; polyphase 3:2 length check.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Round-trip and exact-dt tests pass
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Time alignment (26); `value_at_time` (already in core).
+
+## Resolution notes
+
+- **Forced contract change: `WaveformProtocol` gained a second factory,
+  `_with_axis(values, dt) -> WaveformProtocol`.** Every mixin through chunk
+  24 builds its results via `_with_values(values)`, which carries `self`'s
+  `dt`/`t0` forward unchanged — sufficient because none of those families
+  ever change the sample spacing. `ResamplingMixin` is the first that does
+  (`decimated`/`interpolated`/`resampled`/`polyphase_resampled` all compute
+  a new `dt`), and the acceptance criterion "`decimated(4).dt == dt * 4`
+  exactly" is unsatisfiable through `_with_values` alone. Added `_with_axis`
+  to `dsp/_protocol.py`'s `WaveformProtocol` and implemented it on
+  `Waveform1D` (`waveforms/waveform1d.py`, alongside `_with_values`); `t0`
+  is not a parameter (every method here leaves `t0` unchanged, per the
+  design constraints). Per the 00-overview.md convention ("if implementation
+  forces a contract change, update the spec in the same chunk and bump its
+  semver"), `waveformDsp.md` §Organization documents the addition and its
+  semver was bumped 0.0.3 → 0.0.4. This is the only file touched outside
+  this chunk's own `Files` list.
+- **`decimated` uses `scipy.signal.decimate(..., ftype="fir")`, not the
+  default `ftype="iir"`.** The default Chebyshev-I IIR anti-alias filter's
+  ~0.05 dB passband ripple, doubled by zero-phase `sosfiltfilt`, produced
+  ~1.1% amplitude error even deep in the passband on a 5 Hz sine sampled at
+  1 kHz — enough to blow the `interpolated(2).decimated(2)` round-trip's
+  `rtol=1e-3` acceptance bound. The FIR variant (linear-phase, near-flat
+  passband) round-trips to ~1e-6 on the same signal and, as a side benefit,
+  tolerates much shorter inputs (its padding requirement scales with taps
+  rather than a fixed ~27-sample IIR minimum). `decimated(factor)`'s public
+  signature is unchanged — this is an internal default choice, not an
+  exposed parameter — so it stays within the spec's `decimated(factor)`
+  surface.
+- **`interpolated`'s four kernels:** `LINEAR`/`NEAREST` use `np.interp`-style
+  sample-index interpolation directly; `CUBIC` uses
+  `scipy.interpolate.CubicSpline`; `FOURIER` uses `scipy.signal.resample`.
+  All four produce `(n - 1) * factor + 1` samples (endpoints preserved),
+  matching the Swift reference's insert-between-samples scheme rather than
+  `scipy.signal.resample`'s periodic/`n * factor` convention.
+  `resampled`/`resampled_to_match`/`polyphase_resampled` are unaffected
+  (they always use FFT/polyphase resampling per the spec's Backing column).
+- **`resampled(target_frequency_hz)`** computes the achieved sample count as
+  `round(sample_count * target_frequency_hz / sampling_frequency_hz)` and
+  derives `dt` from that achieved count (`dt * sample_count /
+  achieved_count`) rather than `1 / target_frequency_hz` — matches the
+  design constraint ("`resampled(hz)` derives dt from the achieved rate")
+  and the `scipy.signal.resample` input/output-length/sample-rate
+  relationship. `resampled_to_match(other)` is a thin wrapper calling the
+  same helper with `other.sampling_frequency_hz`.
+- All TDD-step scenarios pass as written: `interpolated(2).decimated(2)`
+  round-trips a 2000-sample, 5 Hz sine's interior to `rtol=1e-3` (both
+  `LINEAR` and `CUBIC` kernels tested); `decimated(4).dt == dt * 4` exactly
+  (`PrecisionTimeInterval` equality); `resampled_to_match` yields matching
+  `dt` (6 decimal places) and length within ±1 of `other`'s; polyphase 3:2
+  length matches `ceil(n * 3 / 2)` against `scipy.signal.resample_poly`'s
+  actual output.
+- 30 new tests in `tests/waveforms/dsp/test_resampling.py`; full gate
+  (`make uv-fullCheck`) green at 1029 passed, ruff clean, mypy strict clean.
diff --git a/.claude/archive/math-tools-port/26-dsp-time-alignment.md b/.claude/archive/math-tools-port/26-dsp-time-alignment.md
new file mode 100644
index 0000000..cea9b9a
--- /dev/null
+++ b/.claude/archive/math-tools-port/26-dsp-time-alignment.md
@@ -0,0 +1,147 @@
+---
+chunk: 26-dsp-time-alignment
+track: D
+status: complete
+depends_on: [14, 19]
+spec: ../specs/waveformDsp.md §Family contracts (TimeAlignmentMixin), §Compliance 1–2
+last_updated: 2026-07-17
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 26 — `TimeAlignmentMixin`
+
+**Deliverable:** `dsp/_time_alignment.py` + tests. Swift reference:
+`SWIFT_MATH/Waveform1D/Extensions/Waveform1D+TimeAlignment.swift`.
+
+## Files
+
+Create `src/math_tools/waveforms/dsp/_time_alignment.py`,
+`tests/waveforms/dsp/test_time_alignment.py`. Test-subclass note: this
+mixin's CORRELATION method calls the correlation surface, so the test
+subclass composes both: `class _W(TimeAlignmentMixin, CorrelationMixin,
+Waveform1D)`.
+
+## Design constraints
+
+- Methods per spec table: `aligned(to, method: WaveformAlignmentMethod =
+  CORRELATION)` (shift by detected lag; START_TIME aligns `t0`s),
+  `time_lag(to, max_lag=None) -> WaveformTimeLag | None` (None when no
+  correlation peak qualifies), classmethod
+  `synchronize(waveforms) -> list[Waveform1D]` (common overlapping span),
+  `time_windows(window_duration, overlap=0.0) -> list[Waveform1D]`,
+  `time_segments(boundaries) -> list[Waveform1D]`.
+- Exception to the no-sibling-imports rule (documented in the spec's mixin
+  rules as "via CorrelationMixin"): this mixin may TYPE against the
+  protocol + call `self.cross_correlation`/`find_max_correlation` — declare
+  those on a small local `Protocol` extension rather than importing
+  `_correlation`, keeping module-level imports clean.
+
+## TDD steps
+
+1. Failing tests: `aligned` recovers a k-sample shift (result lag 0
+   afterward); `synchronize` of two offset waveforms returns equal-length
+   overlaps with matching `t0`; `time_windows(1.0, overlap=0.5)` count
+   formula pinned; segment boundaries respected.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Shift-recovery and synchronize tests pass
+- [x] No `import ... _correlation` at module level (grep)
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Resampling to a common rate (25's `resampled_to_match`).
+
+## Resolution notes
+
+- **Forced contract change: `WaveformProtocol` gained a third factory,
+  `_with_t0(values, t0) -> WaveformProtocol`.** Every method in this chunk
+  (`aligned`, `synchronize`, `time_windows`, `time_segments`) produces a
+  result with the same `dt` as its source but a genuinely different `t0` —
+  a shape neither existing factory covers (`_with_values`: same `dt`, same
+  `t0`; `_with_axis`: new `dt`, same `t0`, added by chunk 25). Added
+  `_with_t0` to `dsp/_protocol.py`'s `WaveformProtocol` and implemented it
+  on `Waveform1D` (`waveforms/waveform1d.py`), giving the three factories a
+  complete same-dt/same-t0 triangle. Per the 00-overview.md convention,
+  `waveformDsp.md` §Organization documents the addition and its semver was
+  bumped 0.0.4 → 0.0.5. `_protocol.py` and `waveform1d.py` are the only
+  files touched outside this chunk's own `Files` list.
+- **`time_lag` is deliberately `t0`-aware, unlike `CorrelationMixin.
+  find_max_correlation`.** `find_max_correlation` is a pure value-domain
+  measure — it correlates `values` arrays and never looks at either
+  waveform's `t0`. That's correct for "how similar are these sample
+  arrays," but wrong for a method named `time_lag` living in a mixin about
+  time-axis reasoning: two waveforms whose `t0`s already differ can have
+  identical values (raw lag 0) yet clearly occur at different real times.
+  `TimeAlignmentMixin.time_lag` (via the module-level `_correlating_time_lag`
+  helper) adds the existing `t0` offset between the two waveforms (rounded
+  to the nearest sample) to the raw value-domain lag `find_max_correlation`
+  returns, producing a genuine real-world sample/second offset. This is
+  also what makes `aligned`'s `CORRELATION` method a true round trip:
+  shifting `t0` by `-lag_samples * dt` always drives a second `time_lag`
+  call back to lag 0 (the pinned "result lag 0 afterward" acceptance
+  criterion) — a purely value-domain lag could not guarantee that once the
+  two waveforms' `t0`s already differ, since shifting `t0` alone never
+  touches the values `find_max_correlation` looks at. Verified directly:
+  `TestAlignedCorrelationRecoversKnownShift` pins the round trip for k in
+  {0, 3, 17} sample shifts, and `TestTimeLagAccountsForExistingT0Offset`
+  pins the `t0`-offset-only case (identical values, different `t0`) against
+  a raw `find_max_correlation` call that would report lag 0 for the same
+  inputs.
+- **Correlation-mixin cross-reference without importing `_correlation`.**
+  Per the design constraint, `aligned`'s `CORRELATION` method and `time_lag`
+  need `CorrelationMixin.find_max_correlation` but must not import
+  `dsp/_correlation.py` (waveformDsp.md §Organization / §Compliance 2, "no
+  sibling mixin imports"). Declared a small local `Protocol` extension,
+  `_CorrelatingWaveform(WaveformProtocol, Protocol)`, naming only the
+  `find_max_correlation` signature needed; any host composing both mixins
+  (this chunk's own `_W(TimeAlignmentMixin, CorrelationMixin, Waveform1D)`
+  test subclass, and `Waveform1D` from the compose chunk onward) satisfies
+  it structurally. `tests/test_package_layering.py::
+  test_dsp_mixins_do_not_import_sibling_mixins` (a static AST scan) and a
+  manual grep both confirm no `_correlation` import exists in the module.
+  `find_max_correlation`/`time_lag` are called through a module-level
+  helper (`_correlating_time_lag`), not a same-class `self.time_lag(...)`
+  call from `aligned` — matching every other DSP mixin's internal-sharing
+  convention of module-level helpers over same-class method calls (e.g.
+  `dsp/_resampling.py`'s `_resample_to_frequency`).
+- **Chunk 19's import-cycle risk (point 4 of this chunk's brief): still
+  latent, not triggered.** This mixin imports `WaveformAlignmentMethod`/
+  `WaveformTimeLag` from `waveforms/support.py`, which imports
+  `waveforms/waveform1d.py` — the same shape chunk 19 flagged for
+  `_correlation.py`. `waveform1d.py` still does not import back into
+  `dsp/` (mixins compose in a later chunk, 30), so no cycle exists today;
+  documented again in the module docstring per the brief's instruction to
+  report rather than silently work around it.
+- **`time_segments(boundaries)` and `time_windows(window_duration,
+  overlap)` take float-seconds arguments** (relative to `t0`), not sample
+  indices or `PrecisionTimestamp`s — the spec table's `time_windows(...)`/
+  `time_segments(...)` entries were intentionally abbreviated (matching
+  other family-contract rows with optional-heavy signatures); the concrete
+  signatures are pinned by this chunk's own tests.
+  `time_windows`/`time_segments` are not detectors (waveformDsp.md
+  §Numerical conventions), so both raise `ValueError` (naming the
+  requirement) rather than returning `[]` when the input is too short —
+  `time_windows` when even one window doesn't fit, `time_segments` when the
+  waveform is empty or a boundary falls outside the open span
+  `(0, duration_seconds)`.
+- **`synchronize` does not resample mismatched-rate inputs**, unlike the
+  Swift reference's `resampleToCommonRate` option — matching this chunk's
+  own Out of scope note ("Resampling to a common rate" is chunk 25's
+  `resampled_to_match`, not this one's). Every input to `synchronize` must
+  already share the same `dt`; a mismatch raises `WaveformCompatibilityError`.
+- Bug caught by the TDD run itself (not by inspection): `time_segments`'s
+  first implementation zipped `split_points` against `split_points[1:]`
+  with `strict=True`, added defensively for ruff's B905 ("zip without an
+  explicit strict= parameter"). Since that pairwise idiom's two sequences
+  are intentionally offset by one element, `strict=True` made every
+  non-trivial call raise `ValueError: zip() argument 2 is shorter than
+  argument 1`. Fixed to `strict=False`, which still satisfies B905 (an
+  explicit value was given) while preserving the intended pairwise
+  semantics.
+- 26 new tests in `tests/waveforms/dsp/test_time_alignment.py`; full gate
+  (`make uv-fullCheck`) green: ruff clean, mypy strict clean (70 source
+  files), 1055 passed.
diff --git a/.claude/archive/math-tools-port/27-dsp-triggers.md b/.claude/archive/math-tools-port/27-dsp-triggers.md
new file mode 100644
index 0000000..983ffb2
--- /dev/null
+++ b/.claude/archive/math-tools-port/27-dsp-triggers.md
@@ -0,0 +1,117 @@
+---
+chunk: 27-dsp-triggers
+track: D
+status: complete
+depends_on: [14]
+spec: ../specs/waveformDsp.md §Family contracts (TriggerMixin), §Compliance 1–2
+last_updated: 2026-07-17
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 27 — `TriggerMixin`
+
+**Deliverable:** `dsp/_triggers.py` + tests. Swift reference:
+`SWIFT_MATH/Waveform1D/Extensions/Waveform1D+TriggerDetection.swift`.
+
+## Files
+
+Create `src/math_tools/waveforms/dsp/_triggers.py`,
+`tests/waveforms/dsp/test_triggers.py`. Test-subclass pattern per chunk 18.
+
+## Design constraints
+
+- Methods per spec table: `detect_edge_triggers(level, edge:
+  WaveformEdgeType)` (sign-change of `values - level`, RISING/FALLING/BOTH),
+  `detect_level_triggers(level, ...)`, `detect_window_triggers(low, high,
+  kind: WaveformWindowTriggerType)` (ENTER/EXIT of the band),
+  `detect_pattern_triggers(pattern, tolerance)` (sliding-window match),
+  generic `detect_triggers(trigger: WaveformTrigger)` dispatching on
+  `trigger.kind`, `with_event_markers(events) -> WaveformWithEvents`.
+- All detectors return `list[WaveformTriggerEvent]`, empty on no-hit;
+  events carry index, `time_seconds`, value, kind.
+
+## TDD steps
+
+1. Failing tests: square wave — rising-edge count == cycle count, falling
+   likewise, BOTH is their sum; window ENTER/EXIT pair up on a sine
+   crossing a band; pattern trigger finds an embedded motif at the planted
+   indices; no-hit → [].
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Square-wave edge counts exact; pattern indices exact
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Zero crossings (29 — level 0 lives there); peak detection (23).
+
+## Resolution notes
+
+- **Design constraints followed as written** (the chunk file already used the
+  post-chunk-18 self-typed-``WaveformProtocol`` idiom, not nominal Protocol
+  inheritance, so no rewrite was needed there).
+- **`detect_level_triggers`** shares `detect_edge_triggers`'s sign-change
+  machinery (same private `_sign_change_events` helper), distinguished only
+  by the `WaveformTriggerType` tag stamped on the resulting events and its
+  default direction (`RISING` vs. `EDGE`'s `BOTH`) — the spec's `EDGE`/
+  `LEVEL` split reads as a provenance/intent tag, not two different
+  detection algorithms (the Swift reference's own `evaluateLevelTrigger` is
+  likewise a plain threshold comparison).
+- **Forced contract change, `waveforms/support.py` (semver 0.0.5 → 0.0.6),
+  touched even though it is outside this chunk's literal "Files" list** —
+  same escape hatch chunks 25/26 used for `dsp/_protocol.py`'s factories:
+  1. `WaveformTrigger` gained two optional fields, `edge: WaveformEdgeType
+     | None` and `window_kind: WaveformWindowTriggerType | None`, both
+     defaulting to `None`. Without them, the generic `detect_triggers`
+     dispatcher had no way to read the direction/enter-exit selector a
+     `WaveformTrigger` should carry for `EDGE`/`LEVEL`/`WINDOW` kinds — the
+     direct `detect_edge_triggers`/`detect_level_triggers`/
+     `detect_window_triggers` methods take it as an explicit argument, but
+     nothing on the dataclass could express it before this change.
+     Backward-compatible: every existing `WaveformTrigger(...)` call site
+     (including `tests/waveforms/test_support.py`) omits both new fields and
+     is unaffected; dispatch falls back to `BOTH`/`RISING`/`ENTER`
+     respectively when unset.
+  2. `WaveformWithEvents.waveform` is now typed `WaveformProtocol`
+     (`dsp/_protocol.py`), not the concrete `Waveform1D` it held through
+     chunk 26. `with_event_markers` is the first mixin method that has to
+     embed `self` itself into a returned descriptor; every earlier
+     descriptor only ever held *derived* values. Since mixins type `self` as
+     `WaveformProtocol` and must never import `Waveform1D` — not even under
+     `TYPE_CHECKING`, per `dsp/_protocol.py`'s own docstring — a field typed
+     concrete `Waveform1D` was unsatisfiable from `_triggers.py` without
+     breaking that rule. Retyping the field to the already-`Waveform1D`-
+     satisfying structural protocol resolves this and, as a side effect,
+     removes `support.py`'s only import of `waveforms/waveform1d.py` —
+     closing off what would otherwise become a real circular import once
+     the chunk-30 compose step makes `waveform1d.py` import every mixin
+     (mixins already import `support.py`; `support.py` importing
+     `waveform1d.py` back would have completed the cycle). Not exercised by
+     this chunk's own tests, but `tests/waveforms/test_support.py`'s
+     existing `WaveformWithEvents` construction/mutation/slots assertions
+     continue to pass unchanged (a `Waveform1D` instance still satisfies the
+     field at runtime).
+  3. `.claude/specs/waveformDsp.md` §Support descriptor types updated to
+     describe both changes; spec semver bumped 0.0.5 → 0.0.6.
+- **`detect_triggers` never calls `self.detect_edge_triggers(...)` etc.**
+  Each `detect_*` method's shared sign-change/window/pattern logic lives in
+  a private module-level function (`_sign_change_events`,
+  `_window_trigger_events`, `_pattern_trigger_events`) that both the direct
+  method and `detect_triggers`'s dispatch call directly — a same-class
+  `self.<sibling method>(...)` call would not type-check under mypy strict
+  (`self: WaveformProtocol` does not declare this mixin's own methods),
+  mirroring `dsp/_time_alignment.py`'s `_correlating_time_lag` /
+  `dsp/_resampling.py`'s `_resample_to_frequency` precedent. Caught by
+  running `make uv-typecheck` during implementation, not by inspection.
+- **Pattern matching uses elementwise tolerance** (`max(abs(segment -
+  pattern)) <= tolerance`), not the Swift reference's normalized-correlation
+  `threshold` — deterministic and exact for the "finds the planted motif at
+  the planted indices" acceptance criterion, and the spec's "scipy/better-
+  tested semantics win" allowance applies equally to a better-specified
+  numpy equivalent.
+- `make uv-fullCheck` verified clean: ruff (`All checks passed!`), mypy
+  strict (`Success: no issues found in 72 source files`), pytest (1087
+  passed, including 32 new tests in `tests/waveforms/dsp/test_triggers.py`).
diff --git a/.claude/archive/math-tools-port/28-dsp-windowing.md b/.claude/archive/math-tools-port/28-dsp-windowing.md
new file mode 100644
index 0000000..718cf25
--- /dev/null
+++ b/.claude/archive/math-tools-port/28-dsp-windowing.md
@@ -0,0 +1,93 @@
+---
+chunk: 28-dsp-windowing
+track: D
+status: complete
+depends_on: [14]
+spec: ../specs/waveformDsp.md §Family contracts (WindowingMixin), §Compliance 1–2
+last_updated: 2026-07-17
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 28 — `WindowingMixin`
+
+**Deliverable:** `dsp/_windowing.py` + tests. Swift reference:
+`SWIFT_MATH/Waveform1D/Extensions/Waveform1D+Windowing.swift`.
+
+## Files
+
+Create `src/math_tools/waveforms/dsp/_windowing.py`,
+`tests/waveforms/dsp/test_windowing.py`. Test-subclass pattern per chunk 18.
+
+## Design constraints
+
+- Methods per spec table: `windowed(window: WaveformWindowType)`
+  (elementwise multiply), staticmethods `generate_window(window, length)
+  -> npt.NDArray` (`scipy.signal.get_window`; KAISER takes a beta default
+  matching the Swift parameterization — read the Swift enum first),
+  `window_coherent_gain(window) -> float` (mean of the window),
+  `window_processing_gain(window) -> float`.
+
+## TDD steps
+
+1. Failing tests: RECTANGULAR `windowed` is identity; HANN endpoints ≈ 0 and
+   midpoint ≈ 1; coherent gain of HANN ≈ 0.5 (rtol 1e-2 for finite length);
+   every `WaveformWindowType` member generates without error.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] All enum members covered; HANN gain test passes
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Spectral methods' internal window use (21 handles its own).
+
+## Resolution notes
+
+- Implemented `WindowingMixin` in `src/math_tools/waveforms/dsp/_windowing.py`
+  per chunk 18's mixin-typing fix (§Organization): plain class, `self` typed
+  `WaveformProtocol` on each instance method, `generate_window` a
+  `@staticmethod` — not `class WindowingMixin(WaveformProtocol)`. The chunk
+  file's own reference (Swift extension) predates that fix; followed the
+  merged convention instead, per this chunk's own instructions.
+- `scipy.signal.get_window` is called with `fftbins=False` (symmetric, not
+  periodic) — this is what makes the TDD step's HANN acceptance criterion
+  literally true (endpoints exactly 0.0, an odd-length midpoint sample
+  exactly 1.0); the default periodic (`fftbins=True`) form does not have
+  that property and is what `dsp/_spectral.py` uses for its own STFT-frame
+  purpose. Verified numerically before committing to this choice.
+- `WaveformWindowType.KAISER` carries no `beta` field (flat `str` enum,
+  unlike the Swift `.kaiser(beta:)` associated value), and the chunk's own
+  `generate_window(window, length) -> npt.NDArray` signature exposes none
+  either — fixed one default beta (`14.0`), independently declared (not
+  imported) but numerically matching `dsp/_spectral.py`'s own independent
+  default for the same reason (comparable sidelobe suppression to
+  Blackman). No spec change needed; `waveformDsp.md` already documents
+  `WaveformWindowType` as a flat enum and doesn't promise a `beta`
+  parameter on `generate_window`.
+- The enum->scipy-name map deliberately duplicates a few lines already
+  present in `dsp/_spectral.py` rather than sharing them, per chunk 21's own
+  documented design constraint (§Organization / §Compliance 2: no sibling
+  mixin imports) and this chunk's item 4 instruction not to unify the two.
+- `window_coherent_gain`/`window_processing_gain` are instance methods
+  (mean / RMS of `generate_window` at `self`'s own sample count), matching
+  the Swift reference's `windowCoherentGain(for:)`/`windowProcessingGain(for:)`
+  and the family-contract table (only `generate_window` is called out as a
+  staticmethod).
+- No new result-factory needed: `windowed` reuses `_with_values` (same
+  `dt`/`t0`, new samples) — no contract change to `waveformDsp.md` was
+  required.
+- `windowed`/`window_coherent_gain`/`window_processing_gain` raise
+  `ValueError` on an empty (0-sample) waveform, and `generate_window` raises
+  `ValueError` for `length <= 0` — per §Numerical conventions (these are not
+  detector methods).
+- Gate: `make uv-fullCheck` green (ruff clean, mypy strict clean over
+  `src`+`tests`, pytest 1102 passed, including the 15 new tests in
+  `tests/waveforms/dsp/test_windowing.py` and the existing
+  `test_dsp_mixins_do_not_import_sibling_mixins` layering test, which
+  confirms `_windowing.py` imports only scipy/numpy plus
+  `_protocol`/`support`).
+- No deviation from the chunk beyond following the already-merged chunk 18
+  mixin-typing fix as instructed.
diff --git a/.claude/archive/math-tools-port/29-dsp-zero-crossings.md b/.claude/archive/math-tools-port/29-dsp-zero-crossings.md
new file mode 100644
index 0000000..5a15be4
--- /dev/null
+++ b/.claude/archive/math-tools-port/29-dsp-zero-crossings.md
@@ -0,0 +1,88 @@
+---
+chunk: 29-dsp-zero-crossings
+track: D
+status: complete
+depends_on: [14]
+spec: ../specs/waveformDsp.md §Family contracts (ZeroCrossingMixin), §Compliance 1–2
+last_updated: 2026-07-17
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 29 — `ZeroCrossingMixin`
+
+**Deliverable:** `dsp/_zero_crossings.py` + tests. Swift reference:
+`SWIFT_MATH/Waveform1D/Extensions/Waveform1D+ZeroX.swift`.
+
+## Files
+
+Create `src/math_tools/waveforms/dsp/_zero_crossings.py`,
+`tests/waveforms/dsp/test_zero_crossings.py`. Test-subclass pattern per
+chunk 18.
+
+## Design constraints
+
+- Methods per spec table: `zero_crossings(direction:
+  WaveformZeroCrossingDirection = BOTH) -> list[WaveformZeroCrossing]`
+  (sign-change indexing + sub-sample linear interpolation for
+  `time_seconds`), `zero_crossing_count(direction=BOTH)`,
+  `zero_crossing_rate() -> float` (crossings per second),
+  `segments_between_zero_crossings() -> list[Waveform1D]` (each segment
+  carries a correctly shifted `t0`).
+- Exact zeros count once; empty list on no-hit.
+
+## TDD steps
+
+1. Failing tests (spec compliance 1): f-Hz sine over an integer number of
+   periods → `zero_crossing_rate() == 2f` ± one crossing; POSITIVE +
+   NEGATIVE counts sum to BOTH; sub-sample interp: crossing of a line
+   `y = t − 0.5` lands at 0.5 s (atol dt/100); segments' t0s are
+   monotonically increasing and lengths sum to ≈ n.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Rate and sub-sample interpolation tests pass
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Trigger detection (27).
+
+## Resolution notes
+
+- Implemented per the chunk's own Design constraints, using
+  `dsp/_triggers.py`'s `_sign_change_events` sign-change-mask technique
+  (`previous <= 0 & current > 0` for rising, mirrored for falling) at
+  `level=0`, plus a per-crossing linear-interpolation refinement step for
+  `time_seconds`. "Exact zeros count once" falls out of that same
+  non-strict/strict split used by the trigger mixin: a sample sitting
+  exactly on zero can only ever be the *departed* side of one crossing,
+  never both.
+- Mixin follows the chunk-18 self-typing idiom exactly (`class
+  ZeroCrossingMixin:` with `self: WaveformProtocol` per method); no nominal
+  `Protocol` inheritance. Only the two already-merged factories were
+  needed: `segments_between_zero_crossings` uses `_with_t0` (same `dt`, new
+  `t0` per segment); no fourth factory was required.
+- `zero_crossing_count`/`zero_crossing_rate` both took on an optional
+  `direction: WaveformZeroCrossingDirection = BOTH` parameter beyond the
+  chunk's literal `zero_crossing_rate() -> float` text, matching the Swift
+  reference's `zeroCrossingRate(direction:)` overload and this mixin's own
+  `zero_crossings(direction=...)`. This is a backward-compatible superset
+  (the chunk's own `zero_crossing_rate()` call still works via the
+  default) rather than a contract narrowing, so no spec edit/semver bump
+  was needed for it.
+- `segments_between_zero_crossings` mirrors the Swift reference's
+  *inclusive*-range segmentation (`values[startIdx...endIdx]`), not
+  `dsp/_time_alignment.py`'s exclusive/non-overlapping split — each
+  interior crossing sample is shared by the two segments it borders, which
+  is what makes "lengths sum to ≈ n" (not exactly `n`) true, matching the
+  chunk's own TDD wording. Return type is `list[WaveformProtocol]`
+  (self-typed), not the spec table's descriptive `list[Waveform1D]` — same
+  established discrepancy already present for `TimeAlignmentMixin.
+  synchronize`/`time_windows`/`time_segments` in the same spec table; no
+  spec change needed.
+- No surprises during implementation; all 14 new tests passed on the first
+  run against the initial implementation, and `make uv-fullCheck` (ruff +
+  mypy strict + full 1116-test pytest suite, including the sibling-import
+  layering test) passed clean.
diff --git a/.claude/archive/math-tools-port/30-dsp-compose.md b/.claude/archive/math-tools-port/30-dsp-compose.md
new file mode 100644
index 0000000..b7d547d
--- /dev/null
+++ b/.claude/archive/math-tools-port/30-dsp-compose.md
@@ -0,0 +1,95 @@
+---
+chunk: 30-dsp-compose
+track: D
+status: complete
+depends_on: [18, 19, 20, 21, 22, 23, 24, 25, 26, 27, 28, 29]
+spec: ../specs/waveformDsp.md §Organization (composition phasing), §Compliance 2, 4
+last_updated: 2026-07-17
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 30 — Compose the DSP mixins into `Waveform1D`
+
+**Deliverable:** the one-time base-list edit plus the MRO/layering pins.
+Runs ONLY after chunks 18–29 are all done.
+
+## Files
+
+- Edit: `src/math_tools/waveforms/waveform1d.py` (base list + imports only)
+- Edit: `src/math_tools/waveforms/dsp/__init__.py` (export the 12 mixins)
+- Create: `tests/waveforms/dsp/test_compose.py`
+- Edit: `tests/waveforms/dsp/test_*.py` — remove the per-chunk local test
+  subclasses (`class _W(XMixin, Waveform1D)`) in favor of plain `Waveform1D`
+  (mechanical; assertions unchanged)
+
+## Design constraints
+
+1. Base list exactly as the spec's Organization block (12 mixins then
+   `Waveform1dABC`); no other change to the class body.
+2. `test_compose.py` pins: each of the 12 mixins appears in
+   `Waveform1D.__mro__` exactly once; `Waveform1D.__abstractmethods__ ==
+   frozenset()`; `Waveform1D([1.0, 2.0])` constructs; one smoke call per
+   family on a short sine (e.g. `.fft()`, `.detect_peaks()`, …) succeeds.
+3. Layering pin (spec compliance 2): each `dsp/_*.py` module's imports are
+   scipy/numpy/stdlib/`_protocol`/`_common` only — extend
+   `tests/test_package_layering.py` with this rule if chunk 02's version
+   doesn't already cover `dsp/`.
+
+## TDD steps
+
+1. Write `test_compose.py` first (fails: mixins not composed).
+2. Make the base-list edit; simplify the per-chunk test subclasses.
+3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] MRO test passes; every DSP family callable directly on `Waveform1D`
+- [x] `grep -rn "class _W(" tests/waveforms/dsp/` → no hits
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Any mixin behavior change — if a compose-time conflict (name collision
+between mixins) appears, STOP and report; resolution is a spec decision.
+
+## Resolution notes
+
+- Base-list edit landed exactly as the spec's Organization block (12
+  mixins, `Waveform1dABC` last); `waveform1d.py` imports each mixin module
+  directly (not via `dsp/__init__.py`), keeping the compose step's own
+  import graph minimal.
+- `dsp/__init__.py` now imports and re-exports all twelve mixins (`__all__`)
+  per this chunk's file list — this surfaced a genuine circular import (not
+  the one chunks 19/26/27 had already preempted): populating
+  `dsp/__init__.py` means importing *any* `dsp/_*` submodule now also runs
+  `dsp/__init__.py` first, which imports every mixin, several of which
+  import back into `waveforms/support.py`; `support.py` itself imports
+  `dsp._protocol.WaveformProtocol` at module scope (chunk 27, for the
+  `WaveformWithEvents.waveform` field annotation only). That produced
+  `import support.py` → `dsp/__init__.py` → `dsp/_correlation.py` →
+  `support.py` (still mid-import) → `ImportError: cannot import name
+  'WaveformTimeLag' from partially initialized module`.
+  - **Fix:** moved `support.py`'s `WaveformProtocol` import under `if
+    TYPE_CHECKING:`. Safe because `support.py` already has `from
+    __future__ import annotations`, so the field annotation that uses
+    `WaveformProtocol` is never evaluated at runtime — only mypy needs the
+    import, and mypy resolves `TYPE_CHECKING` imports without executing
+    them. This is the *opposite* direction from the import `dsp/_protocol.py`
+    forbids even under `TYPE_CHECKING` (a mixin importing `Waveform1D`); a
+    support module importing the mixins' shared protocol under
+    `TYPE_CHECKING` isn't that case and doesn't reopen it.
+- `tests/test_package_layering.py::test_dsp_mixins_do_not_import_sibling_mixins`
+  globs `dsp/_*.py`, which also matches `dsp/__init__.py` (`__` starts with
+  `_`) — before this chunk that was harmless (the file was import-free), but
+  once it re-exports every mixin the test flagged it as a "sibling-mixin
+  import" violation. `dsp/__init__.py` is not a mixin module — from this
+  chunk onward it is *expected* to import every mixin — so the test now
+  explicitly excludes `__init__.py` from that specific check. The mixin
+  modules themselves are still fully covered (unchanged).
+- No mixin name collisions found composing all twelve; no mixin behavior
+  was touched.
+- `waveformDsp.md` bumped to semver 0.0.7 documenting both resolutions;
+  `tests/waveforms/dsp/test_*.py` (12 files) mechanically dropped their
+  local `class _W(XMixin, Waveform1D): pass` subclasses in favor of plain
+  `Waveform1D` (assertions unchanged), matching the now-composed class.
diff --git a/.claude/archive/math-tools-port/31-otg-enums-and-errors.md b/.claude/archive/math-tools-port/31-otg-enums-and-errors.md
new file mode 100644
index 0000000..47db3a1
--- /dev/null
+++ b/.claude/archive/math-tools-port/31-otg-enums-and-errors.md
@@ -0,0 +1,79 @@
+---
+chunk: 31-otg-enums-and-errors
+track: E
+status: complete
+depends_on: [10]
+spec: ../specs/otg.md §Public API (enums), §Error semantics; §Compliance 3, 4
+last_updated: 2026-07-21
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 31 — OTG enums + errors
+
+**Deliverable:** the OTG package skeleton with wire-stable enums.
+
+## Files
+
+- Create: `src/math_tools/otg/__init__.py` (exports grow per chunk; start
+  with the enums + `OtgError`), `src/math_tools/otg/py.typed`,
+  `src/math_tools/otg/enums.py`, `src/math_tools/otg/errors.py`
+- Create: `tests/otg/__init__.py`, `tests/otg/test_enums.py`
+
+## Design constraints
+
+1. `enums.py` per spec: `Result(IntEnum)` with the exact nine values
+   (including the intentional gap at −103 — transcribe from the spec table,
+   verify against `SWIFT_MATH/OTG/enums/Result.swift`); `ControlInterface`,
+   `Synchronization`, `DurationDiscretization` (string enums);
+   internal `ControlSigns` (UDDU/UDUD), `Direction` (UP/DOWN),
+   `ReachedLimits` (8 members per the Swift enum) — internal ones may live
+   in `enums.py` but are excluded from `__all__`.
+2. `errors.py`: `OtgError(MathToolsError)` — raised only for structural
+   misuse per spec §Error semantics.
+3. Pure stdlib module (the layering test's no-numpy-in-otg rule starts
+   applying here).
+
+## TDD steps
+
+1. Failing tests: every `Result` member's integer value grep-matches the
+   spec table (write the values as literals in the test); `Result(-103)`
+   raises `ValueError` (the gap is real); `OtgError` is a `MathToolsError`.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Nine `Result` values pinned literally; the −103 gap pinned
+- [x] No numpy import anywhere under `src/math_tools/otg/`
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Every other OTG module.
+
+## Resolution notes
+
+- Transcribed all seven enums from `SWIFT_MATH/OTG/enums/*.swift` (`Result`,
+  `ControlInterface`, `Synchronization`, `DurationDiscretization`,
+  `ControlSigns`, `Direction`, `ReachedLimits`). `Result` is `enum.IntEnum`
+  (wire-stable ints); the rest are `str, enum.Enum` per the existing
+  repo convention (`waveforms/support.py`) — public string enums keep the
+  Swift raw string values verbatim (`"Position"`, `"TimeIfNecessary"`, …) for
+  `to_dict`/`from_dict` wire parity; internal enums (`ControlSigns`,
+  `Direction`, `ReachedLimits`) live in `enums.py` but are excluded from
+  `__all__`, matching Swift's `internal` visibility.
+- `otg/__init__.py` re-exports only the four public enums + `OtgError` this
+  chunk introduces; the flat `math_tools` root `__init__.py` is left
+  untouched (still empty — curating it is chunk 43's job per
+  mathToolsArchitecture.md §Public surface).
+- `tests/test_package_layering.py::test_otg_does_not_import_numpy` was
+  already written (guarded to skip until `math_tools/otg` exists) by an
+  earlier chunk; it now runs for real against this package and passes with
+  no changes needed to that test file.
+- No spec changes were required; `otg.md` §Public API's enum table matched
+  the Swift source exactly, including the `-103` gap.
+- `tests/otg/test_enums.py` also pins the three public string enums and the
+  three internal enums (beyond the chunk's minimum TDD step) since the
+  chunk's own "Design constraints" section requires transcribing all seven
+  from the Swift source — leaving them untested would leave the fidelity
+  requirement unverified.
diff --git a/.claude/archive/math-tools-port/32-otg-input-parameter.md b/.claude/archive/math-tools-port/32-otg-input-parameter.md
new file mode 100644
index 0000000..5cf06e7
--- /dev/null
+++ b/.claude/archive/math-tools-port/32-otg-input-parameter.md
@@ -0,0 +1,91 @@
+---
+chunk: 32-otg-input-parameter
+track: E
+status: complete
+depends_on: [31]
+spec: ../specs/otg.md §Public API (InputParameter)
+last_updated: 2026-07-21
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 32 — `InputParameter`
+
+**Deliverable:** the per-cycle input struct with validation and wire codec.
+
+## Files
+
+- Create: `src/math_tools/otg/input_parameter.py`
+- Edit: `src/math_tools/otg/__init__.py` (export)
+- Create: `tests/otg/test_input_parameter.py`
+
+## Design constraints
+
+1. Field-for-field port of `SWIFT_MATH/OTG/InputParameter.swift` (read it
+   first; snake_case the names): state/target arrays, limits, optional
+   min/positional limits, `enabled`, per-DOF interface/sync overrides,
+   `intermediate_positions`, per-section arrays, `minimum_duration`,
+   `interrupt_calculation_duration`. Constructor `InputParameter(dofs)`
+   fills the Swift defaults (arrays sized to dofs).
+2. `validate(check_current_state_within_limits=False,
+   check_target_state_within_limits=True) -> bool` — port the Swift checks
+   (NaN/inf, limit positivity, target within limits, enabled handling)
+   branch-for-branch.
+3. `==` field equality; `to_dict`/`from_dict` with the camelCase keys from
+   `SWIFT_MATH/OTG/extensions/InputParameter+codable.swift` — these keys
+   MUST match the truth-table JSON corpus (chunk 42 loads it through this
+   codec).
+4. `list[float]` fields, stdlib only.
+
+## TDD steps
+
+1. Failing tests: default construction shapes; a valid input validates; each
+   invalidity class (zero max jerk, target velocity over limit, NaN) flips
+   `validate()`; `from_dict` on one literal case copied verbatim out of
+   `successful_trajectories.json` (embed the dict in the test) round-trips
+   `to_dict`.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] The embedded truth-table case parses; `==` and codec round-trip pass
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+OutputParameter/Trajectory (35); any solver logic.
+
+## Resolution notes
+
+- `validate()` returns `bool` rather than throwing, per `otg.md` §Error
+  semantics (per-cycle failures are `Result` codes, never exceptions in this
+  port -- `InputParameter.swift`'s `RuckigError` throws are the exception
+  this repo's contract explicitly carves against). Each private
+  `_validate_*` helper returns `False` at the first violation instead of
+  raising with a message, matching the checked branches 1:1 but not the
+  error text.
+- Deviation from the chunk's literal TDD wording: it lists "zero max jerk"
+  as an invalidity class, but Swift's `validateJerkLimits` only rejects
+  `jMax.isNaN || jMax < 0.0` -- zero is a legal (if degenerate) limit in the
+  Swift source. Ported that check verbatim (reject NaN/negative only) and
+  added `test_zero_max_jerk_is_legal` to pin the boundary; the "limit
+  positivity" example is instead exercised with a negative max jerk
+  (`test_negative_max_jerk_invalidates`).
+- The design constraints' parenthetical "enabled handling" does not
+  correspond to any branch in `InputParameter.swift`'s `validate()` --
+  `enabled` is read only by `CalculatorTarget.swift` (chunk 40, out of
+  scope). Ported `enabled` as a stored/equatable/codec field only, with no
+  validate() branch, matching the Swift source exactly.
+- `__eq__` is implemented as full field equality (including
+  `degrees_of_freedom` and `interrupt_calculation_duration`), which is a
+  superset of Swift's hand-written `==` (which omits both of those fields).
+  No oracle or spec text pins `InputParameter` equality semantics beyond
+  "field equality," so the simpler/more defensible full-field comparison
+  was chosen; flagging in case downstream chunks assumed the narrower
+  Swift-literal behavior.
+- `from_dict` ignores unrecognized keys (e.g. the classification corpus'
+  `"error"` string on failed cases) rather than rejecting them, so chunk 42
+  can feed corpus records straight through the codec without pre-filtering.
+- `to_dict` omits `None`-valued optional fields (mirrors Swift's
+  `encodeIfPresent`), which is what makes the truth-table round-trip
+  produce a dict `==`-equal to the embedded literal.
diff --git a/.claude/archive/math-tools-port/33-otg-profile.md b/.claude/archive/math-tools-port/33-otg-profile.md
new file mode 100644
index 0000000..232397d
--- /dev/null
+++ b/.claude/archive/math-tools-port/33-otg-profile.md
@@ -0,0 +1,136 @@
+---
+chunk: 33-otg-profile
+track: E
+status: complete
+depends_on: [31]
+spec: ../specs/otg.md §Internal fidelity 1, 4, 5
+last_updated: 2026-07-21
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 33 — `Profile`
+
+**Deliverable:** the per-DOF kinematic profile record — the hot data
+structure every step solver fills. Faithful port of
+`SWIFT_MATH/OTG/Profile.swift` (~715 lines; translate mechanically,
+preserve method and branch structure).
+
+## Files
+
+- Create: `src/math_tools/otg/profile.py`
+- Create: `tests/otg/test_profile.py`
+
+## Design constraints
+
+1. Fixed-length `list[float]` arrays `t[7]`, `t_sum[7]`, `j[7]`, `a[8]`,
+   `v[8]`, `p[8]` — never resized. Targets `pf/vf/af`; `limits:
+   ReachedLimits`, `direction: Direction`, `control_signs: ControlSigns`;
+   `brake`/`accel` BrakeProfile fields are typed as the placeholder until
+   chunk 34 lands — declare them `brake: "BrakeProfile"` with a deferred
+   import if 34 is not yet merged, or coordinate to land 34's dataclass
+   stub here (note which).
+2. Kinematic stepping uses `math_tools.functional.roots.integrate_jerk` —
+   never a fresh implementation.
+3. Port the full `check*` family (`check`, `check_for_velocity`,
+   `check_for_second_order`, `check_for_first_order`, `set_boundary`,
+   `*_with_timing` variants, `check_position_extremum`,
+   `check_step_for_position_extremum`) with the Swift epsilon constants
+   (`EPS16` etc. from `functional.roots`).
+4. Stdlib `math` only.
+
+## TDD steps
+
+1. Failing tests: a hand-constructed 7-phase profile (constant jerk ±j)
+   integrates to the expected `p/v/a` boundary arrays (compute the expected
+   values with `integrate_jerk` in the test, independent of Profile's own
+   loop ordering); `check` accepts a known-valid profile and rejects a
+   perturbed one (`t[3] += 1e-3`); `t_sum` is the prefix sum of `t`.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Boundary-array integration test passes; perturbation rejected
+- [x] `grep -n "integrate_jerk" src/math_tools/otg/profile.py` ≥ 1;
+      no local jerk-integration reimplementation
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Brake trajectory computation (34); step solvers; trajectory sampling.
+
+## Resolution notes
+
+- **BrakeProfile forward reference (for chunk 34 to reconcile):** chunk 34
+  had not landed, so `brake`/`accel` are typed as a module-private
+  `_DeferredBrakeProfile` dataclass (top of `profile.py`) rather than a
+  `TYPE_CHECKING`-guarded string forward reference to
+  `math_tools.otg.brake.BrakeProfile` -- that module doesn't exist yet, and
+  a `TYPE_CHECKING` import of a nonexistent module fails `mypy --strict`
+  even though it's runtime-inert (mypy evaluates `TYPE_CHECKING` blocks).
+  `_DeferredBrakeProfile` mirrors `Brake.swift`'s public shape exactly
+  (`duration`, `t`, `j`, `a`, `v`, `p`, with the same `[0.0, 0.0]` defaults)
+  so `Profile.__init__`'s `BrakeProfile()` defaults and
+  `Profile.set_boundary`'s `brake`/`accel` copy are both faithful without
+  needing a real instance of the future type. **Chunk 34 should**: delete
+  `_DeferredBrakeProfile` from `profile.py`, import the real `BrakeProfile`
+  from `math_tools.otg.brake`, and retype `Profile.brake`/`Profile.accel`
+  (and the `set_boundary` copy) to it -- no other call site needs to
+  change, since every chunk-33 method treats `brake`/`accel` as opaque
+  (copied, never read field-by-field).
+- **`Bound` forward reference:** `check_position_extremum` and
+  `check_step_for_position_extremum`'s `ext` parameter is typed against a
+  module-private structural `Protocol` (`_PositionExtremumSink`: `min`,
+  `max`, `t_min`, `t_max` floats) instead of importing the not-yet-landed
+  `Bound`. Since `34-otg-block-brake-bound.md` specifies `Bound` with
+  exactly those field names, the real `Bound` will satisfy this Protocol
+  automatically -- **chunk 34 does not need to touch `profile.py` for
+  this one**; the Protocol can stay indefinitely, or be swapped for a
+  direct `Bound` import later purely for readability.
+- **Epsilon constants:** `otg.md`'s "exact epsilon constants (`EPS16`
+  etc. from `functional.roots`)" guidance doesn't literally apply to
+  `Profile.swift`'s own comparisons -- that file defines its own private
+  module constants (`vEps`, `aEps`, `jEps`, `pPrecision`, `vPrecision`,
+  `aPrecision`, `tPrecision`, `tMax`), none of which exist in
+  `functional/roots.py` (`EPS16` = `16*ulp` ≈ 3.55e-15 is a different,
+  unrelated constant used only by the polynomial-root kernel). Ported
+  `Profile.swift`'s constants as verbatim module-level literals in
+  `profile.py`. The one genuine overlap is `Double.ulpOfOne`, reproduced
+  as `_ULP = sys.float_info.epsilon` (the same value `functional/roots.py`
+  keeps in its own private, non-exported `_ULP` -- not importable across
+  modules, so redefined rather than reimplemented).
+- **Swift method-overload collapsing:** Python has no positional-overload
+  dispatch. `set_boundary`'s two overloads (copy-from-`Profile` vs. six
+  scalars) differ by type, so they're ported as `@typing.overload` +
+  `isinstance` dispatch (positional-only parameters, `/`, on both overload
+  stubs -- required to satisfy `mypy --strict`'s "overloaded implementation
+  must accept all parameters of each signature" check, since the stubs'
+  first parameter names differ). Every other Swift overload pair
+  (`checkWithTiming`, `checkForVelocityWithTiming`,
+  `checkForSecondOrderVelocityWithTiming`, `checkForSecondOrderWithTiming`,
+  `checkForFirstOrderWithTiming`) differs only by one or two extra bound
+  arguments inserted before the trailing `controlSigns`/`limits`
+  parameters -- collapsed into one Python method each with the extra
+  bound(s) as trailing keyword-only optional parameters (default `None`),
+  rather than mirroring Swift's positional insertion point. This changes
+  argument order relative to the Swift signature but preserves every
+  branch exactly (guard runs only when the optional is provided, then
+  delegates to the same shorter method). The unused `tf` timing parameter
+  in every `*_with_timing` overload is kept (fidelity to the Swift
+  signature) but genuinely unused in every branch, exactly as upstream.
+- **Deferred out of scope (not in the chunk's `check*` list):**
+  `getPositionExtrema()` and `getFirstStateAtPosition()` were not ported --
+  design constraint 3 enumerates the required `check*` family explicitly
+  and both are absent from it. Both also have real dependencies this chunk
+  doesn't carry: `getPositionExtrema` reads `brake.duration`/`brake.t`
+  (meaningless against the placeholder) and aggregates across the whole
+  profile plus brake sub-profiles (a `Trajectory`-level concern, chunk 35);
+  `getFirstStateAtPosition` needs
+  `functional.polynomial.UnivariatePolynomial`'s cubic root solver, not
+  wired into this module. Flagging so a later chunk (35, trajectory
+  sampling) knows these two Swift methods still need a home.
+- All 9 `integrate_jerk` call sites replace every Swift `for i in 0..<7`
+  kinematic loop, including the "second-order"/"first-order" interfaces
+  where Swift inlines the `j == 0` special case by hand (verified
+  algebraically: `integrate_jerk(t, p0, v0, a0, 0.0)` reduces to exactly
+  Swift's `v0 + t*a0` / `p0 + t*(v0 + t*a0/2)`).
diff --git a/.claude/archive/math-tools-port/34-otg-block-brake-bound.md b/.claude/archive/math-tools-port/34-otg-block-brake-bound.md
new file mode 100644
index 0000000..8963965
--- /dev/null
+++ b/.claude/archive/math-tools-port/34-otg-block-brake-bound.md
@@ -0,0 +1,132 @@
+---
+chunk: 34-otg-block-brake-bound
+track: E
+status: complete
+depends_on: [33]
+spec: ../specs/otg.md §Internal fidelity 3–5
+last_updated: 2026-07-21
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 34 — `Block`, `BrakeProfile`, `Bound`, `Interval`
+
+**Deliverable:** the block-interval synchronization support types and the
+brake pre-trajectory. Faithful ports of `SWIFT_MATH/OTG/Block.swift`,
+`Brake.swift`, `Bound.swift`.
+
+## Files
+
+- Create: `src/math_tools/otg/block.py` (Block + Interval),
+  `src/math_tools/otg/brake.py`, `src/math_tools/otg/bound.py`
+- Edit: `src/math_tools/otg/profile.py` ONLY if chunk 33 left the
+  BrakeProfile fields as deferred placeholders (wire the real type in)
+- Create: `tests/otg/test_block.py`, `tests/otg/test_brake.py`
+
+## Design constraints
+
+1. `bound.py`: `Bound` (min/max/t_min/t_max) — plain mutable dataclass.
+2. `brake.py`: `BrakeProfile` — port `finalize`, `finalize_second_order`,
+   `acceleration_brake`, `velocity_brake`,
+   `get_position_brake_trajectory`, `get_velocity_brake_trajectory`,
+   `v_at_t`, `v_at_a_zero`, `==` branch-for-branch.
+3. `block.py`: `Block` (`p_min`, `t_min`, optional intervals `a`/`b`,
+   `calculate_block`, `is_blocked`, `get_profile`) and `Interval`
+   (`left`/`right`/`profile`). Preserve the blocked-interval selection
+   logic exactly — it drives synchronization in chunk 40.
+4. Stdlib `math` + `functional.roots` only.
+
+## TDD steps
+
+1. Failing tests: brake — a state exceeding max acceleration produces a
+   non-zero brake duration and `v_at_t(0)` equals the initial velocity;
+   a within-limits state produces an empty brake (t[0] == 0). Block —
+   `is_blocked` boundary behavior at interval edges; `get_profile` returns
+   the interval's profile for an in-interval t.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Brake zero/non-zero cases pass; interval edge cases pinned
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Step solvers; TargetCalculator.
+
+## Resolution notes
+
+- **Files landed:** `src/math_tools/otg/bound.py` (`Bound`, plain mutable
+  `@dataclass`), `src/math_tools/otg/brake.py` (`BrakeProfile`),
+  `src/math_tools/otg/block.py` (`Block` + `Interval`),
+  `tests/otg/test_bound.py` was not created separately -- `Bound` has no
+  behavior beyond its four fields and default values, so it is exercised
+  indirectly via `test_block.py`'s `Interval`/`Block` fixtures and directly
+  covered by mypy structural-Protocol satisfaction against
+  `profile.py`'s `_PositionExtremumSink` (see below); `tests/otg/test_block.py`,
+  `tests/otg/test_brake.py` created per the chunk's file list.
+- **`BrakeProfile` scope beyond the chunk's design-constraint-2 method
+  list:** also ported `get_second_order_position_brake_trajectory` and
+  `get_second_order_velocity_brake_trajectory` (present in `Brake.swift`
+  but not named in this chunk's design constraint 2). Justification:
+  otg.md's fidelity ranking puts "faithful port" first, `Brake.swift`'s
+  four `get*BrakeTrajectory` methods are all part of one cohesive public
+  surface, and the second-order velocity/position step solvers (chunks
+  36–39, not yet landed) will need the second-order brake paths — landing
+  a partial `BrakeProfile` now would force a second, disruptive edit to
+  this same file later. All four `get*BrakeTrajectory` methods, both
+  `finalize*` methods, both velocity helpers, and `==` are ported
+  branch-for-branch from `Brake.swift`.
+- **Swift `inout` parameters:** `BrakeProfile.finalize`/
+  `finalize_second_order` take `pS`/`vS`/`aS` as Swift `inout Double`;
+  Python has no by-reference scalar parameters, so both return the updated
+  `(p, v, a)` tuple instead. `Block.calculateBlock`/`Block.removeProfile`'s
+  `inout Int` (`validProfileCounter`) becomes a returned, possibly
+  decremented counter for the same reason; `block` (a class instance) and
+  `validProfiles` (a list) mutate in place as normal Python object
+  references, matching Swift's `inout` semantics for those two without any
+  signature change.
+- **Bug caught during self-review before running the gate:** an early
+  draft of `BrakeProfile.acceleration_brake` added `del a_min` to mark the
+  parameter as intentionally unused (mirroring `velocity_brake`, where
+  `aMax` truly is unused in every branch of the Swift source) — but
+  `acceleration_brake` **does** use `a_min` later, in the
+  `velocity_brake(v0, a0, v_max, v_min, a_max, a_min, j_max)` delegation
+  call. The `del` would have raised `UnboundLocalError` at runtime the
+  first time that branch executed. Caught by re-reading `Brake.swift`
+  side-by-side with the draft before writing tests; fixed by removing the
+  `del` (kept only on `velocity_brake`'s genuinely-unused `a_max`).
+- **`profile.py` reconciliation (chunk 33's deferred placeholders):**
+  - `BrakeProfile`: removed the module-private `_DeferredBrakeProfile`
+    dataclass and its now-unused `dataclasses.field`/`dataclass` imports;
+    `profile.py` now does `from math_tools.otg.brake import BrakeProfile`
+    and `Profile.brake`/`Profile.accel` are typed and constructed as the
+    real `BrakeProfile`. No other call site changed — every chunk-33
+    method already treated `brake`/`accel` as opaque (copied via
+    `set_boundary`, never read field-by-field), exactly as chunk 33's
+    Resolution notes predicted.
+  - `Bound`: **left the `_PositionExtremumSink` structural `Protocol` in
+    place**, rather than importing `math_tools.otg.bound.Bound` directly
+    into `profile.py`. Chunk 33's Resolution notes explicitly authorized
+    this ("the Protocol can stay indefinitely, or be swapped for a direct
+    `Bound` import later purely for readability"). Reasons for choosing
+    "stay" over "swap": (1) `Bound`'s fields (`min`, `max`, `t_min`,
+    `t_max`) already satisfy the Protocol structurally by construction —
+    the swap has zero behavioral or type-safety benefit; (2) swapping
+    would additionally require retyping `tests/otg/test_profile.py`'s
+    `_FakeBound` fixture (which duck-types the same Protocol) to import
+    the real `Bound`, an edit to a file outside this chunk's own file list
+    that the stay-in-scope default posture counsels against absent a
+    concrete benefit; (3) it keeps `bound.py` a leaf module with zero
+    importers inside `otg/` until `block.py`'s `Interval`/`Block` and the
+    later `Trajectory`/`TargetCalculator` chunks actually need it,
+    matching the "no import edge until there's a real dependency" spirit
+    of the original deferral. Only `profile.py`'s module docstring and the
+    `_PositionExtremumSink` class docstring were reworded (from
+    "not-yet-landed" to "why this stays a Protocol") — no code/behavior
+    change.
+- **Gate:** `make uv-fullCheck` passes (ruff clean, mypy strict clean over
+  91 source files, 1267 tests passed including the 21 new `test_block.py`
+  and 23 new `test_brake.py` cases). `grep -rn numpy src/math_tools/otg/`
+  shows no import (only doc-comment mentions), preserving otg.md's
+  compliance requirement 4.
diff --git a/.claude/archive/math-tools-port/35-otg-trajectory-and-output.md b/.claude/archive/math-tools-port/35-otg-trajectory-and-output.md
new file mode 100644
index 0000000..31a9360
--- /dev/null
+++ b/.claude/archive/math-tools-port/35-otg-trajectory-and-output.md
@@ -0,0 +1,119 @@
+---
+chunk: 35-otg-trajectory-and-output
+track: E
+status: complete
+depends_on: [34]
+spec: ../specs/otg.md §Public API (Trajectory, OutputParameter)
+last_updated: 2026-07-21
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 35 — `Trajectory` + `OutputParameter`
+
+**Deliverable:** the trajectory container/sampler and the per-cycle output
+struct. Faithful ports of `SWIFT_MATH/OTG/Trajectory.swift` and
+`OutputParameter.swift`.
+
+## Files
+
+- Create: `src/math_tools/otg/trajectory.py`,
+  `src/math_tools/otg/output_parameter.py`
+- Edit: `src/math_tools/otg/__init__.py` (export both)
+- Create: `tests/otg/test_trajectory.py`, `tests/otg/test_output_parameter.py`
+
+## Design constraints
+
+1. `Trajectory`: `profiles: list[list[Profile]]`, `duration`,
+   `cumulative_times`, `independent_min_durations`, `degrees_of_freedom`;
+   `at_time(t) -> (positions, velocities, accelerations)` (lists of float;
+   clamp to `[0, duration]` per the Swift edge handling — read `atTime`
+   first and mirror its section lookup), `position_extrema() ->
+   list[Bound]`, internal `get_intermediate_durations`,
+   `get_first_time_at_position`.
+2. `OutputParameter(dofs, max_number_of_waypoints=0)`: fields per spec
+   (`new_position/velocity/acceleration/jerk`, `time`, `new_section`,
+   `did_section_change`, `new_calculation`, `calculation_duration` in µs),
+   `pass_to_input(input)` (copies new state into the input's current
+   state — port the Swift field list exactly), `repr`.
+3. Stdlib only; sampling loops over DOFs like the Swift.
+
+## TDD steps
+
+1. Failing tests: build a single-DOF Trajectory from a hand-constructed
+   Profile (chunk 33's test fixture): `at_time(0)` == initial state,
+   `at_time(duration)` == target state (atol 1e-9), midpoint consistent
+   with `integrate_jerk`; out-of-range `t` clamps; `pass_to_input` copies
+   every kinematic field (assert against a sentinel-filled InputParameter).
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Endpoint/midpoint sampling tests pass
+- [x] `pass_to_input` field coverage pinned (loop over dofs asserting equality)
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Extrema across brake sections beyond the direct port; the driver's time
+stepping (41).
+
+## Resolution notes
+
+- **Files landed:** `src/math_tools/otg/trajectory.py` (`Trajectory`),
+  `src/math_tools/otg/output_parameter.py` (`OutputParameter`),
+  `tests/otg/test_trajectory.py`, `tests/otg/test_output_parameter.py`;
+  `src/math_tools/otg/__init__.py` now also exports `Trajectory` and
+  `OutputParameter`.
+- **`Profile.getPositionExtrema()` / `Profile.getFirstStateAtPosition()`
+  (deferred by chunk 33 to "a later chunk (35, trajectory sampling)" per
+  its Resolution notes):** ported as module-private functions in
+  `trajectory.py` (`_profile_position_extrema`,
+  `_profile_first_state_at_position`) rather than as new methods on
+  `Profile` itself. This chunk's own file list does not include
+  `profile.py`, and both functions only need `Profile`'s already-public
+  fields plus the already-public `Profile.check_step_for_position_extremum`
+  staticmethod, so no edit to `profile.py` was required. Cubic root
+  solving in `_profile_first_state_at_position` delegates to
+  `math_tools.functional.roots.solve_cubic` (never reimplemented), per
+  otg.md's "OTG chunks MUST NOT reimplement root solving."
+- **Constructor overload collapsing:** Swift's two `Trajectory` initializers
+  (`init(dofs:)` and `init(dofs:maxNumberOfWaypoints:)`) collapse into one
+  Python signature, `Trajectory(dofs, max_number_of_waypoints=0)` --
+  `maxNumberOfWaypoints=0` already produces the identical single-section
+  shape as the no-waypoints overload in the Swift source, so nothing is
+  lost. `OutputParameter(dofs, max_number_of_waypoints=0)` mirrors the same
+  collapse for its own two Swift overloads (`init(DOFs:)` /
+  `init(dofs:maxNumberOfWaypoints:)`).
+- **`at_time` clamping:** implemented by clamping the input `time` to
+  `[0, duration]` before section lookup (`max(0.0, min(time, duration))`),
+  exactly matching otg.md's own public-API text ("clamped to `[0,
+  duration]` ends per Swift") -- not a deviation, just making explicit what
+  the spec already specifies. At `time == duration` exactly, the ported
+  `stateToIntegrateFrom` branch already yields `t_diff == 0` against the
+  final boundary state, so clamping values beyond `duration` down to
+  `duration` coincides with (rather than replaces) the literal Swift
+  extrapolate-with-constant-acceleration behavior at the boundary itself;
+  it only changes behavior strictly beyond the boundary, where the spec
+  explicitly calls for clamping anyway.
+- **`Bound` import:** `trajectory.py` imports `math_tools.otg.bound.Bound`
+  directly (not the `_PositionExtremumSink` Protocol `profile.py` uses).
+  Chunk 34's Resolution notes anticipated this: the Protocol was kept in
+  `profile.py` specifically "until ... the later `Trajectory`/
+  `TargetCalculator` chunks actually need it" -- this is that real
+  dependency.
+- **Structural-misuse error convention:** `OutputParameter.__init__`
+  raises plain `ValueError` for non-positive `dofs` (matching
+  `InputParameter.__init__`'s existing precedent), not `OtgError` --
+  `OtgError` remains reserved for the `Otg` driver's own structural-misuse
+  detection (otg.md §Error semantics, chunk 41), not leaf-type constructor
+  validation. `OutputParameter.pass_to_input`'s array-size guard follows
+  the same convention.
+- **Gate:** `make uv-fullCheck` passes (ruff clean, mypy strict clean over
+  95 source files, 1290 tests passed including the 14 new
+  `test_trajectory.py` and 9 new `test_output_parameter.py` cases).
+  `grep -rn numpy src/math_tools/otg/trajectory.py
+  src/math_tools/otg/output_parameter.py` shows no import, preserving
+  otg.md's compliance requirement 4. No spec change was needed --
+  `otg.md`'s existing text already documents both the clamping behavior
+  and the module layout used here.
diff --git a/.claude/archive/math-tools-port/36-otg-velocity-steps.md b/.claude/archive/math-tools-port/36-otg-velocity-steps.md
new file mode 100644
index 0000000..cc10feb
--- /dev/null
+++ b/.claude/archive/math-tools-port/36-otg-velocity-steps.md
@@ -0,0 +1,118 @@
+---
+chunk: 36-otg-velocity-steps
+track: E
+status: complete
+depends_on: [34]
+spec: ../specs/otg.md §Internal fidelity 2, 4, 5
+last_updated: 2026-07-21
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 36 — Velocity-interface step solvers
+
+**Deliverable:** `steps/velocity_second_order.py` +
+`steps/velocity_third_order.py`. Faithful ports of
+`SWIFT_MATH/OTG/VelocitySecondOrderStep1.swift`, `...Step2.swift`,
+`VelocityThirdOrderStep1.swift`, `...Step2.swift`.
+
+## Files
+
+- Create: `src/math_tools/otg/steps/__init__.py`,
+  `src/math_tools/otg/steps/velocity_second_order.py`,
+  `src/math_tools/otg/steps/velocity_third_order.py`
+- Create: `tests/otg/steps/__init__.py`,
+  `tests/otg/steps/test_velocity_steps.py`
+
+## Design constraints
+
+1. One class per Swift class, same names (`VelocityThirdOrderStep1` etc.),
+   same method names snake_cased, same branch structure — translate
+   mechanically; the case analysis encodes the Ruckig profile taxonomy and
+   must stay diffable against the Swift.
+2. Roots/epsilons exclusively from `math_tools.functional.roots`.
+3. Step1 computes the time-optimal profile (fills a `Profile`); Step2
+   computes a profile for a prescribed duration. Keep the
+   `check`-based validation flow (Profile methods from chunk 33).
+
+## TDD steps
+
+1. Failing tests (analytic, hand-derived in test comments): third-order
+   velocity change Δv under jerk limit j and accel limit a — when
+   `Δv ≥ a²/j` the optimal profile is trapezoidal-acceleration with
+   `t = Δv/a + a/j` total; when `Δv < a²/j` it is triangular with
+   `t = 2·sqrt(Δv/j)`. Pin both regimes and the profile's boundary arrays;
+   second-order (no jerk limit) `t = Δv/a`. Step2: prescribed duration
+   1.5× optimal yields a valid profile hitting the target velocity.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Both analytic regimes pinned for third order; second order pinned
+- [x] Class/method names diff-mappable to the Swift files (reviewer spot-check)
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Position-interface steps (37–39); synchronization.
+
+## Resolution notes
+
+- **Struct-value-copy semantics (the load-bearing decision this chunk had to
+  make).** `Profile` is a Python class (reference type); Swift's `Profile`
+  is a struct (value type). Several Swift lines are `var x = someProfile`
+  followed by conditional keep-or-discard based on a `check*` call's
+  success. A naive Python port (`x = some_profile`, a plain alias) would
+  silently break correctness in two spots:
+  - `VelocityThirdOrderStep1._time_acc0`/`_time_none`: Swift captures `var
+    profile = validProfiles[profileCount]` **once** and reuses it across
+    Solution 1 and Solution 2 within the same call. If Solution 1 succeeds
+    (`validProfiles[profileCount] = profile`, a struct copy in Swift) and
+    Solution 2 then mutates the same local further, Swift's copy already
+    diverged from the array slot — the saved Solution 1 candidate is safe.
+    A Python alias would let Solution 2's mutations retroactively corrupt
+    the already-recorded Solution 1 profile. Fixed by `copy.deepcopy` at
+    the read (`profile = copy.deepcopy(self.valid_profiles[...])`) **and**
+    at each save (`self.valid_profiles[...] = copy.deepcopy(profile)`).
+  - `VelocitySecondOrderStep1.get_profile` / `VelocityThirdOrderStep1`'s
+    zero-limits branch: `var p = block.pMin` then `p.setBoundary(input)`
+    — on failure Swift's `block.pMin` is untouched (the local copy is
+    discarded); a Python alias would leave `block.p_min` mutated with
+    partial/garbage state even though the function returned `False`. Fixed
+    by `copy.deepcopy(block.p_min)` before mutating.
+  All four `Profile` field types (float, list[float], `BrakeProfile`, `str`
+  enum members) are plain and deepcopy-safe; no changes to `profile.py`
+  were needed or made (out of scope, and unnecessary).
+- **`VelocityThirdOrderStep2` needed no copy.** Its private helpers mutate
+  a single `profile` argument passed straight through (Swift `inout` on
+  one object) and always return on first success — Python's natural
+  pass-by-reference mutable-object semantics already match Swift's
+  `inout` here, so these are plain mechanical translations.
+- **Dropped the `debugThis`/`print(...)` scaffolding** in
+  `VelocitySecondOrderStep2.swift` (a `let debugThis = true` flag guarding
+  `print` calls, with the intended real condition commented out:
+  `// (abs(vd) < 0.01)`). This is debug noise, not part of the semantic
+  contract (fidelity requirement 2 covers branch structure and method
+  names, not console output), and printing from a library call is
+  undesirable regardless. No other file in this chunk's scope had similar
+  scaffolding.
+- **Test boundary values pre-set via `Profile.set_boundary_for_velocity`.**
+  A fresh `Profile()` has `vf = af = 0.0`; since `Step1.get_profile`
+  copies its working profile's `vf`/`af`/`v[0]`/`a[0]` from the caller-
+  supplied `input` profile (`set_boundary`'s "from-profile" overload), the
+  test fixtures call `set_boundary_for_velocity(p0_new=0.0, v0_new=0.0,
+  a0_new=..., vf_new=..., af_new=...)` on the input profile before
+  invoking `get_profile` — mirroring how the (not-yet-built)
+  `TargetCalculator` would populate it.
+- **Test regime derivation** (both third-order analytic regimes, matching
+  the chunk's TDD step): a = 2.0, j = 1.0 (a²/j = 4.0). Δv = 6.0 (≥ 4.0)
+  exercises the trapezoidal-acceleration (`ACC0`) regime via `_time_acc0`,
+  t = Δv/a + a/j = 5.0. Δv = 3.0 (< 4.0) exercises the triangular regime
+  via `_time_none`'s Solution 2, t = 2·sqrt(Δv/j) ≈ 3.464. Second order:
+  Δv = 4.0, aMax = 2.0, t = Δv/a = 2.0. Both Step2 tests use tf = 1.5 ×
+  the corresponding Step1-optimal duration and assert the profile hits the
+  target velocity/acceleration and spans exactly `tf`. All boundary arrays
+  are cross-checked against `integrate_jerk` computed independently in the
+  test, per `tests/otg/test_profile.py`'s established convention.
+- No deviations from the plan's file list or design constraints; `otg.md`
+  required no contract changes (only a semver bump for this landing).
diff --git a/.claude/archive/math-tools-port/37-otg-position-first-second-steps.md b/.claude/archive/math-tools-port/37-otg-position-first-second-steps.md
new file mode 100644
index 0000000..5852327
--- /dev/null
+++ b/.claude/archive/math-tools-port/37-otg-position-first-second-steps.md
@@ -0,0 +1,108 @@
+---
+chunk: 37-otg-position-first-second-steps
+track: E
+status: complete
+depends_on: [34]
+spec: ../specs/otg.md §Internal fidelity 2, 4, 5
+last_updated: 2026-07-21
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 37 — Position first/second-order step solvers
+
+**Deliverable:** `steps/position_first_order.py` +
+`steps/position_second_order.py`. Faithful ports of
+`SWIFT_MATH/OTG/PositionFirstOrderStep1.swift`, `...Step2.swift`,
+`PositionSecondOrderStep1.swift`, `...Step2.swift`.
+
+## Files
+
+- Create: `src/math_tools/otg/steps/position_first_order.py`,
+  `src/math_tools/otg/steps/position_second_order.py`
+- Create: `tests/otg/steps/test_position_first_second.py`
+
+## Design constraints
+
+Same porting rules as chunk 36 (mechanical translation, roots/epsilons from
+`functional.roots`, Profile from chunk 33).
+
+## TDD steps
+
+1. Failing tests (analytic): first order (velocity-limited only) —
+   `t = |Δp|/v_max`, profile position endpoints exact. Second order
+   (velocity+acceleration) — trapezoidal velocity when
+   `|Δp| ≥ v_max²/a_max` with
+   `t = |Δp|/v_max + v_max/a_max`, else triangular with
+   `t = 2·sqrt(|Δp|/a_max)`; pin both, both directions (Δp < 0 exercises
+   `Direction.DOWN`). Step2: prescribed duration 2× optimal reaches the
+   target position.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Trapezoidal + triangular regimes pinned in both directions
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Third-order steps (38, 39).
+
+## Resolution notes
+
+- **Alias-mutation hazard, per chunk 36's flagged pattern.** Both
+  `PositionFirstOrderStep1.get_profile` and
+  `PositionSecondOrderStep1.get_profile`'s zero-limits branch reproduce
+  Swift's `var p = block.pMin` (a struct value copy) as
+  `copy.deepcopy(block.p_min)`, matching
+  `VelocitySecondOrderStep1.get_profile`'s identical pattern: without the
+  deep copy, a Python alias would let a failed candidate's partial
+  mutations corrupt `block.p_min` even though the function returns
+  `False` (Swift's local copy is simply discarded on failure).
+- **No copy needed in `PositionSecondOrderStep1._time_acc0`/`_time_none`,
+  unlike `VelocityThirdOrderStep1`'s equivalent helpers.** The Swift
+  source mutates `validProfiles[profileCount]` directly through the array
+  subscript on every line -- it never captures a local `var profile =
+  validProfiles[profileCount]` first the way
+  `VelocityThirdOrderStep1._time_acc0`/`_time_none` do. Python list
+  indexing has the same direct-mutation semantics, and `_add_profile`
+  always advances to a fresh, distinct `Profile()` instance before the
+  next attempt, so a plain mechanical port (no `copy.deepcopy`) already
+  reproduces Swift's behavior exactly. Verified this by hand-deriving both
+  analytic regimes (trapezoidal and triangular) independently and
+  confirming the ported code reproduces them bit-for-bit on the first test
+  run -- see the test file's docstrings for the derivations. `valid_profiles`
+  is still built as three genuinely separate `Profile()` instances (`[Profile()
+  for _ in range(3)]`, never `[Profile()] * 3`), matching the same hazard
+  `VelocityThirdOrderStep1` calls out.
+- **`PositionSecondOrderStep2` needs no copy at all** (mirrors
+  `VelocityThirdOrderStep2`): its methods mutate a single `profile`
+  argument passed straight through and always return on first success --
+  Python's natural pass-by-reference mutable-object semantics already
+  match Swift's `inout` here.
+- **Two Swift function parameters are declared but unused in the function
+  body** (`PositionSecondOrderStep1.timeAcc0`'s `returnAfterFound` --
+  there is only ever one candidate write in that function, so nothing to
+  short-circuit; `timeAllSingleStep`'s `aMax`/`aMin` -- only `vMax`/`vMin`
+  are threaded into `checkForSecondOrder`). Ported faithfully with
+  `del return_after_found` / `del a_max, a_min` (matching `profile.py`'s
+  established `del tf` convention for the same situation) rather than
+  dropping the parameters, to keep the signatures diff-mappable to the
+  Swift source per fidelity requirement 2.
+- **Test design.** Point-to-point cases (`v0 = vf = 0`) exercise each
+  solver's "no final velocity" branch, matching `TargetCalculator`'s
+  expected common usage. First-order: `p0=0, pf=±5, vMax=2` pins `t =
+  |Δp|/vMax` in both directions. Second-order: `vMax = aMax = 2.0` =>
+  `vMax²/aMax = 2.0`; `pd=6.0` (>= 2.0, `Direction.UP`) pins the
+  trapezoidal regime, `pd=-1.0` (< 2.0, `Direction.DOWN`) pins the
+  triangular regime -- covering both analytic regimes and both directions
+  across the two tests, per the chunk's TDD step. Step2 tests use `tf = 2x`
+  the corresponding Step1-optimal duration (per the chunk's TDD step
+  wording) and assert the profile reaches the target position and spans
+  exactly `tf`. All boundary-array expectations are recomputed
+  independently via `integrate_jerk` in the test, per
+  `tests/otg/steps/test_velocity_steps.py`'s established convention. All
+  ten tests passed on the first run against the mechanically-ported
+  implementation, confirming the hand-derived formulas and the port agree.
+- No deviations from the plan's file list or design constraints; `otg.md`
+  required no contract changes.
diff --git a/.claude/archive/math-tools-port/38-otg-position-third-step1.md b/.claude/archive/math-tools-port/38-otg-position-third-step1.md
new file mode 100644
index 0000000..b702ddd
--- /dev/null
+++ b/.claude/archive/math-tools-port/38-otg-position-third-step1.md
@@ -0,0 +1,118 @@
+---
+chunk: 38-otg-position-third-step1
+track: E
+status: complete
+depends_on: [34]
+spec: ../specs/otg.md §Internal fidelity 2, 4, 5; §Module layout (chunking hints)
+last_updated: 2026-07-21
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 38 — `PositionThirdOrderStep1` (time-optimal)
+
+**Deliverable:** `steps/position_third_order_step1.py` — faithful port of
+`SWIFT_MATH/OTG/PositionThirdOrderStep1.swift` (~850 lines). This is the
+time-optimal profile finder for the full jerk-limited position interface.
+
+## Files
+
+- Create: `src/math_tools/otg/steps/position_third_order_step1.py`
+- Create: `tests/otg/steps/test_position_third_step1.py`
+
+## Design constraints
+
+1. Mechanical translation: one Python method per Swift method
+   (`time_acc0_acc1_vel`, `time_vel`, `time_acc0`, … — keep every profile-
+   family case), same guard order, same use of `solve_cubic`/
+   `solve_quartic_monic`/`shrink_interval` from `functional.roots`.
+2. Do NOT simplify algebra or merge branches; if a Swift branch looks dead,
+   port it anyway and note it.
+3. The class's public entry mirrors the Swift `getProfile`-style API filling
+   candidate `Profile`s and selecting valid ones via `Profile.check`.
+
+## TDD steps
+
+1. Failing tests: three hand-derivable cases — (a) rest-to-rest long move
+   (all limits reached: ACC0_ACC1_VEL profile; total time
+   `t = Δp/v + v/a + a/j` +symmetric phases — derive in the test comment),
+   (b) rest-to-rest short move (jerk-dominated, no limit reached), (c) a
+   moving-start case with a0 ≠ 0. Assert total duration (atol 1e-9) AND the
+   7 segment times of the selected profile (this is what chunk 42's numeric
+   oracle will lean on).
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] The three analytic cases pass with segment-time pinning
+- [x] Every Swift method name has a snake_case counterpart (reviewer diff spot-check)
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Step2 (39); synchronization; blocks.
+
+## Resolution notes
+
+- **All 11 Swift methods ported 1:1, snake_cased**: `addProfile` →
+  `_add_profile`, `resetProfiles` → `_reset_profiles`, `hasProfiles` →
+  `_has_profiles`, `timeAllVel` → `_time_all_vel`, `timeAcc0Acc1` →
+  `_time_acc0_acc1`, `timeAllNoneAcc0Acc1` → `_time_all_none_acc0_acc1`,
+  `timeAcc1VelTwoStep` → `_time_acc1_vel_two_step`, `timeAcc0TwoStep` →
+  `_time_acc0_two_step`, `timeVelTwoStep` → `_time_vel_two_step`,
+  `timeNoneTwoStep` → `_time_none_two_step`, `timeAllSingleStep` →
+  `_time_all_single_step`, `getProfile` → `get_profile`. Confirmed via a
+  `grep`-diff of Swift `func` names against Python `def` names (see
+  module docstring/report). The chunk description's example names
+  (`time_acc0_acc1_vel`, `time_vel`, `time_acc0`) don't literally appear
+  in the Swift source (the actual grouping methods are `timeAllVel` /
+  `timeAcc0Acc1` / `timeAllNoneAcc0Acc1`); the acceptance criterion (every
+  Swift method name has a snake_case counterpart) is satisfied by the
+  literal Swift names, which is what was ported.
+- **Confirmed dead code, ported anyway**: a source-tree `grep` for
+  `timeAcc1VelTwoStep`/`timeAcc0TwoStep`/`timeVelTwoStep`/`timeNoneTwoStep`
+  shows zero call sites anywhere in `SWIFT_MATH` outside their own
+  declarations -- these four "only for numerical issues" methods are
+  genuinely unreachable from `getProfile` in the Swift source too. Ported
+  field-for-field per design constraint 2 and documented in the module
+  docstring; no dedicated tests target them directly since they cannot be
+  exercised through the public `get_profile` entry point (matching how
+  `get_profile`'s own reachable paths are the only ones the TDD cases can
+  drive).
+- **New alias-mutation pattern beyond chunks 36/37**:
+  `_time_all_none_acc0_acc1` introduces a pattern not seen in the velocity
+  or first/second-order position steps -- the Swift source explicitly
+  re-fetches `profile = validProfiles[profileCount]` mid-loop (with its
+  own "BUG FIX: Get fresh profile reference..." comment) after a
+  non-returning success. Ported as: `copy.deepcopy` on every *save*
+  (`self.valid_profiles[self._profile_count] = copy.deepcopy(profile)`,
+  severing the alias so later mutations can't corrupt what was just
+  saved), but a *plain* reference reassignment for the mid-loop refresh
+  itself (pointing `profile` at the fresh, not-yet-saved next slot needs
+  no copy). Reasoning recorded in full in the module docstring.
+- **Swift/Python IEEE 754 division divergence (new, spec-worthy)**: the
+  three hand-derived TDD cases (rest-to-rest short move and the
+  moving-start case) both hit a legitimate `t == 0` quartic root in
+  `_time_all_none_acc0_acc1`'s NONE loop (whenever the polynomial's
+  constant term `-h2_p2/j^2` is zero, `insertIfPositive` accepts `0.0` as
+  a valid non-negative root). The subsequent `h0 = h2_none / (2*j*t)` is a
+  genuine `0.0/0.0`, which Swift/IEEE754 silently resolves to `nan` (later
+  rejected by `Profile.check`'s precision comparisons) but Python's `/`
+  raises `ZeroDivisionError` on. Fixed with a small `_ieee754_div` helper
+  used only at this one call site (not a blanket division-wrapping sweep).
+  otg.md §Internal fidelity requirement 4 was updated (semver 0.0.2 →
+  0.0.3) to document this as a recognized, narrowly-scoped port pattern
+  for future step-solver chunks (39, `calculator_target`) to watch for
+  and reuse rather than rediscover.
+- **Three TDD cases, all closed-form, all verified by independent
+  re-integration**: (a) long move, ACC0_ACC1_VEL, `t = pd/v_max +
+  v_max/a_max + a_max/j_max = 8.0`, segments `[1,1,1,2,1,1,1]`; (b) short
+  move, NONE, `t2 = (4*pd/j)**(1/3)` with `t0=t6=t2/2`; (c) moving-start
+  (`a0=af=0.5`), NONE, `h2_none` collapses to 0 by choosing `a0=af`,
+  reducing the quartic to a cubic with a hand-picked root `t2=2` pinning
+  `pd=1.5`. All three additionally assert `profile.limits` matches the
+  expected `ReachedLimits` member and reintegrate the returned segment
+  times via `integrate_jerk` independently of `Profile`'s own internal
+  loop, confirming the final `(p, v, a)` lands on the target state.
+- No deviation from the chunk's file list or scope; `Out of scope` items
+  (Step2, synchronization, blocks) untouched.
diff --git a/.claude/archive/math-tools-port/39-otg-position-third-step2.md b/.claude/archive/math-tools-port/39-otg-position-third-step2.md
new file mode 100644
index 0000000..fd39151
--- /dev/null
+++ b/.claude/archive/math-tools-port/39-otg-position-third-step2.md
@@ -0,0 +1,103 @@
+---
+chunk: 39-otg-position-third-step2
+track: E
+status: complete
+depends_on: [34]
+spec: ../specs/otg.md §Internal fidelity 2, 4, 5; §Module layout (chunking hints)
+last_updated: 2026-07-21
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 39 — `PositionThirdOrderStep2` (prescribed-duration)
+
+**Deliverable:** `steps/position_third_order_step2.py` — faithful port of
+`SWIFT_MATH/OTG/PositionThirdOrderStep2.swift` (~1,900 lines, the single
+largest file in the port). Solves a profile hitting the target at an
+EXACT prescribed duration (the synchronization workhorse).
+
+## Files
+
+- Create: `src/math_tools/otg/steps/position_third_order_step2.py`
+- Create: `tests/otg/steps/test_position_third_step2.py`
+
+## Design constraints
+
+1. Same mechanical-translation rules as chunk 38. If a single session
+   cannot finish, split at Swift function boundaries and leave the
+   remaining functions raising `NotImplementedError` with the chunk noted
+   `in_progress` — never merge a silently wrong branch.
+2. Every polynomial solve routes through `functional.roots`; epsilon
+   comparisons use the shared constants.
+
+## TDD steps
+
+1. Failing tests: take chunk 38's three analytic cases, compute their
+   optimal durations, then ask Step2 for 1.25×, 1.5×, and 3× that duration —
+   assert the returned profile (a) passes `Profile.check`, (b) reaches
+   `pf/vf/af` (atol 1e-8), (c) has `t_sum[-1]` equal to the prescribed
+   duration (atol 1e-9). Add one negative test: a duration BELOW optimal
+   yields no valid profile.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] All three scale factors × three cases pass; below-optimal rejected
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Step1 changes; TargetCalculator.
+
+## Resolution notes
+
+- Full mechanical port of all 10 Swift methods (`timeAcc0Acc1Vel`,
+  `timeAcc1Vel`, `timeAcc0Vel`, `timeVel`, `timeAcc0Acc1`, `timeAcc1`,
+  `timeAcc0`, `timeNone`, `timeNoneSmooth`, `getProfile`) as
+  `PositionThirdOrderStep2` in
+  `src/math_tools/otg/steps/position_third_order_step2.py`. No
+  alias-mutation hazard here (unlike Step1): every method mutates the
+  single caller-owned `Profile` directly and returns on first success,
+  architecturally identical to `VelocityThirdOrderStep2` — no
+  `copy.deepcopy` needed.
+- Dropped the Swift `timeVel` method's `debugTimeVel`-gated `print(...)`
+  block (a hardcoded-`false` developer tracing flag, permanently dead) —
+  not part of the algorithm; every branch/root-search/Newton-step it
+  wrapped is preserved exactly.
+- `timeNoneSmooth` is never called from `getProfile` in the Swift source
+  (grep-confirmed) — ported anyway per otg.md design constraint 2, same
+  precedent as Step1's `*_two_step` methods.
+- Preserved a genuine Swift source quirk verbatim in `_time_acc0`: the
+  second `do` block is comment-labeled `// UDUD` but its
+  `checkWithTiming` call actually passes `.UDDU`. Ported as literally
+  executed, not "corrected" to match the comment.
+- TDD surfaced a real fidelity gap beyond otg.md's `_ieee754_div`
+  precedent: the "below-optimal duration is infeasible" negative test
+  hit `math domain error` (Python `math.sqrt` on a negative argument)
+  and, after the first site was patched, a `ZeroDivisionError` at two
+  more sites. Traced the root cause: for a below-time-optimal prescribed
+  duration, `get_profile` tries well over a dozen candidate branches in
+  sequence, and a negative discriminant is the *generic* way each
+  branch's algebra signals infeasibility — not a rare degenerate case.
+  Added `_ieee754_sqrt` (Swift `sqrt(negative) == nan` semantics) and
+  applied it at **every** `math.sqrt` call site in this one file
+  (~30 sites) rather than iterating one failing-test-site at a time,
+  since the hazard is structurally identical everywhere it appears; this
+  intentionally goes beyond `_ieee754_div`'s narrower, per-site-only
+  scoping (documented as a deliberate, file-scoped exception in both the
+  module docstring and otg.md §Internal fidelity requirement 4, bumped
+  to 0.0.4). Added `_ieee754_div` (identical to Step1's helper) and
+  applied it only at the two sites the same test actually reached (T
+  3456's `h0`/`t[3]` denominator, and the UZU 3-step profile's `t == 0`
+  root), per the requirement's existing per-site scoping.
+- `make uv-fullCheck` required hand-fixing ~46 `E501` line-too-long
+  violations. Ran `ruff format` scoped to only this chunk's two files
+  (not the Makefile's whole-tree `uv-format` target) per the chunk
+  instructions barring a broad auto-formatter run; `git status` after
+  confirms only the two new files changed.
+- All three chunk-38 analytic cases (ACC0_ACC1_VEL long move, NONE short
+  move, NONE moving-start) pass at 1.25×/1.5×/3× their Step1-optimal
+  duration (`p`/`v`/`a` within 1e-8, `t_sum[-1] == tf` within 1e-9); the
+  below-optimal negative test passes. Full gate:
+  `make uv-fullCheck` — ruff clean, mypy strict clean (107 source
+  files), 1318/1318 tests pass.
diff --git a/.claude/archive/math-tools-port/40-otg-calculator-target.md b/.claude/archive/math-tools-port/40-otg-calculator-target.md
new file mode 100644
index 0000000..e05678f
--- /dev/null
+++ b/.claude/archive/math-tools-port/40-otg-calculator-target.md
@@ -0,0 +1,133 @@
+---
+chunk: 40-otg-calculator-target
+track: E
+status: complete
+depends_on: [32, 35, 36, 37, 38, 39]
+spec: ../specs/otg.md §Internal fidelity 3
+last_updated: 2026-07-21
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 40 — `TargetCalculator`
+
+**Deliverable:** `calculator_target.py` — faithful port of
+`SWIFT_MATH/OTG/CalculatorTarget.swift` (~780 lines): per-DOF Step1/Step2
+dispatch plus cross-DOF synchronization (Block/Interval logic, the
+discrete-duration path, phase sync).
+
+## Files
+
+- Create: `src/math_tools/otg/calculator_target.py`
+- Create: `tests/otg/test_calculator_target.py`
+
+## Design constraints
+
+1. Port `calculate(...)` and `synchronize(...)` branch-for-branch: per-DOF
+   control-interface dispatch to the step solver classes (36–39), Block
+   construction, blocked-interval resolution, `Synchronization` mode
+   handling (TIME / TIME_IF_NECESSARY / PHASE / NONE), minimum-duration and
+   discrete-duration paths.
+2. Error paths return the spec'd `Result` codes
+   (`ERROR_EXECUTION_TIME_CALCULATION`, `ERROR_SYNCHRONIZATION_CALCULATION`)
+   — no exceptions.
+3. Fills a `Trajectory` (chunk 35); consumes `InputParameter` (32).
+
+## TDD steps
+
+1. Failing tests: (a) 1-DOF position case reproduces chunk 38's analytic
+   duration through the full calculate path; (b) 3-DOF TIME sync — all DOFs
+   report identical trajectory duration equal to the slowest DOF's optimal
+   (compose from chunk 38's cases with different distances); (c) NONE sync —
+   per-DOF durations equal their independent optima; (d) an `enabled=False`
+   DOF stays at its current state; (e) an unsolvable synchronization input
+   returns `ERROR_SYNCHRONIZATION_CALCULATION` rather than raising.
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] TIME/NONE sync duration semantics pinned; disabled-DOF pinned
+- [x] No `raise` in the calculate path (grep for `raise` → only in
+      structural-misuse guards, if any)
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+The `Otg` driver loop (41); waypoints beyond what the Swift implements.
+
+## Resolution notes
+
+- **Deliverable**: `src/math_tools/otg/calculator_target.py` (`TargetCalculator`,
+  private per otg.md's module layout — `__all__ = []`) plus
+  `tests/otg/test_calculator_target.py` (6 tests covering TDD cases a-e; (e)
+  is covered by two tests, see below). Ported `calculate()`, `synchronize()`
+  (as `_synchronize`, since Swift's `private func`), and
+  `isInputCollinear()` (as `_is_input_collinear`) branch-for-branch from
+  `CalculatorTarget.swift`.
+- **Alias-mutation hazard, identified and fixed at 8 sites**: unlike chunks
+  36-39 (where the hazard is *within* a single `get_profile()` call),
+  `TargetCalculator` holds `self._blocks` as *instance* state that persists
+  across `calculate()` calls, so every Swift `trajectory.profiles[0][dof] =
+  blocks[dof].pMin` (or `.a!.profile!` / `.b!.profile!`) — a value copy in
+  Swift, a live alias in Python otherwise — was routed through
+  `copy.deepcopy()`: `_synchronize`'s own save point (3 branches), the "None
+  Synchronization" loop, the `duration == 0.0` copy-all-profiles branch, the
+  1-DOF shortcut, and the "Time Synchronization" loop's 3 early-exit
+  branches. Also caught one array-level (not whole-`Profile`) case: Swift's
+  `p.t = pLimiting.t` (phase sync) copies a Swift array *value*; ported as
+  `p.t = list(p_limiting.t)`, not a bare `p.t = p_limiting.t` (which would
+  alias the two profiles' timing arrays). Full reasoning, including why the
+  *other* `trajectory.profiles[0][dof] = p` write-backs need no copy
+  (`p` already *is* that list slot's object — Python alias mutation, not a
+  fresh Swift struct copy), is in the module docstring.
+- **Verified analytically that `TargetCalculator._synchronize`'s search is
+  provably complete for any Block state a real Step1 call produces** (a
+  DOF's own `t_min`, and any `Interval.right`, is never self-blocking at its
+  own boundary — `Block.is_blocked`/`Interval.is_blocked` both use strict
+  `<`/open intervals). This made TDD case (e) ("an unsolvable
+  synchronization input") impractical to reach through a *naturally*
+  Step1-derived `InputParameter` without an adversarial multi-DOF interval
+  coincidence, so it's covered by two targeted tests instead: one calls
+  `_synchronize` directly with a hand-built `Block` pair proven by
+  construction to block every finite candidate (an `Interval(1.0, math.inf)`
+  combined with a second DOF's `t_min` floor that blocks the first DOF's
+  only escape point at `t=1.0`); the other forces `_synchronize` to return
+  `False` via `unittest.mock.patch.object` and confirms `calculate()`
+  propagates it to `Result.ERROR_SYNCHRONIZATION_CALCULATION` without
+  raising. Documented in the test file's own docstring.
+- **Dropped 4 Swift `print("[DEBUG] ...")` statements** (in `synchronize()`'s
+  failure path and `calculate()`'s two error branches) — unconditional
+  developer tracing, not part of the algorithm, same category as chunk 39's
+  dropped `debugTimeVel` print block. Every branch/decision they straddled
+  is preserved exactly.
+- **No new `_ieee754_div`/`_ieee754_sqrt` sites**: `_is_input_collinear`'s
+  divisions (`pd[dof] / scale`, etc.) all divide by `scale_vector[scale_dof]`,
+  which is only selected after `abs(...) > _EPS` was already checked —
+  provably nonzero, so plain `/` is correct per otg.md §Internal fidelity
+  requirement 4 (`_ieee754_div` is for a *failing test*-demonstrated
+  zero-denominator, not a blanket wrap). One division
+  (`controlLimiting * currentScale / scaleLimiting`) has no such proof and
+  is flagged in the module docstring for a future chunk to revisit if a
+  test ever reaches it; none of this chunk's own tests do (no `Synchronization.PHASE`
+  case was required by the chunk's TDD steps, so this path is implemented
+  per the design constraints but not itself under test here).
+- **Fidelity oddity ported verbatim**: the trivial "already at target, zero
+  motion" branch sets `p.a`/`p.v`/`p.p` to length-7 lists (`[value] * 7`),
+  matching Swift's `Array(repeating: ..., count: 7)` exactly even though
+  `Profile`'s normal invariant is 8-element `a`/`v`/`p` arrays — verified
+  harmless (every element is identical, and `Trajectory.at_time` always
+  indexes via `[-1]`, never a hardcoded `[7]`, so the shorter list is never
+  a break) but preserved rather than "corrected" to 8, per the port's
+  mechanical-translation mandate.
+- **Known, accepted, untested Python/Swift divergence documented, not
+  fixed**: an early error `return` (`ERROR_ZERO_LIMITS`,
+  `ERROR_EXECUTION_TIME_CALCULATION`) can leave `trajectory.profiles[0][dof]`
+  partially mutated in Python (reference-type alias), where Swift's local
+  struct copy would leave it untouched. Nothing in otg.md's oracle/
+  classification/numeric test strategy inspects trajectory state after an
+  error `Result`, so this is unobservable through the documented contract;
+  not patched with defensive copying (would violate the alias-mutation
+  fix's "not blanket everywhere" scoping). Recorded in the module docstring.
+- Gate: `make uv-fullCheck` — ruff clean, mypy strict clean (109 source
+  files), 1324/1324 tests pass (full suite ran in ~12s locally, well under
+  the 60-70s ceiling the chunk brief warned about).
diff --git a/.claude/archive/math-tools-port/41-otg-driver.md b/.claude/archive/math-tools-port/41-otg-driver.md
new file mode 100644
index 0000000..01f24d3
--- /dev/null
+++ b/.claude/archive/math-tools-port/41-otg-driver.md
@@ -0,0 +1,136 @@
+---
+chunk: 41-otg-driver
+track: E
+status: complete
+depends_on: [40]
+spec: ../specs/otg.md §Public API (Otg), §Error semantics, §Compliance 5
+last_updated: 2026-07-22
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 41 — `Otg` driver
+
+**Deliverable:** the per-cycle driver class and the finished public surface.
+Faithful port of `SWIFT_MATH/OTG/spmOTG.swift`.
+
+## Files
+
+- Create: `src/math_tools/otg/otg.py`
+- Edit: `src/math_tools/otg/__init__.py` (final `__all__` per spec §Module
+  layout)
+- Create: `tests/otg/test_otg_driver.py`
+
+## Design constraints
+
+1. `Otg(control_cycle, dofs, max_number_of_waypoints=0)`; `OtgError` for
+   structural misuse only (non-positive control_cycle, DOF mismatch between
+   constructor and parameters); `update(input, output) -> Result` (validate
+   → recalc-on-change → step `output.time` → sample → WORKING/FINISHED),
+   `calculate(input, output) -> Result`, `reset()`. Port the input-change
+   detection and `interrupt_calculation_duration` handling as the Swift
+   does.
+2. `calculation_duration` measured with `time.perf_counter_ns()` → µs
+   (Swift used DispatchTime).
+
+## TDD steps
+
+1. Failing tests: a 1-DOF rest-to-rest move driven via repeated `update`
+   reaches `FINISHED` in ≤ `duration/control_cycle + 2` calls (spec
+   invariant); `output.new_position` at each cycle matches
+   `trajectory.at_time(output.time)`; invalid input → `ERROR_INVALID_INPUT`
+   (no exception); DOF mismatch raises `OtgError`; `pass_to_input` +
+   `update` chaining is stable (`new_calculation` False when input
+   unchanged).
+2. Implement. 3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] FINISHED-within-bound and no-exception error paths pass
+- [x] `math_tools/otg/__init__.py` `__all__` == the spec's export list
+      (pinned by test — spec compliance 5)
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Oracle suites (42); performance tuning.
+
+## Resolution notes
+
+- **Deliverable**: `src/math_tools/otg/otg.py` (`Otg`, the finished driver)
+  plus `tests/otg/test_otg_driver.py` (17 tests across 6 `TestCase`
+  classes). `__init__.py` now exports `Otg` and `Profile` (the latter was
+  already public in `profile.py`'s own `__all__` since chunk 33 but not yet
+  wired into the package `__init__`), bringing `__all__` to the spec's full
+  10-name §Module layout list, pinned by `TestPublicSurface`.
+- **Constructor deviates from Swift by design, per the chunk brief**:
+  Swift's `OTG.init(deltaTime: Double = -1.0)` only rejects a non-positive
+  delta lazily inside `validateInput`, and only when
+  `durationDiscretization != .Continuous`. This port requires
+  `control_cycle > 0` unconditionally at construction (`OtgError`
+  otherwise), per design constraint 1's "non-positive control_cycle" ->
+  structural misuse. Consequence: Swift's `deltaTime <= 0.0` branch inside
+  `validateInput` is dead code under this port's stricter contract and was
+  not ported (documented in `otg.py`'s module docstring).
+- **DOF-mismatch guard added (not in Swift)**: Swift's fixed-size arrays
+  make a DOF mismatch a compile-time non-issue in normal use, so
+  `OTG.swift` never checks for one. This port's `InputParameter`/
+  `OutputParameter` are plain Python lists with no static size, so
+  `Otg._check_degrees_of_freedom` raises `OtgError` explicitly (checked at
+  the top of both `calculate()` and `update()`, since `update()` can skip
+  its own call to `calculate()` when the input hasn't changed).
+- **Alias-mutation hazard (otg.md's cross-chunk pattern)**: Swift's
+  `currentInput: InputParameter` is a struct field, so `currentInput =
+  input` is a value copy; this port's `InputParameter` is a reference type
+  (chunk 32), so the equivalent line uses `copy.deepcopy`. Verified by
+  construction that a bare `self._current_input = input_parameter` would
+  have aliased the caller's object and made the next cycle's
+  `input_parameter != self._current_input` compare always `False`
+  (identity), permanently breaking recalculation-on-change — documented in
+  the module docstring rather than left implicit.
+- **Confirmed the standard drive loop requires the caller to call
+  `output.pass_to_input(input)` themselves each cycle** (mirroring Swift's
+  documented Ruckig usage pattern): `Otg.update`'s internal
+  `output.pass_to_input(self._current_input)` only keeps the driver's own
+  cached copy in sync, not the caller's `input` object. A first draft of
+  the `TestReset` test omitted this call between cycles and failed
+  (`new_calculation` stayed `True` every cycle, since the caller's
+  unmodified `input` kept diverging from the driver's internally-advancing
+  cache) — fixed by adding `output.pass_to_input(inp)` between `update()`
+  calls, which is the correct, intended usage pattern, not a workaround.
+- **`filterIntermediatePositions` and the `interrupt_calculation_duration`
+  field are intentionally not ported**: both are dead in the Swift source
+  itself (`filterIntermediatePositions` is defined on `OTG` but never
+  called by `calculate`/`update`; `interruptCalculationDuration` is read
+  only by the Codable wire format, never by `OTG.swift` or
+  `CalculatorTarget.swift`) — porting either would add untested surface
+  outside otg.md §Public API (Otg) and this chunk's scope. Documented in
+  the module docstring per the chunk instruction to "port
+  `interrupt_calculation_duration` handling as the Swift does" (i.e.,
+  not at all, since the Swift driver never reads it).
+- **`Trajectory._state_to_integrate_from` reused directly**, per that
+  method's own docstring ("available for the driver, chunk 41, to reuse")
+  — the public `Trajectory.at_time` clamps its `time` argument to
+  `[0, duration]` for its own standalone convenience-method contract, but
+  `Otg.update` needs the section index and per-DOF jerk value alongside
+  position/velocity/acceleration (`OutputParameter.new_section`/
+  `new_jerk`), which `at_time`'s public signature doesn't expose; the
+  private method returns exactly the `(section, [(t, p, v, a, j), ...])`
+  tuple the driver needs and already handles the `time >= duration`
+  constant-acceleration hold internally, matching Swift's unclamped
+  `stateToIntegrateFrom(time: output.time, ...)` call inside `update`.
+- **Test convergence tuned for speed, not fidelity**: chunk 40's shared
+  rest-to-rest limits (`v_max=2, a_max=1, j_max=1`) were kept, but the
+  target distance was reduced to `2.0` (`duration ≈ 4.0s`) with
+  `control_cycle=0.1`, converging in ~40 `update()` calls instead of
+  thousands — the FINISHED-within-bound invariant
+  (`duration/control_cycle + 2`) is dimensionless and holds at any scale
+  the numeric-stepping loop can just as well exercise at a much smaller
+  iteration count.
+- **`calculate()`'s public signature is `(input, output)`, not
+  `(input, trajectory)`** like Swift's `OTG.calculate` — matching otg.md
+  §Public API's unification (`calculate(input, output) -> Result`) already
+  established by the chunk brief; internally it forwards
+  `output.trajectory` to `TargetCalculator.calculate`.
+- Gate: `make uv-fullCheck` — ruff clean, mypy strict clean (111 source
+  files), 1335/1335 tests pass (full suite ran in ~1.6s locally).
diff --git a/.claude/archive/math-tools-port/42-otg-oracle-suites.md b/.claude/archive/math-tools-port/42-otg-oracle-suites.md
new file mode 100644
index 0000000..a199f66
--- /dev/null
+++ b/.claude/archive/math-tools-port/42-otg-oracle-suites.md
@@ -0,0 +1,171 @@
+---
+chunk: 42-otg-oracle-suites
+track: E
+status: complete
+depends_on: [41]
+spec: ../specs/otg.md §Oracle and test strategy, §Compliance 1–2
+last_updated: 2026-07-23
+semver: 0.0.3
+author: Nicholas Bergantz
+---
+
+# 42 — OTG oracle suites
+
+**Deliverable:** the classification corpus, the 31-case numeric truth
+table, and the ported continuity/comprehensive/regression suites — the
+proof the port is faithful.
+
+## Files
+
+- Create: `tests/otg/data/successful_trajectories.json`,
+  `tests/otg/data/failed_trajectories.json` (copied UNMODIFIED from
+  `SWIFT_TESTS/OTGTests/truthTables/`),
+  `tests/otg/data/otg_numeric_truth.json` (transcribed from the hardcoded
+  31-case array in `SWIFT_TESTS/OTGTests/OTGTruthTableTests.swift` — each
+  case: inputs + `expectedDuration` + `expectedTimeIntervals`; note the
+  transcription source file/lines in a `_meta` key)
+- Create: `tests/otg/test_otg_truth_table.py`,
+  `tests/otg/test_otg_continuity.py`, `tests/otg/test_otg_comprehensive.py`,
+  `tests/otg/test_otg_failure_fixes.py`, `tests/otg/test_otg_invariants.py`
+
+## Design constraints
+
+1. Classification suite: successful cases → `calculate` returns
+   `Result >= 0`; failed cases → `Result < 0` (free-text error strings are
+   NOT mapped to specific codes). Load through `InputParameter.from_dict`.
+2. Numeric suite: per case, duration rtol 1e-6; the selected profile's
+   `t` segment times vs `expectedTimeIntervals` atol 1e-6.
+3. Continuity: port `OTGContinuityTests.swift` — across consecutive
+   `update` cycles, position/velocity/acceleration are continuous
+   (|Δ| bounded by the cycle's kinematic limits) including at section
+   changes.
+4. Comprehensive/failure-fix: port `OTGComprehensiveTests.swift` and
+   `OTGFailureFixTests.swift` case-for-case (skip Swift cases that only
+   test Swift-specific machinery; list every skip with a reason in the
+   test file docstring).
+5. Invariants (spec §Oracle 4): seeded random valid inputs — limits never
+   exceeded beyond 1e-9, target reached at `duration` within 1e-8,
+   FINISHED within `duration/control_cycle + 2` updates.
+6. If any oracle case fails: do NOT tune tolerances — the port is wrong;
+   report the failing case IDs and stop.
+
+## TDD steps
+
+Oracle-first by construction: land the data + all suites (failing where the
+port is wrong), then fix ports via follow-up notes — this chunk itself only
+adds tests/data and may not modify `src/`.
+
+## Acceptance criteria
+
+- [x] 100% classification corpus pass (~1,782/1,782 cases)
+- [x] 31/31 numeric cases pass -- only 31 cases exist in the Swift source
+      (not 32 as originally described in the spec/chunk brief; see
+      Resolution notes). otg.md §Oracle and test strategy 2 / §Compliance 1
+      were corrected (semver 0.0.4 → 0.0.5) to atol 1e-6 on segment times,
+      since the Swift literals are themselves recorded to only 6 decimal
+      places and no correct port can satisfy a tighter tolerance. All 31
+      cases pass duration rtol 1e-6 and segment-time atol 1e-6.
+- [x] Continuity + comprehensive + failure-fix + invariant suites pass
+- [x] `git diff --stat` for this chunk touches only `tests/otg/`
+- [x] `make uv-fullCheck` passes (full repo) -- 1353 passed, ruff and mypy
+      strict clean.
+
+## Out of scope
+
+Any `src/` modification (failures are reported, fixed under the owning
+chunk's spec); performance benchmarks.
+
+## Resolution notes
+
+**Data sources.**
+- `tests/otg/data/successful_trajectories.json` /
+  `failed_trajectories.json` copied byte-for-byte (MD5-verified) from
+  `SWIFT_TESTS/OTGTests/truthTables/`.
+- `tests/otg/data/otg_numeric_truth.json` transcribed from the `truthTable`
+  array literal in `SWIFT_TESTS/OTGTests/OTGTruthTableTests.swift` (lines
+  27-490). Transcription was cross-checked mechanically: a standalone
+  regex parse of the Swift literal was diffed field-for-field against the
+  JSON and found to match exactly (0 mismatches across all 11 numeric
+  fields × 31 cases).
+
+**Deviation 1 -- 31 cases, not 32.** otg.md §Oracle and test strategy 2 and
+this chunk's own brief both describe "the 32-case hardcoded truth table."
+The Swift source array actually contains 31 entries (`Test Case 1` through
+`Test Case 31`, no gaps, no duplicated indices; confirmed by both manual
+count and the mechanical regex parse above). All 31 real cases are
+transcribed and asserted; none were invented or duplicated to reach 32.
+Recommend the spec's "32-case" wording be corrected to "31-case" in a
+follow-up spec-only change (out of this chunk's scope, since it doesn't
+touch `src/` or change test behavior).
+
+**Deviation 2 -- numeric truth table tolerance vs. transcription
+precision (design constraint 6 applies: not tuned).** `test_otg_truth_table.py`
+implements otg.md's exact mandated tolerances (duration rtol 1e-6, segment
+times atol 1e-8). Against those tolerances, 1/31 cases pass in full (case
+1, whose expected values happen to be exact round numbers) and all 31 pass
+on duration; 30/31 fail the atol-1e-8 segment-time check. Root-cause
+analysis (see the case-by-case diffs surfaced by the gate run): every
+failing diff is ≤ 4.9e-7 (e.g. case 31 `t[0]`: actual
+`1.1093968047096334` vs. expected `1.109397`, diff ≈1.95e-7), which is
+exactly the maximum possible rounding error for a value the Swift source
+only recorded to 6 decimal places (max rounding error = 5e-7). Every
+computed value is consistent with being the correctly-rounded 6-decimal
+truncation of the port's own output, and every diff is ~2,000x smaller
+than the Swift test's own tolerance (`accuracy: 0.001`) for the identical
+assertion. This pattern (uniformly small, uniformly rounding-consistent
+diffs, zero outliers, 100% pass on the independent duration assertion)
+indicates a data-precision ceiling in the source literal, not a port
+defect -- but per design constraint 6 this is reported, not adjudicated:
+the test file was written to and left at the spec's literal atol 1e-8 and
+is not tuned to pass. Options for a human/spec owner to resolve, not
+applied here: (a) relax otg.md's atol to something the 6-decimal source
+data can support (e.g. 1e-6), (b) regenerate `otg_numeric_truth.json` from
+a higher-precision Swift-side re-run of the same 31 inputs, or (c) accept
+the current atol 1e-8 as aspirational/inapplicable to this data source and
+scope the compliance check to the duration-only assertion.
+
+**Comprehensive suite skips (design constraint 4).** Documented in
+`test_otg_comprehensive.py`'s module docstring: the Swift file's own
+`testTruthTable` (3 cases, itself a duplicate subset of
+`OTGTruthTableTests.swift`) and its `testSuccessfulTrajectoriesFromJSON`/
+`testFailedTrajectoriesFromJSON` (which load the exact same JSON files
+copied into `tests/otg/data/` by this chunk) are skipped as exact-data
+duplicates of `test_otg_truth_table.py`'s own suites, not ported a second
+time under a different tolerance. **Correction (chunk 56, post-audit
+finding E-11):** this line originally claimed "All 4 of the Swift file's
+`testBugFix_*` cases are ported case-for-case" -- the Swift source in fact
+defines 5 `testBugFix_*` cases; `testBugFix_NegativeTimeInterval_Case3` was
+missed by this chunk and was ported by chunk 56.
+
+**Invariant suite (design constraint 5) design decisions.** Interpreted
+"output never exceeds max velocity/acceleration/jerk beyond 1e-9" as the
+`OutputParameter` fields sampled once per `Otg.update()` control cycle
+(not a dense continuous re-sample of `at_time`), matching "FINISHED
+reached within `duration/control_cycle + 2` update calls," which is
+inherently about the discrete `update()` call sequence. Random valid
+inputs are rejection-sampled through `InputParameter.validate()` with both
+`check_current_state_within_limits` and `check_target_state_within_limits`
+set, so a transiently-out-of-limits current state (a deliberate
+brake-profile scenario already covered by the classification corpus) is
+excluded from this suite's definition of "valid." Seed `20260711`, 50
+cases, 0 generation-rejection failures observed; all 3 invariants held for
+all 50 cases with 0 failures.
+
+**Gate result (initial).** `make uv-fullCheck`: `uv-lint` clean,
+`uv-typecheck` clean (mypy strict, 116 source files), `uv-test` 30 subtest
+failures (all in `TestNumericTruthTable`, per Deviation 2 above) out of
+1,353 collected top-level test items. No `src/` files were modified;
+`git diff --stat` for this chunk touches only new files under
+`tests/otg/`.
+
+**Resolution (post-report, human-approved).** Per Deviation 2's option
+(a): the user chose to relax otg.md's segment-time atol from 1e-8 to 1e-6
+(matching duration rtol; still 500x tighter than the Swift test's own
+`accuracy: 0.001`), since the source literals' 6-decimal precision makes
+1e-8 unsatisfiable by any correct port. otg.md §Oracle and test strategy 2
+and §Compliance 1 updated accordingly (semver 0.0.4 → 0.0.5,
+last_updated 2026-07-22); `test_otg_truth_table.py`'s `_TIME_INTERVAL_ATOL`
+and `otg_numeric_truth.json`'s `_meta.tolerances` updated to match; all
+"32-case" wording corrected to "31-case" throughout (spec, test docstring,
+data `_meta`). Re-ran `make uv-fullCheck`: 1353 passed, ruff/mypy clean.
+Chunk now genuinely complete against the corrected spec.
diff --git a/.claude/archive/math-tools-port/43-public-surface.md b/.claude/archive/math-tools-port/43-public-surface.md
new file mode 100644
index 0000000..bccbe30
--- /dev/null
+++ b/.claude/archive/math-tools-port/43-public-surface.md
@@ -0,0 +1,74 @@
+---
+chunk: 43-public-surface
+track: A
+status: complete
+depends_on: [30, 42, 09, 17]
+spec: ../specs/mathToolsArchitecture.md §Shared conventions (Public surface)
+last_updated: 2026-07-22
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 43 — Curated top-level public surface (final chunk)
+
+**Deliverable:** the flat `import math_tools as mt` working set. Runs last —
+after every exporting track is done.
+
+## Files
+
+- Edit: `src/math_tools/__init__.py`
+- Create: `tests/test_public_surface.py`
+
+## Design constraints
+
+1. Root `__all__` is EXACTLY the umbrella spec's list: `Position`,
+   `Quaternion`, `SpatialPose`, `PrecisionTimeInterval`,
+   `PrecisionTimestamp`, `Waveform1D`, `WaveformPosition`,
+   `WaveformQuaternion`, `WaveformSpatialPose`, `UnivariatePolynomial`,
+   `Otg`, `InputParameter`, `OutputParameter`, `Trajectory`, `Result`,
+   `MathToolsError`, `WaveformCompatibilityError`,
+   `TimestampComparisonError`, `PolynomialSolveError`. Re-exports only —
+   no logic in `__init__.py`.
+2. The test pins `set(math_tools.__all__)` to that literal list, imports
+   every name, and asserts each resolves to the subpackage-defined class
+   (identity check, e.g. `math_tools.Position is
+   math_tools.spatial.Position`).
+
+## TDD steps
+
+1. Write the failing `__all__` pin test. 2. Wire the re-exports.
+3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] `import math_tools as mt; mt.Waveform1D.sine(n=8)` works in a fresh interpreter
+- [x] `__all__` pin test passes; no extra public names
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Adding names beyond the spec list (that requires an umbrella spec bump).
+
+## Resolution notes
+
+- `src/math_tools/__init__.py` was empty (stub) prior to this chunk; wired it
+  to re-export the umbrella spec's 19 names only, sourced from each
+  subpackage's already-curated `__all__` (`spatial`, `precision_time`,
+  `waveforms`, `functional`, `otg`, `errors`) — no new logic, pure
+  re-export, matching design constraint 1.
+- `Result` resolves to `math_tools.otg.Result` (the OTG result enum defined
+  in `otg/enums.py`); no naming collision with anything else in scope.
+- `tests/test_public_surface.py` (new) has three cases: (1) `__all__` pins
+  to the exact literal spec set via `assertEqual` on the `set` plus a
+  length check (catches accidental duplicates); (2) every name is checked
+  by identity (`assertIs`) against the subpackage-qualified source, per the
+  chunk's stated test shape; (3) the whole-plan smoke deliverable
+  `math_tools.Waveform1D.sine(n=8)`.
+- TDD order followed exactly: wrote the test against the empty
+  `__init__.py` first, confirmed 21 failures (`AttributeError` on every
+  pinned name), then wired the re-exports, then reran — 3 passed / 19
+  subtests passed.
+- `make uv-fullCheck` green: ruff clean, mypy strict clean (117 source
+  files), pytest 1356 passed (0 failed) including the new file.
+- No deviations from the chunk as written; no scope creep — only the two
+  listed files were touched.
diff --git a/.claude/archive/math-tools-port/44-otg-step2-udud-discriminant.md b/.claude/archive/math-tools-port/44-otg-step2-udud-discriminant.md
new file mode 100644
index 0000000..162121b
--- /dev/null
+++ b/.claude/archive/math-tools-port/44-otg-step2-udud-discriminant.md
@@ -0,0 +1,108 @@
+---
+chunk: 44-otg-step2-udud-discriminant
+track: F
+status: complete
+depends_on: []
+spec: ../specs/otg.md §Internal fidelity 2
+last_updated: 2026-07-23
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 44 — Fix UDUD T0246 discriminant transcription drift (Step2)
+
+## Origin
+
+Post-audit finding E-1 (class **c**, spec/Swift drift). Confirmed firsthand by
+side-by-side read of the Swift source against the port.
+
+`SWIFT_MATH/OTG/position/PositionThirdOrderStep2.swift:1279,1286,1289` computes
+`jMax * tfP2 * tf` — that is **j·tf³**. The port at
+`src/math_tools/otg/steps/position_third_order_step2.py:1731,1752,1763`
+computes `j_max * self.tf_p3 * self.tf` — that is **j·tf⁴**, because `tf_p3`
+is already `tf*tf*tf` (`:174`). One power too many, at three sites inside
+`_time_none`'s UDUD T0246 branch.
+
+Impact: ~0.57% of prescribed-duration Step2 solves select a different profile
+branch. Both branches pass `Profile.check`, so the existing gate cannot see it.
+
+## Files
+
+- Edit: `src/math_tools/otg/steps/position_third_order_step2.py`
+- Edit: `tests/otg/steps/test_position_third_step2.py`
+
+## Design constraints
+
+1. The fix is mechanical: at each of the three sites, `self.tf_p3 * self.tf`
+   becomes `self.tf_p2 * self.tf`. Do **not** "simplify" this to `self.tf_p3`
+   — keep the Swift's literal `tfP2 * tf` shape so the next auditor can diff
+   token-for-token against the Swift line.
+2. Change **only** those three multiplications. Every other expression in
+   `_time_none` was token-diffed against the Swift source during the audit and
+   is correct; do not touch it.
+3. Do not alter `tf_p3`'s definition at `:174` — it is used correctly
+   elsewhere.
+
+## TDD steps
+
+1. Write a failing regression test that pins the corrected branch selection.
+   Use this boundary condition, which the audit confirmed diverges between the
+   two variants:
+   `(p0, v0, a0, pf, vf, af) = (0.4524, 0, 0.4983, 0.2324, 0.2779, 0, 0)`-style
+   inputs — construct a Step2 solve with a prescribed `tf` and assert the
+   resulting profile's segment times match the **j·tf³** result. Derive the
+   expected values by running the corrected formula, and record in the test
+   docstring that these came from the Swift-faithful form.
+2. Apply the three-site fix.
+3. Confirm the new test passes and the full existing OTG suite still passes —
+   in particular `tests/otg/test_otg_truth_table.py` (31 cases) must remain
+   green, since it is the strongest existing oracle.
+4. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] All three sites read `self.tf_p2 * self.tf`
+- [x] New regression test fails before the fix, passes after
+- [x] `tests/otg/test_otg_truth_table.py` still passes unchanged (no tolerance loosening)
+- [x] Full `tests/otg/` suite green
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Broadening Step2 oracle coverage — that is chunk 56. Any other Step1/Step2
+arithmetic (audited clean).
+
+## Resolution notes
+
+- The three sites (`:1731,1752,1763`) each changed `j_max * self.tf_p3 *
+  self.tf` to `j_max * self.tf_p2 * self.tf` per design constraint 1 (kept
+  the Swift's literal `tfP2 * tf` shape, did not collapse to `self.tf_p3`).
+  `tf_p3`'s definition (`:174`) and all its other call sites (`:1642, 1997,
+  2019, 2036, 2052, 2204, 2222, 2229, 2265`) were left untouched.
+- The hardest part of this chunk was TDD step 1: finding a concrete
+  boundary condition that actually reaches the "UDUD T0246" branch (needs
+  `a0 != 0`, which the plan's example inputs matched) *and* where the buggy
+  vs. Swift-faithful discriminant diverge enough to flip which
+  `control_signs` branch `_time_none` selects (both pass
+  `Profile.check_with_timing`, so most random inputs do NOT diverge in a
+  test-detectable way — this matches the origin note's measured ~0.57%
+  rate). Found by an in-process random search: loaded the source twice
+  (unpatched, and with the three sites mechanically patched to
+  `tf_p2 * self.tf` in an in-memory copy of the module text), ran both
+  against ~200k random rest-unconstrained boundary conditions with
+  `a0 != 0`, and kept the first divergent case. Landed on
+  `p0=0.0, v0=-0.5237, a0=2.7015, pf=-1.7271, vf=-1.9901, af=1.6448,
+  tf=11.2581` (v_max/a_max=10, j_max=1): pre-fix selects UDDU with a
+  4-nonzero-segment profile, Swift-faithful selects UDUD T0246 (`t[1]=t[3]=
+  t[5]=0`). The expected `t[]` values hardcoded in the test are the
+  Swift-faithful run's output at full float precision, verified to reach
+  `pf/vf/af` and sum to `tf`.
+- Confirmed red/green manually: reverted the fix via `git apply -R` on a
+  scratch patch, ran the new test (failed on `control_signs` mismatch:
+  `UDDU != UDUD`), then reapplied the fix and reran (passed). This
+  reproduces the TDD-step-1/3 cycle without polluting the git history with
+  an intermediate failing commit.
+- No spec change was needed — `otg.md`'s "Internal fidelity requirements"
+  §2 already mandates mechanical, token-faithful translation; this chunk
+  brings the code into conformance with the existing contract rather than
+  changing it.
diff --git a/.claude/archive/math-tools-port/45-otg-trivial-profile-length.md b/.claude/archive/math-tools-port/45-otg-trivial-profile-length.md
new file mode 100644
index 0000000..c62c6e8
--- /dev/null
+++ b/.claude/archive/math-tools-port/45-otg-trivial-profile-length.md
@@ -0,0 +1,109 @@
+---
+chunk: 45-otg-trivial-profile-length
+track: F
+status: complete
+depends_on: []
+spec: ../specs/otg.md §Internal fidelity 1 (line 120)
+last_updated: 2026-07-23
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 45 — Trivial "already at target" profile must use fixed-length arrays
+
+## Origin
+
+Post-audit finding E-2 (class **c**). Confirmed at runtime:
+
+```
+trivial (1->1): (Result.WORKING, 7, 7, 7)   # len(p.p), len(p.v), len(p.a)
+normal  (0->1): (Result.WORKING, 8, 8, 8)
+```
+
+`.claude/specs/otg.md:120` mandates `j[7]`, `a[8]`, `v[8]`, `p[8]` — "fixed
+length, never resized". The trivial branch at
+`src/math_tools/otg/calculator_target.py:366-372` builds 7-element `p.a`,
+`p.v`, `p.p`, so `p.p[7]` raises `IndexError` on a trajectory that any other
+path would make safely indexable. The repo's own continuity helper
+(`tests/otg/test_otg_continuity.py:48`, `range(1, 8)`) would raise on such a
+profile.
+
+The same branch never assigns `p.pf`, so `Trajectory.position_extrema()`
+reports `min=0.0` for a trajectory parked at `p=1.0`.
+
+Note: the 7-element form is faithful to `CalculatorTarget.swift:256-261`. The
+spec's fixed-length invariant is the higher authority here (00-overview
+convention 1 ranks spec above line-level fidelity), and the Swift form is a
+latent bug rather than a contract. Fix the port; do not propagate the defect.
+
+## Files
+
+- Edit: `src/math_tools/otg/calculator_target.py`
+- Edit: `tests/otg/test_calculator_target.py`
+
+## Design constraints
+
+1. In the trivial branch, `p.a`, `p.v`, `p.p` become length **8**; `p.t`,
+   `p.t_sum`, `p.j` stay length **7**. Match the lengths every non-trivial
+   path already produces.
+2. Set `p.pf` to the current position in the same branch, so
+   `position_extrema()` reports the parked position rather than `0.0`.
+3. Touch only the trivial branch. The `for dof` loop that follows it (`:378`)
+   is the normal path and is correct.
+4. Add a short comment noting the deliberate divergence from
+   `CalculatorTarget.swift:256-261` and pointing at otg.md §Internal fidelity 1,
+   so the next fidelity audit does not "fix" it back.
+
+## TDD steps
+
+1. Write failing tests: (a) a trivial-target `calculate` yields
+   `len(p.p) == len(p.v) == len(p.a) == 8` and `len(p.t) == 7`; (b)
+   `position_extrema()` on a trajectory parked at a non-zero position returns
+   that position as both min and max, not `0.0`.
+2. Apply the fix.
+3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Trivial-target profile arrays are 8/8/8 and 7/7/7 as spec'd
+- [x] `p.pf` set; `position_extrema()` correct for a parked trajectory
+- [x] Both new tests fail before, pass after
+- [x] Divergence comment present, citing otg.md §Internal fidelity 1
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Any other `CalculatorTarget` path. The phase-sync and discrete-duration
+coverage gaps are chunk 56.
+
+## Resolution notes
+
+- `src/math_tools/otg/calculator_target.py`'s trivial branch (~line
+  366-379) now builds `p.a`/`p.v`/`p.p` as 8-element lists (was 7) and sets
+  `p.pf = input_parameter.current_position[dof]`; `p.t`/`p.t_sum`/`p.j`
+  remain 7-element, matching every other path (`Profile.__init__` in
+  `src/math_tools/otg/profile.py:113-119` is the authoritative fixed-length
+  shape). Added an inline comment citing `CalculatorTarget.swift:256-261`
+  and otg.md §Internal fidelity requirement 1 so a future fidelity audit
+  doesn't "fix" this back to the 7-element Swift form.
+- Confirmed via research that `Trajectory.position_extrema()` /
+  `_profile_position_extrema` (`src/math_tools/otg/trajectory.py:244-291`)
+  only reads `profile.p[i]` for `i in range(7)` (indices 0-6) directly, so
+  the 7-vs-8 length alone wasn't what crashed `position_extrema`; the
+  `IndexError` risk is in code that walks all 8 boundary indices (e.g.
+  `tests/otg/test_otg_continuity.py`'s `range(1, 8)` helper, and any future
+  caller relying on the spec's fixed-length invariant). `position_extrema`'s
+  final min/max check does compare against `profile.pf` (lines 284-289),
+  which is what made the parked-position test fail before the fix (`pf`
+  stayed at its zero-init default in the trivial branch, since that branch
+  never calls `Profile.set_boundary`).
+- Added two tests to `tests/otg/test_calculator_target.py`:
+  `TestTrivialProfileUsesFixedLengthArrays` (array-length assertions) and
+  `TestTrivialProfilePositionExtrema` (parked non-zero position reported
+  correctly by `position_extrema()`). Both were confirmed failing before
+  the fix (`7 != 8` and `0.0 != 5.0`) and passing after.
+- No spec change was needed -- the implementation was brought into
+  conformance with the existing otg.md §Internal fidelity requirement 1,
+  not the other way around.
+- `make uv-fullCheck` is green: ruff clean, mypy strict clean (117 source
+  files), 1359 tests passed (was 1357; +2 new).
diff --git a/.claude/archive/math-tools-port/46-otg-step1-sqrt-guard.md b/.claude/archive/math-tools-port/46-otg-step1-sqrt-guard.md
new file mode 100644
index 0000000..c52a87f
--- /dev/null
+++ b/.claude/archive/math-tools-port/46-otg-step1-sqrt-guard.md
@@ -0,0 +1,104 @@
+---
+chunk: 46-otg-step1-sqrt-guard
+track: F
+status: complete
+depends_on: []
+spec: ../specs/otg.md §Internal fidelity 4
+last_updated: 2026-07-23
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 46 — Apply the IEEE-754 sqrt guard to Step1
+
+## Origin
+
+Post-audit finding E-3 (class **c**). Confirmed by grep:
+`position_third_order_step2.py` uses `_ieee754_sqrt` at **32** sites;
+`position_third_order_step1.py` uses bare `math.sqrt` at **8+** sites
+(`:239, :283, :325, :396, :832, :891, :942, :991`).
+
+Swift's `Double.sqrt` returns `nan` on a negative radicand and lets the `nan`
+propagate into `Profile.check`, which rejects the branch. Python's
+`math.sqrt` raises `ValueError: math domain error` instead. The audit
+reproduced the raise in 6,718/30,000 direct Step1 fuzz calls.
+
+otg.md §Internal fidelity 4 already mandates `_ieee754_sqrt` file-wide for
+exactly this reason; Step1 was simply left unwrapped.
+
+**Severity: latent, not live.** The audit drove 51,733 `validate()`-passing
+1-DOF inputs through `Otg.calculate` and triggered **zero** exceptions — brake
+pre-processing appears to shield the path. Fix it as hardening, not as an
+outage.
+
+## Files
+
+- Edit: `src/math_tools/otg/steps/position_third_order_step1.py`
+- Edit: `tests/otg/steps/test_position_first_second.py` (or the Step1 test file)
+
+## Design constraints
+
+1. Replace every bare `math.sqrt` in this file with the same `_ieee754_sqrt`
+   helper Step2 imports. Do not write a second helper — import the existing one.
+2. Replacement must be mechanical and total: after the change,
+   `grep -n "math.sqrt" src/math_tools/otg/steps/position_third_order_step1.py`
+   returns nothing.
+3. Do not restructure surrounding branch logic. The point is that a negative
+   radicand yields `nan` and the branch is then rejected by `Profile.check`,
+   exactly as in Swift — no new explicit guards, no early returns.
+
+## TDD steps
+
+1. Write a failing test that calls a Step1 solver directly with a boundary
+   condition producing a negative radicand, and asserts it returns/propagates
+   without raising `ValueError` (branch rejected, not crashed). The audit found
+   these via fuzzing; pick one concrete reproducing case and hard-code it.
+2. Apply the replacement.
+3. Re-run the full OTG suite; truth table and comprehensive suites must stay green.
+4. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Zero `math.sqrt` occurrences remain in the file
+- [x] `_ieee754_sqrt` imported from its existing location, not redefined
+- [x] Negative-radicand test fails before (ValueError), passes after
+- [x] Full `tests/otg/` suite green
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Auditing other modules for bare `math.sqrt`. `functional/roots.py` has its own
+divide-by-zero issue — that is chunk 48.
+
+## Resolution notes
+
+- `_ieee754_sqrt` lives in `position_third_order_step2.py` (module-private,
+  no `__all__` export) and was never previously imported cross-module;
+  `position_third_order_step1.py` now imports it directly
+  (`from math_tools.otg.steps.position_third_order_step2 import
+  _ieee754_sqrt`). Verified no circular-import risk: `step2.py` imports
+  nothing from `step1.py` (only `calculator_target.py` imports both, as
+  siblings). No second helper was written, per the design constraint.
+- All 8 sites replaced mechanically via a scoped `sed` pass matching only
+  `math.sqrt(` — `math.nan`, `math.copysign`, `math.inf` (used by the
+  file's existing `_ieee754_div`) were untouched, and the bare `import
+  math` stays because those calls remain.
+- Reproducing test: `PositionThirdOrderStep1(a0=af=-1.0, v0=vf=0.0, pd=1.0,
+  j_max=0.0)` routes `get_profile` to the zero-limits special case
+  (`_time_all_single_step`), where `q = sqrt(2*a0*pd + v0**2) =
+  sqrt(-2)` was the failing call. Confirmed raising `ValueError: math
+  domain error` before the fix; after the fix `_ieee754_sqrt` returns
+  `nan`, `profile.t[3] = nan` fails the immediately-following `>= 0.0`
+  guard (Python's `nan >= 0.0` is `False`), so the branch is silently
+  rejected and `get_profile` returns `False` — `Profile.check` is never
+  even reached for this particular case, an even earlier rejection point
+  than the audit's general nan-propagation account, but consistent with
+  it (the candidate is discarded, not crashed).
+- Added test class `TestPositionThirdOrderStep1NegativeRadicandGuard` to
+  `tests/otg/steps/test_position_third_step1.py` (the existing Step1 test
+  file; `test_position_first_second.py` covers the first/second-order
+  interfaces, not this file, so the chunk's file list's parenthetical
+  alternative was resolved in favor of the file that actually matches).
+- No branch logic restructured; no new explicit guards added, per design
+  constraint 3. Full `tests/otg/` (226 tests) and the repo-wide gate
+  (1360 tests + ruff + mypy) are green.
diff --git a/.claude/archive/math-tools-port/47-position-tolerance-and-timestamp-accessors.md b/.claude/archive/math-tools-port/47-position-tolerance-and-timestamp-accessors.md
new file mode 100644
index 0000000..ad1ba4e
--- /dev/null
+++ b/.claude/archive/math-tools-port/47-position-tolerance-and-timestamp-accessors.md
@@ -0,0 +1,107 @@
+---
+chunk: 47-position-tolerance-and-timestamp-accessors
+track: F
+status: complete
+depends_on: []
+spec: ../specs/spatialMath.md, ../specs/precisionTimeMath.md
+last_updated: 2026-07-23
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 47 — Fix `Position.is_unit` tolerance and pre-epoch timestamp accessors
+
+## Origin
+
+Post-audit findings B-1 and B-2 (class **c**), both confirmed at runtime:
+
+```
+Position(1.00001, 0, 0).is_unit                  -> True    (should be False)
+from_datetime(1969-12-31T23:59:50Z).seconds_of_day -> 10     (should be 86390)
+from_datetime(1960-01-01Z).days_since_epoch        -> +3653  (should be -3653)
+```
+
+Two independent defects, grouped because both are one-line arithmetic fixes in
+Track B accessors with the same test-blindness root cause (only the easy side
+of the boundary was ever tested).
+
+**B-1** — `src/math_tools/spatial/position.py:234` calls
+`np.isclose(self.magnitude, 1.0, atol=1e-12)` but leaves numpy's default
+`rtol=1e-5`, so the effective tolerance is ~1e-5, not the spec's 1e-12.
+
+**B-2** — `src/math_tools/precision_time/precision_timestamp.py:250,255`
+compute `days_since_epoch` / `seconds_of_day` from the **magnitude**
+(`self.seconds`), so pre-epoch timestamps report positive, wrong-direction
+values. The spec declares these as plain accessors on a *signed* epoch offset.
+
+## Files
+
+- Edit: `src/math_tools/spatial/position.py`
+- Edit: `src/math_tools/precision_time/precision_timestamp.py`
+- Edit: `tests/spatial/test_position.py`
+- Edit: `tests/precision_time/test_precision_timestamp.py`
+
+## Design constraints
+
+1. B-1: pass `rtol=0.0` alongside `atol=1e-12` so the spec's absolute
+   tolerance is the only one in effect.
+2. B-2: compute both accessors from the signed offset. `days_since_epoch` must
+   be negative for pre-epoch instants. `seconds_of_day` must be the
+   **wall-clock second within the UTC day**, i.e. always in `[0, 86400)` — use
+   a floor-division/modulo pair, not `abs()`, so 1969-12-31T23:59:50Z yields
+   `86390` and its day index is `-1`.
+3. Do not change the storage representation or any constructor. These are
+   read-side fixes only.
+
+## TDD steps
+
+1. Failing tests first:
+   - `Position(1.00001, 0, 0).is_unit is False`; keep the existing 1.0/2.0
+     cases; add a just-inside case (`1 + 1e-13`) that must stay `True`.
+   - `seconds_of_day` and `days_since_epoch` for a pre-epoch instant
+     (1969-12-31T23:59:50Z → 86390, day −1) and a far pre-epoch instant
+     (1960-01-01Z → days −3653), plus the existing post-epoch case unchanged.
+   - Assert `0 <= seconds_of_day < 86400` holds for both signs.
+2. Apply both fixes.
+3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] `is_unit` rejects 1.00001 and accepts 1 + 1e-13
+- [x] Pre-epoch `days_since_epoch` is negative; `seconds_of_day` ∈ [0, 86400) for both signs
+- [x] All new tests fail before, pass after
+- [x] Existing post-epoch and unit-magnitude tests unchanged and still green
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+The generic-constructor degradation (`Position.from_vector` hardcoding, finding
+B-6) — recorded, no action; see chunk 57's "Recorded — no action" section.
+
+## Resolution notes
+
+Both fixes were exactly the one-liners the plan predicted:
+
+- **B-1** (`src/math_tools/spatial/position.py:234`): added `rtol=0.0` to
+  the `np.isclose` call in `is_unit`, so the spec's `atol=1e-12` is the only
+  tolerance in effect.
+- **B-2** (`src/math_tools/precision_time/precision_timestamp.py:247-258`):
+  `days_since_epoch` / `seconds_of_day` now derive from
+  `self._interval.total_attoseconds` (the signed offset) via a floor-division
+  (`//`) / modulo (`%`) pair against `ATTOSECONDS_PER_SECOND` and
+  `_SECONDS_PER_DAY`, instead of the old `self.seconds` magnitude accessor.
+  Python's `//`/`%` are floor-based for negative operands, which gives the
+  wall-clock-second semantics the spec calls for for free (e.g. `-10 // 86400
+  == -1`, `-10 % 86400 == 86390`) — no `abs()` or explicit sign branching
+  needed.
+
+TDD: added 2 new tests to `tests/spatial/test_position.py`
+(`test_is_unit_false_just_outside_tolerance`,
+`test_is_unit_true_just_inside_tolerance`) and 6 new tests to
+`tests/precision_time/test_precision_timestamp.py` (pre-epoch
+`days_since_epoch`/`seconds_of_day` at the 10s boundary, the far pre-epoch
+1960-01-01 case matching the origin finding, and `[0, 86400)` bound checks
+for both signs). Verified all new tests failed against the pre-fix code
+before applying either fix, then verified green after. No existing test was
+modified. `make uv-fullCheck` (ruff + mypy strict + full 1368-test pytest
+suite) passes clean.
diff --git a/.claude/archive/math-tools-port/48-roots-degenerate-cases.md b/.claude/archive/math-tools-port/48-roots-degenerate-cases.md
new file mode 100644
index 0000000..bf8966e
--- /dev/null
+++ b/.claude/archive/math-tools-port/48-roots-degenerate-cases.md
@@ -0,0 +1,130 @@
+---
+chunk: 48-roots-degenerate-cases
+track: F
+status: complete
+depends_on: []
+spec: ../specs/polynomials.md rules 3-4
+last_updated: 2026-07-23
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 48 — Roots: near-zero leading coefficient and the 0/0 Newton trap
+
+## Origin
+
+Post-audit findings B-7 and B-14. Both live in `functional/roots.py`, which the
+OTG calls per control cycle.
+
+**B-7 (class a/b)** — confirmed at runtime:
+`solve_cubic(1e-10, 2.0, -3.0, -2.0)` returns `[]`; `np.roots` finds a real
+root at `2.0`. polynomials.md rule 4 names near-zero leading coefficient as a
+required degenerate case, but the fallback threshold at
+`src/math_tools/functional/roots.py:86` is `_ULP` (2.2e-16), so a coefficient
+of 1e-10 takes the cubic branch and the solve collapses. The test that looks
+like it covers this (`tests/functional/test_roots.py:104`) passes `a = 0.0`
+*exactly*, and the randomized cross-check at `:208` explicitly `continue`s on
+`abs(a) < 1e-6` — so the gap is masked from both directions.
+
+**B-14 (class a)** — `roots.py:374` computes `dx = f / df` and raises
+`ZeroDivisionError` when `f == 0.0 and df == 0.0`: the bisection guard at
+`:364` evaluates `0 > 0` and `abs(0) > abs(0)` as both false and falls through.
+Swift produces NaN/inf here rather than trapping. Untested.
+
+## Files
+
+- Edit: `src/math_tools/functional/roots.py`
+- Edit: `tests/functional/test_roots.py`
+- Possibly edit: `.claude/specs/polynomials.md` (see constraint 3)
+
+## Design constraints
+
+1. B-7: raise the degeneracy threshold from `_ULP` to a scale-relative test —
+   compare `abs(a)` against the other coefficients' magnitude (e.g.
+   `abs(a) <= eps * max(abs(b), abs(c), abs(d))`), not against an absolute
+   constant. An absolute threshold cannot be right across the coefficient
+   scales this module sees. Pick the epsilon, justify it in a comment, and
+   state it in the spec.
+2. B-14: guard the `f == 0.0 and df == 0.0` case before the division. `f == 0`
+   means the root is already found — return it. Do **not** paper over this with
+   a blanket `try/except ZeroDivisionError`.
+3. If constraint 1 changes the documented threshold semantics, update
+   `.claude/specs/polynomials.md` rule 4 in this same chunk and bump its
+   `semver` (00-overview convention 1).
+4. Keep the module stdlib-only — `tests/functional/test_roots.py` has an AST
+   test pinning this. Use `numpy` only inside tests, as the existing
+   cross-check already does.
+
+## TDD steps
+
+1. Failing tests first:
+   - `solve_cubic(1e-10, 2.0, -3.0, -2.0)` returns a root ≈ 2.0 (cross-check
+     against `np.roots`, filtering to finite real roots).
+   - Sweep the leading coefficient across several decades (1e-4 … 1e-14) and
+     assert agreement with `np.roots` at each — this is what the `continue` at
+     `:208` was suppressing. Remove that `continue`, do not widen it.
+   - A Newton call reaching `f == 0.0 and df == 0.0` returns the root instead
+     of raising `ZeroDivisionError`.
+   - Cover the `solve_resolvent` `count == 2` branch (`roots.py:201-203`),
+     currently unexercised (finding B-8).
+2. Apply both fixes.
+3. Re-run the OTG suite as well — this module is on the OTG hot path and a
+   threshold change can move OTG branch selection. Truth table must stay green.
+4. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Near-zero leading coefficient agrees with `np.roots` across 1e-4…1e-14
+- [x] The `abs(a) < 1e-6` `continue` at test_roots.py:208 is gone, not widened
+- [x] The 0/0 Newton case returns a root; no `ZeroDivisionError`
+- [x] `solve_resolvent` `count == 2` branch covered
+- [x] Spec updated + `semver` bumped if the threshold contract changed
+- [x] `tests/otg/` still green (hot-path regression check)
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+`shrink_interval`'s loose 1e-9 test tolerance (finding B-9) — that is chunk 54.
+
+## Resolution notes
+
+- **B-7 fix** (`roots.py:86`, `_CUBIC_LEADING_COEFF_EPS = 1e-6`): replaced
+  the absolute `abs(a) < _ULP` leading-coefficient degeneracy check with
+  `abs(a) <= 1e-6 * max(abs(b), abs(c), abs(d))`. `1e-6` was picked
+  empirically, not arbitrarily: measured the closed-form cubic branch's
+  error vs. `np.roots` and the quadratic-fallback's error vs. `np.roots`
+  across `a` from `1e-4` to `1e-14` (fixed `b=2, c=-3, d=-2`, the B-7 repro
+  coefficients) — the cubic branch's error grows as `a` shrinks (the
+  `1/a**3` scaling amplifies rounding error, reaching total failure by
+  `a≈1e-9`), while the quadratic fallback's error shrinks as `a` shrinks
+  (`O(a)`, since it's exactly the term being dropped); the two cross near
+  `a / max(|b|,|c|,|d|) ≈ 1e-6`. Below that ratio the quadratic branch is
+  strictly more accurate, so that's where the switch happens. This is
+  documented in the module (constant docstring) and in polynomials.md rule
+  4 (semver bumped 0.0.3 → 0.0.4).
+- **Test tolerance for the decade sweep**: since the quadratic fallback's
+  error is `O(a)`, a fixed `atol` across the 1e-4…1e-14 sweep would either
+  be too loose at the small end or fail at the large end. Used
+  `atol = max(2.0 * a, 1e-9)`, empirically bounding the observed error
+  (worst case ~1.6× the fallback's ratio) with margin.
+- **B-14 fix** (`shrink_interval`, `roots.py:372-380`): added
+  `if f == 0.0: return rts` immediately before the `dx = f / df` Newton
+  step, inside the `else` branch (the one the bisection guard falls through
+  to). No blanket `try/except` — the guard is unconditional on `f == 0.0`
+  because `f == 0` already means the root is found regardless of `df`;
+  computing `dx = 0.0 / df` is redundant work at best and a
+  `ZeroDivisionError` at worst (`df == 0.0` too, e.g. at a root of
+  multiplicity ≥ 2). Repro test brackets `(x-2)^3` on `[1, 3]`: the initial
+  midpoint guess lands exactly on the triple root, where both `f` and `f'`
+  are `0.0` on the very first iteration.
+- **`solve_resolvent` `count == 2` coverage (B-8)**: added
+  `TestSolveResolvent.test_two_real_roots_case` using the resolvent of
+  `(y-2)^2(y+1) = y^3 - 3y^2 + 4`, which takes the `r2 >= q3` branch and
+  collapses `x[2]` to within `_ULP` of `x[1]`. This is a coverage-only
+  addition — no code change was needed for this path (it already worked;
+  it was just untested), consistent with "implemented, untested" finding
+  class (b).
+- **No behavioral surprises** beyond the tolerance-scaling question above.
+  `tests/otg/` (226 tests, 90 subtests) and the full suite (1372 tests)
+  are green; the leading-coefficient threshold change does not visibly
+  move OTG branch selection in the existing oracle corpus.
diff --git a/.claude/archive/math-tools-port/49-waveform-spatial-pose-indexing.md b/.claude/archive/math-tools-port/49-waveform-spatial-pose-indexing.md
new file mode 100644
index 0000000..56da2a9
--- /dev/null
+++ b/.claude/archive/math-tools-port/49-waveform-spatial-pose-indexing.md
@@ -0,0 +1,112 @@
+---
+chunk: 49-waveform-spatial-pose-indexing
+track: F
+status: complete
+depends_on: []
+spec: ../specs/waveformCore.md §Compliance 9
+last_updated: 2026-07-23
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 49 — `WaveformSpatialPose` negative indexing must respect `sample_count`
+
+## Origin
+
+Post-audit findings C-4 and C-5 (correctness, untested). Confirmed at runtime.
+
+`WaveformSpatialPose` holds `positions` and `quaternions` that may differ in
+length; `sample_count` is the min. `__getitem__(int)` at
+`src/math_tools/waveforms/waveform_spatial_pose.py:471-474` indexes both raw
+arrays directly instead of the `sample_count` prefix. On the unequal-length
+state that waveformCore.md §Compliance 9 explicitly contemplates:
+
+```
+len(w) == 2
+w[-1].position == [2,2,2]     # pairs positions[2] with quaternions[1]
+w[1].position  == [1,1,1]     # a pose that never existed
+```
+
+`w[-1]` and `w[1]` disagree despite `len(w) == 2`, and `get(-1)` (`:476`,
+correctly bounded) disagrees with `w[-1]`. The module's own docstring
+(`:27-30`) claims every index path derives from `sample_count`.
+
+`pop` has the same defect (`:542-556`): `pop(-1)` on an unequal instance
+deletes `positions[-1]` and `quaternions[-1]` — two rows that are not the same
+sample.
+
+## Files
+
+- Edit: `src/math_tools/waveforms/waveform_spatial_pose.py`
+- Edit: `tests/waveforms/test_waveform_spatial_pose.py`
+
+## Design constraints
+
+1. Normalize the index against `sample_count` **once**, at the top of each
+   entry point, then index the raw arrays with the normalized non-negative
+   index. `get()` at `:476` already does this correctly — reuse its helper
+   rather than writing a third copy.
+2. Out-of-range must raise `IndexError` consistently with `get()`.
+3. Audit the remaining index paths in this file for the same bug while you are
+   in it (slicing, iteration, `__setitem__` if present) — but only fix what is
+   genuinely the same defect; do not restructure the class.
+4. `WaveformPosition` and `WaveformQuaternion` are single-array containers and
+   are not affected. Do not touch them.
+
+## TDD steps
+
+1. Failing tests first, all on a deliberately unequal-length instance
+   (3 positions, 2 quaternions, `sample_count == 2`):
+   - `w[-1] == w[1]` (the two must agree)
+   - `w[-1] == w.get(-1)` (bracket and `get` must agree)
+   - `w[2]` raises `IndexError` (past `sample_count`, though `positions[2]` exists)
+   - `pop(-1)` removes the sample at index 1 from both arrays and leaves
+     `sample_count == 1`
+2. Apply the fix.
+3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] All four tests fail before, pass after (three of four; see Resolution
+      notes for the one that already passed pre-fix for an unrelated reason)
+- [x] Single shared index-normalization helper; no duplicated bounds logic
+- [x] Docstring at `:27-30` is now true
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Adding `from_components` / `__array__` / `isclose` to the aggregates — that is
+chunk 50.
+
+## Resolution notes
+
+- Added `WaveformSpatialPose._resolve_index(index: int) -> int`
+  (`src/math_tools/waveforms/waveform_spatial_pose.py`), the single shared
+  helper that normalizes an int index against `sample_count` and raises
+  `IndexError` out of range. `__getitem__(int)`, `get()`, and `pop()` all now
+  call it instead of indexing `_positions`/`_quaternions` with the raw index.
+  `get()` wraps the call in `try/except IndexError` to preserve its
+  `None`-on-out-of-range contract.
+- `pop()`'s empty-check now tests `sample_count == 0` (was
+  `len(_positions) == 0 or len(_quaternions) == 0`), consistent with treating
+  `sample_count` as the single source of truth for valid range.
+- Audited slicing (`__getitem__(slice)`) and `__iter__`: both already derive
+  bounds from `sample_count` (`index.indices(self.sample_count)` and
+  `range(self.sample_count)` respectively) — no defect, no change. No
+  `__setitem__` exists on this class (only named mutation verbs
+  `replace`/`replace_range`/`insert`, which the chunk's audit list did not
+  name); left untouched per "do not restructure the class" / stay-in-scope.
+- Deviation from the TDD steps: the 3rd failing test (`w[2]` raises
+  `IndexError` past `sample_count` though the longer raw array has index 2)
+  already passed *before* the fix. `sample_count = min(len(positions),
+  len(quaternions))` guarantees at least one raw array is exactly
+  `sample_count` long, so any index `>= sample_count` always overruns that
+  shorter array and numpy raises `IndexError` on it regardless of the
+  indexing bug — there is no reachable state where a positive
+  beyond-`sample_count` index is in-bounds on both raw arrays. The test is
+  kept (it is still the correct behavioral pin, now true by design rather
+  than by accident) but only 3 of the 4 tests actually demonstrated a
+  pre-fix failure.
+- No spec change: `waveformCore.md` §Compliance 9 and the module docstring
+  already specified sample_count-derived indexing; this chunk closes an
+  implementation gap, not a contract gap.
diff --git a/.claude/archive/math-tools-port/50-aggregate-container-api-idioms.md b/.claude/archive/math-tools-port/50-aggregate-container-api-idioms.md
new file mode 100644
index 0000000..92d9dda
--- /dev/null
+++ b/.claude/archive/math-tools-port/50-aggregate-container-api-idioms.md
@@ -0,0 +1,134 @@
+---
+chunk: 50-aggregate-container-api-idioms
+track: F
+status: complete
+depends_on: [49]
+spec: ../specs/mathToolsArchitecture.md §API idioms (lines 126-128), ../specs/waveformCore.md:137
+last_updated: 2026-07-23
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 50 — Aggregate waveform containers: missing shared API idioms
+
+## Origin
+
+Post-audit findings C-1, C-2, C-3 (class **a**). Confirmed at runtime:
+
+```
+WaveformPosition     array: False  isclose: False  from_components: True
+WaveformQuaternion   array: False  isclose: False  from_components: True
+WaveformSpatialPose  array: False  isclose: False  from_components: False
+```
+
+Three repo-wide idioms that `Position`, `Quaternion`, and `Waveform1D` all
+honor are absent from all three aggregate containers:
+
+- **`__array__`** — mathToolsArchitecture.md:128 ("array-like classes implement
+  `__array__` so `np.asarray(x)` works"), inherited by every chunk via
+  00-overview convention 7.
+- **`isclose(rtol, atol)`** — mathToolsArchitecture.md:126-128. The containers
+  currently offer only exact `==`, which is close to useless for float
+  trajectories.
+- **`from_components`** on `WaveformSpatialPose` — waveformCore.md:137 says all
+  *three* aggregates share it; pose got only `from_poses`/`from_waveforms`,
+  which the spec calls *additional*. Chunk 17 dropped it silently.
+
+Depends on 49 so the pose indexing fix lands first — `__array__` and `isclose`
+must both read through the corrected `sample_count` prefix.
+
+## Files
+
+- Edit: `src/math_tools/waveforms/waveform_position.py`
+- Edit: `src/math_tools/waveforms/waveform_quaternion.py`
+- Edit: `src/math_tools/waveforms/waveform_spatial_pose.py`
+- Edit: `tests/waveforms/test_waveform_position.py`
+- Edit: `tests/waveforms/test_waveform_quaternion.py`
+- Edit: `tests/waveforms/test_waveform_spatial_pose.py`
+
+## Design constraints
+
+1. `__array__` returns the `sample_count`-truncated array, not the raw backing
+   store. For `WaveformSpatialPose` — which has two backing arrays — decide the
+   shape deliberately: prefer a `(sample_count, 7)` stack of
+   `[x, y, z, w, i, j, k]`, document it in the docstring, and state it in
+   waveformCore.md. This is a contract addition, so bump that spec's `semver`.
+2. `__array__` must honor NumPy 2's `copy` argument: raise `ValueError` when
+   `copy=False` is requested and a copy is unavoidable. (`Waveform1D.__array__`
+   at `waveform1d.py:1118-1121` gets this wrong too — finding C-7 — fix it there
+   in the same pass, since it is the same three lines and the same contract.)
+3. `isclose(other, rtol=..., atol=...)` mirrors the signature already used by
+   `Position.isclose` — do not invent a different parameter order. Return
+   `False` on differing `sample_count`. For `WaveformQuaternion` and the
+   quaternion half of `WaveformSpatialPose`, be **double-cover aware**: `q` and
+   `-q` are the same rotation, matching `Quaternion.isclose`.
+4. `WaveformSpatialPose.from_components` takes per-component `Waveform1D`s
+   consistent with the other two aggregates' signature. Read
+   `WaveformPosition.from_components` and follow its shape exactly.
+
+## TDD steps
+
+1. Failing tests first, for each of the three containers:
+   - `np.asarray(w)` returns the documented shape and the truncated sample count
+   - `np.array(w, copy=False)` raises `ValueError`
+   - `isclose` true for a perturbation within tolerance, false outside it,
+     false on differing `sample_count`
+   - quaternion containers: `isclose(w, -w)` is `True` (double cover)
+   - `WaveformSpatialPose.from_components(...)` round-trips against
+     `from_poses`
+2. Implement.
+3. Update `waveformCore.md` with the `__array__` shape contract; bump `semver`.
+4. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] All three containers expose `__array__`, `isclose`, `from_components`
+- [x] `__array__` reads the `sample_count` prefix and honors `copy=False`
+- [x] `Waveform1D.__array__` `copy` contract fixed too
+- [x] Double-cover awareness tested for both quaternion-bearing containers
+- [x] `waveformCore.md` documents the array shape; `semver` bumped
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Generator off-by-one fixes (chunk 51). DSP mixin coverage (chunk 55).
+
+## Resolution notes
+
+- **`Waveform1D.__array__` fix (design constraint 2)** was not listed under
+  this chunk's `## Files`, but the chunk body explicitly directs fixing it
+  "in the same pass" (finding C-7) — treated that instruction as
+  authoritative over the (stale) file list. Added a regression test to
+  `tests/waveforms/test_waveform1d_core.py` (also not in the original file
+  list) for the same reason; no other file outside the listed set was
+  touched.
+- **`isclose` scope beyond the literal test list**: in addition to the
+  required `sample_count` check, all three `isclose` implementations also
+  return `False` on differing `dt`/`t0` (mirroring `Waveform1D.isclose`'s
+  "same `dt`, same `t0`, all samples close" contract). This wasn't spelled
+  out in the TDD steps but follows directly from what "whole-waveform
+  isclose" means for a time series with its own time axis; tests for it were
+  added alongside the required cases.
+- **`isclose` tolerance defaults**: each container's `atol` default mirrors
+  its wrapped element type — `0.0` for `WaveformPosition` (matches
+  `Position.isclose`), `1e-11` for `WaveformQuaternion` (matches
+  `Quaternion.isclose`), and `0.0` for `WaveformSpatialPose` (position
+  default; one `rtol`/`atol` pair is applied uniformly to both the position
+  and quaternion halves — no separate per-half tolerance parameter was
+  introduced, keeping the signature identical in shape to
+  `Position.isclose`).
+- **Double-cover awareness is per-sample, not per-waveform**: for
+  `WaveformQuaternion`/`WaveformSpatialPose`, each row independently may
+  match `other`'s row or its negation (vectorized via
+  `np.isclose(a, b) | np.isclose(a, -b)` reduced per row), not a single
+  "flip everything or nothing" decision — this is the correct vectorization
+  of `Quaternion.isclose`'s per-element double-cover check.
+- **`WaveformSpatialPose.from_components` signature**: chose seven flat
+  `Waveform1D` parameters (`position_x/y/z`, `quaternion_w/x/y/z`) rather
+  than a nested-tuple signature accepting `PositionComponentWaveforms` /
+  `QuaternionComponentWaveforms`, per design constraint 4's "follow
+  `WaveformPosition.from_components`'s shape exactly" — each component stays
+  its own explicit, individually-typed argument, consistent with the sibling
+  constructors.
+- Verified: `make uv-fullCheck` green (ruff clean, mypy strict clean over
+  `src/` + `tests/`, 1410 tests passed).
diff --git a/.claude/archive/math-tools-port/51-waveform-generator-phase-conventions.md b/.claude/archive/math-tools-port/51-waveform-generator-phase-conventions.md
new file mode 100644
index 0000000..2b88e84
--- /dev/null
+++ b/.claude/archive/math-tools-port/51-waveform-generator-phase-conventions.md
@@ -0,0 +1,121 @@
+---
+chunk: 51-waveform-generator-phase-conventions
+track: F
+status: complete
+depends_on: []
+spec: ../specs/waveformCore.md §Generators
+last_updated: 2026-07-23
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 51 — `Waveform1D` generator span off-by-one
+
+## Origin
+
+Post-audit finding C-15 (class **c**). Confirmed at runtime:
+`Waveform1D.heaviside(n=4, dt_seconds=1.0)` → `[0, 0, 1, 1]`, stepping at
+index 2 rather than the midpoint of the sample span `[0, 3]`.
+
+Three generators compute their span as `duration = n * dt_s` when the actual
+sample span of an `n`-sample waveform is `(n-1) * dt_s`:
+
+- `chirp` — `waveform1d.py:292-293`: `sweep_rate` is scaled by `n * dt_s`, so
+  the final sample's instantaneous frequency is not `end_frequency`.
+- `heaviside` — `:443`: default `step_time = n * dt_s / 2.0`.
+- `sigmoid` — `:480`: default `center = n * dt_s / 2.0`.
+
+The only chirp test (`tests/waveforms/test_waveform1d_generators.py:102`) is a
+coarse quarter-vs-quarter zero-crossing comparison that cannot resolve a
+one-sample error.
+
+## Files
+
+- Edit: `src/math_tools/waveforms/waveform1d.py`
+- Edit: `tests/waveforms/test_waveform1d_generators.py`
+- Possibly edit: `.claude/specs/waveformCore.md`
+
+## Design constraints
+
+1. Decide the span convention **once**, explicitly, and apply it to all three:
+   for an `n`-sample waveform starting at `t0`, the last sample is at
+   `t0 + (n-1)*dt`. Endpoint-inclusive. State this in waveformCore.md's
+   generator section — the spec is currently silent, which is why the drift
+   went unnoticed — and bump its `semver`.
+2. Fix the three sites to use `(n - 1) * dt_s`. Guard `n == 1` (span 0) so no
+   generator divides by zero.
+3. Check the remaining generators for the same pattern while you are in the
+   file, but change only ones genuinely affected by the span convention. Do not
+   touch generators whose math does not depend on total duration.
+4. This changes output values for existing callers. That is the point — but
+   call it out in the resolution notes.
+
+## TDD steps
+
+1. Failing tests first:
+   - `heaviside(n=4, dt_seconds=1.0)` steps at the midpoint of `[0, 3]`
+   - `sigmoid`'s default `center` sits at the span midpoint (assert the value
+     at the midpoint sample is 0.5)
+   - `chirp`'s instantaneous frequency at the **final** sample equals
+     `end_frequency` — measure via the final-interval zero-crossing spacing or
+     the analytic phase derivative; the existing quarter-comparison test is not
+     sufficient, so add a real one rather than tightening it
+   - `n == 1` does not raise for all three
+2. Apply the fixes.
+3. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] All three generators use the `(n-1)*dt` span
+- [x] Endpoint convention documented in waveformCore.md; `semver` bumped
+- [x] `n == 1` handled for all three
+- [x] New tests fail before, pass after
+- [x] Resolution notes list the changed output values
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Value-level tests for the other 13 under-tested generators (finding C-9) —
+that is chunk 54.
+
+## Resolution notes
+
+- Added a shared `_span_seconds(n, dt_s) -> (n-1)*dt_s if n > 1 else 0.0`
+  helper in `waveform1d.py` and switched all three sites to it: `chirp`'s
+  `duration` (line ~292), `heaviside`'s default `step_time` (~443),
+  `sigmoid`'s default `center` (~480). `chirp`'s existing
+  `if duration != 0.0 else 0.0` guard already covers the new `n == 1`
+  zero-duration case (previously only reachable at `n == 0`); `heaviside`/
+  `sigmoid` need no extra guard since halving `0.0` isn't a division by
+  zero — verified `n == 1` does not raise for any of the three either way.
+- Confirmed the other 19 generators do not depend on total duration/midpoint
+  and were left untouched (scanned for the `n * dt_s` pattern; only the
+  three named sites matched).
+- Checked pre-fix failure by `git stash`-ing the source fix and running the
+  four new tests against the old code: all four failed, confirming they are
+  real regression tests, not tautologies. Restored the fix and reran full
+  suite green.
+- **Changed output values** (both examples use `dt_seconds=1.0`):
+  - `heaviside(n=5)`: old `[0, 0, 0, 1, 1]` (`step_time=2.5`) → new
+    `[0, 0, 1, 1, 1]` (`step_time=2.0`).
+  - `sigmoid(n=5)`: old `values[2] ≈ 0.3775` (`center=2.5`) → new
+    `values[2] == 0.5` (`center=2.0`).
+  - `chirp(n=201, start_frequency=5, end_frequency=50, dt_seconds=0.001)`
+    (the regression-test case): the realized sweep rate moves from
+    `(50-5)/(201*0.001) ≈ 223.88` Hz/s (old) to `(50-5)/(200*0.001) = 225`
+    Hz/s (new); the final-sample instantaneous frequency, recovered from
+    the generated samples' interpolated zero crossings, moves accordingly
+    from ≈49.78 Hz (old, ~0.45% low) to ≈50.00 Hz (new, matches
+    `end_frequency` exactly as designed). Note `n=4` (the post-audit
+    origin example) happens to produce an *identical* array under both
+    conventions, because the true continuous midpoint (`1.5`) and the old
+    formula's midpoint (`2.0`) both round up to the same first qualifying
+    sample index (`2`) for that specific `n`; the regression tests
+    therefore use `n=5` (heaviside/sigmoid) and `n=201` (chirp), where the
+    conventions diverge at the sample level, per "add a real one rather
+    than tightening it."
+  - As called out in the plan's design constraint 4, this is an intentional
+    behavior change for existing `heaviside`/`sigmoid`/`chirp` callers that
+    relied on the previous (incorrect) `n*dt` span.
+- No spec sections beyond the new "Generators — span convention" paragraph
+  needed changes; `waveformCore.md` bumped `0.0.3` → `0.0.4`.
diff --git a/.claude/archive/math-tools-port/52-subpackage-public-surface.md b/.claude/archive/math-tools-port/52-subpackage-public-surface.md
new file mode 100644
index 0000000..45779d9
--- /dev/null
+++ b/.claude/archive/math-tools-port/52-subpackage-public-surface.md
@@ -0,0 +1,125 @@
+---
+chunk: 52-subpackage-public-surface
+track: F
+status: complete
+depends_on: []
+spec: ../specs/mathToolsArchitecture.md:114-116
+last_updated: 2026-07-23
+semver: 0.0.1
+author: Nicholas Bergantz
+---
+
+# 52 — Empty subpackage `__init__.py` for `spherical` and `math_plot_helpers`
+
+## Origin
+
+Post-audit findings A-1 (class **a**) and A-2 (class **c**). Confirmed:
+`src/math_tools/spherical/__init__.py` and
+`src/math_plot_helpers/__init__.py` are both **0 bytes**.
+
+mathToolsArchitecture.md:114-116 requires each package and subpackage
+`__init__.py` to re-export its public API with `__all__`. 7 public functions in
+`spherical/` (`constructors.py:14`, `spherical_generators.py:62,159`,
+`spherical_transforms.py:33,77,105,131`) and 4 in `plot_unit_spherical.py`
+(`:28,252,488,702`) are unexported.
+
+This cascades into A-2: the same spec line forbids deep module paths
+("consumers import from the subpackage … never deep module paths"), yet
+`README.md:48,61-62` and `examples/sphericalPlotting/*.py` all use deep paths —
+because there is no subpackage-level path to import.
+
+No chunk ever owned this. Chunk 01 explicitly out-of-scoped `__init__.py`
+curation (`01:73-75`); chunk 43 touched only the root. Both packages are
+**pre-existing legacy, not scope violations** — verified via
+`git log --diff-filter=A`, and `mathToolsArchitecture.md:94` names `spherical/`
+in the module map as "behavior unchanged".
+
+## Files
+
+- Edit: `src/math_tools/spherical/__init__.py`
+- Edit: `src/math_plot_helpers/__init__.py`
+- Edit: `README.md`
+- Edit: `examples/sphericalPlotting/plotArcs.py`
+- Edit: `examples/sphericalPlotting/plotQuatUnitCircles.py`
+- Create: `tests/spherical/__init__.py`, `tests/spherical/test_public_surface.py`
+
+## Design constraints
+
+1. Re-exports only, with an explicit `__all__`. No logic in either
+   `__init__.py` — follow the pattern chunk 43 established at
+   `src/math_tools/__init__.py`.
+2. `math_plot_helpers/__init__.py` may import matplotlib transitively; that is
+   allowed for this package and only this package. Re-run
+   `tests/test_package_layering.py` to confirm the one-way rule still holds —
+   `math_tools` must not gain a matplotlib path.
+3. Update README and both example scripts to import from the subpackage, not
+   deep module paths, so documented usage matches the spec's own rule.
+4. Do **not** add these names to the root `math_tools.__all__` — chunk 43 pinned
+   that list to the umbrella spec's 19 names, and widening it requires a spec
+   bump that is not in scope here.
+
+## TDD steps
+
+1. Write a failing test pinning each subpackage's `__all__` and asserting every
+   name imports from the subpackage level (mirroring
+   `tests/test_public_surface.py`'s identity-check shape).
+2. Wire the re-exports.
+3. Update README and the two example scripts; run both scripts to confirm they
+   still execute (they are outside the gate — see chunk 57).
+4. `make uv-fullCheck` green, including the layering test.
+
+## Acceptance criteria
+
+- [x] Both `__init__.py` files export their public API via `__all__`
+- [x] All 11 public functions importable from the subpackage level
+- [x] README and both examples use subpackage imports
+- [x] Both example scripts execute without error
+- [x] `tests/test_package_layering.py` still passes
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Behavioral tests for `spherical/` and `math_plot_helpers/` (finding A-7, 11
+untested public functions) — recorded; see chunk 57's "Recorded — no action" section. This
+chunk pins the surface only.
+
+## Resolution notes
+
+- `src/math_tools/spherical/__init__.py` re-exports 7 functions:
+  `arc_from_two_points` (constructors.py), `generate_spherical_arc_points`,
+  `generate_spherical_small_circle_points` (spherical_generators.py),
+  `cartesian_to_spherical`, `compute_spherical_arc_endpoint`,
+  `plate_carree_transform`, `spherical_to_cartesian`
+  (spherical_transforms.py).
+- `src/math_plot_helpers/__init__.py` re-exports the 4 plotting entry points:
+  `plot_unit_spherical_advanced`, `plot_unit_spherical_polar`,
+  `plot_unit_spherical_3d`, `plot_unit_spherical_multiplot`. The `demo()`
+  function in `plot_unit_spherical.py` is a `__main__`-only demo, not public
+  API, and was intentionally left unexported.
+- TDD was verified literally: the new test file was run against the
+  (temporarily re-emptied) `__init__.py` files first to confirm 13 failures,
+  then the implementation was restored and the test suite re-run green
+  before proceeding.
+- `tests/spherical/test_public_surface.py` pins **both** subpackages'
+  `__all__` in one file (mirroring the two test files named in the chunk's
+  "Files" list — no `tests/math_plot_helpers/` directory was created, since
+  none was listed and none of this chunk's other files needed it).
+- The module-level angle constants in `plot_unit_spherical.py` (`deg45`,
+  `deg90`, `deg180`, `deg22_5`) are not part of the "4 public functions"
+  the origin section confirmed, so they were deliberately left off
+  `math_plot_helpers.__all__`; `examples/sphericalPlotting/plotArcs.py`
+  still imports them via the deep module path (unavoidable — they are not
+  curated public surface).
+- **Adjacent issue found, not fixed (per stay-in-scope):** README.md's
+  "Quaternions" Quick Start section and
+  `examples/sphericalPlotting/plotQuatUnitCircles.py` both import
+  `Quaternion` via the deep path `math_tools.spatial.quaternion` even
+  though `math_tools.spatial` already re-exports `Quaternion` in its
+  `__init__.py` (from chunk 06/07). This is the same deep-path anti-pattern
+  the umbrella spec forbids, but it belongs to the `spatial` subpackage,
+  not this chunk's scope (`spherical`/`math_plot_helpers`, per Origin
+  A-1/A-2). Recording here for a future chunk / chunk 57's docs sweep to
+  pick up.
+- Both example scripts were executed with `MPLBACKEND=Agg` and completed
+  without error (only the expected "FigureCanvasAgg is non-interactive"
+  `plt.show()` warning).
diff --git a/.claude/archive/math-tools-port/53-window-convention-reconciliation.md b/.claude/archive/math-tools-port/53-window-convention-reconciliation.md
new file mode 100644
index 0000000..3002db3
--- /dev/null
+++ b/.claude/archive/math-tools-port/53-window-convention-reconciliation.md
@@ -0,0 +1,134 @@
+---
+chunk: 53-window-convention-reconciliation
+track: F
+status: complete
+depends_on: []
+spec: ../specs/waveformDsp.md §Family contracts
+last_updated: 2026-07-23
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 53 — Reconcile the symmetric/periodic window split between DSP families
+
+## Origin
+
+Post-audit finding D-windowing-(c). Confirmed by grep:
+
+- `_windowing.py:86` — `get_window(..., fftbins=False)` (**symmetric**)
+- `_spectral.py:100` — `get_window(...)` with scipy's default (**periodic**)
+
+So `window_processing_gain(HANN)` and `window_coherent_gain(HANN)` describe a
+different window than `power_spectral_density(window=HANN)` and
+`spectrogram(window=HANN)` actually apply. A caller who uses the gain helpers
+to correct a spectral estimate — the whole reason those helpers exist — gets a
+subtly wrong scale factor.
+
+`_windowing.py:7-12` documents the symmetric choice as deliberate, and it is
+individually defensible; the defect is that the two families disagree and
+nothing spec's or tests the seam.
+
+Also folded in (same seam, same two files): `_DEFAULT_KAISER_BETA = 14.0` is
+hardcoded independently at `_windowing.py:54` and `_spectral.py:80`, with no
+shared constant and no test pinning them equal. The Swift reference makes beta
+caller-supplied (`WaveformWindowType.swift:16`, `case kaiser(beta:)`), so the
+Python surface silently narrows the capability *and* can drift between copies.
+
+## Files
+
+- Edit: `src/math_tools/waveforms/dsp/_windowing.py`
+- Edit: `src/math_tools/waveforms/dsp/_spectral.py`
+- Edit: `src/math_tools/waveforms/support.py` (if beta moves onto the enum)
+- Edit: `tests/waveforms/dsp/test_windowing.py`
+- Edit: `tests/waveforms/dsp/test_spectral.py`
+- Edit: `.claude/specs/waveformDsp.md`
+
+## Design constraints
+
+1. **Decide and document, do not silently unify.** Both conventions are
+   legitimate: symmetric for filter design and gain analysis, periodic for
+   STFT/PSD. The requirement is that the spec states which family uses which
+   and *why*, and that the gain helpers can describe the periodic window when
+   asked. Recommended: keep the per-family defaults, but give the gain helpers
+   and `generate_window` an explicit `periodic: bool = False` parameter so a
+   caller correcting a PSD can request the matching convention.
+2. Update waveformDsp.md §Family contracts with the chosen rule; bump `semver`.
+3. Kaiser beta: single shared constant, imported by both modules — not two
+   literals. If exposing caller-supplied beta (closing the Swift gap) is
+   cheap given the enum shape, do it and spec it; if it forces an enum
+   redesign, keep the shared constant and record the narrowing as a known
+   deviation in the spec. State which path you took and why.
+4. Do not change any existing default behavior of `power_spectral_density` or
+   `spectrogram` — additive parameters only. Existing callers must be unaffected.
+
+## TDD steps
+
+1. Failing tests first:
+   - `generate_window(HANN, n, periodic=True)` equals
+     `scipy.signal.get_window("hann", n)` and `periodic=False` equals
+     `get_window("hann", n, fftbins=False)` — pin both against scipy directly
+   - the gain helpers, asked for the periodic convention, return the gain of the
+     window `power_spectral_density` actually applies
+   - a test asserting the Kaiser beta used by `_windowing` and `_spectral` is
+     the same value, sourced from one constant
+2. Implement.
+3. Update the spec, bump `semver`.
+4. `make uv-fullCheck` green.
+
+## Acceptance criteria
+
+- [x] Spec states the per-family window convention and the rationale
+- [x] Gain helpers can describe either convention; defaults unchanged
+- [x] One shared Kaiser beta constant; equality pinned by test
+- [x] Kaiser-beta decision (expose vs. document narrowing) recorded in the spec
+- [x] `waveformDsp.md` `semver` bumped
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+The broader DSP coverage gaps — chunk 55. The unconsumed support types
+(`WaveformPaddingStrategy`, `WaveformFilterCoefficients`, `WaveformFrequencyRange`,
+`WaveformSpectrogramScaling`) — chunk 57 records the decision.
+
+## Resolution notes
+
+- **Path taken:** kept the per-family defaults (`WindowingMixin` symmetric,
+  `SpectralMixin` periodic) and added an explicit `periodic: bool = False`
+  parameter to `generate_window`, `window_coherent_gain`, and
+  `window_processing_gain` — the recommended path in the design constraints.
+  `windowed` was deliberately left without a `periodic` parameter: it's
+  `WindowingMixin`'s own use case (filter/analysis framing on a whole
+  waveform), not a spectral-estimate-correction helper, so the extra
+  parameter would be unused surface.
+- **Kaiser beta:** moved to a single shared constant,
+  `dsp/_common.DEFAULT_KAISER_BETA = 14.0`, imported by both
+  `_windowing.py` and `_spectral.py` (both re-export it in `__all__` so
+  mypy strict's explicit-reexport check allows the cross-module equality
+  test). `support.py` was **not** touched — `WaveformWindowType` is a flat
+  `str` enum with no `beta` field, and adding a caller-supplied beta would
+  force an enum redesign (out of scope per the chunk's own constraint 3
+  "if it forces an enum redesign, keep the shared constant and record the
+  narrowing"). Recorded as a known Swift-parity deviation in
+  waveformDsp.md's new §Window convention section.
+- **Spec change:** added a new `## Window convention` section to
+  `waveformDsp.md` (between §Family contracts and §Support descriptor
+  types) documenting the symmetric-vs-periodic rule, why each family keeps
+  its own default, the `periodic` parameter fix, and the Kaiser-beta
+  decision. Updated the `WindowingMixin` row of the family-contracts table
+  to show the new parameter. Bumped `semver` 0.0.7 → 0.0.8, `last_updated`
+  → 2026-07-23.
+- **Tests:** added to both `tests/waveforms/dsp/test_windowing.py` (pins
+  `periodic=True`/`False` against `scipy.signal.get_window` directly, pins
+  the gain helpers at `periodic=True` against `_spectral._window_array`'s
+  actual output, pins the two Kaiser constants/arrays equal) and
+  `tests/waveforms/dsp/test_spectral.py` (mirrors the shared-constant pin
+  from that module's side, plus a regression pin that
+  `power_spectral_density`'s default output/window is untouched by the
+  reconciliation).
+- **Surprise:** mypy strict's explicit-reexport rule (no
+  `--no-implicit-reexport` override in this repo) rejected the tests'
+  `module.DEFAULT_KAISER_BETA` attribute access until the constant was
+  added to each module's `__all__` — a one-line fix in both
+  `_windowing.py` and `_spectral.py`, no behavior change.
+- **Gate:** `make uv-fullCheck` green — ruff clean, mypy strict clean
+  (119 source files), pytest 1429 passed (0 failures, 0 skipped).
diff --git a/.claude/archive/math-tools-port/54-test-closure-tracks-bc.md b/.claude/archive/math-tools-port/54-test-closure-tracks-bc.md
new file mode 100644
index 0000000..e2d41ce
--- /dev/null
+++ b/.claude/archive/math-tools-port/54-test-closure-tracks-bc.md
@@ -0,0 +1,185 @@
+---
+chunk: 54-test-closure-tracks-bc
+track: F
+status: complete
+depends_on: [47, 48, 49, 50, 51]
+spec: ../specs/spatialMath.md, ../specs/precisionTimeMath.md, ../specs/polynomials.md, ../specs/waveformCore.md
+last_updated: 2026-07-23
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 54 — Test-coverage closure: Tracks B and C
+
+## Origin
+
+Post-audit class **(b)** findings for Tracks B and C — behavior that is
+implemented but unverified. Runs after the code-fix chunks so the new tests
+pin corrected behavior, not the defects.
+
+**Tests only. No `src/` changes.** If writing a test exposes a genuine defect,
+stop and report it in the resolution notes rather than fixing it here.
+
+## Files
+
+- Edit: `tests/spatial/test_spatial_pose.py`, `tests/spatial/test_quaternion_additions.py`
+- Edit: `tests/functional/test_roots.py`
+- Edit: `tests/waveforms/test_waveform1d_core.py`, `test_waveform1d_operators.py`,
+  `test_waveform1d_generators.py`
+- Edit: `tests/waveforms/test_waveform_position.py`, `test_waveform_quaternion.py`,
+  `test_waveform_spatial_pose.py`
+
+## Gaps to close
+
+**Track B**
+
+1. **B-3/B-12** — `Quaternion.__hash__ is None` is never asserted. spatialMath
+   §Compliance 10 pins it for all three classes; only `Position`
+   (`position.py:380`) and `SpatialPose` (`spatial_pose.py:269`) set it
+   *explicitly*. Add the missing assertion, **and** set it explicitly on
+   `Quaternion` (`quaternion.py:71-72`) — currently `None` only as a dataclass
+   side effect. This is the one permitted `src/` edit in this chunk.
+2. **B-9** — `tests/functional/test_roots.py:258` asserts `shrink_interval`
+   converges to `delta=1e-9`; polynomials.md Compliance 3 requires
+   `POLYNOMIAL_TOLERANCE` (1e-14). Tighten to the spec'd tolerance.
+3. **B-10** — `SpatialPose.isclose`'s double-cover awareness is untested. Add a
+   `q` vs `-q` pose case, plus a negative (must-return-`False`) case; the
+   existing test varies position only and has no false case.
+
+**Track C**
+
+4. **C-8** — operator surface: bitwise `|`, `^`, `>>` have no test at all; no
+   reflected or in-place bitwise test; no `//=`, `%=`; reflected `/`, `//`, `%`
+   untested; length-mismatch pinned only for `+`; `NotImplemented` observed only
+   indirectly. Close all of these.
+5. **C-9** — 13 of 22 generators lack value-level assertions. Specifically:
+   `square`/`digital_square` `duty_cycle` never exercised; `sawtooth`/`triangle`
+   only range-checked; `heaviside` default `step_time`, `sigmoid`
+   `center`/`steepness`, `relu` `slope`, `white_noise` `amplitude`, and
+   `damped_sinusoid`'s analytic form never pinned. (Chunk 51 covers the three
+   span-convention defaults; this covers the rest.)
+6. **C-6** — in-place operators silently change dtype:
+   `Waveform1D([1,2,3]) += 0.5` yields float64 where numpy in-place would raise
+   a casting error; `append(9.7)` / `insert(1, 9.7)` on an int waveform store
+   `9`. Pin the current behavior deliberately after confirming it is intended —
+   if it is not, report rather than fix.
+7. **C-10** — no §Compliance-10 bulk smoke test for `Waveform1D` at all;
+   waveformCore.md:190 requires a 1e6-sample pin. The aggregates use 100 000,
+   not 1e6 (`test_waveform_position.py:260` et al). Add the `Waveform1D` case at
+   1e6 and raise the aggregates to spec.
+8. **C-11** — the ABC accessor `Waveform1D.waveform` (`waveform1d.py:593-596`),
+   the O(n) materialization path waveformCore.md:43 calls load-bearing, has no
+   direct test.
+9. **C-12** — `replace_range` is tested only at equal length
+   (`test_waveform1d_core.py:338`); §Compliance 7's "match stdlib list
+   semantics" is unverified for unequal-length slice assignment. numpy requires
+   equal length where a list does not — pin whichever the spec means.
+10. **C-13** — `subset_time` boundary clamping (start before `t0`, end past the
+    span) is unpinned.
+11. **C-14** — aggregate `pop` with an out-of-range index untested for all three
+    containers (only the empty case is covered).
+
+## Design constraints
+
+1. Assertions must be **value-level** — known-answer or analytic. A test that
+   checks only shape, dtype, length, or "did not raise" does not close a (b)
+   finding and will be rejected at review.
+2. Follow the existing file's `unittest.TestCase` style and naming.
+3. Only permitted `src/` edit: the explicit `__hash__ = None` on `Quaternion`
+   (gap 1). Anything else, report.
+
+## Acceptance criteria
+
+- [x] All 11 gaps have value-level tests
+- [x] Every new test observed failing against deliberately broken behavior before being accepted
+- [x] `Quaternion.__hash__ = None` set explicitly and asserted
+- [x] `shrink_interval` tolerance tightened to 1e-14
+- [x] `Waveform1D` bulk test at 1e6; aggregates raised to 1e6
+- [x] No `src/` changes beyond gap 1
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+DSP mixin coverage (chunk 55). OTG coverage (chunk 56).
+
+## Resolution notes
+
+All 11 gaps closed, tests only, one permitted `src/` edit
+(`Quaternion.__hash__ = None`, `src/math_tools/spatial/quaternion.py`).
+
+- **B-3/B-12**: `Quaternion.__hash__` was already `None` as a dataclass side
+  effect (unfrozen `@dataclass` with default `eq=True`); made it explicit
+  per spec and added `TestHashability` to
+  `tests/spatial/test_quaternion_additions.py`.
+- **B-9**: `shrink_interval`'s quintic-bracket test tightened from
+  `delta=1e-9` to `roots.POLYNOMIAL_TOLERANCE` (1e-14); confirmed the solver
+  already converges exactly (`found - 2.0 == 0.0`) before tightening.
+- **B-10**: added a `q`/`-q` double-cover `isclose` case and a genuine
+  negative (different-orientation) case to `TestComparison` in
+  `test_spatial_pose.py`.
+- **C-8**: closed all named gaps in `test_waveform1d_operators.py` — `|`,
+  `^`, `>>`; reflected and in-place bitwise (`&=`, `|=`, `^=`, `<<=`, `>>=`);
+  `//=`, `%=`; reflected `/`, `//`, `%`; length-mismatch pinned for every
+  binary/bitwise op (previously only `+`); and a direct
+  `w.__add__(...) is NotImplemented`-style check (previously only observed
+  indirectly via the resulting `TypeError`).
+- **C-9**: added value-level (analytic-formula) pins for `square`/
+  `digital_square` `duty_cycle`, `sawtooth`/`triangle`, `sigmoid`
+  `center`/`steepness`, `relu` `slope`, `white_noise` `amplitude`, and
+  `damped_sinusoid`'s envelope×oscillation form, in
+  `test_waveform1d_generators.py`. (`heaviside`/`sigmoid`/`chirp` default
+  span-convention behavior was already covered by chunk 51's
+  `TestGeneratorSpanConvention`; only added one extra explicit-`step_time`
+  case there.)
+- **C-6**: confirmed and pinned as intentional (not a defect): in-place
+  arithmetic operators (`+=` etc.) reassign a freshly-constructed result
+  rather than mutating the numpy buffer in place, so they silently *promote*
+  dtype on mixed int/float arithmetic (`Waveform1D([1,2,3]) += 0.5` ->
+  `float64`) instead of raising numpy's native `same_kind` casting error.
+  `append`/`insert` go the other way — they cast the incoming value to the
+  existing dtype via `np.asarray(value, dtype=...)`, so a float value onto
+  an int waveform truncates (`append(9.7)` stores `9`). Both directions
+  pinned by test (`TestInPlaceOperatorDtypePromotion` in the operators file;
+  two new cases in `TestSpecCompliance7Mutation` in the core file).
+- **C-10**: added a 1e6-sample `Waveform1D` arithmetic+stats smoke test
+  (`TestSpecCompliance10VectorizedBulkOps` in `test_waveform1d_core.py`,
+  ~0.1s locally) and raised the three aggregate smoke tests
+  (`test_waveform_position.py`, `test_waveform_quaternion.py`,
+  `test_waveform_spatial_pose.py`) from `100_000` to `1_000_000` samples per
+  waveformCore.md:190, keeping the existing generous 5s bound (measured
+  ~0.02s locally at 1e6).
+- **C-11**: added a direct test of the `Waveform1D.waveform` ABC accessor
+  (`test_waveform_abc_accessor_returns_samples_as_float_list`).
+- **C-12**: `replace_range` does not implement stdlib list slice-assignment
+  semantics (which resize the sequence); it does a direct numpy assignment
+  `self._values[index] = np.asarray(values, dtype=...)`. This means: (a) a
+  replacement longer than the slice raises `ValueError` (numpy "could not
+  broadcast" — pinned), and (b) a single-element replacement *broadcasts*
+  across the whole slice rather than shrinking the waveform (pinned as its
+  own case, since it is neither the numpy-`ValueError` behavior nor the
+  stdlib-list-shrink behavior). This is a genuine (if narrow) divergence
+  from "match stdlib list semantics" as literally read, but the module is
+  explicitly numpy-backed (waveformCore.md's storage column) and stdlib-list
+  resizing semantics for slice assignment were never separately specified;
+  reported here per the chunk's instructions rather than changed, since
+  fixing it would be a `src/` behavior change outside this chunk's scope.
+- **C-13**: added `subset_time` boundary-clamping tests — start before `t0`,
+  end past the span, and both simultaneously — confirming the existing
+  `np.searchsorted`-based implementation already clamps correctly (no `src/`
+  change needed).
+- **C-14**: added an out-of-range `pop` test (`IndexError`) for all three
+  aggregate containers (`WaveformPosition`, `WaveformQuaternion`,
+  `WaveformSpatialPose`); only the empty case was previously covered.
+
+**Verification**: every new/changed assertion was confirmed to actually
+exercise the claimed behavior — either by directly observing the real
+runtime value before writing the pin (dtype promotion, `replace_range`
+broadcast, `subset_time` clamping, `pop` `IndexError`, `shrink_interval`'s
+exact convergence), or by injecting a deliberate defect into the relevant
+`src/` line, watching the new test fail, then reverting via `Edit` (spot
+-checked `Waveform1D.__ror__` using `operator.and_` instead of `operator.or_`,
+and `sigmoid`'s logistic exponent doubled) and confirming `git status`/`git
+diff` showed no residual `src/` change afterward.
+
+No genuine spec violations were found; no gap required weakening a test to
+pass.
diff --git a/.claude/archive/math-tools-port/55-test-closure-dsp.md b/.claude/archive/math-tools-port/55-test-closure-dsp.md
new file mode 100644
index 0000000..a364b3e
--- /dev/null
+++ b/.claude/archive/math-tools-port/55-test-closure-dsp.md
@@ -0,0 +1,229 @@
+---
+chunk: 55-test-closure-dsp
+track: F
+status: complete
+depends_on: [53]
+spec: ../specs/waveformDsp.md
+last_updated: 2026-07-23
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 55 — Test-coverage closure: DSP mixins (Track D)
+
+## Origin
+
+The 18 class **(b)** findings from the Track D audit — the track's dominant
+defect class, concentrated in `FilteringMixin` (6), `SpectralMixin` (5), and
+`ResamplingMixin` (5). Runs after chunk 53 so window-convention tests pin the
+reconciled contract.
+
+**Tests only. No `src/` changes.** If a test exposes a genuine defect, stop and
+report it in the resolution notes.
+
+This chunk is large. Execute it family by family, running the suite after each
+family, rather than writing everything and running once.
+
+## Files
+
+- Edit: `tests/waveforms/dsp/test_correlation.py`, `test_envelope.py`,
+  `test_spectral.py`, `test_filtering.py`, `test_peaks.py`, `test_phase.py`,
+  `test_resampling.py`, `test_time_alignment.py`, `test_triggers.py`,
+  `test_windowing.py`, `test_zero_crossings.py`
+
+## Gaps to close, by family
+
+**Highest value first** — the first three are spec-mandated behaviors with zero
+coverage:
+
+1. **Filtering `causal=True`** (`_filtering.py:208,228,251,278`) — never set to
+   `True` anywhere (`grep -rn causal tests/` returns nothing), so the `lfilter`
+   branch of `_apply_iir` (`:136`) is entirely untested despite waveformDsp.md
+   §Numerical conventions mandating the flag.
+2. **`savitzky_golay_filter(deriv > 0)`** (`_filtering.py:356`) — the only place
+   `delta=dt_seconds` is applied. A wrong `delta` silently returns per-sample
+   instead of per-second derivatives. Verified live: `(11, 3, deriv=1)` on a
+   50 Hz sine returns ~322, i.e. correct 1/s units — pin that number.
+3. **`resampled` value assertions** (`_resampling.py:205`) — currently checks
+   only `dt`, length, `t0`. waveformDsp.md §Compliance 1 names by title
+   "`resampled` ×2 then ÷2 round-trips (rtol 1e-3, interior)"; the suite
+   substitutes `interpolated(2).decimated(2)`. Add the spec's actual case.
+
+**Filtering**
+4. `_validate_order` (`:63`, `order < 1`) never triggered for any Butterworth
+   method — the raise-don't-clamp policy's load-bearing path.
+5. `_validate_cutoff` lower bound (`:68`, `cutoff_hz <= 0`) untested.
+6. `frequency_response` (`:406`) — `phases` never asserted; BAND_PASS and
+   BAND_STOP never requested.
+7. `exponential_filter` (`:162`) — pinned only at `alpha=1.0`, first-sample
+   equality, and `values[20] < 1.0`. A swapped `alpha`/`1−alpha` survives all
+   three. Compute the closed form `y[i] = α·x[i] + (1−α)·y[i−1]` for a specific `i`.
+
+**Spectral**
+8. `scaling: WaveformPSDScaling` (`:232`) never passed. `DENSITY` and `SPECTRUM`
+   differ ~11× on a 50 Hz tone at fs=2 kHz — pin both.
+9. `window: WaveformWindowType` (`:231,268,292`) never varied from `HANN`;
+   `_window_array`/`_scipy_window_spec` KAISER branch unreached.
+10. `mel_spectrogram` (`:289`) — shape/non-negativity/raises only; assert mel
+    magnitudes concentrate in the band containing a known tone.
+11. `WaveformSpectralFeatures` (`:379-394`) — only `centroid` has a known answer;
+    `spread`/`rolloff`/`flatness` have range checks that a swapped mean or a
+    power-vs-magnitude rolloff would pass.
+
+**Resampling**
+12. `NEAREST` (`:116`) never used — including its banker's-rounding half-sample bias.
+13. `FOURIER` (`:102`) never used.
+14. `resampled_to_match` (`:226`) — samples never compared to the reference.
+15. `polyphase_resampled` (`:236`) — no numeric check against the source.
+
+**Others**
+16. `cross_correlation(normalized=False)` (`_correlation.py:155`) — raw-energy
+    branch has no numeric assertion.
+17. Envelope: `upper_lower_envelopes` (`:106`) never asserts upper ≈ `+A` /
+    lower ≈ `−A` for `A·sin`; `_windowed_rms` (`:80`) has no known answer and
+    even-`window_size` (asymmetric pad + truncation, `:88`) is unexercised;
+    `_peak_envelope` (`:67`) never asserts a sine's rectified peak ≈ amplitude.
+18. `WaveformPeakWithProminence.prominence` (`_peaks.py:144`) — only ordering
+    asserted, never the numeric value; `find_most_prominent_peaks` `min_distance`
+    (`:131`) never passed.
+19. `unwrap_phase` `threshold` (`_phase.py:107`) never varied; `phase_coherence`
+    default `window` expression (`:187`) never exercised.
+20. `time_lag` `max_lag` (`_time_alignment.py:171`) never passed.
+21. `minimum_interval` dedup (`_triggers.py:245,266,286`) verified through 1 of
+    5 entry points.
+22. Windowing: coefficients verified only for `HANN`; `HAMMING`, `BLACKMAN`,
+    `BARTLETT`, `KAISER` checked only for shape — a wrong `_WINDOW_NAME_MAP`
+    entry (`:56`) passes. `window_processing_gain` known-answer only for
+    `RECTANGULAR`; HANN's analytic `sqrt(3/8) ≈ 0.6124` is available (impl
+    returns 0.61207 at n=1001) but unpinned.
+23. `segments_between_zero_crossings` (`_zero_crossings.py:178`) — inclusive
+    `[start:stop+1]` slicing (`:206`) unpinned on a hand-computed case.
+
+## Design constraints
+
+1. **Known-answer or analytic assertions only.** Shape, dtype, length,
+   non-negativity, monotonicity, and "did not raise" do not close a (b) finding.
+   Where scipy is the reference, assert against a direct scipy call with the
+   same parameters.
+2. Derive expected values analytically where the math permits (window
+   coefficients, processing gains, exponential-filter recursion, SG derivative
+   units). Fall back to pinning observed output only where no analytic form
+   exists — and say so in the test docstring.
+3. Do not loosen any existing tolerance to make a new test pass.
+
+## Acceptance criteria
+
+- [x] All 23 gaps closed with value-level assertions
+- [x] Gaps 1–3 (the spec-mandated zero-coverage paths) closed first and verified
+- [x] No existing tolerance loosened
+- [x] No `src/` changes; any defect found is reported, not fixed
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+Track B/C coverage (chunk 54). OTG coverage (chunk 56).
+
+## Resolution notes
+
+Executed family by family per the chunk's own instruction, running
+`tests/waveforms/dsp/<family>` after each file before moving to the next; all
+23 gaps closed with either a direct-library-reference comparison
+(`scipy.signal.*`/`np.unwrap`/`np.fft.rfft` called directly in the test with
+the same parameters) or a hand-derived analytic expected value, per Design
+constraint 1/2. No existing test or tolerance was touched — every change is a
+net-new test class appended to its file.
+
+- **Gaps 1–3** (spec-mandated, zero coverage): `causal=True` pinned against a
+  direct `scipy.signal.lfilter` call for low/high/band-pass and the `filtered`
+  dispatcher, plus a same-vs-different check against the `filtfilt` default
+  (`test_filtering.py`). `savitzky_golay_filter(deriv=1)` pinned against a
+  direct `scipy.signal.savgol_filter(..., delta=dt_seconds)` call and against
+  the analytic derivative `2*pi*f*A*cos(...)` on the interior — the chunk's
+  own "verified live: ~322" example did not reproduce exactly under any
+  `(n, fs)` combination tried (own runs landed ~310–314, i.e. `2*pi*50`), so
+  the test pins the actually-observed/analytically-correct value rather than
+  the chunk doc's illustrative number; the load-bearing assertion (a wrong
+  `delta` producing per-sample instead of per-second units) is unambiguously
+  caught either way, since a per-sample result would be off by a factor of
+  `dt_seconds` (~2000x here), not a few percent. `resampled` x2-then-/2 is now
+  tested literally (`test_resampling.py`), distinct from the pre-existing
+  `interpolated(2).decimated(2)` substitute the spec called out.
+- **Gaps 4–7** (Filtering): `order < 1` and `cutoff_hz <= 0` now raise-tested
+  for every Butterworth-backed method. `frequency_response`'s `phases` and
+  BAND_PASS/BAND_STOP are pinned against a direct `scipy.signal.freqz` call.
+  `exponential_filter`'s closed form is pinned at a specific interior sample
+  (plus a "swapped-alpha would not match" sanity check proving the pin is
+  load-bearing).
+- **Gaps 8–11** (Spectral): `WaveformPSDScaling.DENSITY`/`SPECTRUM` each pinned
+  against a direct `scipy.signal.welch` call and shown to diverge by ~5.9x
+  (not the chunk doc's illustrative "~11x", but clearly material) on a 50 Hz
+  tone at fs=2 kHz. KAISER window exercised for both `power_spectral_density`
+  and `spectrogram`, pinned against direct scipy calls with the same
+  `(kaiser, DEFAULT_KAISER_BETA)` window array. `mel_spectrogram` now asserts
+  a 1 kHz tone's energy concentrates (>50%) in the mel band nearest 1 kHz.
+  `spectral_features` gained a two-tone (10 Hz amplitude 1, 100 Hz amplitude
+  3, both exact-bin-resolved so no spectral leakage) known-answer suite:
+  `centroid`/`spread` pinned to hand-derived weighted-mean/weighted-std closed
+  forms, `rolloff` pinned to land exactly on the 100 Hz bin, `flatness` pinned
+  against an independently-computed geomean/arithmean over the raw FFT
+  magnitude array (not by calling any private helper).
+- **Gaps 12–15** (Resampling): `NEAREST` pinned on a hand-computed
+  banker's-rounding (round-half-to-even) case at exactly-.5 target positions.
+  `FOURIER` pinned against a direct `scipy.signal.resample` call.
+  `resampled_to_match` and `polyphase_resampled` each gained a numeric
+  comparison against a direct `scipy.signal.resample`/`resample_poly` call
+  (previously only length/`dt` were checked).
+  `resampled` x2-then-/2 round trip (rtol 1e-3, interior) added per gap 3.
+- **Gap 16** (Correlation): `cross_correlation(normalized=False)` pinned
+  against a direct `scipy.signal.correlate` call, plus a lag-0-equals-energy
+  check.
+  **Deviation:** this gap targeted `_correlation.py:155`, which does not
+  actually branch on `normalized` for the raw-energy path (the same
+  `_cross_correlation_and_lags` helper handles both); the new tests still
+  close the coverage gap the chunk describes (no numeric assertion previously
+  existed for `normalized=False`).
+- **Gap 17** (Envelope): `upper_lower_envelopes` now asserts upper ≈ `+A` /
+  lower ≈ `−A` on the interior for `A·sin` (with a larger boundary trim than
+  the Hilbert-based `amplitude_envelope` needs, since the peak-interpolated
+  envelope's first/last anchors are the boundary samples, not extrema).
+  `_windowed_rms` gained odd- and even-`window_size` known-answer tests at a
+  strictly interior index, hand-derived from the documented centered/edge-pad
+  construction (not by re-executing the private helper's own code — the
+  even-window case independently derives the asymmetric `[i-half, i+half)`
+  span from the module docstring's own description). `PEAK` method
+  (`instantaneous_amplitude`) now asserts interior ≈ amplitude for a sine.
+- **Gap 18** (Peaks): `WaveformPeakWithProminence.prominence` pinned against a
+  direct `scipy.signal.peak_prominences` call. `find_most_prominent_peaks`
+  `min_distance` now exercised (mirrors the existing `detect_peaks`
+  `min_distance` test).
+- **Gap 19** (Phase): `unwrap_phase`'s `threshold` now varied via a
+  hand-constructed borderline case (constant 3.3 rad/sample step, which a
+  `threshold=3.4` leaves untouched but the default `threshold=pi` corrects) —
+  pinned both against a direct `np.unwrap(..., discont=...)` call and via a
+  "differs from raw" sanity check. `phase_coherence`'s default `window`
+  expression (`min(256, max(1, sample_count // 4))`) exercised on both its
+  unclamped (`n=40`) and clamped (`n=2000`) branches, each compared to the
+  matching explicit `window=` call.
+- **Gap 20** (Time alignment): `time_lag`'s `max_lag` now exercised (mirrors
+  the existing `find_max_correlation` `max_lag` test), showing the restricted
+  search finds a materially different (bounded) lag than the unrestricted one.
+- **Gap 21** (Triggers): `minimum_interval` dedup extended from its 1-of-5
+  existing coverage (`detect_edge_triggers`) to all 5 entry points:
+  `detect_level_triggers`, `detect_window_triggers`, `detect_pattern_triggers`,
+  and `detect_triggers`'s generic dispatch (asserted to match the direct
+  method's deduped output).
+- **Gap 22** (Windowing): HAMMING/BLACKMAN/BARTLETT/KAISER/RECTANGULAR now
+  pinned as full coefficient arrays against direct `scipy.signal.get_window`
+  calls (previously HANN-only; the rest were shape-only, so a wrong
+  `_WINDOW_NAME_MAP` entry would have passed). `window_processing_gain(HANN)`
+  pinned against the analytic `sqrt(3/8) ≈ 0.6124` (delta 1e-3, matching the
+  chunk doc's observed 0.61207 at n=1001).
+- **Gap 23** (Zero crossings): `segments_between_zero_crossings`'s inclusive
+  `[start:stop+1]` slicing pinned on the hand-computed `[1, -1, 1, -1, 1]`
+  alternating-sign case (4 segments, each length 2, sharing every interior
+  boundary sample).
+- **No `src/` defects found.** Every gap closed cleanly against the existing
+  implementation; no test exposed a spec violation requiring a stop-and-report.
+- **Gate:** `make uv-fullCheck` green — ruff clean (one import-order autofix
+  applied to `test_spectral.py` via `ruff check --fix`, no manual edit), mypy
+  strict clean (119 source files), pytest 1537 passed (0 failures, 0 skipped).
diff --git a/.claude/archive/math-tools-port/56-test-closure-otg-oracles.md b/.claude/archive/math-tools-port/56-test-closure-otg-oracles.md
new file mode 100644
index 0000000..49348b5
--- /dev/null
+++ b/.claude/archive/math-tools-port/56-test-closure-otg-oracles.md
@@ -0,0 +1,274 @@
+---
+chunk: 56-test-closure-otg-oracles
+track: F
+status: complete
+depends_on: [44, 45, 46]
+spec: ../specs/otg.md §Oracle, §Internal fidelity 3
+last_updated: 2026-07-23
+semver: 0.1.0
+author: Nicholas Bergantz
+---
+
+# 56 — Test-coverage closure: OTG oracles
+
+## Origin
+
+Post-audit class **(b)** findings for Track E. This is the most consequential
+coverage chunk in the set: the audit established that the OTG oracle corpus is
+far narrower than its size suggests.
+
+Runs after the three OTG code fixes so new oracles pin corrected behavior.
+
+**Tests and test data only. No `src/` changes.**
+
+## The headline gap
+
+`tests/otg/data/successful_trajectories.json` + `failed_trajectories.json` —
+1,784 cases, and **every single one** is 1-DOF / Position / Time-sync /
+Continuous / no waypoints. Confirmed:
+
+```
+successful: 1682   dofs {1: 1682}  Position 1682  Time 1682  Continuous 1682
+failed:      102   dofs {1: 102}   Position 102   Time 102   Continuous 102
+```
+
+Combined with the 1-DOF fast path at `calculator_target.py:546`, the audit
+instrumented `PositionThirdOrderStep2.get_profile` and confirmed it is invoked
+**exactly 0 times across all 1,784 corpus cases**. The 2,744-line Step2 module —
+the largest, hardest file in the port, and the one chunk 44 just fixed a
+transcription defect in — has no oracle coverage. Its only tests are 3 boundary
+conditions × 3 scale factors.
+
+## Files
+
+- Edit: `tests/otg/test_otg_continuity.py`, `test_otg_driver.py`,
+  `test_otg_invariants.py`, `test_otg_comprehensive.py`
+- Edit: `tests/otg/test_calculator_target.py`
+- Edit: `tests/otg/steps/test_position_third_step2.py`
+- Create: multi-DOF corpus data under `tests/otg/data/`
+
+## Gaps to close
+
+1. **Multi-DOF corpus (E-4).** Generate a corpus that actually reaches Step2:
+   ≥2 DOF, so the 1-DOF fast path is bypassed. Verify reach by instrumenting
+   `PositionThirdOrderStep2.get_profile` and asserting a non-zero invocation
+   count — do not assume coverage, measure it, and record the count in the
+   resolution notes. This is the acceptance signal for the whole chunk.
+2. **Phase synchronization (E-5).** `_is_input_collinear`
+   (`calculator_target.py:154`) has **0% statement coverage (0/50)**, measured
+   by `sys.settrace` over all 222 passing OTG tests. `Synchronization.PHASE`
+   appears only as an enum-value assertion and a field assignment; it is never
+   driven through `calculate`. otg.md §Internal fidelity 3 requires this path.
+3. **Discrete duration (E-6).** `calculator_target.py:543` never exercised
+   end-to-end. Same for `minimum_duration` (never passed to `calculate`),
+   `Synchronization.TIME_IF_NECESSARY`, and `ControlInterface.VELOCITY` (never
+   driven through `calculate`/`update` — only `InputParameter.validate`).
+   `TargetCalculator.calculate` overall sits at **45% (89/198 statements)**.
+4. **Continuity across `update` cycles (E-7).** `test_otg_continuity.py:33`
+   never calls `update()` and never crosses a section boundary; all 5 cases call
+   `Otg.calculate`. The file's own docstring concedes it is "a self-consistency
+   check on the profile's internal bookkeeping, not a comparison against an
+   external oracle." Chunk 42 design constraint 3 and otg.md §Oracle 3 both
+   require continuity across consecutive `update` cycles *including at section
+   changes*. Add real cross-cycle continuity, asserting across a
+   `did_section_change` transition.
+5. **New target mid-trajectory (E-8).** No test pins it. The audit verified the
+   behavior works (retarget at cycle 11 of a 90-cycle move triggers exactly one
+   extra recalculation and converges to `-3.000000000000001`), but
+   `TestUpdateLoopReachesFinishedWithinBound` drives an unchanging input, and the
+   `new_calculation` assertion (`:109-110`) asserts the *absence* of
+   recalculation, never its presence on a genuine mid-flight change.
+6. **Intra-cycle limit violations (E-9).** `test_otg_invariants.py:142` samples
+   `new_velocity`/`new_acceleration`/`new_jerk` only at control-cycle instants,
+   1-DOF, 50 cases — intra-cycle peaks are invisible. Sample the trajectory
+   densely *within* cycles. Also: invariant (2) is evaluated on the last
+   re-planned trajectory (after `pass_to_input` at `:163` re-plans every cycle),
+   not the originally planned one, which substantially weakens "at_time(duration)
+   hits the target". Assert against the originally planned trajectory.
+7. **Under-covered Step2 branches (E-10).** `check_root_udud` (`:1041`) at
+   **3% (1/29)** and live (reachable from `_time_vel`'s UDUD branch);
+   `_time_acc0_vel` 34%, `_time_acc1_vel` 44%, `_time_acc0_acc1` 48%. The
+   multi-DOF corpus (gap 1) should reach these — measure and report which
+   remain uncovered. `_time_none_smooth` (`:2415`, 0%) is dead in Swift too and
+   documented as such: **no action, recorded**.
+8. **Missing Swift case (E-11).** Swift `OTGComprehensiveTests.swift:312`
+   defines **5** `testBugFix_*` cases; the port lands **4**.
+   `testBugFix_NegativeTimeInterval_Case3` is silently absent, and both the
+   module docstring (`test_otg_comprehensive.py:12`) and chunk 42:134 claim all
+   4/all cases are ported. It matters: the only port of that input
+   (`test_otg_failure_fixes.py:169`) wraps every assertion in `if result >= 0:`,
+   so a regression to an error `Result` would assert nothing, whereas the
+   comprehensive contract requires unconditional success. The audit ran it —
+   it passes today (`result=0`, `dur=3.5809`, target hit, `maxv=6.279 ≤ 6.282`,
+   `maxa=9.128 ≤ 9.974`). Port it and fix both docstring claims.
+
+## Design constraints
+
+1. **Measure, don't assume.** Gaps 1, 2, 3, 7 are coverage claims — report
+   before/after statement coverage for `_is_input_collinear`,
+   `TargetCalculator.calculate`, `check_root_udud`, and Step2's
+   `get_profile` invocation count.
+2. Do not loosen any tolerance. The existing 1e-6 segment-time atol was
+   human-approved with a recorded rationale and stays as is.
+3. No `pytest.skip`, `xfail`, or `expectedFailure` in new tests. If a case
+   cannot be made to pass, report it as a defect — do not park it.
+4. Generated corpus data must be reproducible: commit the generator script or a
+   fixed seed alongside the data.
+
+## Acceptance criteria
+
+- [x] Multi-DOF corpus lands; Step2 `get_profile` invocation count > 0, measured and reported
+- [x] `_is_input_collinear` coverage > 0%, measured and reported
+- [x] Discrete-duration, `minimum_duration`, `TIME_IF_NECESSARY`, and VELOCITY interface each driven through `calculate`/`update`
+- [x] Continuity asserted across `update` cycles including a `did_section_change` transition
+- [x] Mid-trajectory retarget test pins the recalculation *and* convergence
+- [x] Limits checked intra-cycle, not only at cycle instants; invariant (2) against the originally planned trajectory
+- [x] `testBugFix_NegativeTimeInterval_Case3` ported; docstring and chunk 42 claims corrected
+- [x] `TargetCalculator.calculate` coverage materially above 45%; report the number
+- [x] No skips/xfails; no tolerance loosened
+- [x] `make uv-fullCheck` passes
+
+## Out of scope
+
+`_time_none_smooth` coverage — dead in Swift, recorded as no-action.
+
+## Resolution notes
+
+**Files touched.** `tests/otg/test_calculator_target.py`,
+`tests/otg/test_otg_continuity.py`, `tests/otg/test_otg_driver.py`,
+`tests/otg/test_otg_invariants.py`, `tests/otg/test_otg_comprehensive.py`,
+`tests/otg/steps/test_position_third_step2.py` (docstring-only coverage
+note, no new cases), `tests/otg/data/generate_multi_dof_corpus.py` (new),
+`tests/otg/data/successful_trajectories_multi_dof.json` (new, 450 cases),
+and `.claude/action-plan/42-otg-oracle-suites.md` (correcting its "all 4"
+`testBugFix_*` claim per gap 8's explicit instruction — the only `src/`-free,
+doc-only touch outside this chunk's own file). No `src/` files were changed.
+
+**Gap 1 — multi-DOF corpus (E-4).** `generate_multi_dof_corpus.py` combines
+1-DOF `successful_trajectories.json` cases (fixed seed `20260722`) into
+150×2-DOF + 150×3-DOF + 150×4-DOF cases (450 total, 1,350 of the 1,682
+source cases consumed) under default `Synchronization.TIME`, filtering to
+only combinations `Otg.calculate` itself verifies succeed at generation
+time (450/450 kept, 0 rejected in the committed run — re-running the
+generator against the unmodified source corpus reproduces the JSON
+byte-for-byte, verified). `TestMultiDofCorpusReachesStep2` drives all 450
+cases through `Otg.calculate` with `PositionThirdOrderStep2.get_profile`
+instrumented: **900 invocations across 450 cases**, all succeed (0
+errors) — this is the chunk's acceptance signal, and it was measured, not
+assumed.
+
+**Gap 2 — phase synchronization (E-5).** Two new tests drive
+`Synchronization.PHASE` through `calculate()` for real:
+`TestPhaseSynchronizationCollinear` (proportional rest-to-rest targets,
+`_is_input_collinear` returns `True`, 0 Step2 calls — phase sync reuses the
+limiting DOF's own timing) and `TestPhaseSynchronizationFallsBackToTime`
+(a current-velocity ratio that doesn't match the position-delta ratio,
+`_is_input_collinear` returns `False`, falls back to per-DOF `TIME` sync
+via Step2 — confirming otg.md's "phase synchronize when possible, else fall
+back to TIME" contract). Statement coverage of `_is_input_collinear`,
+measured via `sys.settrace` over the full OTG suite: **0% (0/61) before →
+59% (36/61) after**. The remaining uncovered lines are the
+velocity/acceleration-driven scale-vector fallback branches (used only
+when the PHASE-tagged DOFs' position deltas are ~0), the "no scale vector
+found → return False" trivial path, the `math.isinf(max_jerk)` branch, and
+the second loop's `continue` for a non-PHASE DOF mixed with PHASE DOFs —
+recorded, not chased further (design constraint 1 asks for >0% measured
+and reported, not 100%).
+
+**Gap 3 — discrete duration / minimum_duration / TIME_IF_NECESSARY /
+VELOCITY (E-6).** Four new test classes, each driven through
+`TargetCalculator.calculate` (three) or `Otg.calculate` (the VELOCITY
+case): `TestDiscreteDuration` (a non-multiple-of-`delta_time` natural
+optimum gets rounded up to the next multiple), `TestMinimumDuration` (a
+1-DOF move stretched to 2x its natural optimum lands exactly on
+`minimum_duration`, via a real Step2 solve — confirmed the 1-DOF fast path
+is bypassed whenever `minimum_duration is not None`), and
+`TestTimeIfNecessarySynchronization` (both branches: a zero-target-velocity
+DOF keeps its own short unstretched duration and just holds at the target
+early, non-zero-target-velocity forces a Step2 stretch to the synchronized
+duration), `TestVelocityControlInterface` (a pure velocity-interface move
+reaches the target velocity through `set_boundary_for_velocity` +
+`VelocityThirdOrderStep1`/`Step2`).
+`TargetCalculator.calculate` statement coverage, measured the same way:
+**41.8% (167/400) before → 58.5% (234/400) after** (absolute line counts
+differ from the original post-audit's own tooling — no `coverage.py` in
+this project's venv, so an ad hoc `sys.settrace` line-counter was used
+instead; the audit's own baseline numbers also predate chunks 44-46's own
+regression tests, which already moved some of these numbers before this
+chunk started). Materially above the pre-chunk 45% figure either way.
+
+**Gap 4 — cross-cycle continuity (E-7).**
+`TestUpdateCycleContinuity` drives a real `Otg.update()` control loop to
+`FINISHED` and asserts, every cycle: `output.new_*` matches an independent
+`trajectory.at_time(output.time)` query, and the cycle-to-cycle state jump
+is bounded. A single-section (no-waypoint) trajectory has exactly one real
+`did_section_change` transition — the cycle `output.time` first crosses
+`trajectory.duration` (`Trajectory._state_to_integrate_from`'s branch
+switch) — confirmed to coincide exactly with the `FINISHED` cycle; the test
+asserts this transition occurs exactly once, at the `FINISHED` cycle, and
+that the state at that transition matches the target within `1e-6`.
+
+**Gap 5 — mid-trajectory retarget (E-8).**
+`TestMidTrajectoryRetarget` (in `test_otg_driver.py`) mutates
+`inp.target_position` at cycle 11 of a run that finishes at cycle 86 (target
+6.0 → -3.0), and asserts `new_calculation` is `True` on exactly cycles `[1,
+11]` (the initial calculation plus exactly one recalculation, never more)
+and that the loop converges to the new target (`-3.000000000000002`,
+matching the audit's own empirical observation almost to the ULP) rather
+than the original one.
+
+**Gap 6 — intra-cycle limits + invariant (2) (E-9).** Each cycle in
+`TestRandomizedValidInputInvariants` now additionally samples
+`trajectory.at_time` at 11 points across the just-elapsed cycle interval
+(not just the single control-cycle instant) and checks velocity/
+acceleration limits there too (jerk is piecewise-constant per profile
+segment, so it has no intra-segment peak the cycle-instant sample could
+miss, unlike velocity/acceleration). Investigated the premise behind
+"`pass_to_input` re-plans every cycle": empirically, for these 50 seeded
+random cases, `Otg.update()`'s change-detection sees the caller's
+`pass_to_input`-updated `current_*` state as identical to the driver's own
+internally-updated cached copy (`otg.py:173`'s own `output.pass_to_input(
+self._current_input)`), so **no case recalculates more than once** — the
+post-loop `output.trajectory` was, in every observed case, already the
+originally-planned trajectory, not a re-planned one. This doesn't
+contradict the spec (no violation to report) — but per the gap's literal
+ask, and to make the test robust to any future change in that
+change-detection behavior, invariant (2) now explicitly snapshots
+(`copy.deepcopy`) the trajectory immediately after the first
+(`new_calculation`) cycle and asserts against that snapshot, rather than
+relying on the post-loop `output.trajectory` reference remaining
+unmutated.
+
+**Gap 7 — under-covered Step2 branches (E-10).** No new cases added to
+`test_position_third_step2.py`; the multi-DOF corpus (gap 1) reaches these
+branches through realistic synchronized multi-DOF inputs. Measured via
+`sys.settrace`, before → after: `check_root_udud` 82% → 98% (1/55 lines
+unreached — a `linecache`/`dis` measurement artifact inside a nested
+function, not chased further), `_time_acc0_vel` 39% → 99% (the one
+"uncovered" line is the `def` line itself), `_time_acc1_vel` 41% → 99%
+(same artifact), `_time_acc0_acc1` 98% → 98% unchanged (one substantive
+branch remains unreached: the `check_with_timing(..., ReachedLimits.
+ACC0_ACC1, ...)` success path at `position_third_order_step2.py:1267`;
+recorded, not pursued further — design constraint 1 asks for measurement
+and reporting, not 100%). `_time_none_smooth` (0%, dead in Swift) is out of
+this chunk's scope per its own "Out of scope" section, unchanged.
+
+**Gap 8 — `testBugFix_NegativeTimeInterval_Case3` (E-11).** Ported into
+`TestBugFixNegativeTimeInterval.test_case_3` with the file's unconditional-
+success contract (unlike `test_otg_failure_fixes.py`'s existing port of the
+same input, which wraps every assertion in `if result >= 0:`). Both the
+module docstring ("Ported (4 cases)" → "Ported (5 cases)") and
+`.claude/action-plan/42-otg-oracle-suites.md`'s "All 4 of the Swift file's
+`testBugFix_*` cases are ported case-for-case" claim were corrected in
+place (with a note explaining the correction, not a silent edit).
+
+**Gate.** `make uv-fullCheck`: `uv-lint` clean, `uv-typecheck` clean (mypy
+strict, 120 source files), `uv-test` 1,548 passed (0 failures, 0 errors,
+0 skips). Full `tests/otg` suite: 237 top-level tests / 90 subtests, all
+passing, ~14s.
+
+**Deviations from the plan as written.** None functionally; the chunk 42
+doc correction (gap 8) was made as a small in-place edit with an
+explanatory note rather than a rewrite, since it is itself an
+already-committed action-plan artifact and the instruction was to correct
+a specific factual claim, not restructure the file.
diff --git a/.claude/archive/math-tools-port/57-docs-and-convention-sweep.md b/.claude/archive/math-tools-port/57-docs-and-convention-sweep.md
new file mode 100644
index 0000000..cce5a56
--- /dev/null
+++ b/.claude/archive/math-tools-port/57-docs-and-convention-sweep.md
@@ -0,0 +1,266 @@
+---
+chunk: 57-docs-and-convention-sweep
+track: F
+status: complete
+depends_on: [44, 45, 46, 47, 48, 49, 50, 51, 52, 53, 54, 55, 56]
+spec: ../specs/templateConformance.md, ../specs/mathToolsArchitecture.md
+last_updated: 2026-07-23
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# 57 — Docs and convention sweep (runs last)
+
+## Origin
+
+All class **(e)** docs/convention-drift findings from the audit, plus the
+governance-test gaps. Runs last so it can also reconcile documentation against
+whatever chunks 44–56 actually changed.
+
+## Files
+
+- Edit: `Makefile`, `pyproject.toml`, `README.md`
+- Edit: `.claude/CLAUDE.md`
+- Edit: `.claude/specs/templateConformance.md`
+- Edit: `.claude/action-plan/00-overview.md` and all chunk files (frontmatter only)
+- Edit: `.claude/action-plan/42-otg-oracle-suites.md`
+- Edit: `src/math_tools/hints.py`
+- Edit: `src/math_tools/waveforms/waveform_position.py`,
+  `waveform_quaternion.py`, `waveform_spatial_pose.py` (resolution-note comments only)
+- Edit: `tests/otg/test_otg_truth_table.py`, `test_otg_comprehensive.py` (docstrings only)
+- Edit: `tests/test_governance.py`
+
+## Gaps to close
+
+**Dead references**
+
+1. **A-3** — `templateConformance.md:27-29` lists `ci.yml` / `tag-on-prod.yml` /
+   `publish.yml` as "already conformant (verify, don't re-do)".
+   `.github/workflows/` contains only `ci-cd.yml`. Correct the spec to name the
+   file that exists.
+2. **A-4** — `Makefile:434-436` prints release instructions referencing
+   `tag-on-prod.yml` and "the publish-on-tag workflow". Neither exists;
+   `make release` hands the user a dead procedure. Fix the text to match
+   `ci-cd.yml`'s actual release path, or state plainly that release is manual.
+3. **A-13** — `README.md:40` says `pip install py_math_tools`, but the package
+   is unpublished (`pyproject.toml:57-59` point at `github.com/kopecn`) and the
+   real path is `make uv-sync`. templateConformance Gap 4.1 requires the README
+   describe what actually exists.
+4. **A-8** — `pyproject.toml:15`: `keywords = ["my_package", "python", "package"]`
+   — template boilerplate that survived Gap 4.
+
+**Stale claims in test and plan docs**
+
+5. **E-doc** — `tests/otg/test_otg_truth_table.py:121` and
+   `test_otg_comprehensive.py:29` both say "segment times atol 1e-8"; the
+   constant at `test_otg_truth_table.py:55` is `1e-6`.
+6. **E-doc** — `.claude/action-plan/42-otg-oracle-suites.md:37` design constraint 2
+   still says atol 1e-8, contradicting the same file's own Resolution at `:158-168`.
+7. **E-doc** — `42-otg-oracle-suites.md:14` says "32-case numeric truth table";
+   it is 31. (The audit re-parsed all 31 Swift cases and diffed every field —
+   0 mismatches, nothing dropped. The count in the doc is simply wrong.)
+8. **C-16** — chunks 15/16 resolution notes claim `normalize()`'s zero-magnitude
+   check uses "the same `atol=1e-12` tolerance" as `Position.is_unit`. The code
+   uses an exact `norms == 0.0` (`waveform_position.py:242`,
+   `waveform_quaternion.py:266`, `waveform_spatial_pose.py:423,430`). The
+   behavior is correct — it matches `Position.normalize`'s own exact
+   `magnitude == 0.0` (`position.py:354`) — the notes are wrong. Fix the notes.
+
+**Convention drift**
+
+9. **A-9** — `00-overview.md:33-34` defines chunk status as
+   `pending` → `in_progress` / `done`. All 44 existing chunk files use
+   `status: complete`, a value the convention does not define. Reconcile:
+   amend the convention to include `complete` (simpler, matches reality) and say
+   so in the overview.
+10. **A-10** — `templateConformance.md:104-109`: all six compliance boxes remain
+    `- [ ]` though chunks 01–03 are complete and five of six are satisfied.
+    Check off what is genuinely true; leave the rest unchecked.
+11. **A-11** — `.claude/CLAUDE.md` carries no frontmatter, while all 8 specs and
+    all 44 chunks correctly carry `last_updated` / `semver` /
+    `author: Nicholas Bergantz`. Add it.
+12. **A-12** — `src/math_tools/hints.py:30-32`: an
+    `if __name__ == "__main__":` block with a bare `assert isinstance(...)`.
+    Not spec'd, not tested, not reachable. Delete.
+
+**Governance-test gaps**
+
+13. **A-5** — half the template compliance checklist has no regression test.
+    `templateConformance.md:104-105` (no `pyMathTools` hits anywhere; `py.typed`
+    present in every public package) are never asserted;
+    `tests/test_governance.py:18-43` covers only items 107-108. A rename
+    regression or a dropped `py.typed` passes the gate silently. Add both
+    assertions.
+14. **A-6** — `examples/` is entirely outside the gate: `Makefile:37`
+    (`PY_EXAMPLES ?=`) is never set, so neither `uv-typecheck` (`Makefile:281`)
+    nor `uv-lint` scans it. Chunk 03's "both example scripts import-run without
+    error" was a one-time manual check with nothing guarding it — the exact
+    dead-import class of bug Gap 4.3 existed to fix. Evidence it has already
+    drifted: `examples/sphericalPlotting/plotArcs.py:1` and
+    `plotQuatUnitCircles.py:28` use `from typing import List`, which ruff's `UP`
+    rules (`pyproject.toml:85`) would flag if scanned. Wire `examples/` into
+    lint and typecheck, then fix what that surfaces.
+
+## Design constraints
+
+1. Docs only, plus the two mechanical code deletions (gap 12) and the
+   governance/gate wiring (gaps 13–14). No behavioral source changes.
+2. Gap 14 will surface lint/type errors in `examples/`. Fix those; if any fix
+   would change example *behavior*, stop and report instead.
+3. Reconcile every doc against the post-44–56 state of the repo, not the
+   pre-audit state.
+
+## Acceptance criteria
+
+- [x] All 14 gaps closed
+- [ ] `grep -rn "tag-on-prod\|publish.yml" Makefile .claude/` returns nothing
+      -- unchecked as literally written: `Makefile` and
+      `templateConformance.md` are clean (verified separately), but the
+      grep still matches this chunk file's own gap-description prose
+      (`.claude/action-plan/57-docs-and-convention-sweep.md`, describing
+      the dead references that were fixed) and this line's own text. See
+      Resolution notes.
+- [x] `examples/` covered by `uv-lint` and `uv-typecheck`; both clean
+- [x] `test_governance.py` asserts no-`pyMathTools` and `py.typed` presence
+- [x] `.claude/CLAUDE.md` has compliant frontmatter
+- [x] `make uv-fullCheck` passes
+
+## Resolution notes
+
+**All 14 gaps closed.** File-by-file:
+
+- **A-3** (`templateConformance.md`): "Already conformant" bullet corrected
+  to name `ci-cd.yml` (quality + compatibility checks on PRs to
+  `dev`/`prod`) instead of the nonexistent `ci.yml`/`tag-on-prod.yml`/
+  `publish.yml` scaffold.
+- **A-4** (`Makefile`): `release` target's printed procedure and preceding
+  comment rewritten to state plainly that no CI-driven publish path exists
+  (`ci-cd.yml` only runs quality/compat checks) and release is a manual,
+  human-run `twine upload`. Behavior unchanged — `make release` still
+  refuses and exits 1.
+- **A-13** (`README.md`): Installation section no longer claims
+  `pip install py_math_tools`; states the package is unpublished and points
+  at `make uv-sync`, linking to Development Workflows.
+- **A-8** (`pyproject.toml`): `keywords` replaced with real, descriptive
+  terms (`math`, `numpy`, `quaternion`, `spatial`, `waveform`,
+  `trajectory-generation`), replacing the `my_package`/`python`/`package`
+  boilerplate.
+- **E-doc atol** (`tests/otg/test_otg_truth_table.py:121`,
+  `tests/otg/test_otg_comprehensive.py:41`): both corrected from the stale
+  "atol 1e-8" to the actual "atol 1e-6" the constants/spec use.
+- **E-doc constraint 2** (`42-otg-oracle-suites.md:37`): design constraint
+  2 corrected from `atol 1e-8` to `atol 1e-6` to match the chunk's own
+  Resolution notes (the historical narrative documenting *why* it changed,
+  lines 92-169, was left untouched — only the current-tense
+  Deliverable/Files/Design-constraint text describing what the chunk
+  produces was corrected).
+- **E-doc "32-case"** (`42-otg-oracle-suites.md:14,24`): corrected to
+  "31-case" in the Deliverable and Files sections (same rationale: the
+  historical Resolution-notes narrative is left as-is).
+- **C-16** (deviation from the literal Files list): the false "same
+  `atol=1e-12`" claim about `normalize()`'s zero-magnitude check does not
+  exist anywhere in `src/math_tools/waveforms/waveform_position.py`,
+  `waveform_quaternion.py`, or `waveform_spatial_pose.py` (grepped for it;
+  0 hits). It exists only in `.claude/action-plan/15-waveform-position.md`
+  and `16-waveform-quaternion.md`'s own "Resolution notes" sections — the
+  chunk's Files list appears to have mislabeled the file type for this
+  item. Fixed at the actual location instead: both chunk files' resolution
+  notes now correctly state that `are_all_unit` uses `atol=1e-12` (parity
+  with `Position.is_unit`) while the zero-magnitude `ValueError` in
+  `normalize()` uses an exact `== 0.0` check (parity with
+  `Position.normalize()`'s own exact check), not `atol=1e-12`. Bumped both
+  chunks' frontmatter (semver 0.0.1 → 0.0.2) since their body text changed.
+  `waveform_spatial_pose.py`/chunk 17 was checked and carries no such claim
+  — nothing to fix there.
+- **A-9** (`00-overview.md`): convention item 5 amended to specify
+  `complete` (not `done`) as the terminal status, matching all 57 existing
+  chunk files. Reconciled the doc to reality per the gap's own
+  recommendation rather than rewriting 44 chunk files' status fields.
+- **A-10** (`templateConformance.md` compliance checklist): checked off
+  5 of 6 boxes after independently re-verifying each (grep for
+  `pyMathTools` → 0 hits; `py.typed` in all 9 public package dirs;
+  `make uv-fullCheck` passes; `.claude/CLAUDE.md` links all 8 specs;
+  `README.md` has no "Boilerplate" text). The 6th
+  (`test_package_layering.py` "passes and fails if matplotlib is added")
+  was also checked, since `test_math_tools_does_not_import_matplotlib`
+  is a real AST-scan assertion, not a vacuous one.
+- **A-11**: `.claude/CLAUDE.md` given minimal frontmatter
+  (`last_updated`/`semver`/`author`), matching the gap's literal ask.
+- **A-12**: the dead `if __name__ == "__main__":` block deleted from
+  `src/math_tools/hints.py`; its now-unused `q_one` import removed too
+  (would otherwise trip ruff F401).
+- **A-5** (`tests/test_governance.py`): added
+  `TestNoPreRenamePackageName` (scans `src/`, `tests/`, `examples/`,
+  `Makefile`, `pyproject.toml` for the pre-rename `pyMathTools` string;
+  excludes itself and `__pycache__`) and
+  `TestPublicPackagesShipPyTyped` (walks every `__init__.py` under `src/`
+  that defines `__all__` — the mechanical definition of "public package"
+  used elsewhere in this repo, e.g. distinguishing the private
+  `otg/steps/` from public packages — and asserts a sibling `py.typed`).
+  Both pass against the current tree (6/6 governance tests green).
+- **A-6** (`examples/` gate wiring): `Makefile`'s `PY_EXAMPLES ?=` default
+  changed to `PY_EXAMPLES ?= examples`. This surfaced real lint/type
+  errors exactly as the gap predicted: unused `typing.List` imports,
+  unsorted imports, 3 genuinely-unused constants (`deg45`/`deg180`/
+  `deg22_5`) in `plotArcs.py`, a too-long docstring line, a missing `-> None`
+  return annotation, an `arcs` list typed too narrowly for what
+  `arc_from_two_points` actually returns (widened to the `UnitSphericalArcABC`
+  base it's declared to return, matching `plot_unit_spherical_multiplot`'s
+  own parameter type), and 3 `from_unit_x_to_vector(list[int])` calls
+  needing `np.ndarray` per that method's signature. All fixes are
+  mechanical (typing/import hygiene, no numeric or control-flow change);
+  verified by running both example scripts end-to-end under `Agg` backend
+  post-fix — both complete without error, matching pre-fix behavior.
+
+**Deviation from the literal acceptance grep.** The plan's acceptance
+criterion `grep -rn "tag-on-prod\|publish.yml" Makefile .claude/` cannot
+return zero hits as literally written, because this chunk file
+(`.claude/action-plan/57-docs-and-convention-sweep.md`) necessarily quotes
+those strings while describing the A-3/A-4 gaps it fixed (and now also
+quotes the acceptance-criterion line itself). Verified the substantive
+intent instead: `grep -rn "tag-on-prod\|publish.yml" Makefile
+.claude/specs/templateConformance.md` returns nothing — the two files that
+actually needed correcting are clean.
+
+**No spec-semver bump was needed on `mathToolsArchitecture.md`** — nothing
+in its content was found stale by this sweep. `templateConformance.md` was
+bumped 0.0.2 → 0.0.3 (A-3 correction + compliance-checklist checkoffs);
+`.claude/action-plan/00-overview.md` bumped 0.1.0 → 0.1.1 (status
+convention); `42-otg-oracle-suites.md` bumped 0.0.2 → 0.0.3;
+`15-waveform-position.md` and `16-waveform-quaternion.md` each bumped
+0.0.1 → 0.0.2.
+
+**Gate.** `make uv-fullCheck`: ruff clean (`src`, `tests`, `examples`),
+mypy strict clean (122 source files, up from 116 pre-sweep since
+`examples/` is now scanned), 1550 passed (up from 1548 — the 2 new
+governance tests), exit 0.
+
+## Recorded — no action
+
+These audit findings are deliberately not being fixed. Recorded so the decision
+is not relitigated:
+
+- **B-6** — `Position`/`SpatialPose` operators hardcode `Position.from_vector`
+  while constructors are `cls: type[T]`-generic, so subclasses degrade to the
+  base type on arithmetic (`position.py:245,257,320,334,364`;
+  `spatial_pose.py:192,206,212,226,253`). No subclasses exist in-repo and none
+  are planned; fixing it touches every operator. Revisit if a subclass appears.
+- **B-4/B-5** — `SpatialPose.inverse` and `UnivariatePolynomial.derivative` are
+  methods where the spec's notation implies properties. Cosmetic; changing them
+  is a breaking API change for no behavioral gain.
+- **A-7** — `spherical/` and `math_plot_helpers/` have zero behavioral tests
+  (11 public functions). Pre-existing legacy, explicitly "behavior unchanged"
+  per `mathToolsArchitecture.md:94`; no chunk ever owned them. Chunk 52 pins
+  their public surface. A test suite for them is separate scoped work.
+- **D-cross-cutting** — `WaveformPaddingStrategy`,
+  `WaveformFilterCoefficients`, `WaveformFrequencyRange` (`support.py:158,238,354`)
+  and `WaveformSpectrogramScaling` (`support.py:174`) are spec'd support types
+  that no DSP method consumes. Either the spec's YAGNI rule is violated or
+  consuming methods are missing. Deciding which is a spec question, not a fix —
+  raise it in the next spec review.
+- **D-spectral-(c)** — `spectrogram` uses legacy `scipy.signal.spectrogram`
+  where waveformDsp.md names `scipy.signal.ShortTimeFFT`. Chunk 21 permitted
+  either, so spec and code disagree but chunk and code do not. Migrating is a
+  behavioral change needing its own chunk.
+- **E-10** — `_time_none_smooth` (`position_third_order_step2.py:2415`, 0%
+  coverage) is dead in Swift too and documented as such.
diff --git a/.claude/settings.local.json b/.claude/settings.local.json
deleted file mode 100644
index f315077..0000000
--- a/.claude/settings.local.json
+++ /dev/null
@@ -1,9 +0,0 @@
-{
-  "permissions": {
-    "allow": [
-      "Bash(python:*)"
-    ],
-    "deny": [],
-    "ask": []
-  }
-}
diff --git a/.claude/specs/mathToolsArchitecture.md b/.claude/specs/mathToolsArchitecture.md
new file mode 100644
index 0000000..6bac934
--- /dev/null
+++ b/.claude/specs/mathToolsArchitecture.md
@@ -0,0 +1,188 @@
+---
+version: 1.0
+type: umbrella-architecture
+name: mathToolsArchitecture
+purpose: Layering, package layout, dependency policy, and shared conventions for py-MathTools
+spec: MathToolsArchitecture
+scope: project
+status: accepted
+applies_to: src/, tests/, pyproject.toml
+last_updated: 2026-07-11
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# py-MathTools Architecture
+
+> Umbrella spec. Each module's behavioral contract lives in a sibling spec
+> (index at the bottom); this spec owns the layering, the package layout, the
+> dependency policy, and the conventions every sibling inherits. On conflict
+> within this repo, this spec wins for structure; the sibling wins for its own
+> module's behavior.
+
+## Role — Tier 3 of the foundation math tiers
+
+py-MathTools is the **math implementation tier** ("`Xxxx`") of the tier system
+defined in py-foundationTools' `.claude/specs/mathTypeTiers.md`:
+
+- **Tier 1** (`XxxxType`, `foundationTypes.mathTypes.MathTypes`) — codegen data
+  carriers. Serialization/validation only. Owned by py-foundationTools.
+- **Tier 2** (`XxxxABC`, `foundation_abc.math.*`) — stdlib-only accessor +
+  serialization contracts. Owned by py-foundationTools.
+- **Tier 3** (this repo) — rich math classes that subclass the Tier-2 ABCs,
+  choose their own storage (numpy), and implement arithmetic, composition,
+  interpolation, DSP, and trajectory generation.
+
+Rules that follow:
+
+1. Every py-MathTools class whose concept has a Tier-2 ABC **MUST subclass that
+   ABC** and satisfy its accessor and `to_dict`/`from_dict` contract
+   (`PositionABC`, `QuaternionABC`, `SpatialTransformABC`, `Waveform1dABC`,
+   `PositionWaveformABC`, `QuaternionWaveformABC`, `WaveformSpatialABC`,
+   `PrecisionTimeIntervalABC`, `PrecisionTimestampABC`).
+2. py-MathTools **never re-implements storage/data-carrier types** that
+   foundation already generates; it interoperates with them via
+   `to_dict`/`from_dict` (wire-format parity is the compatibility contract).
+3. Dependency direction is one-way: py-MathTools → pyFoundationTools. Nothing
+   in foundation may import this package. The foundation-side `XxxxMathLike`
+   modules referenced by `mathTypeTiers.md` do not exist yet; when foundation
+   adds them, tightening our base classes is a follow-on task in that repo's
+   cadence — not assumed here.
+
+## Dependency policy (differs from foundation)
+
+Foundation is zero-dependency by policy; **this repo is not**. A mature pip
+package that covers a scope SHALL be preferred over reimplementation:
+
+| Dependency | Used for | Rule |
+|---|---|---|
+| `pyFoundationTools` | ABCs, generated Types, enums | required, git/tag pin in `requirements.txt` |
+| `numpy` | array storage, linear algebra, FFT | required |
+| `scipy` | signal processing (filters, PSD, spectrogram, peaks, resampling) | required; every DSP method wraps scipy/numpy when an equivalent exists |
+| `numpy-quaternion` | quaternion backend | required (already in use) |
+| `matplotlib` | plotting | **only** importable from `math_plot_helpers` |
+
+Wrappers MUST present a typed, ABC-conformant surface — the pip package is an
+implementation detail, never part of the public API (no scipy/numpy types leak
+into signatures except `np.ndarray` / `npt.NDArray[...]` where arrays are the
+natural currency). Names go in `pyproject.toml`, pins in `requirements*.txt`,
+per the template BKM (see [templateConformance.md](templateConformance.md)).
+
+## Packages and layering
+
+Two top-level snake_case packages under `src/` (replacing `pyMathTools` and
+`pyMathToolsPlotHelpers` — see the rename contract in
+[templateConformance.md](templateConformance.md)):
+
+```
+math_plot_helpers  →  math_tools  →  pyFoundationTools  →  stdlib
+       (matplotlib)      (numpy, scipy, numpy-quaternion)
+```
+
+No reverse imports. `matplotlib` never appears in `math_tools`.
+
+### `math_tools` module map
+
+```
+src/math_tools/
+  __init__.py            # curated public re-exports (see Public surface)
+  py.typed
+  hints.py               # shared type aliases (migrated from pyMathTools/hints.py)
+  errors.py              # exception hierarchy (see Error semantics)
+  precision_time/        # PrecisionTimeInterval, PrecisionTimestamp   → precisionTimeMath.md
+  spatial/               # Position, Quaternion, SpatialPose           → spatialMath.md
+  spherical/             # migrated spherical arc/circle utilities (behavior unchanged)
+  waveforms/             # Waveform1D + aggregates                     → waveformCore.md
+    dsp/                 # DSP mixin per family                        → waveformDsp.md
+    support.py           # DSP descriptor dataclasses/enums            → waveformDsp.md
+  functional/            # polynomials + analytic root solvers         → polynomials.md
+  otg/                   # online trajectory generation (Ruckig port)  → otg.md
+```
+
+`src/math_plot_helpers/` holds the migrated plotting module(s); rename-only,
+no behavioral change in this effort.
+
+## Shared conventions (inherited by every sibling spec)
+
+- **Naming:** pythonic `snake_case` methods/functions; `PascalCase` classes.
+  Swift's camelCase API maps mechanically (`durationInSeconds` →
+  `duration_seconds`). The Swift name is never kept for its own sake.
+- **Storage:** numpy-backed (`float64` default). Scalar-generic Swift
+  duplication (Float/Double/Int specializations) collapses to one
+  implementation; dtype is preserved where the input dtype is meaningful
+  (integer waveforms).
+- **Public surface:** each package and subpackage `__init__.py` re-exports its
+  public API with `__all__`; consumers import from the subpackage
+  (`from math_tools.spatial import Position`), never deep module paths. Every
+  package ships `py.typed`. Additionally the **root** `math_tools/__init__.py`
+  curates a flat working set so `import math_tools as mt` is coherent:
+  `Position`, `Quaternion`, `SpatialPose`, `PrecisionTimeInterval`,
+  `PrecisionTimestamp`, `Waveform1D`, `WaveformPosition`,
+  `WaveformQuaternion`, `WaveformSpatialPose`, `UnivariatePolynomial`,
+  `Otg`, `InputParameter`, `OutputParameter`, `Trajectory`, `Result`, and
+  the `errors` exception types (pinned by an `__all__` test; grows only via
+  a spec update).
+- **API idioms (repo-wide):** `normalized()` is a method returning a copy,
+  `normalize()` mutates; approximate comparison is
+  `isclose(..., rtol, atol)` (numpy vocabulary — never a bare `tolerance`
+  argument); array-like classes implement `__array__` so `np.asarray(x)`
+  works; mutable numpy-backed classes set `__hash__ = None` explicitly
+  (only the immutable precision-time types are hashable).
+- **Typing:** mypy `strict` clean (the gate). Explicit signatures everywhere.
+- **Immutability of results:** analysis/DSP/transform methods return new
+  objects; only the explicitly-named mutation APIs (`append`, `insert`, …)
+  mutate in place.
+- **Error semantics:** see below.
+- **Testing:** `unittest.TestCase` style run under pytest (repo convention,
+  `tests/test*.py`); tests mirror the package layout
+  (`tests/spatial/test_position.py`, …). TDD per chunk. Gate:
+  `make uv-fullCheck`.
+- **Docstrings:** every public symbol; module docstrings state conventions
+  (e.g. the ISO spherical convention doc in the existing `spherical/` module
+  stays canonical).
+
+## Error semantics
+
+`math_tools/errors.py` defines:
+
+```python
+class MathToolsError(Exception): ...
+class WaveformCompatibilityError(MathToolsError): ...   # dt/shape mismatch on waveform ops
+class TimestampComparisonError(MathToolsError): ...     # timescale/frame mismatch in validated compare
+class PolynomialSolveError(MathToolsError): ...         # unsolvable/ill-posed root requests
+```
+
+- Programmer errors (wrong type, wrong shape, invalid argument) raise stdlib
+  `TypeError`/`ValueError`.
+- Domain failures raise the `MathToolsError` subtype above.
+- **Exception:** the OTG control loop reports via its `Result` code enum and
+  does not raise per cycle (real-time contract, see [otg.md](otg.md)).
+
+## Explicit non-goals (decided divergences from the Swift source)
+
+1. **No `Complex` type.** Python's native `complex` / numpy complex dtypes
+   cover Swift's `Complex<T>` + its arithmetic/analysis extensions entirely.
+2. **No cached `_isNormalized` flag.** Swift caches normalization and
+   invalidates on mutation; here `is_unit` is recomputed on access
+   (correctness > performance; optimize later with evidence).
+3. **No saturating/wrapping integer arithmetic** in precision time. Swift's
+   `UInt64` clamping (`&+`, `&-`) is a representation constraint, not domain
+   behavior; Python ints are unbounded and exact.
+4. **Swift stubs are not ported:** `Waveform1D+Custom`, the empty
+   `SpatialWaveforms/Operators/*+Arithmetic` files, and the empty
+   `PrecisionTime/Extensions` files define no behavior.
+5. **Serialization file I/O helpers** (Swift's CSV/JSON `load/save`) are not
+   part of this effort; wire interop is `to_dict`/`from_dict` (foundation's
+   `DataModelHelper` owns file I/O patterns).
+
+## Sibling spec index
+
+| Spec | Contract |
+|---|---|
+| [templateConformance.md](templateConformance.md) | template migration: packaging, Makefile/CI parity, rename, governance |
+| [precisionTimeMath.md](precisionTimeMath.md) | `PrecisionTimeInterval`, `PrecisionTimestamp` |
+| [spatialMath.md](spatialMath.md) | `Position`, `Quaternion`, `SpatialPose` |
+| [waveformCore.md](waveformCore.md) | `Waveform1D` + aggregate waveform containers |
+| [waveformDsp.md](waveformDsp.md) | DSP families, scipy mapping, support types |
+| [polynomials.md](polynomials.md) | polynomial type + analytic root solvers |
+| [otg.md](otg.md) | online trajectory generation (Ruckig port) |
diff --git a/.claude/specs/otg.md b/.claude/specs/otg.md
new file mode 100644
index 0000000..186e485
--- /dev/null
+++ b/.claude/specs/otg.md
@@ -0,0 +1,209 @@
+---
+version: 1.0
+type: specification
+name: otg
+purpose: Behavioral contract for the online trajectory generation (OTG / Ruckig-port) subsystem
+spec: OTG
+scope: project
+status: accepted
+applies_to: src/math_tools/otg/, tests/otg/
+last_updated: 2026-07-22
+semver: 0.0.5
+author: Nicholas Bergantz
+---
+
+# Online Trajectory Generation (OTG)
+
+> Sibling of [mathToolsArchitecture.md](mathToolsArchitecture.md). A
+> **faithful port** of the Swift OTG subsystem
+> (`spmMathTools/FoundationMathTypes/OTG/`, itself a Ruckig port): time
+> optimal, jerk-limited, multi-DOF trajectory generation. Fidelity ranking:
+> (1) identical results on the truth-table oracles, (2) identical public
+> semantics, (3) code structure mirroring the Swift files so the two ports
+> stay diffable. Numeric kernel: `functional/roots.py`
+> ([polynomials.md](polynomials.md)) — the OTG chunks MUST NOT reimplement
+> root solving.
+
+## Module layout (mirrors the Swift files 1:1)
+
+```
+math_tools/otg/
+  __init__.py            # public re-exports: Otg, InputParameter, OutputParameter,
+                         # Trajectory, Profile, Result, ControlInterface,
+                         # Synchronization, DurationDiscretization, OtgError
+  otg.py                 # Otg driver class            (spmOTG.swift)
+  input_parameter.py     # InputParameter + validate   (InputParameter.swift + codable ext)
+  output_parameter.py    # OutputParameter             (OutputParameter.swift)
+  trajectory.py          # Trajectory                  (Trajectory.swift)
+  profile.py             # Profile + ControlSigns/Direction/ReachedLimits (Profile.swift)
+  block.py               # Block, Interval             (Block.swift)
+  bound.py               # Bound                       (Bound.swift)
+  brake.py               # BrakeProfile                (Brake.swift)
+  calculator_target.py   # TargetCalculator            (CalculatorTarget.swift)
+  enums.py               # Result, ControlInterface, Synchronization, DurationDiscretization
+  errors.py              # OtgError (Swift RuckigError/OTGErrors)
+  steps/
+    position_first_order.py    # PositionFirstOrderStep1/Step2
+    position_second_order.py   # PositionSecondOrderStep1/Step2
+    position_third_order_step1.py  # PositionThirdOrderStep1 (~850 Swift lines)
+    position_third_order_step2.py  # PositionThirdOrderStep2 (~1900 Swift lines)
+    velocity_second_order.py   # VelocitySecondOrderStep1/Step2
+    velocity_third_order.py    # VelocityThirdOrderStep1/Step2
+```
+
+**Chunking hints (sized for one-session execution):**
+`position_third_order_step1.py` and `position_third_order_step2.py` are
+separate modules AND separate chunks (combined they are ~2,750 Swift lines —
+never one chunk; split further along Swift function boundaries if needed,
+preserving diffability). `profile.py` (~715 Swift lines),
+`calculator_target.py` (~780), and the `Otg` driver each get their own
+chunk.
+
+Only the `__init__.py` re-exports are public; `steps/`, `block/bound/brake`,
+and `calculator_target` are private (`_`-free filenames but excluded from
+`__all__`; they mirror Swift `internal`).
+
+## Public API
+
+**Enums** (`enums.py`):
+- `Result(IntEnum)`: `WORKING = 0`, `FINISHED = 1`, `ERROR = -1`,
+  `ERROR_INVALID_INPUT = -100`, `ERROR_TRAJECTORY_DURATION = -101`,
+  `ERROR_POSITIONAL_LIMITS = -102`, `ERROR_ZERO_LIMITS = -104`,
+  `ERROR_EXECUTION_TIME_CALCULATION = -110`,
+  `ERROR_SYNCHRONIZATION_CALCULATION = -111` — values are wire-stable
+  (Ruckig parity).
+- `ControlInterface`: `POSITION`, `VELOCITY`.
+- `Synchronization`: `TIME`, `TIME_IF_NECESSARY`, `PHASE`, `NONE`.
+- `DurationDiscretization`: `CONTINUOUS`, `DISCRETE`.
+
+**`InputParameter(dofs: int)`** — mutable per-cycle input; field-for-field
+port of the Swift struct (current/target position/velocity/acceleration,
+max/min velocity/acceleration, max jerk, optional position limits,
+`enabled: list[bool]`, per-DOF control interface/synchronization overrides,
+`intermediate_positions`, per-section limits/durations, `minimum_duration`,
+`interrupt_calculation_duration`). `validate(check_current_state_within_limits=False,
+check_target_state_within_limits=True) -> bool`. `==` field equality.
+`to_dict`/`from_dict` (camelCase keys per the Swift Codable extension).
+
+**`OutputParameter(dofs: int, max_number_of_waypoints: int = 0)`** —
+`trajectory: Trajectory`, `new_position/new_velocity/new_acceleration/
+new_jerk: list[float]`, `time: float`, `new_section: int`,
+`did_section_change: bool`, `new_calculation: bool`,
+`calculation_duration: float` (µs, Swift parity),
+`pass_to_input(input: InputParameter) -> None`.
+
+**`Trajectory`** — `duration: float`, `degrees_of_freedom: int`,
+`at_time(t: float) -> tuple[list[float], list[float], list[float]]`
+(position, velocity, acceleration; clamped to `[0, duration]` ends per
+Swift), `position_extrema() -> list[Bound]`, `independent_min_durations:
+list[float]`, profile access for tests.
+
+**`Otg(control_cycle: float, dofs: int, max_number_of_waypoints: int = 0)`**
+— the driver:
+- `update(input: InputParameter, output: OutputParameter) -> Result` — one
+  control cycle: validates (→ `ERROR_INVALID_INPUT`), recalculates when the
+  input changed, steps `output.time` forward by `control_cycle`, samples the
+  trajectory into `output.new_*`, returns `WORKING`/`FINISHED`/error code.
+- `calculate(input: InputParameter, output: OutputParameter) -> Result` —
+  full-trajectory calculation without time stepping.
+- `reset() -> None`.
+
+**Error semantics** (umbrella exception carve-out): per-cycle failures are
+`Result` codes, never exceptions. `OtgError` is raised only for structural
+misuse (mismatched DOF counts between constructor and parameters,
+non-positive `control_cycle`) — conditions that make every future cycle
+invalid.
+
+## Internal fidelity requirements
+
+1. `Profile` is the hot per-DOF state record: arrays `t[7]`, `t_sum[7]`,
+   `j[7]`, `a[8]`, `v[8]`, `p[8]` as `list[float]` (fixed length, never
+   resized), plus `brake`/`accel: BrakeProfile`, targets `pf/vf/af`,
+   `limits: ReachedLimits`, `direction: Direction`,
+   `control_signs: ControlSigns`, and the `check*` method family with the
+   same names snake_cased. The kinematic stepping uses
+   `functional.roots.integrate_jerk`.
+2. Step-solver classes port one Swift class each, same names snake_cased
+   (`PositionThirdOrderStep1.get_profile_...` etc.), same branch structure.
+   Translate mechanically; do not restructure the case analysis (it encodes
+   the Ruckig paper's profile taxonomy).
+3. `TargetCalculator.synchronize` reproduces the Swift block-interval
+   synchronization (including `Block`/`Interval` blocked-interval logic and
+   the discrete-duration path).
+4. Float64 throughout; comparisons use the Swift port's exact epsilon
+   constants (`EPS16`, `POLYNOMIAL_*` from `functional/roots.py` — never
+   fresh literals). Swift `Double` division silently yields `inf`/`nan` on
+   a zero denominator (IEEE 754); Python's `/` raises `ZeroDivisionError`
+   instead. Where a step solver's own algebra can produce a legitimate
+   zero denominator at a degenerate root (e.g.
+   `steps/position_third_order_step1.py`'s `_time_all_none_acc0_acc1`, a
+   `t == 0` quartic root when the polynomial's constant term is zero), the
+   division is routed through an IEEE-754-semantics helper
+   (`_ieee754_div`) instead of the bare `/` operator, reproducing Swift's
+   silent nan/inf propagation (which `Profile.check`'s precision
+   comparisons then naturally reject) rather than crashing. This is NOT a
+   blanket rule to wrap every division in the OTG port — only sites where
+   a real Swift Double division-by-zero has been shown (by a failing
+   test) to be reachable. The same total-vs-partial-function divergence
+   applies to `sqrt`: Swift `Double`'s `sqrt` of a negative argument is
+   `nan` (never traps), Python's `math.sqrt` raises `ValueError`. A
+   negative-discriminant `sqrt` is the *generic* way a Step2 time-
+   synchronization solver's algebra signals "no real solution at this
+   prescribed duration" — reachable from ordinary usage (any
+   below-time-optimal duration), not a rare degenerate root — so
+   `steps/position_third_order_step2.py` routes every `sqrt` call through
+   an `_ieee754_sqrt` helper file-wide, unlike `_ieee754_div`'s
+   deliberately per-site scoping (see that file's module docstring and
+   `_ieee754_sqrt`'s docstring for the reachability trace that motivated
+   the broader scope, and `39-otg-position-third-step2.md`'s Resolution
+   notes). Future step-solver chunks should default to `_ieee754_div`'s
+   narrower, failing-test-driven scoping and only widen it the way this
+   file did if a similar cascade is demonstrated.
+5. Pure Python + stdlib `math` in the per-cycle path (no numpy — scalar
+   loops over DOFs, matching Swift; performance is explicitly a non-goal
+   until measured).
+
+## Oracle and test strategy
+
+Two oracle tiers — the JSON corpus records **inputs only** (no durations, no
+kinematics, no Result codes), so it can classify but not pin numbers; the
+numeric golden lives in a hardcoded Swift test array.
+
+1. **Classification corpus:** copy `successful_trajectories.json`
+   (~1,680 cases) and `failed_trajectories.json` (~100 cases) from
+   `spmMathTools/spm/Tests/spmMathToolsTests/OTGTests/truthTables/` into
+   `tests/otg/data/` unmodified. `test_otg_truth_table.py` asserts:
+   successful cases → `calculate` returns a non-error `Result`
+   (`Result >= 0`); failed cases → an error `Result` (`Result < 0` — the
+   JSON's free-text error strings are NOT mapped to specific codes).
+2. **Numeric oracle:** port the 31-case hardcoded truth table from
+   `OTGTruthTableTests.swift` (each case: input state/limits +
+   `expectedDuration` + `expectedTimeIntervals`, the 7 profile segment
+   times) into `tests/otg/data/otg_numeric_truth.json`, transcribed
+   verbatim from the Swift literals. Assertions per case: trajectory
+   duration rtol 1e-6; `Profile.t` segment times against
+   `expectedTimeIntervals` atol 1e-6 (this pins branch selection, not just
+   the coincidentally-summable duration; capped at 1e-6 rather than 1e-8
+   because the Swift literals themselves are recorded to only 6 decimal
+   places — a tighter atol cannot be satisfied by any correct port).
+3. **Ported suites:** the Swift `OTGComprehensiveTests`, `OTGContinuityTests`
+   (position/velocity/acceleration continuity across cycle boundaries and
+   section changes), and `OTGFailureFixTests` regression cases are ported
+   test-for-test.
+4. **Invariant tests:** for randomized (seeded) valid inputs — output never
+   exceeds max velocity/acceleration/jerk beyond 1e-9; `at_time(duration)`
+   hits the target state within 1e-8; `FINISHED` is reached within
+   `duration/control_cycle + 2` update calls.
+
+## Compliance requirements (test-checkable)
+
+1. Classification corpus passes 100% of cases; numeric 31-case oracle passes
+   (duration rtol 1e-6, segment times atol 1e-6).
+2. Continuity suite passes (no kinematic discontinuities at cycle/section
+   boundaries).
+3. `Result` enum integer values grep-match the table above.
+4. `math_tools/otg/` imports numpy nowhere (grep-pinned); imports the root
+   kernel only from `math_tools.functional.roots`.
+5. Public surface = the `__init__.py` re-export list, nothing else
+   (`__all__` pinned by test).
+6. mypy strict clean.
diff --git a/.claude/specs/polynomials.md b/.claude/specs/polynomials.md
new file mode 100644
index 0000000..3a18bde
--- /dev/null
+++ b/.claude/specs/polynomials.md
@@ -0,0 +1,155 @@
+---
+version: 1.0
+type: specification
+name: polynomials
+purpose: Behavioral contract for the univariate polynomial type and the analytic root solvers
+spec: Polynomials
+scope: project
+status: accepted
+applies_to: src/math_tools/functional/, tests/functional/
+last_updated: 2026-07-23
+semver: 0.0.4
+author: Nicholas Bergantz
+---
+
+# Polynomials and Root Solvers
+
+> Sibling of [mathToolsArchitecture.md](mathToolsArchitecture.md). Two
+> deliberately different fidelity levels: a **pythonic polynomial class**
+> (numpy-backed, replaces the Swift subclass-per-degree hierarchy) and a
+> **faithful port of the analytic root kernel** (`Roots.swift` /
+> `Utils.swift`), because the OTG solver ([otg.md](otg.md)) depends on that
+> kernel's exact semantics and tolerances.
+
+## `functional/polynomial.py` — `UnivariatePolynomial`
+
+One class; the Swift `PolynomialUnivariateOrder` enum + eleven subclasses
+collapse (documented divergence — composition over inheritance; numpy's
+companion-matrix roots supersede per-degree closed forms for the general
+API).
+
+- Storage: `coefficients: npt.NDArray` float64, **ascending degree order**
+  (`c[0] + c[1]·x + …`, numpy convention; the Swift ordering is mapped at
+  construction — pin with a test).
+- `UnivariatePolynomial(coefficients: Sequence[float])` — `ValueError` on
+  empty; trailing (highest-degree) zeros trimmed, so `degree` is exact.
+- `degree: int`; `coefficient_at(degree: int) -> float` (0.0 beyond degree).
+- `__call__(x: float | npt.NDArray) -> float | npt.NDArray` — Horner/
+  `np.polynomial.polynomial.polyval`.
+- `derivative -> UnivariatePolynomial`,
+  `integrate(constant: float = 0.0) -> UnivariatePolynomial`.
+- `real_roots(tolerance: float = POLYNOMIAL_ZERO_THRESHOLD) -> list[float]`
+  — companion-matrix roots (`np.roots` equivalent), imaginary parts within
+  tolerance treated as real, sorted ascending. Degree-0: empty list
+  (constant ≠ 0) or `PolynomialSolveError` (zero polynomial — infinitely
+  many roots).
+- `==` (trimmed-coefficient equality), `repr` (human-readable
+  `"3.0·x² − 1.0"` style), immutable (frozen dataclass or read-only
+  property).
+
+## `functional/roots.py` — analytic kernel (faithful port)
+
+Free functions and constants, semantics matching `Roots.swift` /
+`Utils.swift` exactly (this module is the OTG's numeric substrate — do not
+"improve" it).
+
+**This is NOT a general root finder.** Swift's `insertIfPositive`
+(`Utils.swift:33`) means `solve_cubic` / `solve_quartic_monic` return only
+**non-negative** real roots (they solve for time ≥ 0). This MUST be stated in
+the module docstring and each function docstring; general root finding is
+`UnivariatePolynomial.real_roots` above — the two contracts are deliberately
+different.
+
+```python
+import sys
+
+EPS16: float = 16 * sys.float_info.epsilon   # Swift: 16 * .ulpOfOne ≈ 3.5527e-15 (NOT 1e-16)
+POLYNOMIAL_TOLERANCE: float = 1e-14
+POLYNOMIAL_ZERO_THRESHOLD: float = 1e-9
+
+def solve_cubic(a: float, b: float, c: float, d: float) -> list[float]: ...
+def solve_resolvent(a: float, b: float, c: float) -> tuple[list[float], int]:
+    """Roots of the cubic resolvent plus the REAL-root count (Swift returns Int).
+
+    In the 1-real-root case the third slot holds the imaginary part, not a
+    root — callers (solve_quartic_monic) must consult the count before
+    reading slots 1..2.
+    """
+def solve_quartic_monic(a: float, b: float, c: float, d: float) -> list[float]:
+    """Non-negative real roots of the monic quartic x⁴ + a·x³ + b·x² + c·x + d."""
+def evaluate_polynomial(coefficients: Sequence[float], x: float) -> float: ...
+def polynomial_derivative(coefficients: Sequence[float]) -> list[float]: ...
+def polynomial_monic_derivative(coefficients: Sequence[float]) -> list[float]: ...
+def shrink_interval(coefficients: Sequence[float], left: float, right: float) -> float: ...
+
+def integrate_jerk(t: float, p0: float, v0: float, a0: float, j: float) -> tuple[float, float, float]:
+    """Constant-jerk kinematic step → (p, v, a) after t. Swift Utils.integrate."""
+```
+
+Rules:
+
+1. Real-root **multiplicity, ordering, and the non-negative filter** match
+   the Swift implementation (translate the algorithm, then pin with test
+   vectors; where Swift returns duplicated roots for multiplicity, so does
+   this).
+2. Coefficient argument ordering matches the Swift functions (document per
+   function in the docstring; it differs from `UnivariatePolynomial`'s
+   ascending convention).
+3. Pure `math`-module scalar code — **no numpy** in this module (called
+   per-cycle by OTG; keep it allocation-light).
+4. Degenerate leading coefficients degrade exactly as Swift does (cubic with
+   `a ≈ 0` within tolerance solves the quadratic, etc.) -- with one accepted
+   deviation from the literal Swift source: `solve_cubic`'s leading-
+   coefficient degeneracy check (`Roots.swift:37`'s `abs(a) < .ulpOfOne`) is
+   an **absolute** threshold, which is wrong across the coefficient scales
+   this module sees. A coefficient like `a = 1e-10` against `b, c, d` of
+   order 1 is negligible, but `1e-10 >> ulpOfOne`, so the literal port took
+   the cubic branch, whose `1/a**3` scaling amplifies rounding error until
+   the solve collapses (confirmed: `solve_cubic(1e-10, 2.0, -3.0, -2.0)`
+   returned `[]` instead of the root near `2.0`). `roots.py` instead uses a
+   **scale-relative** threshold:
+   `abs(a) <= 1e-6 * max(abs(b), abs(c), abs(d))` (constant
+   `_CUBIC_LEADING_COEFF_EPS`). `1e-6` is chosen empirically as the
+   crossover where the closed-form cubic formula's error (which grows as
+   `a` shrinks, due to the `1/a**3` scaling) exceeds the quadratic
+   fallback's error (which shrinks as `a` shrinks, `O(a)` by dropping the
+   cubic term) -- pinned by the decade sweep in
+   `TestSolveCubicNearZeroLeadingCoefficient` (`tests/functional/test_roots.py`),
+   `a` from `1e-4` to `1e-14` against `b, c, d` of order 1-5.
+5. **Accepted deviation from the literal Swift source:** `solve_cubic`'s
+   `halfq` (the depressed-cubic resolvent term `R`) is scaled by `inva *
+   invaa` (`1/a³`), not `Roots.swift:70`'s literal `invaa * invaa` (`1/a⁴`).
+   The standard resolvent `R = (2A³ − 9AB + 27C) / 54` (`A=b/a, B=c/a,
+   C=d/a`) scales as `1/a³`; the Swift source's `1/a⁴` is a latent scaling
+   bug, inert at both of its call sites (`PositionThirdOrderStep2.swift`,
+   `PolynomialUnivariateFunction.swift`) because they always pass a monic
+   cubic (`a == 1`, where `1/a³ == 1/a⁴`). It is not inert for general
+   coefficients: Compliance 2b (below) requires agreement with `np.roots`
+   for randomized non-monic cubics, which the literal `1/a⁴` scaling fails
+   for any `a != 1`. This is the one intentional arithmetic correction in
+   this otherwise line-by-line port; it is called out inline in
+   `roots.py`'s `solve_cubic`.
+
+## Compliance requirements (test-checkable)
+
+1. `UnivariatePolynomial([−1, 0, 1]).real_roots() == [−1.0, 1.0]`; derivative
+   /integrate round-trip up to the constant; `__call__` matches Horner
+   evaluation on a vector input.
+2. Kernel functions pinned two ways, entirely within this repo (no Swift
+   toolchain required):
+   a. **Literal vectors** — ≥ 15 hand-computed cases as test literals
+      spanning distinct roots, repeated roots, complex pairs, all-negative
+      real roots (→ empty result, pinning the non-negative filter), and
+      degenerate leading coefficient (`a ≈ 0` cubic → quadratic fallback).
+      Agreement: atol 1e-9 per root, identical root counts.
+   b. **Cross-check** — for randomized (seeded) coefficient sets, results
+      equal the non-negative real subset of `np.roots` (imaginary part <
+      `POLYNOMIAL_ZERO_THRESHOLD`), atol 1e-8; numpy is a test-only import.
+3. `shrink_interval` converges on a bracketed root of a quintic to
+   `POLYNOMIAL_TOLERANCE`.
+4. `integrate_jerk` pinned analytically: `t=1, p0=0, v0=0, a0=0, j=6` →
+   `(1.0, 3.0, 6.0)`.
+5. `EPS16 == 16 * sys.float_info.epsilon` pinned by test (guards against the
+   1e-16 transcription error).
+6. `roots.py` imports nothing beyond `math`/`sys`/stdlib (grep-pinned).
+7. mypy strict clean.
diff --git a/.claude/specs/precisionTimeMath.md b/.claude/specs/precisionTimeMath.md
new file mode 100644
index 0000000..4e00aab
--- /dev/null
+++ b/.claude/specs/precisionTimeMath.md
@@ -0,0 +1,127 @@
+---
+version: 1.0
+type: specification
+name: precisionTimeMath
+purpose: Behavioral contract for the Tier-3 PrecisionTimeInterval and PrecisionTimestamp math types
+spec: PrecisionTimeMath
+scope: project
+status: accepted
+applies_to: src/math_tools/precision_time/, tests/precision_time/
+last_updated: 2026-07-11
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# Precision Time Math Types
+
+> Sibling of [mathToolsArchitecture.md](mathToolsArchitecture.md). Ports the
+> behavior of Swift `PrecisionTimeInterval` / `PrecisionTimestamp`
+> (spmFoundationTools `FoundationTypes/PrecisionTime/`, including
+> `+Arithmetic`) as Tier-3 classes over the foundation ABCs. These are the
+> time axis of every waveform type ([waveformCore.md](waveformCore.md)).
+
+## Base contracts
+
+- `PrecisionTimeInterval(PrecisionTimeIntervalABC)` — from
+  `foundation_abc.math.precisionTimeABC`.
+- `PrecisionTimestamp(PrecisionTimestampABC)` — same module.
+- Enums come from `foundation_abc.math.mathEnums` (`NumericSign`,
+  `Timescale`, `ReferenceFrame`) — never redefined here.
+
+## Representation
+
+Internal storage is a **single signed Python `int` of total attoseconds**
+(exact, unbounded). The ABC's `(seconds, attoseconds, sign)` triple is derived
+on access:
+
+```python
+@property
+def seconds(self) -> int:      return abs(self._total_atto) // ATTOSECONDS_PER_SECOND
+@property
+def attoseconds(self) -> int:  return abs(self._total_atto) % ATTOSECONDS_PER_SECOND
+@property
+def sign(self) -> NumericSign: # ZERO when _total_atto == 0, else POSITIVE/NEGATIVE
+```
+
+Divergence from Swift (per umbrella non-goal 3): no `UInt64` saturation, no
+wrapping operators — arithmetic is exact.
+
+## `PrecisionTimeInterval`
+
+Immutable (instances are hashable; all operations return new instances).
+
+**Constructors**
+- `PrecisionTimeInterval(seconds: int = 0, attoseconds: int = 0, sign: NumericSign = POSITIVE)` — ABC-shaped; normalizes (attosecond carry into seconds); `ValueError` on negative magnitude components.
+- `from_seconds(seconds: float | int) -> PrecisionTimeInterval` — sign inferred; float path loses no more than float64 precision.
+- `from_attoseconds(total: int) -> PrecisionTimeInterval` — signed total.
+- `from_string(seconds: str, fractional: str) -> PrecisionTimeInterval` — lossless decimal-string constructor (fractional right-padded to 18 digits; `ValueError` if >18 digits or non-numeric).
+- Class constants: `ZERO`, `ONE_SECOND`, `ONE_DECISECOND`, `ONE_MILLISECOND`, `ONE_MICROSECOND`.
+
+**Accessors** (beyond ABC): `total_attoseconds: int` (signed),
+`seconds_as_float: float`.
+
+**Arithmetic / comparison** (all with `PrecisionTimeInterval` operands unless
+noted; `NotImplemented` for foreign types so Python falls back correctly):
+- `+`, `-`, unary `-`, unary `+`, `abs()`
+- `*` and `/` by `int | float` scalar (both operand orders for `*`); scalar
+  ops round to nearest attosecond.
+- `/` interval → `float` ratio (`ZeroDivisionError` on zero divisor).
+- `==`, `<`, `<=`, `>`, `>=` (total ordering on signed total), `__hash__`.
+- `bool(x)` is `not x.is_zero`.
+
+**Serialization**: `to_dict` inherited from the ABC; `from_dict` accepts the
+ABC wire shape `{"seconds", "attoseconds", "sign"}` — exactly what
+`foundationTypes` `PrecisionTimeIntervalType.to_dict()` emits (wire-format
+interop is the Tier-1↔Tier-3 contract).
+
+## `PrecisionTimestamp`
+
+A point in time = signed attosecond offset from the Unix epoch, plus optional
+metadata `timescale: Timescale | None`, `reference_frame: ReferenceFrame | None`,
+`uncertainty: int | None` (attoseconds). Immutable, hashable.
+
+**Constructors**
+- `PrecisionTimestamp(seconds=0, attoseconds=0, sign=POSITIVE, *, timescale=None, reference_frame=None, uncertainty=None)`
+- `from_interval(interval, *, timescale=None, ...)`
+- `from_datetime(dt: datetime.datetime, ...)` — pre-epoch supported; naive datetimes are `ValueError` (require tz-aware).
+- `now(*, timescale=None, ...)` — classmethod.
+- `from_days(days_since_epoch: int, attoseconds_of_day: int = 0, sign=POSITIVE, ...)`
+- Class constant `EPOCH`.
+
+**Accessors**: ABC set plus `interval: PrecisionTimeInterval` (offset from
+epoch), `days_since_epoch: int`, `seconds_of_day: int`,
+`as_datetime: datetime.datetime` (UTC, lossy to microseconds).
+
+**Arithmetic / comparison**
+- `timestamp ± interval → timestamp` (metadata carried from the timestamp);
+  `interval + timestamp → timestamp`.
+- `timestamp - timestamp → PrecisionTimeInterval`.
+- `==` includes metadata equality; `<`/`<=`/`>`/`>=` compare offsets only
+  (numeric ordering, Swift parity).
+- `can_compare(other) -> bool` — False only when **both** sides specify a
+  `timescale` and they differ, or both specify a `reference_frame` and they
+  differ (a `None` on either side is compatible with anything). Uncertainty
+  is NOT part of `can_compare` (Swift parity: `canCompare(to:)`).
+- `compare_validated(other) -> int` — returns -1/0/1; raises
+  `TimestampComparisonError` (from `math_tools.errors`, with a reason) when
+  (a) both specify differing timescales, (b) both specify differing reference
+  frames, or (c) both carry `uncertainty` and the absolute offset difference
+  is ≤ the sum of the two uncertainties (overlap). This is the Python
+  rendering of Swift's `Result<ComparisonResult, ComparisonValidationError>`
+  in `PrecisionTimestamp+Comparable.swift`.
+
+**Serialization**: ABC `to_dict` (camelCase optional keys); `from_dict`
+accepts the same wire shape (parity with `PrecisionTimestampType`).
+
+## Compliance requirements (test-checkable)
+
+1. Round-trip: `PrecisionTimeInterval.from_dict(PrecisionTimeIntervalType.from_dict(d).to_dict()).to_dict() == d` for representative payloads (and the timestamp equivalent).
+2. `from_string("1", "5")` equals 1.5 s exactly; `from_string("0", "000000000000000001")` is 1 attosecond.
+3. Attosecond exactness: `ONE_SECOND - PrecisionTimeInterval.from_attoseconds(1)` has `seconds == 0`, `attoseconds == 10**18 - 1`.
+4. Carry normalization: constructing with `attoseconds >= 10**18` carries into seconds.
+5. Sign algebra: negating flips `sign`; zero is `NumericSign.ZERO` and `bool` False.
+6. Scalar mult/div round to nearest attosecond (pin one case each).
+7. `timestamp - timestamp` across the epoch (one pre-1970 operand) is exact.
+8. `compare_validated` raises `TimestampComparisonError` on differing timescale (both set), differing frame (both set), and overlapping uncertainty (both set, delta ≤ combined — pin the boundary case delta == combined as raising); returns -1/0/1 otherwise. `can_compare` is True when either side's metadata is `None` and ignores uncertainty.
+9. `as_datetime`/`from_datetime` round-trips to microsecond precision, including a pre-epoch instant.
+10. mypy strict clean; all classes pass `isinstance(x, <ABC>)`.
diff --git a/.claude/specs/spatialMath.md b/.claude/specs/spatialMath.md
new file mode 100644
index 0000000..5467715
--- /dev/null
+++ b/.claude/specs/spatialMath.md
@@ -0,0 +1,192 @@
+---
+version: 1.0
+type: specification
+name: spatialMath
+purpose: Behavioral contract for the Position, Quaternion, and SpatialPose math types
+spec: SpatialMath
+scope: project
+status: accepted
+applies_to: src/math_tools/spatial/, tests/spatial/
+last_updated: 2026-07-11
+semver: 0.0.2
+author: Nicholas Bergantz
+---
+
+# Spatial Math Types
+
+> Sibling of [mathToolsArchitecture.md](mathToolsArchitecture.md). Ports the
+> Swift `Position` / `Quaternion` / `SpatialPose` behavior (base types from
+> spmFoundationTools plus the operator/constructor extensions in
+> spmMathTools `FoundationMathTypes/Spatial/`) as Tier-3 SE(3) classes.
+
+## Modules and base contracts
+
+| Class | Module | Subclasses | Storage |
+|---|---|---|---|
+| `Position` | `spatial/position.py` | `PositionABC` | `np.ndarray` shape `(3,)` float64 |
+| `Quaternion` | `spatial/quaternion.py` (migrated existing class) | `QuaternionABC` (already) | `numpy-quaternion` (already) |
+| `SpatialPose` | `spatial/spatial_pose.py` | `SpatialTransformABC` | composed `Position` + `Quaternion` |
+
+`Quaternion` is the **existing, tested implementation** (~90 tests). Its
+math behavior is authoritative and unchanged, but one structural edit is
+REQUIRED: the pinned foundation branch deleted
+`foundationTypes.mathTypes.quaternionABC` — the base class re-parents to
+`foundation_abc.math.spatialABCs.QuaternionABC`. The old ABC also carried
+`DataModelHelper`; the new one is `ABC`-only, so serialization tests that
+assert `DataModelHelper` inheritance update their base-class assertions
+(`to_dict`/`from_dict` behavior itself is preserved by the new ABC).
+Beyond that, this spec only adds the members under "Quaternion additions".
+
+## Coordinate conventions (single source of truth)
+
+- **spherical** (`azimuth`, `elevation`): elevation measured from the xy-plane
+  (geographic).
+- **spherical ISO** (`azimuth`, `polar`): polar measured from +z (ISO 80000-2
+  colatitude) — the convention already documented in
+  `math_tools/spherical/spherical_generators.py`; both conventions preserved,
+  as in Swift.
+- Angles in radians everywhere.
+
+## Cross-cutting API conventions (all three classes)
+
+- `normalized()` is a **method** returning a copy (matches the incumbent
+  `Quaternion.normalized()`); `normalize()` mutates in place.
+- Approximate comparison is `isclose(other, rtol=1e-9, atol=0.0) -> bool`
+  (incumbent signature style; numpy `rtol`/`atol` vocabulary repo-wide).
+- These classes are **mutable → unhashable**: each sets `__hash__ = None`
+  explicitly (pinned by test). Hashable time types are the immutable
+  exception ([precisionTimeMath.md](precisionTimeMath.md)).
+- `__array__(dtype=None)` on `Position` (→ `(3,)` vector) and `Quaternion`
+  (→ `[w, x, y, z]`), so `np.asarray(x)` / `plt.plot(...)` work directly.
+
+## `Position`
+
+Mutable components (`p.x = 1.0` allowed), matching the existing `Quaternion`
+dataclass idiom.
+
+**Constructors**
+- `Position(x=0.0, y=0.0, z=0.0)`
+- `from_vector(v: npt.ArrayLike) -> Position` (copies; `ValueError` unless it
+  coerces to shape `(3,)`) — covers lists/tuples/arrays; there is no
+  separate sequence constructor
+- `from_components(x=0.0, y=0.0, z=0.0)` — scalar args, defaulted, matching
+  the incumbent `Quaternion.from_components(w, x, y, z)` shape
+- `from_cylindrical(radius, angle, height)`
+- `from_spherical(radius, azimuth, elevation)`
+- `from_spherical_iso(radius, azimuth, polar)`
+- classmethod constants: `origin()`, `unit_x()`, `unit_y()`, `unit_z()`
+- `from_dict({"x","y","z"})` (ABC)
+
+**Properties**
+- `x, y, z: float` (settable); `vector: npt.NDArray` (copy out);
+  `components: list[float]`
+- Inverse coordinate accessors returning `NamedTuple`s:
+  `cylindrical -> (radius, angle, height)`,
+  `spherical -> (radius, azimuth, elevation)`,
+  `spherical_iso -> (radius, azimuth, polar)`
+- `magnitude`, `magnitude_squared`, `is_unit` (recomputed, tolerance 1e-12);
+  `norm` as an alias of `magnitude` (parity with the incumbent
+  `Quaternion.norm`) and `__abs__` returning it
+
+**Operators / methods**
+- `+`/`-` position±position and position±scalar (scalar broadcast, both orders);
+  `*`/`/` by scalar (both orders for `*`); in-place variants; unary `-`, `+`
+- `dot(other) -> float`, `cross(other) -> Position`
+- `distance(to)`, `distance_squared(to)`
+- `normalize()` (in place; `ValueError` on zero vector),
+  `normalized() -> Position`
+- `==` (exact), `isclose(other, rtol, atol)`, `repr`, `to_dict`/`from_dict`
+
+Swift's custom `•`/`×` operators map to the named methods `dot`/`cross` plus
+`@` is NOT used (reserved; matrix semantics would mislead).
+
+## `Quaternion` additions
+
+Added to the existing class (plus the ABC re-parent above; no other change):
+
+1. `dot(other) -> float` — 4-component dot product.
+2. `rotation_matrix_elements -> RotationMatrixElements` — frozen dataclass
+   with fields `xx, xy, xz, yx, yy, yz, zx, zy, zz` derived from
+   `to_rotation_matrix()` (single source: delegates to the existing method).
+3. `rotate_position(p: Position) -> Position` — thin wrapper over the existing
+   `rotate_vector`, typed for `Position` (`q * p` NOT overloaded; explicit
+   method only, to avoid ambiguity with the existing quaternion `*`).
+4. `__array__(dtype=None)` per the cross-cutting conventions.
+5. snake_case aliases for the two camelCase slips on the public surface:
+   `from_numpy_quaternion` (= `fromNumpyQuaternion`) and
+   `to_unit_spherical_small_circle` (= `to_unitSphericalSmallCircle`); the
+   camelCase originals remain as deprecated aliases (docstring note, no
+   removal in this effort).
+
+## `SpatialPose`
+
+**Constructors**
+- `SpatialPose(position: Position, orientation: Quaternion)` (defaults:
+  origin, identity)
+- `from_components(x, y, z, qw, qx, qy, qz)` — quaternion order w-first,
+  matching the existing `Quaternion.from_components`.
+- `from_homogeneous(matrix: npt.NDArray) -> SpatialPose` — `(4,4)`; rotation
+  extracted via the existing `Quaternion.from_rotation_matrix`; `ValueError`
+  on shape or non-rigid bottom row.
+- `from_denavit_hartenberg(a: float, alpha: float, d: float, theta: float)` —
+  standard DH; the Swift precomputed-cos/sin overload collapses into this one.
+- `identity()` classmethod.
+- `from_dict({"position", "orientation"})` (ABC).
+
+**Properties**
+- `position: Position`, `orientation: Quaternion` (ABC names; `orientation`
+  is the ABC's name for Swift's `quaternion` — ABC wins)
+- passthroughs `x, y, z, qw, qx, qy, qz: float`
+- `homogeneous -> npt.NDArray` `(4,4)` float64 (orientation normalized first,
+  Swift parity)
+- `is_unit` — delegates to `orientation`
+
+**Operators / methods** (SE(3) semantics; `*` = "apply", the universal
+robotics reading)
+- `pose * pose -> SpatialPose` — composition: result rotation
+  `q1 * q2`, result position `p1 + q1.rotate(p2)`.
+- `pose * position -> Position` — full SE(3) application, identical to
+  `transform(p)` (`q.rotate(p) + position`).
+- `transform(p: Position) -> Position` — the named form of the above.
+- `translated(by: Position) -> SpatialPose` — translation-only shift of the
+  pose. Swift's `pose + position` / `pose - position` operators are NOT
+  ported: a `+` that ignores orientation reads like "apply" and silently
+  drops rotation — the explicit method removes the footgun.
+- `inverse -> SpatialPose` — `q⁻¹`, `-(q⁻¹.rotate(p))`.
+- `relative_pose(to: SpatialPose) -> SpatialPose` — `self.inverse * to`.
+- `interpolate(to, t: float) -> SpatialPose` — position lerp + quaternion
+  slerp (delegates to existing `Quaternion.slerp`); `t` unclamped, Swift
+  parity pinned by test.
+- `position_distance(to)`, `position_distance_squared(to)`,
+  `angular_distance(to) -> float` (radians, double-cover safe: uses
+  `min(θ, 2π−θ)` via `|dot|`).
+- `normalize()` / `normalized()` — normalize orientation only.
+- `==` exact, `isclose(other, rtol, atol)` (double-cover aware via
+  `Quaternion.isclose`), `repr`, `to_dict`/`from_dict`.
+
+## Compliance requirements (test-checkable)
+
+1. All three classes satisfy `isinstance` of their ABC and round-trip
+   `to_dict`/`from_dict` against the matching `foundationTypes` generated
+   Type's wire output — exact target names on the pinned branch:
+   `PositionType`, `QuaternionType`, `SpatialTransformType`
+   (NOT the pre-template `PositionVectorType`/`SpatialPoseType`; refresh the
+   venv to the branch pin first, per
+   [templateConformance.md](templateConformance.md)).
+2. Coordinate inits/accessors are mutual inverses (property-style tests over
+   a grid of radii/angles, both spherical conventions, atol 1e-12).
+3. `cross` follows the right-hand rule (`unit_x × unit_y == unit_z` pinned).
+4. DH: pinned against at least two published DH parameter sets (e.g. a 2-link
+   planar arm at known joint angles → known end-effector pose).
+5. Composition algebra: `pose * pose.inverse` ≈ identity;
+   `(a * b).transform(p) == a.transform(b.transform(p))` (atol 1e-9).
+6. `interpolate(t=0)` == self, `(t=1)` ≈ other (double-cover tolerant);
+   midpoint rotation angle is half the total angle for a pure rotation.
+7. `angular_distance` between `q` and `-q` is 0.
+8. `homogeneous` ∘ `from_homogeneous` round-trips (atol 1e-9), including a
+   non-normalized input quaternion (normalized on export).
+9. Existing `Quaternion` test suite passes with import-path and base-class
+   assertion edits only — no assertion on math behavior changes.
+10. `__hash__ is None` pinned for all three classes; `np.asarray(x)` returns
+    the documented array for `Position` and `Quaternion`.
+11. mypy strict clean.
diff --git a/.claude/specs/templateConformance.md b/.claude/specs/templateConformance.md
new file mode 100644
index 0000000..942f8cc
--- /dev/null
+++ b/.claude/specs/templateConformance.md
@@ -0,0 +1,111 @@
+---
+version: 1.0
+type: specification
+name: templateConformance
+purpose: Bring py-MathTools into full conformance with the py-foundationTools template conventions
+spec: TemplateConformance
+scope: project
+status: accepted
+applies_to: pyproject.toml, requirements.txt, Makefile, .env, .github/, .claude/, src/, README.md
+last_updated: 2026-08-14
+semver: 0.0.4
+author: Nicholas Bergantz
+---
+
+# Template Conformance
+
+> Sibling of [mathToolsArchitecture.md](mathToolsArchitecture.md). The
+> authoritative template reference is py-foundationTools at branch
+> `feat/switch-to-new-template`
+> (`/Users/nbergantz/__Workspaces__/pythonWorkspaces/py-foundationTools`);
+> this spec states what "conformant" means for this repo, not a copy of that
+> repo's content.
+
+## Already conformant (verify, don't re-do)
+
+The current branch already carries: the uv Makefile (with `uv-fullCheck`
+gate), `.env` (`PY_SRC=src`), `.bumpversion.cfg`, the `ci-cd.yml` workflow
+(quality checks + Python compatibility matrix on PRs to `dev`/`prod`),
+names-only `pyproject.toml` policy, and pinned `requirements.txt`.
+Conformance work MUST NOT rewrite these wholesale; only close the specific
+gaps below.
+
+## Gap 1 — package rename (breaking, approved)
+
+| Current | Target |
+|---|---|
+| `src/pyMathTools/` | `src/math_tools/` |
+| `src/pyMathToolsPlotHelpers/` | `src/math_plot_helpers/` |
+
+Requirements:
+
+1. `git mv` the trees; module layout inside follows the umbrella's module map
+   (existing `spatial/`, `spherical/`, `hints.py` migrate; `Quaternion.py` →
+   `spatial/quaternion.py`; `plotUnitSpherical.py` →
+   `math_plot_helpers/plot_unit_spherical.py`). Module **filenames** become
+   snake_case; class names are unchanged.
+2. Behavior of migrated code is unchanged in the rename chunk — imports and
+   paths only ([stay-in-scope]). Extensions to migrated classes come later
+   under their own sibling specs.
+3. All imports updated: `tests/`, `examples/`, intra-package.
+4. Every package dir (`math_tools`, each subpackage with public API,
+   `math_plot_helpers`) contains `py.typed`.
+5. `pyproject.toml` needs no `packages` edit (`package-dir = {"" = "src"}`
+   auto-discovers), but the Makefile's mypy package list (`MYPY_PKGS` pattern
+   from the template) and any name references MUST resolve to the new names.
+6. Distribution name stays `py_math_tools`; only import packages rename.
+
+## Gap 2 — dependencies
+
+1. `pyproject.toml` `dependencies`: names only —
+   `pyFoundationTools`, `numpy`, `scipy`, `numpy-quaternion`, `matplotlib`.
+2. `requirements.txt`: keep the `pyFoundationTools @ git+...@feat/switch-to-new-template`
+   pin until foundation tags a release, then move to a tag pin (tracked as a
+   known follow-up, not part of this effort).
+3. No `uv.lock` committed (repo BKM).
+4. **Hard prerequisite for every other chunk:** the installed `.venv` may
+   hold a pre-template `pyfoundationtools` (old per-type ABC layout,
+   `foundationTypes.mathTypes.quaternionABC` etc.). The first chunk MUST
+   `make uv-refresh` (or equivalent) so the environment matches the branch
+   pin's layout (`foundation_abc.math.*`, `PositionType`,
+   `SpatialTransformType`, `ScalarWaveformType`); the gate is meaningless
+   against the stale install.
+
+## Gap 3 — `.claude/` governance
+
+1. `.claude/CLAUDE.md` authored for this repo: role (Tier 3 of foundation's
+   math tiers), package map, gate command, pointer to `.claude/specs/`.
+   It references specs — never duplicates their content.
+2. `.claude/specs/` — this spec set.
+3. `.claude/archive/math-tools-port/` — the completed chunk set produced
+   from these specs.
+
+## Gap 4 — README and metadata
+
+1. `README.md` replaces the "Python Boilerplate" stub, following the
+   template's section shape: title → Features → Installation → Quick Start →
+   Development Workflows → Requirements. Content MUST describe what actually
+   exists at the time the chunk runs (no aspirational feature lists).
+2. `pyproject.toml` `description` updated from boilerplate text.
+3. `examples/sphericalPlotting/*` imports fixed to real module paths (note:
+   `plotArcs.py` currently imports a nonexistent
+   `foundationTypes.mathTypes.UnitSphericalArc` path).
+
+## Gap 5 — layering test
+
+Port the template's layering-enforcement pattern
+(py-foundationTools `tests/test_package_layering.py`) as
+`tests/test_package_layering.py` asserting, via import/AST scan of `src/`:
+
+- `math_tools` never imports `math_plot_helpers` or `matplotlib`.
+- `math_plot_helpers` may import `math_tools`.
+- Only `math_plot_helpers` imports `matplotlib`.
+
+## Compliance checklist (mechanically verifiable)
+
+- [x] `grep -r "pyMathTools" src/ tests/ examples/ Makefile pyproject.toml` → no hits
+- [x] `find src -name py.typed` covers every public package
+- [x] `make uv-fullCheck` passes after rename
+- [x] `.claude/CLAUDE.md` exists and links every spec in `.claude/specs/`
+- [x] `README.md` contains no "Boilerplate" text
+- [x] `tests/test_package_layering.py` passes and fails if `import matplotlib` is added to any `math_tools` module
diff --git a/.claude/specs/waveformCore.md b/.claude/specs/waveformCore.md
new file mode 100644
index 0000000..f4e0e34
--- /dev/null
+++ b/.claude/specs/waveformCore.md
@@ -0,0 +1,240 @@
+---
+version: 1.0
+type: specification
+name: waveformCore
+purpose: Behavioral contract for Waveform1D and the aggregate spatial waveform containers
+spec: WaveformCore
+scope: project
+status: accepted
+applies_to: src/math_tools/waveforms/, tests/waveforms/
+last_updated: 2026-07-23
+semver: 0.0.4
+author: Nicholas Bergantz
+---
+
+# Waveform Core Types
+
+> Sibling of [mathToolsArchitecture.md](mathToolsArchitecture.md). Ports Swift
+> `Waveform1D` / `WaveformPosition` / `WaveformQuaternion` /
+> `WaveformSpatialPose` container behavior (storage, stats, operators,
+> slicing, mutation, component decomposition). The DSP/analysis surface is a
+> separate contract: [waveformDsp.md](waveformDsp.md).
+
+## Modules and base contracts
+
+| Class | Module | Subclasses | Sample storage |
+|---|---|---|---|
+| `Waveform1D` | `waveforms/waveform1d.py` | `Waveform1dABC` | `np.ndarray` 1-D (dtype preserved; float64 default) |
+| `WaveformPosition` | `waveforms/waveform_position.py` | `PositionWaveformABC` | `np.ndarray` `(n, 3)` float64 |
+| `WaveformQuaternion` | `waveforms/waveform_quaternion.py` | `QuaternionWaveformABC` | `np.ndarray` `(n, 4)` float64, order `(w, x, y, z)` |
+| `WaveformSpatialPose` | `waveforms/waveform_spatial_pose.py` | `WaveformSpatialABC` | parallel `(n,3)` + `(n,4)` arrays |
+
+Element access materializes `Position` / `Quaternion` / `SpatialPose`
+([spatialMath.md](spatialMath.md)) on demand; bulk storage stays numpy
+(vectorized ops never round-trip through per-element objects).
+
+## ABC accessor vs numpy storage (load-bearing)
+
+The ABCs' abstract accessors have fixed names and types that MUST be
+implemented or the classes stay abstract:
+
+| Class | ABC accessor implemented | Returns | numpy bulk accessor |
+|---|---|---|---|
+| `Waveform1D` | `waveform` | `Sequence[float]` (the samples) | `values: npt.NDArray` |
+| `WaveformPosition` | `positions` | `Sequence[PositionABC]` (materialized `Position` list, built on access) | `positions_array: npt.NDArray (n,3)` |
+| `WaveformQuaternion` | `quaternions` | `Sequence[QuaternionABC]` | `quaternions_array: npt.NDArray (n,4)` |
+| `WaveformSpatialPose` | `positions` + `quaternions` | both of the above | `positions_array` + `quaternions_array` |
+
+The inherited ABC `to_dict` therefore emits the correct wire keys
+(`"waveform"`, `"positions"`, `"quaternions"`) for free. Implementation code
+and the DSP mixins use the numpy accessors; the ABC accessors exist for the
+contract and serialization.
+
+## Instantiability / DSP phasing (load-bearing)
+
+The core chunk ships `class Waveform1D(Waveform1dABC)` with **no DSP mixin
+bases**. The mixin base list is added in a single later "compose" chunk after
+every mixin exists ([waveformDsp.md](waveformDsp.md)); until then the class
+is complete and the gate stays green. A test pins that `Waveform1D` is
+concrete (`Waveform1D.__abstractmethods__ == frozenset()` and a bare
+construction succeeds).
+
+## Time axis (shared by all four)
+
+- `dt: PrecisionTimeInterval` — required, `ValueError` unless strictly
+  positive ([precisionTimeMath.md](precisionTimeMath.md)).
+- `t0: PrecisionTimestamp` — **defaults to `PrecisionTimestamp.EPOCH`**.
+  Divergence from Swift's optional `t0`, forced by the ABC's non-optional
+  `t0` contract; a waveform with unspecified start simply starts at epoch.
+- Shared computed properties: `duration: PrecisionTimeInterval`
+  (`dt * (n-1)`, ZERO when `n <= 1`), `duration_seconds: float`,
+  `sampling_frequency_hz: float`, `nyquist_frequency_hz: float`,
+  `sample_count: int` (also `__len__`), `time_axis() -> npt.NDArray`
+  (float64 seconds relative to `t0`).
+- Convenience constructor parameters on every class:
+  `dt_seconds: float = 1.0` (**the default when `dt` is omitted** — so
+  `Waveform1D(values)` and `Waveform1D.sine(n=1000)` are legal and mean
+  one sample per second; `TypeError` if both `dt` and `dt_seconds` given)
+  and `t0_seconds: float` (offset from epoch; mutually exclusive with `t0`).
+
+## `Waveform1D`
+
+**Constructors**: `Waveform1D(values, dt=..., t0=...)` (`values`: any 1-D
+array-like; copied), plus signal generator classmethods (all take
+`n: int, dt/dt_seconds, t0` and shape parameters; seeded determinism where
+random): `sine`, `cosine`, `square`, `triangle`, `sawtooth`, `chirp`,
+`exponential_decay`, `exponential_growth`, `polynomial(coefficients)`,
+`linear_ramp`, `logarithm`, `logarithm10`, `square_root`, `heaviside`,
+`relu`, `sigmoid`, `white_noise(seed)`, `constant`, `impulse`,
+`damped_sinusoid`, `counter`, `digital_square`. Each maps to a one-line
+numpy expression; the Swift parameterization is the reference for argument
+names/meaning.
+
+**Generators — span convention (load-bearing).** For an `n`-sample
+waveform starting at `t0`, the sample span is `[0, (n-1)*dt]`
+(endpoint-inclusive) — consistent with `duration` above, NOT `n*dt`. Any
+generator parameter that scales by or defaults to "the waveform's total
+duration" or "the midpoint of the waveform" MUST derive it from `(n-1)*dt`:
+`chirp`'s sweep rate (so the **final** sample's instantaneous frequency is
+exactly `end_frequency`), `heaviside`'s default `step_time`, and
+`sigmoid`'s default `center` (both default to the span midpoint,
+`(n-1)*dt/2`). `n <= 1` is a zero-length span (`0`), not a
+division-by-zero — every affected generator must guard it explicitly.
+Generators whose math does not depend on total duration (e.g. `sine`'s
+`frequency`, `exponential_decay`'s `time_constant`) are unaffected and keep
+using the raw per-sample time axis `np.arange(n) * dt`.
+
+**Statistics** (properties; `None` on empty where Swift is optional):
+`minimum`, `maximum`, `peak_to_peak`, `mean`, `rms`, `standard_deviation`,
+`variance`, `sum`, `absolute_sum`.
+
+**Operators** (elementwise; operands `Waveform1D | scalar`; both scalar
+orders; in-place variants mutate):
+- `+ - * /` (and `//`, `%` — meaningful for integer dtype); waveform⊕waveform
+  requires equal `dt` and length else `WaveformCompatibilityError`.
+- Bitwise `& | ^ << >> ~` — integer dtype only (`TypeError` otherwise,
+  numpy's natural behavior surfaced with a clear message).
+- Unary `-`, `+`, `abs()`.
+- Comparison producers: `elements_equal(other) -> npt.NDArray[np.bool_]`,
+  `elements_less_than`, `elements_greater_than`,
+  `isclose_elementwise(other, rtol=1e-9, atol=0.0)` (numpy `rtol`/`atol`
+  vocabulary, consistent with the spatial types — not Swift's single
+  `tolerance`).
+- `isclose(other, rtol=1e-9, atol=0.0) -> bool` — whole-waveform: same `dt`,
+  same `t0`, all samples close.
+- `==` — full equality: samples (exact), `dt`, `t0`.
+- `__iter__` (yields scalars), `__array__(dtype=None)` (→ the samples), so
+  `for x in w`, `np.asarray(w)`, `np.mean(w)`, `plt.plot(w)` all work.
+
+**Indexing / slicing / sampling**
+- `w[i] -> scalar`; `w[a:b] -> Waveform1D` (t0 advanced by `a * dt`;
+  step != 1 is `ValueError` — resampling is the explicit API). Index
+  slicing is the only index-range API (Swift's `subset(start:end:)` is
+  redundant with it and not ported).
+- `subset_time(start_time, end_time)` (PrecisionTimestamp or float seconds
+  relative to t0) — half-open, `ValueError` on empty/invalid range.
+- `value_at_index(i: float) -> float`, `value_at_time(t) -> float` — linear
+  interpolation; `ValueError` outside `[0, n-1]` / the time span.
+
+**Mutation API** (the only in-place surface besides in-place operators) —
+Python list vocabulary, not Swift's:
+`append(x)`, `append_values(iterable)`, `prepend(x)`,
+`prepend_values(iterable)` (t0 shifts back by `k * dt`), `insert(i, x)`,
+`replace(i, x)`, `replace_range(slice, values)`,
+`pop(i=-1) -> float` (`IndexError` on empty/out-of-range — stdlib
+semantics, not Swift's Optional), `clear()`.
+
+## Aggregate containers
+
+All three share (with `Element` = `Position` / `Quaternion` / `SpatialPose`):
+
+- **Constructors**: from element arrays/lists; `from_components(...)` from
+  per-component `Waveform1D`s (`None`-safe: `ValueError` unless counts and
+  `dt` all match — Swift returned nil); `WaveformSpatialPose` additionally
+  `from_poses(list[SpatialPose], dt/dt_seconds, t0)` and
+  `from_waveforms(position_waveform, quaternion_waveform)`.
+- **Element access**: `w[i] -> Element`, `w[a:b] -> Self`, `get(i) ->
+  Element | None` (Swift's `subscript(safe:)`), `__iter__` yielding
+  materialized `Element`s.
+- **Component decomposition**: `component_waveforms` returning a `NamedTuple`
+  of `Waveform1D`s — `(x, y, z)` for positions, **`(w, x, y, z)`** for
+  quaternions (w-first, matching storage, `from_components`, and the
+  incumbent `Quaternion.to_components()`; the Swift x-first tuple order is
+  NOT kept), nested position+quaternion tuple for poses;
+  `WaveformSpatialPose` also `position_waveform` and `quaternion_waveform`.
+- **Normalization**: predicate stem is `unit` everywhere —
+  `WaveformPosition.are_all_unit`, `WaveformQuaternion.are_all_unit`,
+  `WaveformSpatialPose.are_all_positions_unit` /
+  `are_all_quaternions_unit`; `normalize()` in place, `normalized()` copy.
+  Zero-magnitude elements raise `ValueError` (parity with
+  `Position.normalize`).
+- **Mutation**: same verbs as `Waveform1D` with `Element` payloads, plus
+  `extend(other: Self)` and `concatenate(other: Self) -> Self` — both raise
+  `WaveformCompatibilityError` on `dt` mismatch (Swift `throws` parity).
+- `WaveformSpatialPose.is_valid` (parallel arrays equal length) and
+  `sample_count == min(len(positions), len(quaternions))` — both subtle Swift
+  behaviors, kept.
+- `==`, `repr`, `to_dict`/`from_dict` per the ABC wire shapes.
+- **Shared API idioms** (mathToolsArchitecture.md §API idioms, chunk 50): all
+  three aggregates additionally implement `__array__` and
+  `isclose(other, rtol, atol)`, mirroring the umbrella idiom already required
+  of `Waveform1D`, `Position`, and `Quaternion`.
+  - `__array__(dtype=None, copy=None)`: `WaveformPosition` returns the
+    `(sample_count, 3)` position array; `WaveformQuaternion` returns the
+    `(sample_count, 4)` `(w, x, y, z)` array; `WaveformSpatialPose` returns a
+    **`(sample_count, 7)`** array, columns `[x, y, z, w, i, j, k]` (position
+    `xyz` then quaternion `wxyz`, both truncated to `sample_count` — the
+    "valid prefix" per §Compliance 9, not either raw array's own length).
+    All three raise `ValueError` when `copy=False` is requested, since a copy
+    is always required (the returned array must never alias the mutable
+    backing store) — the same contract `Waveform1D.__array__` follows.
+  - `isclose(other, rtol=1e-9, atol=...)`: `False` on differing
+    `sample_count` or differing `dt`/`t0`; otherwise elementwise
+    `np.isclose` over the backing array(s) (`atol` default mirrors the
+    wrapped element type: `0.0` for `WaveformPosition`/the position half of
+    `WaveformSpatialPose`, matching `Position.isclose`; `1e-11` for
+    `WaveformQuaternion`, matching `Quaternion.isclose`).
+    `WaveformQuaternion` and the quaternion half of `WaveformSpatialPose` are
+    double-cover aware **per sample**: each row independently may match
+    either `other`'s row or its negation (`q` and `-q` are the same
+    rotation).
+  - `WaveformSpatialPose.from_components(position_x, position_y, position_z,
+    quaternion_w, quaternion_x, quaternion_y, quaternion_z)`: the third
+    aggregate's `from_components`, dropped in chunk 17 and restored in chunk
+    50 — seven per-component `Waveform1D`s (three position, four quaternion),
+    following `WaveformPosition.from_components`/
+    `WaveformQuaternion.from_components`'s shape; `ValueError` unless all
+    seven share length and `dt`.
+
+## Compliance requirements (test-checkable)
+
+1. All four classes: `isinstance` of their ABC; `to_dict` output loads via
+   the matching `foundationTypes` generated Type and round-trips equal —
+   exact target names on the pinned branch: `Waveform1D` ↔
+   `ScalarWaveformType`, `WaveformPosition` ↔ `PositionWaveformType`,
+   `WaveformQuaternion` ↔ `QuaternionWaveformType`, `WaveformSpatialPose` ↔
+   `SpatialTransformWaveformType`.
+2. `dt` mismatch on any binary/extend/concat op raises
+   `WaveformCompatibilityError`; equal-`dt` path is exact.
+3. Slicing adjusts `t0` by exactly `start * dt` (attosecond-exact via
+   PrecisionTime, not float).
+4. Generators pinned analytically: `sine` matches `np.sin` on the time axis;
+   `white_noise(seed=k)` reproducible; `impulse` sums to 1 sample of
+   amplitude.
+5. Stats match numpy references on a fixed vector (`rms` =
+   `sqrt(mean(x**2))`, `variance` population variance — pin Swift's ddof
+   choice with a literal expected value).
+6. `value_at_time` midpoint between two samples returns their average.
+7. Mutation verbs match stdlib list semantics (pin `prepend` t0 shift;
+   `pop()` on empty raises `IndexError`; `clear()` empties).
+8. Aggregate `component_waveforms` → `from_components` round-trips exactly
+   (quaternion tuple order `(w, x, y, z)` pinned).
+9. `WaveformSpatialPose` with unequal arrays: `is_valid` False,
+   `sample_count` = min — both pinned.
+10. Bulk ops never construct per-element objects (pin with a 1e6-sample
+    smoke test completing under a generous bound, guarding the vectorized
+    design).
+11. `Waveform1D(values)` with no time arguments constructs (dt = 1 s);
+    `Waveform1D.__abstractmethods__` is empty; `np.asarray(w)` equals the
+    samples; `for x in w` iterates them.
+12. mypy strict clean.
diff --git a/.claude/specs/waveformDsp.md b/.claude/specs/waveformDsp.md
new file mode 100644
index 0000000..b21f0cd
--- /dev/null
+++ b/.claude/specs/waveformDsp.md
@@ -0,0 +1,314 @@
+---
+version: 1.0
+type: specification
+name: waveformDsp
+purpose: Behavioral contract for the Waveform1D DSP/analysis surface (scipy-backed)
+spec: WaveformDsp
+scope: project
+status: accepted
+applies_to: src/math_tools/waveforms/dsp/, src/math_tools/waveforms/support.py, tests/waveforms/dsp/
+last_updated: 2026-07-23
+semver: 0.0.8
+author: Nicholas Bergantz
+---
+
+# Waveform DSP Surface
+
+> Sibling of [mathToolsArchitecture.md](mathToolsArchitecture.md); extends
+> `Waveform1D` from [waveformCore.md](waveformCore.md). Target: **capability
+> parity** with the Swift `Waveform1D/Extensions/` DSP families, implemented
+> as thin scipy/numpy wrappers. Parity is judged per capability, not per
+> Swift overload — where scipy's algorithm is the better-tested equivalent,
+> scipy semantics win and the divergence is documented in the method
+> docstring.
+
+## Organization — one mixin per family
+
+Each family is a mixin class in its own module under
+`math_tools/waveforms/dsp/`; `Waveform1D` composes them:
+
+```python
+# waveforms/waveform1d.py
+class Waveform1D(
+    CalcMixin, CorrelationMixin, EnvelopeMixin, SpectralMixin,
+    FilteringMixin, PeakMixin, PhaseMixin, ResamplingMixin,
+    TimeAlignmentMixin, TriggerMixin, WindowingMixin, ZeroCrossingMixin,
+    Waveform1dABC,
+):
+```
+
+Mixin rules: stateless; touch only the public `Waveform1D` surface
+(`values`, `dt`, `t0`, constructors). Typing mechanism (load-bearing —
+mypy strict rejects a bare mixin referencing `self.values`): each mixin is a
+**plain class** (no runtime base beyond `object`) that types its `self`
+parameter as `WaveformProtocol` on every method — mypy's documented "mixin
+classes" idiom, e.g. `def integrate(self: WaveformProtocol, ...) ->
+WaveformProtocol: ...` — where `WaveformProtocol` is a `typing.Protocol` in
+`dsp/_protocol.py` declaring `values: npt.NDArray`, `dt`, `t0`,
+`sampling_frequency_hz`, and the replace-values factory the mixins use to
+build results. That makes every mixin independently mypy-strict-checkable
+and independently testable. Methods return new objects or descriptor
+types — never mutate.
+
+**Do not nominally inherit `WaveformProtocol`** (`class CalcMixin
+(WaveformProtocol)`) — that was the first design tried and it is broken at
+runtime. Explicitly subclassing a `Protocol` (without also listing
+`Protocol` itself as a base) turns its stub property bodies — literally
+`...`, so the getter returns `None` — into concrete inherited
+implementations. The DSP mixin test convention composes a mixin directly
+with `Waveform1D` (`class _W(CalcMixin, Waveform1D): pass`, see below);
+under C3 linearization that puts the inherited Protocol stub ahead of
+`Waveform1D`'s real property, so `self.values` silently returns `None`
+instead of the sample array — caught by chunk 18's own TDD steps, not by
+inspection. Self-typing `self` avoids this: the mixin class carries no
+runtime base beyond `object`, so composing it with `Waveform1D` never pulls
+`WaveformProtocol` into the MRO, while mypy still resolves every `self.*`
+access structurally through the `self: WaveformProtocol` annotation.
+
+**Two result factories.** Every mixin through chunk 24 only ever produces
+results that share `self`'s `dt`/`t0` (built via `_with_values(values)`, same
+`dt`/`t0`, new samples). `ResamplingMixin` (chunk 25, `dsp/_resampling.py`)
+is the first family whose results have a genuinely different sample
+spacing (`decimated`/`interpolated`/`resampled`/`polyphase_resampled` all
+compute a new `dt`), so `WaveformProtocol` gained a second factory,
+`_with_axis(values, dt) -> WaveformProtocol` (new samples, a caller-supplied
+`dt`, `t0` unchanged from `self`) — implemented alongside `_with_values` on
+`Waveform1D`. `t0` is deliberately not a parameter of `_with_axis`: every
+`ResamplingMixin` method keeps `t0` unchanged (see its family-contract row
+below), so add a `t0` parameter only when a future mixin needs to vary it
+too.
+
+**Three result factories.** `TimeAlignmentMixin` (chunk 26,
+`dsp/_time_alignment.py`) is that future mixin: `aligned`, `synchronize`,
+`time_windows`, and `time_segments` all produce results with the same `dt`
+as their source but a genuinely different `t0` (a detected/reference time
+shift, an overlap window's start, or a sub-span's start). Neither existing
+factory fits (`_with_values` pins `t0`; `_with_axis` also pins `t0` while
+changing `dt`), so `WaveformProtocol` gained a third factory,
+`_with_t0(values, t0) -> WaveformProtocol` (new samples, same `dt` as
+`self`, a caller-supplied `t0`) — implemented alongside the other two on
+`Waveform1D`. The three factories now form a complete same-dt/same-t0
+triangle: `_with_values` (same `dt`, same `t0`), `_with_axis` (new `dt`,
+same `t0`), `_with_t0` (same `dt`, new `t0`).
+
+**Composition phasing** (mirrors waveformCore's "Instantiability" section):
+the core `Waveform1D` ships with base `Waveform1dABC` only. Each mixin chunk
+adds a module without touching `waveform1d.py`. A single final **compose
+chunk** edits the base list to the form above, adds the MRO test, and pins
+that the composed class is still concrete (empty `__abstractmethods__`,
+bare construction succeeds). Compliance item 4 applies only from that chunk
+onward.
+
+**Done as of chunk 30 (semver 0.0.7).** `waveform1d.py` now imports all
+twelve `dsp/_*.py` mixin modules directly (not via `dsp/__init__.py`) and
+composes them in the base-list order above; `tests/waveforms/dsp/test_compose.py`
+pins the MRO, concreteness, and one live smoke call per family.
+`dsp/__init__.py` also re-exports all twelve mixins (`__all__`) for direct
+import convenience, per this chunk's own file list.
+
+**Circular import found and resolved (chunk 30).** Composing every mixin
+into `waveform1d.py` is not the only place a cycle could appear: populating
+`dsp/__init__.py`'s exports means importing *any* `dsp/_*` submodule now
+also executes `dsp/__init__.py` (Python always initializes a package before
+one of its submodules), which in turn imports every mixin -- several of
+which (`dsp/_correlation.py`, etc.) import descriptor types back out of
+`waveforms/support.py`. `support.py` itself imports `dsp._protocol.
+WaveformProtocol` at module scope (only for the `WaveformWithEvents.waveform`
+field annotation, chunk 27) -- so `import support.py` -> triggers
+`dsp/__init__.py` -> imports `dsp/_correlation.py` -> imports back into
+`support.py`, which is still mid-import (`WaveformTimeLag` not yet defined),
+raising `ImportError: cannot import name 'WaveformTimeLag' from partially
+initialized module`. Fix: `support.py`'s `WaveformProtocol` import moved
+under `if TYPE_CHECKING:` -- safe because `from __future__ import
+annotations` (already present in `support.py`) defers every annotation to a
+string, so the import was never needed at runtime, only for mypy, which
+resolves `TYPE_CHECKING` imports without executing them. This is the
+opposite direction from the forbidden case in `dsp/_protocol.py`'s
+docstring (a DSP mixin importing `Waveform1D`, forbidden even under
+`TYPE_CHECKING`, because a mixin must stay import-cycle-free with the class
+it composes onto) -- `support.py` importing the mixins' shared protocol
+under `TYPE_CHECKING` carries no such restriction and does not reopen that
+door.
+
+**Layering test scope correction (chunk 30).** `tests/test_package_layering.py
+::test_dsp_mixins_do_not_import_sibling_mixins` globs `dsp/_*.py`, which
+also matches `dsp/__init__.py` (a leading `__` starts with `_`). That test
+enforces §Compliance 2 ("each mixin module imports scipy/numpy plus
+_protocol/_common only") -- correct for the twelve mixin modules, but
+`dsp/__init__.py` is not a mixin module; from this chunk onward it is
+*expected* to import every mixin to re-export it. The test now explicitly
+skips `__init__.py` rather than treating it as a mixin-module violation.
+
+**Chunking hint:** one action-plan chunk per mixin; `support.py`,
+`dsp/_protocol.py`, and `dsp/_common.py` land first as a prerequisite chunk.
+
+## Family contracts
+
+For every family: the Swift extension file is the reference for the method
+list and argument meanings; the table row states the required Python surface
+and its backing implementation. Enum arguments use the support types below.
+
+| Mixin (module) | Required methods | Backing |
+|---|---|---|
+| `CalcMixin` (`_calc.py`) | `integrate(initial_value=0.0)`, `derivative()` | cumulative trapezoid (`scipy.integrate.cumulative_trapezoid`) · `np.gradient`; both scale by `dt` seconds |
+| `CorrelationMixin` (`_correlation.py`) | `auto_correlation(max_lag=None, normalized=True)`, `cross_correlation(other, ...)`, `find_max_correlation(other, ...) -> WaveformTimeLag` | `scipy.signal.correlate` / `correlation_lags` |
+| `EnvelopeMixin` (`_envelope.py`) | `amplitude_envelope(...)`, `upper_lower_envelopes(...) -> tuple[Waveform1D, Waveform1D]`, `instantaneous_amplitude(method: WaveformInstantaneousMethod)` | `scipy.signal.hilbert`; peak-interp path via `find_peaks` + interp |
+| `SpectralMixin` (`_spectral.py`) | `fft() -> WaveformSpectrum`, `power_spectral_density(...) -> WaveformSpectrum`, `spectrogram(...) -> WaveformSpectrogram`, `mel_spectrogram(...) -> WaveformMelSpectrogram`, `spectral_features() -> WaveformSpectralFeatures` | `np.fft.rfft` / `scipy.signal.welch` / `scipy.signal.ShortTimeFFT`; mel filterbank hand-built (numpy) |
+| `FilteringMixin` (`_filtering.py`) | `filtered(filter_type: WaveformFilterType, order=4)`, `low_pass_filter(cutoff_hz, ...)`, `high_pass_filter(...)`, `band_pass_filter(low_hz, high_hz, ...)`, `moving_average_filter(window_size)`, `exponential_filter(alpha)`, `savitzky_golay_filter(window_length, polyorder, deriv=0)`, `whittaker_henderson_filter(lam, order=2)`, `frequency_response(...) -> WaveformSpectrum` | `scipy.signal.butter`+`filtfilt`, `savgol_filter`, `np.convolve`; Whittaker–Henderson via `scipy.sparse` difference-matrix solve |
+| `PeakMixin` (`_peaks.py`) | `detect_peaks(...) -> list[WaveformPeak]`, `detect_valleys(...)`, `find_most_prominent_peaks(count, min_distance=None) -> list[WaveformPeakWithProminence]` | `scipy.signal.find_peaks` / `peak_prominences` |
+| `PhaseMixin` (`_phase.py`) | `instantaneous_phase(...)`, `unwrap_phase(...)`, `instantaneous_frequency(...) -> WaveformInstantaneousFrequency`, `phase_difference(other, ...)`, `phase_coherence(other, ...)`, `phase_synchronization_index(other) -> float`, `group_delay(...)` | `scipy.signal.hilbert`, `np.unwrap` |
+| `ResamplingMixin` (`_resampling.py`) | `decimated(factor, ...)`, `interpolated(factor, method: WaveformInterpolationMethod = ...)`, `resampled(target_frequency_hz, ...)`, `resampled_to_match(other)`, `polyphase_resampled(up, down)` | `scipy.signal.decimate` / `resample` / `resample_poly`; results carry recomputed `dt` (attosecond-exact where the ratio is rational) |
+| `TimeAlignmentMixin` (`_time_alignment.py`) | `aligned(to, method: WaveformAlignmentMethod = ...)`, `time_lag(to, max_lag=None) -> WaveformTimeLag \| None`, `synchronize(waveforms: Sequence[Waveform1D]) -> list[Waveform1D]` (classmethod), `time_windows(...)`, `time_segments(...)` | correlation-lag via `CorrelationMixin` |
+| `TriggerMixin` (`_triggers.py`) | `detect_triggers(trigger: WaveformTrigger) -> list[WaveformTriggerEvent]`, `detect_edge_triggers(level, edge: WaveformEdgeType)`, `detect_level_triggers(...)`, `detect_window_triggers(low, high, kind: WaveformWindowTriggerType)`, `detect_pattern_triggers(pattern, tolerance)`, `with_event_markers(events) -> WaveformWithEvents` | numpy comparisons + sign-change indexing |
+| `WindowingMixin` (`_windowing.py`) | `windowed(window: WaveformWindowType)`, `generate_window(window, length, periodic: bool = False) -> npt.NDArray` (staticmethod), `window_coherent_gain(window, periodic: bool = False) -> float`, `window_processing_gain(window, periodic: bool = False) -> float` | `scipy.signal.get_window`; see §Window convention for the symmetric/periodic split with `SpectralMixin` |
+| `ZeroCrossingMixin` (`_zero_crossings.py`) | `zero_crossings(direction: WaveformZeroCrossingDirection = BOTH) -> list[WaveformZeroCrossing]`, `zero_crossing_count(...)`, `zero_crossing_rate(...) -> float`, `segments_between_zero_crossings(...) -> list[Waveform1D]` | numpy sign-change indexing, sub-sample linear interp |
+
+## Window convention (chunk 53)
+
+`WindowingMixin` and `SpectralMixin` both call `scipy.signal.get_window`, but
+for genuinely different purposes, and each keeps its own default:
+
+- **`WindowingMixin` default: symmetric** (`fftbins=False`). This matches the
+  Swift reference's own `n - 1`-denominator formulas: a finite-length
+  window's first and last samples are exactly the window's edge value, and
+  (for odd length) the true midpoint sample is exactly the window's peak.
+  This is the right convention for filter design, gain/coherent-gain
+  analysis, and applying a window to a whole waveform (`windowed`).
+- **`SpectralMixin` default: periodic** (`fftbins=True`, scipy's own
+  default). This is the right convention for STFT frame tiling
+  (`power_spectral_density` via `welch`, `spectrogram`), where the window
+  must satisfy the constant-overlap-add condition across abutting frames —
+  a symmetric window's duplicated edge sample breaks that condition.
+
+Both conventions are legitimate and neither family's default changes as a
+result of this reconciliation. The defect this section closes (post-audit
+finding D-windowing-(c)) was that `WindowingMixin.window_coherent_gain`/
+`window_processing_gain` — whose entire purpose is to let a caller correct a
+spectral estimate's scale factor — had no way to describe the periodic
+window `power_spectral_density`/`spectrogram` actually apply, so a caller
+using them together got a subtly wrong gain. Fix: `generate_window`,
+`window_coherent_gain`, and `window_processing_gain` all take an explicit
+`periodic: bool = False` parameter. `periodic=False` (the default,
+unchanged) is `WindowingMixin`'s own symmetric convention; `periodic=True`
+requests the exact periodic window `SpectralMixin` applies internally, so
+`w.window_coherent_gain(HANN, periodic=True)` correctly describes the
+window backing `w.power_spectral_density(window=HANN)`. `windowed` keeps
+the symmetric-only default — it is `WindowingMixin`'s own use case
+(filter/analysis framing on a whole waveform), not a spectral-estimate
+correction helper, so it gained no `periodic` parameter.
+
+**Kaiser beta: single shared constant.** `dsp/_common.DEFAULT_KAISER_BETA =
+14.0` is the one source both `_windowing.py` and `_spectral.py` import for
+the Kaiser window's shape parameter (previously two independent `14.0`
+literals with no test pinning them equal). `WaveformWindowType` is a flat
+`str` enum with no `beta` field (unlike the Swift reference's associated-
+value `.kaiser(beta:)`), so exposing a caller-supplied beta would force an
+enum redesign; this chunk took the "keep the shared constant, record the
+narrowing" path from the corrective-action chunk rather than redesigning
+the enum. **Known deviation from the Swift reference:** Kaiser beta is not
+caller-configurable in the Python surface (Swift: `case kaiser(beta:
+Double)`); it is fixed at `DEFAULT_KAISER_BETA` for both families. Revisit
+only if a caller needs a different beta (YAGNI).
+
+## Support descriptor types — `waveforms/support.py`
+
+Port from Swift `Waveform1D/Support/` **only the types consumed by the
+methods above** (YAGNI on the rest; add with the method that needs them).
+
+- **Enums** (`enum.Enum`, values = snake_case strings):
+  `WaveformFilterType` (LOW_PASS/HIGH_PASS/BAND_PASS/BAND_STOP),
+  `WaveformWindowType` (HANN/HAMMING/BLACKMAN/BARTLETT/KAISER/RECTANGULAR),
+  `WaveformInterpolationMethod` (LINEAR/CUBIC/NEAREST/FOURIER),
+  `WaveformInstantaneousMethod` (HILBERT/RMS/PEAK),
+  `WaveformEdgeType` (RISING/FALLING/BOTH),
+  `WaveformWindowTriggerType` (ENTER/EXIT),
+  `WaveformAlignmentMethod` (CORRELATION/START_TIME),
+  `WaveformZeroCrossingDirection` (POSITIVE/NEGATIVE/BOTH),
+  `WaveformPaddingStrategy` (ZERO/EDGE/REFLECT/WRAP),
+  `WaveformPSDScaling` (DENSITY/SPECTRUM),
+  `WaveformSpectrogramScaling` (LINEAR/DB/MEL).
+- **Frozen dataclasses** (all `@dataclass(frozen=True, slots=True)`).
+  **ndarray hazard:** any descriptor holding numpy arrays
+  (`WaveformSpectrum`, `WaveformSpectrogram`, `WaveformMelSpectrogram`,
+  `WaveformInstantaneousFrequency`, `WaveformFilterCoefficients`, …) MUST
+  use `@dataclass(frozen=True, slots=True, eq=False)` — the generated
+  `__eq__`/`__hash__` raise/misbehave on arrays (`ValueError: ambiguous
+  truth value`). Scalar-only descriptors keep the default `eq=True`.
+  Descriptor types:
+  `WaveformSpectrum(frequencies, magnitudes, phases)` (numpy arrays; replaces
+  Swift's anonymous fft tuple), `WaveformSpectrogram(times, frequencies,
+  magnitudes)`, `WaveformMelSpectrogram(...)`, `WaveformSpectralFeatures`
+  (centroid, spread, rolloff, flatness, …, matching the Swift fields),
+  `WaveformPeak(index, time_seconds, value)`,
+  `WaveformPeakWithProminence(peak, prominence)`,
+  `WaveformTimeLag(lag_samples, lag_seconds, correlation)`,
+  `WaveformTrigger(kind: WaveformTriggerType, level, lower, upper, pattern,
+  tolerance, minimum_interval, edge, window_kind)`,
+  `WaveformTriggerEvent(index, time_seconds, value, kind)`,
+  `WaveformEventMarker(index, label)`, `WaveformWithEvents(waveform:
+  WaveformProtocol, events)`, `WaveformZeroCrossing(index, time_seconds,
+  direction)`, `WaveformInstantaneousFrequency(frequencies_hz,
+  times_seconds)`, `WaveformFrequencyRange(low_hz, high_hz)`,
+  `WaveformFilterCoefficients(numerator, denominator)`.
+
+  **`WaveformTrigger`'s `edge`/`window_kind` fields (chunk 27, semver
+  0.0.6):** `edge: WaveformEdgeType | None = None` and `window_kind:
+  WaveformWindowTriggerType | None = None`, both optional and defaulting to
+  `None`. `TriggerMixin.detect_triggers` (the generic `WaveformTrigger`-
+  driven dispatcher) needs a direction/enter-exit selector for `EDGE`/
+  `LEVEL`/`WINDOW` kinds — the direct `detect_edge_triggers`/
+  `detect_level_triggers`/`detect_window_triggers` methods take it as an
+  explicit argument, but the dataclass had no field to carry it until this
+  change. Dispatch falls back to `WaveformEdgeType.BOTH` (`EDGE`),
+  `WaveformEdgeType.RISING` (`LEVEL`), and `WaveformWindowTriggerType.ENTER`
+  (`WINDOW`) when the caller leaves the field unset — matching each direct
+  method's own default — so this is backward-compatible with every
+  pre-chunk-27 `WaveformTrigger(...)` call site.
+
+  **`WaveformWithEvents.waveform`'s type (chunk 27, semver 0.0.6):** typed
+  `WaveformProtocol` (`dsp/_protocol.py`), not the concrete `Waveform1D` it
+  held through chunk 26. `TriggerMixin.with_event_markers` is the first
+  mixin method that embeds `self` itself into a returned descriptor —
+  every earlier descriptor holds only derived values (arrays, scalars,
+  other descriptors). Mixins type `self` as `WaveformProtocol` and must
+  never import `Waveform1D` (§Organization; not even under
+  `TYPE_CHECKING` — see `dsp/_protocol.py`'s docstring), so a field typed
+  concrete `Waveform1D` was unsatisfiable from a mixin method without that
+  forbidden import. `Waveform1D` already satisfies `WaveformProtocol`
+  structurally (both at runtime via `@runtime_checkable` and under mypy
+  strict), so retyping the field is behavior-preserving for every caller —
+  a real `Waveform1D` is still exactly what gets passed in and read back
+  out — and removes `support.py`'s only import of `waveforms/waveform1d.py`,
+  closing off what would otherwise become a circular import once the
+  chunk-30 compose step makes `waveform1d.py` import every mixin (mixins
+  already import `support.py`; `support.py` importing back into
+  `waveform1d.py` would have completed the cycle).
+
+## Numerical conventions
+
+- Frequencies in Hz, times in float seconds (derived from the PrecisionTime
+  axis at the boundary), phases in radians.
+- Filters are zero-phase (`filtfilt`) unless a method exposes a `causal=`
+  flag.
+- Methods that need a minimum length raise `ValueError` with the requirement
+  in the message (never a silent empty result), except detectors
+  (`detect_*`, `zero_crossings`) which return empty lists on no-hit.
+
+## Compliance requirements (test-checkable)
+
+1. Every mixin method tested against an analytically known signal — e.g.
+   `fft` of a pure 10 Hz sine peaks at 10 Hz bin; `low_pass_filter` on a
+   5 Hz + 200 Hz mix attenuates the 200 Hz component by ≥ 40 dB;
+   `derivative` of a linear ramp is constant to atol 1e-9;
+   `integrate`∘`derivative` recovers a smooth signal (interior points,
+   rtol 1e-6); `detect_peaks` on `sine` finds exactly `⌊n·f·dt⌋` peaks;
+   `zero_crossing_rate` of a sine equals `2f` ±1 count; `unwrap_phase` of a
+   chirp is monotone; `resampled` ×2 then ÷2 round-trips (rtol 1e-3, interior).
+2. Each mixin module imports scipy/numpy only (no sibling mixin imports —
+   shared helpers live in `dsp/_common.py`); pinned by a layering test.
+3. Descriptor types are frozen (mutation raises); ndarray-bearing ones have
+   `eq=False` (pin: constructing two equal-content instances and comparing
+   does not raise); all mypy strict clean.
+4. From the compose chunk onward: `Waveform1D` MRO composes every mixin
+   exactly once (pinned by a test enumerating `Waveform1D.__mro__`), the
+   class remains concrete, and a bare `Waveform1D(values)` constructs.
diff --git a/.editorconfig b/.editorconfig
new file mode 100644
index 0000000..4ff9be7
--- /dev/null
+++ b/.editorconfig
@@ -0,0 +1,33 @@
+# https://editorconfig.org
+root = true
+
+[*]
+charset = utf-8
+end_of_line = lf
+indent_style = space
+indent_size = 4
+trim_trailing_whitespace = true
+insert_final_newline = true
+
+[*.{html,css,js,json,sh,yml,yaml}]
+indent_size = 2
+
+[LICENSE]
+insert_final_newline = false
+
+[Makefile]
+indent_style = tab
+indent_size = unset
+
+# Ignore binary or generated files
+[*.{png,jpg,gif,ico,woff,woff2,ttf,eot,svg,pdf}]
+charset = unset
+end_of_line = unset
+indent_style = unset
+indent_size = unset
+trim_trailing_whitespace = unset
+insert_final_newline = unset
+max_line_length = unset
+
+[*.{diff,patch}]
+trim_trailing_whitespace = false
diff --git a/.env b/.env
index 5567480..5bd627c 100644
--- a/.env
+++ b/.env
@@ -1,2 +1,23 @@
+# This file is parsed by GNU Make (`include .env` in the Makefile), not a shell.
+# Values are Make variables expanded UNQUOTED into recipes — keep that in mind below.
+
+# Python interpreter for pip-based targets (single token — used as `$(PYTHON) -m pip`).
 PYTHON=python3
-VENV=/tmp/pipTest
+
+# Default version for single-version uv operations. MUST appear in PYTHONS below.
+DEFAULT_PYTHON=3.13
+
+# Versions to test against. SPACE-SEPARATED, UNQUOTED on purpose:
+# Make expands `$(PYTHONS)` straight into `uv python install ...` as separate args.
+# Do NOT quote or comma-separate — that collapses it into one bogus argument.
+# Canonical set: default 3.13, support floor 3.10 (matches requires-python>=3.10).
+PYTHONS=3.10 3.11 3.12 3.13
+
+# Throwaway clean-room venv for `make testInEnv` (deleted on teardown).
+# Kept DISTINCT from uv's `.venv` so the clean-room never nukes your dev env.
+VENV=.cleanroom-venv
+
+# Quality-target source dir. A generated project uses a src/ layout (no hooks/),
+# so override the Makefile's root default (PY_SRC=hooks) → src here. This is what
+# `make uv-lint` / `uv-typecheck` scan; the Makefile's PY_SRC ?= is the fallback.
+PY_SRC=src
diff --git a/.github/CODEOWNERS b/.github/CODEOWNERS
new file mode 100644
index 0000000..fbada3a
--- /dev/null
+++ b/.github/CODEOWNERS
@@ -0,0 +1,3 @@
+# Code owners — automatically requested for review on matching paths.
+# https://docs.github.com/en/repositories/managing-your-repos-settings/about-code-owners
+* @kopecn
diff --git a/.github/workflows/ci-cd.yml b/.github/workflows/ci-cd.yml
new file mode 100644
index 0000000..f366819
--- /dev/null
+++ b/.github/workflows/ci-cd.yml
@@ -0,0 +1,45 @@
+name: CI-CD
+
+on:
+  pull_request:
+    branches:
+      - dev
+      - prod
+    types:
+      - opened
+      - synchronize
+      - reopened
+
+jobs:
+  quality:
+    name: Quality
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+
+      - name: Install Python versions
+        run: make uv-bootstrap-pythons
+
+      - name: Bootstrap development environment
+        run: make uv-bootstrap
+
+      - name: Run quality checks
+        run: make uv-fullCheck
+
+  compatibility:
+    name: Python Compatibility
+    runs-on: ubuntu-latest
+
+    steps:
+      - uses: actions/checkout@v4
+
+      - uses: astral-sh/setup-uv@v5
+
+      - name: Install configured Python versions
+        run: make uv-bootstrap-pythons
+
+      - name: Run compatibility matrix
+        run: make uv-test-all
\ No newline at end of file
diff --git a/.gitignore b/.gitignore
index d609a52..a9f81c8 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,157 +1,148 @@
-# Byte-compiled / optimized / DLL files
+# ==============================
+# Python Build / Bytecode Artifacts
+# ==============================
+
+# Compiled Python files (bytecode)
 __pycache__/
 *.py[cod]
 *$py.class
 
-# Cython and C extensions
+# Compiled binary extensions
 *.c
 *.so
 *.pyd
 *.dll
 
-# Distribution / packaging
-.Python
+# Directory-level compiled artifacts
 build/
-develop-eggs/
 dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
+develop-eggs/
 sdist/
+parts/
 var/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
 
-# PyInstaller
-# Usually contains a dist/ folder and build/ artifacts
-*.manifest
-*.spec
 
-# PyBuilder
-target/
+# ==============================
+# Virtual Environments & Dependencies
+# ==============================
 
-# Virtual environments
-.env/
+# General virtual environments (Modern and Classic)
 .venv/
-env/
+# Throwaway clean-room venv for `make testInEnv` (VENV in .env)
+.cleanroom-venv/
 venv/
-ENV/
-env.bak/
-venv.bak/
-
-# pipenv
-Pipfile.lock
+env/
+.env/
 
-# poetry
+# Specific package manager caches / lock files
 poetry.lock
+Pipfile.lock
+# uv.lock is intentionally NOT committed: this is a library, so we declare version
+# ranges (requires-python) and stay on uv's `uv pip` interface, which never writes a
+# lockfile (only `uv sync`/`uv lock` do). Ignored as belt-and-suspenders.
+uv.lock
+# NOTE: requirements.txt and requirements-release.txt are COMMITTED, not ignored. Per the
+# dependency BKM pyproject.toml declares dependency NAMES ONLY; the requirements files carry
+# the pins + git-based pointers and every install path leans on them. No `lock`/compile step.
+# requirements-local.txt is the per-machine local editable sibling overlay (`-e ../sibling`
+# lines) consumed by `make uv-sync-local`. Never committed.
+requirements-local.txt
+# Generic wheel/package info folders
+*.egg-info/
 
-# hatch
-*.hatch/
-
-# pdm
-__pypackages__/
-
-# tox and nox
+# PDK / Environment Specific Cache Folders
 .tox/
 .nox/
-
-# pytest
-.cache/
-.pytest_cache/
-
-# mypy
 .mypy_cache/
-.dmypy.json
-dmypy.json
 
-# coverage and test reports
+# ==============================
+# Tooling and Static Analysis Caches
+# ==============================
+
+# Coverage / Testing Reports
 .coverage
 .coverage.*
-nosetests.xml
-coverage.xml
-*.cover
-.hypothesis/
-
-# Pyre type checker
-.pyre/
-
-# CMake files
-CMakeFiles/
-CMakeCache.txt
-cmake_install.cmake
+htmlcov/
 
+# Pytest cache directory
+.pytest_cache/ 
 
-# Translations
-*.mo
-*.pot
+# Mypy specific files
+dmypy.json
 
-# Django stuff
-*.log
-local_settings.py
-db.sqlite3
+# Ruff (Linter) cache
+.ruff_cache/
 
-# Flask stuff
-instance/
-.webassets-cache
+# Jupyter Notebook checkpoints
+.ipynb_checkpoints/
 
-# Scrapy stuff
-.scrapy
 
-# IPython / Jupyter
-.ipynb_checkpoints/
-profile
+# ==============================
+# IDEs, Editors, and OS System Files
+# ==============================
 
 # macOS system files
-*.DS_Store
+.DS_Store
 .AppleDouble
 .LSOverride
 
-# Thumbnails and metadata
-._*
-
-# Files that might appear in root of a volume
-.DocumentRevisions-V100
-.fseventsd
-.Spotlight-V100
-.TemporaryItems
-.Trashes
-.VolumeIcon.icns
-.com.apple.timemachine.donotpresent
-
-# Directories created on remote AFP share
-.AppleDB
-.AppleDesktop
-Network Trash Folder
-Temporary Items
-.apdisk
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
+# Standard VCS/Code Editor folders
+# IntelliJ IDEA family
+.idea/
+# Generic module file
+*.iml
+# VS Code workspace settings
+.vscode/
 
-# Unit test / coverage reports
-htmlcov/
+# Python boilerplate / Framework config
+# Django specific local overrides
+local_settings.py
+
+
+# ==============================
+# Packaging, Installation & Build Systems
+# ==============================
+
+# General package distribution folders (PyInstaller/Build tools)
+# PyInstaller spec files
+*.spec
+# Setuptools directory
+.Python
+# Man pages/manifests
+MANIFEST
+
+# CMake build system files
+CMakeFiles/
+CMakeCache.txt
+cmake_install.cmake
+
+
+# ==============================
+# Documentation and Translations
+# ==============================
 
-# Sphinx documentation build
+# Sphinx documentation builds
 docs/_build/
 
-# IDEs and editors
-# IntelliJ IDEA family
-.idea/
-*.iml
-*.ipr
-*.iws
-.idea_modules/
+# Translation files (gettext)
+*.mo
+*.pot
 
-# Visual Studio Code
-.vscode/
 
-# Cookiecutter
-output/
-python_boilerplate/
-cookiecutter-pypackage-env/
+# ==============================
+# Local Runtime Data & Logs 
+# (DO NOT COMMIT THESE FILES!)
+# ==============================
+
+# Databases and local state files
+# SQLite database file
+db.sqlite3
+# Flask application instance folder
+instance/
+# General storage data folder (if applicable)
+storage/*
+
+# Logs
+# Generic log files
+*.log
+pip-log.txt
diff --git a/.pylintrc b/.pylintrc
deleted file mode 100644
index f32cab5..0000000
--- a/.pylintrc
+++ /dev/null
@@ -1,34 +0,0 @@
-# https://pylint.readthedocs.io/en/v2.12.2/user_guide/options.html
-
-[BASIC]
-module-naming-style=any
-const-naming-style=any
-class-naming-style=any
-function-naming-style=any
-method-naming-style=any
-attr-naming-style=any
-argument-naming-style=any
-variable-naming-style=any
-class-attribute-naming-style=any
-class-const-naming-style=any
-inlinevar-naming-style=any
-
-# Custom regexes to allow both snake_case and camelCase
-module-rgx=(?:(?P<snake>[a-z_][a-z0-9_]+)|(?P<camel>[a-z]+(?:[A-Z][a-z0-9]*)*))$
-const-rgx=(?:(?P<snake>[A-Z_][A-Z0-9_]*)|(?P<camel>[A-Z][a-zA-Z0-9]*))$
-class-rgx=(?:(?P<camel>[A-Z][a-zA-Z0-9]*)|(?P<snake>[a-z_][a-z0-9_]+))$
-function-rgx=(?:(?P<snake>[a-z_][a-z0-9_]*)|(?P<camel>[a-z]+(?:[A-Z][a-z0-9]*)*))$
-method-rgx=(?:(?P<snake>[a-z_][a-z0-9_]*)|(?P<camel>[a-z]+(?:[A-Z][a-z0-9]*)*))$
-attr-rgx=(?:(?P<snake>[a-z_][a-z0-9_]*)|(?P<camel>[a-z]+(?:[A-Z][a-z0-9]*)*))$
-argument-rgx=(?:(?P<snake>[a-z_][a-z0-9_]*)|(?P<camel>[a-z]+(?:[A-Z][a-z0-9]*)*))$
-variable-rgx=(?:(?P<snake>[a-z_][a-z0-9_]*)|(?P<camel>[a-z]+(?:[A-Z][a-z0-9]*)*))$
-class-attribute-rgx=(?:(?P<snake>[a-z_][a-z0-9_]*)|(?P<camel>[a-z]+(?:[A-Z][a-z0-9]*)*))$
-class-const-rgx=(?:(?P<snake>[A-Z_][A-Z0-9_]*)|(?P<camel>[A-Z][a-zA-Z0-9]*))$
-inlinevar-rgx=(?:(?P<snake>[a-z_][a-z0-9_]*)|(?P<camel>[a-z]+(?:[A-Z][a-z0-9]*)*))$
-
-[design]
-max-locals = 24
-
-[MESSAGES CONTROL]
-disable=W0621
-disable=W0102
diff --git a/.python-version b/.python-version
new file mode 100644
index 0000000..24ee5b1
--- /dev/null
+++ b/.python-version
@@ -0,0 +1 @@
+3.13
diff --git a/CODE_OF_CONDUCT.md b/CODE_OF_CONDUCT.md
index 4455894..6ff40ea 100644
--- a/CODE_OF_CONDUCT.md
+++ b/CODE_OF_CONDUCT.md
@@ -1,4 +1,3 @@
-
 # Contributor Covenant Code of Conduct
 
 ## Our Pledge
@@ -61,7 +60,7 @@ representative at an online or offline event.
 
 Instances of abusive, harassing, or otherwise unacceptable behavior may be
 reported to the community leaders responsible for enforcement at
-[INSERT CONTACT METHOD].
+nicholas.bergantz@gmail.com.
 All complaints will be reviewed and investigated promptly and fairly.
 
 All community leaders are obligated to respect the privacy and security of the
diff --git a/CONTRIBUTING.md b/CONTRIBUTING.md
index 7182138..27082ba 100644
--- a/CONTRIBUTING.md
+++ b/CONTRIBUTING.md
@@ -1,4 +1,4 @@
-# Contributing to py-mathTools
+# Contributing to py-MathTools
 
 Thank you for considering contributing to this project — every bit helps, and all contributors are appreciated!
 
@@ -10,7 +10,7 @@ You can contribute in several ways:
 
 ### Report Bugs
 
-Open an issue at [GitHub Issues](https://github.com/kopecn/pyMathTools/issues) with:
+Open an issue at [GitHub Issues](https://github.com/kopecn/py_math_tools/issues) with:
 
 - Your operating system and version
 - Any relevant local setup details
@@ -40,23 +40,23 @@ For new features, please:
 
 ## Getting Started
 
-Follow these steps to set up `pyMathTools` locally:
+Follow these steps to set up `py_math_tools` locally:
 
 1. **Fork** the repository:  
-   [https://github.com/kopecn/pyMathTools/fork](https://github.com/kopecn/pyMathTools/fork)
+   [https://github.com/kopecn/py_math_tools/fork](https://github.com/kopecn/py_math_tools/fork)
 
 2. **Clone** your fork:
 
     ```sh
-    git clone git@github.com:your_name_here/pyMathTools.git
-    cd pyMathTools
+    git clone git@github.com:your_name_here/py_math_tools.git
+    cd py_math_tools
     ```
 
-3. **Set up a virtual environment** and install the project locally:
+3. **Set up the environment** and install the project with dev dependencies:
 
     ```sh
-    mkvirtualenv pyMathTools
-    python setup.py develop
+    make dev          # uv: create .venv + install -e ".[dev]" from pyproject
+    # (or `make installDev` for the pip fallback)
     ```
 
 4. **Create a new branch**:
@@ -65,11 +65,11 @@ Follow these steps to set up `pyMathTools` locally:
     git checkout -b your-feature-branch
     ```
 
-5. **Run linters and tests**:
+5. **Run linters, type checks, and tests**:
 
     ```sh
-    make lint
-    make test-all
+    make uv-fullCheck     # ruff + mypy + pytest
+    # or individually: make uv-lint · make uv-typecheck · make uv-test
     ```
 
 6. **Commit and push your changes**:
@@ -84,13 +84,30 @@ Follow these steps to set up `pyMathTools` locally:
 
 ---
 
+## Co-developing with sibling repositories
+
+When you need to develop this project against a **local, unreleased** checkout of a sibling
+library (e.g. it lives at `../my-sibling-lib`), use a **`requirements-local.txt`** overlay. Local
+and git/path resolution never goes in `pyproject.toml` — the manifest stays dependency **names
+only** (putting path/git pointers there is a module-deployment hazard).
+
+```sh
+echo "-e ../my-sibling-lib" >> requirements-local.txt
+make uv-sync-local     # creates the venv, installs -r requirements-local.txt, then -e ".[dev]"
+```
+
+`requirements-local.txt` is **gitignored** and never read by CI/release, so a solo checkout is
+unaffected (just don't create the file).
+
+---
+
 ## PR Guidelines
 
 Before submitting a pull request, make sure:
 
 - [ ] Tests are included for new logic
 - [ ] Documentation is updated if needed
-- [ ] The project supports Python 3.12 and 3.13
+- [ ] The project supports Python 3.10 through 3.13
 - [ ] All tests pass (CI checks will run on PRs)
 
 ---
@@ -100,29 +117,45 @@ Before submitting a pull request, make sure:
 To run a targeted test suite:
 
 ```sh
-pytest tests/test_pyMathTools.py
+pytest tests/test_py_math_tools.py
 ```
 
 
+## Changelog (`HISTORY.md`)
+
+This project keeps a human-readable changelog in `HISTORY.md`, following
+[Keep a Changelog](https://keepachangelog.com/en/1.1.0/) and
+[Semantic Versioning](https://semver.org/spec/v2.0.0.html). The best-known method:
+
+1. **Every PR that changes behavior** adds a bullet under the `## [Unreleased]`
+   section, in the appropriate group: `Added`, `Changed`, `Deprecated`, `Removed`,
+   `Fixed`, or `Security`. No "internal-only" changes (refactors, CI) need an entry
+   unless they affect users.
+2. **At release time** (maintainers), rename `## [Unreleased]` to the new version and
+   date, e.g. `## [1.2.0] - 2025-08-16`, then add a fresh empty `## [Unreleased]`
+   block above it and update the comparison links at the bottom.
+3. Keep entries imperative and user-facing ("Add X", "Fix Y"), not commit-message dumps.
+
 ## Deploying (Maintainers Only)
 
-1. Confirm all changes are committed (including `HISTORY.md`)
-2. Bump the version:
+1. Update `HISTORY.md`: roll `[Unreleased]` into the new version + date (see above).
+2. Confirm all changes are committed (including `HISTORY.md`).
+3. Bump the version:
 
 ```sh
 bump2version patch  # Use major/minor/patch as needed
 ```
 
-3. Push changes and tags:
+4. Push changes and tags:
 
 ```sh
 git push
 git push --tags
 ```
 
-4. (Optional) Use [GitHub Actions](https://docs.github.com/en/actions/use-cases-and-examples/building-and-testing/building-and-testing-python#publishing-to-pypi) to auto-deploy to PyPI.
+5. (Optional) Use [GitHub Actions](https://docs.github.com/en/actions/use-cases-and-examples/building-and-testing/building-and-testing-python#publishing-to-pypi) to auto-deploy to PyPI.
 
 ## Code of Conduct
 This project follows a [Contributor Code of Conduct](https://chatgpt.com/#:~:text=follows%20a%20Contributor-,Code,-of%20Conduct.%20By). By participating, you agree to uphold these standards.
 
-Feel free to reach out or [open an issue](https://github.com/kopecn/pyMathTools/issues) with any questions.
+Feel free to reach out or [open an issue](https://github.com/kopecn/py_math_tools/issues) with any questions.
diff --git a/HISTORY.md b/HISTORY.md
index fd26aed..5b98e61 100644
--- a/HISTORY.md
+++ b/HISTORY.md
@@ -1,5 +1,80 @@
 # History
 
-## 0.0.1 (2025-12-01)
+All notable changes to this project are documented here.
 
-* First release on PyPI.
+The format is based on [Keep a Changelog](https://keepachangelog.com/en/1.1.0/),
+and this project adheres to [Semantic Versioning](https://semver.org/spec/v2.0.0.html).
+
+## [Unreleased]
+
+### Added
+-
+
+## [0.0.2] - 2026-08-26
+
+Tier-3 math implementation layer built out on top of `pyFoundationTools`, plus a
+full migration onto the project template. This release renames both packages;
+see Changed for the import migration.
+
+### Added
+- `math_tools.precision_time`: `PrecisionTimeInterval` and `PrecisionTimestamp`
+  — integer-backed nanosecond time arithmetic, comparison, and conversion.
+- `math_tools.spatial`: `Position` and `SpatialPose` alongside the existing
+  `Quaternion`, with tolerance-aware comparison and timestamp accessors.
+- `math_tools.functional`: `UnivariatePolynomial` plus analytic root solvers
+  (`solve_cubic`, `solve_quartic_monic`, `solve_resolvent`), derivative and
+  evaluation kernels, and shared polynomial tolerances.
+- `math_tools.waveforms`: `Waveform1D` core, operators, and generators, plus the
+  aggregate containers `WaveformPosition`, `WaveformQuaternion`, and
+  `WaveformSpatialPose` (and their component-waveform views).
+- `math_tools.waveforms.dsp`: twelve scipy-backed DSP mixins composed onto
+  `Waveform1D` — calc, correlation, envelope, filtering, peaks, phase,
+  resampling, spectral, time alignment, triggers, windowing, and zero crossings
+  — with a `WaveformProtocol` typing contract and a support-type surface
+  (spectra, spectrograms, filter coefficients, triggers, peaks, enums).
+- `math_tools.otg`: online trajectory generation ported from Ruckig — `Otg`
+  driver, `InputParameter`, `OutputParameter`, `Trajectory`, `Profile`, block
+  and brake computation, and first/second/third-order position and velocity
+  step solvers, with `Result`, `Synchronization`, `ControlInterface`, and
+  `DurationDiscretization` enums.
+- Error hierarchy rooted at `MathToolsError`: `WaveformCompatibilityError`,
+  `TimestampComparisonError`, `PolynomialSolveError`, and `OtgError`.
+- Curated root re-export surface on `math_tools`, and `py.typed` markers on
+  every distributed package.
+- Test suite mirroring the package layout under `tests/`, including OTG oracle
+  corpora (`tests/otg/data/`) validated against reference trajectories, plus
+  governance, public-surface, and package-layering guard tests.
+- `.claude/specs/` architecture and per-module contracts, and `.claude/CLAUDE.md`
+  repo guidance.
+- Template infrastructure: `.github/workflows/ci-cd.yml`, `.github/CODEOWNERS`,
+  `.editorconfig`, `.python-version` (3.13), `.bumpversion.cfg`, and a
+  hand-authored `requirements.txt`.
+
+### Changed
+- **Breaking:** `pyMathTools` renamed to `math_tools` and
+  `pyMathToolsPlotHelpers` renamed to `math_plot_helpers`; modules and public
+  functions moved to snake_case (e.g. `spherical.sphericalTransforms` →
+  `spherical.spherical_transforms`, `plotUnitSpherical` helpers →
+  `plot_unit_spherical_*`). Update imports accordingly.
+- Layering is now one-way and enforced by test: `math_plot_helpers` →
+  `math_tools` → `pyFoundationTools`; `math_tools` never imports matplotlib.
+- Makefile reworked as the source of truth for tooling, with `uv-` targets and
+  the `uv-fullCheck` CI gate (ruff + strict mypy + pytest).
+- Linting and formatting moved to ruff; type checking is strict `mypy` over
+  `src/` and `tests/`.
+- Runtime dependencies in `pyproject.toml` are names-only; pins live in
+  `requirements.txt`.
+- Governance docs refreshed: `README.md`, `CONTRIBUTING.md`,
+  `CODE_OF_CONDUCT.md`, `LICENSE`.
+
+### Removed
+- `.pylintrc` (superseded by ruff).
+
+## [0.0.1] - 2026-06-29
+
+### Added
+- First release on PyPI.
+
+[Unreleased]: https://github.com/kopecn/py_math_tools/compare/v0.0.2...HEAD
+[0.0.2]: https://github.com/kopecn/py_math_tools/compare/v0.0.1...v0.0.2
+[0.0.1]: https://github.com/kopecn/py_math_tools/releases/tag/v0.0.1
diff --git a/LICENSE b/LICENSE
index 6484eac..3d596aa 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,6 +1,6 @@
 MIT License
 
-Copyright (c) 2025, Nicholas Bergantz
+Copyright (c) 2026, Nicholas Bergantz
 
 Permission is hereby granted, free of charge, to any person obtaining a copy
 of this software and associated documentation files (the "Software"), to deal
diff --git a/Makefile b/Makefile
index 0bc1850..16cc5f0 100644
--- a/Makefile
+++ b/Makefile
@@ -1,123 +1,485 @@
-.PHONY: clean cleanTest cleanArtifacts cleanBuild docs help test testInEnv \
-	testInEnvInstallFromSetup testInEnvRunPytest testInEnvCleanup \
-	dist release install devInstall flushPip build version tag
+# ============================================================================
+# CONFIG
+# ============================================================================
+.PHONY: help version checkCleanGit open-github \
+	clean clean-build clean-artifacts clean-test \
+	bump-patch bump-minor bump-major \
+	check-uv install-uv list-uv \
+	uv-bootstrap-pythons uv-bootstrap uv-sync uv-sync-headless uv-sync-dev uv-sync-release uv-sync-local uv-editable uv-refresh \
+	uv-lint uv-format uv-typecheck uv-fullCheck \
+	uv-test uv-test-all uv-test-matrix \
+	uv-flush-cache uv-flush-envs uv-flush-pythons uv-flush-everything uv-nuke \
+	uv-lifecycle-test \
+	dev setup \
+	installDev e refresh \
+	test cleanRoomCleanup cleanRoomBootstrap cleanRoomPytest testInEnv \
+	build validateBuild release-test release \
+	nuke list
 
 .DEFAULT_GOAL := help
 
-# Load anything from the .env file if it exists
+# Load .env file if it exists
 ifneq (,$(wildcard .env))
-	include .env
-	export
+    include .env
+    export
 endif
 
-VERSION=v$(shell grep -m 1 version pyproject.toml | tr -s ' ' | tr -d '"' | tr -d "'" | cut -d' ' -f3)
+# Defaults (overridable via .env — the user-editable surface). Keep in sync with .env.
+PYTHONS ?= 3.10 3.11 3.12 3.13
+DEFAULT_PYTHON ?= 3.13
+PYTHON ?= python3
+VENV ?= .cleanroom-venv
+
+# Quality-target paths. ROOT half has NO src/ — its Python lives in hooks/ + tests/
+# (see GAPS.md §6). The template half overrides these to src/. Overridable via .env.
+PY_SRC ?= hooks
+PY_TESTS ?= tests
+PY_EXAMPLES ?= examples
+PY_ALL ?= $(PY_SRC) $(PY_TESTS) $(PY_EXAMPLES)
+
+
+# Derived
+# Tool runner for uv- quality/test recipes. `--extra dev` ensures ruff/mypy/pytest are
+# resolved (and installed if missing) from the "[dev]" extra even on a FRESH checkout —
+# no reliance on a pre-existing .venv, rather than the ambient PATH.
+UV := uv run --no-project
 PIP := $(PYTHON) -m pip
+BUMPVERSION := bumpversion --allow-dirty
+REPO := $(notdir $(CURDIR))
+UNAME_S := $(shell uname -s)
+HR := ========================================
+
+# Guard: DEFAULT_PYTHON must be one of the versions we test against.
+ifeq ($(filter $(DEFAULT_PYTHON),$(PYTHONS)),)
+    $(error DEFAULT_PYTHON ($(DEFAULT_PYTHON)) is not in PYTHONS ($(PYTHONS)) — fix .env)
+endif
 
-help:  ## Show available make commands with descriptions
-	@echo "Makefile for pyMathTools"
-	@awk 'BEGIN {FS = ":.*?## "}; /^[a-zA-Z0-9_-]+:.*?## / {printf "%-30s -> %s\n", $$1, $$2}' $(MAKEFILE_LIST)
-
-bumpPatch:
-	bump2version patch
-
-bumpMinor:
-	bump2version minor
-
-bumpMajor:
-	bump2version major
-
-clean: cleanBuild cleanArtifacts cleanTest  ## Remove all build, Python, and test-related artifacts
-
-cleanBuild:  ## Delete build-related directories and files
+# ============================================================================
+# MARK: - Helpers · 
+# ============================================================================
+
+define uninstall_package_list
+	@$(1) | while read pkg; do \
+		[ -n "$$pkg" ] || continue; \
+		$(PIP) uninstall -y "$$pkg" 2>&1 \
+			|| echo "SKIPPED (system-managed): $$pkg"; \
+	done
+endef
+
+define print_packages
+	@echo "========================================"
+	@echo "$(1)"
+	@echo "========================================"
+	@$(2) list 2>/dev/null || echo "No packages or pip not available"
+	@echo
+endef
+
+# Roll HISTORY.md on a version bump: open a fresh dated section under
+# [Unreleased] (folding the accumulated notes into the just-bumped version) and
+# amend it into bump2version's commit so version + changelog move together.
+# Keep-a-Changelog convention: the `## [Unreleased]` header is the anchor.
+define roll_changelog
+	@ver=$$($(MAKE) -s version); day=$$(date +%F); \
+	awk -v v="$$ver" -v d="$$day" '\
+		{ print } \
+		/^## \[Unreleased\]/ && !seen { print ""; print "## [" v "] - " d; seen=1 }' \
+		HISTORY.md > HISTORY.md.tmp && mv HISTORY.md.tmp HISTORY.md; \
+	git add HISTORY.md; \
+	case "$$(git log -1 --pretty=%s)" in \
+		"Bump version:"*) git commit --amend --no-edit ;; \
+		*) git commit -m "Roll HISTORY.md for v$$ver" ;; \
+	esac
+endef
+
+# ============================================================================
+# MARK: - HELP
+# ============================================================================
+help:  ## Show this help
+	@echo "$(REPO) — make targets   (bare = pip · uv-… = uv path)"
+	@echo "config: DEFAULT_PYTHON=$(DEFAULT_PYTHON)  PYTHONS=$(PYTHONS)"
+	@echo ""
+	@awk 'BEGIN {FS = ":.*?## "} \
+		/^##@ / {printf "\n\033[1m%s\033[0m\n", substr($$0, 5); next} \
+		/^[a-zA-Z0-9_%-]+:.*?## / {printf "  \033[36m%-26s\033[0m %s\n", $$1, $$2}' \
+		$(MAKEFILE_LIST)
+
+
+# ============================================================================
+# MARK: - COMMON · VERSION & GIT
+# ============================================================================
+##@ Common · Version & Git
+version:  ## Display the current project version
+	@$(PYTHON) -c "import tomllib; print(tomllib.load(open('pyproject.toml','rb'))['project']['version'])" 2>/dev/null \
+		|| grep -m1 '^version' pyproject.toml | cut -d'"' -f2
+
+checkCleanGit:  ## Guard: fail if the git working tree is dirty
+	@[ -z "$$(git status --porcelain)" ] || \
+		(echo "Working tree is dirty. Commit or stash changes first."; exit 1)
+
+# Static pattern rule: all three documented parts share one recipe (`$*` = the
+# part). Bump the version, then roll the changelog into the same commit.
+bump-patch bump-minor bump-major: bump-%:  ## Bump version (patch|minor|major) + roll HISTORY.md
+	$(BUMPVERSION) $*
+	$(call roll_changelog)
+
+open-github:  ## Open the GitHub repository in the default browser (macOS/Linux)
+	@remote=$$(git remote | head -1); \
+	[ -n "$$remote" ] || { echo "No git remote configured."; exit 1; }; \
+	url=$$(git remote get-url "$$remote" | sed -e 's|git@github.com:|https://github.com/|' -e 's|\.git$$||'); \
+	echo "Opening $$url"; \
+	if [ "$(UNAME_S)" = "Darwin" ]; then open "$$url"; \
+	elif command -v xdg-open >/dev/null 2>&1; then xdg-open "$$url"; \
+	else echo "No browser opener found; visit: $$url"; fi
+
+# ============================================================================
+# MARK: - COMMON · CLEAN
+# Base cleanup targets used by install, test, and CI workflows.
+# ============================================================================
+##@ Common · Clean
+
+clean: clean-build clean-artifacts clean-test ## Remove all build, cache, and test artifacts
+
+clean-build: ## Remove packaging and distribution artifacts
 	rm -rf build/ dist/ .eggs/
-	find . -name '*.egg-info' -exec rm -rf {} +
-	find . -name '*.egg' -exec rm -rf {} +
-
-cleanArtifacts:  ## Remove Python bytecode and cache files
-	find . \( -name '*.pyc' -o -name '*.pyo' -o -name '*~' \) -exec rm -f {} +
-	find . -name '__pycache__' -exec rm -rf {} +
-
-cleanTest:  ## Remove test outputs and coverage data
+	find . \( -name '*.egg-info' -o -name '*.egg' \) -exec rm -rf {} +
+	rm -f uv.lock
+
+clean-artifacts: ## Remove Python bytecode and cache files
+	find . \( \
+		-name '*.pyc' -o \
+		-name '*.pyo' -o \
+		-name '*~' -o \
+		-name '__pycache__' \
+	\) -exec rm -rf {} +
+
+clean-test: ## Remove test, coverage, and lint caches
 	rm -f .coverage
-	rm -rf htmlcov/ .pytest_cache
-
-lint:  ## Run linters like pylint or ruff
-	pylint src/
-
-format:  ## Format code with black
-	black src/
-
-typecheck:  ## Type check with mypy
-	mypy src/
+	rm -rf \
+		htmlcov/ \
+		.pytest_cache/ \
+		.mypy_cache/ \
+		.ruff_cache/ \
+		.tox/ \
+		.nox/
+
+# ============================================================================
+# MARK: - UV · TOOLING
+# ============================================================================
+##@ UV · Tooling
+check-uv:  ## Check if uv is installed (guard for all uv- targets)
+	@command -v uv >/dev/null 2>&1 || { \
+	  echo "ERROR: uv not found."; \
+	  echo "  Install it with: make install-uv"; \
+	  echo "  Or see: https://docs.astral.sh/uv/getting-started/installation/"; \
+	  exit 1; }
+
+install-uv:  ## Install uv (brew on macOS, installer script on Linux)
+ifeq ($(UNAME_S),Darwin)
+	@echo "Detected macOS - installing via Homebrew..."
+	@command -v brew >/dev/null 2>&1 || { echo "ERROR: Homebrew not found. Install from https://brew.sh"; exit 1; }
+	brew install uv
+else ifeq ($(UNAME_S),Linux)
+	@echo "Detected Linux - installing via official installer..."
+	curl -LsSf https://astral.sh/uv/install.sh | sh
+	@echo ""
+	@echo "NOTE: You may need to add ~/.local/bin to your PATH:"
+	@echo '  export PATH="$$HOME/.local/bin:$$PATH"'
+else
+	@echo "Unsupported OS: $(UNAME_S)"
+	@echo "Install manually: https://docs.astral.sh/uv/getting-started/installation/"
+	@exit 1
+endif
+	@echo ""
+	@echo "uv installed successfully:"
+	@uv --version
+
+list-uv: check-uv  ## List uv envs, installed Pythons, packages, and cache info
+	@echo "$(HR)"; echo "UV VERSION"; echo "$(HR)"
+	@uv --version
+	@echo ""; echo "$(HR)"; echo "INSTALLED PYTHON VERSIONS"; echo "$(HR)"
+	@uv python list --only-installed
+	@echo ""; echo "$(HR)"; echo "PROJECT VIRTUAL ENVIRONMENTS"; echo "$(HR)"
+	@ls -d .venv 2>/dev/null || echo "No .venv found"
+	@ls -d .venvs/*/ 2>/dev/null || echo "No .venvs/ matrix environments found"
+	@echo ""; echo "$(HR)"; echo "INSTALLED PACKAGES (.venv)"; echo "$(HR)"
+	@uv pip list 2>/dev/null || echo "No packages or .venv not found"
+	@echo ""; echo "$(HR)"; echo "UV CACHE INFO"; echo "$(HR)"
+	@uv cache dir
+	@du -sh $$(uv cache dir) 2>/dev/null || echo "Cache empty or not accessible"
+
+# ============================================================================
+# MARK: - UV · BOOTSTRAP & SYNC
+# ============================================================================
+##@ UV · Bootstrap & Sync
+uv-bootstrap-pythons: check-uv  ## Install all configured Python versions via uv
+	uv python install $(PYTHONS)
+
+# Dependency model (BKM; see GAPS §5 / spec §6): pyproject.toml declares dependency
+# NAMES ONLY — never version-pinned (only the application layer pins; module-level pins
+# cause conflicts). The requirements*.txt files carry pins and git-based pointers, and
+# every install path — pip AND uv — leans on them: `-r requirements.txt` then the
+# editable self-install. No `uv.lock`, no `lock`/compile target.
+
+uv-bootstrap: check-uv uv-bootstrap-pythons  ## Full bootstrap: pythons + venv + deps
+	uv venv --python $(DEFAULT_PYTHON)
+	uv pip install -r requirements.txt
+	uv pip install -e ".[dev]"
+	@echo ""
+	@echo "Bootstrap complete. Run 'make uv-test-all' to validate."
+
+uv-sync: check-uv  ## Sync all dependencies including dev (default dev workflow)
+	@[ -d ".venv" ] || uv venv --python $(DEFAULT_PYTHON)
+	uv pip install -r requirements.txt
+	uv pip install -e ".[dev]"
+
+uv-sync-headless: check-uv  ## Sync dependencies without dev/UI extras (headless deploy)
+	@[ -d ".venv" ] || uv venv --python $(DEFAULT_PYTHON)
+	uv pip install -r requirements.txt
+	uv pip install -e "."
+
+uv-sync-dev: check-uv  ## Sync dependencies with dev extras
+	@[ -d ".venv" ] || uv venv --python $(DEFAULT_PYTHON)
+	uv pip install -r requirements.txt
+	uv pip install -e ".[dev]"
+
+uv-sync-release: check-uv  ## Sync using tag-pinned release requirements (requirements-release.txt)
+	@[ -d ".venv" ] || uv venv --python $(DEFAULT_PYTHON)
+	uv pip install -r requirements-release.txt
+	uv pip install -e "."
+
+uv-sync-local: check-uv  ## Sync using local editable path overrides (requirements-local.txt)
+	@[ -d ".venv" ] || uv venv --python $(DEFAULT_PYTHON)
+	uv pip install -r requirements-local.txt
+	uv pip install -e ".[dev]"
+
+dev: uv-sync  ## One-command dev setup entrypoint (alias → uv-sync)
+setup: dev  ## One-command dev setup entrypoint (alias → uv-sync)
+
+uv-editable: check-uv  ## Install this package editable via uv (uv pip install -e .)
+	uv pip install -e .
+
+uv-refresh: check-uv  ## Clean cache + reinstall from requirements + upgrade editable dev
+	uv cache clean
+	uv pip install -r requirements.txt
+	uv pip install --upgrade -e ".[dev]"
+
+# ============================================================================
+# MARK: - UV · QUALITY
+# ============================================================================
+##@ UV · Quality
+uv-lint: check-uv  ## Run ruff linter (read-only; non-zero exit for CI)
+	$(UV) ruff check $(PY_ALL)
+
+uv-format: check-uv  ## Format code with ruff
+	$(UV) ruff format $(PY_ALL)
+# KEEP --unsafe-fixes: intentional, added after findings on 2026-06-25.
+# Do NOT strip in cleanup/refactor passes — the unsafe autofixes here are relied
+# upon deliberately. Removing it has regressed this target before.
+	$(UV) ruff check --fix --unsafe-fixes $(PY_ALL)
+
+uv-typecheck: check-uv  ## Strict type check with mypy
+	$(UV) mypy $(PY_SRC) $(PY_TESTS) $(PY_EXAMPLES)
+
+# ty (Astral's preview type-checker) is intentionally OUT for now (decision D1):
+# it's pre-release and not wired into uv-fullCheck. Revisit when it stabilizes.
+uv-fullCheck: check-uv uv-lint uv-typecheck uv-test  ## lint + typecheck + tests
+
+# ============================================================================
+# MARK: - UV · TEST
+# ============================================================================
+##@ UV · Test
+# Depends on uv-sync so a fresh checkout never tests an empty/stale .venv (no
+# false-green no-op): the [dev] extra is installed from pyproject before pytest runs.
+uv-test: check-uv uv-sync  ## Run tests on DEFAULT_PYTHON (ensures a synced env first)
+	$(UV) pytest
+
+uv-test-all: check-uv  ## Run tests across all configured Python versions (.venvs/<ver>)
+	@failed=""; \
+	for py in $(PYTHONS); do \
+		echo ""; \
+		echo "========================================"; \
+		echo "Testing Python $$py"; \
+		echo "========================================"; \
+		venv=".venvs/$$py"; \
+		[ -d "$$venv" ] || uv venv --python $$py "$$venv"; \
+		if ( . "$$venv/bin/activate" && \
+		     uv pip install -q -e ".[dev]" && \
+		     python -m pytest ); then \
+			echo "PASS: Python $$py"; \
+		else \
+			echo "FAIL: Python $$py"; \
+			failed="$$failed $$py"; \
+		fi; \
+	done; \
+	echo ""; \
+	echo "========================================"; \
+	if [ -n "$$failed" ]; then \
+		echo "FAILED VERSIONS:$$failed"; \
+		echo "========================================"; \
+		exit 1; \
+	else \
+		echo "ALL PYTHON VERSIONS PASSED"; \
+		echo "========================================"; \
+	fi
+
+uv-test-matrix: uv-bootstrap-pythons uv-test-all  ## Ensure Pythons installed, then run all tests
+
+# ============================================================================
+# MARK: - UV · FLUSH / NUKE
+# ============================================================================
+##@ UV · Flush / Nuke
+
+uv-flush-envs:  ## Remove all virtual environments (.venv + .venvs/<ver>)
+	@echo ">> Removing virtual environments..."
+	rm -rf .venv
+	rm -rf .venvs
+	rm -rf .venv-py*
+	@echo "Virtual environments removed."
+
+uv-flush-cache: check-uv  ## Clean uv cache
+	@echo ">> Cleaning uv cache..."
+	uv cache clean
+	@echo "uv cache cleaned."
+
+uv-flush-pythons:  ## Remove uv-managed Python installs (NUCLEAR)
+	@echo "WARNING: This removes ALL uv-managed Python installations!"
+	@echo "Location: ~/.local/share/uv/python"
+	rm -rf ~/.local/share/uv/python
+	@echo "uv-managed Pythons removed."
+
+uv-flush-everything: clean uv-flush-envs uv-flush-cache  ## Full cleanup (keeps pythons)
+	@echo "Environment flushed. Run 'make uv-flush-pythons' separately for global Pythons."
+
+uv-nuke: uv-flush-everything  ## NUCLEAR: everything then prompt for Python removal
+	@echo ""
+	@echo ">> Running uv-nuke..."
+	@$(MAKE) uv-flush-pythons
+	@echo ""
+	@echo "Environment nuked. Run 'make uv-bootstrap' to rebuild from scratch."
+
+uv-lifecycle-test: uv-flush-everything uv-bootstrap uv-test-all  ## flush -> bootstrap -> test-all
+	@echo ">> Lifecycle test complete"
+
+# ============================================================================
+# MARK: - PIP · INSTALL
+# ============================================================================
+##@ PIP · Install
+# Ambient-pip fallback (prefer the uv- path). Both pip and uv lean on the requirements
+# file (BKM rule 4): install -r requirements.txt, then self-install the editable
+# package. No --break-system-packages / --force-reinstall: use a venv (make uv-sync)
+# rather than fighting an externally-managed interpreter.
+installDev: clean  ## Install dev dependencies with pip (-r requirements.txt + editable [dev])
+	$(PIP) install -r requirements.txt
+	$(PIP) install -e ".[dev]"
+
+e:  ## Install this package in editable mode (pip install -e .)
+	$(PIP) install -e .
 
-fullCheck: lint typecheck test  ## Run full quality and test checks
+refresh:  ## Refresh pip packages: reinstall from requirements + upgrade editable dev
+	$(PIP) install -r requirements.txt
+	$(PIP) install --upgrade -e ".[dev]"
 
-validateTomlSetup:  ## Check if pyproject.toml and setup are valid
-	$(PYTHON) -m build --sdist --wheel --outdir /tmp/test_build
+# ============================================================================
+# MARK: - PIP · TEST
+# ============================================================================
+##@ PIP · Test
 
 test:  ## Run tests using the current Python environment
 	pytest
 
-testInEnv: clean testInEnvInstallFromSetup testInEnvRunPytest testInEnvCleanup  ## Run tests in a temporary virtual environment
+cleanRoomCleanup:  ## Delete the clean-room venv ($(VENV))
+	rm -rf $(VENV) || true
 
-testInEnvInstallFromSetup: testInEnvCleanup  ## Set up temporary venv and install dev dependencies
-	$(PYTHON) -m venv $(VENV) && \
+# The clean room is an install path, so it obeys the same BKM rule as every other
+# one (see the dependency-model comment above ##@ UV · Bootstrap): pyproject.toml
+# declares dependency NAMES ONLY, and requirements.txt carries the pins and the
+# git/path pointers. Installing ".[dev]" alone makes pip resolve those bare names
+# against PyPI, which fails outright for any unpublished sibling dependency
+# (`No matching distribution found`). Install the requirements file FIRST, then the
+# package. Keep ".[dev]" NON-editable here — validating the real packaging path is
+# this target's entire purpose.
+cleanRoomBootstrap: cleanRoomCleanup  ## Bootstrap the clean-room venv + deps (runs NO tests)
+	$(PYTHON) -m venv $(VENV)
 	. $(VENV)/bin/activate && \
 	which python3 && \
-	$(PYTHON) -m pip install ".[personal_repos,develop]"
+	$(VENV)/bin/pip install -r requirements.txt && \
+	$(VENV)/bin/pip install ".[dev]"
 	@echo "Virtual env can be activated with 'source $(VENV)/bin/activate'"
 
-testInEnvRunPytest:  ## Run tests inside the temporary virtual environment
+cleanRoomPytest:  ## Run pytest inside the clean-room venv
 	. $(VENV)/bin/activate && \
 	which $(PYTHON) && \
 	$(PYTHON) -m pytest
 
-testInEnvCleanup:  ## Delete the temporary virtual environment
-	rm -rf $(VENV) || true
-
-checkVenv:
-	@test "$$VIRTUAL_ENV" != "" || (echo "Not in a virtualenv!"; exit 1)
-
-dist: clean  ## Create source and wheel distributions
-	$(PYTHON) -m build
-	ls -l dist
+testInEnv: clean cleanRoomBootstrap cleanRoomPytest cleanRoomCleanup  ## Full clean-room test
+	@echo ">> testInEnv completed"
 
-build:  ## Build project to check packaging without uploading
-	rm -rf build dist
+# ============================================================================
+# MARK: - PIP · BUILD & RELEASE
+# ============================================================================
+##@ PIP · Build & Release
+build: clean-build  ## Build sdist + wheel ($(PYTHON) -m build)
+	@echo "Building package..."
 	$(PYTHON) -m build
 
-version:  ## Display the current project version
-	@echo "Current version is $(VERSION)"
-
-tag: checkCleanGit version  ## Create and push a git tag
-	@echo "Tagging version $(VERSION)"
-	git tag -a $(VERSION) -m "Creating version $(VERSION)"
-	git push origin $(VERSION)
-
-checkCleanGit:
-	@git diff-index --quiet HEAD -- || (echo "Git working directory not clean" && exit 1)
-
-releaseTest: dist  ## Upload to TestPyPI
-	twine upload --repository-url https://test.pypi.org/legacy/ dist/*
-
-release: dist  ## Upload the distribution package to PyPI
-	set -euo pipefail && twine upload dist/*
-
-install: clean  ## Install the package in editable mode (local dev install)
-	$(PIP) install -e .
-
-devInstall: clean  ## Install development dependencies
-	$(PIP) install -e .[develop]
-	$(PIP) install pytest pylint black mypy bump2version build twine
-
-docs:  ## Build HTML documentation using Sphinx
-	sphinx-build -b html docs/ docs/_build/html
-	@echo "Documentation built in docs/_build/html"
-
-flushpip: SHELL := /bin/bash
-flushpip:  ## Uninstall all packages from the current environment
-	$(PIP) uninstall -y -r <($(PIP) freeze)
-
-e: ## install this package into environment for development 
-	$(PIP) install -e .
-
+validateBuild: build  ## Validate build artifacts with twine
+	@echo "Validating dist/ with twine..."
+	$(PYTHON) -m twine check dist/*
+
+release-test: checkCleanGit validateBuild  ## Dry-run publish to TestPyPI (clean tree only)
+	@echo "Uploading $(REPO) v$$($(MAKE) -s version) to TestPyPI..."
+	@$(PYTHON) -m twine upload --repository testpypi dist/*
+
+# No CI-driven publish path exists: `.github/workflows/ci-cd.yml` runs quality
+# checks and the Python compatibility matrix on PRs to dev/prod only — it does not
+# tag or upload anything. Release is therefore a manual, human-run procedure;
+# `make release` refuses to upload from an unreviewed working tree and prints that
+# procedure instead of performing it.
+release: validateBuild  ## Refuse local upload; print the manual release procedure
+	@echo "No CI-driven publish path exists — release is a manual procedure."
+	@echo ""
+	@echo "To release $(REPO) v$$($(MAKE) -s version):"
+	@echo "  1. Bump the version (make bump-patch|bump-minor|bump-major) and merge to prod."
+	@echo "  2. Build + validate: make validateBuild."
+	@echo "  3. Upload by hand: python3 -m twine upload dist/*"
+	@echo ""
+	@echo "For a local pre-flight, use: make release-test (TestPyPI)."
+	@exit 1
+
+# ============================================================================
+# MARK: - PIP · FLUSH / LIST
+# ============================================================================
+##@ PIP · Flush / List
+# `nuke` is the INFERIOR pip fallback (Lesson 2): it per-package-uninstalls from
+# the AMBIENT interpreter ($(PIP)). Prefer `make uv-flush-envs` — deleting the
+# venv dir is the reliable flush primitive. Use this only when you're stuck in a
+# non-deletable (e.g. system) env. Non-editable URL/VCS installs are skipped.
+nuke: ## Per-package uninstall from ambient env (inferior — prefer uv-flush-envs)
+	@echo "Uninstalling regular packages (skipping system-managed)..."
+	$(call uninstall_package_list,$(PIP) freeze --exclude-editable | grep -v ' @ ')
+
+	@echo "Uninstalling editable packages by name..."
+	$(call uninstall_package_list,$(PIP) list --editable --format=freeze | cut -d= -f1)
+
+	@echo "pip-nuke complete."
+
+list: ## List pip packages in available environments
+	$(call print_packages,SYSTEM PYTHON PACKAGES,$(PIP))
+
+	@if [ -d ".venv" ]; then \
+		echo "$(HR)"; \
+		echo "VENV PACKAGES (.venv)"; \
+		echo "$(HR)"; \
+		.venv/bin/pip list 2>/dev/null || echo "No packages or pip not available"; \
+		echo; \
+	fi
+
+	@for venv in .venvs/*; do \
+		[ -d "$$venv" ] || continue; \
+		echo "$(HR)"; \
+		echo "VENV PACKAGES ($$venv)"; \
+		echo "$(HR)"; \
+		$$venv/bin/pip list 2>/dev/null || echo "No packages or pip not available"; \
+		echo; \
+	done
+	
\ No newline at end of file
diff --git a/README.md b/README.md
index a3ed155..fe8c6e6 100644
--- a/README.md
+++ b/README.md
@@ -1,7 +1,104 @@
-# py-mathTools
+# py-MathTools
 
-Python Boilerplate contains all the boilerplate you need to create a Python package.
+The Tier 3 math implementation layer for `pyFoundationTools`: numpy-backed
+math classes (quaternions today, spatial poses / waveforms / polynomials /
+trajectory generation as the port lands) that subclass the Tier-2
+`foundation_abc.math.*` ABCs and interoperate with the Tier-1
+`foundationTypes.mathTypes` data carriers, plus a separate `matplotlib`
+plotting helper package.
 
 ## Features
 
-* TODO
+- **`math_tools.spatial.quaternion.Quaternion`** — fully-typed OOP wrapper
+  around the `numpy-quaternion` library: arithmetic (`+ - * /`, scalar and
+  quaternion operands), `conjugate`/`inverse`/`normalized`/`norm`,
+  rotation-matrix and axis/angle conversions, and conversion to/from the
+  spherical small-circle representation.
+- **`math_tools.spherical`** — spherical-arc and small-circle utilities
+  (great-circle construction between two points, endpoint computation,
+  Plate Carrée / Cartesian coordinate transforms) built on the ISO physics
+  spherical convention, using the Tier-1 `UnitSphericalArcType` /
+  `UnitSphericalSmallCircleType` carriers.
+- **`math_tools.errors`** — the `MathToolsError` domain exception hierarchy
+  (`WaveformCompatibilityError`, `TimestampComparisonError`,
+  `PolynomialSolveError`); programmer errors still raise stdlib
+  `TypeError`/`ValueError`.
+- **`math_plot_helpers.plot_unit_spherical`** — matplotlib visualizations
+  (Plate Carrée, polar, and 3D multiplot views) for spherical arcs, small
+  circles, and quaternions. This is the only package in the repo permitted
+  to import `matplotlib` (`tests/test_package_layering.py` enforces the
+  one-way `math_plot_helpers → math_tools` dependency).
+
+See [`.claude/specs/mathToolsArchitecture.md`](.claude/specs/mathToolsArchitecture.md)
+for the full architecture and the module map for capability still being
+ported (spatial pose, waveforms/DSP, polynomials, OTG trajectory
+generation).
+
+## Installation
+
+The package is not published (`pyproject.toml`'s project URLs point at
+`github.com/kopecn/py_math_tools`, not a PyPI release). Install from source:
+
+```bash
+make uv-sync
+```
+
+See [Development Workflows](#development-workflows) below for the full
+`uv-`-prefixed workflow.
+
+## Quick Start
+
+### Quaternions
+
+```python
+from math_tools.spatial.quaternion import Quaternion
+
+identity = Quaternion.from_components(1, 0, 0, 0)
+rotated = Quaternion.from_unit_x_to_vector([0, 1, 0])
+
+print((identity * rotated).normalized())
+print(rotated.to_rotation_matrix())
+```
+
+### Spherical arcs
+
+```python
+import numpy as np
+from math_tools.spherical import arc_from_two_points, compute_spherical_arc_endpoint
+
+arc = arc_from_two_points(azimuth1=0, polar1=0, azimuth2=0, polar2=np.pi / 2)
+end_azimuth, end_polar = compute_spherical_arc_endpoint(arc)
+```
+
+### Plotting
+
+```bash
+uv run python examples/sphericalPlotting/plotArcs.py
+uv run python examples/sphericalPlotting/plotQuatUnitCircles.py
+```
+
+Both scripts call `plot_unit_spherical_multiplot(..., show_plot=True)`; run
+with an interactive matplotlib backend to see the figures, or with
+`MPLBACKEND=Agg` to just exercise the code path non-interactively.
+
+## Development Workflows
+
+All workflows go through the Makefile (`make help` lists every target); it
+is the source of truth for tooling, not this README.
+
+```bash
+make uv-sync        # create/refresh .venv from pyproject + requirements.txt
+make uv-fullCheck   # gate: ruff lint + strict mypy + pytest
+make uv-format       # ruff format + autofix
+```
+
+`make uv-refresh` is required after the `pyFoundationTools` pin in
+`requirements.txt` changes — a stale `.venv` makes the gate meaningless.
+
+## Requirements
+
+- Python >= 3.10
+- `pyFoundationTools`, `numpy`, `scipy`, `numpy-quaternion`, `matplotlib`
+  (see [`pyproject.toml`](pyproject.toml) for the names-only dependency
+  declaration and [`requirements.txt`](requirements.txt) for the pinned
+  `pyFoundationTools` source)
diff --git a/examples/sphericalPlotting/plotArcs.py b/examples/sphericalPlotting/plotArcs.py
index 991acb2..61b3168 100644
--- a/examples/sphericalPlotting/plotArcs.py
+++ b/examples/sphericalPlotting/plotArcs.py
@@ -1,26 +1,19 @@
-from typing import List
 
-from foundationTypes.mathTypes.UnitSphericalArc import UnitSphericalArc
+from foundation_abc.math.sphericalABCs import UnitSphericalArcABC
+from foundationTypes.mathTypes.MathTypes import UnitSphericalArcType
 
-from pyMathToolsPlotHelpers.plotUnitSpherical import (
-    deg45,
+from math_plot_helpers import plot_unit_spherical_multiplot
+from math_plot_helpers.plot_unit_spherical import (
     deg90,
-    deg180,
-    deg22_5,
-    plot_unit_spherical_multiplot,
 )
-
-from pyMathTools.spherical.constructors import (
-    arc_from_two_points,
-)
-from pyMathTools.spherical.sphericalTransforms import compute_spherical_arc_endpoint
+from math_tools.spherical import arc_from_two_points, compute_spherical_arc_endpoint
 
 
 def demo() -> None:
-    """Demonstration of multiplot view showing spherical small circles in three different projections."""
+    """Demo of the multiplot view: spherical small circles in three projections."""
 
-    arc1 = UnitSphericalArc(orient=0, azimuth=0, polar=0, arc_length=deg90)
-    arc2 = UnitSphericalArc(orient=deg90, azimuth=0, polar=deg90, arc_length=deg90)
+    arc1 = UnitSphericalArcType(orient=0, azimuth=0, polar=0, arc_length=deg90)
+    arc2 = UnitSphericalArcType(orient=deg90, azimuth=0, polar=deg90, arc_length=deg90)
     az, po = compute_spherical_arc_endpoint(arc2)
     arc3 = arc_from_two_points(
         azimuth1=az,
@@ -29,7 +22,7 @@ def demo() -> None:
         polar2=arc1.polar,
     )
 
-    arcs: List[UnitSphericalArc] = [
+    arcs: list[UnitSphericalArcABC] = [
         arc1,
         arc2,
         arc3,
diff --git a/examples/sphericalPlotting/plotQuatUnitCircles.py b/examples/sphericalPlotting/plotQuatUnitCircles.py
index 9f12860..c53bc34 100644
--- a/examples/sphericalPlotting/plotQuatUnitCircles.py
+++ b/examples/sphericalPlotting/plotQuatUnitCircles.py
@@ -25,19 +25,16 @@
 
 """
 
-from typing import List
-from numpy import pi
-
-from foundationTypes.mathTypes.UnitSphericalSmallCircle import UnitSphericalSmallCircle
 
-from pyMathTools.spatial.Quaternion import Quaternion
+import numpy as np
+from foundationTypes.mathTypes.MathTypes import UnitSphericalSmallCircleType
+from numpy import pi
 
-from pyMathToolsPlotHelpers.plotUnitSpherical import (
-    plot_unit_spherical_multiplot,
-)
+from math_plot_helpers import plot_unit_spherical_multiplot
+from math_tools.spatial.quaternion import Quaternion
 
 
-def main():
+def main() -> None:
     """
     Convert canonical quaternions to spherical small circles and plot them.
 
@@ -49,15 +46,15 @@ def main():
     All circles use a radius angle of pi/8 except y and z, which use the default.
     """
 
-    quat4 = Quaternion.from_unit_x_to_vector([1, 0, 0])
-    quat5 = Quaternion.from_unit_x_to_vector([0, 1, 0])
-    quat6 = Quaternion.from_unit_x_to_vector([0, 0, 1])
+    quat4 = Quaternion.from_unit_x_to_vector(np.array([1.0, 0.0, 0.0]))
+    quat5 = Quaternion.from_unit_x_to_vector(np.array([0.0, 1.0, 0.0]))
+    quat6 = Quaternion.from_unit_x_to_vector(np.array([0.0, 0.0, 1.0]))
 
     quat1 = Quaternion.from_components(0, 1, 0, 0)
     quat2 = Quaternion.from_components(0, 0, 1, 0)
     quat3 = Quaternion.from_components(0, 0, 0, 1)
 
-    circles: List[UnitSphericalSmallCircle] = [
+    circles: list[UnitSphericalSmallCircleType] = [
         quat1.to_unitSphericalSmallCircle(radius_angle=pi / 8),
         quat2.to_unitSphericalSmallCircle(radius_angle=pi / 8),
         quat3.to_unitSphericalSmallCircle(),
@@ -66,7 +63,7 @@ def main():
         quat6.to_unitSphericalSmallCircle(radius_angle=pi / 16),
     ]
 
-    quats: List[Quaternion] = [quat1, quat2, quat3, quat4, quat5, quat6]
+    quats: list[Quaternion] = [quat1, quat2, quat3, quat4, quat5, quat6]
 
     # from_vector_part
     _ = plot_unit_spherical_multiplot(
diff --git a/pyproject.toml b/pyproject.toml
index afb03c6..2cfe65b 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -4,44 +4,59 @@ build-backend = "setuptools.build_meta"
 
 
 [project]
-name = "pyMathTools"
-version = "0.0.1"
-description = "Python Boilerplate contains all the boilerplate you need to create a Python package."
+name = "py_math_tools"
+version = "0.0.2"
+description = "Tier 3 numpy-backed math implementation layer for pyFoundationTools (quaternions, spatial/spherical math, waveforms, polynomials, trajectory generation)."
 readme = {file = "README.md", content-type = "text/markdown"}
-requires-python = ">= 3.10"
+requires-python = ">=3.10"
 authors = [
   {name = "Nicholas Bergantz", email = "nicholas.bergantz@gmail.com"}
 ]
-keywords = [
-  
-]
+keywords = ["math", "numpy", "quaternion", "spatial", "waveform", "trajectory-generation"]
 classifiers = [
-
+    "Development Status :: 3 - Alpha",
+    "Intended Audience :: Developers",
+    "License :: OSI Approved :: MIT License",
+    "Natural Language :: English",
+    "Operating System :: OS Independent",
+    "Programming Language :: Python :: 3",
+    "Programming Language :: Python :: 3.10",
+    "Programming Language :: Python :: 3.11",
+    "Programming Language :: Python :: 3.12",
+    "Programming Language :: Python :: 3.13",
+    "Programming Language :: Python :: Implementation :: CPython",
 ]
 license = {text = "MIT"}
+# Runtime dependencies — NAMES ONLY, never version-pinned (BKM: only the application
+# layer pins; module-level pins cause dependency conflicts). Put any version pins,
+# tag-pins, or git-based pointers in requirements*.txt — NEVER here (git URLs in
+# pyproject are a module-deployment disaster). e.g.:
+#   dependencies = ["requests"]
 dependencies = [
-    "pyFoundationTools @ git+https://github.com/kopecn/py-foundationTools.git@dev",
-    "matplotlib",
+    "pyFoundationTools",
+    "numpy",
+    "scipy",
     "numpy-quaternion",
+    "matplotlib",
 ]
 
 [project.optional-dependencies]
-develop = [
+dev = [
     "pytest",
-    "black",
+    "pytest-asyncio",
+    "ruff",
     "build",
     "bump2version",
-    "pylint",
     "mypy",
+    "ty",
     "twine",
 ]
-personal_repos = []
 
 [project.urls]
 
-bugs = "https://github.com/kopecn/pyMathTools/issues"
-changelog = "https://github.com/kopecn/pyMathTools/blob/master/changelog.md"
-homepage = "https://github.com/kopecn/pyMathTools"
+bugs = "https://github.com/kopecn/py_math_tools/issues"
+changelog = "https://github.com/kopecn/py_math_tools/blob/prod/HISTORY.md"
+homepage = "https://github.com/kopecn/py_math_tools"
 
 [tool.setuptools]
 package-dir = {"" = "src"}
@@ -52,4 +67,39 @@ package-dir = {"" = "src"}
 [tool.pytest.ini_options]
 testpaths = ["tests/*"]
 python_functions = ["test*"]
-python_files = ["test*.py"]
\ No newline at end of file
+python_files = ["test*.py"]
+# src/ layout: let pytest import the package without an install (so `make test` and a
+# bare `pytest` work on a fresh checkout).
+pythonpath = ["src"]
+
+# Path resolution: the Makefile scopes quality targets via PY_* vars (.env sets
+# PY_SRC=src for this src/ layout). The src/files config below is the fallback that
+# makes a bare `ruff check .` / `mypy .` (no path args) and IDE integrations resolve
+# the same scope. The Makefile is byte-identical across halves.
+[tool.ruff]
+target-version = "py310"  # support floor; default dev interpreter is 3.13
+line-length = 100
+src = ["src", "tests"]
+
+[tool.ruff.lint]
+select = ["E", "F", "I", "UP", "B"]
+ignore = ["D301"]
+
+[tool.mypy]
+python_version = "3.13"
+strict = true
+files = ["src", "tests"]
+
+# Multi-repo co-development: local editable sibling repos and any git-based pointers
+# go in requirements-local.txt (NEVER in pyproject — git URLs / path overrides here
+# are a module-deployment disaster). `make uv-sync-local` installs that overlay on top
+# of the normal env; it is gitignored and never read by CI/release.
+
+# scipy ships no inline type stubs and the third-party `scipy-stubs` package lags the
+# pinned scipy release (waveformDsp.md's DSP mixins are thin scipy wrappers per
+# mathToolsArchitecture.md's dependency policy, so every scipy submodule they touch
+# hits this). Narrowly scoped to `scipy.*` only -- every other third-party import stays
+# strict/unignored.
+[[tool.mypy.overrides]]
+module = "scipy.*"
+ignore_missing_imports = true
\ No newline at end of file
diff --git a/requirements.txt b/requirements.txt
new file mode 100644
index 0000000..de5e654
--- /dev/null
+++ b/requirements.txt
@@ -0,0 +1,22 @@
+# Runtime dependencies
+#
+# pyproject.toml is the source of truth for dependency declarations, version ranges,
+# and optional dependency groups.
+#
+# This file is intentionally minimal and is used by installation workflows that
+# expect a requirements file (e.g., `make installDev`, `make uv-sync`).
+#
+# Add runtime dependencies here only as needed and keep them aligned with
+# pyproject.toml.
+
+# Examples
+#
+# Tag:      some-package @ git+https://github.com/example-org/some-package.git@v1.4.2
+# Commit:   some-package @ git+https://github.com/example-org/some-package.git@a1b2c3d4e5f6
+# Branch:   some-package @ git+https://github.com/example-org/some-package.git@main
+# Monorepo: some-package @ git+https://github.com/example-org/monorepo.git@v2.0.0#subdirectory=packages/some-package
+# Extras:   some-package[dev,test] @ git+https://github.com/example-org/some-package.git@v1.4.2
+# Editable: -e git+https://github.com/example-org/some-package.git@develop#egg=some-package
+
+
+pyFoundationTools @ git+https://github.com/kopecn/py-foundationTools.git@feat/switch-to-new-template
\ No newline at end of file
diff --git a/src/math_plot_helpers/__init__.py b/src/math_plot_helpers/__init__.py
new file mode 100644
index 0000000..2f8e7f3
--- /dev/null
+++ b/src/math_plot_helpers/__init__.py
@@ -0,0 +1,24 @@
+"""``math_plot_helpers``: matplotlib plotting helpers for spherical math types.
+
+Curated subpackage re-exports so consumers import
+``from math_plot_helpers import plot_unit_spherical_multiplot`` rather than
+reaching into ``plot_unit_spherical`` directly. See
+``.claude/specs/mathToolsArchitecture.md`` §Shared conventions (Public
+surface). This is the only package permitted to import ``matplotlib``
+(enforced by ``tests/test_package_layering.py``). This module contains
+re-exports only -- no logic.
+"""
+
+from math_plot_helpers.plot_unit_spherical import (
+    plot_unit_spherical_3d,
+    plot_unit_spherical_advanced,
+    plot_unit_spherical_multiplot,
+    plot_unit_spherical_polar,
+)
+
+__all__ = [
+    "plot_unit_spherical_advanced",
+    "plot_unit_spherical_polar",
+    "plot_unit_spherical_3d",
+    "plot_unit_spherical_multiplot",
+]
diff --git a/src/pyMathToolsPlotHelpers/plotUnitSpherical.py b/src/math_plot_helpers/plot_unit_spherical.py
similarity index 78%
rename from src/pyMathToolsPlotHelpers/plotUnitSpherical.py
rename to src/math_plot_helpers/plot_unit_spherical.py
index 8ac8fad..e5fa87a 100644
--- a/src/pyMathToolsPlotHelpers/plotUnitSpherical.py
+++ b/src/math_plot_helpers/plot_unit_spherical.py
@@ -1,18 +1,23 @@
-from typing import List, Tuple, Optional
-import numpy as np
+from collections.abc import Sequence
+from typing import cast
+
 import matplotlib.pyplot as plt
-from matplotlib.figure import Figure
+import numpy as np
+from foundation_abc.math.sphericalABCs import (
+    UnitSphericalArcABC,
+    UnitSphericalSmallCircleABC,
+)
+from foundationTypes.mathTypes.MathTypes import UnitSphericalArcType, UnitSphericalSmallCircleType
 from matplotlib.axes import Axes
+from matplotlib.figure import Figure
+from mpl_toolkits.mplot3d import Axes3D  # type: ignore[import-untyped]
 
-from foundationTypes.mathTypes.UnitSphericalSmallCircle import UnitSphericalSmallCircle
-from foundationTypes.mathTypes.UnitSphericalArc import UnitSphericalArc
-
-from pyMathTools.spatial.Quaternion import Quaternion
-from pyMathTools.spherical.sphericalTransforms import plate_carree_transform
-from pyMathTools.spherical.sphericalGenerators import (
-    generate_spherical_small_circle_points,
+from math_tools.spatial.quaternion import Quaternion
+from math_tools.spherical.spherical_generators import (
     generate_spherical_arc_points,
+    generate_spherical_small_circle_points,
 )
+from math_tools.spherical.spherical_transforms import plate_carree_transform
 
 deg45 = np.deg2rad(45)
 deg90 = np.deg2rad(90)
@@ -21,21 +26,21 @@
 
 
 def plot_unit_spherical_advanced(
-    circles: List[UnitSphericalSmallCircle] | None = None,
-    arcs: List[UnitSphericalArc] | None = None,
-    quaternions: List[Quaternion] | None = None,
+    circles: Sequence[UnitSphericalSmallCircleABC] | None = None,
+    arcs: Sequence[UnitSphericalArcABC] | None = None,
+    quaternions: list[Quaternion] | None = None,
     num_points: int = 120,
-    figsize: Tuple[int, int] = (10, 6),
+    figsize: tuple[int, int] = (10, 6),
     title: str = "Small Circles on Sphere (Flattened)",
-    colors: Optional[List[str]] = None,
-    labels: Optional[List[str]] = None,
+    colors: list[str] | None = None,
+    labels: list[str] | None = None,
     show_centers: bool = True,
     show_plot: bool = False,
-    ax: Optional[Axes] = None,
-    arc_colors: Optional[List[str]] = ["red", "green", "blue"],
-    circle_colors: Optional[List[str]] = ["red", "green", "blue"],
-    quaternion_colors: Optional[List[str]] = ["red", "green", "blue"],
-) -> Tuple[Figure, Axes]:
+    ax: Axes | None = None,
+    arc_colors: list[str] | None = None,
+    circle_colors: list[str] | None = None,
+    quaternion_colors: list[str] | None = None,
+) -> tuple[Figure, Axes]:
     """
     Advanced version with more customization options.
 
@@ -82,7 +87,14 @@ def plot_unit_spherical_advanced(
     """
 
     # Helper function to get color with fallback to matplotlib's color cycle
-    def get_color(color_list: Optional[List[str]], idx: int) -> str:
+    if quaternion_colors is None:
+        quaternion_colors = ["red", "green", "blue"]
+    if circle_colors is None:
+        circle_colors = ["red", "green", "blue"]
+    if arc_colors is None:
+        arc_colors = ["red", "green", "blue"]
+
+    def get_color(color_list: list[str] | None, idx: int) -> str:
         """Get color from list or fallback to matplotlib's color cycle."""
         if color_list is None or len(color_list) == 0:
             return f"C{idx}"
@@ -96,11 +108,10 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
     if ax is None:
         fig, ax = plt.subplots(figsize=figsize)
     else:
-        fig = ax.get_figure()
+        fig = cast(Figure, ax.get_figure())
 
     if circles is not None:
         for idx, circle in enumerate(circles):
-
             # Generate true spherical small circle points
             azimuth_points, polar_points = generate_spherical_small_circle_points(
                 circle, num_points
@@ -128,9 +139,7 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
 
             # Plot center point if requested
             if show_centers:
-                x_center, y_center = plate_carree_transform(
-                    circle.azimuth, circle.polar
-                )
+                x_center, y_center = plate_carree_transform(circle.azimuth, circle.polar)
                 ax.scatter(
                     np.degrees(x_center),
                     np.degrees(y_center),
@@ -143,11 +152,8 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
     # Generate points for each arc
     if arcs is not None:
         for idx, arc in enumerate(arcs):
-
             # Generate spherical arc points
-            azimuth_points, polar_points = generate_spherical_arc_points(
-                arc, num_points
-            )
+            azimuth_points, polar_points = generate_spherical_arc_points(arc, num_points)
 
             # Apply Plate Carrée projection
             x_points, y_points = plate_carree_transform(azimuth_points, polar_points)
@@ -185,7 +191,13 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
             label = labels[idx] if labels is not None and idx < len(labels) else None
 
             if label is None:
-                label = f"Quat {idx + 1}: w:{quat.w:.1f}, x:{quat.x:.1f}, y:{quat.y:.1f}, z:{quat.z:.1f}"
+                label = (
+                    f"Quat {idx + 1}: "
+                    f"w:{quat.w:.1f}, "
+                    f"x:{quat.x:.1f}, "
+                    f"y:{quat.y:.1f}, "
+                    f"z:{quat.z:.1f}"
+                )
 
             # Plot vector as an arrow from origin to the point
             ax.annotate(
@@ -238,19 +250,19 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
 
 
 def plot_unit_spherical_polar(
-    circles: List[UnitSphericalSmallCircle] | None = None,
-    arcs: List[UnitSphericalArc] | None = None,
-    quaternions: List[Quaternion] | None = None,
+    circles: Sequence[UnitSphericalSmallCircleABC] | None = None,
+    arcs: Sequence[UnitSphericalArcABC] | None = None,
+    quaternions: list[Quaternion] | None = None,
     num_points: int = 120,
-    figsize: Tuple[int, int] = (8, 8),
+    figsize: tuple[int, int] = (8, 8),
     title: str = "Small Circles on Sphere (Polar View)",
-    labels: Optional[List[str]] = None,
-    ax: Optional[Axes] = None,
+    labels: list[str] | None = None,
+    ax: Axes | None = None,
     show_plot: bool = False,
-    arc_colors: Optional[List[str]] = ["red", "green", "blue"],
-    circle_colors: Optional[List[str]] = ["red", "green", "blue"],
-    quaternion_colors: Optional[List[str]] = ["red", "green", "blue"],
-) -> Tuple[Figure, Axes]:
+    arc_colors: list[str] | None = None,
+    circle_colors: list[str] | None = None,
+    quaternion_colors: list[str] | None = None,
+) -> tuple[Figure, Axes]:
     """
     Plot small circles and arcs on a sphere using polar projection.
     Azimuth is shown as the angle, polar angle is mapped to radius.
@@ -291,7 +303,14 @@ def plot_unit_spherical_polar(
     """
 
     # Helper function to get color with fallback to matplotlib's color cycle
-    def get_color(color_list: Optional[List[str]], idx: int) -> str:
+    if quaternion_colors is None:
+        quaternion_colors = ["red", "green", "blue"]
+    if circle_colors is None:
+        circle_colors = ["red", "green", "blue"]
+    if arc_colors is None:
+        arc_colors = ["red", "green", "blue"]
+
+    def get_color(color_list: list[str] | None, idx: int) -> str:
         """Get color from list or fallback to matplotlib's color cycle."""
         if color_list is None or len(color_list) == 0:
             return f"C{idx}"
@@ -305,11 +324,10 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
     if ax is None:
         fig, ax = plt.subplots(figsize=figsize, subplot_kw={"projection": "polar"})
     else:
-        fig = ax.get_figure()
+        fig = cast(Figure, ax.get_figure())
 
     if circles is not None:
         for idx, circle in enumerate(circles):
-
             # Generate true spherical small circle points
             azimuth_points, polar_points = generate_spherical_small_circle_points(
                 circle, num_points
@@ -344,22 +362,24 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
                 azimuth_plot.append(azimuth_points[0])
                 radius_plot.append(radius_points[0])
 
-            azimuth_plot = np.array(azimuth_plot)
-            radius_plot = np.array(radius_plot)
+            azimuth_arr = np.array(azimuth_plot)
+            radius_arr = np.array(radius_plot)
 
             # Convert radius to degrees for legend
             radius_deg = np.degrees(circle.radius_angle)
             azimuth_deg = np.degrees(circle.azimuth)
             polar_deg = np.degrees(circle.polar)
-            label = f"Circle {idx + 1}: A:{azimuth_deg:.1f}°, P:{polar_deg:.1f}°, R:{radius_deg:.1f}°"
+            label = (
+                f"Circle {idx + 1}: A:{azimuth_deg:.1f}°, P:{polar_deg:.1f}°, R:{radius_deg:.1f}°"
+            )
 
             # Get color for this circle
             color = get_color(circle_colors, idx)
 
             # Plot in polar coordinates using plot instead of scatter for continuous lines
             ax.plot(
-                azimuth_plot,
-                radius_plot,
+                azimuth_arr,
+                radius_arr,
                 linewidth=2,
                 alpha=0.7,
                 label=label,
@@ -369,11 +389,8 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
     # Generate points for each arc
     if arcs is not None:
         for idx, arc in enumerate(arcs):
-
             # Generate spherical arc points
-            azimuth_points, polar_points = generate_spherical_arc_points(
-                arc, num_points
-            )
+            azimuth_points, polar_points = generate_spherical_arc_points(arc, num_points)
 
             # Map polar angle to radius (0 to 1) for polar plot
             radius_points = (polar_points + np.pi / 2) / np.pi
@@ -392,23 +409,29 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
                 azimuth_plot.append(azimuth_points[i])
                 radius_plot.append(radius_points[i])
 
-            azimuth_plot = np.array(azimuth_plot)
-            radius_plot = np.array(radius_plot)
+            azimuth_arr = np.array(azimuth_plot)
+            radius_arr = np.array(radius_plot)
 
             # Convert to degrees for legend
             arc_length_deg = np.degrees(arc.arc_length)
             azimuth_deg = np.degrees(arc.azimuth)
             polar_deg = np.degrees(arc.polar)
             orient_deg = np.degrees(arc.orient)
-            label = f"Arc {idx + 1}: A:{azimuth_deg:.1f}°, P:{polar_deg:.1f}°, L:{arc_length_deg:.1f}°, O:{orient_deg:.1f}°"
+            label = (
+                f"Arc {idx + 1}: "
+                f"A:{azimuth_deg:.1f}°, "
+                f"P:{polar_deg:.1f}°, "
+                f"L:{arc_length_deg:.1f}°, "
+                f"O:{orient_deg:.1f}°"
+            )
 
             # Get color for this arc
             color = get_color(arc_colors, idx)
 
             # Plot the arc
             ax.plot(
-                azimuth_plot,
-                radius_plot,
+                azimuth_arr,
+                radius_arr,
                 linewidth=2,
                 alpha=0.8,
                 label=label,
@@ -440,12 +463,12 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
             # Plot endpoint
             azimuth_deg = np.degrees(azimuth)
             polar_deg = np.degrees(polar)
-            label = f"Quat {idx + 1}: w:{quat.w:.1f}, x:{quat.x:.1f}, y:{quat.y:.1f}, z:{quat.z:.1f}"
-
-            ax.scatter(
-                azimuth, radius, s=150, marker="*", label=label, c=color, zorder=10
+            label = (
+                f"Quat {idx + 1}: w:{quat.w:.1f}, x:{quat.x:.1f}, y:{quat.y:.1f}, z:{quat.z:.1f}"
             )
 
+            ax.scatter(azimuth, radius, s=150, marker="*", label=label, c=color, zorder=10)
+
     ax.set_title(title, fontsize=14, pad=20)
 
     if labels is not None:
@@ -463,20 +486,20 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
 
 
 def plot_unit_spherical_3d(
-    circles: List[UnitSphericalSmallCircle] | None = None,
-    arcs: List[UnitSphericalArc] | None = None,
-    quaternions: List[Quaternion] | None = None,
+    circles: Sequence[UnitSphericalSmallCircleABC] | None = None,
+    arcs: Sequence[UnitSphericalArcABC] | None = None,
+    quaternions: list[Quaternion] | None = None,
     num_points: int = 120,
-    figsize: Tuple[int, int] = (10, 10),
+    figsize: tuple[int, int] = (10, 10),
     title: str = "Small Circles on Unit Sphere (3D)",
     show_sphere: bool = True,
     show_legend: bool = True,
     show_plot: bool = False,
-    ax: Optional[Axes] = None,
-    arc_colors: Optional[List[str]] = ["red", "green", "blue"],
-    circle_colors: Optional[List[str]] = ["red", "green", "blue"],
-    quaternion_colors: Optional[List[str]] = ["red", "green", "blue"],
-) -> Tuple[Figure, Axes]:
+    ax: Axes3D | None = None,
+    arc_colors: list[str] | None = None,
+    circle_colors: list[str] | None = None,
+    quaternion_colors: list[str] | None = None,
+) -> tuple[Figure, Axes]:
     """
     Plot small circles and arcs on a 3D unit sphere.
 
@@ -518,7 +541,14 @@ def plot_unit_spherical_3d(
     """
 
     # Helper function to get color with fallback to matplotlib's color cycle
-    def get_color(color_list: Optional[List[str]], idx: int) -> str:
+    if quaternion_colors is None:
+        quaternion_colors = ["red", "green", "blue"]
+    if circle_colors is None:
+        circle_colors = ["red", "green", "blue"]
+    if arc_colors is None:
+        arc_colors = ["red", "green", "blue"]
+
+    def get_color(color_list: list[str] | None, idx: int) -> str:
         """Get color from list or fallback to matplotlib's color cycle."""
         if color_list is None or len(color_list) == 0:
             return f"C{idx}"
@@ -533,7 +563,7 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
         fig = plt.figure(figsize=figsize)
         ax = fig.add_subplot(111, projection="3d")
     else:
-        fig = ax.get_figure()
+        fig = cast(Figure, ax.get_figure())
 
     # Optionally plot the sphere surface (physics convention)
     if show_sphere:
@@ -547,7 +577,6 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
     # Plot each circle
     if circles is not None:
         for idx, circle in enumerate(circles):
-
             # Generate true spherical small circle points
             azimuth_points, polar_points = generate_spherical_small_circle_points(
                 circle, num_points
@@ -564,7 +593,9 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
             radius_deg = np.degrees(circle.radius_angle)
             azimuth_deg = np.degrees(circle.azimuth)
             polar_deg = np.degrees(circle.polar)
-            label = f"Circle {idx + 1}: A:{azimuth_deg:.1f}°, P:{polar_deg:.1f}°, R:{radius_deg:.1f}°"
+            label = (
+                f"Circle {idx + 1}: A:{azimuth_deg:.1f}°, P:{polar_deg:.1f}°, R:{radius_deg:.1f}°"
+            )
 
             # Get color for this circle
             color = get_color(circle_colors, idx)
@@ -575,11 +606,8 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
     # Plot each arc
     if arcs is not None:
         for idx, arc in enumerate(arcs):
-
             # Generate spherical arc points
-            azimuth_points, polar_points = generate_spherical_arc_points(
-                arc, num_points
-            )
+            azimuth_points, polar_points = generate_spherical_arc_points(arc, num_points)
 
             # Convert to Cartesian coordinates (unit sphere, r=1, physics convention)
             x = np.sin(polar_points) * np.cos(azimuth_points)
@@ -591,7 +619,13 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
             azimuth_deg = np.degrees(arc.azimuth)
             polar_deg = np.degrees(arc.polar)
             orient_deg = np.degrees(arc.orient)
-            label = f"Arc {idx + 1}: A:{azimuth_deg:.1f}°, P:{polar_deg:.1f}°, L:{arc_length_deg:.1f}°, O:{orient_deg:.1f}°"
+            label = (
+                f"Arc {idx + 1}: "
+                f"A:{azimuth_deg:.1f}°, "
+                f"P:{polar_deg:.1f}°, "
+                f"L:{arc_length_deg:.1f}°, "
+                f"O:{orient_deg:.1f}°"
+            )
 
             # Get color for this arc
             color = get_color(arc_colors, idx)
@@ -613,7 +647,7 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
     if quaternions is not None:
         for idx, quat in enumerate(quaternions):
             # Convert quaternion to Cartesian coordinates
-            x, y, z = quat.vector_cartesian
+            qx, qy, qz = quat.vector_cartesian
 
             # Get color for this quaternion
             color = get_color(quaternion_colors, idx)
@@ -623,9 +657,9 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
                 0,
                 0,
                 0,
-                x,
-                y,
-                z,
+                qx,
+                qy,
+                qz,
                 length=1.0,
                 arrow_length_ratio=0.05,
                 color=color,
@@ -634,9 +668,11 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
             )
 
             # Plot endpoint
-            label = f"Quat {idx + 1}: w:{quat.w:.1f}, x:{quat.x:.1f}, y:{quat.y:.1f}, z:{quat.z:.1f}"
+            label = (
+                f"Quat {idx + 1}: w:{quat.w:.1f}, x:{quat.x:.1f}, y:{quat.y:.1f}, z:{quat.z:.1f}"
+            )
 
-            ax.scatter(x, y, z, s=50, marker="*", label=label, c=color, zorder=10)
+            ax.scatter(qx, qy, qz, s=50, marker="*", label=label, c=color, zorder=10)
 
     ax.set_xlabel("X")
     ax.set_ylabel("Y")
@@ -664,24 +700,24 @@ def get_color(color_list: Optional[List[str]], idx: int) -> str:
 
 
 def plot_unit_spherical_multiplot(
-    circles: List[UnitSphericalSmallCircle] | None = None,
-    arcs: List[UnitSphericalArc] | None = None,
-    quaternions: List[Quaternion] | None = None,
+    circles: Sequence[UnitSphericalSmallCircleABC] | None = None,
+    arcs: Sequence[UnitSphericalArcABC] | None = None,
+    quaternions: list[Quaternion] | None = None,
     num_points: int = 120,
-    figsize: Tuple[int, int] = (24, 6),
+    figsize: tuple[int, int] = (24, 6),
     title: str = "Small Circles on Unit Sphere - Multiple Views",
     show_plot: bool = False,
-    arc_colors: Optional[List[str]] = ["red", "green", "blue"],
-    circle_colors: Optional[List[str]] = ["red", "green", "blue"],
-    quaternion_colors: Optional[List[str]] = ["red", "green", "blue"],
+    arc_colors: list[str] | None = None,
+    circle_colors: list[str] | None = None,
+    quaternion_colors: list[str] | None = None,
 ) -> Figure:
     """
     Create a multiplot showing Plate Carrée, Top View, and 3D views of spherical small circles.
 
     Parameters:
     -----------
-    circles : List[UnitSphericalSmallCircle] or array-like
-        List of UnitSphericalSmallCircle objects or array of [azimuth, polar, radius] lists
+    circles : List[UnitSphericalSmallCircleABC] or array-like
+        List of UnitSphericalSmallCircleABC objects or array of [azimuth, polar, radius] lists
     arcs : List[UnitSphericalArc], optional
         List of UnitSphericalArc objects
     quaternions : List[Quaternion], optional
@@ -709,6 +745,12 @@ def plot_unit_spherical_multiplot(
     fig : matplotlib figure object
     """
     # Create figure with overall title
+    if quaternion_colors is None:
+        quaternion_colors = ["red", "green", "blue"]
+    if circle_colors is None:
+        circle_colors = ["red", "green", "blue"]
+    if arc_colors is None:
+        arc_colors = ["red", "green", "blue"]
     fig = plt.figure(figsize=figsize)
     fig.suptitle(title, fontsize=16)
 
@@ -783,71 +825,74 @@ def plot_unit_spherical_multiplot(
 
 
 def demo() -> None:
-    """Demonstration of multiplot view showing spherical small circles in three different projections."""
+    """
+    Demonstration of multiplot view showing spherical small circles in three
+    different projections.
+    """
 
     # Define 4 circles using UnitSphericalSmallCircle dataclass
-    circles: List[UnitSphericalSmallCircle] = [
-        UnitSphericalSmallCircle(
+    circles = [
+        UnitSphericalSmallCircleType(
             azimuth=0,
             polar=0,
             radius_angle=deg45,
         ),
-        UnitSphericalSmallCircle(
+        UnitSphericalSmallCircleType(
             azimuth=0,
             polar=np.pi / 2,
             radius_angle=deg45,
         ),
-        UnitSphericalSmallCircle(
+        UnitSphericalSmallCircleType(
             azimuth=0,
             polar=np.pi,
             radius_angle=deg45,
         ),
-        UnitSphericalSmallCircle(
+        UnitSphericalSmallCircleType(
             azimuth=0,
             polar=-np.pi / 2,
             radius_angle=deg45,
         ),
-        UnitSphericalSmallCircle(
+        UnitSphericalSmallCircleType(
             azimuth=-np.pi / 2,
             polar=np.pi / 2,
             radius_angle=deg45,
         ),
-        UnitSphericalSmallCircle(
+        UnitSphericalSmallCircleType(
             azimuth=np.pi / 2,
             polar=np.pi / 2,
             radius_angle=deg45,
         ),
-        UnitSphericalSmallCircle(
+        UnitSphericalSmallCircleType(
             azimuth=-deg45,
             polar=deg45,
             radius_angle=deg45,
         ),
-        UnitSphericalSmallCircle(
+        UnitSphericalSmallCircleType(
             azimuth=np.deg2rad(135),
             polar=deg45,
             radius_angle=deg45,
         ),
     ]
 
-    arcs: List[UnitSphericalArc] = [
-        UnitSphericalArc(orient=0, azimuth=0, polar=0, arc_length=deg22_5),
-        UnitSphericalArc(orient=deg45, azimuth=0, polar=0, arc_length=deg22_5),
-        UnitSphericalArc(orient=deg90, azimuth=0, polar=0, arc_length=deg22_5),
-        UnitSphericalArc(orient=0, azimuth=0, polar=deg45, arc_length=deg22_5),
-        UnitSphericalArc(orient=0, azimuth=deg45, polar=deg45, arc_length=deg22_5),
-        UnitSphericalArc(orient=0, azimuth=deg90, polar=deg45, arc_length=deg22_5),
-        UnitSphericalArc(orient=deg45, azimuth=0, polar=deg45, arc_length=deg22_5),
-        UnitSphericalArc(orient=deg45, azimuth=deg45, polar=deg45, arc_length=deg22_5),
-        UnitSphericalArc(orient=deg45, azimuth=deg90, polar=deg45, arc_length=deg22_5),
-        UnitSphericalArc(orient=deg90, azimuth=0, polar=deg45, arc_length=deg22_5),
-        UnitSphericalArc(orient=deg90, azimuth=deg45, polar=deg45, arc_length=deg22_5),
-        UnitSphericalArc(orient=deg90, azimuth=deg90, polar=deg45, arc_length=deg22_5),
-        UnitSphericalArc(orient=0, azimuth=0, polar=deg45, arc_length=-deg22_5),
-        UnitSphericalArc(orient=0, azimuth=deg45, polar=deg45, arc_length=-deg22_5),
-        UnitSphericalArc(orient=0, azimuth=deg90, polar=deg45, arc_length=-deg22_5),
+    arcs = [
+        UnitSphericalArcType(orient=0, azimuth=0, polar=0, arc_length=deg22_5),
+        UnitSphericalArcType(orient=deg45, azimuth=0, polar=0, arc_length=deg22_5),
+        UnitSphericalArcType(orient=deg90, azimuth=0, polar=0, arc_length=deg22_5),
+        UnitSphericalArcType(orient=0, azimuth=0, polar=deg45, arc_length=deg22_5),
+        UnitSphericalArcType(orient=0, azimuth=deg45, polar=deg45, arc_length=deg22_5),
+        UnitSphericalArcType(orient=0, azimuth=deg90, polar=deg45, arc_length=deg22_5),
+        UnitSphericalArcType(orient=deg45, azimuth=0, polar=deg45, arc_length=deg22_5),
+        UnitSphericalArcType(orient=deg45, azimuth=deg45, polar=deg45, arc_length=deg22_5),
+        UnitSphericalArcType(orient=deg45, azimuth=deg90, polar=deg45, arc_length=deg22_5),
+        UnitSphericalArcType(orient=deg90, azimuth=0, polar=deg45, arc_length=deg22_5),
+        UnitSphericalArcType(orient=deg90, azimuth=deg45, polar=deg45, arc_length=deg22_5),
+        UnitSphericalArcType(orient=deg90, azimuth=deg90, polar=deg45, arc_length=deg22_5),
+        UnitSphericalArcType(orient=0, azimuth=0, polar=deg45, arc_length=-deg22_5),
+        UnitSphericalArcType(orient=0, azimuth=deg45, polar=deg45, arc_length=-deg22_5),
+        UnitSphericalArcType(orient=0, azimuth=deg90, polar=deg45, arc_length=-deg22_5),
     ]
 
-    quats: List[Quaternion] = [
+    quats: list[Quaternion] = [
         Quaternion.from_components(w=1, x=0, y=0, z=0),
         Quaternion.from_components(w=0, x=1, y=0, z=0),
         Quaternion.from_components(w=0, x=0, y=1, z=0),
@@ -862,8 +907,8 @@ def demo() -> None:
     ]
 
     _ = plot_unit_spherical_multiplot(
-        # circles=circles,
-        # arcs=arcs,
+        circles=circles,
+        arcs=arcs,
         quaternions=quats,
         show_plot=True,
     )
diff --git a/src/pyMathTools/__init__.py b/src/math_plot_helpers/py.typed
similarity index 100%
rename from src/pyMathTools/__init__.py
rename to src/math_plot_helpers/py.typed
diff --git a/src/math_tools/__init__.py b/src/math_tools/__init__.py
new file mode 100644
index 0000000..e80b5e6
--- /dev/null
+++ b/src/math_tools/__init__.py
@@ -0,0 +1,49 @@
+"""``math_tools``: Tier-3 numpy-backed math implementation layer.
+
+Curated root re-exports so ``import math_tools as mt`` is coherent. Consumers
+needing the wider per-subpackage surface (DSP support types, OTG enums,
+polynomial solver helpers, ...) import from the subpackage directly, e.g.
+``from math_tools.waveforms import WaveformSpectrum``.
+
+See ``.claude/specs/mathToolsArchitecture.md`` §Shared conventions (Public
+surface). This module contains re-exports only -- no logic.
+"""
+
+from math_tools.errors import (
+    MathToolsError,
+    PolynomialSolveError,
+    TimestampComparisonError,
+    WaveformCompatibilityError,
+)
+from math_tools.functional import UnivariatePolynomial
+from math_tools.otg import InputParameter, Otg, OutputParameter, Result, Trajectory
+from math_tools.precision_time import PrecisionTimeInterval, PrecisionTimestamp
+from math_tools.spatial import Position, Quaternion, SpatialPose
+from math_tools.waveforms import (
+    Waveform1D,
+    WaveformPosition,
+    WaveformQuaternion,
+    WaveformSpatialPose,
+)
+
+__all__ = [
+    "Position",
+    "Quaternion",
+    "SpatialPose",
+    "PrecisionTimeInterval",
+    "PrecisionTimestamp",
+    "Waveform1D",
+    "WaveformPosition",
+    "WaveformQuaternion",
+    "WaveformSpatialPose",
+    "UnivariatePolynomial",
+    "Otg",
+    "InputParameter",
+    "OutputParameter",
+    "Trajectory",
+    "Result",
+    "MathToolsError",
+    "WaveformCompatibilityError",
+    "TimestampComparisonError",
+    "PolynomialSolveError",
+]
diff --git a/src/math_tools/errors.py b/src/math_tools/errors.py
new file mode 100644
index 0000000..0e3c637
--- /dev/null
+++ b/src/math_tools/errors.py
@@ -0,0 +1,22 @@
+"""Exception hierarchy for domain failures raised by ``math_tools``.
+
+Programmer errors (wrong type, wrong shape, invalid argument) raise stdlib
+``TypeError``/``ValueError``; domain failures raise a ``MathToolsError``
+subtype defined here (see mathToolsArchitecture.md §Error semantics).
+"""
+
+
+class MathToolsError(Exception):
+    """Base class for all domain-level errors raised by math_tools."""
+
+
+class WaveformCompatibilityError(MathToolsError):
+    """Raised when waveform operands are incompatible (dt/shape mismatch)."""
+
+
+class TimestampComparisonError(MathToolsError):
+    """Raised when comparing timestamps with mismatched timescale/frame."""
+
+
+class PolynomialSolveError(MathToolsError):
+    """Raised when a polynomial root request is unsolvable or ill-posed."""
diff --git a/src/math_tools/functional/__init__.py b/src/math_tools/functional/__init__.py
new file mode 100644
index 0000000..88681b2
--- /dev/null
+++ b/src/math_tools/functional/__init__.py
@@ -0,0 +1,34 @@
+"""Polynomials and analytic root solvers.
+
+See ``.claude/specs/polynomials.md``.
+"""
+
+from math_tools.functional.polynomial import UnivariatePolynomial
+from math_tools.functional.roots import (
+    EPS16,
+    POLYNOMIAL_TOLERANCE,
+    POLYNOMIAL_ZERO_THRESHOLD,
+    evaluate_polynomial,
+    integrate_jerk,
+    polynomial_derivative,
+    polynomial_monic_derivative,
+    shrink_interval,
+    solve_cubic,
+    solve_quartic_monic,
+    solve_resolvent,
+)
+
+__all__ = [
+    "EPS16",
+    "POLYNOMIAL_TOLERANCE",
+    "POLYNOMIAL_ZERO_THRESHOLD",
+    "UnivariatePolynomial",
+    "evaluate_polynomial",
+    "integrate_jerk",
+    "polynomial_derivative",
+    "polynomial_monic_derivative",
+    "shrink_interval",
+    "solve_cubic",
+    "solve_quartic_monic",
+    "solve_resolvent",
+]
diff --git a/src/math_tools/functional/polynomial.py b/src/math_tools/functional/polynomial.py
new file mode 100644
index 0000000..2de148b
--- /dev/null
+++ b/src/math_tools/functional/polynomial.py
@@ -0,0 +1,182 @@
+"""Numpy-backed general polynomial type: :class:`UnivariatePolynomial`.
+
+See ``.claude/specs/polynomials.md`` (§UnivariatePolynomial).
+
+Coefficients are stored in **ascending-degree order** (numpy convention:
+``c[0] + c[1]·x + c[2]·x² + ...``), collapsing the Swift
+``PolynomialUnivariateOrder`` enum + eleven per-degree subclasses into one
+class (composition over inheritance; numpy's companion-matrix root solver
+supersedes the closed-form per-degree solvers for this general-purpose API).
+
+:meth:`UnivariatePolynomial.real_roots` returns **all** real roots of the
+polynomial. This is a deliberate contrast with the OTG analytic root kernel
+(``math_tools.functional.roots``, chunk 10), which returns only
+**non-negative** real roots because it solves for time >= 0 -- the two
+contracts are intentionally different; see that module's docstring.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+import numpy.polynomial.polynomial as npoly
+import numpy.typing as npt
+
+from math_tools.errors import PolynomialSolveError
+from math_tools.functional.roots import POLYNOMIAL_ZERO_THRESHOLD as POLYNOMIAL_ZERO_THRESHOLD
+
+#: Imaginary-part tolerance for treating a companion-matrix root as real; also
+#: the default ``tolerance`` for :meth:`UnivariatePolynomial.real_roots`.
+#:
+#: Re-exported from ``math_tools.functional.roots`` (the OTG analytic root
+#: kernel), its authoritative home per polynomials.md design constraint 3.
+
+_SUPERSCRIPT_DIGITS = str.maketrans(
+    "0123456789", "⁰¹²³⁴⁵⁶⁷⁸⁹"
+)
+
+
+def _superscript(power: int) -> str:
+    return str(power).translate(_SUPERSCRIPT_DIGITS)
+
+
+def _trim_trailing_zeros(coefficients: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+    """Trim highest-degree zero coefficients, keeping at least one entry."""
+    last = len(coefficients) - 1
+    while last > 0 and coefficients[last] == 0.0:
+        last -= 1
+    return np.array(coefficients[: last + 1], dtype=np.float64)
+
+
+class UnivariatePolynomial:
+    """An immutable univariate polynomial with float64 coefficients.
+
+    Coefficients are ascending-degree (``coefficients[0]`` is the constant
+    term), matching numpy's convention -- the Swift ordering is descending
+    and is mapped at construction boundaries, never here.
+    """
+
+    __slots__ = ("_coefficients",)
+
+    def __init__(self, coefficients: Sequence[float] | npt.NDArray[np.floating[Any]]) -> None:
+        """Construct from ascending-degree coefficients.
+
+        Args:
+            coefficients: ``[c0, c1, ..., cn]`` such that the polynomial is
+                ``c0 + c1*x + ... + cn*x**n``. Trailing (highest-degree)
+                zeros are trimmed so :attr:`degree` is exact.
+
+        Raises:
+            ValueError: If ``coefficients`` is empty.
+        """
+        if len(coefficients) == 0:
+            raise ValueError("UnivariatePolynomial requires at least one coefficient")
+        arr = np.asarray(coefficients, dtype=np.float64)
+        self._coefficients: npt.NDArray[np.float64] = _trim_trailing_zeros(arr)
+
+    # MARK: - Accessors
+
+    @property
+    def coefficients(self) -> npt.NDArray[np.float64]:
+        """Ascending-degree coefficients, copied out (immutable storage)."""
+        return np.array(self._coefficients, dtype=np.float64)
+
+    @property
+    def degree(self) -> int:
+        """The polynomial's degree (index of the highest nonzero coefficient)."""
+        return int(len(self._coefficients) - 1)
+
+    def coefficient_at(self, degree: int) -> float:
+        """Return the coefficient of ``x**degree`` (``0.0`` beyond :attr:`degree`)."""
+        if degree < 0 or degree >= len(self._coefficients):
+            return 0.0
+        return float(self._coefficients[degree])
+
+    # MARK: - Evaluation
+
+    def __call__(self, x: float | npt.ArrayLike) -> float | npt.NDArray[np.float64]:
+        """Evaluate the polynomial at ``x`` (scalar or array) via Horner's method."""
+        arr = np.asarray(x, dtype=np.float64)
+        result = npoly.polyval(arr, self._coefficients)
+        if arr.ndim == 0:
+            return float(result)
+        return np.asarray(result, dtype=np.float64)
+
+    # MARK: - Calculus
+
+    def derivative(self) -> UnivariatePolynomial:
+        """Return the derivative polynomial."""
+        return UnivariatePolynomial(npoly.polyder(self._coefficients))
+
+    def integrate(self, constant: float = 0.0) -> UnivariatePolynomial:
+        """Return the antiderivative with the given integration constant."""
+        return UnivariatePolynomial(npoly.polyint(self._coefficients, k=constant))
+
+    # MARK: - Roots
+
+    def real_roots(self, tolerance: float = POLYNOMIAL_ZERO_THRESHOLD) -> list[float]:
+        """Return all real roots, sorted ascending.
+
+        Unlike ``math_tools.functional.roots`` (the OTG analytic kernel,
+        which returns only non-negative real roots because it solves for
+        time >= 0), this returns **every** real root of the polynomial.
+
+        Roots are found via the companion matrix (``numpy.roots``
+        equivalent); a root is treated as real when its imaginary part's
+        magnitude is within ``tolerance`` of zero.
+
+        Args:
+            tolerance: Imaginary-part magnitude below which a companion-matrix
+                root is treated as real.
+
+        Raises:
+            PolynomialSolveError: If this is the zero polynomial (every
+                coefficient is zero) -- it has infinitely many roots.
+        """
+        if self.degree == 0:
+            if self._coefficients[0] == 0.0:
+                raise PolynomialSolveError(
+                    "cannot solve for roots of the zero polynomial (infinitely many roots)"
+                )
+            return []
+
+        # numpy.roots expects descending-degree coefficients.
+        descending = self._coefficients[::-1]
+        roots = np.roots(descending)
+        real_mask = np.abs(roots.imag) <= tolerance
+        return sorted(float(value) for value in roots.real[real_mask])
+
+    # MARK: - Comparison
+
+    def __eq__(self, other: object) -> bool:
+        """Check equality of trimmed coefficients."""
+        if isinstance(other, UnivariatePolynomial):
+            return bool(np.array_equal(self._coefficients, other._coefficients))
+        return False
+
+    __hash__ = None  # type: ignore[assignment]
+
+    def __repr__(self) -> str:
+        """Return a human-readable representation, e.g. ``"3.0·x² − 1.0"``."""
+        pieces: list[str] = []
+        for index, power in enumerate(range(self.degree, -1, -1)):
+            coeff = float(self._coefficients[power])
+            if coeff == 0.0 and self.degree > 0:
+                continue
+            magnitude = abs(coeff)
+            if power == 0:
+                term = f"{magnitude}"
+            elif power == 1:
+                term = f"{magnitude}·x"
+            else:
+                term = f"{magnitude}·x{_superscript(power)}"
+
+            if index == 0:
+                sign = "−" if coeff < 0 else ""
+                pieces.append(f"{sign}{term}")
+            else:
+                sign = " − " if coeff < 0 else " + "
+                pieces.append(f"{sign}{term}")
+        return "".join(pieces)
diff --git a/src/pyMathTools/spatial/__init__.py b/src/math_tools/functional/py.typed
similarity index 100%
rename from src/pyMathTools/spatial/__init__.py
rename to src/math_tools/functional/py.typed
diff --git a/src/math_tools/functional/roots.py b/src/math_tools/functional/roots.py
new file mode 100644
index 0000000..d4293f4
--- /dev/null
+++ b/src/math_tools/functional/roots.py
@@ -0,0 +1,437 @@
+"""OTG analytic root kernel -- a faithful port of ``Roots.swift`` / ``Utils.swift``.
+
+See ``.claude/specs/polynomials.md`` (§functional/roots.py). This module is
+the numeric substrate for the online trajectory generator (OTG, see
+``otg.md``) and translates the Swift control flow and arithmetic as directly
+as possible; it does NOT substitute numpy/scipy or closed-form
+"improvements" for the ported algorithms.
+
+**This is NOT a general root finder.** Swift's ``insertIfPositive``
+(``Utils.swift:33``) means :func:`solve_cubic` / :func:`solve_quartic_monic`
+return only **non-negative** real roots -- they solve for time >= 0. General
+root finding is :meth:`math_tools.functional.polynomial.UnivariatePolynomial.real_roots`;
+the two contracts are deliberately different.
+
+Imports are ``math`` + ``sys`` + stdlib ONLY -- no numpy, no scipy (numpy is
+allowed in this module's test file only, for the ``np.roots`` cross-check).
+"""
+
+from __future__ import annotations
+
+import math
+import sys
+from collections.abc import Sequence
+
+#: Machine epsilon scaled by 16, matching Swift's ``eps16 = 16 * .ulpOfOne``.
+#: NOT ``1e-16`` -- see polynomials.md design constraint 1.
+EPS16: float = 16 * sys.float_info.epsilon
+
+#: Standard tolerance for polynomial root finding (Swift ``polynomialTolerance``).
+POLYNOMIAL_TOLERANCE: float = 1e-14
+
+#: Threshold below which a value (e.g. a companion-matrix root's imaginary
+#: part) is treated as zero (Swift ``polynomialZeroThreshold``).
+POLYNOMIAL_ZERO_THRESHOLD: float = 1e-9
+
+# Swift's `.ulpOfOne` for Double == Python's sys.float_info.epsilon (2^-52).
+# Most tolerance checks in Roots.swift compare against this raw ulp, not
+# EPS16 (16x larger) -- the two are used inconsistently in the Swift source
+# and that inconsistency is preserved here faithfully (see solve_quartic_monic).
+_ULP = sys.float_info.epsilon
+
+#: Cosine/sine of 120 degrees, used to rotate among the three cube-root
+#: branches of a depressed cubic (Swift ``cos120`` / ``sin120``).
+_COS_120 = -0.50
+_SIN_120 = 0.866025403784438646764
+
+#: Maximum iterations for shrink_interval's safe-Newton loop (Swift ``maxIts``).
+_MAX_ITS = 128
+
+#: Scale-relative degeneracy threshold for solve_cubic's leading coefficient.
+#: An *absolute* threshold (the original ``_ULP``) cannot be right across the
+#: coefficient scales this module sees: e.g. ``solve_cubic(1e-10, 2.0, -3.0,
+#: -2.0)`` has ``abs(a) == 1e-10 >> _ULP``, so it took the cubic branch, whose
+#: ``1/a**3`` scaling amplifies rounding error catastrophically as ``a``
+#: shrinks (empirically: the closed-form root error grows past the
+#: quadratic-fallback's ``O(a)`` error once ``abs(a)`` drops below roughly
+#: ``1e-6`` of the other coefficients' magnitude -- see polynomials.md
+#: design constraint 1 and the decade sweep in test_roots.py). Below this
+#: relative threshold, `a` is treated as zero and the cubic degrades to the
+#: quadratic branch, matching Swift's degenerate-leading-coefficient rule.
+_CUBIC_LEADING_COEFF_EPS = 1e-6
+
+
+def _cbrt(x: float) -> float:
+    """Real cube root, defined for negative ``x`` (matches C/Swift ``cbrt``)."""
+    if x < 0.0:
+        return -float((-x) ** (1.0 / 3.0))
+    return float(x ** (1.0 / 3.0))
+
+
+def _insert_if_positive(collected: list[float], value: float) -> None:
+    """Append ``value`` only if non-negative (Swift ``insertIfPositive``, ``val >= 0``).
+
+    This is the load-bearing time-domain filter: :func:`solve_cubic` and
+    :func:`solve_quartic_monic` solve for time >= 0, so negative real roots
+    are dropped, not returned.
+    """
+    if value >= 0:
+        collected.append(value)
+
+
+def solve_cubic(a: float, b: float, c: float, d: float) -> list[float]:
+    """Non-negative real roots of ``a*x^3 + b*x^2 + c*x + d = 0``.
+
+    OTG time-domain kernel; NOT a general root finder -- see
+    ``UnivariatePolynomial.real_roots``. Coefficients are ordered highest to
+    lowest degree, matching ``Roots.swift:solveCubic``.
+    """
+    roots: list[float] = []
+
+    if abs(d) < _ULP:
+        # First solution is x = 0; convert the remainder to a quadratic.
+        _insert_if_positive(roots, 0.0)
+        d = c
+        c = b
+        b = a
+        a = 0.0
+
+    if abs(a) <= _CUBIC_LEADING_COEFF_EPS * max(abs(b), abs(c), abs(d)):
+        if abs(b) < _ULP:
+            # Linear equation.
+            if abs(c) > _ULP:
+                _insert_if_positive(roots, -d / c)
+        else:
+            # Quadratic equation.
+            discriminant = c * c - 4 * b * d
+            if discriminant >= 0:
+                inv2b = 1.0 / (2 * b)
+                y = math.sqrt(discriminant)
+                _insert_if_positive(roots, (-c + y) * inv2b)
+                _insert_if_positive(roots, (-c - y) * inv2b)
+    else:
+        # Cubic equation.
+        inva = 1.0 / a
+        invaa = inva * inva
+        bb = b * b
+        bover3a = b * inva / 3
+        p = (a * c - bb / 3) * invaa
+        # NOTE: deliberate deviation from the literal Swift source. Roots.swift:70
+        # scales halfq by `invaa * invaa` (1/a**4); the correct scaling for the
+        # standard depressed-cubic resolvent (R = (2A**3 - 9AB + 27C) / 54 with
+        # A=b/a, B=c/a, C=d/a) is 1/a**3, i.e. `inva * invaa`. The Swift bug is
+        # inert at both of its call sites (PositionThirdOrderStep2.swift,
+        # PolynomialUnivariateFunction.swift) because they always pass a monic
+        # cubic (a == 1), where 1/a**3 == 1/a**4 == 1 -- so it was never
+        # observed upstream. It is NOT inert here: polynomials.md Compliance 2b
+        # requires solve_cubic to match np.roots for general (non-monic)
+        # random coefficients, which the literal 1/a**4 scaling fails for any
+        # a != 1. See polynomials.md §functional/roots.py rules for the
+        # accepted spec deviation.
+        halfq = (2 * bb * b - 9 * a * b * c + 27 * a * a * d) / 54 * inva * invaa
+        yy = p * p * p / 27 + halfq * halfq
+
+        if yy > _ULP:
+            # Sqrt is positive: one real solution.
+            y = math.sqrt(yy)
+            uuu = -halfq + y
+            vvv = -halfq - y
+            www = uuu if abs(uuu) > abs(vvv) else vvv
+            w = _cbrt(www)
+            _insert_if_positive(roots, w - p / (3 * w) - bover3a)
+        elif yy < -_ULP:
+            # Sqrt is negative: three real solutions.
+            x = -halfq
+            y = math.sqrt(-yy)
+            if abs(x) > _ULP:
+                theta = math.atan(y / x) if x > 0.0 else math.atan(y / x) + math.pi
+                r = math.sqrt(x * x - yy)
+            else:
+                # Vertical line.
+                theta = math.pi / 2
+                r = y
+            theta /= 3
+            r = 2 * _cbrt(r)
+            ux = math.cos(theta) * r
+            uyi = math.sin(theta) * r
+
+            _insert_if_positive(roots, ux - bover3a)
+            _insert_if_positive(roots, ux * _COS_120 - uyi * _SIN_120 - bover3a)
+            _insert_if_positive(roots, ux * _COS_120 + uyi * _SIN_120 - bover3a)
+        else:
+            # Sqrt is zero: two real solutions.
+            www = -halfq
+            w = 2 * _cbrt(www)
+            _insert_if_positive(roots, w - bover3a)
+            _insert_if_positive(roots, w * _COS_120 - bover3a)
+
+    return roots
+
+
+def solve_resolvent(a: float, b: float, c: float) -> tuple[list[float], int]:
+    """Roots of the cubic resolvent ``y^3 + a*y^2 + b*y + c = 0`` for a quartic.
+
+    Coefficients are ordered highest to lowest degree (monic cubic), matching
+    ``Roots.swift:solveResolvent``.
+
+    Returns:
+        A 3-element list of scratch/root values plus the REAL-root count.
+        In the 1-real-root case, slot 0 holds the real root and slot 2 holds
+        an imaginary-part scratch value, NOT a root -- callers
+        (:func:`solve_quartic_monic`) must consult the count before reading
+        slots 1 and 2 (Swift ``Roots.swift:234`` guard).
+    """
+    x = [0.0, 0.0, 0.0]
+
+    a = a / 3
+    a2 = a * a
+    q = a2 - b / 3
+    r = (a * (2 * a2 - b) + c) / 2
+    r2 = r * r
+    q3 = q * q * q
+
+    if r2 < q3:
+        qsqrt = math.sqrt(q)
+        t = min(max(r / (q * qsqrt), -1.0), 1.0)
+        q = -2 * qsqrt
+
+        theta = math.acos(t) / 3
+        ux = math.cos(theta) * q
+        uyi = math.sin(theta) * q
+        x[0] = ux - a
+        x[1] = ux * _COS_120 - uyi * _SIN_120 - a
+        x[2] = ux * _COS_120 + uyi * _SIN_120 - a
+        return x, 3
+
+    big_a = -_cbrt(abs(r) + math.sqrt(r2 - q3))
+    if r < 0.0:
+        big_a = -big_a
+    big_b = 0.0 if big_a == 0.0 else q / big_a
+
+    x[0] = (big_a + big_b) - a
+    x[1] = -(big_a + big_b) / 2 - a
+    x[2] = math.sqrt(3) * (big_a - big_b) / 2
+    if abs(x[2]) < _ULP:
+        x[2] = x[1]
+        return x, 2
+
+    return x, 1
+
+
+def solve_quartic_monic(a: float, b: float, c: float, d: float) -> list[float]:
+    """Non-negative real roots of the monic quartic ``x^4 + a*x^3 + b*x^2 + c*x + d = 0``.
+
+    OTG time-domain kernel; NOT a general root finder -- see
+    ``UnivariatePolynomial.real_roots``. Coefficients are ordered highest to
+    lowest degree (excluding the implicit leading ``1``), matching
+    ``Roots.swift:solveQuarticMonic``.
+    """
+    roots: list[float] = []
+
+    if abs(d) < _ULP:
+        if abs(c) < _ULP:
+            _insert_if_positive(roots, 0.0)
+            disc = a * a - 4 * b
+            if abs(disc) < _ULP:
+                _insert_if_positive(roots, -a / 2)
+            elif disc > 0.0:
+                sqrt_disc = math.sqrt(disc)
+                _insert_if_positive(roots, (-a - sqrt_disc) / 2)
+                _insert_if_positive(roots, (-a + sqrt_disc) / 2)
+            return roots
+
+        if abs(a) < _ULP and abs(b) < _ULP:
+            _insert_if_positive(roots, 0.0)
+            _insert_if_positive(roots, -_cbrt(c))
+            return roots
+
+    a3 = -b
+    b3 = a * c - 4 * d
+    c3 = -a * a * d - c * c + 4 * b * d
+
+    x3, number_of_zeroes = solve_resolvent(a3, b3, c3)
+
+    y = x3[0]
+    # Choosing y with maximal absolute value. Consult the real-root count
+    # before reading slots 1-2: in the 1-real-root case slot 2 is an
+    # imaginary-part scratch value, not a root (Swift Roots.swift:234).
+    if number_of_zeroes != 1:
+        if abs(x3[1]) > abs(y):
+            y = x3[1]
+        if abs(x3[2]) > abs(y):
+            y = x3[2]
+
+    disc = y * y - 4 * d
+    if abs(disc) < _ULP:
+        q1 = y / 2
+        q2 = q1
+        disc = a * a - 4 * (b - y)
+        if abs(disc) < _ULP:
+            p1 = a / 2
+            p2 = p1
+        else:
+            sqrt_disc = math.sqrt(disc)
+            p1 = (a + sqrt_disc) / 2
+            p2 = (a - sqrt_disc) / 2
+    else:
+        sqrt_disc = math.sqrt(disc)
+        q1 = (y + sqrt_disc) / 2
+        q2 = (y - sqrt_disc) / 2
+        p1 = (a * q1 - c) / (q1 - q2)
+        p2 = (c - a * q2) / (q1 - q2)
+
+    disc = p1 * p1 - 4 * q1
+    if abs(disc) < EPS16:
+        _insert_if_positive(roots, -p1 / 2)
+    elif disc > 0.0:
+        sqrt_disc = math.sqrt(disc)
+        _insert_if_positive(roots, (-p1 - sqrt_disc) / 2)
+        _insert_if_positive(roots, (-p1 + sqrt_disc) / 2)
+
+    disc = p2 * p2 - 4 * q2
+    if abs(disc) < EPS16:
+        _insert_if_positive(roots, -p2 / 2)
+    elif disc > 0.0:
+        sqrt_disc = math.sqrt(disc)
+        _insert_if_positive(roots, (-p2 - sqrt_disc) / 2)
+        _insert_if_positive(roots, (-p2 + sqrt_disc) / 2)
+
+    return roots
+
+
+def evaluate_polynomial(coefficients: Sequence[float], x: float) -> float:
+    """Evaluate a polynomial at ``x`` via Horner's method.
+
+    ``coefficients`` are ordered highest to lowest degree (Swift
+    ``evaluatePolynomial``), which differs from
+    ``UnivariatePolynomial``'s ascending-degree convention.
+    """
+    if not coefficients:
+        return 0.0
+    result = coefficients[0]
+    for i in range(1, len(coefficients)):
+        result = result * x + coefficients[i]
+    return result
+
+
+def polynomial_derivative(coefficients: Sequence[float]) -> list[float]:
+    """Return the derivative's coefficients, highest to lowest degree.
+
+    Matches ``Roots.swift:polynomialDerivative``; ``coefficients`` are
+    ordered highest to lowest degree.
+    """
+    if len(coefficients) <= 1:
+        return []
+    count = len(coefficients) - 1
+    deriv = [0.0] * count
+    for i in range(count):
+        deriv[i] = float(count - i) * coefficients[i]
+    return deriv
+
+
+def polynomial_monic_derivative(coefficients: Sequence[float]) -> list[float]:
+    """Return the monic-normalized derivative's coefficients, highest to lowest degree.
+
+    Matches ``Roots.swift:polynomialMonicDerivative``; ``coefficients`` are
+    ordered highest to lowest degree and assumed monic (leading coefficient 1).
+    """
+    if len(coefficients) <= 1:
+        return []
+    n = len(coefficients)
+    deriv = [0.0] * (n - 1)
+    deriv[0] = 1.0
+    for i in range(1, n - 1):
+        deriv[i] = float(n - 1 - i) * coefficients[i] / float(n - 1)
+    return deriv
+
+
+def shrink_interval(coefficients: Sequence[float], left: float, right: float) -> float:
+    """Shrink ``[left, right]`` to converge on a bracketed root of ``coefficients``.
+
+    Safe-Newton (Newton-Raphson with bisection fallback) iteration, matching
+    ``Roots.swift:shrinkInterval``. ``coefficients`` are ordered highest to
+    lowest degree and must bracket exactly the root of interest.
+    """
+    lo = left
+    hi = right
+
+    f_lo = evaluate_polynomial(coefficients, lo)
+    if f_lo == 0.0:
+        return lo
+
+    f_hi = evaluate_polynomial(coefficients, hi)
+    if f_hi == 0.0:
+        return hi
+
+    if f_lo > 0.0:
+        lo, hi = hi, lo
+
+    rts = (lo + hi) / 2
+    dx_old = abs(hi - lo)
+    dx = dx_old
+    deriv = polynomial_derivative(coefficients)
+    f = evaluate_polynomial(coefficients, rts)
+    df = evaluate_polynomial(deriv, rts)
+
+    for _ in range(_MAX_ITS):
+        if (((rts - hi) * df - f) * ((rts - lo) * df - f) > 0.0) or (
+            abs(2 * f) > abs(dx_old * df)
+        ):
+            dx_old = dx
+            dx = (hi - lo) / 2
+            rts = lo + dx
+            if lo == rts:
+                break
+        else:
+            if f == 0.0:
+                # f == 0 (regardless of df) means rts is already the root;
+                # dividing (0.0 / df) is either 0 or, when df is also 0.0,
+                # a ZeroDivisionError trap. Swift's untyped division would
+                # silently produce NaN/inf here and the safe-Newton loop
+                # would exit via the dx-tolerance check below; returning the
+                # already-found root directly is the guard called out in
+                # polynomials.md design constraint 2.
+                return rts
+            dx_old = dx
+            dx = f / df
+            temp = rts
+            rts -= dx
+            if temp == rts:
+                break
+
+        if abs(dx) < POLYNOMIAL_TOLERANCE:
+            break
+
+        f = evaluate_polynomial(coefficients, rts)
+        df = evaluate_polynomial(deriv, rts)
+
+        if f < 0.0:
+            lo = rts
+        else:
+            hi = rts
+
+    return rts
+
+
+def integrate_jerk(
+    t: float, p0: float, v0: float, a0: float, j: float
+) -> tuple[float, float, float]:
+    """Constant-jerk kinematic step: ``(p, v, a)`` after duration ``t``.
+
+    Matches ``Utils.swift:integrate``.
+
+    Args:
+        t: Duration in seconds.
+        p0: Initial position.
+        v0: Initial velocity.
+        a0: Initial acceleration.
+        j: Applied (constant) jerk over the interval.
+
+    Returns:
+        The ``(position, velocity, acceleration)`` tuple after time ``t``.
+    """
+    return (
+        p0 + t * (v0 + t * (a0 / 2 + t * j / 6)),
+        v0 + t * (a0 + t * j / 2),
+        a0 + t * j,
+    )
diff --git a/src/pyMathTools/hints.py b/src/math_tools/hints.py
similarity index 57%
rename from src/pyMathTools/hints.py
rename to src/math_tools/hints.py
index 2305056..03c02ef 100644
--- a/src/pyMathTools/hints.py
+++ b/src/math_tools/hints.py
@@ -5,27 +5,22 @@
 enabling strict and clear typing in mathematical code throughout the package.
 """
 
-from typing import Union, TYPE_CHECKING
-import numpy as np
+from typing import TYPE_CHECKING, Union
+
 from numpy import float64
 from numpy.typing import NDArray
-import quaternion
+from quaternion import quaternion as np_quaternion  # type: ignore[import-untyped]
 
 if TYPE_CHECKING:
-    from pyMathTools.spatial.quaternion import Quaternion
+    from math_tools.spatial.quaternion import Quaternion
 
 # Basic numeric types
-FloatOrNDArray = Union[float, NDArray[float64]]
+FloatOrNDArray = float | NDArray[float64]
 FloatNDArray = NDArray[float64]
 
 # Quaternion types
-QuaternionLike = Union["Quaternion", np.quaternion, NDArray[np.quaternion]]
-FloatOrQuaternion = Union["Quaternion", float, np.quaternion]
+QuaternionLike = Union["Quaternion", np_quaternion, NDArray[np_quaternion]]
+FloatOrQuaternion = Union["Quaternion", float, np_quaternion]
 FloatArray3 = NDArray[float64]  # Shape (..., 3)
 FloatArray4 = NDArray[float64]  # Shape (..., 4)
 RotationMatrix = NDArray[float64]  # Shape (..., 3, 3)
-
-
-if __name__ == "__main__":
-    q = quaternion.one
-    assert isinstance(q, np.quaternion)
diff --git a/src/math_tools/otg/__init__.py b/src/math_tools/otg/__init__.py
new file mode 100644
index 0000000..19ffc92
--- /dev/null
+++ b/src/math_tools/otg/__init__.py
@@ -0,0 +1,41 @@
+"""Online trajectory generation (OTG): a faithful Ruckig port.
+
+See ``.claude/specs/otg.md``. Pure Python + stdlib in the per-cycle path --
+this package (and everything under it) never imports numpy (real-time
+control-loop constraint, enforced by ``tests/test_package_layering.py``).
+
+This chunk (41) lands the final public re-export: ``Otg``, the per-cycle
+driver, plus ``Profile`` (already public in ``profile.py``'s own
+``__all__`` since chunk 33, but not yet wired into this module). The
+``__all__`` list below now matches otg.md §Module layout's re-export list
+exactly (otg.md §Compliance 5) -- the finished public surface for this
+subsystem.
+"""
+
+from __future__ import annotations
+
+from math_tools.otg.enums import (
+    ControlInterface,
+    DurationDiscretization,
+    Result,
+    Synchronization,
+)
+from math_tools.otg.errors import OtgError
+from math_tools.otg.input_parameter import InputParameter
+from math_tools.otg.otg import Otg
+from math_tools.otg.output_parameter import OutputParameter
+from math_tools.otg.profile import Profile
+from math_tools.otg.trajectory import Trajectory
+
+__all__ = [
+    "ControlInterface",
+    "DurationDiscretization",
+    "InputParameter",
+    "Otg",
+    "OtgError",
+    "OutputParameter",
+    "Profile",
+    "Result",
+    "Synchronization",
+    "Trajectory",
+]
diff --git a/src/math_tools/otg/block.py b/src/math_tools/otg/block.py
new file mode 100644
index 0000000..46fd8e8
--- /dev/null
+++ b/src/math_tools/otg/block.py
@@ -0,0 +1,218 @@
+"""Block-interval synchronization support types: the fastest per-DOF motion
+profile plus zero, one, or two "blocked" time intervals during which a
+slower profile must not be selected.
+
+Faithful port of ``SWIFT_MATH/OTG/Block.swift`` and ``Interval.swift`` (the
+branch structure of ``calculate_block`` is preserved exactly -- it drives
+``TargetCalculator.synchronize``, chunk 40). See ``.claude/specs/otg.md``
+§Internal fidelity requirement 3 and
+``.claude/action-plan/34-otg-block-brake-bound.md`` design constraint 3.
+
+Swift's ``inout`` ``validProfileCounter`` parameter on
+``Block.calculateBlock``/``Block.removeProfile`` becomes a returned,
+possibly-decremented counter here -- Python ints are immutable and cannot
+be mutated by reference. ``block`` and ``valid_profiles`` (a class instance
+and a list, both mutable Python objects) ARE mutated in place, matching the
+Swift ``inout`` semantics for those two parameters.
+"""
+
+from __future__ import annotations
+
+import sys
+
+from math_tools.otg.profile import Profile
+
+__all__ = ["Block", "Interval"]
+
+#: Swift ``Double.ulpOfOne`` -- used (not ``functional.roots.EPS16``) for
+#: the near-equality tolerances in ``calculate_block``, matching
+#: ``profile.py``'s identical convention for its own private epsilons.
+_ULP = sys.float_info.epsilon
+
+
+class Interval:
+    """A time interval ``[left, right]`` during which a slower profile
+    (``profile``, valid starting at ``right``) blocks synchronization at
+    the faster profile's duration.
+    """
+
+    def __init__(self, left: float, right: float, profile: Profile | None = None) -> None:
+        self.left = left
+        self.right = right
+        self.profile = profile
+
+    @classmethod
+    def from_profiles(cls, profile_left: Profile, profile_right: Profile) -> Interval:
+        """``Interval(profileLeft:profileRight:)`` -- orders the pair by
+        total duration (``t_sum[-1] + brake.duration + accel.duration``)
+        and stores the *slower* profile at ``right``.
+        """
+        left_duration = (
+            profile_left.t_sum[-1] + profile_left.brake.duration + profile_left.accel.duration
+        )
+        right_duration = (
+            profile_right.t_sum[-1] + profile_right.brake.duration + profile_right.accel.duration
+        )
+        if left_duration < right_duration:
+            return cls(left_duration, right_duration, profile_right)
+        return cls(right_duration, left_duration, profile_left)
+
+    def is_blocked(self, t: float) -> bool:
+        """``isBlocked`` -- strictly inside the open interval ``(left, right)``."""
+        return self.left < t < self.right
+
+
+class Block:
+    """The fastest profile (``p_min``) among a set of synchronization
+    candidates, plus up to two blocked ``Interval``s during which a slower
+    profile must not be selected.
+    """
+
+    def __init__(self, p_min: Profile | None = None, t_min: float = 0.0) -> None:
+        self.p_min: Profile = p_min if p_min is not None else Profile()
+        self.t_min: float = t_min
+        self.a: Interval | None = None
+        self.b: Interval | None = None
+
+    @staticmethod
+    def remove_profile(
+        valid_profiles: list[Profile], valid_profile_counter: int, index: int
+    ) -> int:
+        """``removeProfile`` -- shifts elements past ``index`` left by one
+        in place; returns the decremented counter."""
+        for i in range(index, valid_profile_counter - 1):
+            valid_profiles[i] = valid_profiles[i + 1]
+        return valid_profile_counter - 1
+
+    def set_min_profile(self, profile: Profile) -> None:
+        """``setMinProfile`` -- adopts ``profile`` as the fastest candidate
+        and clears any previously computed blocked intervals."""
+        self.p_min = profile
+        self.t_min = profile.t_sum[-1] + profile.brake.duration + profile.accel.duration
+        self.a = None
+        self.b = None
+
+    @staticmethod
+    def calculate_block(
+        block: Block,
+        valid_profiles: list[Profile],
+        valid_profile_counter: int,
+        numerical_robust: bool = True,
+    ) -> tuple[bool, int]:
+        """``calculateBlock`` -- computes ``block``'s minimal profile and
+        (for 3 or 5 valid candidates) one or two blocked intervals.
+
+        Mutates ``block`` and ``valid_profiles`` in place. Returns
+        ``(success, updated_valid_profile_counter)``: the counter can
+        shrink (the ``validProfileCounter == 4`` numerical-duplicate-removal
+        path), and Python ints can't be passed by reference the way Swift's
+        ``inout`` counter is, so the (possibly unchanged) value is always
+        returned alongside the success flag.
+        """
+        if valid_profile_counter == 1:
+            block.set_min_profile(valid_profiles[0])
+            return True, valid_profile_counter
+
+        elif valid_profile_counter == 2:
+            if abs(valid_profiles[0].t_sum[-1] - valid_profiles[1].t_sum[-1]) < 8.0 * _ULP:
+                block.set_min_profile(valid_profiles[0])
+                return True, valid_profile_counter
+
+            if numerical_robust:
+                idx_min = 0 if valid_profiles[0].t_sum[-1] < valid_profiles[1].t_sum[-1] else 1
+                idx_else1 = (idx_min + 1) % 2
+
+                block.set_min_profile(valid_profiles[idx_min])
+                block.a = Interval.from_profiles(
+                    valid_profiles[idx_min], valid_profiles[idx_else1]
+                )
+                return True, valid_profile_counter
+
+        elif valid_profile_counter == 4:
+            if (
+                abs(valid_profiles[0].t_sum[-1] - valid_profiles[1].t_sum[-1]) < 32 * _ULP
+                and valid_profiles[0].direction != valid_profiles[1].direction
+            ):
+                valid_profile_counter = Block.remove_profile(
+                    valid_profiles, valid_profile_counter, 1
+                )
+            elif (
+                abs(valid_profiles[2].t_sum[-1] - valid_profiles[3].t_sum[-1]) < 256 * _ULP
+                and valid_profiles[2].direction != valid_profiles[3].direction
+            ):
+                valid_profile_counter = Block.remove_profile(
+                    valid_profiles, valid_profile_counter, 3
+                )
+            elif (
+                abs(valid_profiles[0].t_sum[-1] - valid_profiles[3].t_sum[-1]) < 256 * _ULP
+                and valid_profiles[0].direction != valid_profiles[3].direction
+            ):
+                valid_profile_counter = Block.remove_profile(
+                    valid_profiles, valid_profile_counter, 3
+                )
+            else:
+                return False, valid_profile_counter
+
+        elif valid_profile_counter % 2 == 0:
+            return False, valid_profile_counter
+
+        # validProfileCounter is 3 or 5 here (or was 4 above and just got
+        # reduced to 3 by remove_profile) -- all other counts returned
+        # above -- so this is never an empty sequence.
+        candidates = list(enumerate(valid_profiles[:valid_profile_counter]))
+        if not candidates:
+            return False, valid_profile_counter  # unreachable -- see note above
+        idx_min, _ = min(candidates, key=lambda pair: pair[1].t_sum[-1])
+
+        block.set_min_profile(valid_profiles[idx_min])
+
+        if valid_profile_counter == 3:
+            idx_else1 = (idx_min + 1) % 3
+            idx_else2 = (idx_min + 2) % 3
+
+            block.a = Interval.from_profiles(valid_profiles[idx_else1], valid_profiles[idx_else2])
+            return True, valid_profile_counter
+
+        elif valid_profile_counter == 5:
+            idx_else1 = (idx_min + 1) % 5
+            idx_else2 = (idx_min + 2) % 5
+            idx_else3 = (idx_min + 3) % 5
+            idx_else4 = (idx_min + 4) % 5
+
+            if valid_profiles[idx_else1].direction == valid_profiles[idx_else2].direction:
+                block.a = Interval.from_profiles(
+                    valid_profiles[idx_else1], valid_profiles[idx_else2]
+                )
+                block.b = Interval.from_profiles(
+                    valid_profiles[idx_else3], valid_profiles[idx_else4]
+                )
+            else:
+                block.a = Interval.from_profiles(
+                    valid_profiles[idx_else1], valid_profiles[idx_else4]
+                )
+                block.b = Interval.from_profiles(
+                    valid_profiles[idx_else2], valid_profiles[idx_else3]
+                )
+            return True, valid_profile_counter
+
+        return False, valid_profile_counter
+
+    def is_blocked(self, t: float) -> bool:
+        """``isBlocked`` -- before the fastest profile's duration, or
+        inside either blocked interval."""
+        if t < self.t_min:
+            return True
+        if self.a is not None and self.a.is_blocked(t):
+            return True
+        if self.b is not None and self.b.is_blocked(t):
+            return True
+        return False
+
+    def get_profile(self, t: float) -> Profile:
+        """``getProfile`` -- the profile that should be selected at time
+        ``t``, given the blocked intervals."""
+        if self.b is not None and t >= self.b.right:
+            return self.b.profile if self.b.profile is not None else self.p_min
+        if self.a is not None and t >= self.a.right:
+            return self.a.profile if self.a.profile is not None else self.p_min
+        return self.p_min
diff --git a/src/math_tools/otg/bound.py b/src/math_tools/otg/bound.py
new file mode 100644
index 0000000..877e5cd
--- /dev/null
+++ b/src/math_tools/otg/bound.py
@@ -0,0 +1,37 @@
+"""Position-extremum record for a computed motion ``Profile``.
+
+Faithful port of ``SWIFT_MATH/OTG/Bound.swift``. See ``.claude/specs/otg.md``
+§Internal fidelity requirements and
+``.claude/action-plan/34-otg-block-brake-bound.md`` design constraint 1.
+
+Structurally satisfies ``math_tools.otg.profile``'s module-private
+``_PositionExtremumSink`` Protocol (``min``, ``max``, ``t_min``, ``t_max``
+floats) by field name -- see that chunk's Resolution notes for why
+``profile.py`` does not import this module directly.
+"""
+
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+
+__all__ = ["Bound"]
+
+
+@dataclass
+class Bound:
+    """Position extrema (min/max) reached during a motion ``Profile``, and
+    the times at which they occur.
+
+    Plain mutable dataclass (otg.md §Internal fidelity, design constraint
+    1) -- ``Profile.check_position_extremum``/
+    ``check_step_for_position_extremum`` mutate instances of this type in
+    place. Defaults mirror Swift's parameterless ``init()``
+    (``min = +infinity``, ``max = -infinity``, so any real position
+    trivially becomes a new extremum on first comparison).
+    """
+
+    min: float = math.inf
+    max: float = -math.inf
+    t_min: float = 0.0
+    t_max: float = 0.0
diff --git a/src/math_tools/otg/brake.py b/src/math_tools/otg/brake.py
new file mode 100644
index 0000000..9179a47
--- /dev/null
+++ b/src/math_tools/otg/brake.py
@@ -0,0 +1,266 @@
+"""Pre-trajectory braking profile: brings an out-of-limits kinematic state
+within bounds before the main synchronized trajectory begins.
+
+Faithful port of ``SWIFT_MATH/OTG/Brake.swift`` (method and branch structure
+preserved mechanically). See ``.claude/specs/otg.md`` §Internal fidelity
+requirements 1, 4, 5 and ``.claude/action-plan/34-otg-block-brake-bound.md``
+design constraint 2.
+
+All kinematic stepping goes through
+:func:`math_tools.functional.roots.integrate_jerk` (Swift's free function
+``integrate``) -- never a fresh constant-jerk integration, matching
+``profile.py``'s identical convention (otg.md §Internal fidelity
+requirement 1).
+
+Swift's ``inout`` position/velocity/acceleration parameters on ``finalize``
+and ``finalizeSecondOrder`` become returned ``(p, v, a)`` tuples here --
+Python has no by-reference scalar parameters.
+"""
+
+from __future__ import annotations
+
+import math
+
+from math_tools.functional.roots import integrate_jerk
+
+__all__ = ["BrakeProfile"]
+
+#: Brake.swift's own private module constant (transcribed verbatim) -- NOT
+#: functional.roots.EPS16/POLYNOMIAL_* (a distinct, unrelated tolerance),
+#: matching profile.py's identical convention for its own private epsilons.
+_EPS = 2.2e-14
+
+
+class BrakeProfile:
+    """Models a pre-trajectory braking motion to bring a system within
+    acceptable kinematic limits (position, velocity, acceleration) before
+    the main synchronized trajectory begins.
+
+    Computed via either a second-order (acceleration-limited) or
+    third-order (jerk-limited) profile, depending on which limits are
+    violated.
+    """
+
+    def __init__(self) -> None:
+        self.duration: float = 0.0
+        self.t: list[float] = [0.0, 0.0]
+        self.j: list[float] = [0.0, 0.0]
+        self.a: list[float] = [0.0, 0.0]
+        self.v: list[float] = [0.0, 0.0]
+        self.p: list[float] = [0.0, 0.0]
+
+    # MARK: - Equality
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, BrakeProfile):
+            return NotImplemented
+        return (
+            self.duration == other.duration
+            and self.t == other.t
+            and self.j == other.j
+            and self.a == other.a
+            and self.v == other.v
+            and self.p == other.p
+        )
+
+    # MARK: - Finalization
+
+    def finalize(self, p_s: float, v_s: float, a_s: float) -> tuple[float, float, float]:
+        """``finalize`` (third-order braking). Returns the updated
+        ``(position, velocity, acceleration)`` state."""
+        if self.t[0] <= 0.0 and self.t[1] <= 0.0:
+            self.duration = 0.0
+            return p_s, v_s, a_s
+
+        self.duration = self.t[0]
+        self.p[0] = p_s
+        self.v[0] = v_s
+        self.a[0] = a_s
+        p_s, v_s, a_s = integrate_jerk(self.t[0], p_s, v_s, a_s, self.j[0])
+
+        if self.t[1] > 0.0:
+            self.duration += self.t[1]
+            self.p[1] = p_s
+            self.v[1] = v_s
+            self.a[1] = a_s
+            p_s, v_s, a_s = integrate_jerk(self.t[1], p_s, v_s, a_s, self.j[1])
+
+        return p_s, v_s, a_s
+
+    def finalize_second_order(
+        self, p_s: float, v_s: float, a_s: float
+    ) -> tuple[float, float, float]:
+        """``finalizeSecondOrder``. Returns the updated ``(position,
+        velocity, acceleration)`` state."""
+        if self.t[0] <= 0.0:
+            self.duration = 0.0
+            return p_s, v_s, a_s
+
+        self.duration = self.t[0]
+        self.p[0] = p_s
+        self.v[0] = v_s
+        p_s, v_s, a_s = integrate_jerk(self.t[0], p_s, v_s, self.a[0], 0.0)
+        return p_s, v_s, a_s
+
+    # MARK: - Velocity helpers
+
+    def v_at_t(self, v0: float, a0: float, j: float, t: float) -> float:
+        """``vAtT`` -- velocity at time ``t`` under constant jerk ``j``."""
+        return v0 + t * (a0 + j * t / 2)
+
+    def v_at_a_zero(self, v0: float, a0: float, j: float) -> float:
+        """``vAtAZero`` -- velocity at the moment acceleration reaches zero."""
+        return v0 + (a0 * a0) / (2 * j)
+
+    # MARK: - Brake construction
+
+    def acceleration_brake(
+        self,
+        v0: float,
+        a0: float,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> None:
+        """``accelerationBrake`` -- brings acceleration into bounds first,
+        falling back to :meth:`velocity_brake` when velocity would still be
+        out of bounds once acceleration is corrected."""
+        self.j[0] = -j_max
+
+        t_to_a_max = (a0 - a_max) / j_max
+        t_to_a_zero = a0 / j_max
+
+        v_at_a_max = self.v_at_t(v0, a0, -j_max, t_to_a_max)
+        v_at_a_zero = self.v_at_t(v0, a0, -j_max, t_to_a_zero)
+
+        if (v_at_a_zero > v_max and j_max > 0) or (v_at_a_zero < v_max and j_max < 0):
+            self.velocity_brake(v0, a0, v_max, v_min, a_max, a_min, j_max)
+        elif (v_at_a_max < v_min and j_max > 0) or (v_at_a_max > v_min and j_max < 0):
+            t_to_v_min = -(v_at_a_max - v_min) / a_max
+            t_to_v_max = -a_max / (2 * j_max) - (v_at_a_max - v_max) / a_max
+
+            self.t[0] = t_to_a_max + _EPS
+            self.t[1] = max(min(t_to_v_min, t_to_v_max - _EPS), 0.0)
+        else:
+            self.t[0] = t_to_a_max + _EPS
+
+    def velocity_brake(
+        self,
+        v0: float,
+        a0: float,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> None:
+        """``velocityBrake`` -- brings velocity into bounds directly.
+
+        ``a_max`` is accepted (matching the Swift signature) but unused in
+        every branch, exactly as upstream.
+        """
+        self.j[0] = -j_max
+
+        t_to_a_min = (a0 - a_min) / j_max
+        t_to_v_max = a0 / j_max + math.sqrt(a0 * a0 + 2 * j_max * (v0 - v_max)) / abs(j_max)
+        t_to_v_min = a0 / j_max + math.sqrt(a0 * a0 / 2 + j_max * (v0 - v_min)) / abs(j_max)
+        t_min_to_v = min(t_to_v_max, t_to_v_min)
+
+        if t_to_a_min < t_min_to_v:
+            v_at_a_min = self.v_at_t(v0, a0, -j_max, t_to_a_min)
+            t_to_v_max_with_constant = -(v_at_a_min - v_max) / a_min
+            t_to_v_min_with_constant = a_min / (2 * j_max) - (v_at_a_min - v_min) / a_min
+
+            self.t[0] = max(t_to_a_min - _EPS, 0.0)
+            self.t[1] = max(min(t_to_v_max_with_constant, t_to_v_min_with_constant), 0.0)
+        else:
+            self.t[0] = max(t_min_to_v - _EPS, 0.0)
+
+    # MARK: - Trajectory selection
+
+    def get_position_brake_trajectory(
+        self,
+        v0: float,
+        a0: float,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> None:
+        """``getPositionBrakeTrajectory`` -- selects acceleration- or
+        velocity-based braking (or none) from the third-order position
+        interface's initial state and limits."""
+        self.t = [0.0, 0.0]
+        self.j = [0.0, 0.0]
+
+        if j_max == 0.0 or a_max == 0.0 or a_min == 0.0:
+            return
+
+        if a0 > a_max:
+            self.acceleration_brake(v0, a0, v_max, v_min, a_max, a_min, j_max)
+        elif a0 < a_min:
+            self.acceleration_brake(v0, a0, v_min, v_max, a_min, a_max, -j_max)
+        elif (v0 > v_max and self.v_at_a_zero(v0, a0, -j_max) > v_min) or (
+            a0 > 0 and self.v_at_a_zero(v0, a0, j_max) > v_max
+        ):
+            self.velocity_brake(v0, a0, v_max, v_min, a_max, a_min, j_max)
+        elif (v0 < v_min and self.v_at_a_zero(v0, a0, j_max) < v_max) or (
+            a0 < 0 and self.v_at_a_zero(v0, a0, -j_max) < v_min
+        ):
+            self.velocity_brake(v0, a0, v_min, v_max, a_min, a_max, -j_max)
+
+    def get_second_order_position_brake_trajectory(
+        self,
+        v0: float,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+    ) -> None:
+        """``getSecondOrderPositionBrakeTrajectory`` -- acceleration-only
+        braking from the second-order position interface."""
+        self.t = [0.0, 0.0]
+        self.j = [0.0, 0.0]
+        self.a = [0.0, 0.0]
+
+        if a_max == 0.0 or a_min == 0.0:
+            return
+
+        if v0 > v_max:
+            self.a[0] = a_min
+            self.t[0] = (v_max - v0) / a_min + _EPS
+        elif v0 < v_min:
+            self.a[0] = a_max
+            self.t[0] = (v_min - v0) / a_max + _EPS
+
+    def get_velocity_brake_trajectory(
+        self,
+        a0: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> None:
+        """``getVelocityBrakeTrajectory`` -- jerk-limited braking that
+        brings acceleration into bounds, for the second-order velocity
+        interface."""
+        self.t = [0.0, 0.0]
+        self.j = [0.0, 0.0]
+
+        if j_max == 0.0:
+            return
+
+        if a0 > a_max:
+            self.j[0] = -j_max
+            self.t[0] = (a0 - a_max) / j_max + _EPS
+        elif a0 < a_min:
+            self.j[0] = j_max
+            self.t[0] = -(a0 - a_min) / j_max + _EPS
+
+    def get_second_order_velocity_brake_trajectory(self) -> None:
+        """``getSecondOrderVelocityBrakeTrajectory`` -- no-op reset, ported
+        verbatim (the Swift source documents this as a placeholder)."""
+        self.t = [0.0, 0.0]
+        self.j = [0.0, 0.0]
diff --git a/src/math_tools/otg/calculator_target.py b/src/math_tools/otg/calculator_target.py
new file mode 100644
index 0000000..f9d159d
--- /dev/null
+++ b/src/math_tools/otg/calculator_target.py
@@ -0,0 +1,864 @@
+"""``TargetCalculator``: per-DOF Step1/Step2 dispatch plus cross-DOF
+synchronization (Block/Interval logic, the discrete-duration path, phase
+sync).
+
+Faithful port of ``SWIFT_MATH/OTG/CalculatorTarget.swift`` (~780 lines). See
+``.claude/specs/otg.md`` §Internal fidelity requirement 3 and
+``.claude/action-plan/40-otg-calculator-target.md``.
+
+**Alias-mutation hazard (otg.md's cross-chunk pattern, see chunks 36-39's
+module docstrings).** ``Profile`` is a Python class (reference type); Swift's
+``Profile`` is a struct (value type), so every Swift ``profiles[i] =
+someBlock.pMin`` (or ``.a!.profile!`` / ``.b!.profile!``) is an *independent
+copy* in Swift but a *shared alias* in Python unless explicitly severed.
+``self._blocks`` is instance state that persists across ``calculate()``
+calls (mirroring Swift's per-DOF ``blocks`` array living on the
+``TargetCalculator`` instance), and ``Block.p_min``/``Interval.profile`` are
+read again on later calls (e.g. Step1's own ``copy.deepcopy(block.p_min)``
+pattern) and within the same call (the "Time Synchronization" loop can, when
+``discrete_duration`` is true, still reach and mutate a profile that
+``synchronize()`` or the "None Synchronization" loop already wrote from a
+block). Every site that assigns a ``Block``/``Interval``-held ``Profile``
+into ``trajectory.profiles[0][...]`` therefore goes through
+``copy.deepcopy()`` here: :meth:`TargetCalculator._synchronize`'s own
+``profiles[div_rem] = ...`` save point, the "None Synchronization" loop, the
+``trajectory.duration == 0.0`` copy-all-profiles branch, the 1-DOF
+shortcut, and the "Time Synchronization" loop's three early-exit branches
+(exact duration already matches an extremal profile). Everywhere else,
+``trajectory.profiles[0][dof]`` is read, mutated in place, and (redundantly
+but harmlessly, matching the Swift read-mutate-writeback structure)
+reassigned to itself -- these are the trajectory's own persistent per-cycle
+objects, never a fresh alias, so no copy is needed.
+
+**Known, accepted Python/Swift divergence (not fixed, not tested):** Swift's
+per-DOF loop reads ``var p = trajectory.profiles[0][dof]`` as a *local
+struct copy*; an early ``return`` (e.g. ``.ErrorZeroLimits``,
+``.ErrorExecutionTimeCalculation``) leaves ``trajectory.profiles[0][dof]``
+untouched for any DOF whose mutations hadn't been explicitly written back
+yet. In Python, since ``Profile`` is a reference type, mutating ``p``
+*is* mutating ``trajectory.profiles[0][dof]`` immediately -- an early error
+return leaves partially-mutated profile state in place rather than Swift's
+clean rollback. otg.md's fidelity ranking is (1) oracle results, (2) public
+semantics, (3) code structure; nothing in the oracle/classification/numeric
+test strategy inspects trajectory state after an error ``Result``, so this
+divergence is unobservable through the documented contract and is not
+patched with defensive copying (that would violate the "not blanket
+everywhere" scoping of the alias-mutation fix above).
+
+**Debug ``print`` statements dropped.** The Swift source has four
+``print("[DEBUG] ...")`` calls (in ``synchronize()``'s failure path and
+``calculate()``'s two error branches) that are unconditional developer
+tracing, not part of the algorithm -- same category as chunk 39's
+``debugTimeVel``-gated print block, which was dropped as "not part of the
+algorithm; every branch/root-search/Newton-step it wrapped is preserved
+exactly." Dropped here for the same reason; every branch/decision they
+straddled is preserved.
+
+Division in :meth:`TargetCalculator._is_input_collinear` (``pd[dof] /
+scale``, etc.) uses the bare ``/`` operator, not ``_ieee754_div``: ``scale``
+is ``scale_vector[scale_dof]``, and ``scale_dof`` is only ever selected when
+``abs(scale_vector[scale_dof]) > _EPS`` was already checked immediately
+before -- the denominator is provably nonzero at every call site, unlike the
+degenerate-root cases in chunks 38/39 that motivated ``_ieee754_div``
+(otg.md §Internal fidelity requirement 4: only wrap where a *failing test*
+shows a zero-denominator is reachable). ``controlLimiting * currentScale /
+scaleLimiting``'s denominator (``scale_vector[limiting_dof]``) has no such
+proof and could in principle be zero for some phase-sync input; no failing
+test in this chunk's suite reaches that case, so it is left as a bare ``/``
+per the same narrowly-scoped precedent, flagged here for any future chunk
+that does hit it.
+"""
+
+from __future__ import annotations
+
+import copy
+import math
+import sys
+
+from math_tools.otg.block import Block
+from math_tools.otg.enums import (
+    ControlInterface,
+    ControlSigns,
+    Direction,
+    DurationDiscretization,
+    ReachedLimits,
+    Result,
+    Synchronization,
+)
+from math_tools.otg.input_parameter import InputParameter
+from math_tools.otg.profile import Profile
+from math_tools.otg.steps.position_first_order import (
+    PositionFirstOrderStep1,
+    PositionFirstOrderStep2,
+)
+from math_tools.otg.steps.position_second_order import (
+    PositionSecondOrderStep1,
+    PositionSecondOrderStep2,
+)
+from math_tools.otg.steps.position_third_order_step1 import PositionThirdOrderStep1
+from math_tools.otg.steps.position_third_order_step2 import PositionThirdOrderStep2
+from math_tools.otg.steps.velocity_second_order import (
+    VelocitySecondOrderStep1,
+    VelocitySecondOrderStep2,
+)
+from math_tools.otg.steps.velocity_third_order import (
+    VelocityThirdOrderStep1,
+    VelocityThirdOrderStep2,
+)
+from math_tools.otg.trajectory import Trajectory
+
+__all__: list[str] = []
+
+#: Swift ``Double.ulpOfOne`` -- ``CalculatorTarget.swift``'s own ``private
+#: static let eps`` (transcribed under its Swift-local name rather than
+#: profile.py's/block.py's ``_ULP``, matching this port's per-Swift-file
+#: private-constant convention).
+_EPS = sys.float_info.epsilon
+
+#: ``CalculatorTarget.swift``'s ``private static let returnErrorAtMaximalDuration = true``.
+_RETURN_ERROR_AT_MAXIMAL_DURATION = True
+
+#: ``CalculatorTarget.swift``'s numerical trajectory-duration ceiling.
+_MAX_DURATION = 7.6e3
+
+
+class TargetCalculator:
+    """Calculation class for a state-to-state trajectory.
+
+    Owns large, pre-allocated per-DOF buffers (``_blocks``,
+    ``_possible_t_syncs``, ``_idx``, ...) mutated in place on every call to
+    :meth:`calculate`, mirroring the Swift ``class`` (reference type) for
+    the same reason: this is the hot path of a real-time control loop.
+    """
+
+    def __init__(self, dofs: int) -> None:
+        self.degrees_of_freedom = dofs
+
+        self._blocks: list[Block] = [Block() for _ in range(dofs)]
+        self._inp_min_velocity: list[float] = [0.0] * dofs
+        self._inp_min_acceleration: list[float] = [0.0] * dofs
+        self._inp_per_dof_control_interface: list[ControlInterface] = [
+            ControlInterface.POSITION
+        ] * dofs
+        self._inp_per_dof_synchronization: list[Synchronization] = [
+            Synchronization.NONE
+        ] * dofs
+
+        self._new_phase_control: list[float] = [0.0] * dofs
+        self._pd: list[float] = [0.0] * dofs  # For phase synchronization.
+        self._possible_t_syncs: list[float] = [math.inf] * (3 * dofs + 1)
+        self._idx: list[int] = [0] * (3 * dofs + 1)
+
+    # MARK: - Phase-synchronization collinearity check
+
+    def _is_input_collinear(
+        self, inp: InputParameter, limiting_direction: Direction, limiting_dof: int
+    ) -> bool:
+        """``isInputCollinear`` -- is the trajectory (in principle) phase
+        synchronizable? Checks that ``pd``/``v0``/``a0``/``vf``/``af`` are
+        collinear across every DOF tagged ``Synchronization.PHASE``."""
+        dofs = self.degrees_of_freedom
+        for dof in range(dofs):
+            self._pd[dof] = inp.target_position[dof] - inp.current_position[dof]
+
+        scale_vector: list[float] | None = None
+        scale_dof: int | None = None  # Need a scale DOF: limiting DOF might not be phase synced.
+
+        for dof in range(dofs):
+            if self._inp_per_dof_synchronization[dof] != Synchronization.PHASE:
+                continue
+
+            if (
+                self._inp_per_dof_control_interface[dof] == ControlInterface.POSITION
+                and abs(self._pd[dof]) > _EPS
+            ):
+                scale_vector = self._pd
+                scale_dof = dof
+                break
+            elif abs(inp.current_velocity[dof]) > _EPS:
+                scale_vector = inp.current_velocity
+                scale_dof = dof
+                break
+            elif abs(inp.current_acceleration[dof]) > _EPS:
+                scale_vector = inp.current_acceleration
+                scale_dof = dof
+                break
+            elif abs(inp.target_velocity[dof]) > _EPS:
+                scale_vector = inp.target_velocity
+                scale_dof = dof
+                break
+            elif abs(inp.target_acceleration[dof]) > _EPS:
+                scale_vector = inp.target_acceleration
+                scale_dof = dof
+                break
+
+        if scale_dof is None or scale_vector is None:
+            # Zero everywhere is in theory collinear, but that trivial case
+            # is better handled elsewhere.
+            return False
+
+        scale = scale_vector[scale_dof]
+        pd_scale = self._pd[scale_dof] / scale
+        v0_scale = inp.current_velocity[scale_dof] / scale
+        vf_scale = inp.target_velocity[scale_dof] / scale
+        a0_scale = inp.current_acceleration[scale_dof] / scale
+        af_scale = inp.target_acceleration[scale_dof] / scale
+
+        scale_limiting = scale_vector[limiting_dof]
+        if math.isinf(inp.max_jerk[limiting_dof]):
+            control_limiting = (
+                inp.max_acceleration[limiting_dof]
+                if limiting_direction == Direction.UP
+                else self._inp_min_acceleration[limiting_dof]
+            )
+        else:
+            control_limiting = (
+                inp.max_jerk[limiting_dof]
+                if limiting_direction == Direction.UP
+                else -inp.max_jerk[limiting_dof]
+            )
+
+        for dof in range(dofs):
+            if self._inp_per_dof_synchronization[dof] != Synchronization.PHASE:
+                continue
+
+            current_scale = scale_vector[dof]
+            if (
+                (
+                    self._inp_per_dof_control_interface[dof] == ControlInterface.POSITION
+                    and abs(self._pd[dof] - pd_scale * current_scale) > _EPS
+                )
+                or abs(inp.current_velocity[dof] - v0_scale * current_scale) > _EPS
+                or abs(inp.current_acceleration[dof] - a0_scale * current_scale) > _EPS
+                or abs(inp.target_velocity[dof] - vf_scale * current_scale) > _EPS
+                or abs(inp.target_acceleration[dof] - af_scale * current_scale) > _EPS
+            ):
+                return False
+
+            self._new_phase_control[dof] = control_limiting * current_scale / scale_limiting
+
+        return True
+
+    # MARK: - Cross-DOF time synchronization
+
+    def _synchronize(
+        self,
+        t_min: float | None,
+        profiles: list[Profile],
+        discrete_duration: bool,
+        delta_time: float,
+    ) -> tuple[bool, float, int | None]:
+        """``synchronize`` -- returns ``(found, t_sync, limiting_dof)``.
+        Mutates ``profiles`` (``trajectory.profiles[0]``) in place at its
+        selected index, matching Swift's ``inout [Profile]`` parameter."""
+        dofs = self.degrees_of_freedom
+
+        # Possible tSyncs are the start times of the intervals and optional t_min.
+        any_interval = False
+        for dof in range(dofs):
+            # Ignore DoFs without synchronization here.
+            if self._inp_per_dof_synchronization[dof] == Synchronization.NONE:
+                self._possible_t_syncs[dof] = 0.0
+                self._possible_t_syncs[dofs + dof] = math.inf
+                self._possible_t_syncs[2 * dofs + dof] = math.inf
+                continue
+
+            block = self._blocks[dof]
+            self._possible_t_syncs[dof] = block.t_min
+            self._possible_t_syncs[dofs + dof] = block.a.right if block.a is not None else math.inf
+            self._possible_t_syncs[2 * dofs + dof] = (
+                block.b.right if block.b is not None else math.inf
+            )
+            any_interval = any_interval or block.a is not None or block.b is not None
+
+        self._possible_t_syncs[3 * dofs] = t_min if t_min is not None else math.inf
+        any_interval = any_interval or t_min is not None
+
+        if discrete_duration:
+            for i in range(len(self._possible_t_syncs)):
+                if math.isinf(self._possible_t_syncs[i]):
+                    continue
+                remainder = math.fmod(self._possible_t_syncs[i], delta_time)  # in [0, delta_time)
+                if remainder > _EPS:
+                    self._possible_t_syncs[i] += delta_time - remainder
+
+        # Test them in sorted order.
+        idx_end = len(self._idx) if any_interval else dofs
+        for i in range(idx_end):
+            self._idx[i] = i
+        self._idx[0:idx_end] = sorted(
+            self._idx[0:idx_end], key=lambda i: self._possible_t_syncs[i]
+        )
+
+        # Start at last tmin (or worse).
+        for i in range(dofs - 1, idx_end):
+            possible_t_sync = self._possible_t_syncs[self._idx[i]]
+            is_blocked = False
+            for dof in range(dofs):
+                if self._inp_per_dof_synchronization[dof] == Synchronization.NONE:
+                    continue  # inner dof loop
+                if self._blocks[dof].is_blocked(possible_t_sync):
+                    is_blocked = True
+                    break  # inner dof loop
+
+            floor = t_min if t_min is not None else 0.0
+            if is_blocked or possible_t_sync < floor or math.isinf(possible_t_sync):
+                continue
+
+            t_sync = possible_t_sync
+            if self._idx[i] == 3 * dofs:  # Optional t_min.
+                return True, t_sync, None
+
+            div_quot, div_rem = divmod(self._idx[i], dofs)
+            limiting_dof = div_rem
+            block = self._blocks[div_rem]
+            if div_quot == 0:
+                profiles[div_rem] = copy.deepcopy(block.p_min)
+            elif div_quot == 1 and block.a is not None and block.a.profile is not None:
+                profiles[div_rem] = copy.deepcopy(block.a.profile)
+            elif div_quot == 2 and block.b is not None and block.b.profile is not None:
+                profiles[div_rem] = copy.deepcopy(block.b.profile)
+            return True, t_sync, limiting_dof
+
+        return False, 0.0, None
+
+    # MARK: - Calculation
+
+    def calculate(
+        self,
+        input_parameter: InputParameter,
+        trajectory: Trajectory,
+        delta_time: float,
+    ) -> Result:
+        """Calculate the time-optimal waypoint-based trajectory. Never
+        raises for per-cycle failures (otg.md §Error semantics) -- returns
+        an error :class:`~math_tools.otg.enums.Result` instead."""
+        dofs = self.degrees_of_freedom
+
+        # Check for the trivial case: all positions equal, all
+        # velocities/accelerations zero.
+        all_positions_equal = True
+        all_velocities_zero = True
+        all_accelerations_zero = True
+
+        for dof in range(dofs):
+            position_delta = (
+                input_parameter.target_position[dof] - input_parameter.current_position[dof]
+            )
+            if abs(position_delta) > _EPS:
+                all_positions_equal = False
+            if (
+                abs(input_parameter.current_velocity[dof]) > _EPS
+                or abs(input_parameter.target_velocity[dof]) > _EPS
+            ):
+                all_velocities_zero = False
+            if (
+                abs(input_parameter.current_acceleration[dof]) > _EPS
+                or abs(input_parameter.target_acceleration[dof]) > _EPS
+            ):
+                all_accelerations_zero = False
+
+        if all_positions_equal and all_velocities_zero and all_accelerations_zero:
+            # Trivial case: already at target with zero motion.
+            trajectory.duration = 0.0
+            trajectory.cumulative_times[0] = 0.0
+
+            for dof in range(dofs):
+                p = trajectory.profiles[0][dof]
+                p.t = [0.0] * 7
+                p.t_sum = [0.0] * 7
+                p.j = [0.0] * 7
+                # 8-element a/v/p, deliberately NOT the 7-element form of
+                # CalculatorTarget.swift:256-261 -- otg.md §Internal
+                # fidelity requirement 1 mandates fixed-length a[8]/v[8]/
+                # p[8] (never resized) on every path, and the Swift
+                # 7-element trivial branch is a latent bug, not a contract
+                # to port faithfully (see chunk 45).
+                p.a = [input_parameter.current_acceleration[dof]] * 8
+                p.v = [input_parameter.current_velocity[dof]] * 8
+                p.p = [input_parameter.current_position[dof]] * 8
+                p.pf = input_parameter.current_position[dof]
+                trajectory.independent_min_durations[dof] = 0.0
+
+            return Result.WORKING
+
+        for dof in range(dofs):
+            p = trajectory.profiles[0][dof]
+
+            self._inp_min_velocity[dof] = (
+                input_parameter.min_velocity[dof]
+                if input_parameter.min_velocity is not None
+                else -input_parameter.max_velocity[dof]
+            )
+            self._inp_min_acceleration[dof] = (
+                input_parameter.min_acceleration[dof]
+                if input_parameter.min_acceleration is not None
+                else -input_parameter.max_acceleration[dof]
+            )
+            self._inp_per_dof_control_interface[dof] = (
+                input_parameter.per_dof_control_interface[dof]
+                if input_parameter.per_dof_control_interface is not None
+                else input_parameter.control_interface
+            )
+            self._inp_per_dof_synchronization[dof] = (
+                input_parameter.per_dof_synchronization[dof]
+                if input_parameter.per_dof_synchronization is not None
+                else input_parameter.synchronization
+            )
+
+            if not input_parameter.enabled[dof]:
+                p.p[-1] = input_parameter.current_position[dof]
+                p.v[-1] = input_parameter.current_velocity[dof]
+                p.a[-1] = input_parameter.current_acceleration[dof]
+                p.t_sum[-1] = 0.0
+                self._blocks[dof].t_min = 0.0
+                self._blocks[dof].a = None
+                self._blocks[dof].b = None
+                trajectory.profiles[0][dof] = p
+                continue
+
+            control_interface = self._inp_per_dof_control_interface[dof]
+
+            # Calculate brake (if input exceeds or will exceed limits).
+            if control_interface == ControlInterface.POSITION:
+                if not math.isinf(input_parameter.max_jerk[dof]):
+                    p.brake.get_position_brake_trajectory(
+                        input_parameter.current_velocity[dof],
+                        input_parameter.current_acceleration[dof],
+                        input_parameter.max_velocity[dof],
+                        self._inp_min_velocity[dof],
+                        input_parameter.max_acceleration[dof],
+                        self._inp_min_acceleration[dof],
+                        input_parameter.max_jerk[dof],
+                    )
+                elif not math.isinf(input_parameter.max_acceleration[dof]):
+                    p.brake.get_second_order_position_brake_trajectory(
+                        input_parameter.current_velocity[dof],
+                        input_parameter.max_velocity[dof],
+                        self._inp_min_velocity[dof],
+                        input_parameter.max_acceleration[dof],
+                        self._inp_min_acceleration[dof],
+                    )
+                p.set_boundary(
+                    input_parameter.current_position[dof],
+                    input_parameter.current_velocity[dof],
+                    input_parameter.current_acceleration[dof],
+                    input_parameter.target_position[dof],
+                    input_parameter.target_velocity[dof],
+                    input_parameter.target_acceleration[dof],
+                )
+            else:  # ControlInterface.VELOCITY
+                if not math.isinf(input_parameter.max_jerk[dof]):
+                    p.brake.get_velocity_brake_trajectory(
+                        input_parameter.current_acceleration[dof],
+                        input_parameter.max_acceleration[dof],
+                        self._inp_min_acceleration[dof],
+                        input_parameter.max_jerk[dof],
+                    )
+                else:
+                    p.brake.get_second_order_velocity_brake_trajectory()
+                p.set_boundary_for_velocity(
+                    input_parameter.current_position[dof],
+                    input_parameter.current_velocity[dof],
+                    input_parameter.current_acceleration[dof],
+                    input_parameter.target_velocity[dof],
+                    input_parameter.target_acceleration[dof],
+                )
+
+            # Finalize pre & post-trajectories.
+            if not math.isinf(input_parameter.max_jerk[dof]):
+                p.p[0], p.v[0], p.a[0] = p.brake.finalize(p.p[0], p.v[0], p.a[0])
+            elif not math.isinf(input_parameter.max_acceleration[dof]):
+                p.p[0], p.v[0], p.a[0] = p.brake.finalize_second_order(p.p[0], p.v[0], p.a[0])
+
+            found_profile = False
+            if control_interface == ControlInterface.POSITION:
+                if not math.isinf(input_parameter.max_jerk[dof]):
+                    # MARK: - P-ThirdOrderStep1
+                    step1_p3 = PositionThirdOrderStep1(
+                        p0=p.p[0],
+                        v0=p.v[0],
+                        a0=p.a[0],
+                        pf=p.pf,
+                        vf=p.vf,
+                        af=p.af,
+                        v_max=input_parameter.max_velocity[dof],
+                        v_min=self._inp_min_velocity[dof],
+                        a_max=input_parameter.max_acceleration[dof],
+                        a_min=self._inp_min_acceleration[dof],
+                        j_max=input_parameter.max_jerk[dof],
+                    )
+                    found_profile = step1_p3.get_profile(p, self._blocks[dof])
+                elif not math.isinf(input_parameter.max_acceleration[dof]):
+                    # MARK: - P-SecondOrderStep1
+                    step1_p2 = PositionSecondOrderStep1(
+                        p0=p.p[0],
+                        v0=p.v[0],
+                        pf=p.pf,
+                        vf=p.vf,
+                        v_max=input_parameter.max_velocity[dof],
+                        v_min=self._inp_min_velocity[dof],
+                        a_max=input_parameter.max_acceleration[dof],
+                        a_min=self._inp_min_acceleration[dof],
+                    )
+                    found_profile = step1_p2.get_profile(p, self._blocks[dof])
+                else:
+                    # MARK: - P-FirstOrderStep1
+                    step1_p1 = PositionFirstOrderStep1(
+                        p0=p.p[0],
+                        pf=p.pf,
+                        v_max=input_parameter.max_velocity[dof],
+                        v_min=self._inp_min_velocity[dof],
+                    )
+                    found_profile = step1_p1.get_profile(p, self._blocks[dof])
+            else:  # ControlInterface.VELOCITY
+                if not math.isinf(input_parameter.max_jerk[dof]):
+                    # MARK: - V-ThirdOrderStep1
+                    step1_v3 = VelocityThirdOrderStep1(
+                        v0=p.v[0],
+                        a0=p.a[0],
+                        vf=p.vf,
+                        af=p.af,
+                        a_max=input_parameter.max_acceleration[dof],
+                        a_min=self._inp_min_acceleration[dof],
+                        j_max=input_parameter.max_jerk[dof],
+                    )
+                    found_profile = step1_v3.get_profile(p, self._blocks[dof])
+                else:
+                    # MARK: - V-SecondOrderStep1
+                    step1_v2 = VelocitySecondOrderStep1(
+                        v0=p.v[0],
+                        vf=p.vf,
+                        a_max=input_parameter.max_acceleration[dof],
+                        a_min=self._inp_min_acceleration[dof],
+                    )
+                    found_profile = step1_v2.get_profile(p, self._blocks[dof])
+
+            if not found_profile:
+                has_zero_limits = (
+                    input_parameter.max_acceleration[dof] == 0.0
+                    or self._inp_min_acceleration[dof] == 0.0
+                    or input_parameter.max_jerk[dof] == 0.0
+                )
+                if has_zero_limits:
+                    return Result.ERROR_ZERO_LIMITS
+                return Result.ERROR_EXECUTION_TIME_CALCULATION
+
+            trajectory.independent_min_durations[dof] = self._blocks[dof].t_min
+            trajectory.profiles[0][dof] = p
+
+        discrete_duration = (
+            input_parameter.duration_discretization == DurationDiscretization.DISCRETE
+        )
+        if dofs == 1 and input_parameter.minimum_duration is None and not discrete_duration:
+            trajectory.duration = self._blocks[0].t_min
+            trajectory.profiles[0][0] = copy.deepcopy(self._blocks[0].p_min)
+            trajectory.cumulative_times[0] = trajectory.duration
+            return Result.WORKING
+
+        limiting_dof: int | None = None  # The DoF that doesn't need step 2.
+        found_synchronization, t_sync, limiting_dof = self._synchronize(
+            input_parameter.minimum_duration,
+            trajectory.profiles[0],
+            discrete_duration,
+            delta_time,
+        )
+        if found_synchronization:
+            trajectory.duration = t_sync
+
+        if not found_synchronization:
+            has_zero_limits = False
+            for dof in range(dofs):
+                if (
+                    input_parameter.max_acceleration[dof] == 0.0
+                    or self._inp_min_acceleration[dof] == 0.0
+                    or input_parameter.max_jerk[dof] == 0.0
+                ):
+                    has_zero_limits = True
+                    break
+
+            if has_zero_limits:
+                return Result.ERROR_ZERO_LIMITS
+            return Result.ERROR_SYNCHRONIZATION_CALCULATION
+
+        # None Synchronization.
+        for dof in range(dofs):
+            if (
+                input_parameter.enabled[dof]
+                and self._inp_per_dof_synchronization[dof] == Synchronization.NONE
+            ):
+                trajectory.profiles[0][dof] = copy.deepcopy(self._blocks[dof].p_min)
+                if self._blocks[dof].t_min > trajectory.duration:
+                    trajectory.duration = self._blocks[dof].t_min
+                    limiting_dof = dof
+        trajectory.cumulative_times[0] = trajectory.duration
+
+        if _RETURN_ERROR_AT_MAXIMAL_DURATION and trajectory.duration > _MAX_DURATION:
+            return Result.ERROR_TRAJECTORY_DURATION
+
+        if trajectory.duration == 0.0:
+            # Copy all profiles for end state.
+            for dof in range(dofs):
+                trajectory.profiles[0][dof] = copy.deepcopy(self._blocks[dof].p_min)
+            return Result.WORKING
+
+        if not discrete_duration and all(
+            sync == Synchronization.NONE for sync in self._inp_per_dof_synchronization
+        ):
+            return Result.WORKING
+
+        # Phase Synchronization.
+        if limiting_dof is not None and Synchronization.PHASE in self._inp_per_dof_synchronization:
+            p_limiting = trajectory.profiles[0][limiting_dof]
+            if self._is_input_collinear(input_parameter, p_limiting.direction, limiting_dof):
+                found_time_synchronization = True
+                for dof in range(dofs):
+                    if (
+                        not input_parameter.enabled[dof]
+                        or dof == limiting_dof
+                        or self._inp_per_dof_synchronization[dof] != Synchronization.PHASE
+                    ):
+                        continue
+
+                    p = trajectory.profiles[0][dof]
+                    t_profile = trajectory.duration - p.brake.duration - p.accel.duration
+
+                    p.t = list(p_limiting.t)  # Copy timing information from limiting DoF.
+                    p.control_signs = p_limiting.control_signs
+
+                    # ReachedLimits.NONE is a small hack, as there is no
+                    # specialization for that in the check function.
+                    if found_time_synchronization:
+                        dof_control_interface = self._inp_per_dof_control_interface[dof]
+                        j_max_dof = input_parameter.max_jerk[dof]
+                        a_max_dof = input_parameter.max_acceleration[dof]
+                        a_min_dof = self._inp_min_acceleration[dof]
+                        v_max_dof = input_parameter.max_velocity[dof]
+                        v_min_dof = self._inp_min_velocity[dof]
+                        phase_control = self._new_phase_control[dof]
+
+                        if dof_control_interface == ControlInterface.POSITION:
+                            if p.control_signs == ControlSigns.UDDU:
+                                if not math.isinf(j_max_dof):
+                                    ok = p.check_with_timing(
+                                        t_profile,
+                                        phase_control,
+                                        v_max_dof,
+                                        v_min_dof,
+                                        a_max_dof,
+                                        a_min_dof,
+                                        ControlSigns.UDDU,
+                                        ReachedLimits.NONE,
+                                        j_max=j_max_dof,
+                                    )
+                                elif not math.isinf(a_max_dof):
+                                    ok = p.check_for_second_order_with_timing(
+                                        t_profile,
+                                        phase_control,
+                                        -phase_control,
+                                        v_max_dof,
+                                        v_min_dof,
+                                        ControlSigns.UDDU,
+                                        ReachedLimits.NONE,
+                                        a_max=a_max_dof,
+                                        a_min=a_min_dof,
+                                    )
+                                else:
+                                    ok = p.check_for_first_order_with_timing(
+                                        t_profile,
+                                        phase_control,
+                                        ControlSigns.UDDU,
+                                        ReachedLimits.NONE,
+                                        v_max=v_max_dof,
+                                        v_min=v_min_dof,
+                                    )
+                            else:  # UDUD
+                                if not math.isinf(j_max_dof):
+                                    ok = p.check_with_timing(
+                                        t_profile,
+                                        phase_control,
+                                        v_max_dof,
+                                        v_min_dof,
+                                        a_max_dof,
+                                        a_min_dof,
+                                        ControlSigns.UDUD,
+                                        ReachedLimits.NONE,
+                                        j_max=j_max_dof,
+                                    )
+                                else:
+                                    ok = p.check_for_second_order_with_timing(
+                                        t_profile,
+                                        phase_control,
+                                        -phase_control,
+                                        v_max_dof,
+                                        v_min_dof,
+                                        ControlSigns.UDUD,
+                                        ReachedLimits.NONE,
+                                        a_max=a_max_dof,
+                                        a_min=a_min_dof,
+                                    )
+                        else:  # ControlInterface.VELOCITY
+                            if p.control_signs == ControlSigns.UDDU:
+                                if not math.isinf(j_max_dof):
+                                    ok = p.check_for_velocity_with_timing(
+                                        t_profile,
+                                        phase_control,
+                                        a_max_dof,
+                                        a_min_dof,
+                                        ControlSigns.UDDU,
+                                        ReachedLimits.NONE,
+                                        j_max=j_max_dof,
+                                    )
+                                else:
+                                    ok = p.check_for_second_order_velocity_with_timing(
+                                        t_profile,
+                                        phase_control,
+                                        ControlSigns.UDDU,
+                                        ReachedLimits.NONE,
+                                        a_max=a_max_dof,
+                                        a_min=a_min_dof,
+                                    )
+                            else:  # UDUD
+                                if not math.isinf(j_max_dof):
+                                    ok = p.check_for_velocity_with_timing(
+                                        t_profile,
+                                        phase_control,
+                                        a_max_dof,
+                                        a_min_dof,
+                                        ControlSigns.UDUD,
+                                        ReachedLimits.NONE,
+                                        j_max=j_max_dof,
+                                    )
+                                else:
+                                    ok = p.check_for_second_order_velocity_with_timing(
+                                        t_profile,
+                                        phase_control,
+                                        ControlSigns.UDUD,
+                                        ReachedLimits.NONE,
+                                        a_max=a_max_dof,
+                                        a_min=a_min_dof,
+                                    )
+
+                        found_time_synchronization = found_time_synchronization and ok
+
+                    p.limits = p_limiting.limits  # After check method call, to set correct limits.
+                    trajectory.profiles[0][dof] = p
+
+                if found_time_synchronization and all(
+                    sync in (Synchronization.PHASE, Synchronization.NONE)
+                    for sync in self._inp_per_dof_synchronization
+                ):
+                    return Result.WORKING
+
+        # Time Synchronization.
+        for dof in range(dofs):
+            dof_sync = self._inp_per_dof_synchronization[dof]
+            skip_synchronization = (
+                dof == limiting_dof or dof_sync == Synchronization.NONE
+            ) and not discrete_duration
+            if not input_parameter.enabled[dof] or skip_synchronization:
+                continue
+
+            p = trajectory.profiles[0][dof]
+            t_profile = trajectory.duration - p.brake.duration - p.accel.duration
+
+            if (
+                self._inp_per_dof_synchronization[dof] == Synchronization.TIME_IF_NECESSARY
+                and abs(input_parameter.target_velocity[dof]) < _EPS
+                and abs(input_parameter.target_acceleration[dof]) < _EPS
+            ):
+                trajectory.profiles[0][dof] = copy.deepcopy(self._blocks[dof].p_min)
+                continue
+
+            # Check if the final time corresponds to an extremal profile
+            # calculated in step 1. Use 2*eps because of numerical
+            # robustness in duration discretization.
+            block = self._blocks[dof]
+            if abs(t_profile - block.t_min) < 2 * _EPS:
+                trajectory.profiles[0][dof] = copy.deepcopy(block.p_min)
+                continue
+            block_a, block_b = block.a, block.b
+            if block_a is not None and block_a.profile is not None:
+                if abs(t_profile - block_a.right) < 2 * _EPS:
+                    trajectory.profiles[0][dof] = copy.deepcopy(block_a.profile)
+                    continue
+            if block_b is not None and block_b.profile is not None:
+                if abs(t_profile - block_b.right) < 2 * _EPS:
+                    trajectory.profiles[0][dof] = copy.deepcopy(block_b.profile)
+                    continue
+
+            found_time_synchronization = False
+            control_interface = self._inp_per_dof_control_interface[dof]
+            if control_interface == ControlInterface.POSITION:
+                if not math.isinf(input_parameter.max_jerk[dof]):
+                    # MARK: - P-ThirdOrderStep2
+                    step2_p3 = PositionThirdOrderStep2(
+                        t_profile,
+                        p.p[0],
+                        p.v[0],
+                        p.a[0],
+                        p.pf,
+                        p.vf,
+                        p.af,
+                        input_parameter.max_velocity[dof],
+                        self._inp_min_velocity[dof],
+                        input_parameter.max_acceleration[dof],
+                        self._inp_min_acceleration[dof],
+                        input_parameter.max_jerk[dof],
+                    )
+                    found_time_synchronization = step2_p3.get_profile(p)
+                elif not math.isinf(input_parameter.max_acceleration[dof]):
+                    # MARK: - P-SecondOrderStep2
+                    step2_p2 = PositionSecondOrderStep2(
+                        t_profile,
+                        p.p[0],
+                        p.v[0],
+                        p.pf,
+                        p.vf,
+                        input_parameter.max_velocity[dof],
+                        self._inp_min_velocity[dof],
+                        input_parameter.max_acceleration[dof],
+                        self._inp_min_acceleration[dof],
+                    )
+                    found_time_synchronization = step2_p2.get_profile(p)
+                else:
+                    # MARK: - P-FirstOrderStep2
+                    step2_p1 = PositionFirstOrderStep2(
+                        tf=t_profile,
+                        p0=p.p[0],
+                        pf=p.pf,
+                        v_max=input_parameter.max_velocity[dof],
+                        v_min=self._inp_min_velocity[dof],
+                    )
+                    found_time_synchronization = step2_p1.get_profile(profile=p)
+            else:  # ControlInterface.VELOCITY
+                if not math.isinf(input_parameter.max_jerk[dof]):
+                    # MARK: - V-ThirdOrderStep2
+                    step2_v3 = VelocityThirdOrderStep2(
+                        tf=t_profile,
+                        v0=p.v[0],
+                        a0=p.a[0],
+                        vf=p.vf,
+                        af=p.af,
+                        a_max=input_parameter.max_acceleration[dof],
+                        a_min=self._inp_min_acceleration[dof],
+                        j_max=input_parameter.max_jerk[dof],
+                    )
+                    found_time_synchronization = step2_v3.get_profile(p)
+                else:
+                    # MARK: - V-SecondOrderStep2
+                    step2_v2 = VelocitySecondOrderStep2(
+                        tf=t_profile,
+                        v0=p.v[0],
+                        vf=p.vf,
+                        a_max=input_parameter.max_acceleration[dof],
+                        a_min=self._inp_min_acceleration[dof],
+                    )
+                    found_time_synchronization = step2_v2.get_profile(p)
+
+            if not found_time_synchronization:
+                return Result.ERROR_SYNCHRONIZATION_CALCULATION
+
+            trajectory.profiles[0][dof] = p
+
+        return Result.WORKING
diff --git a/src/math_tools/otg/enums.py b/src/math_tools/otg/enums.py
new file mode 100644
index 0000000..6aa6f07
--- /dev/null
+++ b/src/math_tools/otg/enums.py
@@ -0,0 +1,124 @@
+"""Enums for the OTG (online trajectory generation) subsystem.
+
+Faithful port of ``SWIFT_MATH/OTG/enums/*.swift``. See
+``.claude/specs/otg.md`` §Public API and §Internal fidelity requirements.
+
+``Result`` is wire-stable (Ruckig parity): its integer values, including the
+intentional gap at -103 (``ErrorNoPhaseSynchronization``, commented out in
+the Swift source and never a valid member here), MUST NOT change.
+
+``ControlInterface``, ``Synchronization``, and ``DurationDiscretization`` are
+public string enums (Swift ``Codable`` raw values, transcribed verbatim for
+``to_dict``/``from_dict`` wire parity). ``ControlSigns``, ``Direction``, and
+``ReachedLimits`` are internal (Swift ``internal`` visibility) -- they are
+defined here but excluded from ``__all__``.
+"""
+
+from __future__ import annotations
+
+import enum
+
+__all__ = [
+    "ControlInterface",
+    "DurationDiscretization",
+    "Result",
+    "Synchronization",
+]
+
+
+class Result(enum.IntEnum):
+    """Result of one ``Otg.update``/``Otg.calculate`` cycle (Ruckig parity)."""
+
+    WORKING = 0
+    """The trajectory is calculated normally."""
+
+    FINISHED = 1
+    """The trajectory has reached its final position."""
+
+    ERROR = -1
+    """Unclassified error."""
+
+    ERROR_INVALID_INPUT = -100
+    """Error in the input parameter."""
+
+    ERROR_TRAJECTORY_DURATION = -101
+    """The trajectory duration exceeds its numerical limits."""
+
+    ERROR_POSITIONAL_LIMITS = -102
+    """The trajectory exceeds the given positional limits (Ruckig Pro only)."""
+
+    # -103 is intentionally unassigned: Swift's ErrorNoPhaseSynchronization is
+    # commented out in the source (Ruckig Pro only feature, never shipped in
+    # the ported subsystem). The gap is real and MUST NOT be filled in.
+
+    ERROR_ZERO_LIMITS = -104
+    """The trajectory is not valid due to a conflict with zero limits."""
+
+    ERROR_EXECUTION_TIME_CALCULATION = -110
+    """Error during the extremal time calculation (Step 1)."""
+
+    ERROR_SYNCHRONIZATION_CALCULATION = -111
+    """Error during the synchronization calculation (Step 2)."""
+
+
+class ControlInterface(str, enum.Enum):
+    """Kinematic control interface for a DOF."""
+
+    POSITION = "Position"
+    """Position-control: full control over the entire kinematic state (default)."""
+
+    VELOCITY = "Velocity"
+    """Velocity-control: ignores current/target position and velocity limits."""
+
+
+class Synchronization(str, enum.Enum):
+    """DOF synchronization strategy for the trajectory calculation."""
+
+    TIME = "Time"
+    """Always synchronize the DOFs to reach the target at the same time (default)."""
+
+    TIME_IF_NECESSARY = "TimeIfNecessary"
+    """Synchronize only when necessary (e.g. non-zero target velocity/acceleration)."""
+
+    PHASE = "Phase"
+    """Phase synchronize the DOFs when possible, else fall back to ``TIME``."""
+
+    NONE = "None"
+    """Calculate every DOF independently."""
+
+
+class DurationDiscretization(str, enum.Enum):
+    """Discretization policy for the synchronized trajectory duration."""
+
+    CONTINUOUS = "Continuous"
+    """Every trajectory synchronization duration is allowed (default)."""
+
+    DISCRETE = "Discrete"
+    """The trajectory synchronization duration must be a multiple of the control cycle."""
+
+
+class ControlSigns(str, enum.Enum):
+    """Internal: sign pattern of a per-DOF jerk profile (up-down vs. up-down-up-down)."""
+
+    UDDU = "UDDU"
+    UDUD = "UDUD"
+
+
+class Direction(str, enum.Enum):
+    """Internal: net direction of a per-DOF profile."""
+
+    UP = "UP"
+    DOWN = "DOWN"
+
+
+class ReachedLimits(str, enum.Enum):
+    """Internal: which kinematic limits a per-DOF profile saturates."""
+
+    ACC0_ACC1_VEL = "ACC0_ACC1_VEL"
+    VEL = "VEL"
+    ACC0 = "ACC0"
+    ACC1 = "ACC1"
+    ACC0_ACC1 = "ACC0_ACC1"
+    ACC0_VEL = "ACC0_VEL"
+    ACC1_VEL = "ACC1_VEL"
+    NONE = "NONE"
diff --git a/src/math_tools/otg/errors.py b/src/math_tools/otg/errors.py
new file mode 100644
index 0000000..f89c06b
--- /dev/null
+++ b/src/math_tools/otg/errors.py
@@ -0,0 +1,18 @@
+"""Structural-misuse exception for the OTG subsystem.
+
+See ``.claude/specs/otg.md`` §Error semantics: per-cycle failures are
+``Result`` codes, never exceptions (real-time control-loop contract).
+``OtgError`` is the umbrella carve-out -- raised only for structural misuse
+(e.g. mismatched DOF counts between the ``Otg`` driver and its parameters, a
+non-positive ``control_cycle``) where every future cycle would be invalid.
+"""
+
+from __future__ import annotations
+
+from math_tools.errors import MathToolsError
+
+__all__ = ["OtgError"]
+
+
+class OtgError(MathToolsError):
+    """Raised for structural misuse of the OTG driver, never per-cycle failures."""
diff --git a/src/math_tools/otg/input_parameter.py b/src/math_tools/otg/input_parameter.py
new file mode 100644
index 0000000..a3c43bb
--- /dev/null
+++ b/src/math_tools/otg/input_parameter.py
@@ -0,0 +1,419 @@
+"""Per-cycle input parameter for the OTG subsystem.
+
+Field-for-field port of ``SWIFT_MATH/OTG/InputParameter.swift`` (state,
+limits, and ``validate``) plus the wire codec from
+``SWIFT_MATH/OTG/extensions/InputParameter+codable.swift``. See
+``.claude/specs/otg.md`` §Public API (InputParameter) and
+``.claude/action-plan/32-otg-input-parameter.md``.
+
+Deviation from the Swift source: ``validate`` returns ``bool`` instead of
+throwing (``otg.md`` §Error semantics -- per-cycle failures are never
+exceptions in this port), so the private helpers below return ``False`` at
+the first violation instead of raising ``RuckigError`` with a message.
+"""
+
+from __future__ import annotations
+
+import math
+from typing import Any
+
+from math_tools.otg.enums import (
+    ControlInterface,
+    DurationDiscretization,
+    Synchronization,
+)
+
+__all__ = ["InputParameter"]
+
+
+class InputParameter:
+    """Mutable per-cycle input: kinematic state, limits, and DOF config.
+
+    Construct with :class:`InputParameter` ``(dofs)``; all arrays are sized
+    to ``dofs`` and filled with the Swift defaults. Never numpy-backed
+    (``otg.md`` §Internal fidelity requirement 5).
+    """
+
+    def __init__(self, dofs: int) -> None:
+        if dofs <= 0:
+            raise ValueError(f"degrees of freedom must be positive, got {dofs}")
+
+        self.degrees_of_freedom = dofs
+
+        # Control configuration
+        self.control_interface: ControlInterface = ControlInterface.POSITION
+        self.synchronization: Synchronization = Synchronization.TIME
+        self.duration_discretization: DurationDiscretization = DurationDiscretization.CONTINUOUS
+
+        # Current kinematic state
+        self.current_position: list[float] = [0.0] * dofs
+        self.current_velocity: list[float] = [0.0] * dofs
+        self.current_acceleration: list[float] = [0.0] * dofs
+
+        # Target kinematic state
+        self.target_position: list[float] = [0.0] * dofs
+        self.target_velocity: list[float] = [0.0] * dofs
+        self.target_acceleration: list[float] = [0.0] * dofs
+
+        # Global limits
+        self.max_velocity: list[float] = [0.0] * dofs
+        self.max_acceleration: list[float] = [math.inf] * dofs
+        self.max_jerk: list[float] = [math.inf] * dofs
+        self.min_velocity: list[float] | None = None
+        self.min_acceleration: list[float] | None = None
+        self.max_position: list[float] | None = None
+        self.min_position: list[float] | None = None
+
+        # Per-section constraints
+        self.intermediate_positions: list[list[float]] = []
+        self.per_section_max_velocity: list[list[float]] | None = None
+        self.per_section_max_acceleration: list[list[float]] | None = None
+        self.per_section_max_jerk: list[list[float]] | None = None
+        self.per_section_min_velocity: list[list[float]] | None = None
+        self.per_section_min_acceleration: list[list[float]] | None = None
+        self.per_section_max_position: list[list[float]] | None = None
+        self.per_section_min_position: list[list[float]] | None = None
+
+        # DOF-specific configuration
+        self.enabled: list[bool] = [True] * dofs
+        self.per_dof_control_interface: list[ControlInterface] | None = None
+        self.per_dof_synchronization: list[Synchronization] | None = None
+
+        # Duration constraints
+        self.minimum_duration: float | None = None
+        self.per_section_minimum_duration: list[float] | None = None
+        self.interrupt_calculation_duration: float | None = None
+
+    # MARK: - Validation
+
+    def validate(
+        self,
+        check_current_state_within_limits: bool = False,
+        check_target_state_within_limits: bool = True,
+    ) -> bool:
+        """Validate limits and kinematic state; never raises.
+
+        Args:
+            check_current_state_within_limits: also validate the current
+                kinematic state against velocity/acceleration limits.
+            check_target_state_within_limits: also validate the target
+                kinematic state against velocity/acceleration limits
+                (default ``True``, matching Swift).
+
+        Returns:
+            ``True`` iff every check passes.
+        """
+        if not self._validate_jerk_limits():
+            return False
+        if not self._validate_acceleration_limits(
+            check_current_state_within_limits, check_target_state_within_limits
+        ):
+            return False
+        if not self._validate_velocity_limits(
+            check_current_state_within_limits, check_target_state_within_limits
+        ):
+            return False
+        if not self._validate_position_limits():
+            return False
+        return self._validate_intermediate_positions()
+
+    def _validate_jerk_limits(self) -> bool:
+        for j_max in self.max_jerk:
+            if math.isnan(j_max) or j_max < 0.0:
+                return False
+        return True
+
+    def _validate_acceleration_limits(self, check_current: bool, check_target: bool) -> bool:
+        for dof in range(self.degrees_of_freedom):
+            a_max = self.max_acceleration[dof]
+            if math.isnan(a_max) or a_max < 0.0:
+                return False
+
+            a_min = self.min_acceleration[dof] if self.min_acceleration is not None else -a_max
+            if math.isnan(a_min) or a_min > 0.0:
+                return False
+
+            a0 = self.current_acceleration[dof]
+            if math.isnan(a0):
+                return False
+
+            af = self.target_acceleration[dof]
+            if math.isnan(af):
+                return False
+
+            if check_current and (a0 > a_max or a0 < a_min):
+                return False
+
+            if check_target and (af > a_max or af < a_min):
+                return False
+
+        return True
+
+    def _validate_velocity_limits(self, check_current: bool, check_target: bool) -> bool:
+        for dof in range(self.degrees_of_freedom):
+            v0 = self.current_velocity[dof]
+            if math.isnan(v0):
+                return False
+
+            vf = self.target_velocity[dof]
+            if math.isnan(vf):
+                return False
+
+            if self._control_interface_for(dof) != ControlInterface.POSITION:
+                continue
+
+            v_max = self.max_velocity[dof]
+            if math.isnan(v_max) or v_max < 0.0:
+                return False
+
+            v_min = self.min_velocity[dof] if self.min_velocity is not None else -v_max
+            if math.isnan(v_min) or v_min > 0.0:
+                return False
+
+            if check_current and not self._check_current_velocity(dof, v0, v_max, v_min):
+                return False
+
+            if check_target and not self._check_target_velocity(dof, vf, v_max, v_min):
+                return False
+
+        return True
+
+    def _check_current_velocity(self, dof: int, v0: float, v_max: float, v_min: float) -> bool:
+        if v0 > v_max or v0 < v_min:
+            return False
+
+        a0 = self.current_acceleration[dof]
+        j_max = self.max_jerk[dof]
+        if a0 > 0 and j_max > 0:
+            if _velocity_at_acceleration_zero(v0, a0, j_max) > v_max:
+                return False
+        if a0 < 0 and j_max > 0:
+            if _velocity_at_acceleration_zero(v0, a0, -j_max) < v_min:
+                return False
+        return True
+
+    def _check_target_velocity(self, dof: int, vf: float, v_max: float, v_min: float) -> bool:
+        if vf > v_max or vf < v_min:
+            return False
+
+        af = self.target_acceleration[dof]
+        j_max = self.max_jerk[dof]
+        if af < 0 and j_max > 0:
+            if _velocity_at_acceleration_zero(vf, af, j_max) > v_max:
+                return False
+        if af > 0 and j_max > 0:
+            if _velocity_at_acceleration_zero(vf, af, -j_max) < v_min:
+                return False
+        return True
+
+    def _validate_position_limits(self) -> bool:
+        for dof in range(self.degrees_of_freedom):
+            if self._control_interface_for(dof) != ControlInterface.POSITION:
+                continue
+            if math.isnan(self.current_position[dof]):
+                return False
+            if math.isnan(self.target_position[dof]):
+                return False
+        return True
+
+    def _validate_intermediate_positions(self) -> bool:
+        if not self.intermediate_positions or self.control_interface != ControlInterface.POSITION:
+            return True
+
+        duration_is_continuous = self.duration_discretization == DurationDiscretization.CONTINUOUS
+        if self.minimum_duration is not None or not duration_is_continuous:
+            return False
+
+        if self.per_dof_control_interface is not None or self.per_dof_synchronization is not None:
+            return False
+
+        for j_max in self.max_jerk:
+            if math.isinf(j_max):
+                return False
+
+        return True
+
+    def _control_interface_for(self, dof: int) -> ControlInterface:
+        if self.per_dof_control_interface is not None:
+            return self.per_dof_control_interface[dof]
+        return self.control_interface
+
+    # MARK: - Equality
+
+    def __eq__(self, other: object) -> bool:
+        """Full field equality."""
+        if not isinstance(other, InputParameter):
+            return NotImplemented
+        return (
+            self.degrees_of_freedom == other.degrees_of_freedom
+            and self.control_interface == other.control_interface
+            and self.synchronization == other.synchronization
+            and self.duration_discretization == other.duration_discretization
+            and self.current_position == other.current_position
+            and self.current_velocity == other.current_velocity
+            and self.current_acceleration == other.current_acceleration
+            and self.target_position == other.target_position
+            and self.target_velocity == other.target_velocity
+            and self.target_acceleration == other.target_acceleration
+            and self.max_velocity == other.max_velocity
+            and self.max_acceleration == other.max_acceleration
+            and self.max_jerk == other.max_jerk
+            and self.min_velocity == other.min_velocity
+            and self.min_acceleration == other.min_acceleration
+            and self.max_position == other.max_position
+            and self.min_position == other.min_position
+            and self.intermediate_positions == other.intermediate_positions
+            and self.per_section_max_velocity == other.per_section_max_velocity
+            and self.per_section_max_acceleration == other.per_section_max_acceleration
+            and self.per_section_max_jerk == other.per_section_max_jerk
+            and self.per_section_min_velocity == other.per_section_min_velocity
+            and self.per_section_min_acceleration == other.per_section_min_acceleration
+            and self.per_section_max_position == other.per_section_max_position
+            and self.per_section_min_position == other.per_section_min_position
+            and self.enabled == other.enabled
+            and self.per_dof_control_interface == other.per_dof_control_interface
+            and self.per_dof_synchronization == other.per_dof_synchronization
+            and self.minimum_duration == other.minimum_duration
+            and self.per_section_minimum_duration == other.per_section_minimum_duration
+            and self.interrupt_calculation_duration == other.interrupt_calculation_duration
+        )
+
+    # MARK: - Codec
+
+    def to_dict(self) -> dict[str, Any]:
+        """Serialize to the camelCase wire format (Swift ``Codable`` parity).
+
+        Optional (``None``) fields are omitted, mirroring the Swift
+        ``encodeIfPresent`` calls in ``InputParameter+codable.swift``.
+        """
+        data: dict[str, Any] = {
+            "degreesOfFreedom": self.degrees_of_freedom,
+            "controlInterface": self.control_interface.value,
+            "synchronization": self.synchronization.value,
+            "durationDiscretization": self.duration_discretization.value,
+            "currentPosition": list(self.current_position),
+            "currentVelocity": list(self.current_velocity),
+            "currentAcceleration": list(self.current_acceleration),
+            "targetPosition": list(self.target_position),
+            "targetVelocity": list(self.target_velocity),
+            "targetAcceleration": list(self.target_acceleration),
+            "intermediatePositions": [list(p) for p in self.intermediate_positions],
+            "enabled": list(self.enabled),
+            "maxVelocity": list(self.max_velocity),
+            "maxAcceleration": list(self.max_acceleration),
+            "maxJerk": list(self.max_jerk),
+        }
+
+        if self.min_velocity is not None:
+            data["minVelocity"] = list(self.min_velocity)
+        if self.min_acceleration is not None:
+            data["minAcceleration"] = list(self.min_acceleration)
+
+        if self.per_section_max_velocity is not None:
+            data["perSectionMaxVelocity"] = [list(s) for s in self.per_section_max_velocity]
+        if self.per_section_max_acceleration is not None:
+            data["perSectionMaxAcceleration"] = [list(s) for s in self.per_section_max_acceleration]
+        if self.per_section_max_jerk is not None:
+            data["perSectionMaxJerk"] = [list(s) for s in self.per_section_max_jerk]
+        if self.per_section_min_velocity is not None:
+            data["perSectionMinVelocity"] = [list(s) for s in self.per_section_min_velocity]
+        if self.per_section_min_acceleration is not None:
+            data["perSectionMinAcceleration"] = [list(s) for s in self.per_section_min_acceleration]
+        if self.per_section_max_position is not None:
+            data["perSectionMaxPosition"] = [list(s) for s in self.per_section_max_position]
+        if self.per_section_min_position is not None:
+            data["perSectionMinPosition"] = [list(s) for s in self.per_section_min_position]
+
+        if self.max_position is not None:
+            data["maxPosition"] = list(self.max_position)
+        if self.min_position is not None:
+            data["minPosition"] = list(self.min_position)
+
+        if self.per_dof_control_interface is not None:
+            data["perDofControlInterface"] = [ci.value for ci in self.per_dof_control_interface]
+        if self.per_dof_synchronization is not None:
+            data["perDofSynchronization"] = [sync.value for sync in self.per_dof_synchronization]
+
+        if self.minimum_duration is not None:
+            data["minimumDuration"] = self.minimum_duration
+        if self.per_section_minimum_duration is not None:
+            data["perSectionMinimumDuration"] = list(self.per_section_minimum_duration)
+        if self.interrupt_calculation_duration is not None:
+            data["interruptCalculationDuration"] = self.interrupt_calculation_duration
+
+        return data
+
+    @classmethod
+    def from_dict(cls, data: dict[str, Any]) -> InputParameter:
+        """Deserialize from the camelCase wire format.
+
+        Unknown keys (e.g. the classification corpus' ``"error"`` field on
+        failed cases, otg.md §Oracle and test strategy) are ignored.
+        """
+        inst = cls(int(data["degreesOfFreedom"]))
+
+        inst.control_interface = ControlInterface(data["controlInterface"])
+        inst.synchronization = Synchronization(data["synchronization"])
+        inst.duration_discretization = DurationDiscretization(data["durationDiscretization"])
+
+        inst.current_position = list(data["currentPosition"])
+        inst.current_velocity = list(data["currentVelocity"])
+        inst.current_acceleration = list(data["currentAcceleration"])
+        inst.target_position = list(data["targetPosition"])
+        inst.target_velocity = list(data["targetVelocity"])
+        inst.target_acceleration = list(data["targetAcceleration"])
+
+        inst.intermediate_positions = [list(p) for p in data["intermediatePositions"]]
+        inst.enabled = list(data["enabled"])
+
+        inst.max_velocity = list(data["maxVelocity"])
+        inst.max_acceleration = list(data["maxAcceleration"])
+        inst.max_jerk = list(data["maxJerk"])
+
+        if "minVelocity" in data:
+            inst.min_velocity = list(data["minVelocity"])
+        if "minAcceleration" in data:
+            inst.min_acceleration = list(data["minAcceleration"])
+
+        if "perSectionMaxVelocity" in data:
+            inst.per_section_max_velocity = [list(s) for s in data["perSectionMaxVelocity"]]
+        if "perSectionMaxAcceleration" in data:
+            inst.per_section_max_acceleration = [list(s) for s in data["perSectionMaxAcceleration"]]
+        if "perSectionMaxJerk" in data:
+            inst.per_section_max_jerk = [list(s) for s in data["perSectionMaxJerk"]]
+        if "perSectionMinVelocity" in data:
+            inst.per_section_min_velocity = [list(s) for s in data["perSectionMinVelocity"]]
+        if "perSectionMinAcceleration" in data:
+            inst.per_section_min_acceleration = [list(s) for s in data["perSectionMinAcceleration"]]
+        if "perSectionMaxPosition" in data:
+            inst.per_section_max_position = [list(s) for s in data["perSectionMaxPosition"]]
+        if "perSectionMinPosition" in data:
+            inst.per_section_min_position = [list(s) for s in data["perSectionMinPosition"]]
+
+        if "maxPosition" in data:
+            inst.max_position = list(data["maxPosition"])
+        if "minPosition" in data:
+            inst.min_position = list(data["minPosition"])
+
+        if "perDofControlInterface" in data:
+            inst.per_dof_control_interface = [
+                ControlInterface(v) for v in data["perDofControlInterface"]
+            ]
+        if "perDofSynchronization" in data:
+            inst.per_dof_synchronization = [
+                Synchronization(v) for v in data["perDofSynchronization"]
+            ]
+
+        if "minimumDuration" in data:
+            inst.minimum_duration = float(data["minimumDuration"])
+        if "perSectionMinimumDuration" in data:
+            inst.per_section_minimum_duration = list(data["perSectionMinimumDuration"])
+        if "interruptCalculationDuration" in data:
+            inst.interrupt_calculation_duration = float(data["interruptCalculationDuration"])
+
+        return inst
+
+
+def _velocity_at_acceleration_zero(v0: float, a0: float, j: float) -> float:
+    """Velocity reached when acceleration decays to zero under jerk ``j``."""
+    return v0 + (a0 * a0) / (2 * j)
diff --git a/src/math_tools/otg/otg.py b/src/math_tools/otg/otg.py
new file mode 100644
index 0000000..22c96e3
--- /dev/null
+++ b/src/math_tools/otg/otg.py
@@ -0,0 +1,182 @@
+"""``Otg``: the per-cycle trajectory-generation driver.
+
+Faithful port of ``SWIFT_MATH/OTG/spmOTG.swift`` (Swift class ``OTG``). See
+``.claude/specs/otg.md`` §Public API (Otg), §Error semantics, §Compliance 5
+and ``.claude/action-plan/41-otg-driver.md``.
+
+**Deviation from the Swift constructor.** Swift's ``OTG.init`` accepts a
+defaulted ``deltaTime: Double = -1.0`` sentinel and only rejects a
+non-positive value lazily, inside ``validateInput``, and only when
+``durationDiscretization != .Continuous``. This port instead requires
+``control_cycle`` to be positive at construction time and raises
+:class:`~math_tools.otg.errors.OtgError` immediately otherwise (the chunk
+brief: "non-positive control_cycle" is structural misuse -- a condition
+that makes every future cycle invalid). Consequently the Swift
+``deltaTime <= 0.0`` branch inside ``validateInput`` can never fire once
+the constructor's own guard holds, and is not ported here (dead code under
+this port's stricter constructor contract). Likewise, Swift's fixed-size
+arrays make a DOF mismatch between the driver and its per-cycle parameters
+a compile-time impossibility in typical use, so ``OTG.swift`` never checks
+for one; this port adds an explicit runtime check (raising ``OtgError``)
+since Python's lists carry no static size, per the chunk's design
+constraint 1 ("DOF mismatch between constructor and parameters").
+
+**Alias-mutation hazard (otg.md's cross-chunk pattern -- see
+``calculator_target.py``'s module docstring for the fuller treatment).**
+Swift's ``currentInput: InputParameter`` is a struct field, so
+``currentInput = input`` is a value copy. This port's ``InputParameter``
+(chunk 32) is a reference type, so the equivalent assignment goes through
+``copy.deepcopy`` -- a bare ``self._current_input = input_parameter`` would
+alias the caller's own object, and the next cycle's ``input_parameter !=
+self._current_input`` change-detection compare would then always be
+``False`` (an object trivially equals itself) regardless of what the
+caller mutates in between, silently breaking recalculation-on-change.
+
+``filterIntermediatePositions`` is ported nowhere: it is dead code in the
+Swift source too (defined on ``OTG`` but never called from ``calculate``/
+``update``, and not part of otg.md §Public API), so porting it would add
+untested surface outside this chunk's scope.
+
+``interrupt_calculation_duration`` needs no driver-side handling here: it
+is a Swift ``InputParameter`` field read only by the Codable wire format
+(``InputParameter+codable.swift``, ported in chunk 32's ``to_dict``/
+``from_dict``) and never read by ``OTG.swift`` or ``CalculatorTarget.swift``
+-- there is no "interrupt" behavior to port because the Swift source itself
+never implements one against this field.
+"""
+
+from __future__ import annotations
+
+import copy
+import time
+
+from math_tools.functional.roots import integrate_jerk
+from math_tools.otg.calculator_target import TargetCalculator
+from math_tools.otg.enums import ControlInterface, Result
+from math_tools.otg.errors import OtgError
+from math_tools.otg.input_parameter import InputParameter
+from math_tools.otg.output_parameter import OutputParameter
+
+__all__ = ["Otg"]
+
+
+class Otg:
+    """Real-time online trajectory generator: one instance per control loop.
+
+    **Threading contract (Swift parity):** not thread-safe. Designed to be
+    owned exclusively by a single real-time control-loop thread; do not
+    share an instance across threads.
+
+    Construct with :class:`Otg` ``(control_cycle, dofs,
+    max_number_of_waypoints=0)``.
+    """
+
+    def __init__(self, control_cycle: float, dofs: int, max_number_of_waypoints: int = 0) -> None:
+        if control_cycle <= 0.0:
+            raise OtgError(f"control_cycle must be positive, got {control_cycle}")
+        if dofs <= 0:
+            raise OtgError(f"degrees of freedom must be positive, got {dofs}")
+
+        self.degrees_of_freedom = dofs
+        self._control_cycle = control_cycle
+        self._max_number_of_waypoints = max_number_of_waypoints
+
+        self._calculator = TargetCalculator(dofs)
+        self._current_input = InputParameter(dofs)
+        self._current_input_initialized = False
+
+    # MARK: - Structural-misuse guards
+
+    def _check_degrees_of_freedom(
+        self, input_parameter: InputParameter, output: OutputParameter
+    ) -> None:
+        """Raise :class:`OtgError` on a DOF mismatch between this driver
+        and either per-cycle parameter (otg.md §Error semantics: structural
+        misuse, not a per-cycle ``Result`` failure)."""
+        if input_parameter.degrees_of_freedom != self.degrees_of_freedom:
+            raise OtgError(
+                f"InputParameter has {input_parameter.degrees_of_freedom} degrees of "
+                f"freedom, Otg was constructed with {self.degrees_of_freedom}"
+            )
+        if output.degrees_of_freedom != self.degrees_of_freedom:
+            raise OtgError(
+                f"OutputParameter has {output.degrees_of_freedom} degrees of "
+                f"freedom, Otg was constructed with {self.degrees_of_freedom}"
+            )
+
+    # MARK: - Validation
+
+    def _validate_input(self, input_parameter: InputParameter) -> bool:
+        """``validateInput`` -- the OTG-specific waypoint-count check plus
+        ``InputParameter.validate``. Never raises for per-cycle failures
+        (otg.md §Error semantics)."""
+        if (
+            input_parameter.intermediate_positions
+            and input_parameter.control_interface == ControlInterface.POSITION
+            and len(input_parameter.intermediate_positions) > self._max_number_of_waypoints
+        ):
+            return False
+        return input_parameter.validate()
+
+    # MARK: - Public API
+
+    def calculate(self, input_parameter: InputParameter, output: OutputParameter) -> Result:
+        """Full-trajectory calculation, without time stepping."""
+        self._check_degrees_of_freedom(input_parameter, output)
+
+        if not self._validate_input(input_parameter):
+            return Result.ERROR_INVALID_INPUT
+
+        return self._calculator.calculate(input_parameter, output.trajectory, self._control_cycle)
+
+    def update(self, input_parameter: InputParameter, output: OutputParameter) -> Result:
+        """Advance the trajectory by one control cycle (``control_cycle``).
+
+        Validates the input, recalculates the trajectory when the input has
+        changed since the last cycle, steps ``output.time`` forward, and
+        samples the trajectory into ``output.new_*``. Returns ``WORKING``,
+        ``FINISHED``, or an error :class:`~math_tools.otg.enums.Result`
+        (never raises for per-cycle failures).
+        """
+        self._check_degrees_of_freedom(input_parameter, output)
+
+        start = time.perf_counter_ns()
+        output.new_calculation = False
+
+        result = Result.WORKING
+        if not self._current_input_initialized or input_parameter != self._current_input:
+            result = self.calculate(input_parameter, output)
+            if result != Result.WORKING and result != Result.ERROR_POSITIONAL_LIMITS:
+                return result
+
+            self._current_input = copy.deepcopy(input_parameter)
+            self._current_input_initialized = True
+            output.time = 0.0
+            output.new_calculation = True
+
+        old_section = output.new_section
+        output.time += self._control_cycle
+
+        new_section, integrate_args = output.trajectory._state_to_integrate_from(output.time)
+        for dof, (t, p0, v0, a0, j) in enumerate(integrate_args):
+            p, v, a = integrate_jerk(t, p0, v0, a0, j)
+            output.new_position[dof] = p
+            output.new_velocity[dof] = v
+            output.new_acceleration[dof] = a
+            output.new_jerk[dof] = j
+        output.new_section = new_section
+        output.did_section_change = output.new_section > old_section
+
+        stop = time.perf_counter_ns()
+        output.calculation_duration = (stop - start) / 1_000.0
+
+        output.pass_to_input(self._current_input)
+
+        if output.time > output.trajectory.duration:
+            return Result.FINISHED
+        return result
+
+    def reset(self) -> None:
+        """Forget the cached input, forcing a fresh calculation on the next
+        ``update`` call regardless of whether the input has changed."""
+        self._current_input_initialized = False
diff --git a/src/math_tools/otg/output_parameter.py b/src/math_tools/otg/output_parameter.py
new file mode 100644
index 0000000..69479d0
--- /dev/null
+++ b/src/math_tools/otg/output_parameter.py
@@ -0,0 +1,89 @@
+"""Per-cycle output parameter: the calculated trajectory + current kinematic state.
+
+Faithful port of ``SWIFT_MATH/OTG/OutputParameter.swift``. See
+``.claude/specs/otg.md`` §Public API (OutputParameter) and
+``.claude/action-plan/35-otg-trajectory-and-output.md``.
+
+Collapses Swift's two constructor overloads (``init(DOFs:)`` and
+``init(dofs:maxNumberOfWaypoints:)``) into one Python signature,
+``OutputParameter(dofs, max_number_of_waypoints=0)``, matching
+``trajectory.py``'s identical collapse (``max_number_of_waypoints=0``
+already produces the same single-section ``Trajectory`` as the
+no-waypoints overload).
+"""
+
+from __future__ import annotations
+
+from math_tools.otg.input_parameter import InputParameter
+from math_tools.otg.trajectory import Trajectory
+
+__all__ = ["OutputParameter"]
+
+
+class OutputParameter:
+    """Mutable per-cycle output: the calculated ``Trajectory`` plus the
+    current position/velocity/acceleration/jerk and timing/section state.
+
+    Construct with :class:`OutputParameter` ``(dofs,
+    max_number_of_waypoints=0)``.
+    """
+
+    def __init__(self, dofs: int, max_number_of_waypoints: int = 0) -> None:
+        if dofs <= 0:
+            raise ValueError(f"degrees of freedom must be positive, got {dofs}")
+
+        self.degrees_of_freedom = dofs
+        self.trajectory: Trajectory = Trajectory(dofs, max_number_of_waypoints)
+
+        # Current kinematic state.
+        self.new_position: list[float] = [0.0] * dofs
+        self.new_velocity: list[float] = [0.0] * dofs
+        self.new_acceleration: list[float] = [0.0] * dofs
+        self.new_jerk: list[float] = [0.0] * dofs
+
+        # Trajectory state.
+        self.time: float = 0.0
+        self.new_section: int = 0
+
+        # State flags.
+        self.did_section_change: bool = False
+        self.new_calculation: bool = False
+        self.calculation_duration: float = 0.0
+        """Computational duration of the last update call, in microseconds
+        (Swift parity -- otg.md §Public API)."""
+
+    # MARK: - Public methods
+
+    def pass_to_input(self, input_parameter: InputParameter) -> None:
+        """``passToInput`` -- copies this output's current kinematic state
+        into ``input_parameter``'s current state, for trajectory
+        continuation across cycles. If a section change occurred and
+        intermediate positions remain, the first one is removed."""
+        if (
+            len(self.new_position) != self.degrees_of_freedom
+            or len(self.new_velocity) != self.degrees_of_freedom
+            or len(self.new_acceleration) != self.degrees_of_freedom
+        ):
+            raise ValueError("output parameter arrays must match degrees_of_freedom")
+
+        input_parameter.current_position = list(self.new_position)
+        input_parameter.current_velocity = list(self.new_velocity)
+        input_parameter.current_acceleration = list(self.new_acceleration)
+
+        if self.did_section_change and input_parameter.intermediate_positions:
+            input_parameter.intermediate_positions.pop(0)
+
+    # MARK: - String representation
+
+    def __repr__(self) -> str:
+        def fmt(values: list[float]) -> str:
+            return ", ".join(f"{v:.6f}" for v in values)
+
+        return (
+            f"\nout.new_position = [{fmt(self.new_position)}]\n"
+            f"out.new_velocity = [{fmt(self.new_velocity)}]\n"
+            f"out.new_acceleration = [{fmt(self.new_acceleration)}]\n"
+            f"out.new_jerk = [{fmt(self.new_jerk)}]\n"
+            f"out.time = [{self.time:.16f}]\n"
+            f"out.calculation_duration = [{self.calculation_duration:.16f}]\n"
+        )
diff --git a/src/math_tools/otg/profile.py b/src/math_tools/otg/profile.py
new file mode 100644
index 0000000..46dd855
--- /dev/null
+++ b/src/math_tools/otg/profile.py
@@ -0,0 +1,703 @@
+"""Per-DOF kinematic profile: the hot data structure OTG step solvers fill.
+
+Faithful port of ``SWIFT_MATH/OTG/Profile.swift`` (~715 lines; method and
+branch structure preserved mechanically). See ``.claude/specs/otg.md``
+§Internal fidelity requirements 1, 4, 5 and
+``.claude/action-plan/33-otg-profile.md``.
+
+All kinematic stepping goes through
+:func:`math_tools.functional.roots.integrate_jerk` -- never a fresh
+constant-jerk integration (otg.md §Internal fidelity requirement 1). Every
+Swift ``for i in 0..<7`` loop that advances ``p``/``v``/``a`` (with or
+without a nonzero jerk term) is the same closed-form step, so it is ported
+as a call to ``integrate_jerk(t[i], p[i], v[i], a[i], j[i])`` throughout,
+including the "second-order" and "first-order" interfaces where the Swift
+source inlines the ``j == 0`` special case by hand.
+
+``brake``/``accel`` are the real ``math_tools.otg.brake.BrakeProfile``
+(chunk 34, ``otg/brake.py``): chunk 33 originally stood these in with a
+module-private ``_DeferredBrakeProfile`` dataclass because ``brake.py``
+didn't exist yet; chunk 34 landed it and this module now imports the real
+type directly (see ``33-otg-profile.md``'s Resolution notes for the
+original deferral and ``34-otg-block-brake-bound.md``'s Resolution notes
+for the reconciliation).
+
+``check_position_extremum``/``check_step_for_position_extremum``'s ``ext``
+parameter stays typed against the module-private structural
+:class:`~typing.Protocol` :class:`_PositionExtremumSink` (``min``, ``max``,
+``t_min``, ``t_max`` floats) rather than importing
+``math_tools.otg.bound.Bound`` directly -- chunk 34's real ``Bound`` has
+those exact field names (its own design constraint), so it satisfies this
+Protocol structurally without an import edge from this module to
+``bound.py``. ``33-otg-profile.md``'s Resolution notes explicitly permit
+the Protocol to "stay indefinitely"; kept as-is per
+``34-otg-block-brake-bound.md``'s Resolution notes for the same reason.
+"""
+
+from __future__ import annotations
+
+import math
+import sys
+from typing import Protocol, overload
+
+from math_tools.functional.roots import integrate_jerk
+from math_tools.otg.brake import BrakeProfile
+from math_tools.otg.enums import ControlSigns, Direction, ReachedLimits
+
+__all__ = ["Profile"]
+
+# Profile.swift's own private module constants (transcribed verbatim). These
+# are NOT functional.roots.EPS16/POLYNOMIAL_* -- Profile.swift defines its
+# own distinct tolerances, separate from the polynomial-root kernel's.
+_V_EPS = 1e-12
+_A_EPS = 1e-12
+_J_EPS = 1e-12
+_P_PRECISION = 1e-8
+_V_PRECISION = 1e-8
+_A_PRECISION = 1e-10
+_T_PRECISION = 1e-12  # Declared but unused in the Swift source too; ported for fidelity.
+_T_MAX = 1e12
+
+#: Swift ``Double.ulpOfOne`` (machine epsilon for float64) -- used (not
+#: ``EPS16``) everywhere Profile.swift compares against "effectively zero".
+_ULP = sys.float_info.epsilon
+
+# Reached-limits sets used by ``check`` (otg.md's ReachedLimits.NONE is the
+# common case where none of these apply; kept as module-level tuples so the
+# branch conditions below read like the Swift ``||`` chains they replace).
+_ZERO_TIME_VEL_LIMITS = (
+    ReachedLimits.ACC0_ACC1_VEL,
+    ReachedLimits.ACC0_VEL,
+    ReachedLimits.ACC1_VEL,
+    ReachedLimits.VEL,
+)
+_ZERO_TIME_ACC0_LIMITS = (ReachedLimits.ACC0, ReachedLimits.ACC0_ACC1)
+_ZERO_TIME_ACC1_LIMITS = (ReachedLimits.ACC1, ReachedLimits.ACC0_ACC1)
+_ZERO_ACC_AT_VEL_LIMITS = (
+    ReachedLimits.ACC0_ACC1_VEL,
+    ReachedLimits.ACC0_ACC1,
+    ReachedLimits.ACC0_VEL,
+    ReachedLimits.ACC1_VEL,
+    ReachedLimits.VEL,
+)
+
+
+class _PositionExtremumSink(Protocol):
+    """Structural stand-in for ``math_tools.otg.bound.Bound`` (chunk 34),
+    kept intentionally rather than importing ``Bound`` directly (see this
+    module's docstring).
+
+    :meth:`Profile.check_position_extremum` and
+    :meth:`Profile.check_step_for_position_extremum` only mutate these four
+    float attributes, so any object shaped like this -- including the real
+    ``Bound``, whose fields are named identically per
+    ``34-otg-block-brake-bound.md``'s design constraints -- satisfies it
+    structurally without this module importing ``bound.py``.
+    """
+
+    min: float
+    max: float
+    t_min: float
+    t_max: float
+
+
+class Profile:
+    """A single-DOF kinematic profile: position, velocity, acceleration, jerk.
+
+    Fixed-length arrays, never resized (otg.md §Internal fidelity
+    requirement 1): ``t``/``t_sum``/``j`` (7 elements), ``a``/``v``/``p`` (8
+    elements, one boundary value per phase transition plus the initial
+    state).
+    """
+
+    def __init__(self) -> None:
+        self.t: list[float] = [0.0] * 7
+        self.t_sum: list[float] = [0.0] * 7
+        self.j: list[float] = [0.0] * 7
+        self.a: list[float] = [0.0] * 8
+        self.v: list[float] = [0.0] * 8
+        self.p: list[float] = [0.0] * 8
+
+        # Brake sub-profiles (math_tools.otg.brake.BrakeProfile, chunk 34).
+        self.brake: BrakeProfile = BrakeProfile()
+        self.accel: BrakeProfile = BrakeProfile()
+
+        # Target (final) kinematic state.
+        self.pf: float = 0.0
+        self.vf: float = 0.0
+        self.af: float = 0.0
+
+        self.limits: ReachedLimits = ReachedLimits.NONE
+        self.direction: Direction = Direction.DOWN
+        self.control_signs: ControlSigns = ControlSigns.UDDU
+
+    # MARK: - Equality
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, Profile):
+            return NotImplemented
+        return (
+            self.t == other.t
+            and self.t_sum == other.t_sum
+            and self.j == other.j
+            and self.a == other.a
+            and self.v == other.v
+            and self.p == other.p
+            and self.brake == other.brake
+            and self.accel == other.accel
+            and self.pf == other.pf
+            and self.vf == other.vf
+            and self.af == other.af
+            and self.limits == other.limits
+            and self.direction == other.direction
+            and self.control_signs == other.control_signs
+        )
+
+    # MARK: - Third-order velocity interface
+
+    def check_for_velocity(
+        self,
+        jf: float,
+        a_max: float,
+        a_min: float,
+        control_signs: ControlSigns,
+        limits: ReachedLimits,
+    ) -> bool:
+        if self.t[0] < 0:
+            return False
+
+        self.t_sum[0] = self.t[0]
+        for i in range(6):
+            if self.t[i + 1] < 0:
+                return False
+            self.t_sum[i + 1] = self.t_sum[i] + self.t[i + 1]
+
+        if limits == ReachedLimits.ACC0 and self.t[1] < _ULP:
+            return False
+
+        if self.t_sum[-1] > _T_MAX:
+            return False
+
+        if control_signs == ControlSigns.UDDU:
+            self.j = [
+                jf if self.t[0] > 0 else 0.0,
+                0.0,
+                -jf if self.t[2] > 0 else 0.0,
+                0.0,
+                -jf if self.t[4] > 0 else 0.0,
+                0.0,
+                jf if self.t[6] > 0 else 0.0,
+            ]
+        else:
+            self.j = [
+                jf if self.t[0] > 0 else 0.0,
+                0.0,
+                -jf if self.t[2] > 0 else 0.0,
+                0.0,
+                jf if self.t[4] > 0 else 0.0,
+                0.0,
+                -jf if self.t[6] > 0 else 0.0,
+            ]
+
+        for i in range(7):
+            self.p[i + 1], self.v[i + 1], self.a[i + 1] = integrate_jerk(
+                self.t[i], self.p[i], self.v[i], self.a[i], self.j[i]
+            )
+
+        self.control_signs = control_signs
+        self.limits = limits
+
+        self.direction = Direction.UP if a_max > 0 else Direction.DOWN
+        a_upp_lim = (a_max if self.direction == Direction.UP else a_min) + _A_EPS
+        a_low_lim = (a_min if self.direction == Direction.UP else a_max) - _A_EPS
+
+        return (
+            abs(self.v[-1] - self.vf) < _V_PRECISION
+            and abs(self.a[-1] - self.af) < _A_PRECISION
+            and self.a[1] >= a_low_lim
+            and self.a[3] >= a_low_lim
+            and self.a[5] >= a_low_lim
+            and self.a[1] <= a_upp_lim
+            and self.a[3] <= a_upp_lim
+            and self.a[5] <= a_upp_lim
+        )
+
+    def check_for_velocity_with_timing(
+        self,
+        tf: float,
+        jf: float,
+        a_max: float,
+        a_min: float,
+        control_signs: ControlSigns,
+        limits: ReachedLimits,
+        *,
+        j_max: float | None = None,
+    ) -> bool:
+        """``checkForVelocityWithTiming`` (both Swift overloads collapsed).
+
+        ``tf`` is accepted (matching the Swift signature) but unused in
+        every branch, exactly as in the Swift source. ``j_max`` collapses
+        the two-overload/three-overload split: omit it for the plain
+        ``checkForVelocityWithTiming(tf, jf, aMax, aMin, controlSigns,
+        limits)`` overload; pass it for the ``jMax``-guarded overload.
+        """
+        del tf
+        if j_max is not None and not (abs(jf) < abs(j_max) + _J_EPS):
+            return False
+        return self.check_for_velocity(jf, a_max, a_min, control_signs, limits)
+
+    def set_boundary_for_velocity(
+        self,
+        p0_new: float,
+        v0_new: float,
+        a0_new: float,
+        vf_new: float,
+        af_new: float,
+    ) -> None:
+        self.a[0] = a0_new
+        self.v[0] = v0_new
+        self.p[0] = p0_new
+        self.af = af_new
+        self.vf = vf_new
+
+    # MARK: - Second-order velocity interface
+
+    def check_for_second_order_velocity(
+        self,
+        a_up: float,
+        control_signs: ControlSigns,
+        limits: ReachedLimits,
+    ) -> bool:
+        if self.t[1] < 0.0:
+            return False
+
+        self.t_sum = [0.0, self.t[1], self.t[1], self.t[1], self.t[1], self.t[1], self.t[1]]
+        if self.t_sum[-1] > _T_MAX:
+            return False
+
+        self.j = [0.0] * 7
+        self.a = [0.0, a_up if self.t[1] > 0 else 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, self.af]
+        for i in range(7):
+            self.p[i + 1], self.v[i + 1], _ = integrate_jerk(
+                self.t[i], self.p[i], self.v[i], self.a[i], 0.0
+            )
+
+        self.control_signs = control_signs
+        self.limits = limits
+
+        self.direction = Direction.UP if a_up > 0 else Direction.DOWN
+
+        return abs(self.v[-1] - self.vf) < _V_PRECISION
+
+    def check_for_second_order_velocity_with_timing(
+        self,
+        tf: float,
+        a_up: float,
+        control_signs: ControlSigns,
+        limits: ReachedLimits,
+        *,
+        a_max: float | None = None,
+        a_min: float | None = None,
+    ) -> bool:
+        """``checkForSecondOrderVelocityWithTiming`` (both overloads collapsed).
+
+        Pass ``a_max``/``a_min`` together for the bound-checked overload;
+        omit both for the plain delegating overload.
+        """
+        del tf
+        if a_max is not None and a_min is not None:
+            if not (a_min - _A_EPS < a_up < a_max + _A_EPS):
+                return False
+        return self.check_for_second_order_velocity(a_up, control_signs, limits)
+
+    # MARK: - Third-order position interface
+
+    def check(
+        self,
+        jf: float,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        control_signs: ControlSigns,
+        limits: ReachedLimits,
+        set_limits: bool = False,
+    ) -> bool:
+        if self.t[0] < 0:
+            return False
+
+        self.t_sum[0] = self.t[0]
+        for i in range(6):
+            if self.t[i + 1] < 0:
+                return False
+            self.t_sum[i + 1] = self.t_sum[i] + self.t[i + 1]
+
+        if limits in _ZERO_TIME_VEL_LIMITS and self.t[3] < _ULP:
+            return False
+
+        if limits in _ZERO_TIME_ACC0_LIMITS and self.t[1] < _ULP:
+            return False
+
+        if limits in _ZERO_TIME_ACC1_LIMITS and self.t[5] < _ULP:
+            return False
+
+        if self.t_sum[-1] > _T_MAX:
+            return False
+
+        if control_signs == ControlSigns.UDDU:
+            self.j = [
+                jf if self.t[0] > 0 else 0.0,
+                0.0,
+                -jf if self.t[2] > 0 else 0.0,
+                0.0,
+                -jf if self.t[4] > 0 else 0.0,
+                0.0,
+                jf if self.t[6] > 0 else 0.0,
+            ]
+        else:
+            self.j = [
+                jf if self.t[0] > 0 else 0.0,
+                0.0,
+                -jf if self.t[2] > 0 else 0.0,
+                0.0,
+                jf if self.t[4] > 0 else 0.0,
+                0.0,
+                -jf if self.t[6] > 0 else 0.0,
+            ]
+
+        self.direction = Direction.UP if v_max > 0 else Direction.DOWN
+        v_upp_lim = (v_max if self.direction == Direction.UP else v_min) + _V_EPS
+        v_low_lim = (v_min if self.direction == Direction.UP else v_max) - _V_EPS
+
+        for i in range(7):
+            self.p[i + 1], self.v[i + 1], self.a[i + 1] = integrate_jerk(
+                self.t[i], self.p[i], self.v[i], self.a[i], self.j[i]
+            )
+
+            if limits in _ZERO_ACC_AT_VEL_LIMITS and i == 2:
+                self.a[3] = 0.0
+                if self.t[2] > _ULP:
+                    self.j[2] = (self.a[3] - self.a[2]) / self.t[2]
+
+            if set_limits:
+                if limits == ReachedLimits.ACC1 and i == 2:
+                    self.a[3] = a_min
+                    if self.t[2] > _ULP:
+                        self.j[2] = (self.a[3] - self.a[2]) / self.t[2]
+
+                if limits == ReachedLimits.ACC0_ACC1:
+                    if i == 0:
+                        self.a[1] = a_max
+                        if self.t[0] > _ULP:
+                            self.j[0] = (self.a[1] - self.a[0]) / self.t[0]
+                    if i == 4:
+                        self.a[5] = a_min
+                        if self.t[4] > _ULP:
+                            self.j[4] = (self.a[5] - self.a[4]) / self.t[4]
+
+            if i > 1 and self.a[i + 1] * self.a[i] < -_ULP:
+                v_a_zero = self.v[i] - (self.a[i] * self.a[i]) / (2 * self.j[i])
+                if v_a_zero > v_upp_lim or v_a_zero < v_low_lim:
+                    return False
+
+        self.control_signs = control_signs
+        self.limits = limits
+
+        a_upp_lim = (a_max if self.direction == Direction.UP else a_min) + _A_EPS
+        a_low_lim = (a_min if self.direction == Direction.UP else a_max) - _A_EPS
+
+        p_check = abs(self.p[-1] - self.pf) < _P_PRECISION
+        v_check = abs(self.v[-1] - self.vf) < _V_PRECISION
+        a_check = abs(self.a[-1] - self.af) < _A_PRECISION
+
+        a_lim_check = (
+            self.a[1] >= a_low_lim
+            and self.a[3] >= a_low_lim
+            and self.a[5] >= a_low_lim
+            and self.a[1] <= a_upp_lim
+            and self.a[3] <= a_upp_lim
+            and self.a[5] <= a_upp_lim
+        )
+
+        v_lim_check = (
+            self.v[3] <= v_upp_lim
+            and self.v[4] <= v_upp_lim
+            and self.v[5] <= v_upp_lim
+            and self.v[6] <= v_upp_lim
+            and self.v[3] >= v_low_lim
+            and self.v[4] >= v_low_lim
+            and self.v[5] >= v_low_lim
+            and self.v[6] >= v_low_lim
+        )
+
+        return p_check and v_check and a_check and a_lim_check and v_lim_check
+
+    def check_with_timing(
+        self,
+        tf: float,
+        jf: float,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        control_signs: ControlSigns,
+        limits: ReachedLimits,
+        *,
+        j_max: float | None = None,
+    ) -> bool:
+        """``checkWithTiming`` (both Swift overloads collapsed).
+
+        Omit ``j_max`` for the plain delegating overload; pass it for the
+        ``jMax``-guarded overload.
+        """
+        del tf
+        if j_max is not None and not (abs(jf) < abs(j_max) + _J_EPS):
+            return False
+        return self.check(jf, v_max, v_min, a_max, a_min, control_signs, limits)
+
+    @overload
+    def set_boundary(self, profile: Profile, /) -> None: ...
+    @overload
+    def set_boundary(
+        self,
+        p0_new: float,
+        v0_new: float,
+        a0_new: float,
+        pf_new: float,
+        vf_new: float,
+        af_new: float,
+        /,
+    ) -> None: ...
+
+    def set_boundary(
+        self,
+        p0_new: Profile | float,
+        v0_new: float | None = None,
+        a0_new: float | None = None,
+        pf_new: float | None = None,
+        vf_new: float | None = None,
+        af_new: float | None = None,
+    ) -> None:
+        """``setBoundary`` (both Swift overloads: copy-from-profile or set-directly)."""
+        if isinstance(p0_new, Profile):
+            other = p0_new
+            self.a[0] = other.a[0]
+            self.v[0] = other.v[0]
+            self.p[0] = other.p[0]
+            self.af = other.af
+            self.vf = other.vf
+            self.pf = other.pf
+            self.brake = other.brake
+            self.accel = other.accel
+            return
+
+        assert v0_new is not None
+        assert a0_new is not None
+        assert pf_new is not None
+        assert vf_new is not None
+        assert af_new is not None
+
+        self.a[0] = a0_new
+        self.v[0] = v0_new
+        self.p[0] = p0_new
+        self.af = af_new
+        self.vf = vf_new
+        self.pf = pf_new
+
+    # MARK: - Second-order position interface
+
+    def check_for_second_order(
+        self,
+        a_up: float,
+        a_down: float,
+        v_max: float,
+        v_min: float,
+        control_signs: ControlSigns,
+        limits: ReachedLimits,
+    ) -> bool:
+        if self.t[0] < 0:
+            return False
+
+        self.t_sum[0] = self.t[0]
+        for i in range(6):
+            if self.t[i + 1] < 0:
+                return False
+            self.t_sum[i + 1] = self.t_sum[i] + self.t[i + 1]
+
+        if self.t_sum[-1] > _T_MAX:
+            return False
+
+        self.j = [0.0] * 7
+        if control_signs == ControlSigns.UDDU:
+            self.a = [
+                a_up if self.t[0] > 0 else 0.0,
+                0.0,
+                a_down if self.t[2] > 0 else 0.0,
+                0.0,
+                a_down if self.t[4] > 0 else 0.0,
+                0.0,
+                a_up if self.t[6] > 0 else 0.0,
+                self.af,
+            ]
+        else:
+            self.a = [
+                a_up if self.t[0] > 0 else 0.0,
+                0.0,
+                a_down if self.t[2] > 0 else 0.0,
+                0.0,
+                a_up if self.t[4] > 0 else 0.0,
+                0.0,
+                a_down if self.t[6] > 0 else 0.0,
+                self.af,
+            ]
+
+        self.direction = Direction.UP if v_max > 0 else Direction.DOWN
+        v_upp_lim = (v_max if self.direction == Direction.UP else v_min) + _V_EPS
+        v_low_lim = (v_min if self.direction == Direction.UP else v_max) - _V_EPS
+
+        for i in range(7):
+            self.p[i + 1], self.v[i + 1], _ = integrate_jerk(
+                self.t[i], self.p[i], self.v[i], self.a[i], 0.0
+            )
+
+        self.control_signs = control_signs
+        self.limits = limits
+
+        return (
+            abs(self.p[-1] - self.pf) < _P_PRECISION
+            and abs(self.v[-1] - self.vf) < _V_PRECISION
+            and self.v[2] <= v_upp_lim
+            and self.v[3] <= v_upp_lim
+            and self.v[4] <= v_upp_lim
+            and self.v[5] <= v_upp_lim
+            and self.v[6] <= v_upp_lim
+            and self.v[2] >= v_low_lim
+            and self.v[3] >= v_low_lim
+            and self.v[4] >= v_low_lim
+            and self.v[5] >= v_low_lim
+            and self.v[6] >= v_low_lim
+        )
+
+    def check_for_second_order_with_timing(
+        self,
+        tf: float,
+        a_up: float,
+        a_down: float,
+        v_max: float,
+        v_min: float,
+        control_signs: ControlSigns,
+        limits: ReachedLimits,
+        *,
+        a_max: float | None = None,
+        a_min: float | None = None,
+    ) -> bool:
+        """``checkForSecondOrderWithTiming`` (both overloads collapsed).
+
+        Pass ``a_max``/``a_min`` together for the bound-checked overload;
+        omit both for the plain delegating overload.
+        """
+        del tf
+        if a_max is not None and a_min is not None:
+            if not (a_min - _A_EPS < a_up < a_max + _A_EPS):
+                return False
+            if not (a_min - _A_EPS < a_down < a_max + _A_EPS):
+                return False
+        return self.check_for_second_order(a_up, a_down, v_max, v_min, control_signs, limits)
+
+    # MARK: - First-order position interface
+
+    def check_for_first_order(
+        self,
+        v_up: float,
+        control_signs: ControlSigns,
+        limits: ReachedLimits,
+    ) -> bool:
+        if self.t[3] < 0.0:
+            return False
+
+        self.t_sum = [0.0, 0.0, 0.0, self.t[3], self.t[3], self.t[3], self.t[3]]
+        if self.t_sum[-1] > _T_MAX:
+            return False
+
+        self.j = [0.0] * 7
+        self.a = [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, self.af]
+        self.v = [0.0, 0.0, 0.0, v_up if self.t[3] > 0 else 0.0, 0.0, 0.0, 0.0, self.vf]
+
+        for i in range(7):
+            self.p[i + 1], _, _ = integrate_jerk(self.t[i], self.p[i], self.v[i], self.a[i], 0.0)
+
+        self.control_signs = control_signs
+        self.limits = limits
+
+        self.direction = Direction.UP if v_up > 0 else Direction.DOWN
+
+        return abs(self.p[-1] - self.pf) < _P_PRECISION
+
+    def check_for_first_order_with_timing(
+        self,
+        tf: float,
+        v_up: float,
+        control_signs: ControlSigns,
+        limits: ReachedLimits,
+        *,
+        v_max: float | None = None,
+        v_min: float | None = None,
+    ) -> bool:
+        """``checkForFirstOrderWithTiming`` (both overloads collapsed).
+
+        Pass ``v_max``/``v_min`` together for the bound-checked overload;
+        omit both for the plain delegating overload.
+        """
+        del tf
+        if v_max is not None and v_min is not None:
+            if not (v_min - _V_EPS < v_up < v_max + _V_EPS):
+                return False
+        return self.check_for_first_order(v_up, control_signs, limits)
+
+    # MARK: - Secondary features
+
+    @staticmethod
+    def check_position_extremum(
+        t_ext: float,
+        t_sum: float,
+        t: float,
+        p: float,
+        v: float,
+        a: float,
+        j: float,
+        ext: _PositionExtremumSink,
+    ) -> None:
+        if 0 < t_ext < t:
+            p_ext, _, a_ext = integrate_jerk(t_ext, p, v, a, j)
+            if a_ext > 0 and p_ext < ext.min:
+                ext.min = p_ext
+                ext.t_min = t_sum + t_ext
+            elif a_ext < 0 and p_ext > ext.max:
+                ext.max = p_ext
+                ext.t_max = t_sum + t_ext
+
+    @staticmethod
+    def check_step_for_position_extremum(
+        t_sum: float,
+        t: float,
+        p: float,
+        v: float,
+        a: float,
+        j: float,
+        ext: _PositionExtremumSink,
+    ) -> None:
+        if p < ext.min:
+            ext.min = p
+            ext.t_min = t_sum
+        if p > ext.max:
+            ext.max = p
+            ext.t_max = t_sum
+
+        if j != 0:
+            d = a * a - 2 * j * v
+            if abs(d) < _ULP:
+                Profile.check_position_extremum(-a / j, t_sum, t, p, v, a, j, ext)
+            elif d > 0.0:
+                d_sqrt = math.sqrt(d)
+                Profile.check_position_extremum((-a - d_sqrt) / j, t_sum, t, p, v, a, j, ext)
+                Profile.check_position_extremum((-a + d_sqrt) / j, t_sum, t, p, v, a, j, ext)
diff --git a/src/pyMathTools/spherical/__init__.py b/src/math_tools/otg/py.typed
similarity index 100%
rename from src/pyMathTools/spherical/__init__.py
rename to src/math_tools/otg/py.typed
diff --git a/src/math_tools/otg/steps/__init__.py b/src/math_tools/otg/steps/__init__.py
new file mode 100644
index 0000000..7b68612
--- /dev/null
+++ b/src/math_tools/otg/steps/__init__.py
@@ -0,0 +1,9 @@
+"""Step solvers for the OTG (online trajectory generation) subsystem.
+
+Private subpackage (Swift ``internal`` visibility): every class here ports
+one Swift step-solver class 1:1 (``otg.md`` §Module layout). Nothing here is
+re-exported from ``math_tools.otg``'s public surface -- see
+``.claude/specs/otg.md`` §Module layout's "private" note.
+"""
+
+from __future__ import annotations
diff --git a/src/math_tools/otg/steps/position_first_order.py b/src/math_tools/otg/steps/position_first_order.py
new file mode 100644
index 0000000..6f1e76f
--- /dev/null
+++ b/src/math_tools/otg/steps/position_first_order.py
@@ -0,0 +1,95 @@
+"""Step solvers for the first-order (velocity interface only, no
+acceleration/jerk limits) position interface: Step 1 computes the
+time-optimal profile, Step 2 computes a profile for a prescribed duration.
+
+Faithful ports of
+``SWIFT_MATH/OTG/position/PositionFirstOrderStep1.swift`` and
+``...PositionFirstOrderStep2.swift`` (class/method names and branch
+structure preserved mechanically). See ``.claude/specs/otg.md`` §Internal
+fidelity requirements 1, 2, 4, 5 and
+``.claude/action-plan/37-otg-position-first-second-steps.md``.
+
+``PositionFirstOrderStep1.get_profile`` ports Swift's ``var p = block.pMin``
+(a struct value copy) as ``copy.deepcopy(block.p_min)``, matching
+``VelocitySecondOrderStep1.get_profile``'s identical pattern (see
+``steps/velocity_second_order.py``'s module docstring): ``Profile`` is a
+Python class (reference type), so a plain assignment would alias
+``block.p_min`` and let ``p.set_boundary(...)``/the failed-check path mutate
+``block.p_min`` in place even when this function returns ``False`` (Swift's
+local copy is simply discarded on failure, leaving ``block.pMin``
+untouched).
+"""
+
+from __future__ import annotations
+
+import copy
+
+from math_tools.otg.block import Block
+from math_tools.otg.enums import ControlSigns, ReachedLimits
+from math_tools.otg.profile import Profile
+
+__all__: list[str] = []
+
+
+class PositionFirstOrderStep1:
+    """Mathematical equations for Step 1 in first-order position interface:
+    extremal profiles."""
+
+    def __init__(self, p0: float, pf: float, v_max: float, v_min: float) -> None:
+        self._v_max = v_max
+        self._v_min = v_min
+
+        # Pre-calculated expressions.
+        self.pd = pf - p0
+
+    def get_profile(self, input_profile: Profile, block: Block) -> bool:
+        p = copy.deepcopy(block.p_min)
+        p.set_boundary(input_profile)
+
+        vf = self._v_max if self.pd > 0 else self._v_min
+        p.t[0] = 0.0
+        p.t[1] = 0.0
+        p.t[2] = 0.0
+        p.t[3] = self.pd / vf
+        p.t[4] = 0.0
+        p.t[5] = 0.0
+        p.t[6] = 0.0
+
+        if p.check_for_first_order(vf, ControlSigns.UDDU, ReachedLimits.VEL):
+            block.p_min = p
+            block.t_min = p.t_sum[-1] + p.brake.duration + p.accel.duration
+            return True
+        return False
+
+
+class PositionFirstOrderStep2:
+    """Mathematical equations for Step 2 in first-order position interface:
+    time synchronization."""
+
+    def __init__(self, tf: float, p0: float, pf: float, v_max: float, v_min: float) -> None:
+        self.tf = tf
+        self._v_max = v_max
+        self._v_min = v_min
+
+        # Pre-calculated expressions.
+        self.pd = pf - p0
+
+    def get_profile(self, profile: Profile) -> bool:
+        vf = self.pd / self.tf
+
+        profile.t[0] = 0.0
+        profile.t[1] = 0.0
+        profile.t[2] = 0.0
+        profile.t[3] = self.tf
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        return profile.check_for_first_order_with_timing(
+            self.tf,
+            vf,
+            ControlSigns.UDDU,
+            ReachedLimits.NONE,
+            v_max=self._v_max,
+            v_min=self._v_min,
+        )
diff --git a/src/math_tools/otg/steps/position_second_order.py b/src/math_tools/otg/steps/position_second_order.py
new file mode 100644
index 0000000..e3e87b7
--- /dev/null
+++ b/src/math_tools/otg/steps/position_second_order.py
@@ -0,0 +1,430 @@
+"""Step solvers for the second-order (velocity + acceleration limits, no
+jerk limit) position interface: Step 1 computes the time-optimal profile,
+Step 2 computes a profile for a prescribed duration.
+
+Faithful ports of
+``SWIFT_MATH/OTG/position/PositionSecondOrderStep1.swift`` and
+``...PositionSecondOrderStep2.swift`` (class/method names and branch
+structure preserved mechanically). See ``.claude/specs/otg.md`` §Internal
+fidelity requirements 1, 2, 4, 5 and
+``.claude/action-plan/37-otg-position-first-second-steps.md``.
+
+**Struct-value-copy semantics.** ``Profile`` is a Python class (reference
+type); Swift's ``Profile`` is a struct (value type). Two spots need
+``copy.deepcopy`` to reproduce Swift's value semantics (matching the pattern
+established in ``steps/velocity_second_order.py`` and
+``steps/velocity_third_order.py``): ``PositionFirstOrderStep1``-style ``var
+p = block.pMin`` reads, both of which appear in
+``PositionSecondOrderStep1.get_profile`` (the zero-``vMax``/``vMin``
+special case).
+
+``PositionSecondOrderStep1._time_acc0``/``_time_none`` do **not** need a
+deep copy, unlike ``VelocityThirdOrderStep1``'s equivalent helpers: the
+Swift source mutates ``validProfiles[profileCount]`` directly through the
+array subscript on every line (never capturing a local ``var profile =
+validProfiles[profileCount]`` first), so each solution attempt writes
+straight into the current candidate slot. Python's list indexing has the
+same direct-mutation semantics (``self.valid_profiles[self._profile_count]``
+is the actual object at that index, not a copy), and ``_add_profile``
+advances to a fresh, distinct ``Profile()`` instance before the next
+attempt -- so a plain mechanical port (no ``copy.deepcopy``) already
+reproduces Swift's behavior exactly. All three ``valid_profiles`` slots are
+constructed as genuinely separate ``Profile()`` instances (never
+``[Profile()] * 3``), matching ``VelocityThirdOrderStep1``'s identical
+comment about the hazard of accidentally sharing one instance across slots.
+
+``PositionSecondOrderStep2`` needs no copy at all: its methods mutate a
+single ``profile`` argument passed straight through (Swift ``inout`` on one
+object) and always return on first success, matching
+``VelocityThirdOrderStep2``'s identical "no copy needed" case.
+"""
+
+from __future__ import annotations
+
+import copy
+import math
+import sys
+
+from math_tools.otg.block import Block, Interval
+from math_tools.otg.enums import ControlSigns, ReachedLimits
+from math_tools.otg.profile import Profile
+
+__all__: list[str] = []
+
+#: Swift ``Double.leastNormalMagnitude`` (smallest positive normalized
+#: float64, ~2.2250738585072014e-308) -- ``PositionSecondOrderStep1``'s
+#: near-zero guards. Matches ``steps/velocity_third_order.py``'s identical
+#: module-private constant, transcribed per Swift file per that module's
+#: convention.
+_LEAST_NORMAL_MAGNITUDE = sys.float_info.min
+
+
+class PositionSecondOrderStep1:
+    """Mathematical equations for Step 1 in second-order position
+    interface: extremal profiles."""
+
+    def __init__(
+        self,
+        p0: float,
+        v0: float,
+        pf: float,
+        vf: float,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+    ) -> None:
+        self.v0 = v0
+        self.vf = vf
+        self._v_max = v_max
+        self._v_min = v_min
+        self._a_max = a_max
+        self._a_min = a_min
+
+        # Pre-calculated expressions.
+        self.pd = pf - p0
+
+        # Max 3 valid profiles. Separate instances, not shared references
+        # (using `[Profile()] * 3` would create multiple references to the
+        # SAME object).
+        self.valid_profiles: list[Profile] = [Profile() for _ in range(3)]
+        self._profile_count = 0
+
+    def _add_profile(self) -> None:
+        self._profile_count += 1
+        if self._profile_count < len(self.valid_profiles):
+            self.valid_profiles[self._profile_count].set_boundary(
+                self.valid_profiles[self._profile_count - 1]
+            )
+
+    def _reset_profiles(self) -> None:
+        self._profile_count = 0
+
+    def _has_profiles(self) -> bool:
+        return self._profile_count > 0
+
+    def get_profile(self, input_profile: Profile, block: Block) -> bool:
+        # Zero-limits special case.
+        if self._v_max == 0.0 and self._v_min == 0.0:
+            p = copy.deepcopy(block.p_min)
+            p.set_boundary(input_profile)
+
+            if self._time_all_single_step(p, self._v_max, self._v_min, self._a_max, self._a_min):
+                block.p_min = p
+                block.t_min = p.t_sum[-1] + p.brake.duration + p.accel.duration
+                if abs(self.v0) > _LEAST_NORMAL_MAGNITUDE:
+                    block.a = Interval(block.t_min, math.inf)
+                return True
+            return False
+
+        self._reset_profiles()
+        self.valid_profiles[self._profile_count].set_boundary(input_profile)
+
+        if abs(self.vf) < _LEAST_NORMAL_MAGNITUDE:
+            # There is no blocked interval when vf==0, so return after the
+            # first found profile.
+            v_max = self._v_max if self.pd >= 0 else self._v_min
+            v_min = self._v_min if self.pd >= 0 else self._v_max
+            a_max = self._a_max if self.pd >= 0 else self._a_min
+            a_min = self._a_min if self.pd >= 0 else self._a_max
+
+            self._time_none(v_max, v_min, a_max, a_min, True)
+            if self._has_profiles():
+                success, _ = Block.calculate_block(block, self.valid_profiles, self._profile_count)
+                return success
+            self._time_acc0(v_max, v_min, a_max, a_min, True)
+            if self._has_profiles():
+                success, _ = Block.calculate_block(block, self.valid_profiles, self._profile_count)
+                return success
+
+            self._time_none(v_min, v_max, a_min, a_max, True)
+            if self._has_profiles():
+                success, _ = Block.calculate_block(block, self.valid_profiles, self._profile_count)
+                return success
+            self._time_acc0(v_min, v_max, a_min, a_max, True)
+
+        else:
+            self._time_none(self._v_max, self._v_min, self._a_max, self._a_min, False)
+            self._time_none(self._v_min, self._v_max, self._a_min, self._a_max, False)
+            self._time_acc0(self._v_max, self._v_min, self._a_max, self._a_min, False)
+            self._time_acc0(self._v_min, self._v_max, self._a_min, self._a_max, False)
+
+        success, _ = Block.calculate_block(block, self.valid_profiles, self._profile_count)
+        return success
+
+    def _time_acc0(
+        self,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        return_after_found: bool,
+    ) -> None:
+        # Unused in the Swift source too (single candidate, nothing to short-circuit).
+        del return_after_found
+        self.valid_profiles[self._profile_count].t[0] = (-self.v0 + v_max) / a_max
+        self.valid_profiles[self._profile_count].t[1] = (
+            (a_min * self.v0 * self.v0 - a_max * self.vf * self.vf) / (2 * a_max * a_min * v_max)
+            + v_max * (a_max - a_min) / (2 * a_max * a_min)
+            + self.pd / v_max
+        )
+        self.valid_profiles[self._profile_count].t[2] = (self.vf - v_max) / a_min
+        self.valid_profiles[self._profile_count].t[3] = 0.0
+        self.valid_profiles[self._profile_count].t[4] = 0.0
+        self.valid_profiles[self._profile_count].t[5] = 0.0
+        self.valid_profiles[self._profile_count].t[6] = 0.0
+
+        if self.valid_profiles[self._profile_count].check_for_second_order(
+            a_max, a_min, v_max, v_min, ControlSigns.UDDU, ReachedLimits.ACC0
+        ):
+            self._add_profile()
+
+    def _time_none(
+        self,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        return_after_found: bool,
+    ) -> None:
+        h1 = (
+            a_max * self.vf * self.vf - a_min * self.v0 * self.v0 - 2 * a_max * a_min * self.pd
+        ) / (a_max - a_min)
+        if h1 >= 0.0:
+            h1 = math.sqrt(h1)
+
+            # Solution 1
+            self.valid_profiles[self._profile_count].t[0] = -(self.v0 + h1) / a_max
+            self.valid_profiles[self._profile_count].t[1] = 0.0
+            self.valid_profiles[self._profile_count].t[2] = (self.vf + h1) / a_min
+            self.valid_profiles[self._profile_count].t[3] = 0.0
+            self.valid_profiles[self._profile_count].t[4] = 0.0
+            self.valid_profiles[self._profile_count].t[5] = 0.0
+            self.valid_profiles[self._profile_count].t[6] = 0.0
+
+            if self.valid_profiles[self._profile_count].check_for_second_order(
+                a_max, a_min, v_max, v_min, ControlSigns.UDDU, ReachedLimits.NONE
+            ):
+                self._add_profile()
+                if return_after_found:
+                    return
+
+            # Solution 2
+            self.valid_profiles[self._profile_count].t[0] = (-self.v0 + h1) / a_max
+            self.valid_profiles[self._profile_count].t[1] = 0.0
+            self.valid_profiles[self._profile_count].t[2] = (self.vf - h1) / a_min
+            self.valid_profiles[self._profile_count].t[3] = 0.0
+            self.valid_profiles[self._profile_count].t[4] = 0.0
+            self.valid_profiles[self._profile_count].t[5] = 0.0
+            self.valid_profiles[self._profile_count].t[6] = 0.0
+
+            if self.valid_profiles[self._profile_count].check_for_second_order(
+                a_max, a_min, v_max, v_min, ControlSigns.UDDU, ReachedLimits.NONE
+            ):
+                self._add_profile()
+
+    def _time_all_single_step(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+    ) -> bool:
+        del a_max, a_min  # unused in the Swift source too (zero-limits case)
+        if abs(self.vf - self.v0) > _LEAST_NORMAL_MAGNITUDE:
+            return False
+
+        profile.t[0] = 0.0
+        profile.t[1] = 0.0
+        profile.t[2] = 0.0
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if abs(self.v0) > _LEAST_NORMAL_MAGNITUDE:
+            profile.t[3] = self.pd / self.v0
+            if profile.check_for_second_order(
+                0.0, 0.0, v_max, v_min, ControlSigns.UDDU, ReachedLimits.NONE
+            ):
+                return True
+        elif abs(self.pd) < _LEAST_NORMAL_MAGNITUDE:
+            if profile.check_for_second_order(
+                0.0, 0.0, v_max, v_min, ControlSigns.UDDU, ReachedLimits.NONE
+            ):
+                return True
+
+        return False
+
+
+class PositionSecondOrderStep2:
+    """Mathematical equations for Step 2 in second-order position
+    interface: time synchronization."""
+
+    def __init__(
+        self,
+        tf: float,
+        p0: float,
+        v0: float,
+        pf: float,
+        vf: float,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+    ) -> None:
+        self.v0 = v0
+        self.tf = tf
+        self.vf = vf
+        self._v_max = v_max
+        self._v_min = v_min
+        self._a_max = a_max
+        self._a_min = a_min
+
+        # Pre-calculated expressions.
+        self.pd = pf - p0
+        self.vd = vf - v0
+
+    def time_acc0(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+    ) -> bool:
+        # UD Solution 1/2
+        h1_1 = math.sqrt(
+            (
+                2 * a_max * (self.pd - self.tf * self.vf)
+                - 2 * a_min * (self.pd - self.tf * self.v0)
+                + self.vd * self.vd
+            )
+            / (a_max * a_min)
+            + self.tf * self.tf
+        )
+
+        profile.t[0] = (a_max * self.vd - a_max * a_min * (self.tf - h1_1)) / (
+            a_max * (a_max - a_min)
+        )
+        profile.t[1] = h1_1
+        profile.t[2] = self.tf - (profile.t[0] + h1_1)
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check_for_second_order_with_timing(
+            self.tf, a_max, a_min, v_max, v_min, ControlSigns.UDDU, ReachedLimits.ACC0
+        ):
+            profile.pf = profile.p[-1]
+            return True
+
+        # UU Solution
+        h1_2 = -self.vd + a_max * self.tf
+
+        profile.t[0] = -self.vd * self.vd / (2 * a_max * h1_2) + (
+            self.pd - self.v0 * self.tf
+        ) / h1_2
+        profile.t[1] = -self.vd / a_max + self.tf
+        profile.t[2] = 0.0
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = self.tf - (profile.t[0] + profile.t[1])
+
+        if profile.check_for_second_order_with_timing(
+            self.tf, a_max, a_min, v_max, v_min, ControlSigns.UDDU, ReachedLimits.ACC0
+        ):
+            profile.pf = profile.p[-1]
+            return True
+
+        # UU Solution - 2 step
+        profile.t[0] = 0.0
+        profile.t[1] = -self.vd / a_max + self.tf
+        profile.t[2] = 0.0
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = self.vd / a_max
+
+        if profile.check_for_second_order_with_timing(
+            self.tf, a_max, a_min, v_max, v_min, ControlSigns.UDDU, ReachedLimits.ACC0
+        ):
+            profile.pf = profile.p[-1]
+            return True
+
+        return False
+
+    def time_none(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+    ) -> bool:
+        if (
+            abs(self.v0) < _LEAST_NORMAL_MAGNITUDE
+            and abs(self.vf) < _LEAST_NORMAL_MAGNITUDE
+            and abs(self.pd) < _LEAST_NORMAL_MAGNITUDE
+        ):
+            profile.t[0] = 0.0
+            profile.t[1] = self.tf
+            profile.t[2] = 0.0
+            profile.t[3] = 0.0
+            profile.t[4] = 0.0
+            profile.t[5] = 0.0
+            profile.t[6] = 0.0
+
+            if profile.check_for_second_order_with_timing(
+                self.tf, a_max, a_min, v_max, v_min, ControlSigns.UDDU, ReachedLimits.NONE
+            ):
+                profile.pf = profile.p[-1]
+                return True
+
+        # UD Solution 1/2
+        h1 = 2 * (self.vf * self.tf - self.pd)
+
+        profile.t[0] = h1 / self.vd
+        profile.t[1] = self.tf - profile.t[0]
+        profile.t[2] = 0.0
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        af = self.vd * self.vd / h1
+
+        if (a_min - 1e-12 < af < a_max + 1e-12) and profile.check_for_second_order_with_timing(
+            self.tf, af, -af, v_max, v_min, ControlSigns.UDDU, ReachedLimits.NONE
+        ):
+            profile.pf = profile.p[-1]
+            return True
+
+        return False
+
+    def get_profile(self, profile: Profile) -> bool:
+        # Test all cases to get ones that match. However we should guess
+        # which one is correct and try them first...
+        if self.pd > 0:
+            return self.check_all(
+                profile, self._v_max, self._v_min, self._a_max, self._a_min
+            ) or self.check_all(profile, self._v_min, self._v_max, self._a_min, self._a_max)
+
+        return self.check_all(
+            profile, self._v_min, self._v_max, self._a_min, self._a_max
+        ) or self.check_all(profile, self._v_max, self._v_min, self._a_max, self._a_min)
+
+    def check_all(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+    ) -> bool:
+        return self.time_acc0(profile, v_max, v_min, a_max, a_min) or self.time_none(
+            profile, v_max, v_min, a_max, a_min
+        )
diff --git a/src/math_tools/otg/steps/position_third_order_step1.py b/src/math_tools/otg/steps/position_third_order_step1.py
new file mode 100644
index 0000000..c075e44
--- /dev/null
+++ b/src/math_tools/otg/steps/position_third_order_step1.py
@@ -0,0 +1,1129 @@
+"""Step 1 solver for the third-order (jerk-limited) position interface:
+computes the time-optimal profile.
+
+Faithful port of ``SWIFT_MATH/OTG/position/PositionThirdOrderStep1.swift``
+(~850 lines; class/method names and branch structure preserved
+mechanically -- the largest/most complex step solver in the OTG port). See
+``.claude/specs/otg.md`` §Internal fidelity requirements 1, 2, 4, 5 and
+``.claude/action-plan/38-otg-position-third-step1.md``.
+
+**Struct-value-copy semantics.** ``Profile`` is a Python class (reference
+type); Swift's ``Profile`` is a struct (value type). This file has the
+richest set of alias-mutation hazards in the OTG port so far (see
+``steps/velocity_third_order.py`` and ``steps/position_second_order.py``
+for the simpler precedents this follows):
+
+- ``_time_all_vel`` and ``_time_acc0_acc1`` each fetch ONE local
+  ``profile`` copy at the top and reuse it, unmutated-between-checks, for
+  up to four/two sequential solution attempts within the same call (e.g.
+  ``_time_all_vel``'s ACC0_ACC1_VEL / ACC1_VEL / ACC0_VEL / VEL cases all
+  overwrite the same ``profile.t`` array in turn, even after an earlier
+  attempt in the *same call* already succeeded and was "saved" with
+  ``return_after_found=False``). Every ``validProfiles[profileCount] =
+  profile`` save point is ported as ``self.valid_profiles[self._profile_count]
+  = copy.deepcopy(profile)`` so a later attempt's mutations to the shared
+  local ``profile`` cannot retroactively corrupt an earlier saved
+  candidate -- the initial ``profile = copy.deepcopy(self.valid_profiles[
+  self._profile_count])`` fetch is included for the same defensive
+  reason/consistency with those two precedent files, even though (unlike
+  the saves) it is not independently load-bearing.
+- ``_time_all_none_acc0_acc1`` is the one NEW pattern in this port: its
+  three ``for`` loops (NONE / ACC0 / ACC1 roots) call ``self._add_profile()``
+  on every success and, when NOT returning immediately, explicitly
+  re-fetch ``profile = self.valid_profiles[self._profile_count]`` before
+  continuing to the next root -- this ports the Swift source's own
+  explicit "BUG FIX: Get fresh profile reference to prevent corrupting
+  previously added profile" comments verbatim. The re-fetch is a *plain*
+  reference reassignment (no ``copy.deepcopy``): it points ``profile`` at
+  the freshly ``set_boundary``-initialized next slot (untouched by any
+  save), so nothing is aliased with previously-saved state; only the save
+  itself (``self.valid_profiles[self._profile_count] = copy.deepcopy(profile)``)
+  needs to sever the alias, exactly as in the two methods above.
+- ``_time_acc1_vel_two_step``/``_time_acc0_two_step``/``_time_vel_two_step``/
+  ``_time_none_two_step`` are "only for numerical issues" (Swift's own
+  comment) and, per a source-tree grep, are **never called from
+  ``getProfile``** -- dead code in the Swift source too. Ported anyway
+  (otg.md design constraint 2: "if a Swift branch looks dead, port it
+  anyway and note it"). Each is architecturally like
+  ``VelocityThirdOrderStep2``'s "no copy needed" methods (a single
+  ``profile`` mutated directly, always returning on the first success), so
+  no alias hazard exists within them -- deep copies are still applied at
+  every save for uniformity with the rest of this file, not because they
+  are load-bearing here.
+- ``get_profile``'s "trivial zero" special case (``v0``, ``a0``, and ``pd``
+  all ~0) faithfully reproduces an apparent Swift quirk: ``var p =
+  validProfiles[profileCount]`` is passed to ``timeAllSingleStep(&p, ...)``
+  by ``inout``, and on success only ``profileCount += 1`` runs --
+  ``validProfiles[profileCount]`` itself is never reassigned from ``p``.
+  In Swift's struct semantics this discards ``p``'s computed
+  ``j``/``p``/``v``/``a``/``direction``/``limits``/``control_signs``
+  fields, leaving the slot with only its ``set_boundary`` state (this
+  doesn't affect correctness for the reachable inputs: the case is only
+  entered when ``v0``, ``a0``, ``pd`` are all ~0, so
+  ``_time_all_single_step`` always finds the trivial *all-zero-``t``*
+  solution here, which is exactly what an unmutated, freshly-``set_boundary``
+  slot already has). Ported as ``p = copy.deepcopy(self.valid_profiles[
+  self._profile_count])`` with no write-back, reproducing the same
+  discard rather than "fixing" it.
+"""
+
+from __future__ import annotations
+
+import copy
+import math
+import sys
+
+from math_tools.functional.roots import solve_quartic_monic
+from math_tools.otg.block import Block, Interval
+from math_tools.otg.enums import ControlSigns, ReachedLimits
+from math_tools.otg.profile import Profile
+from math_tools.otg.steps.position_third_order_step2 import _ieee754_sqrt
+
+__all__: list[str] = []
+
+#: Swift ``Double.ulpOfOne`` (machine epsilon for float64) -- used for the
+#: "vf/af/v0/a0/pd essentially zero" guards in ``get_profile`` and
+#: ``_time_all_single_step``. Matches ``steps/velocity_third_order.py``'s
+#: identical module-private convention (this is NOT
+#: ``functional.roots.EPS16``).
+_ULP = sys.float_info.epsilon
+
+#: Swift ``Double.leastNormalMagnitude`` (smallest positive normalized
+#: float64, ~2.2250738585072014e-308) -- used for the near-zero guards in
+#: ``get_profile``, ``_time_all_single_step``, and
+#: ``_time_all_none_acc0_acc1``'s Newton-refinement root guards. Distinct
+#: from ``_ULP`` above (both are used in this Swift file, unlike the
+#: single-constant velocity/position-second-order files).
+_LEAST_NORMAL_MAGNITUDE = sys.float_info.min
+
+
+def _ieee754_div(numerator: float, denominator: float) -> float:
+    """IEEE 754 float division (Swift/C ``Double`` ``/`` semantics):
+    ``0.0/0.0`` is ``nan``, ``x/0.0`` (``x != 0``) is a signed infinity --
+    never a crash. Python's ``/`` operator raises ``ZeroDivisionError`` on
+    any zero denominator instead, which diverges from the Swift source at
+    the ``t == 0`` degenerate quartic-root case in
+    ``_time_all_none_acc0_acc1``'s NONE loop (a legitimate
+    ``insertIfPositive``-returned root when the polynomial's constant term
+    is zero -- see ``t_min_none == 0`` in ``get_profile``'s rest-to-rest
+    tests). Swift silently propagates the resulting nan/inf into
+    ``profile.t[0]``, which then fails ``profile.check``'s precision
+    comparisons (nan/inf comparisons are always false) rather than
+    crashing; reproduced here explicitly since Python has no implicit
+    equivalent for this operator.
+    """
+    if denominator != 0.0:
+        return numerator / denominator
+    if numerator == 0.0:
+        return math.nan
+    return math.copysign(math.inf, numerator) * math.copysign(1.0, denominator)
+
+
+class PositionThirdOrderStep1:
+    """Mathematical equations for Step 1 in the third-order (jerk-limited)
+    position interface: extremal (time-optimal) profiles."""
+
+    def __init__(
+        self,
+        p0: float,
+        v0: float,
+        a0: float,
+        pf: float,
+        vf: float,
+        af: float,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> None:
+        self.v0 = v0
+        self.a0 = a0
+        self.vf = vf
+        self.af = af
+        self._v_max = v_max
+        self._v_min = v_min
+        self._a_max = a_max
+        self._a_min = a_min
+        self._j_max = j_max
+
+        # Pre-calculated expressions.
+        self.pd = pf - p0
+        self.v0_p2 = v0 * v0
+        self.vf_p2 = vf * vf
+        self.a0_p2 = a0 * a0
+        self.af_p2 = af * af
+        self.a0_p3 = a0 * self.a0_p2
+        self.a0_p4 = self.a0_p2 * self.a0_p2
+        self.af_p3 = af * self.af_p2
+        self.af_p4 = self.af_p2 * self.af_p2
+        self.j_max_p2 = j_max * j_max
+
+        # Max 5 valid profiles + 1 spare for numerical issues. Separate
+        # instances, not shared references (`[Profile()] * 6` would create
+        # multiple references to the SAME object).
+        self.valid_profiles: list[Profile] = [Profile() for _ in range(6)]
+        self._profile_count = 0
+
+    def _add_profile(self) -> None:
+        self._profile_count += 1
+        if self._profile_count < len(self.valid_profiles):
+            self.valid_profiles[self._profile_count].set_boundary(
+                self.valid_profiles[self._profile_count - 1]
+            )
+
+    def _reset_profiles(self) -> None:
+        self._profile_count = 0
+
+    def _has_profiles(self) -> bool:
+        return self._profile_count > 0
+
+    def _time_all_vel(
+        self,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+        return_after_found: bool,
+    ) -> None:
+        profile = copy.deepcopy(self.valid_profiles[self._profile_count])
+
+        # ACC0_ACC1_VEL
+        # NOTE: this profile type explicitly uses aMax/aMin in the formulas
+        # below, so it inherently respects acceleration limits. No
+        # additional checking needed.
+        profile.t[0] = (-self.a0 + a_max) / j_max
+        profile.t[1] = (self.a0_p2 / 2 - a_max * a_max - j_max * (self.v0 - v_max)) / (
+            a_max * j_max
+        )
+        profile.t[2] = a_max / j_max
+        profile.t[3] = (
+            3 * (self.a0_p4 * a_min - self.af_p4 * a_max)
+            + 8
+            * a_max
+            * a_min
+            * (self.af_p3 - self.a0_p3 + 3 * j_max * (self.a0 * self.v0 - self.af * self.vf))
+            + 6 * self.a0_p2 * a_min * (a_max * a_max - 2 * j_max * self.v0)
+            - 6 * self.af_p2 * a_max * (a_min * a_min - 2 * j_max * self.vf)
+            - 12
+            * j_max
+            * (
+                a_max
+                * a_min
+                * (a_max * (self.v0 + v_max) - a_min * (self.vf + v_max) - 2 * j_max * self.pd)
+                + (a_min - a_max) * j_max * v_max * v_max
+                + j_max * (a_max * self.vf_p2 - a_min * self.v0_p2)
+            )
+        ) / (24 * a_max * a_min * self.j_max_p2 * v_max)
+        profile.t[4] = -a_min / j_max
+        profile.t[5] = -(self.af_p2 / 2 - a_min * a_min - j_max * (self.vf - v_max)) / (
+            a_min * j_max
+        )
+        profile.t[6] = profile.t[4] + self.af / j_max
+
+        if profile.check(
+            j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC0_ACC1_VEL
+        ):
+            self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+            self._add_profile()
+            if return_after_found:
+                return
+
+        # ACC1_VEL
+        # BUG FIX: this profile type calculates times based only on vMax
+        # and jMax for the acceleration phase, without explicitly
+        # constraining to aMax/aMin. We need to check whether the
+        # resulting peak acceleration in the acceleration phase would
+        # violate limits. The deceleration phase explicitly uses aMin, so
+        # it's automatically constrained.
+        t_acc0 = _ieee754_sqrt(self.a0_p2 / (2 * self.j_max_p2) + (v_max - self.v0) / j_max)
+        a_peak_acc0 = j_max * t_acc0
+
+        # Check whether the peak is within [aMin, aMax] (handles both UP
+        # and DOWN directions).
+        a_limit_min = min(a_min, a_max)
+        a_limit_max = max(a_min, a_max)
+
+        if a_limit_min <= a_peak_acc0 <= a_limit_max:
+            # Acceleration-phase peak is within limits. The deceleration
+            # phase uses aMin directly, so it's automatically constrained.
+            # Generate the profile.
+            profile.t[0] = t_acc0 - self.a0 / j_max
+            profile.t[1] = 0.0
+            profile.t[2] = t_acc0
+            profile.t[3] = (
+                -3 * self.af_p4
+                + 8 * a_min * (self.af_p3 - self.a0_p3)
+                + 24 * a_min * j_max * (self.a0 * self.v0 - self.af * self.vf)
+                - 6 * self.af_p2 * (a_min * a_min - 2 * j_max * self.vf)
+                + 12
+                * j_max
+                * (
+                    2 * a_min * j_max * self.pd
+                    + a_min * a_min * (self.vf + v_max)
+                    + j_max * (v_max * v_max - self.vf_p2)
+                    + a_min * t_acc0 * (self.a0_p2 - 2 * j_max * (self.v0 + v_max))
+                )
+            ) / (24 * a_min * self.j_max_p2 * v_max)
+            profile.t[4] = -a_min / j_max
+            profile.t[5] = -(self.af_p2 / 2 - a_min * a_min - j_max * (self.vf - v_max)) / (
+                a_min * j_max
+            )
+            profile.t[6] = profile.t[4] + self.af / j_max
+
+            if profile.check(
+                j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC1_VEL
+            ):
+                self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+                self._add_profile()
+                if return_after_found:
+                    return
+
+        # ACC0_VEL
+        t_acc1 = _ieee754_sqrt(self.af_p2 / (2 * self.j_max_p2) + (v_max - self.vf) / j_max)
+
+        # BUG FIX: check whether the peak acceleration would exceed limits
+        # (preserve sign!).
+        a_peak_acc1_acc0vel = j_max * t_acc1
+
+        if a_limit_min <= a_peak_acc1_acc0vel <= a_limit_max:
+            profile.t[0] = (-self.a0 + a_max) / j_max
+            profile.t[1] = (self.a0_p2 / 2 - a_max * a_max - j_max * (self.v0 - v_max)) / (
+                a_max * j_max
+            )
+            profile.t[2] = a_max / j_max
+            profile.t[3] = (
+                3 * self.a0_p4
+                + 8 * a_max * (self.af_p3 - self.a0_p3)
+                + 24 * a_max * j_max * (self.a0 * self.v0 - self.af * self.vf)
+                + 6 * self.a0_p2 * (a_max * a_max - 2 * j_max * self.v0)
+                - 12
+                * j_max
+                * (
+                    -2 * a_max * j_max * self.pd
+                    + a_max * a_max * (self.v0 + v_max)
+                    + j_max * (v_max * v_max - self.v0_p2)
+                    + a_max * t_acc1 * (-self.af_p2 + 2 * (self.vf + v_max) * j_max)
+                )
+            ) / (24 * a_max * self.j_max_p2 * v_max)
+            profile.t[4] = t_acc1
+            profile.t[5] = 0.0
+            profile.t[6] = t_acc1 + self.af / j_max
+
+            if profile.check(
+                j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC0_VEL
+            ):
+                self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+                self._add_profile()
+                if return_after_found:
+                    return
+
+        # VEL
+        # BUG FIX: re-check tAcc0 and tAcc1 for the VEL profile (they were
+        # calculated earlier). Peak accelerations: a_peak_acc0 (already
+        # calculated), a_peak_acc1 (need t_acc1).
+        t_acc1_vel = _ieee754_sqrt(self.af_p2 / (2 * self.j_max_p2) + (v_max - self.vf) / j_max)
+        a_peak_acc1_vel = j_max * t_acc1_vel
+
+        # Check whether both phases respect limits (directional check, not
+        # abs!). a_limit_min/max were already calculated above for
+        # ACC1_VEL.
+        if (
+            a_limit_min <= a_peak_acc0 <= a_limit_max
+            and a_limit_min <= a_peak_acc1_vel <= a_limit_max
+        ):
+            profile.t[0] = t_acc0 - self.a0 / j_max
+            profile.t[1] = 0.0
+            profile.t[2] = t_acc0
+            profile.t[3] = (
+                (self.af_p3 - self.a0_p3) / (3 * self.j_max_p2 * v_max)
+                + (
+                    self.a0 * self.v0
+                    - self.af * self.vf
+                    + (self.af_p2 * t_acc1_vel + self.a0_p2 * t_acc0) / 2
+                )
+                / (j_max * v_max)
+                - (self.v0 / v_max + 1.0) * t_acc0
+                - (self.vf / v_max + 1.0) * t_acc1_vel
+                + self.pd / v_max
+            )
+
+            if profile.check(
+                j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.VEL
+            ):
+                self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+                self._add_profile()
+                if return_after_found:
+                    return
+
+    def _time_acc0_acc1(
+        self,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+        return_after_found: bool,
+    ) -> None:
+        profile = copy.deepcopy(self.valid_profiles[self._profile_count])
+
+        h1 = (
+            3 * (self.af_p4 * a_max - self.a0_p4 * a_min)
+            + a_max
+            * a_min
+            * (
+                8 * (self.a0_p3 - self.af_p3)
+                + 3 * a_max * a_min * (a_max - a_min)
+                + 6 * a_min * self.af_p2
+                - 6 * a_max * self.a0_p2
+            )
+            + 12
+            * j_max
+            * (
+                a_max * a_min * ((a_max - 2 * self.a0) * self.v0 - (a_min - 2 * self.af) * self.vf)
+                + a_min * self.a0_p2 * self.v0
+                - a_max * self.af_p2 * self.vf
+            )
+        ) / (3 * (a_max - a_min) * self.j_max_p2)
+
+        h1 += (
+            4
+            * (a_max * self.vf_p2 - a_min * self.v0_p2 - 2 * a_min * a_max * self.pd)
+            / (a_max - a_min)
+        )
+
+        if h1 >= 0:
+            h1 = _ieee754_sqrt(h1) / 2
+
+            h2 = (
+                self.a0_p2 / (2 * a_max * j_max)
+                + (a_min - 2 * a_max) / (2 * j_max)
+                - self.v0 / a_max
+            )
+            h3 = (
+                -self.af_p2 / (2 * a_min * j_max)
+                - (a_max - 2 * a_min) / (2 * j_max)
+                + self.vf / a_min
+            )
+
+            # UDDU: Solution 2
+            if h2 > h1 / a_max and h3 > -h1 / a_min:
+                profile.t[0] = (-self.a0 + a_max) / j_max
+                profile.t[1] = h2 - h1 / a_max
+                profile.t[2] = a_max / j_max
+                profile.t[3] = 0.0
+                profile.t[4] = -a_min / j_max
+                profile.t[5] = h3 + h1 / a_min
+                profile.t[6] = profile.t[4] + self.af / j_max
+
+                if profile.check(
+                    j_max,
+                    v_max,
+                    v_min,
+                    a_max,
+                    a_min,
+                    ControlSigns.UDDU,
+                    ReachedLimits.ACC0_ACC1,
+                    True,
+                ):
+                    self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+                    self._add_profile()
+                    if return_after_found:
+                        return
+
+            # UDDU: Solution 1
+            if h2 > -h1 / a_max and h3 > h1 / a_min:
+                profile.t[0] = (-self.a0 + a_max) / j_max
+                profile.t[1] = h2 + h1 / a_max
+                profile.t[2] = a_max / j_max
+                profile.t[3] = 0.0
+                profile.t[4] = -a_min / j_max
+                profile.t[5] = h3 - h1 / a_min
+                profile.t[6] = profile.t[4] + self.af / j_max
+
+                if profile.check(
+                    j_max,
+                    v_max,
+                    v_min,
+                    a_max,
+                    a_min,
+                    ControlSigns.UDDU,
+                    ReachedLimits.ACC0_ACC1,
+                    True,
+                ):
+                    self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+                    self._add_profile()
+
+    def _time_all_none_acc0_acc1(
+        self,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+        return_after_found: bool,
+    ) -> None:
+        # BUG FIX (Swift source comment): reassigned (not just read once)
+        # so a fresh reference can be grabbed after add_profile() advances
+        # to a new slot -- see this module's docstring.
+        profile = copy.deepcopy(self.valid_profiles[self._profile_count])
+
+        # NONE UDDU / UDUD strategy
+        h2_none = (self.a0_p2 - self.af_p2) / (2 * j_max) + (self.vf - self.v0)
+        h2_p2 = h2_none * h2_none
+        t_min_none = (self.a0 - self.af) / j_max
+        t_max_none = (a_max - a_min) / j_max
+
+        polynom_none = [
+            0.0,
+            -2 * (self.a0_p2 + self.af_p2 - 2 * j_max * (self.v0 + self.vf)) / self.j_max_p2,
+            4
+            * (self.a0_p3 - self.af_p3 + 3 * j_max * (self.af * self.vf - self.a0 * self.v0))
+            / (3 * j_max * self.j_max_p2)
+            - 4 * self.pd / j_max,
+            -h2_p2 / self.j_max_p2,
+        ]
+
+        h3_acc0 = (self.a0_p2 - self.af_p2) / (2 * a_max * j_max) + (self.vf - self.v0) / a_max
+        t_min_acc0 = (a_max - self.af) / j_max
+        t_max_acc0 = (a_max - a_min) / j_max
+
+        h0_acc0 = (
+            3 * (self.af_p4 - self.a0_p4)
+            + 8 * (self.a0_p3 - self.af_p3) * a_max
+            + 24 * a_max * j_max * (self.af * self.vf - self.a0 * self.v0)
+            - 6 * self.a0_p2 * (a_max * a_max - 2 * j_max * self.v0)
+            + 6 * self.af_p2 * (a_max * a_max - 2 * j_max * self.vf)
+            + 12
+            * j_max
+            * (
+                j_max * (self.vf_p2 - self.v0_p2 - 2 * a_max * self.pd)
+                - a_max * a_max * (self.vf - self.v0)
+            )
+        )
+        h2_acc0 = -self.af_p2 + a_max * a_max + 2 * j_max * self.vf
+
+        polynom_acc0 = [
+            -2 * a_max / j_max,
+            h2_acc0 / self.j_max_p2,
+            0.0,
+            h0_acc0 / (12 * self.j_max_p2 * self.j_max_p2),
+        ]
+
+        h3_acc1 = (
+            -(self.a0_p2 + self.af_p2) / (2 * j_max * a_min)
+            + a_min / j_max
+            + (self.vf - self.v0) / a_min
+        )
+        t_min_acc1 = (a_min - self.a0) / j_max
+        t_max_acc1 = (a_max - self.a0) / j_max
+
+        h0_acc1 = (
+            (self.a0_p4 - self.af_p4) / 4
+            + 2 * (self.af_p3 - self.a0_p3) * a_min / 3
+            + (self.a0_p2 - self.af_p2) * a_min * a_min / 2
+            + j_max
+            * (
+                self.af_p2 * self.vf
+                + self.a0_p2 * self.v0
+                + 2 * a_min * (j_max * self.pd - self.a0 * self.v0 - self.af * self.vf)
+                + a_min * a_min * (self.v0 + self.vf)
+                + j_max * (self.v0_p2 - self.vf_p2)
+            )
+        )
+        h2_acc1 = self.a0_p2 - self.a0 * a_min + 2 * j_max * self.v0
+
+        polynom_acc1 = [
+            2 * (2 * self.a0 - a_min) / j_max,
+            (5 * self.a0_p2 + a_min * (a_min - 6 * self.a0) + 2 * j_max * self.v0) / self.j_max_p2,
+            2 * (self.a0 - a_min) * h2_acc1 / (self.j_max_p2 * j_max),
+            h0_acc1 / (self.j_max_p2 * self.j_max_p2),
+        ]
+
+        polynom_acc0_min = [
+            polynom_acc0[0] + 4 * t_min_acc0,
+            polynom_acc0[1] + (3 * polynom_acc0[0] + 6 * t_min_acc0) * t_min_acc0,
+            polynom_acc0[2]
+            + (2 * polynom_acc0[1] + (3 * polynom_acc0[0] + 4 * t_min_acc0) * t_min_acc0)
+            * t_min_acc0,
+            polynom_acc0[3]
+            + (
+                polynom_acc0[2]
+                + (polynom_acc0[1] + (polynom_acc0[0] + t_min_acc0) * t_min_acc0) * t_min_acc0
+            )
+            * t_min_acc0,
+        ]
+
+        polynom_acc0_has_solution = (
+            polynom_acc0_min[0] < 0
+            or polynom_acc0_min[1] < 0
+            or polynom_acc0_min[2] < 0
+            or polynom_acc0_min[3] <= 0
+        )
+
+        polynom_acc1_has_solution = any(c < 0 for c in polynom_acc1) or polynom_acc1[3] <= 0
+
+        # Solve quartic polynomial roots.
+        roots_none = sorted(solve_quartic_monic(*polynom_none))
+        roots_acc0 = sorted(solve_quartic_monic(*polynom_acc0)) if polynom_acc0_has_solution else []
+        roots_acc1 = sorted(solve_quartic_monic(*polynom_acc1)) if polynom_acc1_has_solution else []
+
+        # Process roots for NONE.
+        for t_root in roots_none:
+            t = t_root
+            if not (t_min_none <= t <= t_max_none):
+                continue
+            if t > _LEAST_NORMAL_MAGNITUDE:
+                h1 = j_max * t * t
+                orig = (
+                    -h2_p2 / (4 * j_max * t)
+                    + h2_none * (self.af / j_max + t)
+                    + (
+                        4 * self.a0_p3
+                        + 2 * self.af_p3
+                        - 6 * self.a0_p2 * (self.af + 2 * j_max * t)
+                        + 12 * (self.af - self.a0) * j_max * self.v0
+                        + 3 * self.j_max_p2 * (-4 * self.pd + (h1 + 8 * self.v0) * t)
+                    )
+                    / (12 * self.j_max_p2)
+                )
+                deriv = h2_none + 2 * self.v0 - self.a0_p2 / j_max + h2_p2 / (4 * h1) + (3 * h1) / 4
+                t -= orig / deriv
+
+            h0 = _ieee754_div(h2_none, 2 * j_max * t)
+            profile.t[0] = h0 + t / 2 - self.a0 / j_max
+            profile.t[1] = 0.0
+            profile.t[2] = t
+            profile.t[3] = 0.0
+            profile.t[4] = 0.0
+            profile.t[5] = 0.0
+            profile.t[6] = -h0 + t / 2 + self.af / j_max
+
+            if profile.check(
+                j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+            ):
+                self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+                self._add_profile()
+                if return_after_found:
+                    return
+                # BUG FIX: get a fresh profile reference to prevent
+                # corrupting the previously added profile.
+                profile = self.valid_profiles[self._profile_count]
+
+        # Process ACC0 roots.
+        for t_root in roots_acc0:
+            t = t_root
+            if not (t_min_acc0 <= t <= t_max_acc0):
+                continue
+            if t > _LEAST_NORMAL_MAGNITUDE:
+                h1 = j_max * t
+                orig = h0_acc0 / (12 * self.j_max_p2 * t) + t * (h2_acc0 + h1 * (h1 - 2 * a_max))
+                deriv = 2 * (h2_acc0 + h1 * (2 * h1 - 3 * a_max))
+                t -= orig / deriv
+
+            profile.t[0] = (-self.a0 + a_max) / j_max
+            profile.t[1] = h3_acc0 - 2 * t + j_max / a_max * t * t
+            profile.t[2] = t
+            profile.t[3] = 0.0
+            profile.t[4] = 0.0
+            profile.t[5] = 0.0
+            profile.t[6] = (self.af - a_max) / j_max + t
+
+            if profile.check(
+                j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC0
+            ):
+                self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+                self._add_profile()
+                if return_after_found:
+                    return
+                # BUG FIX: get a fresh profile reference to prevent
+                # corrupting the previously added profile.
+                profile = self.valid_profiles[self._profile_count]
+
+        # Process ACC1 roots.
+        for t_root in roots_acc1:
+            t = t_root
+            if not (t_min_acc1 <= t <= t_max_acc1):
+                continue
+            if t > _LEAST_NORMAL_MAGNITUDE:
+                h5 = self.a0_p3 + 2 * j_max * self.a0 * self.v0
+                h1 = j_max * t
+                orig = (
+                    -(
+                        h0_acc1 / 2
+                        + h1
+                        * (
+                            h5
+                            + self.a0 * (a_min - 2 * h1) * (a_min - h1)
+                            + self.a0_p2 * (5 * h1 / 2 - 2 * a_min)
+                            + a_min * a_min * h1 / 2
+                            + j_max * (h1 / 2 - a_min) * (h1 * t + 2 * self.v0)
+                        )
+                    )
+                    / j_max
+                )
+                deriv = (a_min - self.a0 - h1) * (h2_acc1 + h1 * (4 * self.a0 - a_min + 2 * h1))
+                t -= min(orig / deriv, t)
+
+                h1 = j_max * t
+                orig = (
+                    -(
+                        h0_acc1 / 2
+                        + h1
+                        * (
+                            h5
+                            + self.a0 * (a_min - 2 * h1) * (a_min - h1)
+                            + self.a0_p2 * (5 * h1 / 2 - 2 * a_min)
+                            + a_min * a_min * h1 / 2
+                            + j_max * (h1 / 2 - a_min) * (h1 * t + 2 * self.v0)
+                        )
+                    )
+                    / j_max
+                )
+                if abs(orig) > 1e-9:
+                    deriv = (a_min - self.a0 - h1) * (h2_acc1 + h1 * (4 * self.a0 - a_min + 2 * h1))
+                    t -= orig / deriv
+
+                    h1 = j_max * t
+                    orig = (
+                        -(
+                            h0_acc1 / 2
+                            + h1
+                            * (
+                                h5
+                                + self.a0 * (a_min - 2 * h1) * (a_min - h1)
+                                + self.a0_p2 * (5 * h1 / 2 - 2 * a_min)
+                                + a_min * a_min * h1 / 2
+                                + j_max * (h1 / 2 - a_min) * (h1 * t + 2 * self.v0)
+                            )
+                        )
+                        / j_max
+                    )
+                    if abs(orig) > 1e-9:
+                        deriv = (a_min - self.a0 - h1) * (
+                            h2_acc1 + h1 * (4 * self.a0 - a_min + 2 * h1)
+                        )
+                        t -= orig / deriv
+
+            profile.t[0] = t
+            profile.t[1] = 0.0
+            profile.t[2] = (self.a0 - a_min) / j_max + t
+            profile.t[3] = 0.0
+            profile.t[4] = 0.0
+            profile.t[5] = h3_acc1 - (2 * self.a0 + j_max * t) * t / a_min
+            profile.t[6] = (self.af - a_min) / j_max
+
+            if profile.check(
+                j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC1, True
+            ):
+                self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+                self._add_profile()
+                if return_after_found:
+                    return
+                # BUG FIX: get a fresh profile reference to prevent
+                # corrupting the previously added profile.
+                profile = self.valid_profiles[self._profile_count]
+
+    def _time_acc1_vel_two_step(
+        self, v_max: float, v_min: float, a_max: float, a_min: float, j_max: float
+    ) -> None:
+        """Only for numerical issues (Swift ``timeAcc1VelTwoStep``); never
+        called from :meth:`get_profile` in the Swift source either -- a
+        source-tree grep confirms it, ported anyway per otg.md design
+        constraint 2."""
+        profile = copy.deepcopy(self.valid_profiles[self._profile_count])
+
+        profile.t[0] = 0.0
+        profile.t[1] = 0.0
+        profile.t[2] = self.a0 / j_max
+        profile.t[3] = -(
+            3 * self.af_p4
+            - 8 * a_min * (self.af_p3 - self.a0_p3)
+            - 24 * a_min * j_max * (self.a0 * self.v0 - self.af * self.vf)
+            + 6 * self.af_p2 * (a_min * a_min - 2 * j_max * self.vf)
+            - 12
+            * j_max
+            * (
+                2 * a_min * j_max * self.pd
+                + a_min * a_min * (self.vf + v_max)
+                + j_max * (v_max * v_max - self.vf_p2)
+                + a_min * self.a0 * (self.a0_p2 - 2 * j_max * (self.v0 + v_max)) / j_max
+            )
+        ) / (24 * a_min * self.j_max_p2 * v_max)
+        profile.t[4] = -a_min / j_max
+        profile.t[5] = -(self.af_p2 / 2 - a_min * a_min + j_max * (v_max - self.vf)) / (
+            a_min * j_max
+        )
+        profile.t[6] = profile.t[4] + self.af / j_max
+
+        if profile.check(
+            j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC1_VEL
+        ):
+            self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+            self._add_profile()
+
+    def _time_acc0_two_step(
+        self, v_max: float, v_min: float, a_max: float, a_min: float, j_max: float
+    ) -> None:
+        """Never called from :meth:`get_profile` in the Swift source
+        either -- ported anyway per otg.md design constraint 2."""
+        profile = copy.deepcopy(self.valid_profiles[self._profile_count])
+
+        # Two-step profile
+        profile.t[0] = 0.0
+        profile.t[1] = (self.af_p2 - self.a0_p2 + 2 * j_max * (self.vf - self.v0)) / (
+            2 * self.a0 * j_max
+        )
+        profile.t[2] = (self.a0 - self.af) / j_max
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check(j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC0):
+            self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+            self._add_profile()
+            return
+
+        # Three-step profile - removed pf
+        profile.t[0] = (-self.a0 + a_max) / j_max
+        profile.t[1] = (
+            self.a0_p2 + self.af_p2 - 2 * a_max * a_max + 2 * j_max * (self.vf - self.v0)
+        ) / (2 * a_max * j_max)
+        profile.t[2] = (-self.af + a_max) / j_max
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check(j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC0):
+            self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+            self._add_profile()
+            return
+
+        # Three-step profile - removed aMax
+        h0 = 3 * (self.af_p2 - self.a0_p2 + 2 * j_max * (self.v0 + self.vf))
+        h2 = (
+            self.a0_p3
+            + 2 * self.af_p3
+            + 6 * self.j_max_p2 * self.pd
+            + 6 * (self.af - self.a0) * j_max * self.vf
+            - 3 * self.a0 * self.af_p2
+        )
+
+        discriminant_numerator = 2 * (
+            2 * h2 * h2
+            + h0
+            * (
+                self.a0_p4
+                - 6 * self.a0_p2 * (self.af_p2 + 2 * j_max * self.vf)
+                + 8
+                * self.a0
+                * (self.af_p3 + 3 * self.j_max_p2 * self.pd + 3 * self.af * j_max * self.vf)
+                - 3
+                * (
+                    self.af_p4
+                    + 4 * self.af_p2 * j_max * self.vf
+                    + 4 * self.j_max_p2 * (self.vf_p2 - self.v0_p2)
+                )
+            )
+        )
+
+        h1 = _ieee754_sqrt(discriminant_numerator) * abs(j_max) / j_max
+
+        profile.t[0] = (
+            4 * self.af_p3
+            + 2 * self.a0_p3
+            - 6 * self.a0 * self.af_p2
+            + 12 * self.j_max_p2 * self.pd
+            + 12 * (self.af - self.a0) * j_max * self.vf
+            + h1
+        ) / (2 * j_max * h0)
+
+        profile.t[1] = -h1 / (j_max * h0)
+
+        profile.t[2] = (
+            -4 * self.a0_p3
+            - 2 * self.af_p3
+            + 6 * self.a0_p2 * self.af
+            + 12 * self.j_max_p2 * self.pd
+            - 12 * (self.af - self.a0) * j_max * self.v0
+            + h1
+        ) / (2 * j_max * h0)
+
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check(j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC0):
+            self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+            self._add_profile()
+            return
+
+        # Three-step profile - t = (aMax - aMin) / jMax
+        t = (a_max - a_min) / j_max
+
+        profile.t[0] = (-self.a0 + a_max) / j_max
+        profile.t[1] = (
+            (self.a0_p2 - self.af_p2) / (2 * a_max * j_max)
+            + (self.vf - self.v0 + j_max * t * t) / a_max
+            - 2 * t
+        )
+        profile.t[2] = t
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = (self.af - a_min) / j_max
+
+        if profile.check(j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC0):
+            self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+            self._add_profile()
+            return
+
+    def _time_vel_two_step(
+        self, v_max: float, v_min: float, a_max: float, a_min: float, j_max: float
+    ) -> None:
+        """Never called from :meth:`get_profile` in the Swift source
+        either -- ported anyway per otg.md design constraint 2."""
+        profile = copy.deepcopy(self.valid_profiles[self._profile_count])
+
+        h1 = _ieee754_sqrt(self.af_p2 / (2 * self.j_max_p2) + (v_max - self.vf) / j_max)
+
+        # Four-step profile: Solution 3/4
+        profile.t[0] = -self.a0 / j_max
+        profile.t[1] = 0.0
+        profile.t[2] = 0.0
+        profile.t[3] = (
+            (self.af_p3 - self.a0_p3) / (3 * self.j_max_p2 * v_max)
+            + (self.a0 * self.v0 - self.af * self.vf + (self.af_p2 * h1) / 2) / (j_max * v_max)
+            - (self.vf / v_max + 1.0) * h1
+            + self.pd / v_max
+        )
+        profile.t[4] = h1
+        profile.t[5] = 0.0
+        profile.t[6] = h1 + self.af / j_max
+
+        if profile.check(j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.VEL):
+            self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+            self._add_profile()
+            return
+
+        # Four-step profile: Alternative
+        profile.t[0] = 0.0
+        profile.t[1] = 0.0
+        profile.t[2] = self.a0 / j_max
+        profile.t[3] = (
+            (self.af_p3 - self.a0_p3) / (3 * self.j_max_p2 * v_max)
+            + (self.a0 * self.v0 - self.af * self.vf + (self.af_p2 * h1 + self.a0_p3 / j_max) / 2)
+            / (j_max * v_max)
+            - (self.v0 / v_max + 1.0) * self.a0 / j_max
+            - (self.vf / v_max + 1.0) * h1
+            + self.pd / v_max
+        )
+        profile.t[4] = h1
+        profile.t[5] = 0.0
+        profile.t[6] = h1 + self.af / j_max
+
+        if profile.check(j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.VEL):
+            self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+            self._add_profile()
+            return
+
+    def _time_none_two_step(
+        self, v_max: float, v_min: float, a_max: float, a_min: float, j_max: float
+    ) -> None:
+        """Never called from :meth:`get_profile` in the Swift source
+        either -- ported anyway per otg.md design constraint 2."""
+        profile = copy.deepcopy(self.valid_profiles[self._profile_count])
+
+        # Two step
+        h0 = (
+            _ieee754_sqrt((self.a0_p2 + self.af_p2) / 2 + j_max * (self.vf - self.v0))
+            * abs(j_max)
+            / j_max
+        )
+        profile.t[0] = (h0 - self.a0) / j_max
+        profile.t[1] = 0.0
+        profile.t[2] = (h0 - self.af) / j_max
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check(j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE):
+            self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+            self._add_profile()
+            return
+
+        # Single step
+        profile.t[0] = (self.af - self.a0) / j_max
+        profile.t[1] = 0.0
+        profile.t[2] = 0.0
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check(j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE):
+            self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+            self._add_profile()
+            return
+
+    def _time_all_single_step(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> bool:
+        """Only for the zero-limits case."""
+        del j_max  # unused in the Swift source too -- profile.check is
+        # always called with a hardcoded 0.0 jerk, never this parameter.
+        if abs(self.af - self.a0) > _LEAST_NORMAL_MAGNITUDE:
+            return False
+
+        profile.t = [0.0] * 7
+
+        if abs(self.a0) > _LEAST_NORMAL_MAGNITUDE:
+            q = _ieee754_sqrt(2 * self.a0 * self.pd + self.v0_p2)
+
+            # Solution 1
+            profile.t[3] = (-self.v0 + q) / self.a0
+            if profile.t[3] >= 0.0 and profile.check(
+                0.0, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+            ):
+                return True
+
+            # Solution 2
+            profile.t[3] = -(self.v0 + q) / self.a0
+            if profile.t[3] >= 0.0 and profile.check(
+                0.0, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+            ):
+                return True
+
+        elif abs(self.v0) > _ULP:
+            profile.t[3] = self.pd / self.v0
+            if profile.check(
+                0.0, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+            ):
+                return True
+
+        elif abs(self.pd) < _ULP:
+            if profile.check(
+                0.0, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+            ):
+                return True
+
+        return False
+
+    def get_profile(self, input_profile: Profile, block: Block) -> bool:
+        # Zero-limits special case.
+        if self._j_max == 0.0 or self._a_max == 0.0 or self._a_min == 0.0:
+            p = copy.deepcopy(block.p_min)
+            p.set_boundary(input_profile)
+
+            if self._time_all_single_step(
+                p, self._v_max, self._v_min, self._a_max, self._a_min, self._j_max
+            ):
+                block.p_min = p
+                block.t_min = p.t_sum[-1] + p.brake.duration + p.accel.duration
+                if abs(self.v0) > _LEAST_NORMAL_MAGNITUDE or abs(self.a0) > _LEAST_NORMAL_MAGNITUDE:
+                    block.a = Interval(block.t_min, math.inf)
+                return True
+            return False
+
+        self._reset_profiles()
+        self.valid_profiles[self._profile_count].set_boundary(input_profile)
+
+        if abs(self.vf) < _ULP and abs(self.af) < _ULP:
+            v_max = self._v_max if self.pd >= 0 else self._v_min
+            v_min = self._v_min if self.pd >= 0 else self._v_max
+            a_max = self._a_max if self.pd >= 0 else self._a_min
+            a_min = self._a_min if self.pd >= 0 else self._a_max
+            j_max = self._j_max if self.pd >= 0 else -self._j_max
+
+            # Special case: when v0, a0, and pd are all essentially zero.
+            if abs(self.v0) < _ULP and abs(self.a0) < _ULP and abs(self.pd) < _ULP:
+                # For the trivial case where we're already at the target,
+                # try time_all_single_step first.
+                p = copy.deepcopy(self.valid_profiles[self._profile_count])
+                if self._time_all_single_step(p, v_max, v_min, a_max, a_min, j_max):
+                    self._profile_count += 1
+                else:
+                    self._time_all_none_acc0_acc1(v_max, v_min, a_max, a_min, j_max, True)
+            else:
+                # There is no blocked interval when vf==0 && af==0, so
+                # return after the first found profile.
+                self._time_all_vel(v_max, v_min, a_max, a_min, j_max, True)
+                if self._has_profiles():
+                    success, _ = Block.calculate_block(
+                        block, self.valid_profiles, self._profile_count
+                    )
+                    return success
+
+                self._time_all_none_acc0_acc1(v_max, v_min, a_max, a_min, j_max, True)
+
+            if self._has_profiles():
+                success, _ = Block.calculate_block(block, self.valid_profiles, self._profile_count)
+                return success
+
+            # Try profiles one by one and exit early if found.
+            directions = [
+                (v_max, v_min, a_max, a_min, j_max),
+                (v_max, v_min, a_max, a_min, j_max),
+                (v_max, v_min, a_max, a_min, j_max),
+                (v_min, v_max, a_min, a_max, -j_max),
+                (v_min, v_max, a_min, a_max, -j_max),
+                (v_min, v_max, a_min, a_max, -j_max),
+            ]
+
+            for d_v_max, d_v_min, d_a_max, d_a_min, d_j_max in directions:
+                self._time_all_vel(d_v_max, d_v_min, d_a_max, d_a_min, d_j_max, True)
+                if self._has_profiles():
+                    success, _ = Block.calculate_block(
+                        block, self.valid_profiles, self._profile_count
+                    )
+                    return success
+
+                self._time_all_none_acc0_acc1(d_v_max, d_v_min, d_a_max, d_a_min, d_j_max, True)
+                if self._has_profiles():
+                    success, _ = Block.calculate_block(
+                        block, self.valid_profiles, self._profile_count
+                    )
+                    return success
+
+                self._time_acc0_acc1(d_v_max, d_v_min, d_a_max, d_a_min, d_j_max, True)
+                if self._has_profiles():
+                    success, _ = Block.calculate_block(
+                        block, self.valid_profiles, self._profile_count
+                    )
+                    return success
+
+        else:
+            # General search for profiles. Prioritize profiles with proper
+            # limit handling to avoid acceleration violations.
+            self._time_all_vel(
+                self._v_max, self._v_min, self._a_max, self._a_min, self._j_max, False
+            )
+            self._time_all_vel(
+                self._v_min, self._v_max, self._a_min, self._a_max, -self._j_max, False
+            )
+            self._time_acc0_acc1(
+                self._v_max, self._v_min, self._a_max, self._a_min, self._j_max, False
+            )
+            self._time_acc0_acc1(
+                self._v_min, self._v_max, self._a_min, self._a_max, -self._j_max, False
+            )
+            self._time_all_none_acc0_acc1(
+                self._v_max, self._v_min, self._a_max, self._a_min, self._j_max, False
+            )
+            self._time_all_none_acc0_acc1(
+                self._v_min, self._v_max, self._a_min, self._a_max, -self._j_max, False
+            )
+
+        success, _ = Block.calculate_block(block, self.valid_profiles, self._profile_count)
+        return success
diff --git a/src/math_tools/otg/steps/position_third_order_step2.py b/src/math_tools/otg/steps/position_third_order_step2.py
new file mode 100644
index 0000000..991f3f9
--- /dev/null
+++ b/src/math_tools/otg/steps/position_third_order_step2.py
@@ -0,0 +1,2744 @@
+"""Step 2 solver for the third-order (jerk-limited) position interface:
+computes the profile that reaches the target at an EXACT prescribed
+duration (time synchronization) -- the synchronization workhorse used to
+line multiple DOFs up on a common trajectory duration.
+
+Faithful port of ``SWIFT_MATH/OTG/position/PositionThirdOrderStep2.swift``
+(~1,900 lines; the single largest file in the OTG port). See
+``.claude/specs/otg.md`` §Internal fidelity requirements 2, 4, 5 and
+``.claude/action-plan/39-otg-position-third-step2.md``.
+
+**No alias-mutation hazard.** Unlike ``PositionThirdOrderStep1``
+(``steps/position_third_order_step1.py``), this class does not accumulate a
+``validProfiles`` list of saved candidates: every ``time*`` method takes and
+mutates the single caller-owned ``Profile`` directly (an ``inout profile``
+in Swift), trying its candidate branches in sequence and returning ``True``
+on the first one that passes ``Profile.check_with_timing``. This is
+architecturally identical to ``VelocityThirdOrderStep2``
+(``steps/velocity_third_order.py``) -- no ``copy.deepcopy`` is needed
+anywhere in this file.
+
+**Dropped debug logging.** The Swift ``timeVel`` method guards a large
+block of ``print(...)`` calls behind a hardcoded ``let debugTimeVel =
+false`` -- permanently dead, developer-only tracing, not part of the
+algorithm. Those prints are not ported (there is nothing to preserve:
+``debugTimeVel`` is never ``true``); every branch, root search, and Newton
+step they wrap around is preserved exactly.
+
+**Dead branch, ported anyway.** ``timeNoneSmooth`` (Swift) /
+``_time_none_smooth`` (here) is never called from ``getProfile`` in the
+Swift source (grep-confirmed) -- ported anyway per otg.md design
+constraint 2, mirroring ``PositionThirdOrderStep1``'s ``*_two_step``
+precedent.
+
+**Source quirk preserved verbatim.** ``timeAcc0``'s second ``do`` block is
+labeled ``// UDUD`` in the Swift source but its ``checkWithTiming`` call
+actually passes ``.UDDU`` -- a mismatched comment, not a bug in the
+executed logic. Ported as literally written (``ControlSigns.UDDU``), not
+"corrected" to match the comment, per otg.md's "translate mechanically;
+do not restructure" rule.
+
+**No ``_ieee754_div`` in this file.** otg.md §Internal fidelity requirement
+4 only routes a division through the IEEE-754-semantics helper where a
+*failing test* has shown a genuine Swift-``Double``-zero-denominator
+hazard is reachable (see ``position_third_order_step1.py``'s
+``_time_all_none_acc0_acc1``). No such case surfaced while developing this
+chunk's test suite (three analytic cases at three prescribed-duration
+scale factors each, plus a below-optimal negative case); every ``/`` here
+is a plain Python division. If a future oracle/regression case reaches a
+genuine zero denominator, add the helper then, scoped to that one site.
+"""
+
+from __future__ import annotations
+
+import math
+
+from math_tools.functional.roots import (
+    evaluate_polynomial,
+    polynomial_derivative,
+    polynomial_monic_derivative,
+    shrink_interval,
+    solve_cubic,
+    solve_quartic_monic,
+)
+from math_tools.otg.enums import ControlSigns, ReachedLimits
+from math_tools.otg.profile import Profile
+
+__all__: list[str] = []
+
+#: Swift module-private ``tolerance`` constant (``PositionThirdOrderStep2.swift``
+#: line 10) -- distinct from ``functional.roots``' ``POLYNOMIAL_TOLERANCE``
+#: and from ``Profile``'s own epsilon constants.
+_TOLERANCE = 1e-14
+
+#: Swift ``Double.ulpOfOne`` (machine epsilon for float64).
+_ULP = 2.220446049250313e-16
+
+
+def _pow2(x: float) -> float:
+    """Swift ``private func pow2(_:)`` -- squares ``x``."""
+    return x * x
+
+
+def _ieee754_sqrt(x: float) -> float:
+    """IEEE 754 square root (Swift/C ``Double`` ``sqrt`` semantics): a
+    negative argument silently yields ``nan`` -- never a crash. Python's
+    ``math.sqrt`` raises ``ValueError`` on a negative argument instead,
+    which diverges from the Swift source whenever a candidate branch's
+    discriminant goes negative for a physically infeasible prescribed
+    duration (below the Step1 time-optimal minimum) -- exactly the
+    scenario this chunk's "below-optimal duration is infeasible" test
+    exercises (see ``otg.md`` §Internal fidelity requirement 4's
+    ``_ieee754_div`` precedent, the same principle applied to ``sqrt``).
+    Swift silently propagates the resulting ``nan`` into ``profile.t[...]``,
+    which then fails ``Profile.check``'s precision comparisons (``nan``
+    comparisons are always false) rather than crashing; reproduced here
+    explicitly.
+
+    Unlike ``_ieee754_div`` (below) -- and unlike otg.md's own scoping note
+    for division, which is deliberately NOT a blanket rule -- this helper
+    IS used at every ``sqrt`` call site in this file rather than only the
+    literal one the negative-duration test first tripped over. Once that
+    test proved the hazard reachable, tracing it turned up a *cascade*:
+    ``get_profile`` tries well over a dozen candidate branches in
+    sequence for an infeasible (too-short) prescribed duration, and a
+    negative discriminant is the generic, expected way each of those
+    branches' algebra signals "no real solution here" -- not a rare
+    degenerate root the way a zero denominator is for ``_ieee754_div``'s
+    documented site. Patching sites one Newton-recursion at a time (this
+    file has ~30 ``sqrt`` calls) would not change the outcome, only the
+    number of iterations; wrapping every ``sqrt`` in this file (and only
+    this file -- otg.md design constraint 4's per-site scoping still
+    applies elsewhere) is the minimal change that matches the actually
+    demonstrated failure mode. See ``39-otg-position-third-step2.md``'s
+    Resolution notes for the full account.
+    """
+    if x < 0.0:
+        return math.nan
+    return math.sqrt(x)
+
+
+def _ieee754_div(numerator: float, denominator: float) -> float:
+    """IEEE 754 float division (Swift/C ``Double`` ``/`` semantics):
+    ``0.0/0.0`` is ``nan``, ``x/0.0`` (``x != 0``) is a signed infinity --
+    never a crash. Python's ``/`` operator raises ``ZeroDivisionError`` on
+    any zero denominator instead. Matches
+    ``steps/position_third_order_step1.py``'s identical helper (otg.md
+    §Internal fidelity requirement 4); applied here ONLY at the specific
+    site(s) this chunk's below-optimal-duration test showed reachable --
+    unlike ``_ieee754_sqrt`` above, this is NOT a blanket replacement of
+    every ``/`` in this file.
+    """
+    if denominator != 0.0:
+        return numerator / denominator
+    if numerator == 0.0:
+        return math.nan
+    return math.copysign(math.inf, numerator) * math.copysign(1.0, denominator)
+
+
+class PositionThirdOrderStep2:
+    """Mathematical equations for Step 2 in third-order position interface:
+    time synchronization."""
+
+    def __init__(
+        self,
+        tf: float,
+        p0: float,
+        v0: float,
+        a0: float,
+        pf: float,
+        vf: float,
+        af: float,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> None:
+        self.p0 = p0
+        self.v0 = v0
+        self.a0 = a0
+        self.tf = tf
+        self.pf = pf
+        self.vf = vf
+        self.af = af
+        self._v_max = v_max
+        self._v_min = v_min
+        self._a_max = a_max
+        self._a_min = a_min
+        self._j_max = j_max
+
+        # Pre-calculated expressions.
+        self.pd = pf - p0
+        self.tf_p2 = tf * tf
+        self.tf_p3 = self.tf_p2 * tf
+        self.tf_p4 = self.tf_p2 * self.tf_p2
+
+        self.vd = vf - v0
+        self.vd_p2 = self.vd * self.vd
+        self.v0_p2 = v0 * v0
+        self.vf_p2 = vf * vf
+
+        self.ad = af - a0
+        self.ad_p2 = self.ad * self.ad
+        self.a0_p2 = a0 * a0
+        self.af_p2 = af * af
+
+        self.a0_p3 = a0 * self.a0_p2
+        self.a0_p4 = self.a0_p2 * self.a0_p2
+        self.a0_p5 = self.a0_p3 * self.a0_p2
+        self.a0_p6 = self.a0_p4 * self.a0_p2
+        self.af_p3 = af * self.af_p2
+        self.af_p4 = self.af_p2 * self.af_p2
+        self.af_p5 = self.af_p3 * self.af_p2
+        self.af_p6 = self.af_p4 * self.af_p2
+
+        self.j_max_p2 = j_max * j_max
+
+        self.g1 = -self.pd + tf * v0
+        self.g2 = -2 * self.pd + tf * (v0 + vf)
+
+        #: Swift declares ``minimize_jerk: Bool = false`` but never reads it
+        #: -- dead field, ported for fidelity per otg.md design constraint 2.
+        self.minimize_jerk = False
+
+    def _time_acc0_acc1_vel(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> bool:
+        """Profile UDDU, Solution 1 / Profile UDUD."""
+        if (2 * (a_max - a_min) + self.ad) / j_max < self.tf:
+            h1 = (
+                _ieee754_sqrt(
+                    (
+                        self.a0_p4
+                        + self.af_p4
+                        - 4 * self.a0_p3 * (2 * a_max + a_min) / 3
+                        - 4 * self.af_p3 * (a_max + 2 * a_min) / 3
+                        + 2 * (self.a0_p2 - self.af_p2) * a_max * a_max
+                        + (4 * self.a0 * a_max - 2 * self.a0_p2)
+                        * (
+                            self.af_p2
+                            - 2 * self.af * a_min
+                            + (a_min - a_max) * a_min
+                            + 2 * j_max * (a_min * self.tf - self.vd)
+                        )
+                        + 2 * self.af_p2 * (a_min * a_min + 2 * j_max * (a_max * self.tf - self.vd))
+                        + 4
+                        * j_max
+                        * (
+                            2 * a_min * (self.af * self.vd + j_max * self.g1)
+                            + (a_max * a_max - a_min * a_min) * self.vd
+                            + j_max * self.vd_p2
+                        )
+                        + 8 * a_max * self.j_max_p2 * (self.pd - self.tf * self.vf)
+                    )
+                    / (a_max * a_min)
+                    + 4 * self.af_p2
+                    + 2 * self.a0_p2
+                    + (4 * self.af + a_max - a_min) * (a_max - a_min)
+                    + 4 * j_max * (a_min - a_max + j_max * self.tf - 2 * self.af) * self.tf
+                )
+                * abs(j_max)
+                / j_max
+            )
+
+            profile.t[0] = (-self.a0 + a_max) / j_max
+            profile.t[1] = (
+                -(
+                    self.af_p2
+                    - self.a0_p2
+                    + 2 * a_max * a_max
+                    + a_min * (a_min - 2 * self.ad - 3 * a_max)
+                    + 2 * j_max * (a_min * self.tf - self.vd)
+                )
+                + a_min * h1
+            ) / (2 * (a_max - a_min) * j_max)
+            profile.t[2] = a_max / j_max
+            profile.t[3] = (a_min - a_max + h1) / (2 * j_max)
+            profile.t[4] = -a_min / j_max
+            profile.t[5] = self.tf - (
+                profile.t[0]
+                + profile.t[1]
+                + profile.t[2]
+                + profile.t[3]
+                + 2 * profile.t[4]
+                + self.af / j_max
+            )
+            profile.t[6] = profile.t[4] + self.af / j_max
+
+            if profile.check_with_timing(
+                self.tf,
+                j_max,
+                v_max,
+                v_min,
+                a_max,
+                a_min,
+                ControlSigns.UDDU,
+                ReachedLimits.ACC0_ACC1_VEL,
+            ):
+                return True
+
+        # Profile UDUD
+        if (-self.a0 + 4 * a_max - self.af) / j_max < self.tf:
+            profile.t[0] = (-self.a0 + a_max) / j_max
+            profile.t[1] = (
+                3 * (self.a0_p4 + self.af_p4)
+                - 4 * (self.a0_p3 + self.af_p3) * a_max
+                - 4 * self.af_p3 * a_max
+                + 24 * (self.a0 + self.af) * a_max * a_max * a_max
+                - 6 * (self.af_p2 + self.a0_p2) * (a_max * a_max - 2 * j_max * self.vd)
+                + 6 * self.a0_p2 * (self.af_p2 - 2 * self.af * a_max - 2 * a_max * j_max * self.tf)
+                - 12
+                * a_max
+                * a_max
+                * (2 * a_max * a_max - 2 * a_max * j_max * self.tf + j_max * self.vd)
+                - 24 * self.af * a_max * j_max * self.vd
+                + 12 * self.j_max_p2 * (2 * a_max * self.g1 + self.vd_p2)
+            ) / (
+                12
+                * a_max
+                * j_max
+                * (
+                    self.a0_p2
+                    + self.af_p2
+                    - 2 * (self.a0 + self.af) * a_max
+                    + 2 * (a_max * a_max - a_max * j_max * self.tf + j_max * self.vd)
+                )
+            )
+            profile.t[2] = a_max / j_max
+            profile.t[3] = (
+                -self.a0_p2
+                - self.af_p2
+                + 2 * a_max * (self.a0 + self.af - 2 * a_max)
+                - 2 * j_max * self.vd
+            ) / (2 * a_max * j_max) + self.tf
+            profile.t[4] = profile.t[2]
+            profile.t[5] = self.tf - (
+                profile.t[0]
+                + profile.t[1]
+                + profile.t[2]
+                + profile.t[3]
+                + 2 * profile.t[4]
+                - self.af / j_max
+            )
+            profile.t[6] = profile.t[4] - self.af / j_max
+
+            if profile.check_with_timing(
+                self.tf,
+                j_max,
+                v_max,
+                v_min,
+                a_max,
+                a_min,
+                ControlSigns.UDUD,
+                ReachedLimits.ACC0_ACC1_VEL,
+            ):
+                return True
+
+        return False
+
+    def _time_acc1_vel(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> bool:
+        """Profile UDDU / Profile UDUD."""
+        ph1uddu = (
+            self.a0_p2
+            + self.af_p2
+            - a_min * (self.a0 + 2 * self.af - a_min)
+            - 2 * j_max * (self.vd - a_min * self.tf)
+        )
+        ph2uddu = (
+            2 * a_min * (j_max * self.g1 + self.af * self.vd)
+            - a_min * a_min * self.vd
+            + j_max * self.vd_p2
+        )
+        ph3uddu = (
+            self.af_p2 + a_min * (a_min - 2 * self.af) - 2 * j_max * (self.vd - a_min * self.tf)
+        )
+
+        polynom_uddu = [
+            (2 * (2 * self.a0 - a_min)) / j_max,
+            (4 * self.a0_p2 + ph1uddu - 3 * self.a0 * a_min) / self.j_max_p2,
+            (2 * self.a0 * ph1uddu) / (self.j_max_p2 * j_max),
+            (
+                3 * (self.a0_p4 + self.af_p4)
+                - 4 * (self.a0_p3 + 2 * self.af_p3) * a_min
+                + 6 * self.af_p2 * (a_min * a_min - 2 * j_max * self.vd)
+                + 12 * j_max * ph2uddu
+                + 6 * self.a0_p2 * ph3uddu
+            )
+            / (12 * self.j_max_p2 * self.j_max_p2),
+        ]
+
+        t_min_uddu = -self.a0 / j_max
+        t_max_uddu = min(
+            (self.tf + 2 * a_min / j_max - (self.a0 + self.af) / j_max) / 2,
+            (a_max - self.a0) / j_max,
+        )
+
+        roots_uddu = sorted(solve_quartic_monic(*polynom_uddu))
+        for t0 in roots_uddu:
+            if t0 < t_min_uddu or t0 > t_max_uddu:
+                continue
+            t = t0
+
+            # Single Newton step (regarding pd).
+            if abs(self.a0 + j_max * t) > 16 * _ULP:
+                h0 = j_max * t * t
+                orig = (
+                    -self.pd
+                    + (
+                        3 * (self.a0_p4 + self.af_p4)
+                        - 8 * self.af_p3 * a_min
+                        - 4 * self.a0_p3 * a_min
+                        + 6 * self.af_p2 * (a_min * a_min + 2 * j_max * (h0 - self.vd))
+                        + 6
+                        * self.a0_p2
+                        * (
+                            self.af_p2
+                            - 2 * self.af * a_min
+                            + a_min * a_min
+                            + 2 * a_min * j_max * (-2 * t + self.tf)
+                            + 2 * j_max * (5 * h0 - self.vd)
+                        )
+                        + 24
+                        * self.a0
+                        * j_max
+                        * t
+                        * (
+                            self.a0_p2
+                            + self.af_p2
+                            - 2 * self.af * a_min
+                            + a_min * a_min
+                            + 2 * j_max * (a_min * (-t + self.tf) + h0 - self.vd)
+                        )
+                        - 24 * self.af * a_min * j_max * (h0 - self.vd)
+                        + 12
+                        * j_max
+                        * (a_min * a_min * (h0 - self.vd) + j_max * (h0 - self.vd) * (h0 - self.vd))
+                    )
+                    / (24 * a_min * self.j_max_p2)
+                    + h0 * (self.tf - t)
+                    + self.tf * self.v0
+                )
+                deriv = (self.a0 + j_max * t) * (
+                    (self.a0_p2 + self.af_p2) / (a_min * j_max)
+                    + (a_min - self.a0 - 2 * self.af) / j_max
+                    + (4 * self.a0 * t + 2 * h0 - 2 * self.vd) / a_min
+                    + 2 * self.tf
+                    - 3 * t
+                )
+                t -= orig / deriv
+
+            h1 = (
+                -(
+                    (self.a0_p2 + self.af_p2) / 2
+                    + j_max * (-self.vd + 2 * self.a0 * t + j_max * t * t)
+                )
+                / a_min
+            )
+
+            profile.t[0] = t
+            profile.t[1] = 0.0
+            profile.t[2] = self.a0 / j_max + t
+            profile.t[3] = self.tf - (h1 - a_min + self.a0 + self.af) / j_max - 2 * t
+            profile.t[4] = -a_min / j_max
+            profile.t[5] = (h1 + a_min) / j_max
+            profile.t[6] = profile.t[4] + self.af / j_max
+
+            if profile.check_with_timing(
+                self.tf,
+                j_max,
+                v_max,
+                v_min,
+                a_max,
+                a_min,
+                ControlSigns.UDDU,
+                ReachedLimits.ACC1_VEL,
+            ):
+                return True
+
+        # Profile UDUD
+        ph1udud = (
+            self.a0_p2
+            - self.af_p2
+            + (2 * self.af - self.a0) * a_max
+            - a_max * a_max
+            - 2 * j_max * (self.vd - a_max * self.tf)
+        )
+        ph2udud = a_max * a_max + 2 * j_max * self.vd
+        ph3udud = self.af_p2 + ph2udud - 2 * a_max * (self.af + j_max * self.tf)
+        ph4udud = 2 * a_max * j_max * self.g1 + a_max * a_max * self.vd + j_max * self.vd_p2
+
+        polynom = [
+            (4 * self.a0 - 2 * a_max) / j_max,
+            (4 * self.a0_p2 - 3 * self.a0 * a_max + ph1udud) / self.j_max_p2,
+            (2 * self.a0 * ph1udud) / (self.j_max_p2 * j_max),
+            (
+                3 * (self.a0_p4 + self.af_p4)
+                - 4 * (self.a0_p3 + 2 * self.af_p3) * a_max
+                - 24 * self.af * a_max * j_max * self.vd
+                + 12 * j_max * ph4udud
+                - 6 * self.a0_p2 * ph3udud
+                + 6 * self.af_p2 * ph2udud
+            )
+            / (12 * self.j_max_p2 * self.j_max_p2),
+        ]
+
+        t_min = -self.a0 / j_max
+        t_max = min((self.tf + self.ad / j_max - 2 * a_max / j_max) / 2, (a_max - self.a0) / j_max)
+
+        roots = sorted(solve_quartic_monic(*polynom))
+        for t in roots:
+            if t > t_max or t < t_min:
+                continue
+
+            h1 = (
+                (self.a0_p2 - self.af_p2) / 2
+                + self.j_max_p2 * t * t
+                - j_max * (self.vd - 2 * self.a0 * t)
+            ) / a_max
+
+            profile.t[0] = t
+            profile.t[1] = 0.0
+            profile.t[2] = t + self.a0 / j_max
+            profile.t[3] = self.tf + (h1 + self.ad - a_max) / j_max - 2 * t
+            profile.t[4] = a_max / j_max
+            profile.t[5] = -(h1 + a_max) / j_max
+            profile.t[6] = profile.t[4] - self.af / j_max
+
+            if profile.check_with_timing(
+                self.tf,
+                j_max,
+                v_max,
+                v_min,
+                a_max,
+                a_min,
+                ControlSigns.UDUD,
+                ReachedLimits.ACC1_VEL,
+            ):
+                return True
+
+        return False
+
+    def _time_acc0_vel(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> bool:
+        if self.tf < max((-self.a0 + a_max) / j_max, 0.0) + max(a_max / j_max, 0.0):
+            return False
+
+        ph1 = (
+            12
+            * j_max
+            * (
+                -a_max * a_max * self.vd
+                - j_max * self.vd_p2
+                + 2 * a_max * j_max * (-self.pd + self.tf * self.vf)
+            )
+        )
+
+        # Profile UDDU
+        polynom_uddu = [
+            (2 * a_max) / j_max,
+            (
+                self.a0_p2
+                - self.af_p2
+                + 2 * self.ad * a_max
+                + a_max * a_max
+                + 2 * j_max * (self.vd - a_max * self.tf)
+            )
+            / self.j_max_p2,
+            0.0,
+            -(
+                -3 * (self.a0_p4 + self.af_p4)
+                + 4 * (self.af_p3 + 2 * self.a0_p3) * a_max
+                - 12 * self.a0 * a_max * (self.af_p2 - 2 * j_max * self.vd)
+                + 6 * self.a0_p2 * (self.af_p2 - a_max * a_max - 2 * j_max * self.vd)
+                + 6
+                * self.af_p2
+                * (a_max * a_max - 2 * a_max * j_max * self.tf + 2 * j_max * self.vd)
+                + ph1
+            )
+            / (12 * self.j_max_p2 * self.j_max_p2),
+        ]
+
+        t_min_uddu = -self.af / j_max
+        t_max_uddu = min(self.tf - (2 * a_max - self.a0) / j_max, -a_min / j_max)
+
+        roots_uddu = sorted(solve_quartic_monic(*polynom_uddu))
+        for t0 in roots_uddu:
+            if t0 < t_min_uddu or t0 > t_max_uddu:
+                continue
+            t = t0
+
+            # Single Newton step (regarding pd).
+            if t > _ULP:
+                h1 = j_max * t * t + self.vd
+                orig = (
+                    -3 * (self.a0_p4 + self.af_p4)
+                    + 4 * (self.af_p3 + 2 * self.a0_p3) * a_max
+                    - 24 * self.af * a_max * self.j_max_p2 * t * t
+                    - 12 * self.a0 * a_max * (self.af_p2 - 2 * j_max * h1)
+                    + 6 * self.a0_p2 * (self.af_p2 - a_max * a_max - 2 * j_max * h1)
+                    + 6
+                    * self.af_p2
+                    * (a_max * a_max - 2 * a_max * j_max * self.tf + 2 * j_max * h1)
+                    - 12
+                    * j_max
+                    * (
+                        a_max * a_max * h1
+                        + j_max * h1 * h1
+                        + 2
+                        * a_max
+                        * j_max
+                        * (self.pd + j_max * t * t * (t - self.tf) - self.tf * self.vf)
+                    )
+                ) / (24 * a_max * self.j_max_p2)
+                deriv = (
+                    -t
+                    * (
+                        self.a0_p2
+                        - self.af_p2
+                        + 2 * a_max * (self.ad - j_max * self.tf)
+                        + a_max * a_max
+                        + 3 * a_max * j_max * t
+                        + 2 * j_max * h1
+                    )
+                    / a_max
+                )
+                t -= orig / deriv
+
+            h1uddu = ((self.a0_p2 - self.af_p2) / 2 + j_max * (j_max * t * t + self.vd)) / a_max
+
+            profile.t[0] = (-self.a0 + a_max) / j_max
+            profile.t[1] = (h1uddu - a_max) / j_max
+            profile.t[2] = a_max / j_max
+            profile.t[3] = self.tf - (h1uddu + self.ad + a_max) / j_max - 2 * t
+            profile.t[4] = t
+            profile.t[5] = 0.0
+            profile.t[6] = self.af / j_max + t
+
+            if profile.check_with_timing(
+                self.tf,
+                j_max,
+                v_max,
+                v_min,
+                a_max,
+                a_min,
+                ControlSigns.UDDU,
+                ReachedLimits.ACC0_VEL,
+            ):
+                return True
+
+        # Profile UDUD
+        polynom = [
+            (-2 * a_max) / j_max,
+            -(
+                self.a0_p2
+                + self.af_p2
+                - 2 * (self.a0 + self.af) * a_max
+                + a_max * a_max
+                + 2 * j_max * (self.vd - a_max * self.tf)
+            )
+            / self.j_max_p2,
+            0.0,
+            (
+                3 * (self.a0_p4 + self.af_p4)
+                - 4 * (self.af_p3 + 2 * self.a0_p3) * a_max
+                + 6 * self.a0_p2 * (self.af_p2 + a_max * a_max + 2 * j_max * self.vd)
+                - 12 * self.a0 * a_max * (self.af_p2 + 2 * j_max * self.vd)
+                + 6
+                * self.af_p2
+                * (a_max * a_max - 2 * a_max * j_max * self.tf + 2 * j_max * self.vd)
+                - ph1
+            )
+            / (12 * self.j_max_p2 * self.j_max_p2),
+        ]
+
+        t_min = self.af / j_max
+        t_max = min(self.tf - a_max / j_max, a_max / j_max)
+
+        roots = sorted(solve_quartic_monic(*polynom))
+        for t0 in roots:
+            if t0 < t_min or t0 > t_max:
+                continue
+            t = t0
+
+            # Single Newton step (regarding pd).
+            h1ududpd = j_max * t * t - self.vd
+            orig = -(
+                3 * (self.a0_p4 + self.af_p4)
+                - 4 * (2 * self.a0_p3 + self.af_p3) * a_max
+                + 24 * self.af * a_max * self.j_max_p2 * t * t
+                - 12 * self.a0 * a_max * (self.af_p2 - 2 * j_max * h1ududpd)
+                + 6 * self.a0_p2 * (self.af_p2 + a_max * a_max - 2 * j_max * h1ududpd)
+                + 6 * self.af_p2 * (a_max * a_max - 2 * j_max * (self.tf * a_max + h1ududpd))
+                + 12
+                * j_max
+                * (
+                    -a_max * a_max * h1ududpd
+                    + j_max * h1ududpd * h1ududpd
+                    - 2
+                    * a_max
+                    * j_max
+                    * (-self.pd + j_max * t * t * (t - self.tf) + self.tf * self.vf)
+                )
+            ) / (24 * a_max * self.j_max_p2)
+            deriv = (
+                t
+                * (
+                    self.a0_p2
+                    + self.af_p2
+                    - 2 * j_max * h1ududpd
+                    - 2 * (self.a0 + self.af + j_max * self.tf) * a_max
+                    + a_max * a_max
+                    + 3 * a_max * j_max * t
+                )
+                / a_max
+            )
+            t -= orig / deriv
+
+            h1udud = ((self.a0_p2 + self.af_p2) / 2 + j_max * (self.vd - j_max * t * t)) / a_max
+
+            profile.t[0] = (-self.a0 + a_max) / j_max
+            profile.t[1] = (h1udud - a_max) / j_max
+            profile.t[2] = a_max / j_max
+            profile.t[3] = self.tf - (h1udud - self.a0 - self.af + a_max) / j_max - 2 * t
+            profile.t[4] = t
+            profile.t[5] = 0.0
+            profile.t[6] = -(self.af / j_max) + t
+
+            if profile.check_with_timing(
+                self.tf,
+                j_max,
+                v_max,
+                v_min,
+                a_max,
+                a_min,
+                ControlSigns.UDUD,
+                ReachedLimits.ACC0_VEL,
+            ):
+                return True
+
+        return False
+
+    def _time_vel(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> bool:
+        tz_min = max(0.0, -self.a0 / j_max)
+        tz_max = min((self.tf - self.a0 / j_max) / 2, (a_max - self.a0) / j_max)
+
+        # Profile UDDU
+        if (
+            abs(self.v0) < _ULP
+            and abs(self.a0) < _ULP
+            and abs(self.vf) < _ULP
+            and abs(self.af) < _ULP
+        ):
+            polynom = [1.0, -self.tf / 2, 0.0, self.pd / (2 * j_max)]
+            roots = sorted(solve_cubic(*polynom))
+
+            for t0 in roots:
+                if t0 > self.tf / 4:
+                    continue
+                t = t0
+
+                # Single Newton step (regarding pd).
+                if t > _ULP:
+                    orig = -self.pd + j_max * t * t * (self.tf - 2 * t)
+                    deriv = 2 * j_max * t * (self.tf - 3 * t)
+                    t -= orig / deriv
+
+                profile.t[0] = t
+                profile.t[1] = 0.0
+                profile.t[2] = t
+                profile.t[3] = self.tf - 4 * t
+                profile.t[4] = t
+                profile.t[5] = 0.0
+                profile.t[6] = t
+
+                if profile.check_with_timing(
+                    self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.VEL
+                ):
+                    return True
+
+        else:
+            p1 = self.af_p2 - 2 * j_max * (
+                -2 * self.af * self.tf + j_max * self.tf_p2 + 3 * self.vd
+            )
+            ph1 = self.af_p3 - 3 * self.j_max_p2 * self.g1 - 3 * self.af * j_max * self.vd
+            ph2 = (
+                self.af_p4
+                + 8 * self.af_p3 * j_max * self.tf
+                + 12
+                * j_max
+                * (
+                    3 * j_max * self.vd_p2
+                    - self.af_p2 * self.vd
+                    + 2 * self.af * j_max * (self.g1 - self.tf * self.vd)
+                    - 2 * self.j_max_p2 * self.tf * self.g1
+                )
+            )
+            ph3 = self.a0 * (self.af - j_max * self.tf)
+            ph4 = j_max * (-self.ad + j_max * self.tf)
+
+            # Find root of 5th order polynom.
+            polynom5 = [0.0] * 6
+            polynom5[0] = 1.0
+            polynom5[1] = (
+                15 * self.a0_p2
+                + self.af_p2
+                + 4 * self.af * j_max * self.tf
+                - 16 * ph3
+                - 2 * j_max * (j_max * self.tf_p2 + 3 * self.vd)
+            ) / (4 * ph4)
+            polynom5[2] = (
+                29 * self.a0_p3
+                - 2 * self.af_p3
+                - 33 * self.a0 * ph3
+                + 6 * self.j_max_p2 * self.g1
+                + 6 * self.af * j_max * self.vd
+                + 6 * self.a0 * p1
+            ) / (6 * j_max * ph4)
+            polynom5[3] = (
+                61 * self.a0_p4
+                - 76 * self.a0_p2 * ph3
+                - 16 * self.a0 * ph1
+                + 30 * self.a0_p2 * p1
+                + ph2
+            ) / (24 * self.j_max_p2 * ph4)
+            polynom5[4] = (
+                self.a0
+                * (
+                    7 * self.a0_p4
+                    - 10 * self.a0_p2 * ph3
+                    - 4 * self.a0 * ph1
+                    + 6 * self.a0_p2 * p1
+                    + ph2
+                )
+            ) / (12 * self.j_max_p2 * j_max * ph4)
+            polynom5[5] = (
+                7 * self.a0_p6
+                + self.af_p6
+                - 12 * self.a0_p4 * ph3
+                + 48 * self.af_p3 * self.j_max_p2 * self.g1
+                - 8 * self.a0_p3 * ph1
+                - 72
+                * self.j_max_p2
+                * j_max
+                * (
+                    j_max * self.g1 * self.g1
+                    + self.vd_p2 * self.vd
+                    + 2 * self.af * self.g1 * self.vd
+                )
+                - 6 * self.af_p4 * j_max * self.vd
+                + 36 * self.af_p2 * self.j_max_p2 * self.vd_p2
+                + 9 * self.a0_p4 * p1
+                + 3 * self.a0_p2 * ph2
+            ) / (144 * self.j_max_p2 * self.j_max_p2 * ph4)
+
+            deriv5 = polynomial_monic_derivative(polynom5)
+            dderiv5 = polynomial_derivative(deriv5)
+
+            # Solve 4th-order derivative analytically.
+            d_extremas = sorted(solve_quartic_monic(deriv5[1], deriv5[2], deriv5[3], deriv5[4]))
+
+            tz_current = tz_min
+
+            def check_root_uddu(t0: float) -> bool:
+                # Single Newton step (regarding pd).
+                t = t0
+
+                h1pd = _ieee754_sqrt(
+                    (self.a0_p2 + self.af_p2) / (2 * self.j_max_p2)
+                    + (2 * self.a0 * t + j_max * t * t - self.vd) / j_max
+                )
+                orig = -self.pd - (
+                    2 * self.a0_p3
+                    + 4 * self.af_p3
+                    + 24 * self.a0 * j_max * t * (self.af + j_max * (h1pd + t - self.tf))
+                    + 6 * self.a0_p2 * (self.af + j_max * (2 * t - self.tf))
+                    + 6 * (self.a0_p2 + self.af_p2) * j_max * h1pd
+                    + 12 * self.af * j_max * (j_max * t * t - self.vd)
+                    + 12
+                    * self.j_max_p2
+                    * (j_max * t * t * (h1pd + t - self.tf) - self.tf * self.v0 - h1pd * self.vd)
+                ) / (12 * self.j_max_p2)
+                deriv_newton = -(self.a0 + j_max * t) * (
+                    3 * (h1pd + t) - 2 * self.tf + (self.a0 + 2 * self.af) / j_max
+                )
+                if (
+                    not math.isnan(orig)
+                    and not math.isnan(deriv_newton)
+                    and abs(deriv_newton) > _ULP
+                ):
+                    t -= orig / deriv_newton
+
+                if t > self.tf or math.isnan(t):
+                    return False
+
+                h1 = _ieee754_sqrt(
+                    (self.a0_p2 + self.af_p2) / (2 * self.j_max_p2)
+                    + (t * (2 * self.a0 + j_max * t) - self.vd) / j_max
+                )
+
+                profile.t[0] = t
+                profile.t[1] = 0.0
+                profile.t[2] = t + self.a0 / j_max
+                profile.t[3] = self.tf - 2 * (t + h1) - (self.a0 + self.af) / j_max
+                profile.t[4] = h1
+                profile.t[5] = 0.0
+                profile.t[6] = h1 + self.af / j_max
+
+                return profile.check_with_timing(
+                    self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.VEL
+                )
+
+            for tz0 in d_extremas:
+                if tz0 >= tz_max:
+                    continue
+                tz = tz0
+                orig = evaluate_polynomial(deriv5, tz)
+                if abs(orig) > _TOLERANCE:
+                    tz -= orig / evaluate_polynomial(dderiv5, tz)
+
+                val_new = evaluate_polynomial(polynom5, tz)
+                dderiv_val = evaluate_polynomial(dderiv5, tz)
+
+                if abs(val_new) < 64 * abs(dderiv_val) * _TOLERANCE:
+                    if check_root_uddu(tz):
+                        return True
+                elif evaluate_polynomial(polynom5, tz_current) * val_new < 0:
+                    if check_root_uddu(shrink_interval(polynom5, tz_current, tz)):
+                        return True
+                tz_current = tz
+
+            val_max = evaluate_polynomial(polynom5, tz_max)
+            val_current = evaluate_polynomial(polynom5, tz_current)
+
+            if val_current * val_max < 0:
+                if check_root_uddu(shrink_interval(polynom5, tz_current, tz_max)):
+                    return True
+            elif abs(val_max) < 8 * _ULP:
+                if check_root_uddu(tz_max):
+                    return True
+
+        # Profile UDUD
+        ph1 = self.af_p2 - 2 * j_max * (2 * self.af * self.tf + j_max * self.tf_p2 - 3 * self.vd)
+        ph2 = self.af_p3 - 3 * self.j_max_p2 * self.g1 + 3 * self.af * j_max * self.vd
+        ph3 = 2 * j_max * self.tf * self.g1 + 3 * self.vd_p2
+        ph4 = (
+            self.af_p4
+            - 8 * self.af_p3 * j_max * self.tf
+            + 12
+            * j_max
+            * (
+                j_max * ph3
+                + self.af_p2 * self.vd
+                + 2 * self.af * j_max * (self.g1 - self.tf * self.vd)
+            )
+        )
+        ph5 = self.af + j_max * self.tf
+
+        # Find root of 6th order polynom.
+        polynom6 = [0.0] * 7
+        polynom6[0] = 1.0
+        polynom6[1] = (5 * self.a0 - ph5) / j_max
+        polynom6[2] = (39 * self.a0_p2 - ph1 - 16 * self.a0 * ph5) / (4 * self.j_max_p2)
+        polynom6[3] = (55 * self.a0_p3 - 33 * self.a0_p2 * ph5 - 6 * self.a0 * ph1 + 2 * ph2) / (
+            6 * self.j_max_p2 * j_max
+        )
+        polynom6[4] = (
+            101 * self.a0_p4
+            + ph4
+            - 76 * self.a0_p3 * ph5
+            - 30 * self.a0_p2 * ph1
+            + 16 * self.a0 * ph2
+        ) / (24 * self.j_max_p2 * self.j_max_p2)
+        polynom6[5] = (
+            self.a0
+            * (
+                11 * self.a0_p4
+                + ph4
+                - 10 * self.a0_p3 * ph5
+                - 6 * self.a0_p2 * ph1
+                + 4 * self.a0 * ph2
+            )
+        ) / (12 * self.j_max_p2 * self.j_max_p2 * j_max)
+        polynom6[6] = (
+            11 * self.a0_p6
+            - self.af_p6
+            - 12 * self.a0_p5 * ph5
+            - 48 * self.af_p3 * self.j_max_p2 * self.g1
+            - 9 * self.a0_p4 * ph1
+            + 72
+            * self.j_max_p2
+            * j_max
+            * (j_max * self.g1 * self.g1 - self.vd_p2 * self.vd - 2 * self.af * self.g1 * self.vd)
+            - 6 * self.af_p4 * j_max * self.vd
+            - 36 * self.af_p2 * self.j_max_p2 * self.vd_p2
+            + 8 * self.a0_p3 * ph2
+            + 3 * self.a0_p2 * ph4
+        ) / (144 * self.j_max_p2 * self.j_max_p2 * self.j_max_p2)
+
+        deriv6 = polynomial_monic_derivative(polynom6)
+        dderiv6 = polynomial_monic_derivative(deriv6)
+
+        dd_tz_current = tz_min
+        dd_tz_intervals: list[tuple[float, float]] = []
+
+        dd_extremas = sorted(solve_quartic_monic(dderiv6[1], dderiv6[2], dderiv6[3], dderiv6[4]))
+
+        for tz0 in dd_extremas:
+            if tz0 >= tz_max:
+                continue
+            tz = tz0
+            orig = evaluate_polynomial(dderiv6, tz)
+            if abs(orig) > _TOLERANCE:
+                tz -= orig / evaluate_polynomial(polynomial_derivative(dderiv6), tz)
+
+            eval_current = evaluate_polynomial(deriv6, dd_tz_current)
+            eval_tz = evaluate_polynomial(deriv6, tz)
+            product = eval_current * eval_tz
+
+            if product < 0:
+                dd_tz_intervals.append((dd_tz_current, tz))
+            dd_tz_current = tz
+
+        final_eval_current = evaluate_polynomial(deriv6, dd_tz_current)
+        final_eval_max = evaluate_polynomial(deriv6, tz_max)
+        final_dd_product = final_eval_current * final_eval_max
+
+        if final_dd_product < 0:
+            dd_tz_intervals.append((dd_tz_current, tz_max))
+
+        tz_current = tz_min
+
+        def check_root_udud(t0: float) -> bool:
+            # Double Newton step (regarding pd).
+            t = t0
+            h1pd = _ieee754_sqrt(
+                (self.af_p2 - self.a0_p2) / (2 * self.j_max_p2)
+                - ((2 * self.a0 + j_max * t) * t - self.vd) / j_max
+            )
+            orig = (
+                -self.pd
+                + (self.af_p3 - self.a0_p3 + 3 * self.a0_p2 * j_max * (self.tf - 2 * t))
+                / (6 * self.j_max_p2)
+                + (2 * self.a0 + j_max * t) * t * (self.tf - t)
+                + (j_max * h1pd - self.af) * h1pd * h1pd
+                + self.tf * self.v0
+            )
+            deriv_newton = (
+                (self.a0 + j_max * t)
+                * (2 * (self.af + j_max * self.tf) - 3 * j_max * (h1pd + t) - self.a0)
+                / j_max
+            )
+
+            t -= orig / deriv_newton
+
+            h1pd = _ieee754_sqrt(
+                (self.af_p2 - self.a0_p2) / (2 * self.j_max_p2)
+                - ((2 * self.a0 + j_max * t) * t - self.vd) / j_max
+            )
+            orig = (
+                -self.pd
+                + (self.af_p3 - self.a0_p3 + 3 * self.a0_p2 * j_max * (self.tf - 2 * t))
+                / (6 * self.j_max_p2)
+                + (2 * self.a0 + j_max * t) * t * (self.tf - t)
+                + (j_max * h1pd - self.af) * h1pd * h1pd
+                + self.tf * self.v0
+            )
+            if abs(orig) > 1e-9:
+                deriv_newton = (
+                    (self.a0 + j_max * t)
+                    * (2 * (self.af + j_max * self.tf) - 3 * j_max * (h1pd + t) - self.a0)
+                    / j_max
+                )
+                t -= orig / deriv_newton
+
+            h1 = _ieee754_sqrt(
+                (self.af_p2 - self.a0_p2) / (2 * self.j_max_p2)
+                - ((2 * self.a0 + j_max * t) * t - self.vd) / j_max
+            )
+
+            # Calculate times first, validate BEFORE assigning, to prevent
+            # corrupting the shared profile on failure.
+            t0v = t
+            t1v = 0.0
+            t2v = t + self.a0 / j_max
+            t3v = self.tf - 2 * (t + h1) + self.ad / j_max
+            t4v = h1
+            t5v = 0.0
+            t6v = h1 - self.af / j_max
+
+            if t0v < 0 or t2v < 0 or t3v < 0 or t4v < 0 or t6v < 0:
+                return False
+
+            profile.t[0] = t0v
+            profile.t[1] = t1v
+            profile.t[2] = t2v
+            profile.t[3] = t3v
+            profile.t[4] = t4v
+            profile.t[5] = t5v
+            profile.t[6] = t6v
+
+            return profile.check_with_timing(
+                self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDUD, ReachedLimits.VEL
+            )
+
+        for lo, hi in dd_tz_intervals:
+            tz = shrink_interval(deriv6, lo, hi)
+
+            if tz >= tz_max:
+                continue
+
+            p_val = evaluate_polynomial(polynom6, tz)
+            dderiv_val = evaluate_polynomial(dderiv6, tz)
+            threshold = 64 * abs(dderiv_val) * _TOLERANCE
+
+            if abs(p_val) < threshold:
+                if check_root_udud(tz):
+                    return True
+            else:
+                val_current = evaluate_polynomial(polynom6, tz_current)
+                product = val_current * p_val
+
+                if product < 0:
+                    if check_root_udud(shrink_interval(polynom6, tz_current, tz)):
+                        return True
+            tz_current = tz
+
+        final_udud_val_current = evaluate_polynomial(polynom6, tz_current)
+        final_udud_val_max = evaluate_polynomial(polynom6, tz_max)
+        final_udud_product = final_udud_val_current * final_udud_val_max
+
+        if final_udud_product < 0:
+            if check_root_udud(shrink_interval(polynom6, tz_current, tz_max)):
+                return True
+
+        return False
+
+    def _time_acc0_acc1(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> bool:
+        if abs(self.a0) < _ULP and abs(self.af) < _ULP:
+            h1 = (
+                2 * a_min * self.g1
+                + self.vd_p2
+                + a_max * (2 * self.pd + a_min * self.tf_p2 - 2 * self.tf * self.vf)
+            )
+            h2 = (a_max - a_min) * (-a_min * self.vd + a_max * (a_min * self.tf - self.vd))
+
+            jf = h2 / h1
+            profile.t[0] = a_max / jf
+            profile.t[1] = (-2 * a_max * h1 + a_min * a_min * self.g2) / h2
+            profile.t[2] = profile.t[0]
+            profile.t[3] = 0.0
+            profile.t[4] = -a_min / jf
+            profile.t[5] = self.tf - (2 * profile.t[0] + profile.t[1] + 2 * profile.t[4])
+            profile.t[6] = profile.t[4]
+
+            return profile.check_with_timing(
+                self.tf,
+                jf,
+                v_max,
+                v_min,
+                a_max,
+                a_min,
+                ControlSigns.UDDU,
+                ReachedLimits.ACC0_ACC1,
+                j_max=j_max,
+            )
+
+        # UDDU
+        h1 = _ieee754_sqrt(
+            144
+            * _pow2(
+                (a_max - a_min) * (-a_min * self.vd + a_max * (a_min * self.tf - self.vd))
+                - self.af_p2 * (a_max * self.tf - self.vd)
+                + 2 * self.af * a_min * (a_max * self.tf - self.vd)
+                + self.a0_p2 * (a_min * self.tf + self.v0 - self.vf)
+                - 2 * self.a0 * a_max * (a_min * self.tf - self.vd)
+            )
+            + 48
+            * self.ad
+            * (
+                3 * self.a0_p3
+                - 3 * self.af_p3
+                + 12 * a_max * a_min * (-a_max + a_min)
+                + 4 * self.af_p2 * (a_max + 2 * a_min)
+                + self.a0
+                * (
+                    -3 * self.af_p2
+                    + 8 * self.af * (a_min - a_max)
+                    + 6 * (a_max * a_max + 2 * a_max * a_min - a_min * a_min)
+                )
+                + 6 * self.af * (a_max * a_max - 2 * a_max * a_min - a_min * a_min)
+                + self.a0_p2 * (3 * self.af - 4 * (2 * a_max + a_min))
+            )
+            * (
+                2 * a_min * self.g1
+                + self.vd * self.vd
+                + a_max * (2 * self.pd + a_min * self.tf * self.tf - 2 * self.tf * self.vf)
+            )
+        )
+
+        jf = -(
+            3 * self.af_p2 * a_max * self.tf
+            - 3 * self.a0_p2 * a_min * self.tf
+            - 6 * self.ad * a_max * a_min * self.tf
+            + 3 * a_max * a_min * (a_min - a_max) * self.tf
+            + 3 * (self.a0_p2 - self.af_p2) * self.vd
+            + 6 * self.vd * (self.af * a_min - self.a0 * a_max)
+            + 3 * (a_max * a_max - a_min * a_min) * self.vd
+            + h1 / 4
+        ) / (
+            6
+            * (
+                2 * a_min * self.g1
+                + self.vd * self.vd
+                + a_max * (2 * self.pd + a_min * self.tf_p2 - 2 * self.tf * self.vf)
+            )
+        )
+        profile.t[0] = (a_max - self.a0) / jf
+        profile.t[1] = (
+            self.a0_p2
+            - self.af_p2
+            + 2 * self.ad * a_min
+            - 2
+            * (
+                a_max * a_max
+                - 2 * a_max * a_min
+                + a_min * a_min
+                + a_min * jf * self.tf
+                - jf * self.vd
+            )
+        ) / (2 * (a_max - a_min) * jf)
+        profile.t[2] = a_max / jf
+        profile.t[3] = 0.0
+        profile.t[4] = -a_min / jf
+        profile.t[5] = self.tf - (
+            profile.t[0] + profile.t[1] + profile.t[2] + 2 * profile.t[4] + self.af / jf
+        )
+        profile.t[6] = profile.t[4] + self.af / jf
+
+        if profile.check_with_timing(
+            self.tf,
+            jf,
+            v_max,
+            v_min,
+            a_max,
+            a_min,
+            ControlSigns.UDDU,
+            ReachedLimits.ACC0_ACC1,
+            j_max=j_max,
+        ):
+            return True
+
+        return False
+
+    def _time_acc1(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> bool:
+        # Case UDDU
+        h0uddu = (
+            _ieee754_sqrt(
+                self.j_max_p2
+                * (
+                    self.a0_p4
+                    + self.af_p4
+                    - 4 * self.af_p3 * j_max * self.tf
+                    + 6 * self.af_p2 * self.j_max_p2 * self.tf_p2
+                    - 4 * self.a0_p3 * (self.af - j_max * self.tf)
+                    + 6 * self.a0_p2 * (self.af - j_max * self.tf) * (self.af - j_max * self.tf)
+                    + 24 * self.af * self.j_max_p2 * self.g1
+                    - 4
+                    * self.a0
+                    * (
+                        self.af_p3
+                        - 3 * self.af_p2 * j_max * self.tf
+                        + 6 * self.j_max_p2 * (-self.pd + self.tf * self.vf)
+                    )
+                    - 12 * self.j_max_p2 * (-self.vd_p2 + j_max * self.tf * self.g2)
+                )
+                / 3
+            )
+            / j_max
+        )
+        h1_uddu_sol1 = _ieee754_sqrt(
+            (
+                self.a0_p2
+                + self.af_p2
+                - 2 * self.a0 * self.af
+                - 2 * self.ad * j_max * self.tf
+                + 2 * h0uddu
+            )
+            / self.j_max_p2
+            + self.tf_p2
+        )
+
+        profile.t[0] = -(
+            self.a0_p2
+            + self.af_p2
+            + 2 * self.a0 * (j_max * self.tf - self.af)
+            - 2 * j_max * self.vd
+            + h0uddu
+        ) / (2 * j_max * (-self.ad + j_max * self.tf))
+        profile.t[1] = 0.0
+        profile.t[2] = (self.tf - h1_uddu_sol1) / 2 - self.ad / (2 * j_max)
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = h1_uddu_sol1
+        profile.t[6] = self.tf - (profile.t[0] + profile.t[2] + profile.t[5])
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC1
+        ):
+            return True
+
+        # Case UDUD
+        h0udud = (
+            _ieee754_sqrt(
+                self.j_max_p2
+                * (
+                    self.a0_p4
+                    + self.af_p4
+                    + 4 * (self.af_p3 - self.a0_p3) * j_max * self.tf
+                    + 6 * self.af_p2 * self.j_max_p2 * self.tf_p2
+                    + 6 * self.a0_p2 * (self.af + j_max * self.tf) * (self.af + j_max * self.tf)
+                    + 24 * self.af * self.j_max_p2 * self.g1
+                    - 4
+                    * self.a0
+                    * (
+                        self.a0_p2 * self.af
+                        + self.af_p3
+                        + 3 * self.af_p2 * j_max * self.tf
+                        + 6 * self.j_max_p2 * (-self.pd + self.tf * self.vf)
+                    )
+                    + 12 * self.j_max_p2 * (self.vd_p2 + j_max * self.tf * self.g2)
+                )
+                / 3
+            )
+            / j_max
+        )
+        h1udud = _ieee754_sqrt(
+            (
+                self.a0_p2
+                + self.af_p2
+                - 2 * self.a0 * self.af
+                + 2 * self.ad * j_max * self.tf
+                + 2 * h0udud
+            )
+            / self.j_max_p2
+            + self.tf_p2
+        )
+
+        profile.t[0] = 0.0
+        profile.t[1] = 0.0
+        profile.t[2] = -(
+            self.a0_p2
+            + self.af_p2
+            - 2 * self.a0 * self.af
+            + 2 * j_max * (self.vd - self.a0 * self.tf)
+            + h0udud
+        ) / (2 * j_max * (self.ad + j_max * self.tf))
+        profile.t[3] = 0.0
+        profile.t[4] = self.ad / (2 * j_max) + (self.tf - h1udud) / 2
+        profile.t[5] = h1udud
+        profile.t[6] = self.tf - (profile.t[5] + profile.t[4] + profile.t[2])
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDUD, ReachedLimits.ACC1
+        ):
+            return True
+
+        # Case UDDU, Solution 2
+        h0a = (
+            self.a0_p3
+            - self.af_p3
+            - 3 * self.a0_p2 * a_min
+            + 3 * a_min * a_min * (self.a0 + j_max * self.tf)
+            + 3 * self.af * a_min * (-a_min - 2 * j_max * self.tf)
+            - 3 * self.af_p2 * (-a_min - j_max * self.tf)
+            - 3 * self.j_max_p2 * (-2 * self.pd - a_min * self.tf_p2 + 2 * self.tf * self.vf)
+        )
+        h0b = (
+            self.a0_p2
+            + self.af_p2
+            - 2 * (self.a0 + self.af) * a_min
+            + 2 * (a_min * a_min - j_max * (-a_min * self.tf + self.vd))
+        )
+        h0c = (
+            self.a0_p4
+            + 3 * self.af_p4
+            - 4 * (self.a0_p3 + 2 * self.af_p3) * a_min
+            + 6 * self.a0_p2 * a_min * a_min
+            + 6 * self.af_p2 * (a_min * a_min - 2 * j_max * self.vd)
+            + 12
+            * j_max
+            * (2 * a_min * j_max * self.g1 - a_min * a_min * self.vd + j_max * self.vd_p2)
+            + 24 * self.af * a_min * j_max * self.vd
+            - 4
+            * self.a0
+            * (
+                self.af_p3
+                - 3 * self.af * a_min * (-a_min - 2 * j_max * self.tf)
+                + 3 * self.af_p2 * (-a_min - j_max * self.tf)
+                + 3
+                * j_max
+                * (
+                    -a_min * a_min * self.tf
+                    + j_max * (-2 * self.pd - a_min * self.tf_p2 + 2 * self.tf * self.vf)
+                )
+            )
+        )
+        h1_uddu_sol2 = abs(j_max) / j_max * _ieee754_sqrt(4 * h0a * h0a - 6 * h0b * h0c)
+        h2 = 6 * j_max * h0b
+
+        profile.t[0] = 0.0
+        profile.t[1] = 0.0
+        profile.t[2] = (2 * h0a + h1_uddu_sol2) / h2
+        profile.t[3] = -(
+            self.a0_p2
+            + self.af_p2
+            - 2 * (self.a0 + self.af) * a_min
+            + 2 * (a_min * a_min + a_min * j_max * self.tf - j_max * self.vd)
+        ) / (2 * j_max * (self.a0 - a_min - j_max * profile.t[2]))
+        profile.t[4] = (self.a0 - a_min) / j_max - profile.t[2]
+        profile.t[5] = self.tf - (
+            profile.t[2] + profile.t[3] + profile.t[4] + (self.af - a_min) / j_max
+        )
+        profile.t[6] = (self.af - a_min) / j_max
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC1
+        ):
+            return True
+
+        # Case UDUD, Solution 1
+        h0a_udud = (
+            -self.a0_p3
+            + self.af_p3
+            + 3 * (self.a0_p2 - self.af_p2) * a_max
+            - 3 * self.ad * a_max * a_max
+            - 6 * self.af * a_max * j_max * self.tf
+            + 3 * self.af_p2 * j_max * self.tf
+            + 3
+            * j_max
+            * (
+                a_max * a_max * self.tf
+                + j_max * (-2 * self.pd - a_max * self.tf_p2 + 2 * self.tf * self.vf)
+            )
+        )
+        h0b_udud = (
+            self.a0_p2 - self.af_p2 + 2 * self.ad * a_max + 2 * j_max * (a_max * self.tf - self.vd)
+        )
+        h0c_udud = (
+            self.a0_p4
+            + 3 * self.af_p4
+            - 4 * (self.a0_p3 + 2 * self.af_p3) * a_max
+            + 6 * self.a0_p2 * a_max * a_max
+            - 24 * self.af * a_max * j_max * self.vd
+            + 12
+            * j_max
+            * (2 * a_max * j_max * self.g1 + j_max * self.vd_p2 + a_max * a_max * self.vd)
+            + 6 * self.af_p2 * (a_max * a_max + 2 * j_max * self.vd)
+            - 4
+            * self.a0
+            * (
+                self.af_p3
+                + 3 * self.af * a_max * (a_max - 2 * j_max * self.tf)
+                - 3 * self.af_p2 * (a_max - j_max * self.tf)
+                + 3
+                * j_max
+                * (
+                    a_max * a_max * self.tf
+                    + j_max * (-2 * self.pd - a_max * self.tf_p2 + 2 * self.tf * self.vf)
+                )
+            )
+        )
+        h1_udud_sol1 = (
+            abs(j_max) / j_max * _ieee754_sqrt(4 * h0a_udud * h0a_udud - 6 * h0b_udud * h0c_udud)
+        )
+        h2_udud = 6 * j_max * h0b_udud
+
+        profile.t[0] = 0.0
+        profile.t[1] = 0.0
+        profile.t[2] = -(2 * h0a_udud + h1_udud_sol1) / h2_udud
+        profile.t[3] = 2 * h1_udud_sol1 / h2_udud
+        profile.t[4] = (a_max - self.a0) / j_max + profile.t[2]
+        profile.t[5] = self.tf - (
+            profile.t[2] + profile.t[3] + profile.t[4] + (-self.af + a_max) / j_max
+        )
+        profile.t[6] = (-self.af + a_max) / j_max
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDUD, ReachedLimits.ACC1
+        ):
+            return True
+
+        return False
+
+    def _time_acc0(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> bool:
+        # UDUD
+        h1 = _ieee754_sqrt(
+            self.ad_p2 / (2 * self.j_max_p2)
+            - self.ad * (a_max - self.a0) / self.j_max_p2
+            + (a_max * self.tf - self.vd) / j_max
+        )
+
+        profile.t[0] = (a_max - self.a0) / j_max
+        profile.t[1] = self.tf - self.ad / j_max - 2 * h1
+        profile.t[2] = h1
+        profile.t[3] = 0.0
+        profile.t[4] = (self.af - a_max) / j_max + h1
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDUD, ReachedLimits.NONE
+        ):
+            return True
+
+        # NOTE (source quirk, preserved verbatim): the Swift comment above
+        # this block says "// UDUD" but the actual checkWithTiming call
+        # passes .UDDU -- see this module's docstring.
+        h0a = (
+            -self.a0_p2 + self.af_p2 - 2 * self.ad * a_max + 2 * j_max * (a_max * self.tf - self.vd)
+        )
+        h0b = (
+            self.a0_p3
+            + 2 * self.af_p3
+            - 6 * self.af_p2 * a_max
+            - 3 * self.a0_p2 * (self.af - j_max * self.tf)
+            - 3 * self.a0 * a_max * (a_max - 2 * self.af + 2 * j_max * self.tf)
+            - 3
+            * j_max
+            * (
+                j_max * (-2 * self.pd + a_max * self.tf_p2 + 2 * self.tf * self.v0)
+                + a_max * (a_max * self.tf - 2 * self.vd)
+            )
+            + 3 * self.af * (a_max * a_max + 2 * a_max * j_max * self.tf - 2 * j_max * self.vd)
+        )
+        h0 = abs(j_max) * _ieee754_sqrt(4 * h0b * h0b - 18 * h0a * h0a * h0a)
+        h1b = 3 * j_max * h0a
+
+        profile.t[0] = (-self.a0 + a_max) / j_max
+        profile.t[1] = (
+            -self.a0_p3
+            + self.af_p3
+            + self.af_p2 * (-6 * a_max + 3 * j_max * self.tf)
+            + self.a0_p2 * (-3 * self.af + 6 * a_max + 3 * j_max * self.tf)
+            + 6 * self.af * (a_max * a_max - j_max * self.vd)
+            + 3 * self.a0 * (self.af_p2 - 2 * (a_max * a_max + j_max * self.vd))
+            - 6 * j_max * (a_max * (a_max * self.tf - 2 * self.vd) + j_max * self.g2)
+        ) / h1b
+        profile.t[2] = -(self.ad + h0 / h1b) / (2 * j_max) + self.tf / 2 - profile.t[1] / 2
+        profile.t[3] = h0 / (j_max * h1b)
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = self.tf - (profile.t[0] + profile.t[1] + profile.t[2] + profile.t[3])
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+        ):
+            return True
+
+        # a3 != 0
+
+        # UDDU Solution 1
+        h0a_2 = (
+            self.a0_p3
+            + 2 * self.af_p3
+            - 6 * (self.af_p2 + a_max * a_max) * a_max
+            - 6 * (self.a0 + self.af) * a_max * j_max * self.tf
+            + 9 * a_max * a_max * (self.af + j_max * self.tf)
+            + 3 * self.a0 * a_max * (-2 * self.af + 3 * a_max)
+            + 3 * self.a0_p2 * (self.af - 2 * a_max + j_max * self.tf)
+            - 6 * self.j_max_p2 * self.g1
+            + 6 * (self.af - a_max) * j_max * self.vd
+            - 3 * a_max * self.j_max_p2 * self.tf_p2
+        )
+        h0b_2 = (
+            self.a0_p2
+            + self.af_p2
+            + 2
+            * (a_max * a_max - (self.a0 + self.af) * a_max + j_max * (self.vd - a_max * self.tf))
+        )
+        h1_2 = abs(j_max) / j_max * _ieee754_sqrt(4 * h0a_2 * h0a_2 - 18 * h0b_2 * h0b_2 * h0b_2)
+        h2_2 = 6 * j_max * h0b_2
+
+        profile.t[0] = (-self.a0 + a_max) / j_max
+        profile.t[1] = self.ad / j_max - 2 * profile.t[0] - (2 * h0a_2 - h1_2) / h2_2 + self.tf
+        profile.t[2] = -(2 * h0a_2 + h1_2) / h2_2
+        profile.t[3] = (2 * h0a_2 - h1_2) / h2_2
+        profile.t[4] = self.tf - (profile.t[0] + profile.t[1] + profile.t[2] + profile.t[3])
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC0
+        ):
+            return True
+
+        return False
+
+    def _time_none(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> bool:
+        if abs(self.v0) < _ULP and abs(self.a0) < _ULP and abs(self.af) < _ULP:
+            h1 = _ieee754_sqrt(self.tf_p2 * self.vf_p2 + _pow2(4 * self.pd - self.tf * self.vf))
+            jf = 4 * (4 * self.pd - 2 * self.tf * self.vf + h1) / self.tf_p3
+
+            profile.t[0] = self.tf / 4
+            profile.t[1] = 0.0
+            profile.t[2] = 2 * profile.t[0]
+            profile.t[3] = 0.0
+            profile.t[4] = 0.0
+            profile.t[5] = 0.0
+            profile.t[6] = profile.t[0]
+
+            if profile.check_with_timing(
+                self.tf,
+                jf,
+                v_max,
+                v_min,
+                a_max,
+                a_min,
+                ControlSigns.UDDU,
+                ReachedLimits.NONE,
+                j_max=j_max,
+            ):
+                return True
+
+        if abs(self.a0) < _ULP and abs(self.af) < _ULP:
+            # Profiles with a3 != 0, Solution UDDU: first acc, then constant.
+            polynom = [
+                -2 * self.tf,
+                2 * self.vd / j_max + self.tf_p2,
+                4 * (self.pd - self.tf * self.vf) / j_max,
+                (self.vd_p2 + j_max * self.tf * self.g2) / self.j_max_p2,
+            ]
+            roots = sorted(solve_quartic_monic(*polynom))
+            for t0 in roots:
+                t = t0
+                if t > self.tf / 2 or t > (a_max - self.a0) / j_max:
+                    continue
+
+                # Single Newton step (regarding pd).
+                h1 = (j_max * t * (t - self.tf) + self.vd) / (j_max * (2 * t - self.tf))
+                h2 = (2 * j_max * t * (t - self.tf) + j_max * self.tf_p2 - 2 * self.vd) / (
+                    j_max * (2 * t - self.tf) * (2 * t - self.tf)
+                )
+                orig = (
+                    -2 * self.pd
+                    + 2 * self.tf * self.v0
+                    + h1 * h1 * j_max * (self.tf - 2 * t)
+                    + j_max * self.tf * (2 * h1 * t - t * t - (h1 - t) * self.tf)
+                ) / 2
+                deriv = (j_max * self.tf * (2 * t - self.tf) * (h2 - 1)) / 2 + h1 * j_max * (
+                    self.tf - (2 * t - self.tf) * h2 - h1
+                )
+                t -= orig / deriv
+
+                profile.t[0] = t
+                profile.t[1] = 0.0
+                profile.t[2] = (j_max * t * (t - self.tf) + self.vd) / (j_max * (2 * t - self.tf))
+                profile.t[3] = self.tf - 2 * t
+                profile.t[4] = t - profile.t[2]
+                profile.t[5] = 0.0
+                profile.t[6] = 0.0
+
+                if profile.check_with_timing(
+                    self.tf,
+                    j_max,
+                    v_max,
+                    v_min,
+                    a_max,
+                    a_min,
+                    ControlSigns.UDDU,
+                    ReachedLimits.NONE,
+                ):
+                    return True
+
+        # UDUD T 0246
+        h0 = (
+            _ieee754_sqrt(
+                2
+                * self.j_max_p2
+                * (
+                    2
+                    * _pow2(
+                        self.a0_p3
+                        - self.af_p3
+                        - 3 * self.af_p2 * j_max * self.tf
+                        + 9 * self.af * self.j_max_p2 * self.tf_p2
+                        - 3 * self.a0_p2 * (self.af + j_max * self.tf)
+                        + 3 * self.a0 * _pow2(self.af + j_max * self.tf)
+                        + 3
+                        * self.j_max_p2
+                        * (8 * self.pd + j_max * self.tf_p2 * self.tf - 8 * self.tf * self.vf)
+                    )
+                    - 3
+                    * (
+                        self.a0_p2
+                        + self.af_p2
+                        - 2 * self.af * j_max * self.tf
+                        - 2 * self.a0 * (self.af + j_max * self.tf)
+                        - j_max * (j_max * self.tf_p2 + 4 * self.v0 - 4 * self.vf)
+                    )
+                    * (
+                        self.a0_p4
+                        + self.af_p4
+                        + 4 * self.af_p3 * j_max * self.tf
+                        + 6 * self.af_p2 * self.j_max_p2 * self.tf_p2
+                        - 3 * self.j_max_p2 * self.j_max_p2 * self.tf_p2 * self.tf_p2
+                        - 4 * self.a0_p3 * (self.af + j_max * self.tf)
+                        + 6 * self.a0_p2 * _pow2(self.af + j_max * self.tf)
+                        - 12
+                        * self.af
+                        * self.j_max_p2
+                        * (8 * self.pd + j_max * self.tf_p2 * self.tf - 8 * self.tf * self.v0)
+                        + 48 * self.j_max_p2 * self.vd_p2
+                        + 48 * self.j_max_p2 * j_max * self.tf * self.g2
+                        - 4
+                        * self.a0
+                        * (
+                            self.af_p3
+                            + 3 * self.af_p2 * j_max * self.tf
+                            - 9 * self.af * self.j_max_p2 * self.tf_p2
+                            - 3
+                            * self.j_max_p2
+                            * (8 * self.pd + j_max * self.tf_p2 * self.tf - 8 * self.tf * self.vf)
+                        )
+                    )
+                )
+            )
+            / j_max
+        )
+        h1 = (
+            12
+            * j_max
+            * (
+                -self.a0_p2
+                - self.af_p2
+                + 2 * self.af * j_max * self.tf
+                + 2 * self.a0 * (self.af + j_max * self.tf)
+                + j_max * (j_max * self.tf_p2 + 4 * self.v0 - 4 * self.vf)
+            )
+        )
+        h2 = (
+            -4 * self.a0_p3
+            + 4 * self.af_p3
+            + 12 * self.a0_p2 * self.af
+            - 12 * self.a0 * self.af_p2
+            + 48 * self.j_max_p2 * self.pd
+            + 12 * (self.a0_p2 - self.af_p2) * j_max * self.tf
+            - 24 * self.j_max_p2 * self.tf * (self.v0 + self.vf)
+            + 24 * self.ad * j_max * self.vd
+        )
+        h3 = 2 * self.a0_p3 - 2 * self.af_p3 - 6 * self.a0_p2 * self.af + 6 * self.a0 * self.af_p2
+
+        profile.t[0] = (
+            h3
+            - 48 * self.j_max_p2 * (self.tf * self.vf - self.pd)
+            - 6 * (self.a0_p2 + self.af_p2) * j_max * self.tf
+            + 12 * self.a0 * self.af * j_max * self.tf
+            + 6 * (self.a0 + 3 * self.af + j_max * self.tf) * self.tf_p2 * self.j_max_p2
+            - h0
+        ) / h1
+        profile.t[1] = 0.0
+        profile.t[2] = (h2 + h0) / h1
+        profile.t[3] = 0.0
+        profile.t[4] = (-h2 + h0) / h1
+        profile.t[5] = 0.0
+        profile.t[6] = (
+            -h3
+            + 48 * self.j_max_p2 * (self.tf * self.v0 - self.pd)
+            - 6 * (self.a0_p2 + self.af_p2) * j_max * self.tf
+            + 12 * self.a0 * self.af * j_max * self.tf
+            + 6 * (self.af + 3 * self.a0 + j_max * self.tf) * self.tf_p2 * self.j_max_p2
+            - h0
+        ) / h1
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDUD, ReachedLimits.NONE
+        ):
+            return True
+
+        # Profiles with a3 != 0, Solution UDDU: T 0234
+        ph1 = self.af + j_max * self.tf
+
+        polynom_0234 = [
+            -2 * (self.ad + j_max * self.tf) / j_max,
+            2
+            * (self.a0_p2 + self.af_p2 + j_max * (self.af * self.tf + self.vd) - 2 * self.a0 * ph1)
+            / self.j_max_p2
+            + self.tf_p2,
+            2
+            * (
+                self.a0_p3
+                - self.af_p3
+                - 3 * self.af_p2 * j_max * self.tf
+                + 3 * self.a0 * ph1 * (ph1 - self.a0)
+                - 6 * self.j_max_p2 * (-self.pd + self.tf * self.vf)
+            )
+            / (3 * self.j_max_p2 * j_max),
+            (
+                self.a0_p4
+                + self.af_p4
+                + 4 * self.af_p3 * j_max * self.tf
+                - 4 * self.a0_p3 * ph1
+                + 6 * self.a0_p2 * ph1 * ph1
+                + 24 * self.j_max_p2 * self.af * self.g1
+                - 4
+                * self.a0
+                * (
+                    self.af_p3
+                    + 3 * self.af_p2 * j_max * self.tf
+                    + 6 * self.j_max_p2 * (-self.pd + self.tf * self.vf)
+                )
+                + 6 * self.j_max_p2 * self.af_p2 * self.tf_p2
+                + 12 * self.j_max_p2 * (self.vd_p2 + j_max * self.tf * self.g2)
+            )
+            / (12 * self.j_max_p2 * self.j_max_p2),
+        ]
+        t_min_0234 = self.ad / j_max
+        t_max_0234 = min((a_max - self.a0) / j_max, (self.ad / j_max + self.tf) / 2)
+
+        roots_0234 = sorted(solve_quartic_monic(*polynom_0234))
+        for t_root in roots_0234:
+            t_m = t_root
+            if t_m < t_min_0234 or t_m > t_max_0234:
+                continue
+
+            # Single Newton step (regarding pd).
+            h0n = j_max * (2 * t_m - self.tf) - self.ad
+            h1n = (
+                self.ad_p2
+                - 2 * self.af * j_max * t_m
+                + 2 * self.a0 * j_max * (t_m - self.tf)
+                + 2 * j_max * (j_max * t_m * (t_m - self.tf) + self.vd)
+            ) / (2 * j_max * h0n)
+            h2n = (
+                -self.ad_p2
+                + 2 * self.j_max_p2 * (self.tf_p2 + t_m * (t_m - self.tf))
+                + (self.a0 + self.af) * j_max * self.tf
+                - self.ad * h0n
+                - 2 * j_max * self.vd
+            ) / (h0n * h0n)
+
+            orig = (
+                -self.a0_p3
+                + self.af_p3
+                + 3 * self.ad_p2 * j_max * (h1n - t_m)
+                + 3 * self.ad * self.j_max_p2 * (h1n - t_m) * (h1n - t_m)
+                - 3 * self.a0 * self.af * self.ad
+                + 3
+                * self.j_max_p2
+                * (
+                    self.a0 * self.tf_p2
+                    - 2 * self.pd
+                    + 2 * self.tf * self.v0
+                    + h1n * h1n * j_max * (self.tf - 2 * t_m)
+                    + j_max * self.tf * (2 * h1n * t_m - t_m * t_m - (h1n - t_m) * self.tf)
+                )
+            ) / (6 * self.j_max_p2)
+
+            deriv = (h0n * (-self.ad + j_max * self.tf) * (h2n - 1)) / (2 * j_max) + h1n * (
+                -self.ad + j_max * (self.tf - h1n) - h0n * h2n
+            )
+
+            t_m -= orig / deriv
+
+            profile.t[0] = t_m
+            profile.t[1] = 0.0
+            profile.t[2] = (
+                self.ad_p2
+                + 2
+                * j_max
+                * (-self.a0 * self.tf - self.ad * t_m + j_max * t_m * (t_m - self.tf) + self.vd)
+            ) / (2 * j_max * (-self.ad + j_max * (2 * t_m - self.tf)))
+            profile.t[3] = self.ad / j_max + self.tf - 2 * t_m
+            profile.t[4] = self.tf - (t_m + profile.t[2] + profile.t[3])
+            profile.t[5] = 0.0
+            profile.t[6] = 0.0
+
+            if profile.check_with_timing(
+                self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+            ):
+                return True
+
+        # T 3456
+        h1_3456 = 3 * j_max * (self.ad_p2 + 2 * j_max * (self.a0 * self.tf - self.vd))
+        h2_3456 = self.ad_p2 + 2 * j_max * (self.a0 * self.tf - self.vd)
+        h0_3456 = (
+            _ieee754_div(
+                _ieee754_sqrt(
+                    4
+                    * _pow2(
+                        2 * (self.a0_p3 - self.af_p3)
+                        - 6 * self.a0_p2 * (self.af - j_max * self.tf)
+                        + 6 * self.j_max_p2 * self.g1
+                        + 3
+                        * self.a0
+                        * (
+                            2 * self.af_p2
+                            - 2 * j_max * self.af * self.tf
+                            + self.j_max_p2 * self.tf_p2
+                        )
+                        + 6 * self.ad * j_max * self.vd
+                    )
+                    - 18 * h2_3456 * h2_3456 * h2_3456
+                ),
+                h1_3456,
+            )
+            * abs(j_max)
+            / j_max
+        )
+
+        profile.t[0] = 0.0
+        profile.t[1] = 0.0
+        profile.t[2] = 0.0
+        profile.t[3] = _ieee754_div(
+            self.af_p3
+            - self.a0_p3
+            + 3 * (self.af_p2 - self.a0_p2) * j_max * self.tf
+            - 3 * self.ad * (self.a0 * self.af + 2 * j_max * self.vd)
+            - 6 * self.j_max_p2 * self.g2,
+            h1_3456,
+        )
+        profile.t[4] = (self.tf - profile.t[3] - h0_3456) / 2 - self.ad / (2 * j_max)
+        profile.t[5] = h0_3456
+        profile.t[6] = (self.tf - profile.t[3] + self.ad / j_max - h0_3456) / 2
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+        ):
+            return True
+
+        # T 2346
+        ph1_2346 = (
+            self.ad_p2
+            + 2 * (self.af + self.a0) * j_max * self.tf
+            - j_max * (j_max * self.tf_p2 + 4 * self.vd)
+        )
+        ph2_2346 = j_max * self.tf_p2 * self.g1 - self.vd * (
+            -2 * self.pd - self.tf * self.v0 + 3 * self.tf * self.vf
+        )
+        ph3_2346 = (
+            5 * self.af_p2
+            - 8 * self.af * j_max * self.tf
+            + 2 * j_max * (2 * j_max * self.tf_p2 - self.vd)
+        )
+        ph4_2346 = (
+            self.j_max_p2 * self.tf_p4
+            - 2 * self.vd_p2
+            + 8 * j_max * self.tf * (-self.pd + self.tf * self.vf)
+        )
+        ph5_2346 = (
+            5 * self.af_p4
+            - 8 * self.af_p3 * j_max * self.tf
+            - 12 * self.af_p2 * j_max * (j_max * self.tf_p2 + self.vd)
+            + 24
+            * self.af
+            * self.j_max_p2
+            * (-2 * self.pd + j_max * self.tf_p3 + 2 * self.tf * self.vf)
+            - 6 * self.j_max_p2 * ph4_2346
+        )
+        ph6_2346 = (
+            -self.vd_p2
+            + j_max * self.tf * (-2 * self.pd + 3 * self.tf * self.v0 - self.tf * self.vf)
+            - self.af * self.g2
+        )
+
+        poly1_2346 = -(
+            4 * (self.a0_p3 - self.af_p3)
+            - 12 * self.a0_p2 * (self.af - j_max * self.tf)
+            + 6
+            * self.a0
+            * (
+                2 * self.af_p2
+                - 2 * self.af * j_max * self.tf
+                + j_max * (j_max * self.tf_p2 - 2 * self.vd)
+            )
+            + 6 * self.af * j_max * (3 * j_max * self.tf_p2 + 2 * self.vd)
+            - 6
+            * self.j_max_p2
+            * (-4 * self.pd + j_max * self.tf_p3 - 2 * self.tf * self.v0 + 6 * self.tf * self.vf)
+        ) / (3 * j_max * ph1_2346)
+
+        poly2_2346 = -(
+            -self.a0_p4
+            - self.af_p4
+            + 4 * self.a0_p3 * (self.af - j_max * self.tf)
+            + self.a0_p2
+            * (
+                -6 * self.af_p2
+                + 8 * self.af * j_max * self.tf
+                - 4 * j_max * (j_max * self.tf_p2 - self.vd)
+            )
+            + 2 * self.af_p2 * j_max * (j_max * self.tf_p2 + 2 * self.vd)
+            - 4
+            * self.af
+            * self.j_max_p2
+            * (-3 * self.pd + j_max * self.tf_p3 + 2 * self.tf * self.v0 + self.tf * self.vf)
+            + self.j_max_p2
+            * (
+                self.j_max_p2 * self.tf_p4
+                - 8 * self.vd_p2
+                + 4 * j_max * self.tf * (-3 * self.pd + self.tf * self.v0 + 2 * self.tf * self.vf)
+            )
+            + 2
+            * self.a0
+            * (
+                2 * self.af_p3
+                - 2 * self.af_p2 * j_max * self.tf
+                + self.af * j_max * (-3 * j_max * self.tf_p2 - 4 * self.vd)
+                + self.j_max_p2
+                * (
+                    -6 * self.pd
+                    + j_max * self.tf_p3
+                    - 4 * self.tf * self.v0
+                    + 10 * self.tf * self.vf
+                )
+            )
+        ) / (self.j_max_p2 * ph1_2346)
+
+        poly3_2346 = -(
+            self.a0_p5
+            - self.af_p5
+            + self.af_p4 * j_max * self.tf
+            - 5 * self.a0_p4 * (self.af - j_max * self.tf)
+            + 2 * self.a0_p3 * ph3_2346
+            + 4 * self.af_p3 * j_max * (j_max * self.tf_p2 + self.vd)
+            + 12 * self.j_max_p2 * self.af * ph6_2346
+            - 2
+            * self.a0_p2
+            * (
+                5 * self.af_p3
+                - 9 * self.af_p2 * j_max * self.tf
+                - 6 * self.af * j_max * self.vd
+                + 6 * self.j_max_p2 * (-2 * self.pd - self.tf * self.v0 + 3 * self.tf * self.vf)
+            )
+            - 12 * self.j_max_p2 * j_max * ph2_2346
+            + self.a0 * ph5_2346
+        ) / (3 * self.j_max_p2 * j_max * ph1_2346)
+
+        poly4_2346 = -(
+            -self.a0_p6
+            - self.af_p6
+            + 6 * self.a0_p5 * (self.af - j_max * self.tf)
+            - 48 * self.af_p3 * self.j_max_p2 * self.g1
+            + 72
+            * self.j_max_p2
+            * j_max
+            * (j_max * self.g1 * self.g1 + self.vd_p2 * self.vd + 2 * self.af * self.g1 * self.vd)
+            - 3 * self.a0_p4 * ph3_2346
+            - 36 * self.af_p2 * self.j_max_p2 * self.vd_p2
+            + 6 * self.af_p4 * j_max * self.vd
+            + 4
+            * self.a0_p3
+            * (
+                5 * self.af_p3
+                - 9 * self.af_p2 * j_max * self.tf
+                - 6 * self.af * j_max * self.vd
+                + 6 * self.j_max_p2 * (-2 * self.pd - self.tf * self.v0 + 3 * self.tf * self.vf)
+            )
+            - 3 * self.a0_p2 * ph5_2346
+            + 6
+            * self.a0
+            * (
+                self.af_p5
+                - self.af_p4 * j_max * self.tf
+                - 4 * self.af_p3 * j_max * (j_max * self.tf_p2 + self.vd)
+                + 12 * self.j_max_p2 * (-self.af * ph6_2346 + j_max * ph2_2346)
+            )
+        ) / (18 * self.j_max_p2 * self.j_max_p2 * ph1_2346)
+
+        polynom_2346 = [poly1_2346, poly2_2346, poly3_2346, poly4_2346]
+        t_max_2346 = (self.a0 - a_min) / j_max
+
+        roots_2346 = sorted(solve_quartic_monic(*polynom_2346))
+        for t_root in roots_2346:
+            t_m = t_root
+            if t_m > t_max_2346:
+                continue
+
+            # Single Newton step (regarding pd).
+            h1n = self.ad_p2 / 2 + j_max * (
+                self.af * t_m + (j_max * t_m - self.a0) * (t_m - self.tf) - self.vd
+            )
+            h2n = -self.ad + j_max * (self.tf - 2 * t_m)
+            h3n = _ieee754_sqrt(h1n)
+            orig = (
+                (
+                    self.af_p3
+                    - self.a0_p3
+                    + 3 * self.af * j_max * t_m * (self.af + j_max * t_m)
+                    + 3 * self.a0_p2 * (self.af + j_max * t_m)
+                    - 3
+                    * self.a0
+                    * (
+                        self.af_p2
+                        + 2 * self.af * j_max * t_m
+                        + self.j_max_p2 * (t_m * t_m - self.tf_p2)
+                    )
+                    + 3
+                    * self.j_max_p2
+                    * (
+                        -2 * self.pd
+                        + j_max * t_m * (t_m - self.tf) * self.tf
+                        + 2 * self.tf * self.v0
+                    )
+                )
+                / (6 * self.j_max_p2)
+                - h3n * h3n * h3n / (j_max * abs(j_max))
+                + ((-self.ad - j_max * t_m) * h1n) / self.j_max_p2
+            )
+            deriv = (
+                6 * j_max * h2n * h3n / abs(j_max)
+                + 2 * (-self.ad - j_max * self.tf) * h2n
+                - 2
+                * (
+                    3 * self.ad_p2
+                    + self.af * j_max * (8 * t_m - 2 * self.tf)
+                    + 4 * self.a0 * j_max * (-2 * t_m + self.tf)
+                    + 2 * j_max * (j_max * t_m * (3 * t_m - 2 * self.tf) - self.vd)
+                )
+            ) / (4 * j_max)
+
+            t_m -= orig / deriv
+
+            h1_sol2 = _ieee754_sqrt(
+                2 * self.ad_p2
+                + 4
+                * j_max
+                * (self.ad * t_m + self.a0 * self.tf + j_max * t_m * (t_m - self.tf) - self.vd)
+            ) / abs(j_max)
+
+            # Solution 2 with aPlat
+            profile.t[0] = 0.0
+            profile.t[1] = 0.0
+            profile.t[2] = t_m
+            profile.t[3] = self.tf - 2 * t_m - self.ad / j_max - h1_sol2
+            profile.t[4] = h1_sol2 / 2
+            profile.t[5] = 0.0
+            profile.t[6] = self.tf - (t_m + profile.t[3] + profile.t[4])
+
+            if profile.check_with_timing(
+                self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+            ):
+                return True
+
+        # Profiles with a3 != 0, Solution UDUD: T 0124
+        ph0_0124 = -2 * self.pd - self.tf * self.v0 + 3 * self.tf * self.vf
+        ph1_0124 = -self.ad + j_max * self.tf
+        ph2_0124 = j_max * self.tf_p2 * self.g1 - self.vd * ph0_0124
+        ph3_0124 = 5 * self.af_p2 + 2 * j_max * (
+            2 * j_max * self.tf_p2 - self.vd - 4 * self.af * self.tf
+        )
+        ph4_0124 = (
+            self.j_max_p2 * self.tf_p4
+            - 2 * self.vd_p2
+            + 8 * j_max * self.tf * (-self.pd + self.tf * self.vf)
+        )
+        ph5_0124 = (
+            5 * self.af_p4
+            - 8 * self.af_p3 * j_max * self.tf
+            - 12 * self.af_p2 * j_max * (j_max * self.tf_p2 + self.vd)
+            + 24
+            * self.af
+            * self.j_max_p2
+            * (-2 * self.pd + j_max * self.tf_p3 + 2 * self.tf * self.vf)
+            - 6 * self.j_max_p2 * ph4_0124
+        )
+        ph6_0124 = -self.vd_p2 + j_max * self.tf * (
+            -2 * self.pd + 3 * self.tf * self.v0 - self.tf * self.vf
+        )
+        ph7_0124 = 3 * self.j_max_p2 * ph1_0124 * ph1_0124
+
+        poly1_0124 = (4 * self.af * self.tf - 2 * j_max * self.tf_p2 - 4 * self.vd) / ph1_0124
+        poly2_0124 = (
+            -2 * (self.a0_p4 + self.af_p4)
+            + 8 * self.af_p3 * j_max * self.tf
+            + 6 * self.af_p2 * self.j_max_p2 * self.tf_p2
+            + 8 * self.a0_p3 * (self.af - j_max * self.tf)
+            - 12 * self.a0_p2 * (self.af - j_max * self.tf) * (self.af - j_max * self.tf)
+            - 12
+            * self.af
+            * self.j_max_p2
+            * (-self.pd + j_max * self.tf_p3 - 2 * self.tf * self.v0 + 3 * self.tf * self.vf)
+            + 2
+            * self.a0
+            * (
+                4 * self.af_p3
+                - 12 * self.af_p2 * j_max * self.tf
+                + 9 * self.af * self.j_max_p2 * self.tf_p2
+                - 3 * self.j_max_p2 * (2 * self.pd + j_max * self.tf_p3 - 2 * self.tf * self.vf)
+            )
+            + 3
+            * self.j_max_p2
+            * (
+                self.j_max_p2 * self.tf_p4
+                + 4 * self.vd_p2
+                - 4 * j_max * self.tf * (self.pd + self.tf * self.v0 - 2 * self.tf * self.vf)
+            )
+        ) / ph7_0124
+        poly3_0124 = (
+            -self.a0_p5
+            + self.af_p5
+            - self.af_p4 * j_max * self.tf
+            + 5 * self.a0_p4 * (self.af - j_max * self.tf)
+            - 2 * self.a0_p3 * ph3_0124
+            - 4 * self.af_p3 * j_max * (j_max * self.tf_p2 + self.vd)
+            + 12 * self.af_p2 * self.j_max_p2 * self.g2
+            - 12 * self.af * self.j_max_p2 * ph6_0124
+            + 2
+            * self.a0_p2
+            * (
+                5 * self.af_p3
+                - 9 * self.af_p2 * j_max * self.tf
+                - 6 * self.af * j_max * self.vd
+                + 6 * self.j_max_p2 * ph0_0124
+            )
+            + 12 * self.j_max_p2 * j_max * ph2_0124
+            + self.a0
+            * (
+                -5 * self.af_p4
+                + 8 * self.af_p3 * j_max * self.tf
+                + 12 * self.af_p2 * j_max * (j_max * self.tf_p2 + self.vd)
+                - 24
+                * self.af
+                * self.j_max_p2
+                * (-2 * self.pd + j_max * self.tf_p3 + 2 * self.tf * self.vf)
+                + 6 * self.j_max_p2 * ph4_0124
+            )
+        ) / (j_max * ph7_0124)
+        poly4_0124 = -(
+            self.a0_p6
+            + self.af_p6
+            - 6 * self.a0_p5 * (self.af - j_max * self.tf)
+            + 48 * self.af_p3 * self.j_max_p2 * self.g1
+            - 72
+            * self.j_max_p2
+            * j_max
+            * (j_max * self.g1 * self.g1 + self.vd_p2 * self.vd + 2 * self.af * self.g1 * self.vd)
+            + 3 * self.a0_p4 * ph3_0124
+            - 6 * self.af_p4 * j_max * self.vd
+            + 36 * self.af_p2 * self.j_max_p2 * self.vd_p2
+            - 4
+            * self.a0_p3
+            * (
+                5 * self.af_p3
+                - 9 * self.af_p2 * j_max * self.tf
+                - 6 * self.af * j_max * self.vd
+                + 6 * self.j_max_p2 * ph0_0124
+            )
+            + 3 * self.a0_p2 * ph5_0124
+            - 6
+            * self.a0
+            * (
+                self.af_p5
+                - self.af_p4 * j_max * self.tf
+                - 4 * self.af_p3 * j_max * (j_max * self.tf_p2 + self.vd)
+                + 12
+                * self.j_max_p2
+                * (self.af_p2 * self.g2 - self.af * ph6_0124 + j_max * ph2_0124)
+            )
+        ) / (6 * self.j_max_p2 * ph7_0124)
+
+        polynom_0124 = [poly1_0124, poly2_0124, poly3_0124, poly4_0124]
+
+        roots_0124 = sorted(solve_quartic_monic(*polynom_0124))
+        for t in roots_0124:
+            if t > self.tf or t > (a_max - self.a0) / j_max:
+                continue
+
+            h1_0124 = _ieee754_sqrt(
+                self.ad_p2 / (2 * self.j_max_p2)
+                + (self.a0 * (t + self.tf) - self.af * t + j_max * t * self.tf - self.vd) / j_max
+            )
+
+            profile.t[0] = t
+            profile.t[1] = self.tf - self.ad / j_max - 2 * h1_0124
+            profile.t[2] = h1_0124
+            profile.t[3] = 0.0
+            profile.t[4] = self.ad / j_max + h1_0124 - t
+            profile.t[5] = 0.0
+            profile.t[6] = 0.0
+
+            if profile.check_with_timing(
+                self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDUD, ReachedLimits.NONE
+            ):
+                return True
+
+        # 3-step profile (aka UZD), sometimes missed because of numerical
+        # errors: T 012
+        h1_uzd = _ieee754_sqrt(
+            -self.ad_p2
+            + j_max * (2 * (self.a0 + self.af) * self.tf - 4 * self.vd + j_max * self.tf_p2)
+        ) / abs(j_max)
+
+        profile.t[0] = (self.tf - h1_uzd + self.ad / j_max) / 2
+        profile.t[1] = h1_uzd
+        profile.t[2] = (self.tf - h1_uzd - self.ad / j_max) / 2
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+        ):
+            return True
+
+        # 3-step profile (aka UZU), sometimes missed because of numerical
+        # errors.
+        polynom_uzu = [
+            self.ad_p2,
+            self.ad_p2 * self.tf,
+            (self.a0_p2 + self.af_p2 + 10 * self.a0 * self.af) * self.tf_p2
+            + 24 * (self.tf * (self.af * self.v0 - self.a0 * self.vf) - self.pd * self.ad)
+            + 12 * self.vd_p2,
+            -3
+            * self.tf
+            * (
+                (self.a0_p2 + self.af_p2 + 2 * self.a0 * self.af) * self.tf_p2
+                - 4 * self.vd * (self.a0 + self.af) * self.tf
+                + 4 * self.vd_p2
+            ),
+        ]
+        roots_uzu = sorted(solve_cubic(*polynom_uzu))
+        for t in roots_uzu:
+            if t > self.tf:
+                continue
+
+            jf = self.ad / (self.tf - t)
+
+            profile.t[0] = _ieee754_div(
+                2 * (self.vd - self.a0 * self.tf) + self.ad * (t - self.tf), 2 * jf * t
+            )
+            profile.t[1] = t
+            profile.t[2] = 0.0
+            profile.t[3] = 0.0
+            profile.t[4] = 0.0
+            profile.t[5] = 0.0
+            profile.t[6] = self.tf - (profile.t[0] + profile.t[1])
+
+            if profile.check_with_timing(
+                self.tf,
+                jf,
+                v_max,
+                v_min,
+                a_max,
+                a_min,
+                ControlSigns.UDDU,
+                ReachedLimits.NONE,
+                j_max=j_max,
+            ):
+                return True
+
+        # 3-step profile (aka UDU), sometimes missed because of numerical
+        # errors.
+        profile.t[0] = (
+            self.ad_p2 / j_max
+            + 2 * (self.a0 + self.af) * self.tf
+            - j_max * self.tf_p2
+            - 4 * self.vd
+        ) / (4 * (self.ad - j_max * self.tf))
+        profile.t[1] = 0.0
+        profile.t[2] = -self.ad / (2 * j_max) + self.tf / 2
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = self.tf - (profile.t[0] + profile.t[2])
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+        ):
+            return True
+
+        return False
+
+    def _time_none_smooth(
+        self,
+        profile: Profile,
+        v_max: float,
+        v_min: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> bool:
+        """Never called from :meth:`get_profile` in the Swift source either
+        -- ported anyway per otg.md design constraint 2 (see this module's
+        docstring)."""
+        # Solution: h0/h1
+        h0 = self.ad_p2 + 2 * j_max * (self.a0 * self.tf - self.vd)
+        h1a = (
+            2 * (self.a0_p3 - self.af_p3)
+            - 6 * self.a0_p2 * (self.af - j_max * self.tf)
+            + 6 * self.j_max_p2 * (-self.pd + self.tf * self.v0)
+            + 6 * self.a0 * self.af_p2
+            + 3 * self.a0 * j_max * (j_max * self.tf_p2 - 2 * self.vd)
+            + 6 * self.af * j_max * (self.vd - self.tf * self.a0)
+        )
+        h1 = _ieee754_sqrt(4 * h1a * h1a - 18 * h0 * h0 * h0) * abs(j_max) / j_max
+
+        profile.t[0] = 0.0
+        profile.t[1] = (
+            -self.a0_p3
+            + self.af_p3
+            + 3 * (self.af_p2 - self.a0_p2) * j_max * self.tf
+            - 3 * self.a0 * self.af * self.ad
+            - 6 * j_max * self.ad * self.vd
+            - 6 * self.j_max_p2 * (-2 * self.pd + self.tf * (self.v0 + self.vf))
+        ) / (3 * j_max * h0)
+        profile.t[2] = (
+            4 * (self.a0_p3 - self.af_p3)
+            + 6 * self.j_max_p2 * self.a0 * self.tf_p2
+            + 12 * self.a0 * self.af * self.ad
+            + 12
+            * j_max
+            * (j_max * (self.tf * self.v0 - self.pd) + self.ad * (self.vd - self.a0 * self.tf))
+            - h1
+        ) / (6 * j_max * h0)
+        profile.t[3] = h1 / (3 * j_max * h0)
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = self.tf - (profile.t[1] + profile.t[2] + profile.t[3])
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+        ):
+            return True
+
+        # Solution: h0/h0b/h1a
+        h0_2 = self.ad_p2 + 2 * j_max * (self.vd - self.af * self.tf)
+        h0b_2 = self.af_p3 - 3 * self.j_max_p2 * (
+            self.af * self.tf_p2 + 2 * (self.pd - self.tf * self.vf)
+        )
+        h1a_2 = self.a0_p3 + 3 * self.a0 * self.af * self.ad - h0b_2
+        h1_2 = (
+            _ieee754_sqrt(
+                4 * h1a_2 * h1a_2
+                - 6
+                * h0_2
+                * (
+                    self.a0_p4
+                    + self.af_p4
+                    - 4 * self.a0_p3 * self.af
+                    + 6 * self.a0_p2 * self.af_p2
+                    + 12
+                    * self.j_max_p2
+                    * (self.vd_p2 - 2 * self.af * (self.pd - self.tf * self.v0))
+                    - 4 * self.a0 * h0b_2
+                )
+            )
+            * abs(j_max)
+            / j_max
+        )
+
+        profile.t[0] = -(2 * h1a_2 + h1_2) / (6 * j_max * h0_2)
+        profile.t[1] = h1_2 / (3 * j_max * h0_2)
+        profile.t[2] = profile.t[0] - (self.af - self.a0) / j_max
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = self.tf - (profile.t[0] + profile.t[1] + profile.t[2])
+        profile.t[6] = 0.0
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+        ):
+            return True
+
+        # Solution 3
+        h0_3 = (
+            _ieee754_sqrt(
+                3
+                * (
+                    self.a0_p4
+                    + self.af_p4
+                    - 4 * self.af_p3 * j_max * self.tf
+                    + 6 * self.af_p2 * self.j_max_p2 * self.tf_p2
+                    - 4 * self.a0_p3 * (self.af - j_max * self.tf)
+                    + 6 * self.a0_p2 * (self.af - j_max * self.tf) * (self.af - j_max * self.tf)
+                    + 24 * self.af * self.j_max_p2 * (-self.pd + self.tf * self.v0)
+                    - 4
+                    * self.a0
+                    * (
+                        self.af_p3
+                        - 3 * self.af_p2 * j_max * self.tf
+                        + 6 * self.j_max_p2 * (-self.pd + self.tf * self.vf)
+                    )
+                    - 12
+                    * self.j_max_p2
+                    * (
+                        -self.vd_p2
+                        + j_max * self.tf * (-2 * self.pd + self.tf * (self.v0 + self.vf))
+                    )
+                )
+            )
+            * abs(j_max)
+            / j_max
+        )
+        h1_3 = (
+            _ieee754_sqrt(
+                3
+                * (
+                    3 * self.a0_p2
+                    + 3 * self.af_p2
+                    - 6 * self.a0 * self.af
+                    - 6 * self.ad * j_max * self.tf
+                    + 3 * self.j_max_p2 * self.tf_p2
+                    - 2 * h0_3
+                )
+            )
+            * abs(j_max)
+            / j_max
+        )
+
+        profile.t[0] = (
+            -3 * (self.a0_p2 + self.af_p2)
+            + 6 * self.a0 * self.af
+            + 6 * j_max * (self.vd - self.a0 * self.tf)
+            + h0_3
+        ) / (6 * j_max * (-self.ad + j_max * self.tf))
+        profile.t[1] = 0.0
+        profile.t[2] = (3 * j_max * self.tf - 3 * self.ad - h1_3) / (6 * j_max)
+        profile.t[3] = h1_3 / (3 * j_max)
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = self.tf - (profile.t[0] + profile.t[2] + profile.t[3])
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+        ):
+            return True
+
+        # Solution 2
+        h0_4 = 6 * (self.ad_p2 + 2 * self.af * j_max * self.tf - 2 * j_max * self.vd)
+        h1a_4 = 2 * (
+            self.a0_p3
+            - self.af_p3
+            + 3 * self.a0 * self.af * self.ad
+            + 6 * self.j_max_p2 * (self.pd - self.tf * self.vf)
+            + 3 * self.j_max_p2 * self.af * self.tf_p2
+        )
+        h1_4 = (
+            _ieee754_sqrt(
+                h1a_4 * h1a_4
+                - h0_4
+                * (
+                    self.a0_p4
+                    - 4 * self.a0_p3 * self.af
+                    + 6 * self.a0_p2 * self.af_p2
+                    + self.af_p4
+                    + 24 * self.af * self.j_max_p2 * (-self.pd + self.tf * self.v0)
+                    + 12 * self.j_max_p2 * self.vd_p2
+                    - 4
+                    * self.a0
+                    * (
+                        self.af_p3
+                        - 3 * self.af * self.j_max_p2 * self.tf_p2
+                        + 6 * self.j_max_p2 * (-self.pd + self.tf * self.vf)
+                    )
+                )
+            )
+            * abs(j_max)
+            / j_max
+        )
+        h2_4 = (
+            4 * self.a0_p3
+            - 4 * self.af_p3
+            + 12 * self.a0 * self.af * self.ad
+            - 12 * self.j_max_p2 * (self.pd - self.tf * self.vf)
+            - 6 * self.j_max_p2 * self.af * self.tf_p2
+            + 12 * self.ad * j_max * (self.vd - self.af * self.tf)
+        )
+        h3_4 = j_max * h0_4
+
+        profile.t[0] = 0.0
+        profile.t[1] = 0.0
+        profile.t[2] = (h1a_4 + h1_4) / h3_4
+        profile.t[3] = -(h2_4 + h1_4) / h3_4
+        profile.t[4] = (h2_4 - h1_4) / h3_4
+        profile.t[5] = self.tf - (profile.t[2] + profile.t[3] + profile.t[4])
+        profile.t[6] = 0.0
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+        ):
+            return True
+
+        # Solution 1
+        term1 = self.a0_p4 + self.af_p4 - 4 * self.af_p3 * j_max * self.tf
+        term2 = 6 * self.af_p2 * self.j_max_p2 * self.tf_p2
+        term3 = -4 * self.a0_p3 * (self.af - j_max * self.tf)
+        term4 = 6 * self.a0_p2 * (self.af - j_max * self.tf) * (self.af - j_max * self.tf)
+        term5 = 24 * self.af * self.j_max_p2 * (-self.pd + self.tf * self.v0)
+        term6 = (
+            -4
+            * self.a0
+            * (
+                self.af_p3
+                - 3 * self.af_p2 * j_max * self.tf
+                + 6 * self.j_max_p2 * (-self.pd + self.tf * self.vf)
+            )
+        )
+        term7 = (
+            -12
+            * self.j_max_p2
+            * (-self.vd_p2 + j_max * self.tf * (-2 * self.pd + self.tf * (self.v0 + self.vf)))
+        )
+
+        h0_5 = (
+            _ieee754_sqrt((term1 + term2 + term3 + term4 + term5 + term6 + term7) / 3)
+            * abs(j_max)
+            / j_max
+        )
+        h1_5 = (
+            _ieee754_sqrt(
+                self.ad_p2 - 2 * self.ad * j_max * self.tf + self.j_max_p2 * self.tf_p2 + 2 * h0_5
+            )
+            * abs(j_max)
+            / j_max
+        )
+
+        profile.t[0] = -(self.ad_p2 + 2 * j_max * (self.a0 * self.tf - self.vd) + h0_5) / (
+            2 * j_max * (-self.ad + j_max * self.tf)
+        )
+        profile.t[1] = 0.0
+        profile.t[2] = 0.0
+        profile.t[3] = 0.0
+        profile.t[4] = (-self.ad + j_max * self.tf - h1_5) / (2 * j_max)
+        profile.t[5] = h1_5 / j_max
+        profile.t[6] = self.tf - (profile.t[0] + profile.t[4] + profile.t[5])
+
+        if profile.check_with_timing(
+            self.tf, j_max, v_max, v_min, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+        ):
+            return True
+
+        return False
+
+    def get_profile(self, profile: Profile) -> bool:
+        # Set the profile target values and initial state -- these are used
+        # by check()/check_with_timing() to validate the generated
+        # trajectory.
+        profile.pf = self.pf
+        profile.vf = self.vf
+        profile.af = self.af
+        profile.p[0] = self.p0
+        profile.v[0] = self.v0
+        profile.a[0] = self.a0
+
+        # Test all cases to get ones that match. However we should guess
+        # which one is correct and try them first...
+        up_first = self.pd > self.tf * self.v0
+        v_max = self._v_max if up_first else self._v_min
+        v_min = self._v_min if up_first else self._v_max
+        a_max = self._a_max if up_first else self._a_min
+        a_min = self._a_min if up_first else self._a_max
+        j_max = self._j_max if up_first else -self._j_max
+
+        if self._time_acc0_acc1_vel(profile, v_max, v_min, a_max, a_min, j_max):
+            return True
+
+        if self._time_vel(profile, v_max, v_min, a_max, a_min, j_max):
+            return True
+
+        if self._time_acc0_vel(profile, v_max, v_min, a_max, a_min, j_max):
+            return True
+
+        if self._time_acc1_vel(profile, v_max, v_min, a_max, a_min, j_max):
+            return True
+
+        if self._time_acc0_acc1_vel(profile, v_min, v_max, a_min, a_max, -j_max):
+            return True
+
+        if self._time_vel(profile, v_min, v_max, a_min, a_max, -j_max):
+            return True
+
+        if self._time_acc0_vel(profile, v_min, v_max, a_min, a_max, -j_max):
+            return True
+
+        if self._time_acc1_vel(profile, v_min, v_max, a_min, a_max, -j_max):
+            return True
+
+        if self._time_acc0_acc1(profile, v_max, v_min, a_max, a_min, j_max):
+            return True
+
+        if self._time_acc0(profile, v_max, v_min, a_max, a_min, j_max):
+            return True
+
+        if self._time_acc1(profile, v_max, v_min, a_max, a_min, j_max):
+            return True
+
+        if self._time_none(profile, v_max, v_min, a_max, a_min, j_max):
+            return True
+
+        if self._time_acc0_acc1(profile, v_min, v_max, a_min, a_max, -j_max):
+            return True
+
+        if self._time_acc0(profile, v_min, v_max, a_min, a_max, -j_max):
+            return True
+
+        if self._time_acc1(profile, v_min, v_max, a_min, a_max, -j_max):
+            return True
+
+        if self._time_none(profile, v_min, v_max, a_min, a_max, -j_max):
+            return True
+
+        return False
diff --git a/src/math_tools/otg/steps/velocity_second_order.py b/src/math_tools/otg/steps/velocity_second_order.py
new file mode 100644
index 0000000..758517a
--- /dev/null
+++ b/src/math_tools/otg/steps/velocity_second_order.py
@@ -0,0 +1,99 @@
+"""Step solvers for the second-order (no jerk limit) velocity interface:
+Step 1 computes the time-optimal profile, Step 2 computes a profile for a
+prescribed duration.
+
+Faithful ports of
+``SWIFT_MATH/OTG/velocity/VelocitySecondOrderStep1.swift`` and
+``...VelocitySecondOrderStep2.swift`` (class/method names and branch
+structure preserved mechanically). See ``.claude/specs/otg.md`` §Internal
+fidelity requirements 1, 2, 4, 5 and
+``.claude/action-plan/36-otg-velocity-steps.md``.
+
+``VelocitySecondOrderStep1.get_profile`` ports Swift's ``var p =
+block.pMin`` (a struct value copy) as ``copy.deepcopy(block.p_min)``:
+``Profile`` is a Python class (reference type), so a plain assignment would
+alias ``block.p_min`` and let ``p.set_boundary(...)``/the failed-check path
+mutate ``block.p_min`` in place even when this function returns ``False``
+(Swift's local copy is simply discarded on failure, leaving ``block.pMin``
+untouched). ``deepcopy`` is safe here: ``Profile`` holds only plain floats,
+lists, ``BrakeProfile`` (itself plain floats/lists), and immutable ``str``
+enum members.
+"""
+
+from __future__ import annotations
+
+import copy
+
+from math_tools.otg.block import Block
+from math_tools.otg.enums import ControlSigns, ReachedLimits
+from math_tools.otg.profile import Profile
+
+__all__: list[str] = []
+
+
+class VelocitySecondOrderStep1:
+    """Mathematical equations for Step 1 in the second-order velocity
+    interface: extremal profiles."""
+
+    def __init__(self, v0: float, vf: float, a_max: float, a_min: float) -> None:
+        self._a_max = a_max
+        self._a_min = a_min
+
+        # Pre-calculated expressions.
+        self.vd = vf - v0
+
+    def get_profile(self, input_profile: Profile, block: Block) -> bool:
+        p = copy.deepcopy(block.p_min)
+        p.set_boundary(input_profile)
+
+        af = self._a_max if self.vd > 0 else self._a_min
+        p.t[0] = 0.0
+        p.t[1] = self.vd / af
+        p.t[2] = 0.0
+        p.t[3] = 0.0
+        p.t[4] = 0.0
+        p.t[5] = 0.0
+        p.t[6] = 0.0
+
+        if p.check_for_second_order_velocity(af, ControlSigns.UDDU, ReachedLimits.ACC0):
+            block.t_min = p.t_sum[-1] + p.brake.duration + p.accel.duration
+            block.p_min = p
+            return True
+        return False
+
+
+class VelocitySecondOrderStep2:
+    """Mathematical equations for Step 2 in the second-order velocity
+    interface: time synchronization."""
+
+    def __init__(self, tf: float, v0: float, vf: float, a_max: float, a_min: float) -> None:
+        self.tf = tf
+        self._a_max = a_max
+        self._a_min = a_min
+
+        # Pre-calculated expressions.
+        self.vd = vf - v0
+
+    def get_profile(self, profile: Profile) -> bool:
+        af = self.vd / self.tf
+
+        profile.t[0] = 0.0
+        profile.t[1] = self.tf
+        profile.t[2] = 0.0
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check_for_second_order_velocity_with_timing(
+            self.tf,
+            af,
+            ControlSigns.UDDU,
+            ReachedLimits.NONE,
+            a_max=self._a_max,
+            a_min=self._a_min,
+        ):
+            profile.pf = profile.p[-1]
+            return True
+
+        return False
diff --git a/src/math_tools/otg/steps/velocity_third_order.py b/src/math_tools/otg/steps/velocity_third_order.py
new file mode 100644
index 0000000..1db55ac
--- /dev/null
+++ b/src/math_tools/otg/steps/velocity_third_order.py
@@ -0,0 +1,368 @@
+"""Step solvers for the third-order (jerk-limited) velocity interface:
+Step 1 computes the time-optimal profile, Step 2 computes a profile for a
+prescribed duration.
+
+Faithful ports of ``SWIFT_MATH/OTG/velocity/VelocityThirdOrderStep1.swift``
+and ``...VelocityThirdOrderStep2.swift`` (class/method names and branch
+structure preserved mechanically). See ``.claude/specs/otg.md`` §Internal
+fidelity requirements 1, 2, 4, 5 and
+``.claude/action-plan/36-otg-velocity-steps.md``.
+
+**Struct-value-copy semantics.** ``Profile`` is a Python class (reference
+type); Swift's ``Profile`` is a struct (value type). Every Swift ``var x =
+someProfile`` line that is later selectively kept-or-discarded based on a
+``check*`` call's success is ported as ``copy.deepcopy(someProfile)`` here,
+never a plain assignment -- a plain assignment would alias the two names
+and let a failed attempt's partial mutations corrupt the original (or, in
+``VelocityThirdOrderStep1._time_acc0``/``_time_none``, corrupt an
+*already-recorded successful* candidate from an earlier attempt in the same
+call, since both solutions reuse the same local variable). Deep copies
+appear at:
+
+- ``VelocityThirdOrderStep1.get_profile``'s zero-limits branch (``var p =
+  block.pMin``);
+- ``_time_acc0``/``_time_none``'s ``var profile =
+  validProfiles[profileCount]`` (the working candidate) and their
+  ``validProfiles[profileCount] = profile`` save points (so a
+  subsequently-mutated working copy cannot retroactively corrupt an
+  already-saved candidate).
+
+``VelocityThirdOrderStep2`` never needs this: its private ``timeAcc0``/
+``timeNone``/``checkAll`` mutate a single ``profile`` argument directly and
+always return on the first success (Swift ``inout`` maps directly onto
+Python's natural pass-by-reference mutable-object semantics there).
+"""
+
+from __future__ import annotations
+
+import copy
+import math
+import sys
+
+from math_tools.otg.block import Block, Interval
+from math_tools.otg.enums import ControlSigns, ReachedLimits
+from math_tools.otg.profile import Profile
+
+__all__: list[str] = []
+
+#: Swift ``Double.ulpOfOne`` (machine epsilon for float64) -- VelocityThirdOrderStep2's
+#: own "all zero" special case. Matches ``profile.py``'s identical convention of a
+#: module-private epsilon per Swift file (this is NOT ``functional.roots.EPS16``).
+_ULP = sys.float_info.epsilon
+
+#: Swift ``Double.leastNormalMagnitude`` (smallest positive normalized
+#: float64, ~2.2250738585072014e-308) -- VelocityThirdOrderStep1's
+#: near-zero guards. Distinct from ``_ULP``/``Double.ulpOfOne`` above.
+_LEAST_NORMAL_MAGNITUDE = sys.float_info.min
+
+
+class VelocityThirdOrderStep1:
+    """Mathematical equations for Step 1 in the third-order velocity
+    interface: extremal profiles."""
+
+    def __init__(
+        self,
+        v0: float,
+        a0: float,
+        vf: float,
+        af: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> None:
+        self.a0 = a0
+        self.af = af
+        self._a_max = a_max
+        self._a_min = a_min
+        self._j_max = j_max
+
+        # Pre-calculated expressions.
+        self.vd = vf - v0
+
+        # Max 3 valid profiles.
+        self.valid_profiles: list[Profile] = [Profile() for _ in range(3)]
+        self._profile_count = 0
+
+    def _add_profile(self) -> None:
+        self._profile_count += 1
+        if self._profile_count < len(self.valid_profiles):
+            self.valid_profiles[self._profile_count].set_boundary(
+                self.valid_profiles[self._profile_count - 1]
+            )
+
+    def _reset_profiles(self) -> None:
+        self._profile_count = 0
+
+    def _has_profiles(self) -> bool:
+        return self._profile_count > 0
+
+    def _time_acc0(
+        self, a_max: float, a_min: float, j_max: float, return_after_found: bool
+    ) -> None:
+        profile = copy.deepcopy(self.valid_profiles[self._profile_count])
+
+        profile.t[0] = (-self.a0 + a_max) / j_max
+        profile.t[1] = (
+            (self.a0 * self.a0 + self.af * self.af) / (2 * a_max * j_max)
+            - a_max / j_max
+            + self.vd / a_max
+        )
+        profile.t[2] = (-self.af + a_max) / j_max
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check_for_velocity(j_max, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC0):
+            self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+            self._add_profile()
+            if return_after_found:
+                return
+
+    def _time_none(
+        self, a_max: float, a_min: float, j_max: float, return_after_found: bool
+    ) -> None:
+        profile = copy.deepcopy(self.valid_profiles[self._profile_count])
+
+        h1 = (self.a0 * self.a0 + self.af * self.af) / 2 + j_max * self.vd
+        if h1 < 0.0:
+            return
+        h1 = math.sqrt(h1)
+
+        # Solution 1
+        profile.t[0] = -(self.a0 + h1) / j_max
+        profile.t[1] = 0.0
+        profile.t[2] = -(self.af + h1) / j_max
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check_for_velocity(j_max, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE):
+            self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+            self._add_profile()
+            if return_after_found:
+                return
+
+        # Solution 2
+        profile.t[0] = (-self.a0 + h1) / j_max
+        profile.t[1] = 0.0
+        profile.t[2] = (-self.af + h1) / j_max
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check_for_velocity(j_max, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE):
+            self.valid_profiles[self._profile_count] = copy.deepcopy(profile)
+            self._add_profile()
+
+    def _time_all_single_step(
+        self, profile: Profile, a_max: float, a_min: float, j_max: float
+    ) -> bool:
+        """Only for the zero-limits case."""
+        if abs(self.af - self.a0) > _LEAST_NORMAL_MAGNITUDE:
+            return False
+
+        profile.t[0] = 0.0
+        profile.t[1] = 0.0
+        profile.t[2] = 0.0
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if abs(self.a0) > _LEAST_NORMAL_MAGNITUDE:
+            profile.t[3] = self.vd / self.a0
+            if profile.check_for_velocity(0.0, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE):
+                return True
+        elif abs(self.vd) < _LEAST_NORMAL_MAGNITUDE:
+            if profile.check_for_velocity(0.0, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE):
+                return True
+
+        return False
+
+    def get_profile(self, input_profile: Profile, block: Block) -> bool:
+        # Zero-limits special case.
+        if self._j_max == 0.0:
+            p = copy.deepcopy(block.p_min)
+            p.set_boundary(input_profile)
+
+            if self._time_all_single_step(p, self._a_max, self._a_min, self._j_max):
+                block.p_min = p
+                block.t_min = p.t_sum[-1] + p.brake.duration + p.accel.duration
+                if abs(self.a0) > _LEAST_NORMAL_MAGNITUDE:
+                    block.a = Interval(block.t_min, math.inf)
+                return True
+            return False
+
+        self._reset_profiles()
+        self.valid_profiles[self._profile_count].set_boundary(input_profile)
+
+        if abs(self.af) < _LEAST_NORMAL_MAGNITUDE:
+            # There is no blocked interval when af==0, so return after first found profile.
+            a_max = self._a_max if self.vd >= 0 else self._a_min
+            a_min = self._a_min if self.vd >= 0 else self._a_max
+            j_max = self._j_max if self.vd >= 0 else -self._j_max
+
+            self._time_none(a_max, a_min, j_max, True)
+            if self._has_profiles():
+                success, _ = Block.calculate_block(block, self.valid_profiles, self._profile_count)
+                return success
+
+            self._time_acc0(a_max, a_min, j_max, True)
+            if self._has_profiles():
+                success, _ = Block.calculate_block(block, self.valid_profiles, self._profile_count)
+                return success
+
+            self._time_none(a_min, a_max, -j_max, True)
+            if self._has_profiles():
+                success, _ = Block.calculate_block(block, self.valid_profiles, self._profile_count)
+                return success
+
+            self._time_acc0(a_min, a_max, -j_max, True)
+
+        else:
+            self._time_none(self._a_max, self._a_min, self._j_max, False)
+            self._time_none(self._a_min, self._a_max, -self._j_max, False)
+            self._time_acc0(self._a_max, self._a_min, self._j_max, False)
+            self._time_acc0(self._a_min, self._a_max, -self._j_max, False)
+
+        success, _ = Block.calculate_block(block, self.valid_profiles, self._profile_count)
+        return success
+
+
+class VelocityThirdOrderStep2:
+    """Mathematical equations for Step 2 in the third-order velocity
+    interface: time synchronization."""
+
+    def __init__(
+        self,
+        tf: float,
+        v0: float,
+        a0: float,
+        vf: float,
+        af: float,
+        a_max: float,
+        a_min: float,
+        j_max: float,
+    ) -> None:
+        self.tf = tf
+        self.a0 = a0
+        self.af = af
+        self._a_max = a_max
+        self._a_min = a_min
+        self._j_max = j_max
+
+        # Pre-calculated expressions.
+        self.vd = vf - v0
+        self.ad = af - a0
+
+    def _time_acc0(self, profile: Profile, a_max: float, a_min: float, j_max: float) -> bool:
+        # UD Solution 1/2
+        h1 = math.sqrt(
+            (-self.ad * self.ad + 2 * j_max * ((self.a0 + self.af) * self.tf - 2 * self.vd))
+            / (j_max * j_max)
+            + self.tf * self.tf
+        )
+
+        profile.t[0] = self.ad / (2 * j_max) + (self.tf - h1) / 2
+        profile.t[1] = h1
+        profile.t[2] = self.tf - (profile.t[0] + h1)
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        if profile.check_for_velocity_with_timing(
+            self.tf, j_max, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC0
+        ):
+            profile.pf = profile.p[7]
+            return True
+
+        # UU Solution
+        h1 = -self.ad + j_max * self.tf
+
+        profile.t[0] = -self.ad * self.ad / (2 * j_max * h1) + (self.vd - self.a0 * self.tf) / h1
+        profile.t[1] = -self.ad / j_max + self.tf
+        profile.t[2] = 0.0
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = self.tf - (profile.t[0] + profile.t[1])
+
+        if profile.check_for_velocity_with_timing(
+            self.tf, j_max, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC0
+        ):
+            profile.pf = profile.p[7]
+            return True
+
+        # UU Solution - 2 step
+        profile.t[0] = 0.0
+        profile.t[1] = -self.ad / j_max + self.tf
+        profile.t[2] = 0.0
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = self.ad / j_max
+
+        if profile.check_for_velocity_with_timing(
+            self.tf, j_max, a_max, a_min, ControlSigns.UDDU, ReachedLimits.ACC0
+        ):
+            profile.pf = profile.p[7]
+            return True
+
+        return False
+
+    def _time_none(self, profile: Profile, a_max: float, a_min: float, j_max: float) -> bool:
+        # Special case: all zero
+        if abs(self.a0) < _ULP and abs(self.af) < _ULP and abs(self.vd) < _ULP:
+            profile.t[0] = 0.0
+            profile.t[1] = self.tf
+            profile.t[2] = 0.0
+            profile.t[3] = 0.0
+            profile.t[4] = 0.0
+            profile.t[5] = 0.0
+            profile.t[6] = 0.0
+
+            if profile.check_for_velocity_with_timing(
+                self.tf, j_max, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+            ):
+                profile.pf = profile.p[7]
+                return True
+
+        # UD Solution 1/2
+        h1 = 2 * (self.af * self.tf - self.vd)
+
+        profile.t[0] = h1 / self.ad
+        profile.t[1] = self.tf - profile.t[0]
+        profile.t[2] = 0.0
+        profile.t[3] = 0.0
+        profile.t[4] = 0.0
+        profile.t[5] = 0.0
+        profile.t[6] = 0.0
+
+        jf = self.ad * self.ad / h1
+
+        if abs(jf) < abs(j_max) + 1e-12 and profile.check_for_velocity_with_timing(
+            self.tf, jf, a_max, a_min, ControlSigns.UDDU, ReachedLimits.NONE
+        ):
+            profile.pf = profile.p[7]
+            return True
+
+        return False
+
+    def _check_all(self, profile: Profile, a_max: float, a_min: float, j_max: float) -> bool:
+        return self._time_acc0(profile, a_max, a_min, j_max) or self._time_none(
+            profile, a_max, a_min, j_max
+        )
+
+    def get_profile(self, profile: Profile) -> bool:
+        if self.vd > 0:
+            return self._check_all(
+                profile, self._a_max, self._a_min, self._j_max
+            ) or self._check_all(profile, self._a_min, self._a_max, -self._j_max)
+
+        return self._check_all(profile, self._a_min, self._a_max, -self._j_max) or self._check_all(
+            profile, self._a_max, self._a_min, self._j_max
+        )
diff --git a/src/math_tools/otg/trajectory.py b/src/math_tools/otg/trajectory.py
new file mode 100644
index 0000000..64d4d33
--- /dev/null
+++ b/src/math_tools/otg/trajectory.py
@@ -0,0 +1,325 @@
+"""Trajectory container + sampler: the computed motion for all DOFs.
+
+Faithful port of ``SWIFT_MATH/OTG/Trajectory.swift``. See
+``.claude/specs/otg.md`` §Public API (Trajectory) and
+``.claude/action-plan/35-otg-trajectory-and-output.md``.
+
+``atTime``'s several Swift overloads (``inout`` arrays, single-DOF scalars,
+``newSection``/``newJerk`` variants) collapse into one Python entry point:
+:meth:`Trajectory.at_time` returns ``(positions, velocities,
+accelerations)`` directly (matching the Swift convenience overload used by
+external callers), backed by the private :meth:`Trajectory._state_to_integrate_from`
+(mirrors ``stateToIntegrateFrom`` exactly, including the section index --
+available for the driver, chunk 41, to reuse). ``time`` is clamped to
+``[0, duration]`` before sampling, per ``otg.md`` §Public API ("clamped to
+``[0, duration]`` ends per Swift").
+
+``Profile.getPositionExtrema``/``getFirstStateAtPosition`` (Swift) were
+explicitly deferred by chunk 33 to "a later chunk (35, trajectory
+sampling)" (see ``33-otg-profile.md``'s Resolution notes) because both
+depend on things chunk 33 didn't carry: aggregating across the brake
+sub-profile (a ``Trajectory``-level concern) and the cubic root solver.
+Both are ported here as module-private functions operating on a
+``Profile`` instance's already-public fields plus
+``Profile.check_step_for_position_extremum`` (already a public
+``staticmethod``) and ``math_tools.functional.roots.solve_cubic`` --
+deliberately NOT new methods on ``Profile`` itself, since this chunk's own
+file list does not include ``profile.py`` and the stay-in-scope default
+posture calls for the minimal change that satisfies the ask.
+"""
+
+from __future__ import annotations
+
+import math
+import sys
+
+from math_tools.functional.roots import integrate_jerk, solve_cubic
+from math_tools.otg.bound import Bound
+from math_tools.otg.profile import Profile
+
+__all__ = ["Trajectory"]
+
+#: Swift ``Double.ulpOfOne`` -- matches ``profile.py``/``brake.py``/
+#: ``block.py``'s identical convention for their own private near-equality
+#: tolerance (not ``functional.roots.EPS16``, a different, unrelated
+#: constant used only by the polynomial-root kernel).
+_ULP = sys.float_info.epsilon
+
+
+class Trajectory:
+    """The trajectory generated by the Ruckig algorithm: per-DOF ``Profile``
+    sections plus the synchronized sampling logic.
+
+    ``profiles`` is a list of sections; each section is a list of one
+    ``Profile`` per DOF. A trajectory with no intermediate waypoints has
+    exactly one section (``max_number_of_waypoints=0``, the default) --
+    this collapses Swift's two constructor overloads (``init(dofs:)`` and
+    ``init(dofs:maxNumberOfWaypoints:)``) into one, since
+    ``maxNumberOfWaypoints=0`` already produces the same single-section
+    shape as the no-waypoints overload.
+    """
+
+    def __init__(self, dofs: int, max_number_of_waypoints: int = 0) -> None:
+        self.degrees_of_freedom = dofs
+
+        num_sections = max_number_of_waypoints + 1
+        self.profiles: list[list[Profile]] = [
+            [Profile() for _ in range(dofs)] for _ in range(num_sections)
+        ]
+        self.cumulative_times: list[float] = [0.0] * num_sections
+
+        self.duration: float = 0.0
+        self.independent_min_durations: list[float] = [0.0] * dofs
+
+    # MARK: - Sampling
+
+    def _state_to_integrate_from(
+        self, time: float
+    ) -> tuple[int, list[tuple[float, float, float, float, float]]]:
+        """``stateToIntegrateFrom`` -- for each DOF, the ``(t, p, v, a, j)``
+        arguments to feed :func:`~math_tools.functional.roots.integrate_jerk`,
+        plus the section index reached at ``time``.
+
+        ``time`` is assumed already clamped to ``[0, duration]`` by the
+        caller (:meth:`at_time`).
+        """
+        dofs = self.degrees_of_freedom
+
+        if time >= self.duration:
+            # Keep constant acceleration beyond the trajectory's end.
+            new_section = len(self.profiles)
+            last_section = self.profiles[-1]
+            args: list[tuple[float, float, float, float, float]] = []
+            for dof in range(dofs):
+                profile = last_section[dof]
+                t_pre = (
+                    self.cumulative_times[-2]
+                    if len(self.profiles) > 1
+                    else profile.brake.duration
+                )
+                t_diff = time - (t_pre + profile.t_sum[-1])
+                args.append((t_diff, profile.p[-1], profile.v[-1], profile.a[-1], 0.0))
+            return new_section, args
+
+        # Find the correct section (first cumulative time strictly after `time`).
+        new_section = len(self.cumulative_times)
+        for section_i, cumulative in enumerate(self.cumulative_times):
+            if cumulative > time:
+                new_section = section_i
+                break
+
+        t_diff = time
+        if new_section > 0:
+            t_diff -= self.cumulative_times[new_section - 1]
+
+        args = []
+        for dof in range(dofs):
+            profile = self.profiles[new_section][dof]
+            t_diff_dof = t_diff
+
+            # Brake pre-trajectory (only ever present in the first section).
+            if new_section == 0 and profile.brake.duration > 0:
+                if t_diff_dof < profile.brake.duration:
+                    index = 0 if t_diff_dof < profile.brake.t[0] else 1
+                    if index > 0:
+                        t_diff_dof -= profile.brake.t[index - 1]
+                    args.append(
+                        (
+                            t_diff_dof,
+                            profile.brake.p[index],
+                            profile.brake.v[index],
+                            profile.brake.a[index],
+                            profile.brake.j[index],
+                        )
+                    )
+                    continue
+                t_diff_dof -= profile.brake.duration
+
+            if t_diff_dof >= profile.t_sum[-1]:
+                # Keep constant acceleration past this profile's own end.
+                args.append(
+                    (
+                        t_diff_dof - profile.t_sum[-1],
+                        profile.p[-1],
+                        profile.v[-1],
+                        profile.a[-1],
+                        0.0,
+                    )
+                )
+                continue
+
+            # Find the correct time segment (first t_sum strictly after t_diff_dof).
+            index_dof = len(profile.t_sum)
+            for segment_i, t_sum_i in enumerate(profile.t_sum):
+                if t_sum_i > t_diff_dof:
+                    index_dof = segment_i
+                    break
+
+            if index_dof > 0:
+                t_diff_dof -= profile.t_sum[index_dof - 1]
+
+            args.append(
+                (
+                    t_diff_dof,
+                    profile.p[index_dof],
+                    profile.v[index_dof],
+                    profile.a[index_dof],
+                    profile.j[index_dof],
+                )
+            )
+
+        return new_section, args
+
+    def at_time(self, time: float) -> tuple[list[float], list[float], list[float]]:
+        """``atTime`` (the position/velocity/acceleration convenience
+        overload). ``time`` is clamped to ``[0, duration]`` (otg.md §Public
+        API)."""
+        clamped_time = max(0.0, min(time, self.duration))
+        _new_section, integrate_args = self._state_to_integrate_from(clamped_time)
+
+        positions: list[float] = []
+        velocities: list[float] = []
+        accelerations: list[float] = []
+        for t, p0, v0, a0, j in integrate_args:
+            p, v, a = integrate_jerk(t, p0, v0, a0, j)
+            positions.append(p)
+            velocities.append(v)
+            accelerations.append(a)
+        return positions, velocities, accelerations
+
+    # MARK: - Position extrema
+
+    def position_extrema(self) -> list[Bound]:
+        """``getPositionExtrema`` (Trajectory-level): the min/max position
+        (and the times at which they occur) reached by each DOF, merged
+        across every profile section.
+
+        Each section's own extrema are computed independently -- the times
+        recorded are section-relative, not offset by the section's start
+        time. This is a direct, literal port of the Swift source (see this
+        chunk's Out of scope note: "Extrema across brake sections beyond
+        the direct port").
+        """
+        dofs = self.degrees_of_freedom
+        extrema = [_profile_position_extrema(self.profiles[0][dof]) for dof in range(dofs)]
+
+        for section in self.profiles[1:]:
+            for dof in range(dofs):
+                section_extrema = _profile_position_extrema(section[dof])
+                if section_extrema.max > extrema[dof].max:
+                    extrema[dof].max = section_extrema.max
+                    extrema[dof].t_max = section_extrema.t_max
+                if section_extrema.min < extrema[dof].min:
+                    extrema[dof].min = section_extrema.min
+                    extrema[dof].t_min = section_extrema.t_min
+
+        return extrema
+
+    # MARK: - Internal accessors
+
+    def _get_intermediate_durations(self) -> list[float]:
+        """``get_intermediate_durations`` -- the durations at which each
+        intermediate waypoint is reached."""
+        return self.cumulative_times
+
+    def _get_first_time_at_position(
+        self, dof: int, position: float, time_after: float = 0.0
+    ) -> float | None:
+        """``get_first_time_at_position`` -- the first time this
+        trajectory passes ``position`` for the given ``dof``, at or after
+        ``time_after``; ``None`` if it never does (or ``dof`` is out of
+        range)."""
+        if dof >= self.degrees_of_freedom:
+            return None
+
+        for section_i, section in enumerate(self.profiles):
+            found, time = _profile_first_state_at_position(section[dof], position, time_after)
+            if found:
+                section_time = self.cumulative_times[section_i - 1] if section_i > 0 else 0.0
+                return section_time + time
+
+        return None
+
+
+def _profile_position_extrema(profile: Profile) -> Bound:
+    """``Profile.getPositionExtrema`` -- deferred by chunk 33 to this
+    module (see chunk 33's Resolution notes and this module's docstring)."""
+    extrema = Bound(min=math.inf, max=-math.inf, t_min=-math.inf, t_max=-math.inf)
+
+    if profile.brake.duration > 0.0 and profile.brake.t[0] > 0.0:
+        Profile.check_step_for_position_extremum(
+            0.0,
+            profile.brake.t[0],
+            profile.brake.p[0],
+            profile.brake.v[0],
+            profile.brake.a[0],
+            profile.brake.j[0],
+            extrema,
+        )
+        if profile.brake.t[1] > 0.0:
+            Profile.check_step_for_position_extremum(
+                profile.brake.t[0],
+                profile.brake.t[1],
+                profile.brake.p[1],
+                profile.brake.v[1],
+                profile.brake.a[1],
+                profile.brake.j[1],
+                extrema,
+            )
+
+    t_current_sum = 0.0
+    for i in range(7):
+        if i > 0:
+            t_current_sum = profile.t_sum[i - 1]
+        Profile.check_step_for_position_extremum(
+            t_current_sum + profile.brake.duration,
+            profile.t[i],
+            profile.p[i],
+            profile.v[i],
+            profile.a[i],
+            profile.j[i],
+            extrema,
+        )
+
+    if profile.pf < extrema.min:
+        extrema.min = profile.pf
+        extrema.t_min = profile.t_sum[-1] + profile.brake.duration
+    if profile.pf > extrema.max:
+        extrema.max = profile.pf
+        extrema.t_max = profile.t_sum[-1] + profile.brake.duration
+
+    return extrema
+
+
+def _profile_first_state_at_position(
+    profile: Profile, pt: float, time_after: float = 0.0
+) -> tuple[bool, float]:
+    """``Profile.getFirstStateAtPosition`` -- deferred by chunk 33 to this
+    module (see chunk 33's Resolution notes and this module's docstring).
+    Root solving delegates to
+    :func:`math_tools.functional.roots.solve_cubic` (otg.md: "the OTG
+    chunks MUST NOT reimplement root solving")."""
+    t_cum = 0.0
+    for i in range(7):
+        if profile.t[i] == 0.0:
+            continue
+
+        if abs(profile.p[i] - pt) < _ULP and t_cum >= time_after:
+            return True, t_cum
+
+        for root in solve_cubic(
+            profile.j[i] / 6, profile.a[i] / 2, profile.v[i], profile.p[i] - pt
+        ):
+            if 0 < root and time_after - t_cum <= root <= profile.t[i]:
+                return True, root + t_cum
+
+        t_cum += profile.t[i]
+
+    if (
+        (profile.t[6] > 0.0 or profile.t_sum[-1] == 0.0)
+        and abs(profile.pf - pt) < 1e-9
+        and profile.t_sum[-1] >= time_after
+    ):
+        return True, profile.t_sum[-1]
+
+    return False, 0.0
diff --git a/src/math_tools/precision_time/__init__.py b/src/math_tools/precision_time/__init__.py
new file mode 100644
index 0000000..40cb564
--- /dev/null
+++ b/src/math_tools/precision_time/__init__.py
@@ -0,0 +1,9 @@
+"""Precision time math types: attosecond-exact intervals and timestamps.
+
+See ``.claude/specs/precisionTimeMath.md``.
+"""
+
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.precision_time.precision_timestamp import PrecisionTimestamp
+
+__all__ = ["PrecisionTimeInterval", "PrecisionTimestamp"]
diff --git a/src/math_tools/precision_time/precision_time_interval.py b/src/math_tools/precision_time/precision_time_interval.py
new file mode 100644
index 0000000..9c3cbe5
--- /dev/null
+++ b/src/math_tools/precision_time/precision_time_interval.py
@@ -0,0 +1,272 @@
+"""Attosecond-exact time interval, the Tier-3 subclass of
+``PrecisionTimeIntervalABC``.
+
+See ``.claude/specs/precisionTimeMath.md`` (§Representation,
+§PrecisionTimeInterval). Storage is a single signed Python ``int`` of total
+attoseconds (exact, unbounded); the ABC's ``(seconds, attoseconds, sign)``
+triple is derived on access. Unlike the Swift source, there is no
+saturating/wrapping arithmetic — Python ints are unbounded and exact
+(mathToolsArchitecture.md non-goal 3).
+"""
+
+from __future__ import annotations
+
+import math
+from fractions import Fraction
+from typing import Any, ClassVar, overload
+
+from foundation_abc.math.mathEnums import NumericSign
+from foundation_abc.math.precisionTimeABC import (
+    ATTOSECONDS_PER_SECOND,
+    PrecisionTimeIntervalABC,
+)
+
+
+class PrecisionTimeInterval(PrecisionTimeIntervalABC):
+    """An immutable, hashable, attosecond-exact time interval.
+
+    Internally stored as a single signed total-attosecond ``int``; every
+    arithmetic operation returns a new instance. Foreign operand types raise
+    ``TypeError`` (via ``NotImplemented`` and Python's fallback protocol).
+    """
+
+    __slots__ = ("_total_atto",)
+
+    ZERO: ClassVar[PrecisionTimeInterval]
+    ONE_SECOND: ClassVar[PrecisionTimeInterval]
+    ONE_DECISECOND: ClassVar[PrecisionTimeInterval]
+    ONE_MILLISECOND: ClassVar[PrecisionTimeInterval]
+    ONE_MICROSECOND: ClassVar[PrecisionTimeInterval]
+
+    # MARK: - Construction
+
+    def __init__(
+        self,
+        seconds: int = 0,
+        attoseconds: int = 0,
+        sign: NumericSign = NumericSign.POSITIVE,
+    ) -> None:
+        """Construct from an unsigned ``(seconds, attoseconds)`` magnitude and sign.
+
+        Attosecond overflow (``attoseconds >= ATTOSECONDS_PER_SECOND``)
+        carries into seconds. The resulting sign is always derived from the
+        normalized magnitude: zero magnitude is always ``NumericSign.ZERO``
+        regardless of the ``sign`` argument (single source of truth — the
+        stored total is the only state).
+
+        Raises:
+            ValueError: If ``seconds`` or ``attoseconds`` is negative (both
+                are unsigned magnitude components).
+        """
+        if seconds < 0:
+            raise ValueError(f"seconds must be a non-negative magnitude, got {seconds}")
+        if attoseconds < 0:
+            raise ValueError(f"attoseconds must be a non-negative magnitude, got {attoseconds}")
+        carry_seconds, normalized_attoseconds = divmod(attoseconds, ATTOSECONDS_PER_SECOND)
+        magnitude = (seconds + carry_seconds) * ATTOSECONDS_PER_SECOND + normalized_attoseconds
+        self._total_atto = -magnitude if sign == NumericSign.NEGATIVE else magnitude
+
+    @classmethod
+    def from_seconds(cls, seconds: float | int) -> PrecisionTimeInterval:
+        """Construct from a (possibly fractional) number of seconds.
+
+        The float path converts via an exact ``Fraction`` of the float64
+        value, then rounds to the nearest attosecond — no more precision is
+        lost than is already inherent in the float64 representation.
+        """
+        if isinstance(seconds, int):
+            return cls.from_attoseconds(seconds * ATTOSECONDS_PER_SECOND)
+        if not math.isfinite(seconds):
+            raise ValueError(f"seconds must be finite, got {seconds}")
+        total_attoseconds = round(Fraction(seconds) * ATTOSECONDS_PER_SECOND)
+        return cls.from_attoseconds(total_attoseconds)
+
+    @classmethod
+    def from_attoseconds(cls, total: int) -> PrecisionTimeInterval:
+        """Construct from a signed total-attosecond count."""
+        if total == 0:
+            return cls(seconds=0, attoseconds=0, sign=NumericSign.ZERO)
+        sign = NumericSign.POSITIVE if total > 0 else NumericSign.NEGATIVE
+        seconds, attoseconds = divmod(abs(total), ATTOSECONDS_PER_SECOND)
+        return cls(seconds=seconds, attoseconds=attoseconds, sign=sign)
+
+    @classmethod
+    def from_string(cls, seconds: str, fractional: str) -> PrecisionTimeInterval:
+        """Lossless decimal-string constructor.
+
+        ``fractional`` is right-padded to 18 digits (attosecond precision).
+
+        Raises:
+            ValueError: If ``fractional`` has more than 18 digits, or either
+                string is non-numeric.
+        """
+        seconds_text = seconds.strip()
+        is_negative = seconds_text.startswith("-")
+        if is_negative:
+            seconds_text = seconds_text[1:]
+        if not seconds_text.isdigit():
+            raise ValueError(f"invalid seconds string: {seconds!r}")
+
+        fractional_text = fractional.strip()
+        if fractional_text and not fractional_text.isdigit():
+            raise ValueError(f"invalid fractional string: {fractional!r}")
+        if len(fractional_text) > 18:
+            raise ValueError(
+                f"fractional string exceeds attosecond precision (18 digits): {fractional!r}"
+            )
+        padded_fractional = fractional_text.ljust(18, "0")
+
+        seconds_value = int(seconds_text)
+        attoseconds_value = int(padded_fractional)
+        sign = (
+            NumericSign.NEGATIVE
+            if is_negative and (seconds_value or attoseconds_value)
+            else NumericSign.POSITIVE
+        )
+        return cls(seconds=seconds_value, attoseconds=attoseconds_value, sign=sign)
+
+    @classmethod
+    def from_dict(cls, obj: Any) -> PrecisionTimeInterval:
+        """Construct from the ABC wire shape ``{"seconds", "attoseconds", "sign"}``."""
+        if not isinstance(obj, dict):
+            raise TypeError(f"expected a dict, got {type(obj).__name__}")
+        sign_value = obj["sign"]
+        sign = NumericSign(sign_value) if isinstance(sign_value, str) else sign_value
+        if not isinstance(sign, NumericSign):
+            raise TypeError(f"expected a NumericSign or str, got {type(sign_value).__name__}")
+        return cls(
+            seconds=int(obj["seconds"]),
+            attoseconds=int(obj["attoseconds"]),
+            sign=sign,
+        )
+
+    # MARK: - Properties (ABC-required)
+
+    @property
+    def seconds(self) -> int:
+        return abs(self._total_atto) // ATTOSECONDS_PER_SECOND
+
+    @property
+    def attoseconds(self) -> int:
+        return abs(self._total_atto) % ATTOSECONDS_PER_SECOND
+
+    @property
+    def sign(self) -> NumericSign:
+        if self._total_atto == 0:
+            return NumericSign.ZERO
+        return NumericSign.POSITIVE if self._total_atto > 0 else NumericSign.NEGATIVE
+
+    # MARK: - Accessors (beyond the ABC)
+
+    @property
+    def total_attoseconds(self) -> int:
+        """The signed total-attosecond count (the type's canonical storage)."""
+        return self._total_atto
+
+    @property
+    def seconds_as_float(self) -> float:
+        """This interval's duration in seconds, as a (lossy) float."""
+        return self._total_atto / ATTOSECONDS_PER_SECOND
+
+    # MARK: - Arithmetic
+
+    def __add__(self, other: PrecisionTimeInterval) -> PrecisionTimeInterval:
+        if not isinstance(other, PrecisionTimeInterval):
+            return NotImplemented
+        return PrecisionTimeInterval.from_attoseconds(self._total_atto + other._total_atto)
+
+    def __sub__(self, other: PrecisionTimeInterval) -> PrecisionTimeInterval:
+        if not isinstance(other, PrecisionTimeInterval):
+            return NotImplemented
+        return PrecisionTimeInterval.from_attoseconds(self._total_atto - other._total_atto)
+
+    def __neg__(self) -> PrecisionTimeInterval:
+        return PrecisionTimeInterval.from_attoseconds(-self._total_atto)
+
+    def __pos__(self) -> PrecisionTimeInterval:
+        return PrecisionTimeInterval.from_attoseconds(self._total_atto)
+
+    def __abs__(self) -> PrecisionTimeInterval:
+        return PrecisionTimeInterval.from_attoseconds(abs(self._total_atto))
+
+    def __mul__(self, other: int | float) -> PrecisionTimeInterval:
+        if isinstance(other, int):
+            return PrecisionTimeInterval.from_attoseconds(self._total_atto * other)
+        if isinstance(other, float):
+            product = Fraction(self._total_atto) * Fraction(other)
+            return PrecisionTimeInterval.from_attoseconds(round(product))
+        return NotImplemented
+
+    def __rmul__(self, other: int | float) -> PrecisionTimeInterval:
+        return self.__mul__(other)
+
+    @overload
+    def __truediv__(self, other: PrecisionTimeInterval) -> float: ...
+    @overload
+    def __truediv__(self, other: int | float) -> PrecisionTimeInterval: ...
+
+    def __truediv__(
+        self, other: PrecisionTimeInterval | int | float
+    ) -> PrecisionTimeInterval | float:
+        if isinstance(other, PrecisionTimeInterval):
+            if other._total_atto == 0:
+                raise ZeroDivisionError("division by a zero-length PrecisionTimeInterval")
+            return self._total_atto / other._total_atto
+        if isinstance(other, (int, float)):
+            if other == 0:
+                raise ZeroDivisionError("division by zero")
+            quotient = Fraction(self._total_atto) / Fraction(other)
+            return PrecisionTimeInterval.from_attoseconds(round(quotient))
+        return NotImplemented
+
+    # MARK: - Comparison
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, PrecisionTimeInterval):
+            return NotImplemented
+        return self._total_atto == other._total_atto
+
+    def __lt__(self, other: PrecisionTimeInterval) -> bool:
+        if not isinstance(other, PrecisionTimeInterval):
+            return NotImplemented
+        return self._total_atto < other._total_atto
+
+    def __le__(self, other: PrecisionTimeInterval) -> bool:
+        if not isinstance(other, PrecisionTimeInterval):
+            return NotImplemented
+        return self._total_atto <= other._total_atto
+
+    def __gt__(self, other: PrecisionTimeInterval) -> bool:
+        if not isinstance(other, PrecisionTimeInterval):
+            return NotImplemented
+        return self._total_atto > other._total_atto
+
+    def __ge__(self, other: PrecisionTimeInterval) -> bool:
+        if not isinstance(other, PrecisionTimeInterval):
+            return NotImplemented
+        return self._total_atto >= other._total_atto
+
+    def __hash__(self) -> int:
+        return hash(self._total_atto)
+
+    def __bool__(self) -> bool:
+        return not self.is_zero
+
+    def __repr__(self) -> str:
+        return (
+            f"{type(self).__name__}(seconds={self.seconds}, "
+            f"attoseconds={self.attoseconds}, sign={self.sign.name})"
+        )
+
+
+PrecisionTimeInterval.ZERO = PrecisionTimeInterval()
+PrecisionTimeInterval.ONE_SECOND = PrecisionTimeInterval(seconds=1)
+PrecisionTimeInterval.ONE_DECISECOND = PrecisionTimeInterval(
+    attoseconds=ATTOSECONDS_PER_SECOND // 10
+)
+PrecisionTimeInterval.ONE_MILLISECOND = PrecisionTimeInterval(
+    attoseconds=ATTOSECONDS_PER_SECOND // 1_000
+)
+PrecisionTimeInterval.ONE_MICROSECOND = PrecisionTimeInterval(
+    attoseconds=ATTOSECONDS_PER_SECOND // 1_000_000
+)
diff --git a/src/math_tools/precision_time/precision_timestamp.py b/src/math_tools/precision_time/precision_timestamp.py
new file mode 100644
index 0000000..edbd18a
--- /dev/null
+++ b/src/math_tools/precision_time/precision_timestamp.py
@@ -0,0 +1,413 @@
+"""Attosecond-exact, epoch-referenced timestamp, the Tier-3 subclass of
+``PrecisionTimestampABC``.
+
+See ``.claude/specs/precisionTimeMath.md`` (§PrecisionTimestamp). Storage is a
+``PrecisionTimeInterval`` offset from the Unix epoch (1970-01-01 00:00:00 UTC)
+plus optional ``timescale``/``reference_frame``/``uncertainty`` metadata, which
+is carried (never interpreted) and included in equality/hash.
+"""
+
+from __future__ import annotations
+
+import datetime
+from fractions import Fraction
+from typing import Any, ClassVar, overload
+
+from foundation_abc.math.mathEnums import NumericSign, ReferenceFrame, Timescale
+from foundation_abc.math.precisionTimeABC import (
+    ATTOSECONDS_PER_SECOND,
+    PrecisionTimestampABC,
+)
+
+from math_tools.errors import TimestampComparisonError
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+
+_SECONDS_PER_DAY = 86_400
+_ATTOSECONDS_PER_MICROSECOND = ATTOSECONDS_PER_SECOND // 1_000_000
+_UNIX_EPOCH_UTC = datetime.datetime(1970, 1, 1, tzinfo=datetime.timezone.utc)
+
+
+class PrecisionTimestamp(PrecisionTimestampABC):
+    """An immutable, hashable, attosecond-exact point in time.
+
+    Represented internally as a signed ``PrecisionTimeInterval`` offset from
+    the Unix epoch, plus optional metadata. Every operation returns a new
+    instance; foreign operand types raise ``TypeError`` (via ``NotImplemented``
+    and Python's fallback protocol).
+    """
+
+    __slots__ = ("_interval", "_timescale", "_reference_frame", "_uncertainty")
+
+    EPOCH: ClassVar[PrecisionTimestamp]
+
+    # MARK: - Construction
+
+    def __init__(
+        self,
+        seconds: int = 0,
+        attoseconds: int = 0,
+        sign: NumericSign = NumericSign.POSITIVE,
+        *,
+        timescale: Timescale | None = None,
+        reference_frame: ReferenceFrame | None = None,
+        uncertainty: int | None = None,
+    ) -> None:
+        """Construct from an unsigned ``(seconds, attoseconds)`` magnitude and
+        sign, offset from the Unix epoch, plus optional metadata.
+
+        Raises:
+            ValueError: If ``seconds``/``attoseconds`` is negative (see
+                ``PrecisionTimeInterval``), or ``uncertainty`` is negative.
+        """
+        if uncertainty is not None and uncertainty < 0:
+            raise ValueError(f"uncertainty must be a non-negative magnitude, got {uncertainty}")
+        self._interval = PrecisionTimeInterval(seconds=seconds, attoseconds=attoseconds, sign=sign)
+        self._timescale = timescale
+        self._reference_frame = reference_frame
+        self._uncertainty = uncertainty
+
+    @classmethod
+    def from_interval(
+        cls,
+        interval: PrecisionTimeInterval,
+        *,
+        timescale: Timescale | None = None,
+        reference_frame: ReferenceFrame | None = None,
+        uncertainty: int | None = None,
+    ) -> PrecisionTimestamp:
+        """Construct from a ``PrecisionTimeInterval`` offset from the epoch."""
+        return cls(
+            seconds=interval.seconds,
+            attoseconds=interval.attoseconds,
+            sign=interval.sign,
+            timescale=timescale,
+            reference_frame=reference_frame,
+            uncertainty=uncertainty,
+        )
+
+    @classmethod
+    def from_datetime(
+        cls,
+        dt: datetime.datetime,
+        *,
+        timescale: Timescale | None = None,
+        reference_frame: ReferenceFrame | None = None,
+        uncertainty: int | None = None,
+    ) -> PrecisionTimestamp:
+        """Construct from a timezone-aware ``datetime`` (pre-epoch supported).
+
+        Converts to UTC and computes the exact integer microsecond offset from
+        the Unix epoch (``datetime`` subtraction is exact; no float involved).
+
+        Raises:
+            ValueError: If ``dt`` is naive (no timezone).
+        """
+        if dt.tzinfo is None or dt.utcoffset() is None:
+            raise ValueError("from_datetime requires a timezone-aware datetime")
+        dt_utc = dt.astimezone(datetime.timezone.utc)
+        delta = dt_utc - _UNIX_EPOCH_UTC
+        total_microseconds = (
+            delta.days * _SECONDS_PER_DAY * 1_000_000
+            + delta.seconds * 1_000_000
+            + delta.microseconds
+        )
+        total_attoseconds = total_microseconds * _ATTOSECONDS_PER_MICROSECOND
+        interval = PrecisionTimeInterval.from_attoseconds(total_attoseconds)
+        return cls.from_interval(
+            interval,
+            timescale=timescale,
+            reference_frame=reference_frame,
+            uncertainty=uncertainty,
+        )
+
+    @classmethod
+    def now(
+        cls,
+        *,
+        timescale: Timescale | None = None,
+        reference_frame: ReferenceFrame | None = None,
+        uncertainty: int | None = None,
+    ) -> PrecisionTimestamp:
+        """Construct from the current wall-clock time (UTC)."""
+        return cls.from_datetime(
+            datetime.datetime.now(datetime.timezone.utc),
+            timescale=timescale,
+            reference_frame=reference_frame,
+            uncertainty=uncertainty,
+        )
+
+    @classmethod
+    def from_days(
+        cls,
+        days_since_epoch: int,
+        attoseconds_of_day: int = 0,
+        sign: NumericSign = NumericSign.POSITIVE,
+        *,
+        timescale: Timescale | None = None,
+        reference_frame: ReferenceFrame | None = None,
+        uncertainty: int | None = None,
+    ) -> PrecisionTimestamp:
+        """Construct from a whole-day count plus an attosecond offset within
+        that day.
+
+        Raises:
+            ValueError: If ``days_since_epoch`` or ``attoseconds_of_day`` is
+                negative (both are unsigned magnitude components).
+        """
+        if days_since_epoch < 0:
+            raise ValueError(
+                f"days_since_epoch must be a non-negative magnitude, got {days_since_epoch}"
+            )
+        if attoseconds_of_day < 0:
+            raise ValueError(
+                f"attoseconds_of_day must be a non-negative magnitude, got {attoseconds_of_day}"
+            )
+        carry_seconds, remaining_attoseconds = divmod(attoseconds_of_day, ATTOSECONDS_PER_SECOND)
+        total_seconds = days_since_epoch * _SECONDS_PER_DAY + carry_seconds
+        return cls(
+            seconds=total_seconds,
+            attoseconds=remaining_attoseconds,
+            sign=sign,
+            timescale=timescale,
+            reference_frame=reference_frame,
+            uncertainty=uncertainty,
+        )
+
+    @classmethod
+    def from_dict(cls, obj: Any) -> PrecisionTimestamp:
+        """Construct from the ABC wire shape (camelCase optional keys)."""
+        if not isinstance(obj, dict):
+            raise TypeError(f"expected a dict, got {type(obj).__name__}")
+        sign_value = obj["sign"]
+        sign = NumericSign(sign_value) if isinstance(sign_value, str) else sign_value
+        if not isinstance(sign, NumericSign):
+            raise TypeError(f"expected a NumericSign or str, got {type(sign_value).__name__}")
+
+        reference_frame_value = obj.get("referenceFrame")
+        reference_frame: ReferenceFrame | None = None
+        if reference_frame_value is not None:
+            reference_frame = (
+                ReferenceFrame(reference_frame_value)
+                if isinstance(reference_frame_value, str)
+                else reference_frame_value
+            )
+
+        timescale_value = obj.get("timescale")
+        timescale: Timescale | None = None
+        if timescale_value is not None:
+            timescale = (
+                Timescale(timescale_value) if isinstance(timescale_value, str) else timescale_value
+            )
+
+        uncertainty_value = obj.get("uncertainty")
+        uncertainty = int(uncertainty_value) if uncertainty_value is not None else None
+
+        return cls(
+            seconds=int(obj["seconds"]),
+            attoseconds=int(obj["attoseconds"]),
+            sign=sign,
+            timescale=timescale,
+            reference_frame=reference_frame,
+            uncertainty=uncertainty,
+        )
+
+    # MARK: - Properties (ABC-required)
+
+    @property
+    def seconds(self) -> int:
+        return self._interval.seconds
+
+    @property
+    def attoseconds(self) -> int:
+        return self._interval.attoseconds
+
+    @property
+    def sign(self) -> NumericSign:
+        return self._interval.sign
+
+    @property
+    def timescale(self) -> Timescale | None:
+        return self._timescale
+
+    @property
+    def reference_frame(self) -> ReferenceFrame | None:
+        return self._reference_frame
+
+    @property
+    def uncertainty(self) -> int | None:
+        return self._uncertainty
+
+    # MARK: - Accessors (beyond the ABC)
+
+    @property
+    def interval(self) -> PrecisionTimeInterval:
+        """This timestamp's signed offset from the Unix epoch."""
+        return self._interval
+
+    @property
+    def days_since_epoch(self) -> int:
+        """Whole days since the Unix epoch (signed; negative before
+        1970-01-01)."""
+        total_seconds = self._interval.total_attoseconds // ATTOSECONDS_PER_SECOND
+        return total_seconds // _SECONDS_PER_DAY
+
+    @property
+    def seconds_of_day(self) -> int:
+        """Wall-clock second within the UTC day, always in ``[0, 86_400)``
+        regardless of sign."""
+        total_seconds = self._interval.total_attoseconds // ATTOSECONDS_PER_SECOND
+        return total_seconds % _SECONDS_PER_DAY
+
+    @property
+    def as_datetime(self) -> datetime.datetime:
+        """This timestamp as a UTC ``datetime``, lossy to microseconds.
+
+        Rounds to the nearest microsecond (half-to-even, matching the
+        interval's scalar-rounding convention) when the underlying offset
+        isn't already microsecond-aligned.
+        """
+        microseconds_total = round(
+            Fraction(self._interval.total_attoseconds, _ATTOSECONDS_PER_MICROSECOND)
+        )
+        return _UNIX_EPOCH_UTC + datetime.timedelta(microseconds=microseconds_total)
+
+    # MARK: - Arithmetic
+
+    def __add__(self, other: PrecisionTimeInterval) -> PrecisionTimestamp:
+        if not isinstance(other, PrecisionTimeInterval):
+            return NotImplemented
+        return PrecisionTimestamp.from_interval(
+            self._interval + other,
+            timescale=self._timescale,
+            reference_frame=self._reference_frame,
+            uncertainty=self._uncertainty,
+        )
+
+    def __radd__(self, other: PrecisionTimeInterval) -> PrecisionTimestamp:
+        return self.__add__(other)
+
+    @overload
+    def __sub__(self, other: PrecisionTimestamp) -> PrecisionTimeInterval: ...
+    @overload
+    def __sub__(self, other: PrecisionTimeInterval) -> PrecisionTimestamp: ...
+
+    def __sub__(
+        self, other: PrecisionTimestamp | PrecisionTimeInterval
+    ) -> PrecisionTimeInterval | PrecisionTimestamp:
+        if isinstance(other, PrecisionTimestamp):
+            return self._interval - other._interval
+        if isinstance(other, PrecisionTimeInterval):
+            return PrecisionTimestamp.from_interval(
+                self._interval - other,
+                timescale=self._timescale,
+                reference_frame=self._reference_frame,
+                uncertainty=self._uncertainty,
+            )
+        return NotImplemented
+
+    # MARK: - Comparison
+
+    def __eq__(self, other: object) -> bool:
+        if not isinstance(other, PrecisionTimestamp):
+            return NotImplemented
+        return (
+            self._interval == other._interval
+            and self._timescale == other._timescale
+            and self._reference_frame == other._reference_frame
+            and self._uncertainty == other._uncertainty
+        )
+
+    def __lt__(self, other: PrecisionTimestamp) -> bool:
+        if not isinstance(other, PrecisionTimestamp):
+            return NotImplemented
+        return self._interval < other._interval
+
+    def __le__(self, other: PrecisionTimestamp) -> bool:
+        if not isinstance(other, PrecisionTimestamp):
+            return NotImplemented
+        return self._interval <= other._interval
+
+    def __gt__(self, other: PrecisionTimestamp) -> bool:
+        if not isinstance(other, PrecisionTimestamp):
+            return NotImplemented
+        return self._interval > other._interval
+
+    def __ge__(self, other: PrecisionTimestamp) -> bool:
+        if not isinstance(other, PrecisionTimestamp):
+            return NotImplemented
+        return self._interval >= other._interval
+
+    def __hash__(self) -> int:
+        return hash((self._interval, self._timescale, self._reference_frame, self._uncertainty))
+
+    def can_compare(self, other: PrecisionTimestamp) -> bool:
+        """Whether ``self`` and ``other`` are safe to compare.
+
+        ``False`` only when both sides specify a ``timescale`` and they
+        differ, or both specify a ``reference_frame`` and they differ. A
+        ``None`` on either side is compatible with anything. Uncertainty is
+        NOT part of this check (Swift parity: ``canCompare(to:)``).
+        """
+        if (
+            self._timescale is not None
+            and other._timescale is not None
+            and self._timescale != other._timescale
+        ):
+            return False
+        if (
+            self._reference_frame is not None
+            and other._reference_frame is not None
+            and self._reference_frame != other._reference_frame
+        ):
+            return False
+        return True
+
+    def compare_validated(self, other: PrecisionTimestamp) -> int:
+        """Validated three-way comparison: -1/0/1.
+
+        Raises:
+            TimestampComparisonError: If both sides specify differing
+                timescales, both specify differing reference frames, or both
+                carry ``uncertainty`` and the absolute offset difference is
+                less than or equal to the sum of the two uncertainties
+                (overlap; boundary equality raises).
+        """
+        if (
+            self._timescale is not None
+            and other._timescale is not None
+            and self._timescale != other._timescale
+        ):
+            raise TimestampComparisonError(
+                f"incompatible timescale: {self._timescale} vs {other._timescale}"
+            )
+        if (
+            self._reference_frame is not None
+            and other._reference_frame is not None
+            and self._reference_frame != other._reference_frame
+        ):
+            raise TimestampComparisonError(
+                f"incompatible reference frame: {self._reference_frame} vs {other._reference_frame}"
+            )
+        if self._uncertainty is not None and other._uncertainty is not None:
+            delta = abs(self._interval - other._interval)
+            combined = PrecisionTimeInterval.from_attoseconds(
+                self._uncertainty
+            ) + PrecisionTimeInterval.from_attoseconds(other._uncertainty)
+            if delta <= combined:
+                raise TimestampComparisonError("overlapping uncertainty windows")
+
+        if self._interval < other._interval:
+            return -1
+        if self._interval > other._interval:
+            return 1
+        return 0
+
+    def __repr__(self) -> str:
+        return (
+            f"{type(self).__name__}(seconds={self.seconds}, attoseconds={self.attoseconds}, "
+            f"sign={self.sign.name}, timescale={self._timescale}, "
+            f"reference_frame={self._reference_frame}, uncertainty={self._uncertainty})"
+        )
+
+
+PrecisionTimestamp.EPOCH = PrecisionTimestamp()
diff --git a/src/pyMathToolsPlotHelpers/__init__.py b/src/math_tools/precision_time/py.typed
similarity index 100%
rename from src/pyMathToolsPlotHelpers/__init__.py
rename to src/math_tools/precision_time/py.typed
diff --git a/src/math_tools/py.typed b/src/math_tools/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/src/math_tools/spatial/__init__.py b/src/math_tools/spatial/__init__.py
new file mode 100644
index 0000000..183e2c9
--- /dev/null
+++ b/src/math_tools/spatial/__init__.py
@@ -0,0 +1,11 @@
+"""Spatial SE(3) math types: :class:`Position`, :class:`Quaternion`, and
+:class:`SpatialPose`.
+
+See ``.claude/specs/spatialMath.md``.
+"""
+
+from math_tools.spatial.position import Position
+from math_tools.spatial.quaternion import Quaternion
+from math_tools.spatial.spatial_pose import SpatialPose
+
+__all__ = ["Position", "Quaternion", "SpatialPose"]
diff --git a/src/math_tools/spatial/position.py b/src/math_tools/spatial/position.py
new file mode 100644
index 0000000..eb1d934
--- /dev/null
+++ b/src/math_tools/spatial/position.py
@@ -0,0 +1,392 @@
+"""3D Cartesian position, the numpy-backed Tier-3 subclass of ``PositionABC``.
+
+See ``.claude/specs/spatialMath.md`` (§Position, §Coordinate conventions).
+Storage is a private ``(3,)`` float64 ndarray; ``x``/``y``/``z`` are settable
+properties indexing into it (mutable, matching the incumbent
+``Quaternion`` idiom).
+
+Two spherical conventions are supported and are NOT interchangeable:
+
+- ``spherical`` (geographic): ``elevation`` measured from the xy-plane, range
+  ``[-pi/2, pi/2]``.
+- ``spherical_iso`` (ISO 80000-2 physics/colatitude): ``polar`` measured from
+  +z, range ``[0, pi]`` — the same convention documented in
+  ``math_tools.spherical.spherical_generators``.
+"""
+
+from __future__ import annotations
+
+from typing import Any, NamedTuple, TypeVar
+
+import numpy as np
+import numpy.typing as npt
+from foundation_abc.math.spatialABCs import PositionABC
+
+from math_tools.hints import FloatArray3
+
+T = TypeVar("T", bound="Position")
+
+
+class CylindricalCoordinates(NamedTuple):
+    """Inverse accessor for :attr:`Position.cylindrical`."""
+
+    radius: float
+    angle: float
+    height: float
+
+
+class SphericalCoordinates(NamedTuple):
+    """Inverse accessor for :attr:`Position.spherical` (geographic convention)."""
+
+    radius: float
+    azimuth: float
+    elevation: float
+
+
+class SphericalIsoCoordinates(NamedTuple):
+    """Inverse accessor for :attr:`Position.spherical_iso` (ISO 80000-2 convention)."""
+
+    radius: float
+    azimuth: float
+    polar: float
+
+
+def _from_float(x: Any) -> float:
+    assert isinstance(x, (float, int)) and not isinstance(x, bool)
+    return float(x)
+
+
+class Position(PositionABC):
+    """A mutable 3D Cartesian position (the translation component of SE(3))."""
+
+    __slots__ = ("_vector",)
+
+    # MARK: - Constructors
+
+    def __init__(self, x: float = 0.0, y: float = 0.0, z: float = 0.0) -> None:
+        self._vector: FloatArray3 = np.array([x, y, z], dtype=np.float64)
+
+    @classmethod
+    def from_vector(cls: type[T], v: npt.ArrayLike) -> T:
+        """Create a position from an array-like ``[x, y, z]``.
+
+        Args:
+            v: Array-like coercible to a ``(3,)`` float array. The input is
+                copied, never aliased.
+
+        Raises:
+            ValueError: If ``v`` does not coerce to shape ``(3,)``.
+        """
+        arr = np.asarray(v, dtype=np.float64)
+        if arr.shape != (3,):
+            raise ValueError(f"Position.from_vector requires shape (3,), got {arr.shape}")
+        return cls(float(arr[0]), float(arr[1]), float(arr[2]))
+
+    @classmethod
+    def from_components(cls: type[T], x: float = 0.0, y: float = 0.0, z: float = 0.0) -> T:
+        """Create a position from individual x, y, z components."""
+        return cls(x, y, z)
+
+    @classmethod
+    def from_cylindrical(cls: type[T], radius: float, angle: float, height: float) -> T:
+        """Create a position from cylindrical coordinates (radius, angle, height)."""
+        x = radius * np.cos(angle)
+        y = radius * np.sin(angle)
+        return cls(float(x), float(y), float(height))
+
+    @classmethod
+    def from_spherical(cls: type[T], radius: float, azimuth: float, elevation: float) -> T:
+        """Create a position from spherical coordinates (geographic convention).
+
+        Args:
+            radius: Radial distance from the origin.
+            azimuth: Angle in the xy-plane from +x, in radians.
+            elevation: Angle from the xy-plane (equator), in radians;
+                range ``[-pi/2, pi/2]``.
+        """
+        radius_xy = radius * np.cos(elevation)
+        x = radius_xy * np.cos(azimuth)
+        y = radius_xy * np.sin(azimuth)
+        z = radius * np.sin(elevation)
+        return cls(float(x), float(y), float(z))
+
+    @classmethod
+    def from_spherical_iso(cls: type[T], radius: float, azimuth: float, polar: float) -> T:
+        """Create a position from spherical coordinates (ISO 80000-2 convention).
+
+        Args:
+            radius: Radial distance from the origin.
+            azimuth: Angle in the xy-plane from +x, in radians.
+            polar: Angle from +z (colatitude), in radians; range ``[0, pi]``.
+        """
+        radius_xy = radius * np.sin(polar)
+        x = radius_xy * np.cos(azimuth)
+        y = radius_xy * np.sin(azimuth)
+        z = radius * np.cos(polar)
+        return cls(float(x), float(y), float(z))
+
+    @classmethod
+    def origin(cls: type[T]) -> T:
+        """The origin position ``(0, 0, 0)``."""
+        return cls(0.0, 0.0, 0.0)
+
+    @classmethod
+    def unit_x(cls: type[T]) -> T:
+        """Unit position along the x-axis ``(1, 0, 0)``."""
+        return cls(1.0, 0.0, 0.0)
+
+    @classmethod
+    def unit_y(cls: type[T]) -> T:
+        """Unit position along the y-axis ``(0, 1, 0)``."""
+        return cls(0.0, 1.0, 0.0)
+
+    @classmethod
+    def unit_z(cls: type[T]) -> T:
+        """Unit position along the z-axis ``(0, 0, 1)``."""
+        return cls(0.0, 0.0, 1.0)
+
+    @classmethod
+    def from_dict(cls: type[T], obj: Any) -> T:
+        """Create a position instance from a ``{"x", "y", "z"}`` dict."""
+        assert isinstance(obj, dict)
+        x = _from_float(obj.get("x"))
+        y = _from_float(obj.get("y"))
+        z = _from_float(obj.get("z"))
+        return cls(x, y, z)
+
+    # MARK: - Properties
+
+    @property
+    def x(self) -> float:
+        return float(self._vector[0])
+
+    @x.setter
+    def x(self, value: float) -> None:
+        self._vector[0] = value
+
+    @property
+    def y(self) -> float:
+        return float(self._vector[1])
+
+    @y.setter
+    def y(self, value: float) -> None:
+        self._vector[1] = value
+
+    @property
+    def z(self) -> float:
+        return float(self._vector[2])
+
+    @z.setter
+    def z(self, value: float) -> None:
+        self._vector[2] = value
+
+    @property
+    def vector(self) -> FloatArray3:
+        """The ``(3,)`` float64 vector, copied out."""
+        return np.array(self._vector, dtype=np.float64)
+
+    @property
+    def components(self) -> list[float]:
+        """The ``[x, y, z]`` components as a plain list."""
+        return [self.x, self.y, self.z]
+
+    @property
+    def cylindrical(self) -> CylindricalCoordinates:
+        """Cylindrical coordinates ``(radius, angle, height)``."""
+        radius = float(np.hypot(self.x, self.y))
+        angle = float(np.arctan2(self.y, self.x))
+        return CylindricalCoordinates(radius=radius, angle=angle, height=self.z)
+
+    @property
+    def spherical(self) -> SphericalCoordinates:
+        """Spherical coordinates ``(radius, azimuth, elevation)`` (geographic convention)."""
+        radius = self.magnitude
+        azimuth = float(np.arctan2(self.y, self.x))
+        elevation = float(np.arcsin(self.z / radius)) if radius > 0.0 else 0.0
+        return SphericalCoordinates(radius=radius, azimuth=azimuth, elevation=elevation)
+
+    @property
+    def spherical_iso(self) -> SphericalIsoCoordinates:
+        """Spherical coordinates ``(radius, azimuth, polar)`` (ISO 80000-2 convention)."""
+        radius = self.magnitude
+        azimuth = float(np.arctan2(self.y, self.x))
+        polar = float(np.arccos(np.clip(self.z / radius, -1.0, 1.0))) if radius > 0.0 else 0.0
+        return SphericalIsoCoordinates(radius=radius, azimuth=azimuth, polar=polar)
+
+    @property
+    def magnitude_squared(self) -> float:
+        """The squared magnitude (length) of the position vector."""
+        return float(np.dot(self._vector, self._vector))
+
+    @property
+    def magnitude(self) -> float:
+        """The magnitude (length) of the position vector."""
+        return float(np.sqrt(self.magnitude_squared))
+
+    @property
+    def norm(self) -> float:
+        """Alias of :attr:`magnitude` (parity with ``Quaternion.norm``)."""
+        return self.magnitude
+
+    @property
+    def is_unit(self) -> bool:
+        """Whether this is (approximately) a unit vector."""
+        return bool(np.isclose(self.magnitude, 1.0, rtol=0.0, atol=1e-12))
+
+    def __abs__(self) -> float:
+        """Return the magnitude of the position vector."""
+        return self.magnitude
+
+    # MARK: - Arithmetic Operators
+
+    def __add__(self, other: Position | float) -> Position:
+        """Add another position (vector addition) or a scalar (broadcast)."""
+        if isinstance(other, Position):
+            return Position.from_vector(self._vector + other._vector)
+        elif isinstance(other, (float, int)) and not isinstance(other, bool):
+            return Position.from_vector(self._vector + other)
+        return NotImplemented
+
+    def __radd__(self, other: float) -> Position:
+        """Right addition (scalar + position)."""
+        return self.__add__(other)
+
+    def __sub__(self, other: Position | float) -> Position:
+        """Subtract another position (vector subtraction) or a scalar (broadcast)."""
+        if isinstance(other, Position):
+            return Position.from_vector(self._vector - other._vector)
+        elif isinstance(other, (float, int)) and not isinstance(other, bool):
+            return Position.from_vector(self._vector - other)
+        return NotImplemented
+
+    def __rsub__(self, other: float) -> Position:
+        """Right subtraction (scalar - position, component-wise)."""
+        if isinstance(other, (float, int)) and not isinstance(other, bool):
+            return Position.from_vector(other - self._vector)
+        return NotImplemented
+
+    def __mul__(self, other: float) -> Position:
+        """Scale this position by a scalar."""
+        if isinstance(other, (float, int)) and not isinstance(other, bool):
+            return Position.from_vector(self._vector * other)
+        return NotImplemented
+
+    def __rmul__(self, other: float) -> Position:
+        """Right multiplication (scalar * position)."""
+        return self.__mul__(other)
+
+    def __truediv__(self, other: float) -> Position:
+        """Divide this position by a scalar."""
+        if isinstance(other, (float, int)) and not isinstance(other, bool):
+            return Position.from_vector(self._vector / other)
+        return NotImplemented
+
+    def __iadd__(self, other: Position | float) -> Position:
+        """In-place addition."""
+        if isinstance(other, Position):
+            self._vector += other._vector
+            return self
+        elif isinstance(other, (float, int)) and not isinstance(other, bool):
+            self._vector += other
+            return self
+        return NotImplemented
+
+    def __isub__(self, other: Position | float) -> Position:
+        """In-place subtraction."""
+        if isinstance(other, Position):
+            self._vector -= other._vector
+            return self
+        elif isinstance(other, (float, int)) and not isinstance(other, bool):
+            self._vector -= other
+            return self
+        return NotImplemented
+
+    def __imul__(self, other: float) -> Position:
+        """In-place scaling."""
+        if isinstance(other, (float, int)) and not isinstance(other, bool):
+            self._vector *= other
+            return self
+        return NotImplemented
+
+    def __itruediv__(self, other: float) -> Position:
+        """In-place division."""
+        if isinstance(other, (float, int)) and not isinstance(other, bool):
+            self._vector /= other
+            return self
+        return NotImplemented
+
+    def __neg__(self) -> Position:
+        """Negate the position (flip direction)."""
+        return Position.from_vector(-self._vector)
+
+    def __pos__(self) -> Position:
+        """Unary positive (returns a copy)."""
+        return Position.from_vector(self._vector)
+
+    # MARK: - Vector Operations
+
+    def dot(self, other: Position) -> float:
+        """Compute the dot product with another position."""
+        return float(np.dot(self._vector, other._vector))
+
+    def cross(self, other: Position) -> Position:
+        """Compute the cross product with another position (right-hand rule)."""
+        return Position.from_vector(np.cross(self._vector, other._vector))
+
+    def distance(self, to: Position) -> float:
+        """Compute the Euclidean distance to another position."""
+        return float(np.linalg.norm(self._vector - to._vector))
+
+    def distance_squared(self, to: Position) -> float:
+        """Compute the squared Euclidean distance to another position."""
+        diff = self._vector - to._vector
+        return float(np.dot(diff, diff))
+
+    # MARK: - Normalization
+
+    def normalize(self) -> None:
+        """Normalize this position to unit length, in place.
+
+        Raises:
+            ValueError: If this position is the zero vector.
+        """
+        magnitude = self.magnitude
+        if magnitude == 0.0:
+            raise ValueError("cannot normalize a zero-magnitude position")
+        self._vector /= magnitude
+
+    def normalized(self) -> Position:
+        """Return a normalized (unit) copy of this position.
+
+        Raises:
+            ValueError: If this position is the zero vector.
+        """
+        result = Position.from_vector(self._vector)
+        result.normalize()
+        return result
+
+    # MARK: - Comparison
+
+    def __eq__(self, other: object) -> bool:
+        """Check exact equality with another position."""
+        if isinstance(other, Position):
+            return bool(np.array_equal(self._vector, other._vector))
+        return False
+
+    def isclose(self, other: Position, rtol: float = 1e-9, atol: float = 0.0) -> bool:
+        """Check approximate equality with another position."""
+        return bool(np.allclose(self._vector, other._vector, rtol=rtol, atol=atol))
+
+    __hash__ = None  # type: ignore[assignment]
+
+    def __repr__(self) -> str:
+        """Return a detailed string representation."""
+        return f"Position(x={self.x}, y={self.y}, z={self.z})"
+
+    # MARK: - Array Conversion
+
+    def __array__(
+        self, dtype: npt.DTypeLike | None = None, copy: bool | None = None
+    ) -> FloatArray3:
+        """Return the ``(3,)`` vector for ``np.asarray(position)`` interop."""
+        return np.array(self._vector, dtype=dtype, copy=True)
diff --git a/src/math_tools/spatial/py.typed b/src/math_tools/spatial/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/src/pyMathTools/spatial/Quaternion.py b/src/math_tools/spatial/quaternion.py
similarity index 82%
rename from src/pyMathTools/spatial/Quaternion.py
rename to src/math_tools/spatial/quaternion.py
index 966ee3c..870ac4b 100644
--- a/src/pyMathTools/spatial/Quaternion.py
+++ b/src/math_tools/spatial/quaternion.py
@@ -3,39 +3,43 @@
 """
 
 from __future__ import annotations
+
 from dataclasses import dataclass
-from typing import TypeVar, Type, Any
-import numpy as np
-from foundationTypes.mathTypes.QuaternionType import QuaternionType
+from typing import Any, TypeVar
 
-# Import all necessary functions from quaternion module
+import numpy as np
+import numpy.typing as npt
+from foundation_abc.math.spatialABCs import QuaternionABC
+from foundationTypes.mathTypes.MathTypes import UnitSphericalSmallCircleType
+from quaternion import allclose as quat_allclose  # type: ignore[import-untyped]
 from quaternion import (
+    as_euler_angles,
     as_float_array,
     as_quat_array,
-    from_float_array,
     as_rotation_matrix,
-    from_rotation_matrix,
     as_rotation_vector,
-    from_rotation_vector,
-    as_euler_angles,
-    from_euler_angles,
     as_vector_part,
+    from_euler_angles,
+    from_float_array,
+    from_rotation_matrix,
+    from_rotation_vector,
     from_vector_part,
     rotate_vectors,
+)
+from quaternion import (
     isclose as quat_isclose,
-    allclose as quat_allclose,
 )
-from quaternion.quaternion_time_series import slerp as quat_slerp
+from quaternion import quaternion as np_quaternion
+from quaternion.quaternion_time_series import slerp as quat_slerp  # type: ignore[import-untyped]
 
 # Import custom type hints
-from pyMathTools.hints import (
+from math_tools.hints import (
     FloatArray3,
     FloatArray4,
-    RotationMatrix,
     FloatOrQuaternion,
+    RotationMatrix,
 )
-from foundationTypes.mathTypes.UnitSphericalSmallCircle import UnitSphericalSmallCircle
-
+from math_tools.spatial.position import Position
 
 T = TypeVar("T", bound="Quaternion")
 
@@ -45,24 +49,44 @@ def from_float(x: Any) -> float:
     return float(x)
 
 
+@dataclass(frozen=True)
+class RotationMatrixElements:
+    """The nine elements of a 3x3 rotation matrix, named by row/column.
+
+    Derived from :meth:`Quaternion.to_rotation_matrix` (single source of
+    truth: this dataclass never re-derives the matrix from components).
+    """
+
+    xx: float
+    xy: float
+    xz: float
+    yx: float
+    yy: float
+    yz: float
+    zx: float
+    zy: float
+    zz: float
+
+
 @dataclass
-class Quaternion(QuaternionType):
+class Quaternion(QuaternionABC):
     """
     wrapper class for numpy-quaternion for allowing
     """
 
-    __q: np.quaternion
+    __q: np_quaternion
 
     # MARK: - Constructors
 
     @staticmethod
-    def fromNumpyQuaternion(q: np.quaternion) -> "Quaternion":
+    def fromNumpyQuaternion(q: np_quaternion) -> Quaternion:
+        """Deprecated spelling: use :meth:`from_numpy_quaternion` instead."""
         return Quaternion(q)
 
+    from_numpy_quaternion = fromNumpyQuaternion
+
     @classmethod
-    def from_components(
-        cls: Type[T], w: float = 1, x: float = 0, y: float = 0, z: float = 0
-    ) -> T:
+    def from_components(cls: type[T], w: float = 1, x: float = 0, y: float = 0, z: float = 0) -> T:
         """Create a quaternion instance from individual w, x, y, z components.
 
         Args:
@@ -74,10 +98,10 @@ def from_components(
         Returns:
             A concrete QuaternionType instance of the calling class type
         """
-        return cls(np.quaternion(w, x, y, z))
+        return cls(np_quaternion(w, x, y, z))
 
     @classmethod
-    def from_float_array(cls: Type[T], array: FloatArray4) -> T:
+    def from_float_array(cls: type[T], array: FloatArray4) -> T:
         """Create a quaternion from a 4-element float array [w, x, y, z].
 
         Args:
@@ -120,28 +144,28 @@ def as_quat_array(array: np.ndarray) -> np.ndarray:
             >>> Quaternion.as_quat_array([[1,0,0,0], [0.707,0,0,0.707]])
             array([quaternion(1, 0, 0, 0), quaternion(0.707, 0, 0, 0.707)])
         """
-        return as_quat_array(array)
+        return np.asarray(as_quat_array(array))
 
     # MARK: - Properties
 
     @property
     def w(self) -> float:
-        return self.__q.w
+        return float(self.__q.w)
 
     @property
     def x(self) -> float:
-        return self.__q.x
+        return float(self.__q.x)
 
     @property
     def y(self) -> float:
-        return self.__q.y
+        return float(self.__q.y)
 
     @property
     def z(self) -> float:
-        return self.__q.z
+        return float(self.__q.z)
 
     @property
-    def q(self) -> np.quaternion:
+    def q(self) -> np_quaternion:
         return self.__q
 
     # MARK: - Arithmetic Operators
@@ -152,7 +176,7 @@ def __add__(self, other: FloatOrQuaternion) -> Quaternion:
             return Quaternion(self.__q + other.q)
         elif isinstance(other, (float, int)):
             return Quaternion(self.__q + other)
-        elif isinstance(other, np.quaternion):
+        elif isinstance(other, np_quaternion):
             return Quaternion(self.__q + other)
         return NotImplemented
 
@@ -166,7 +190,7 @@ def __sub__(self, other: FloatOrQuaternion) -> Quaternion:
             return Quaternion(self.__q - other.q)
         elif isinstance(other, (float, int)):
             return Quaternion(self.__q - other)
-        elif isinstance(other, np.quaternion):
+        elif isinstance(other, np_quaternion):
             return Quaternion(self.__q - other)
         return NotImplemented
 
@@ -174,7 +198,7 @@ def __rsub__(self, other: FloatOrQuaternion) -> Quaternion:
         """Right subtraction."""
         if isinstance(other, (float, int)):
             return Quaternion(other - self.__q)
-        elif isinstance(other, np.quaternion):
+        elif isinstance(other, np_quaternion):
             return Quaternion(other - self.__q)
         return NotImplemented
 
@@ -184,7 +208,7 @@ def __mul__(self, other: FloatOrQuaternion) -> Quaternion:
             return Quaternion(self.__q * other.q)
         elif isinstance(other, (float, int)):
             return Quaternion(self.__q * other)
-        elif isinstance(other, np.quaternion):
+        elif isinstance(other, np_quaternion):
             return Quaternion(self.__q * other)
         return NotImplemented
 
@@ -198,7 +222,7 @@ def __truediv__(self, other: FloatOrQuaternion) -> Quaternion:
             return Quaternion(self.__q / other.q)
         elif isinstance(other, (float, int)):
             return Quaternion(self.__q / other)
-        elif isinstance(other, np.quaternion):
+        elif isinstance(other, np_quaternion):
             return Quaternion(self.__q / other)
         return NotImplemented
 
@@ -206,7 +230,7 @@ def __rtruediv__(self, other: FloatOrQuaternion) -> Quaternion:
         """Right division."""
         if isinstance(other, (float, int)):
             return Quaternion(other / self.__q)
-        elif isinstance(other, np.quaternion):
+        elif isinstance(other, np_quaternion):
             return Quaternion(other / self.__q)
         return NotImplemented
 
@@ -232,7 +256,7 @@ def __eq__(self, other: object) -> bool:
         """Check equality with another quaternion."""
         if isinstance(other, Quaternion):
             return bool(self.__q == other.q)
-        elif isinstance(other, np.quaternion):
+        elif isinstance(other, np_quaternion):
             return bool(self.__q == other)
         return False
 
@@ -240,6 +264,8 @@ def __ne__(self, other: object) -> bool:
         """Check inequality with another quaternion."""
         return not self.__eq__(other)
 
+    __hash__ = None  # type: ignore[assignment]
+
     def __repr__(self) -> str:
         """Return a detailed string representation."""
         return f"Quaternion(w={self.w}, x={self.x}, y={self.y}, z={self.z})"
@@ -275,6 +301,14 @@ def norm(self) -> float:
         """Return the norm (magnitude) of the quaternion."""
         return float(abs(self.__q))
 
+    def dot(self, other: Quaternion) -> float:
+        """Return the 4-component dot product with another quaternion.
+
+        ``q.dot(q) == q.norm ** 2``; orthogonal (perpendicular) quaternions
+        dot to zero.
+        """
+        return float(self.w * other.w + self.x * other.x + self.y * other.y + self.z * other.z)
+
     @property
     def is_unit(self) -> bool:
         """Check if this is a unit quaternion (norm approximately 1)."""
@@ -295,11 +329,13 @@ def axis(self) -> FloatArray3:
         norm = np.linalg.norm(vect)
         if norm < 1e-10:
             return np.array([0.0, 0.0, 1.0])  # Default axis for identity
-        return vect / norm
+        return np.asarray(vect / norm, dtype=np.float64)
 
     @property
     def vector_spherical(self) -> tuple[float, float]:
-        """Return the quaternion's pointing direction in spherical coordinates (ISO physics convention).
+        """
+        Return the quaternion's pointing direction in spherical coordinates
+        (ISO physics convention).
 
         The quaternion is applied to a reference direction (+X axis) to get the
         pointing direction, which is then converted to spherical coordinates.
@@ -367,12 +403,16 @@ def as_float_array(self) -> FloatArray4:
         This function is fast because no data is copied; the returned
         quantity is just a "view" of the original.
         """
-        return as_float_array(self.__q)
+        return np.asarray(as_float_array(self.__q), dtype=np.float64)
 
     def to_components(self) -> tuple[float, float, float, float]:
         """Return quaternion components as a tuple (w, x, y, z)."""
         return (self.w, self.x, self.y, self.z)
 
+    def __array__(self, dtype: npt.DTypeLike | None = None) -> FloatArray4:
+        """Return the ``[w, x, y, z]`` array for ``np.asarray(quaternion)`` interop."""
+        return np.array([self.w, self.x, self.y, self.z], dtype=dtype or np.float64)
+
     # MARK: - Rotation Matrix Conversions
 
     def to_rotation_matrix(self) -> RotationMatrix:
@@ -388,10 +428,30 @@ def to_rotation_matrix(self) -> RotationMatrix:
         Raises:
             ZeroDivisionError: If this quaternion has zero norm
         """
-        return as_rotation_matrix(self.__q)
+        return np.asarray(as_rotation_matrix(self.__q), dtype=np.float64)
+
+    @property
+    def rotation_matrix_elements(self) -> RotationMatrixElements:
+        """The rotation matrix's nine elements, named by row/column.
+
+        Delegates to :meth:`to_rotation_matrix` (single source of truth) and
+        repackages its entries into a :class:`RotationMatrixElements`.
+        """
+        matrix = self.to_rotation_matrix()
+        return RotationMatrixElements(
+            xx=float(matrix[0, 0]),
+            xy=float(matrix[0, 1]),
+            xz=float(matrix[0, 2]),
+            yx=float(matrix[1, 0]),
+            yy=float(matrix[1, 1]),
+            yz=float(matrix[1, 2]),
+            zx=float(matrix[2, 0]),
+            zy=float(matrix[2, 1]),
+            zz=float(matrix[2, 2]),
+        )
 
     @classmethod
-    def from_rotation_matrix(cls: Type[T], matrix: RotationMatrix) -> T:
+    def from_rotation_matrix(cls: type[T], matrix: RotationMatrix) -> T:
         """Create a quaternion from a 3x3 rotation matrix.
 
         Args:
@@ -419,10 +479,10 @@ def to_rotation_vector(self) -> FloatArray3:
         Returns:
             3-element array representing axis-angle rotation
         """
-        return as_rotation_vector(self.__q)
+        return np.asarray(as_rotation_vector(self.__q), dtype=np.float64)
 
     @classmethod
-    def from_rotation_vector(cls: Type[T], rotation_vector: FloatArray3) -> T:
+    def from_rotation_vector(cls: type[T], rotation_vector: FloatArray3) -> T:
         """Create a quaternion from axis-angle representation.
 
         Args:
@@ -450,11 +510,11 @@ def to_euler_angles(self) -> FloatArray3:
         Returns:
             Array of (alpha, beta, gamma) in radians
         """
-        return as_euler_angles(self.__q)
+        return np.asarray(as_euler_angles(self.__q), dtype=np.float64)
 
     @classmethod
     def from_euler_angles(
-        cls: Type[T],
+        cls: type[T],
         alpha: float,
         beta: float,
         gamma: float,
@@ -481,7 +541,7 @@ def from_euler_angles(
     # MARK: - Vector Part Operations
 
     @classmethod
-    def from_vector_part(cls: Type[T], vector: FloatArray3) -> T:
+    def from_vector_part(cls: type[T], vector: FloatArray3) -> T:
         """Create a quaternion from a 3D vector (pure quaternion).
 
         This creates a quaternion with w=0 and vector part equal to the input.
@@ -501,7 +561,7 @@ def to_vector_part(self) -> FloatArray3:
         Returns:
             3-element array [x, y, z]
         """
-        return as_vector_part(self.__q)
+        return np.asarray(as_vector_part(self.__q), dtype=np.float64)
 
     def rotate_vector(self, vector: FloatArray3) -> FloatArray3:
         """Rotate a 3D vector by this quaternion.
@@ -515,7 +575,16 @@ def rotate_vector(self, vector: FloatArray3) -> FloatArray3:
         Returns:
             Rotated 3-element vector
         """
-        return rotate_vectors(self.__q, vector)
+        return np.asarray(rotate_vectors(self.__q, vector), dtype=np.float64)
+
+    def rotate_position(self, p: Position) -> Position:
+        """Rotate a :class:`Position` by this quaternion.
+
+        Thin wrapper over :meth:`rotate_vector`, typed for ``Position``.
+        Not exposed as ``q * p`` (the existing ``*`` operator is reserved
+        for quaternion-quaternion/scalar multiplication).
+        """
+        return Position.from_vector(self.rotate_vector(p.vector))
 
     # MARK: - Interpolation Methods
 
@@ -593,7 +662,7 @@ def allclose(
     # MARK: - Special Constructors
 
     @classmethod
-    def identity(cls: Type[T]) -> T:
+    def identity(cls: type[T]) -> T:
         """Create an identity quaternion (no rotation).
 
         Returns:
@@ -602,7 +671,7 @@ def identity(cls: Type[T]) -> T:
         return cls.from_components(w=1.0, x=0.0, y=0.0, z=0.0)
 
     @classmethod
-    def from_axis_angle(cls: Type[T], axis: FloatArray3, angle: float) -> T:
+    def from_axis_angle(cls: type[T], axis: FloatArray3, angle: float) -> T:
         """Create a quaternion from a rotation axis and angle.
 
         Args:
@@ -624,7 +693,7 @@ def from_axis_angle(cls: Type[T], axis: FloatArray3, angle: float) -> T:
 
     @classmethod
     def _from_unit_direction_to_vector(
-        cls: Type[T],
+        cls: type[T],
         start_direction: FloatArray3,
         target_vector: FloatArray3,
         perpendicular_axis: FloatArray3,
@@ -673,7 +742,7 @@ def _from_unit_direction_to_vector(
         return cls.from_axis_angle(axis, angle)
 
     @classmethod
-    def from_unit_x_to_vector(cls: Type[T], target_vector: FloatArray3) -> T:
+    def from_unit_x_to_vector(cls: type[T], target_vector: FloatArray3) -> T:
         """Create a quaternion that rotates the +X axis to point toward target_vector.
 
         This constructor computes the rotation that transforms the unit X direction
@@ -701,7 +770,7 @@ def from_unit_x_to_vector(cls: Type[T], target_vector: FloatArray3) -> T:
         return cls._from_unit_direction_to_vector(start, target_vector, perpendicular)
 
     @classmethod
-    def from_unit_y_to_vector(cls: Type[T], target_vector: FloatArray3) -> T:
+    def from_unit_y_to_vector(cls: type[T], target_vector: FloatArray3) -> T:
         """Create a quaternion that rotates the +Y axis to point toward target_vector.
 
         This constructor computes the rotation that transforms the unit Y direction
@@ -729,7 +798,7 @@ def from_unit_y_to_vector(cls: Type[T], target_vector: FloatArray3) -> T:
         return cls._from_unit_direction_to_vector(start, target_vector, perpendicular)
 
     @classmethod
-    def from_unit_z_to_vector(cls: Type[T], target_vector: FloatArray3) -> T:
+    def from_unit_z_to_vector(cls: type[T], target_vector: FloatArray3) -> T:
         """Create a quaternion that rotates the +Z axis to point toward target_vector.
 
         This constructor computes the rotation that transforms the unit Z direction
@@ -757,7 +826,7 @@ def from_unit_z_to_vector(cls: Type[T], target_vector: FloatArray3) -> T:
         return cls._from_unit_direction_to_vector(start, target_vector, perpendicular)
 
     @classmethod
-    def from_dict(cls, obj: Any) -> "Quaternion":
+    def from_dict(cls, obj: Any) -> Quaternion:
         """Create a quaternion instance from a dictionary representation.
 
         Args:
@@ -776,7 +845,9 @@ def from_dict(cls, obj: Any) -> "Quaternion":
 
     def to_unitSphericalSmallCircle(
         q: Quaternion, radius_angle: float = np.pi / 4
-    ) -> UnitSphericalSmallCircle:
-        """ """
+    ) -> UnitSphericalSmallCircleType:
+        """Deprecated spelling: use :meth:`to_unit_spherical_small_circle` instead."""
         a, p = q.vector_spherical
-        return UnitSphericalSmallCircle(azimuth=a, polar=p, radius_angle=radius_angle)
+        return UnitSphericalSmallCircleType(azimuth=a, polar=p, radius_angle=radius_angle)
+
+    to_unit_spherical_small_circle = to_unitSphericalSmallCircle
diff --git a/src/math_tools/spatial/spatial_pose.py b/src/math_tools/spatial/spatial_pose.py
new file mode 100644
index 0000000..9babe5e
--- /dev/null
+++ b/src/math_tools/spatial/spatial_pose.py
@@ -0,0 +1,273 @@
+"""``SpatialPose``: the SE(3) pose type composing :class:`Position` and
+:class:`Quaternion`.
+
+See ``.claude/specs/spatialMath.md`` (§SpatialPose, §Compliance 4-8). Storage
+is a composed ``Position`` (translation) + ``Quaternion`` (rotation); the
+ABC's rotation accessor name is ``orientation`` (not Swift's ``quaternion``).
+
+``*`` is the universal robotics "apply" reading: ``pose * pose`` composes two
+transforms, ``pose * position`` applies the full SE(3) transform to a point
+(identical to :meth:`SpatialPose.transform`). Swift's ``pose + position`` /
+``pose - position`` operators are deliberately NOT ported: a bare ``+`` that
+silently drops rotation is a footgun; :meth:`SpatialPose.translated` is the
+explicit, named replacement.
+"""
+
+from __future__ import annotations
+
+from typing import Any, TypeVar, overload
+
+import numpy as np
+import numpy.typing as npt
+from foundation_abc.math.spatialABCs import SpatialTransformABC
+
+from math_tools.spatial.position import Position
+from math_tools.spatial.quaternion import Quaternion
+
+T = TypeVar("T", bound="SpatialPose")
+
+
+class SpatialPose(SpatialTransformABC):
+    """A 6-DOF pose: one element of SE(3), the Lie group of rigid transforms."""
+
+    # MARK: - Constructors
+
+    def __init__(
+        self, position: Position | None = None, orientation: Quaternion | None = None
+    ) -> None:
+        # Position is mutable (settable x/y/z); copy it so this pose's state
+        # cannot be silently changed via a caller's outstanding reference.
+        # Quaternion has no in-place mutators, so aliasing it is safe.
+        self._position = (
+            Position.from_vector(position.vector) if position is not None else Position.origin()
+        )
+        self._orientation = orientation if orientation is not None else Quaternion.identity()
+
+    @classmethod
+    def from_components(
+        cls: type[T],
+        x: float = 0.0,
+        y: float = 0.0,
+        z: float = 0.0,
+        qw: float = 1.0,
+        qx: float = 0.0,
+        qy: float = 0.0,
+        qz: float = 0.0,
+    ) -> T:
+        """Create a pose from individual position and quaternion (w-first) components."""
+        return cls(Position(x, y, z), Quaternion.from_components(qw, qx, qy, qz))
+
+    @classmethod
+    def from_homogeneous(cls: type[T], matrix: npt.ArrayLike) -> T:
+        """Create a pose from a ``(4, 4)`` homogeneous transformation matrix.
+
+        Args:
+            matrix: A ``(4, 4)`` array-like with a rotation submatrix in the
+                top-left 3x3 block, a translation in the top-right column,
+                and a rigid bottom row ``[0, 0, 0, 1]``.
+
+        Raises:
+            ValueError: If ``matrix`` is not ``(4, 4)`` or its bottom row is
+                not (approximately) ``[0, 0, 0, 1]``.
+        """
+        arr = np.asarray(matrix, dtype=np.float64)
+        if arr.shape != (4, 4):
+            raise ValueError(f"SpatialPose.from_homogeneous requires shape (4, 4), got {arr.shape}")
+        bottom_row = arr[3, :]
+        if not np.allclose(bottom_row, [0.0, 0.0, 0.0, 1.0], atol=1e-9):
+            raise ValueError(
+                "SpatialPose.from_homogeneous requires a rigid bottom row "
+                f"[0, 0, 0, 1], got {bottom_row.tolist()}"
+            )
+        orientation = Quaternion.from_rotation_matrix(arr[:3, :3])
+        position = Position.from_vector(arr[:3, 3])
+        return cls(position, orientation)
+
+    @classmethod
+    def from_denavit_hartenberg(cls: type[T], a: float, alpha: float, d: float, theta: float) -> T:
+        """Create a pose from standard Denavit-Hartenberg parameters.
+
+        [See DH Parameters](https://en.wikipedia.org/wiki/Denavit-Hartenberg_parameters)
+
+        Args:
+            a: Link length (distance along x axis).
+            alpha: Link twist (angle in radians around x axis).
+            d: Link offset (distance along z axis).
+            theta: Joint angle (angle in radians around z axis).
+        """
+        ct, st = float(np.cos(theta)), float(np.sin(theta))
+        ca, sa = float(np.cos(alpha)), float(np.sin(alpha))
+        position = Position(a * ct, a * st, d)
+        rotation_matrix = np.array(
+            [
+                [ct, -st * ca, st * sa],
+                [st, ct * ca, -ct * sa],
+                [0.0, sa, ca],
+            ],
+            dtype=np.float64,
+        )
+        orientation = Quaternion.from_rotation_matrix(rotation_matrix)
+        return cls(position, orientation)
+
+    @classmethod
+    def identity(cls: type[T]) -> T:
+        """The identity pose: origin position, identity orientation."""
+        return cls(Position.origin(), Quaternion.identity())
+
+    @classmethod
+    def from_dict(cls: type[T], obj: Any) -> T:
+        """Create a pose from a ``{"position", "orientation"}`` dict."""
+        assert isinstance(obj, dict)
+        position = Position.from_dict(obj.get("position"))
+        orientation = Quaternion.from_dict(obj.get("orientation"))
+        return cls(position, orientation)
+
+    # MARK: - Properties
+
+    @property
+    def position(self) -> Position:
+        return self._position
+
+    @property
+    def orientation(self) -> Quaternion:
+        return self._orientation
+
+    @property
+    def x(self) -> float:
+        return self._position.x
+
+    @property
+    def y(self) -> float:
+        return self._position.y
+
+    @property
+    def z(self) -> float:
+        return self._position.z
+
+    @property
+    def qw(self) -> float:
+        return self._orientation.w
+
+    @property
+    def qx(self) -> float:
+        return self._orientation.x
+
+    @property
+    def qy(self) -> float:
+        return self._orientation.y
+
+    @property
+    def qz(self) -> float:
+        return self._orientation.z
+
+    @property
+    def homogeneous(self) -> npt.NDArray[np.float64]:
+        """The ``(4, 4)`` homogeneous transformation matrix.
+
+        The orientation is normalized before export (Swift parity), even if
+        this pose's stored orientation is not currently a unit quaternion.
+        """
+        orientation = self._orientation.normalized()
+        matrix = np.eye(4, dtype=np.float64)
+        matrix[:3, :3] = orientation.to_rotation_matrix()
+        matrix[:3, 3] = self._position.vector
+        return matrix
+
+    @property
+    def is_unit(self) -> bool:
+        """Whether the orientation component is (approximately) a unit quaternion."""
+        return self._orientation.is_unit
+
+    # MARK: - Operators
+
+    @overload
+    def __mul__(self, other: SpatialPose) -> SpatialPose: ...
+
+    @overload
+    def __mul__(self, other: Position) -> Position: ...
+
+    def __mul__(self, other: SpatialPose | Position) -> SpatialPose | Position:
+        """Apply: ``pose * pose`` composes; ``pose * position`` transforms the point."""
+        if isinstance(other, SpatialPose):
+            return SpatialPose(
+                self._position + self._orientation.rotate_position(other.position),
+                self._orientation * other.orientation,
+            )
+        if isinstance(other, Position):
+            return self.transform(other)
+        return NotImplemented
+
+    def transform(self, p: Position) -> Position:
+        """Apply the full SE(3) transform (rotate then translate) to a position."""
+        return self._orientation.rotate_position(p) + self._position
+
+    def translated(self, by: Position) -> SpatialPose:
+        """Return a copy of this pose shifted by ``by`` (orientation unchanged)."""
+        return SpatialPose(self._position + by, self._orientation)
+
+    def inverse(self) -> SpatialPose:
+        """Return the inverse pose: ``q^-1``, ``-(q^-1.rotate(p))``."""
+        inverse_orientation = self._orientation.inverse()
+        inverse_position = -(inverse_orientation.rotate_position(self._position))
+        return SpatialPose(inverse_position, inverse_orientation)
+
+    def relative_pose(self, to: SpatialPose) -> SpatialPose:
+        """Return the pose that transforms from ``self`` to ``to``."""
+        return self.inverse() * to
+
+    def interpolate(self, to: SpatialPose, t: float) -> SpatialPose:
+        """Interpolate toward ``to``: position lerp + quaternion slerp.
+
+        ``t`` is unclamped: ``t=0`` returns (a copy of) ``self``, ``t=1``
+        returns ``to``, and values outside ``[0, 1]`` extrapolate.
+        """
+        position = self._position + (to.position - self._position) * t
+        orientation = self._orientation.slerp(to.orientation, t)
+        return SpatialPose(position, orientation)
+
+    def position_distance(self, to: SpatialPose) -> float:
+        """The Euclidean distance between this pose's position and ``to``'s."""
+        return self._position.distance(to.position)
+
+    def position_distance_squared(self, to: SpatialPose) -> float:
+        """The squared Euclidean distance between this pose's position and ``to``'s."""
+        return self._position.distance_squared(to.position)
+
+    def angular_distance(self, to: SpatialPose) -> float:
+        """The angular distance (radians) between this pose's orientation and ``to``'s.
+
+        Double-cover safe: uses ``|dot|`` so ``q`` and ``-q`` (the same
+        rotation) yield the same distance.
+        """
+        cos_half_angle = abs(self._orientation.dot(to.orientation))
+        return float(2.0 * np.arccos(np.clip(cos_half_angle, -1.0, 1.0)))
+
+    # MARK: - Normalization
+
+    def normalize(self) -> None:
+        """Normalize the orientation component, in place."""
+        self._orientation = self._orientation.normalized()
+
+    def normalized(self) -> SpatialPose:
+        """Return a copy of this pose with the orientation normalized."""
+        return SpatialPose(self._position, self._orientation.normalized())
+
+    # MARK: - Comparison
+
+    def __eq__(self, other: object) -> bool:
+        """Check exact equality with another pose."""
+        if isinstance(other, SpatialPose):
+            return self._position == other.position and self._orientation == other.orientation
+        return False
+
+    def isclose(self, other: SpatialPose, rtol: float = 1e-9, atol: float = 0.0) -> bool:
+        """Check approximate equality (double-cover aware via ``Quaternion.isclose``)."""
+        return self._position.isclose(
+            other.position, rtol=rtol, atol=atol
+        ) and self._orientation.isclose(other.orientation, rtol=rtol, atol=atol)
+
+    __hash__ = None  # type: ignore[assignment]
+
+    def __repr__(self) -> str:
+        """Return a detailed string representation."""
+        return f"SpatialPose(position={self._position!r}, orientation={self._orientation!r})"
diff --git a/src/math_tools/spherical/__init__.py b/src/math_tools/spherical/__init__.py
new file mode 100644
index 0000000..b9946d9
--- /dev/null
+++ b/src/math_tools/spherical/__init__.py
@@ -0,0 +1,32 @@
+"""``math_tools.spherical``: spherical arc/small-circle utilities.
+
+Curated subpackage re-exports so consumers import
+``from math_tools.spherical import arc_from_two_points`` rather than reaching
+into the individual ``constructors`` / ``spherical_generators`` /
+``spherical_transforms`` modules. See
+``.claude/specs/mathToolsArchitecture.md`` §Shared conventions (Public
+surface). ISO physics spherical convention is documented canonically in
+``spherical_generators``. This module contains re-exports only -- no logic.
+"""
+
+from math_tools.spherical.constructors import arc_from_two_points
+from math_tools.spherical.spherical_generators import (
+    generate_spherical_arc_points,
+    generate_spherical_small_circle_points,
+)
+from math_tools.spherical.spherical_transforms import (
+    cartesian_to_spherical,
+    compute_spherical_arc_endpoint,
+    plate_carree_transform,
+    spherical_to_cartesian,
+)
+
+__all__ = [
+    "arc_from_two_points",
+    "generate_spherical_arc_points",
+    "generate_spherical_small_circle_points",
+    "cartesian_to_spherical",
+    "compute_spherical_arc_endpoint",
+    "plate_carree_transform",
+    "spherical_to_cartesian",
+]
diff --git a/src/pyMathTools/spherical/constructors.py b/src/math_tools/spherical/constructors.py
similarity index 93%
rename from src/pyMathTools/spherical/constructors.py
rename to src/math_tools/spherical/constructors.py
index 2a28fe3..9326ec4 100644
--- a/src/pyMathTools/spherical/constructors.py
+++ b/src/math_tools/spherical/constructors.py
@@ -6,9 +6,9 @@
 """
 
 import numpy as np
-from numpy import atan2, acos, pi
-
-from foundationTypes.mathTypes.UnitSphericalArc import UnitSphericalArc
+from foundation_abc.math.sphericalABCs import UnitSphericalArcABC
+from foundationTypes.mathTypes.MathTypes import UnitSphericalArcType
+from numpy import atan2
 
 
 def arc_from_two_points(
@@ -17,7 +17,7 @@ def arc_from_two_points(
     azimuth2: float,
     polar2: float,
     isPositive: bool = True,
-) -> UnitSphericalArc:
+) -> UnitSphericalArcABC:
     """
     Create a UnitSphericalArc connecting two points on a unit sphere.
 
@@ -89,7 +89,7 @@ def arc_from_two_points(
     if not isPositive:
         arc_length = -arc_length
 
-    return UnitSphericalArc(
+    return UnitSphericalArcType(
         azimuth=azimuth1,
         polar=polar1,
         orient=orient,
diff --git a/src/math_tools/spherical/py.typed b/src/math_tools/spherical/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/src/pyMathTools/spherical/sphericalGenerators.py b/src/math_tools/spherical/spherical_generators.py
similarity index 95%
rename from src/pyMathTools/spherical/sphericalGenerators.py
rename to src/math_tools/spherical/spherical_generators.py
index 6310ba3..acc41e6 100644
--- a/src/pyMathTools/spherical/sphericalGenerators.py
+++ b/src/math_tools/spherical/spherical_generators.py
@@ -36,32 +36,33 @@
   r = sqrt(x² + y² + z²)
 """
 
-from typing import Tuple
+from foundation_abc.math.sphericalABCs import (
+    UnitSphericalArcABC,
+    UnitSphericalSmallCircleABC,
+)
 from numpy import (
-    clip,
-    pi,
+    arccos,
     arctan2,
-    cos,
-    sin,
     array,
+    clip,
+    cos,
     cross,
+    dot,
     linspace,
-    zeros,
+    pi,
+    sin,
     sqrt,
-    arccos,
-    dot,
+    zeros,
 )
 from numpy.linalg import norm
-from foundationTypes.mathTypes.UnitSphericalSmallCircle import UnitSphericalSmallCircle
-from foundationTypes.mathTypes.UnitSphericalArc import UnitSphericalArc
 
-from pyMathTools.hints import FloatNDArray
+from math_tools.hints import FloatNDArray
 
 
 def generate_spherical_small_circle_points(
-    circle: UnitSphericalSmallCircle,
+    circle: UnitSphericalSmallCircleABC,
     num_points: int = 120,
-) -> Tuple[FloatNDArray, FloatNDArray]:
+) -> tuple[FloatNDArray, FloatNDArray]:
     """
     Generate points on a true small circle on a unit sphere.
 
@@ -72,7 +73,7 @@ def generate_spherical_small_circle_points(
 
     Parameters:
     -----------
-    circle : UnitSphericalSmallCircle
+    circle : UnitSphericalSmallCircleABC
         Small circle specification with:
           - azimuth (φ): angle in xy-plane from +x axis [0, 2π)
           - polar (θ): angle from +z axis (colatitude) [0, π]
@@ -156,9 +157,9 @@ def generate_spherical_small_circle_points(
 
 
 def generate_spherical_arc_points(
-    arc: UnitSphericalArc,
+    arc: UnitSphericalArcABC,
     num_points: int = 120,
-) -> Tuple[FloatNDArray, FloatNDArray]:
+) -> tuple[FloatNDArray, FloatNDArray]:
     """
     Generate points along an arc on a unit sphere.
 
@@ -173,7 +174,7 @@ def generate_spherical_arc_points(
 
     Parameters:
     -----------
-    arc : UnitSphericalArc
+    arc : UnitSphericalArcABC
         Arc specification with:
           - azimuth (φ): starting point angle in xy-plane from +x axis [0, 2π)
           - polar (θ): starting point angle from +z axis (colatitude) [0, π]
diff --git a/src/pyMathTools/spherical/sphericalTransforms.py b/src/math_tools/spherical/spherical_transforms.py
similarity index 92%
rename from src/pyMathTools/spherical/sphericalTransforms.py
rename to src/math_tools/spherical/spherical_transforms.py
index b202fbd..2abe5d5 100644
--- a/src/pyMathTools/spherical/sphericalTransforms.py
+++ b/src/math_tools/spherical/spherical_transforms.py
@@ -11,24 +11,23 @@
 - θ (theta/polar): angle from +z axis (colatitude), range [0, π]
 - φ (phi/azimuth): angle in xy-plane from +x axis, range [0, 2π)
 
-See pyMathTools.generators.sphericalGenerators module docstring for complete details.
+See math_tools.spherical.spherical_generators module docstring for complete details.
 """
 
-from typing import Tuple
-from pyMathTools.hints import FloatOrNDArray
-from numpy import float64
-from numpy.typing import NDArray
+from foundation_abc.math.sphericalABCs import UnitSphericalArcABC
 from numpy import (
-    clip,
-    pi,
+    arccos,
     arctan2,
+    clip,
     cos,
+    float64,
+    pi,
     sin,
-    arccos,
 )
 from numpy.linalg import norm
+from numpy.typing import NDArray
 
-from foundationTypes.mathTypes.UnitSphericalArc import UnitSphericalArc
+from math_tools.hints import FloatOrNDArray
 
 
 def plate_carree_transform(
@@ -103,7 +102,7 @@ def spherical_to_cartesian(azimuth: float, polar: float) -> tuple[float, float,
     return (x, y, z)
 
 
-def cartesian_to_spherical(point: NDArray[float64]) -> tuple:
+def cartesian_to_spherical(point: NDArray[float64]) -> tuple[float, float]:
     """
     Convert Cartesian coordinates to spherical coordinates.
 
@@ -130,14 +129,14 @@ def cartesian_to_spherical(point: NDArray[float64]) -> tuple:
 
 
 def compute_spherical_arc_endpoint(
-    arc: UnitSphericalArc,
-) -> Tuple[float, float]:
+    arc: UnitSphericalArcABC,
+) -> tuple[float, float]:
     """
-    Compute the endpoint of a UnitSphericalArc on a unit sphere.
+    Compute the endpoint of a UnitSphericalArcABC on a unit sphere.
 
     Parameters
     ----------
-    arc : UnitSphericalArc
+    arc : UnitSphericalArcABC
         The spherical arc containing:
         - azimuth: Starting azimuth angle in radians (0 to 2π)
         - polar: Starting polar angle in radians (colatitude/zenith angle)
@@ -163,7 +162,7 @@ def compute_spherical_arc_endpoint(
 
     Examples
     --------
-    >>> arc = UnitSphericalArc(
+    >>> arc = UnitSphericalArcABC(
     ...     arc_length=deg2rad(45),
     ...     azimuth=0.0,
     ...     orient=0.0,
diff --git a/src/math_tools/waveforms/__init__.py b/src/math_tools/waveforms/__init__.py
new file mode 100644
index 0000000..244caeb
--- /dev/null
+++ b/src/math_tools/waveforms/__init__.py
@@ -0,0 +1,83 @@
+"""Waveform container types: :class:`Waveform1D` (and, in later chunks, the
+aggregate spatial waveform containers) plus the DSP support descriptor
+types and enums.
+
+See ``.claude/specs/waveformCore.md`` and ``.claude/specs/waveformDsp.md``.
+"""
+
+from math_tools.waveforms.support import (
+    WaveformAlignmentMethod,
+    WaveformEdgeType,
+    WaveformEventMarker,
+    WaveformFilterCoefficients,
+    WaveformFilterType,
+    WaveformFrequencyRange,
+    WaveformInstantaneousFrequency,
+    WaveformInstantaneousMethod,
+    WaveformInterpolationMethod,
+    WaveformMelSpectrogram,
+    WaveformPaddingStrategy,
+    WaveformPeak,
+    WaveformPeakWithProminence,
+    WaveformPSDScaling,
+    WaveformSpectralFeatures,
+    WaveformSpectrogram,
+    WaveformSpectrogramScaling,
+    WaveformSpectrum,
+    WaveformTimeLag,
+    WaveformTrigger,
+    WaveformTriggerEvent,
+    WaveformTriggerType,
+    WaveformWindowTriggerType,
+    WaveformWindowType,
+    WaveformWithEvents,
+    WaveformZeroCrossing,
+    WaveformZeroCrossingDirection,
+)
+from math_tools.waveforms.waveform1d import Waveform1D
+from math_tools.waveforms.waveform_position import PositionComponentWaveforms, WaveformPosition
+from math_tools.waveforms.waveform_quaternion import (
+    QuaternionComponentWaveforms,
+    WaveformQuaternion,
+)
+from math_tools.waveforms.waveform_spatial_pose import (
+    SpatialPoseComponentWaveforms,
+    WaveformSpatialPose,
+)
+
+__all__ = [
+    "PositionComponentWaveforms",
+    "QuaternionComponentWaveforms",
+    "SpatialPoseComponentWaveforms",
+    "Waveform1D",
+    "WaveformPosition",
+    "WaveformQuaternion",
+    "WaveformSpatialPose",
+    "WaveformAlignmentMethod",
+    "WaveformEdgeType",
+    "WaveformEventMarker",
+    "WaveformFilterCoefficients",
+    "WaveformFilterType",
+    "WaveformFrequencyRange",
+    "WaveformInstantaneousFrequency",
+    "WaveformInstantaneousMethod",
+    "WaveformInterpolationMethod",
+    "WaveformMelSpectrogram",
+    "WaveformPaddingStrategy",
+    "WaveformPeak",
+    "WaveformPeakWithProminence",
+    "WaveformPSDScaling",
+    "WaveformSpectralFeatures",
+    "WaveformSpectrogram",
+    "WaveformSpectrogramScaling",
+    "WaveformSpectrum",
+    "WaveformTimeLag",
+    "WaveformTrigger",
+    "WaveformTriggerEvent",
+    "WaveformTriggerType",
+    "WaveformWindowTriggerType",
+    "WaveformWindowType",
+    "WaveformWithEvents",
+    "WaveformZeroCrossing",
+    "WaveformZeroCrossingDirection",
+]
diff --git a/src/math_tools/waveforms/dsp/__init__.py b/src/math_tools/waveforms/dsp/__init__.py
new file mode 100644
index 0000000..823299c
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/__init__.py
@@ -0,0 +1,38 @@
+"""DSP mixin substrate for ``Waveform1D`` (protocol + shared helpers).
+
+See ``.claude/specs/waveformDsp.md``. This package holds the per-family
+mixin modules (chunks 18-30) plus the shared ``WaveformProtocol`` typing
+contract (``_protocol.py``) and cross-mixin helpers (``_common.py``). As of
+chunk 30, all twelve mixins below are composed onto
+``waveforms.waveform1d.Waveform1D`` (see that module's docstring); this
+package still exposes each mixin individually for direct
+mypy-strict-checkable/testable use.
+"""
+
+from math_tools.waveforms.dsp._calc import CalcMixin
+from math_tools.waveforms.dsp._correlation import CorrelationMixin
+from math_tools.waveforms.dsp._envelope import EnvelopeMixin
+from math_tools.waveforms.dsp._filtering import FilteringMixin
+from math_tools.waveforms.dsp._peaks import PeakMixin
+from math_tools.waveforms.dsp._phase import PhaseMixin
+from math_tools.waveforms.dsp._resampling import ResamplingMixin
+from math_tools.waveforms.dsp._spectral import SpectralMixin
+from math_tools.waveforms.dsp._time_alignment import TimeAlignmentMixin
+from math_tools.waveforms.dsp._triggers import TriggerMixin
+from math_tools.waveforms.dsp._windowing import WindowingMixin
+from math_tools.waveforms.dsp._zero_crossings import ZeroCrossingMixin
+
+__all__ = [
+    "CalcMixin",
+    "CorrelationMixin",
+    "EnvelopeMixin",
+    "FilteringMixin",
+    "PeakMixin",
+    "PhaseMixin",
+    "ResamplingMixin",
+    "SpectralMixin",
+    "TimeAlignmentMixin",
+    "TriggerMixin",
+    "WindowingMixin",
+    "ZeroCrossingMixin",
+]
diff --git a/src/math_tools/waveforms/dsp/_calc.py b/src/math_tools/waveforms/dsp/_calc.py
new file mode 100644
index 0000000..8a69bb9
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_calc.py
@@ -0,0 +1,73 @@
+"""``CalcMixin``: numerical integration and differentiation for ``Waveform1D``.
+
+See ``.claude/specs/waveformDsp.md`` §Family contracts (``CalcMixin``),
+§Numerical conventions, §Compliance 1-2. Swift reference:
+``Waveform1D/Extensions/Waveform1D-Calc.swift``.
+
+Both methods scale by ``dt`` in seconds (not raw sample spacing), and both
+raise ``ValueError`` (naming the required minimum length) rather than
+silently returning an empty result when the waveform is too short --
+per waveformDsp.md §Numerical conventions, that empty-result path is
+reserved for the ``detect_*``/``zero_crossings`` detector family, which
+this is not.
+
+Imports only ``scipy``/``numpy`` plus ``dsp/_protocol.py``/``dsp/_common.py``
+(no sibling mixin imports -- waveformDsp.md §Organization / §Compliance 2).
+
+**Not** ``class CalcMixin(WaveformProtocol)``: nominally inheriting the
+``Protocol`` turns its stub property bodies into concrete implementations
+that shadow ``Waveform1D``'s real ones once a test composes
+``class _W(CalcMixin, Waveform1D)`` (C3 puts the inherited stub ahead of
+``Waveform1D`` in the MRO, so ``self.values`` silently returns ``None`` --
+see waveformDsp.md §Organization for the full account). ``CalcMixin`` is a
+plain class instead, typing ``self`` as ``WaveformProtocol`` on each method
+(mypy's "mixin classes" idiom) -- structurally checkable, no runtime base.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+from scipy.integrate import cumulative_trapezoid
+
+from math_tools.waveforms.dsp._common import float_seconds
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+
+
+class CalcMixin:
+    """Adds ``integrate``/``derivative`` to a ``WaveformProtocol``-satisfying host."""
+
+    def integrate(self: WaveformProtocol, initial_value: float = 0.0) -> WaveformProtocol:
+        """Cumulative trapezoidal integral, scaled by ``dt`` seconds.
+
+        The first sample of the result equals ``initial_value``; each
+        subsequent sample adds the trapezoidal area accumulated since the
+        start (``scipy.integrate.cumulative_trapezoid``).
+
+        Raises:
+            ValueError: If the waveform has no samples.
+        """
+        sample_count = self.values.shape[0]
+        if sample_count == 0:
+            raise ValueError("CalcMixin.integrate requires at least 1 sample, got 0")
+        dt_seconds = float_seconds(self.dt)
+        cumulative = cumulative_trapezoid(self.values, dx=dt_seconds, initial=0.0)
+        return self._with_values(cumulative + initial_value)
+
+    def derivative(self: WaveformProtocol) -> WaveformProtocol:
+        """Numerical derivative over the time axis (``np.gradient``, scaled by ``dt`` seconds).
+
+        Raises:
+            ValueError: If the waveform has fewer than 2 samples (``np.gradient``'s
+                minimum for a first-order estimate).
+        """
+        sample_count = self.values.shape[0]
+        if sample_count < 2:
+            raise ValueError(
+                f"CalcMixin.derivative requires at least 2 samples, got {sample_count}"
+            )
+        dt_seconds = float_seconds(self.dt)
+        gradient = np.gradient(self.values, dt_seconds)
+        return self._with_values(gradient)
+
+
+__all__ = ["CalcMixin"]
diff --git a/src/math_tools/waveforms/dsp/_common.py b/src/math_tools/waveforms/dsp/_common.py
new file mode 100644
index 0000000..c70af18
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_common.py
@@ -0,0 +1,32 @@
+"""Small helpers shared by two or more DSP mixins.
+
+See ``.claude/specs/waveformDsp.md`` §Organization ("shared helpers live in
+``dsp/_common.py``"). Starts minimal -- only what chunk 14 itself needs;
+later mixin chunks add to this module rather than duplicating logic or
+importing a sibling mixin.
+"""
+
+from __future__ import annotations
+
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+
+
+def float_seconds(interval: PrecisionTimeInterval) -> float:
+    """``interval`` as float seconds (thin wrapper over ``seconds_as_float``)."""
+    return interval.seconds_as_float
+
+
+# Single source for the Kaiser-window shape parameter used by both
+# ``dsp/_windowing.py`` (user-facing window utilities) and ``dsp/_spectral.py``
+# (internal STFT/PSD window arrays). Before chunk 53 each module hardcoded its
+# own ``14.0`` literal independently -- individually defensible but with no
+# test pinning them equal and no shared source, so the two could silently
+# drift apart. ``WaveformWindowType`` is a flat ``str`` enum with no ``beta``
+# field (unlike the Swift reference's ``.kaiser(beta:)`` associated value),
+# so exposing a caller-supplied beta would force an enum redesign; per
+# waveformDsp.md's window-convention section this chunk keeps the flat enum
+# and records the narrowed capability here rather than reopening the enum
+# shape. 14.0 gives comparable sidelobe suppression to a Blackman window.
+DEFAULT_KAISER_BETA = 14.0
+
+__all__ = ["float_seconds", "DEFAULT_KAISER_BETA"]
diff --git a/src/math_tools/waveforms/dsp/_correlation.py b/src/math_tools/waveforms/dsp/_correlation.py
new file mode 100644
index 0000000..0059551
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_correlation.py
@@ -0,0 +1,221 @@
+"""``CorrelationMixin``: auto/cross-correlation and lag search for ``Waveform1D``.
+
+See ``.claude/specs/waveformDsp.md`` §Family contracts (``CorrelationMixin``),
+§Compliance 1-2. Swift reference:
+``Waveform1D/Extensions/Waveform1D-Correlation.swift``; test ideas:
+``Waveform1DCorrelationTests.swift`` (39 tests -- representative cases ported).
+
+Backing: ``scipy.signal.correlate``/``correlation_lags`` (linear, full-mode
+correlation), per waveformDsp.md's family-contract table. This diverges from
+the Swift extension in two ways the spec explicitly allows ("parity is
+judged per capability, not per Swift overload"):
+
+- ``cross_correlation``/``find_max_correlation`` only ever compute scipy's
+  ``mode="full"``; the Swift ``WaveformCorrelationMode`` (``valid``/``same``)
+  overloads are not ported (YAGNI -- add with a caller that needs them).
+- **Lag sign convention.** ``scipy.signal.correlation_lags`` defines a lag
+  such that ``other`` shifted *right* by ``lag`` samples (conceptually
+  ``other[n - lag]``) aligns with ``self[n]`` at the correlation peak --
+  i.e. ``lag`` is (roughly) "``self``'s feature index minus ``other``'s
+  feature index". Swift's hand-rolled ``findMaxCorrelation`` computes the
+  opposite sign (``actualLag = maxIndex - (other.count - 1)``, "``other``'s
+  index minus ``self``'s"). This module keeps scipy's native sign rather
+  than negating it, since scipy is the backing implementation the spec
+  names: a waveform ``other`` that trails ``self`` by ``k`` samples (i.e.
+  ``other[i] == self[i - k]``) yields ``lag_samples == -k``, not ``+k``.
+
+Both ``auto_correlation`` and ``cross_correlation`` raise ``ValueError`` on
+an empty input waveform (waveformDsp.md §Numerical conventions -- these are
+not in the ``detect_*``/``zero_crossings`` detector family that gets the
+empty-result exemption). ``cross_correlation``/``find_max_correlation`` raise
+``WaveformCompatibilityError`` when ``other.dt`` differs from ``self.dt``
+(the family contract's stated requirement).
+
+Imports only ``scipy``/``numpy`` plus ``dsp/_protocol.py``/``dsp/_common.py``
+and ``waveforms/support.py`` (for the ``WaveformTimeLag`` return type) --
+no sibling mixin imports (waveformDsp.md §Organization / §Compliance 2).
+
+**Not** ``class CorrelationMixin(WaveformProtocol)``: see ``dsp/_calc.py``'s
+module docstring / waveformDsp.md §Organization for the full account of why
+mixins type ``self`` as ``WaveformProtocol`` on each method instead of
+nominally subclassing it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from scipy.signal import correlate, correlation_lags
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.waveforms.dsp._common import float_seconds
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformTimeLag
+
+
+def _demeaned(values: npt.NDArray[Any], normalized: bool) -> npt.NDArray[np.float64]:
+    """``values`` (as ``float64``) minus its mean when ``normalized``, else unchanged."""
+    values_f64 = np.asarray(values, dtype=np.float64)
+    return values_f64 - values_f64.mean() if normalized else values_f64
+
+
+def _unit_normalized(values: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+    """``values`` scaled to unit energy (``sqrt(sum(values ** 2))``); unscaled if that is 0."""
+    norm = float(np.sqrt(np.sum(values * values)))
+    return values / norm if norm > 0.0 else values
+
+
+def _cross_correlation_and_lags(
+    self_values: npt.NDArray[Any], other_values: npt.NDArray[Any], normalized: bool
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.int_]]:
+    """Full-mode cross-correlation of ``self_values``/``other_values`` and its matching lags.
+
+    Shared by ``cross_correlation`` and ``find_max_correlation`` so both stay
+    exactly consistent about lag indexing.
+    """
+    x = _demeaned(self_values, normalized)
+    y = _demeaned(other_values, normalized)
+    if normalized:
+        x = _unit_normalized(x)
+        y = _unit_normalized(y)
+    correlation: npt.NDArray[np.float64] = correlate(x, y, mode="full")
+    lags: npt.NDArray[np.int_] = correlation_lags(x.shape[0], y.shape[0], mode="full")
+    return correlation, lags
+
+
+def _require_compatible_dt(
+    waveform: WaveformProtocol, other: WaveformProtocol, op_name: str
+) -> None:
+    """Raise ``WaveformCompatibilityError`` unless ``other`` shares ``waveform``'s ``dt``."""
+    if waveform.dt != other.dt:
+        raise WaveformCompatibilityError(
+            f"CorrelationMixin.{op_name}: dt mismatch ({waveform.dt!r} vs {other.dt!r})"
+        )
+
+
+def _require_nonempty(waveform: WaveformProtocol, other: WaveformProtocol, op_name: str) -> None:
+    """Raise ``ValueError`` unless both ``waveform`` and ``other`` have at least 1 sample."""
+    self_count = waveform.values.shape[0]
+    other_count = other.values.shape[0]
+    if self_count == 0 or other_count == 0:
+        raise ValueError(
+            f"CorrelationMixin.{op_name} requires both waveforms to have at least 1 sample, "
+            f"got {self_count} and {other_count}"
+        )
+
+
+class CorrelationMixin:
+    """Adds auto/cross-correlation and max-correlation lag search to a ``WaveformProtocol`` host."""
+
+    def auto_correlation(
+        self: WaveformProtocol, max_lag: int | None = None, normalized: bool = True
+    ) -> WaveformProtocol:
+        """One-sided auto-correlation (lags ``0..max_lag``), ``scipy.signal.correlate``-backed.
+
+        ``max_lag`` defaults to ``sample_count // 2`` and is clamped to
+        ``sample_count - 1``. When ``normalized``, lag 0 is ``1.0`` for any
+        signal with nonzero variance; a zero-variance (constant) signal
+        normalizes to ``1.0`` at every lag if the constant is nonzero, else
+        ``0.0`` at every lag (matches the Swift reference's zero-variance
+        special case).
+
+        Raises:
+            ValueError: If the waveform has no samples, or ``max_lag`` is negative.
+        """
+        sample_count = self.values.shape[0]
+        if sample_count == 0:
+            raise ValueError("CorrelationMixin.auto_correlation requires at least 1 sample, got 0")
+        resolved_max_lag = sample_count // 2 if max_lag is None else max_lag
+        if resolved_max_lag < 0:
+            raise ValueError(
+                f"CorrelationMixin.auto_correlation: max_lag must be >= 0, got {resolved_max_lag}"
+            )
+        clamped_max_lag = min(resolved_max_lag, sample_count - 1)
+
+        signal = _demeaned(self.values, normalized)
+        full: npt.NDArray[np.float64] = correlate(signal, signal, mode="full")
+        lags: npt.NDArray[np.int_] = correlation_lags(sample_count, sample_count, mode="full")
+        one_sided = full[lags >= 0][: clamped_max_lag + 1]
+
+        if normalized:
+            zero_lag_energy = float(one_sided[0])
+            if zero_lag_energy > 0.0:
+                one_sided = one_sided / zero_lag_energy
+            else:
+                # Zero-variance (constant) signal: a nonzero constant is fully
+                # self-similar at every lag (1.0); an all-zero signal carries no
+                # correlatable structure (0.0) -- mirrors the Swift reference.
+                fill = 1.0 if float(self.values[0]) != 0.0 else 0.0
+                one_sided = np.full_like(one_sided, fill, dtype=np.float64)
+
+        return self._with_values(one_sided)
+
+    def cross_correlation(
+        self: WaveformProtocol,
+        other: WaveformProtocol,
+        max_lag: int | None = None,
+        normalized: bool = True,
+    ) -> WaveformProtocol:
+        """Full-mode cross-correlation against ``other`` (``scipy.signal.correlate``-backed).
+
+        When ``max_lag`` is given, the result is trimmed to
+        ``abs(lag) <= max_lag`` (see the module docstring for this module's
+        lag sign convention, which is scipy's native one -- opposite of the
+        Swift reference).
+
+        Raises:
+            WaveformCompatibilityError: If ``other.dt`` differs from ``self.dt``.
+            ValueError: If either waveform has no samples, or ``max_lag`` is negative.
+        """
+        _require_compatible_dt(self, other, "cross_correlation")
+        _require_nonempty(self, other, "cross_correlation")
+        if max_lag is not None and max_lag < 0:
+            raise ValueError(
+                f"CorrelationMixin.cross_correlation: max_lag must be >= 0, got {max_lag}"
+            )
+
+        correlation, lags = _cross_correlation_and_lags(self.values, other.values, normalized)
+        if max_lag is not None:
+            correlation = correlation[np.abs(lags) <= max_lag]
+
+        return self._with_values(correlation)
+
+    def find_max_correlation(
+        self: WaveformProtocol, other: WaveformProtocol, max_lag: int | None = None
+    ) -> WaveformTimeLag:
+        """The lag (samples/seconds) and correlation value of the strongest match with ``other``.
+
+        Always normalizes internally (a "strongest match" search is
+        meaningless on raw, unnormalized energy). See the module docstring
+        for the lag sign convention.
+
+        Raises:
+            WaveformCompatibilityError: If ``other.dt`` differs from ``self.dt``.
+            ValueError: If either waveform has no samples, or ``max_lag`` is negative.
+        """
+        _require_compatible_dt(self, other, "find_max_correlation")
+        _require_nonempty(self, other, "find_max_correlation")
+        if max_lag is not None and max_lag < 0:
+            raise ValueError(
+                f"CorrelationMixin.find_max_correlation: max_lag must be >= 0, got {max_lag}"
+            )
+
+        correlation, lags = _cross_correlation_and_lags(self.values, other.values, normalized=True)
+        if max_lag is not None:
+            within_range = np.abs(lags) <= max_lag
+            correlation = correlation[within_range]
+            lags = lags[within_range]
+
+        best_index = int(np.argmax(correlation))
+        lag_samples = int(lags[best_index])
+        lag_seconds = lag_samples * float_seconds(self.dt)
+        return WaveformTimeLag(
+            lag_samples=lag_samples,
+            lag_seconds=lag_seconds,
+            correlation=float(correlation[best_index]),
+        )
+
+
+__all__ = ["CorrelationMixin"]
diff --git a/src/math_tools/waveforms/dsp/_envelope.py b/src/math_tools/waveforms/dsp/_envelope.py
new file mode 100644
index 0000000..de217a1
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_envelope.py
@@ -0,0 +1,170 @@
+"""``EnvelopeMixin``: amplitude envelope / instantaneous amplitude for ``Waveform1D``.
+
+See ``.claude/specs/waveformDsp.md`` §Family contracts (``EnvelopeMixin``),
+§Numerical conventions, §Compliance 1-2. Swift reference:
+``Waveform1D/Extensions/Waveform1D-Envelope.swift``.
+
+Backing: ``scipy.signal.hilbert`` (analytic-signal amplitude),
+``scipy.signal.find_peaks`` + ``np.interp`` (peak/valley envelope
+interpolation), per waveformDsp.md's family-contract table. This diverges
+from the Swift extension's hand-rolled approximations (a fixed-window
+"quadrature filter" standing in for the Hilbert transform, and a
+local-window ``allSatisfy`` extrema search) in favor of the better-tested
+scipy/numpy equivalents -- the spec explicitly allows this ("parity is
+judged per capability, not per Swift overload... scipy semantics win").
+
+``amplitude_envelope``/``upper_lower_envelopes``/``instantaneous_amplitude``
+all raise ``ValueError`` (naming the requirement) on an empty input
+waveform (waveformDsp.md §Numerical conventions -- these are not in the
+``detect_*``/``zero_crossings`` detector family that gets the
+empty-result exemption).
+
+Imports only ``scipy``/``numpy`` plus ``dsp/_protocol.py`` and
+``waveforms/support.py`` (for the ``WaveformInstantaneousMethod`` enum
+argument) -- no sibling mixin imports (waveformDsp.md §Organization /
+§Compliance 2; ``support.py`` is outside ``dsp/`` and is the same import
+``_correlation.py`` (chunk 19) already makes for ``WaveformTimeLag``).
+
+**Not** ``class EnvelopeMixin(WaveformProtocol)``: see ``dsp/_calc.py``'s
+module docstring / waveformDsp.md §Organization for the full account of why
+mixins type ``self`` as ``WaveformProtocol`` on each method instead of
+nominally subclassing it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from scipy.signal import find_peaks, hilbert
+
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformInstantaneousMethod
+
+
+def _hilbert_amplitude(values: npt.NDArray[Any]) -> npt.NDArray[np.float64]:
+    """Analytic-signal magnitude of ``values`` (``scipy.signal.hilbert``-backed)."""
+    analytic = hilbert(np.asarray(values, dtype=np.float64))
+    result: npt.NDArray[np.float64] = np.abs(analytic)
+    return result
+
+
+def _with_boundary_indices(
+    indices: npt.NDArray[Any], sample_count: int
+) -> npt.NDArray[np.intp]:
+    """``indices`` plus the first/last sample index, sorted ascending with duplicates removed.
+
+    Guarantees an envelope interpolation always has at least the two
+    boundary samples as anchors, even when a signal has no interior local
+    extrema (e.g. a monotonic ramp).
+    """
+    combined = np.concatenate(([0], indices, [sample_count - 1]))
+    unique_sorted: npt.NDArray[np.intp] = np.unique(combined).astype(np.intp)
+    return unique_sorted
+
+
+def _peak_envelope(values: npt.NDArray[Any]) -> npt.NDArray[np.float64]:
+    """Envelope through the peaks of ``abs(values)`` (``find_peaks`` + ``np.interp``)."""
+    abs_values = np.abs(np.asarray(values, dtype=np.float64))
+    sample_count = abs_values.shape[0]
+    peak_indices, _ = find_peaks(abs_values)
+    anchor_indices = _with_boundary_indices(peak_indices, sample_count)
+    sample_positions = np.arange(sample_count, dtype=np.float64)
+    result: npt.NDArray[np.float64] = np.interp(
+        sample_positions, anchor_indices, abs_values[anchor_indices]
+    )
+    return result
+
+
+def _windowed_rms(values: npt.NDArray[Any], window_size: int) -> npt.NDArray[np.float64]:
+    """Centered moving-window RMS of ``values`` (edge-padded so the result matches length)."""
+    values_f64 = np.asarray(values, dtype=np.float64)
+    sample_count = values_f64.shape[0]
+    half_window = window_size // 2
+    padded = np.pad(values_f64 * values_f64, (half_window, half_window), mode="edge")
+    kernel = np.ones(window_size, dtype=np.float64) / window_size
+    convolved = np.convolve(padded, kernel, mode="valid")
+    result: npt.NDArray[np.float64] = np.sqrt(convolved[:sample_count])
+    return result
+
+
+class EnvelopeMixin:
+    """Adds amplitude-envelope / instantaneous-amplitude methods to a ``WaveformProtocol`` host."""
+
+    def amplitude_envelope(self: WaveformProtocol) -> WaveformProtocol:
+        """Instantaneous amplitude via the analytic-signal magnitude (``scipy.signal.hilbert``).
+
+        Raises:
+            ValueError: If the waveform has no samples.
+        """
+        sample_count = self.values.shape[0]
+        if sample_count == 0:
+            raise ValueError("EnvelopeMixin.amplitude_envelope requires at least 1 sample, got 0")
+        return self._with_values(_hilbert_amplitude(self.values))
+
+    def upper_lower_envelopes(self: WaveformProtocol) -> tuple[WaveformProtocol, WaveformProtocol]:
+        """Upper/lower envelopes via local-maxima/-minima interpolation.
+
+        Local maxima/minima are found with ``scipy.signal.find_peaks`` (on
+        ``values`` for the upper envelope, on ``-values`` for the lower);
+        the envelope between them is linear (``np.interp``). The first and
+        last samples are always included as anchor points -- even when they
+        are not local extrema -- so a signal with no interior extrema (e.g.
+        a monotonic ramp) still yields an envelope spanning the full
+        waveform instead of a degenerate one.
+
+        Raises:
+            ValueError: If the waveform has no samples.
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        sample_count = values.shape[0]
+        if sample_count == 0:
+            raise ValueError(
+                "EnvelopeMixin.upper_lower_envelopes requires at least 1 sample, got 0"
+            )
+        peak_indices, _ = find_peaks(values)
+        valley_indices, _ = find_peaks(-values)
+        upper_anchors = _with_boundary_indices(peak_indices, sample_count)
+        lower_anchors = _with_boundary_indices(valley_indices, sample_count)
+        sample_positions = np.arange(sample_count, dtype=np.float64)
+        upper = np.interp(sample_positions, upper_anchors, values[upper_anchors])
+        lower = np.interp(sample_positions, lower_anchors, values[lower_anchors])
+        return self._with_values(upper), self._with_values(lower)
+
+    def instantaneous_amplitude(
+        self: WaveformProtocol,
+        method: WaveformInstantaneousMethod = WaveformInstantaneousMethod.HILBERT,
+        window_size: int = 5,
+    ) -> WaveformProtocol:
+        """Instantaneous amplitude estimate, per ``method``.
+
+        - ``HILBERT``: analytic-signal magnitude (same as ``amplitude_envelope``).
+        - ``RMS``: centered moving-window RMS (``window_size`` samples, edge-padded).
+        - ``PEAK``: envelope through the peaks of ``abs(values)`` (``find_peaks`` +
+          ``np.interp``, same construction as ``upper_lower_envelopes``' upper side
+          applied to the rectified signal).
+
+        Raises:
+            ValueError: If the waveform has no samples, or (``RMS``) ``window_size < 1``.
+        """
+        sample_count = self.values.shape[0]
+        if sample_count == 0:
+            raise ValueError(
+                "EnvelopeMixin.instantaneous_amplitude requires at least 1 sample, got 0"
+            )
+        if method is WaveformInstantaneousMethod.HILBERT:
+            return self._with_values(_hilbert_amplitude(self.values))
+        if method is WaveformInstantaneousMethod.RMS:
+            if window_size < 1:
+                raise ValueError(
+                    "EnvelopeMixin.instantaneous_amplitude: window_size must be >= 1, "
+                    f"got {window_size}"
+                )
+            return self._with_values(_windowed_rms(self.values, window_size))
+        if method is WaveformInstantaneousMethod.PEAK:
+            return self._with_values(_peak_envelope(self.values))
+        raise ValueError(f"EnvelopeMixin.instantaneous_amplitude: unsupported method {method!r}")
+
+
+__all__ = ["EnvelopeMixin"]
diff --git a/src/math_tools/waveforms/dsp/_filtering.py b/src/math_tools/waveforms/dsp/_filtering.py
new file mode 100644
index 0000000..110ea8c
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_filtering.py
@@ -0,0 +1,410 @@
+"""``FilteringMixin``: digital filtering (Butterworth, moving-average, EMA,
+Savitzky-Golay, Whittaker-Henderson) plus filter frequency response.
+
+See ``.claude/specs/waveformDsp.md`` §Family contracts (``FilteringMixin``),
+§Numerical conventions, §Compliance 1-2. Swift reference:
+``Waveform1D/Extensions/Waveform1D-Filtering.swift``.
+
+Backing: ``scipy.signal.butter`` (+ ``filtfilt``/``lfilter``) for the
+Butterworth families, ``scipy.signal.savgol_filter`` for Savitzky-Golay,
+``scipy.signal.freqz`` for the frequency-response sampler, and a sparse
+difference-matrix solve (``scipy.sparse`` + ``scipy.sparse.linalg.spsolve``)
+for Whittaker-Henderson, per waveformDsp.md's family-contract table and the
+chunk's own "one clever bit" recipe.
+
+**Zero-phase by default.** The Butterworth designs (``low_pass_filter``,
+``high_pass_filter``, ``band_pass_filter``, and ``filtered``'s BAND_STOP
+branch) filter via ``scipy.signal.filtfilt`` (zero-phase, doubles the
+effective attenuation in dB relative to a single pass) unless the caller
+passes ``causal=True``, in which case a single causal ``scipy.signal.lfilter``
+pass is used instead -- per waveformDsp.md §Numerical conventions.
+
+**Nyquist validation.** Every cutoff/band edge is validated against the
+waveform's Nyquist frequency (``sampling_frequency_hz / 2``) and raises
+``ValueError`` naming the requirement -- the chunk's own acceptance
+criterion -- rather than silently clamping (the Swift reference clamps;
+this Python port does not, consistent with waveformDsp.md §Numerical
+conventions' "raise `ValueError`... never a silent empty/clamped result"
+policy already followed by every other mixin chunk).
+
+**Deviation from the Swift reference's silent-no-op guards.** The Swift
+methods return ``self`` unchanged on invalid parameters (e.g. an
+out-of-range ``windowSize``); this port raises ``ValueError`` instead,
+consistent with every other DSP mixin chunk (waveformDsp.md §Numerical
+conventions) and with scipy's own behavior for the methods that wrap it
+directly (``savgol_filter``, ``filtfilt``) -- "parity is judged per
+capability, not per Swift overload" (waveformDsp.md's opening note).
+
+Imports only ``scipy``/``numpy`` plus ``dsp/_protocol.py``/``dsp/_common.py``
+and ``waveforms/support.py`` (for the enum/descriptor types) -- no sibling
+mixin imports (waveformDsp.md §Organization / §Compliance 2).
+
+**Not** ``class FilteringMixin(WaveformProtocol)``: see ``dsp/_calc.py``'s
+module docstring / waveformDsp.md §Organization for the full account of why
+mixins type ``self`` as ``WaveformProtocol`` on each method instead of
+nominally subclassing it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from scipy import sparse
+from scipy.signal import butter, filtfilt, freqz, lfilter, savgol_filter
+from scipy.sparse.linalg import spsolve
+
+from math_tools.waveforms.dsp._common import float_seconds
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformFilterType, WaveformSpectrum
+
+
+def _validate_order(order: int, op_name: str) -> None:
+    if order < 1:
+        raise ValueError(f"FilteringMixin.{op_name}: order must be >= 1, got {order}")
+
+
+def _validate_cutoff(cutoff_hz: float, nyquist_hz: float, op_name: str) -> None:
+    if not (0.0 < cutoff_hz < nyquist_hz):
+        raise ValueError(
+            f"FilteringMixin.{op_name}: cutoff_hz must be in (0, {nyquist_hz}) Hz "
+            f"(Nyquist), got {cutoff_hz}"
+        )
+
+
+def _validate_band(low_hz: float, high_hz: float, nyquist_hz: float, op_name: str) -> None:
+    if not (0.0 < low_hz < high_hz < nyquist_hz):
+        raise ValueError(
+            f"FilteringMixin.{op_name}: require 0 < low_hz < high_hz < {nyquist_hz} Hz "
+            f"(Nyquist), got low_hz={low_hz}, high_hz={high_hz}"
+        )
+
+
+def _butter_coefficients(
+    filter_type: WaveformFilterType,
+    order: int,
+    fs: float,
+    cutoff_hz: float | None,
+    low_hz: float | None,
+    high_hz: float | None,
+    op_name: str,
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """Design Butterworth coefficients ``(b, a)`` for ``filter_type`` (Nyquist-validated).
+
+    Shared by every Butterworth-backed method (``low_pass_filter``,
+    ``high_pass_filter``, ``band_pass_filter``, ``filtered``,
+    ``frequency_response``) so they stay exactly consistent about validation
+    and design parameters.
+    """
+    _validate_order(order, op_name)
+    nyquist_hz = fs / 2.0
+
+    if filter_type is WaveformFilterType.LOW_PASS:
+        if cutoff_hz is None:
+            raise ValueError(f"FilteringMixin.{op_name}: cutoff_hz is required for LOW_PASS")
+        _validate_cutoff(cutoff_hz, nyquist_hz, op_name)
+        b, a = butter(order, cutoff_hz, btype="low", fs=fs)
+    elif filter_type is WaveformFilterType.HIGH_PASS:
+        if cutoff_hz is None:
+            raise ValueError(f"FilteringMixin.{op_name}: cutoff_hz is required for HIGH_PASS")
+        _validate_cutoff(cutoff_hz, nyquist_hz, op_name)
+        b, a = butter(order, cutoff_hz, btype="high", fs=fs)
+    elif filter_type in (WaveformFilterType.BAND_PASS, WaveformFilterType.BAND_STOP):
+        if low_hz is None or high_hz is None:
+            raise ValueError(
+                f"FilteringMixin.{op_name}: low_hz and high_hz are required for "
+                f"{filter_type.value.upper()}"
+            )
+        _validate_band(low_hz, high_hz, nyquist_hz, op_name)
+        btype = "bandpass" if filter_type is WaveformFilterType.BAND_PASS else "bandstop"
+        b, a = butter(order, [low_hz, high_hz], btype=btype, fs=fs)
+    else:  # pragma: no cover - WaveformFilterType is exhaustive above
+        raise ValueError(f"FilteringMixin.{op_name}: unsupported filter_type {filter_type!r}")
+
+    return np.asarray(b, dtype=np.float64), np.asarray(a, dtype=np.float64)
+
+
+def _apply_iir(
+    values: npt.NDArray[Any],
+    b: npt.NDArray[np.float64],
+    a: npt.NDArray[np.float64],
+    causal: bool,
+) -> npt.NDArray[np.float64]:
+    """Apply ``(b, a)`` to ``values``: zero-phase (``filtfilt``) unless ``causal``."""
+    float_values = np.asarray(values, dtype=np.float64)
+    result = lfilter(b, a, float_values) if causal else filtfilt(b, a, float_values)
+    return np.asarray(result, dtype=np.float64)
+
+
+def _moving_average(
+    values: npt.NDArray[Any], window_size: int, op_name: str
+) -> npt.NDArray[np.float64]:
+    """Centered moving average; the window shrinks (rather than zero-pads) near the
+    edges, so it averages over exactly the samples available at each point."""
+    if window_size < 1:
+        raise ValueError(f"FilteringMixin.{op_name}: window_size must be >= 1, got {window_size}")
+    float_values = np.asarray(values, dtype=np.float64)
+    n = float_values.shape[0]
+    half_window = window_size // 2
+    cumulative = np.concatenate(([0.0], np.cumsum(float_values)))
+    index = np.arange(n)
+    starts = np.clip(index - half_window, 0, n)
+    ends = np.clip(index + half_window + 1, 0, n)
+    sums = cumulative[ends] - cumulative[starts]
+    counts = (ends - starts).astype(np.float64)
+    result: npt.NDArray[np.float64] = np.divide(
+        sums, counts, out=np.zeros_like(sums), where=counts > 0.0
+    )
+    return result
+
+
+def _exponential_smooth(
+    values: npt.NDArray[Any], alpha: float, op_name: str
+) -> npt.NDArray[np.float64]:
+    """Exponential moving average: ``y[0] = x[0]``, ``y[i] = alpha*x[i] + (1-alpha)*y[i-1]``."""
+    if not (0.0 < alpha <= 1.0):
+        raise ValueError(f"FilteringMixin.{op_name}: alpha must be in (0, 1], got {alpha}")
+    float_values = np.asarray(values, dtype=np.float64)
+    n = float_values.shape[0]
+    if n == 0:
+        raise ValueError(f"FilteringMixin.{op_name} requires at least 1 sample, got 0")
+    smoothed = np.empty(n, dtype=np.float64)
+    smoothed[0] = float_values[0]
+    one_minus_alpha = 1.0 - alpha
+    for i in range(1, n):
+        smoothed[i] = alpha * float_values[i] + one_minus_alpha * smoothed[i - 1]
+    return smoothed
+
+
+def _whittaker_henderson_smooth(
+    values: npt.NDArray[Any], lam: float, order: int, op_name: str
+) -> npt.NDArray[np.float64]:
+    """Whittaker-Henderson smoother: solve ``(I + lam * D^T D) z = v`` for the
+    order-th difference matrix ``D`` -- the chunk's own recipe, verbatim."""
+    if order < 1:
+        raise ValueError(f"FilteringMixin.{op_name}: order must be >= 1, got {order}")
+    if lam < 0.0:
+        raise ValueError(f"FilteringMixin.{op_name}: lam must be >= 0, got {lam}")
+    float_values = np.asarray(values, dtype=np.float64)
+    n = float_values.shape[0]
+    if n <= order:
+        raise ValueError(
+            f"FilteringMixin.{op_name} requires more than order ({order}) samples, got {n}"
+        )
+
+    d = sparse.eye(n, format="csc")
+    for _ in range(order):
+        d = d[1:] - d[:-1]
+    system = (sparse.eye(n, format="csc") + lam * (d.T @ d)).tocsc()
+    smoothed = spsolve(system, float_values)
+    return np.asarray(smoothed, dtype=np.float64)
+
+
+class FilteringMixin:
+    """Adds digital-filtering methods to a ``WaveformProtocol``-satisfying host."""
+
+    def low_pass_filter(
+        self: WaveformProtocol, cutoff_hz: float, order: int = 4, causal: bool = False
+    ) -> WaveformProtocol:
+        """Zero-phase (unless ``causal``) Butterworth low-pass filter.
+
+        Raises:
+            ValueError: If ``order < 1`` or ``cutoff_hz`` is outside
+                ``(0, nyquist)``.
+        """
+        b, a = _butter_coefficients(
+            WaveformFilterType.LOW_PASS,
+            order,
+            self.sampling_frequency_hz,
+            cutoff_hz,
+            None,
+            None,
+            "low_pass_filter",
+        )
+        return self._with_values(_apply_iir(self.values, b, a, causal))
+
+    def high_pass_filter(
+        self: WaveformProtocol, cutoff_hz: float, order: int = 4, causal: bool = False
+    ) -> WaveformProtocol:
+        """Zero-phase (unless ``causal``) Butterworth high-pass filter.
+
+        Raises:
+            ValueError: If ``order < 1`` or ``cutoff_hz`` is outside
+                ``(0, nyquist)``.
+        """
+        b, a = _butter_coefficients(
+            WaveformFilterType.HIGH_PASS,
+            order,
+            self.sampling_frequency_hz,
+            cutoff_hz,
+            None,
+            None,
+            "high_pass_filter",
+        )
+        return self._with_values(_apply_iir(self.values, b, a, causal))
+
+    def band_pass_filter(
+        self: WaveformProtocol,
+        low_hz: float,
+        high_hz: float,
+        order: int = 4,
+        causal: bool = False,
+    ) -> WaveformProtocol:
+        """Zero-phase (unless ``causal``) Butterworth band-pass filter.
+
+        Raises:
+            ValueError: If ``order < 1`` or ``0 < low_hz < high_hz < nyquist``
+                does not hold.
+        """
+        b, a = _butter_coefficients(
+            WaveformFilterType.BAND_PASS,
+            order,
+            self.sampling_frequency_hz,
+            None,
+            low_hz,
+            high_hz,
+            "band_pass_filter",
+        )
+        return self._with_values(_apply_iir(self.values, b, a, causal))
+
+    def filtered(
+        self: WaveformProtocol,
+        filter_type: WaveformFilterType,
+        cutoff_hz: float | None = None,
+        low_hz: float | None = None,
+        high_hz: float | None = None,
+        order: int = 4,
+        causal: bool = False,
+    ) -> WaveformProtocol:
+        """Generic Butterworth dispatch over ``WaveformFilterType`` (adds BAND_STOP,
+        unreachable from the three dedicated methods above).
+
+        Raises:
+            ValueError: If the arguments ``filter_type`` requires are missing,
+                ``order < 1``, or a cutoff/band edge violates Nyquist.
+        """
+        b, a = _butter_coefficients(
+            filter_type,
+            order,
+            self.sampling_frequency_hz,
+            cutoff_hz,
+            low_hz,
+            high_hz,
+            "filtered",
+        )
+        return self._with_values(_apply_iir(self.values, b, a, causal))
+
+    def moving_average_filter(self: WaveformProtocol, window_size: int) -> WaveformProtocol:
+        """Centered moving average (``window_size`` samples; shrinks near the edges
+        rather than zero-padding).
+
+        Raises:
+            ValueError: If ``window_size < 1``.
+        """
+        return self._with_values(
+            _moving_average(self.values, window_size, "moving_average_filter")
+        )
+
+    def exponential_filter(self: WaveformProtocol, alpha: float) -> WaveformProtocol:
+        """Exponential moving average (first sample unchanged).
+
+        Raises:
+            ValueError: If ``alpha`` is outside ``(0, 1]``, or the waveform is
+                empty.
+        """
+        return self._with_values(_exponential_smooth(self.values, alpha, "exponential_filter"))
+
+    def savitzky_golay_filter(
+        self: WaveformProtocol, window_length: int, polyorder: int, deriv: int = 0
+    ) -> WaveformProtocol:
+        """Savitzky-Golay smoothing/derivative filter (``scipy.signal.savgol_filter``).
+
+        ``deriv > 0`` results are scaled by ``1/dt**deriv`` (via ``delta=dt``)
+        to carry proper derivative units.
+
+        Raises:
+            ValueError: If ``window_length`` is not odd and ``>= 3``, if
+                ``polyorder`` is not in ``[0, window_length)``, if ``deriv``
+                is not in ``[0, polyorder]``, or if the waveform has fewer
+                samples than ``window_length``.
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        n = values.shape[0]
+        if window_length < 3 or window_length % 2 == 0:
+            raise ValueError(
+                "FilteringMixin.savitzky_golay_filter: window_length must be odd and "
+                f">= 3, got {window_length}"
+            )
+        if not (0 <= polyorder < window_length):
+            raise ValueError(
+                "FilteringMixin.savitzky_golay_filter: polyorder must be in "
+                f"[0, {window_length}), got {polyorder}"
+            )
+        if not (0 <= deriv <= polyorder):
+            raise ValueError(
+                "FilteringMixin.savitzky_golay_filter: deriv must be in "
+                f"[0, {polyorder}], got {deriv}"
+            )
+        if n < window_length:
+            raise ValueError(
+                "FilteringMixin.savitzky_golay_filter requires at least "
+                f"{window_length} samples, got {n}"
+            )
+        dt_seconds = float_seconds(self.dt)
+        result = savgol_filter(
+            values, window_length, polyorder, deriv=deriv, delta=dt_seconds if deriv > 0 else 1.0
+        )
+        return self._with_values(np.asarray(result, dtype=np.float64))
+
+    def whittaker_henderson_filter(
+        self: WaveformProtocol, lam: float, order: int = 2
+    ) -> WaveformProtocol:
+        """Whittaker-Henderson smoother: trades fidelity to the data against
+        smoothness of the ``order``-th difference, weighted by ``lam``.
+
+        ``lam -> 0`` approximates the identity; large ``lam`` approximates the
+        least-squares polynomial trend of degree ``order - 1``.
+
+        Raises:
+            ValueError: If ``order < 1``, ``lam < 0``, or the waveform has
+                ``order`` or fewer samples.
+        """
+        return self._with_values(
+            _whittaker_henderson_smooth(self.values, lam, order, "whittaker_henderson_filter")
+        )
+
+    def frequency_response(
+        self: WaveformProtocol,
+        filter_type: WaveformFilterType,
+        order: int = 4,
+        cutoff_hz: float | None = None,
+        low_hz: float | None = None,
+        high_hz: float | None = None,
+        num_points: int = 512,
+    ) -> WaveformSpectrum:
+        """The designed Butterworth filter's frequency response (``scipy.signal.freqz``),
+        sampled at ``num_points`` points from 0 Hz to Nyquist.
+
+        Raises:
+            ValueError: Same conditions as the matching Butterworth design
+                method (see ``filtered``).
+        """
+        b, a = _butter_coefficients(
+            filter_type,
+            order,
+            self.sampling_frequency_hz,
+            cutoff_hz,
+            low_hz,
+            high_hz,
+            "frequency_response",
+        )
+        frequencies, response = freqz(b, a, worN=num_points, fs=self.sampling_frequency_hz)
+        return WaveformSpectrum(
+            frequencies=np.asarray(frequencies, dtype=np.float64),
+            magnitudes=np.abs(response).astype(np.float64),
+            phases=np.angle(response).astype(np.float64),
+        )
+
+
+__all__ = ["FilteringMixin"]
diff --git a/src/math_tools/waveforms/dsp/_peaks.py b/src/math_tools/waveforms/dsp/_peaks.py
new file mode 100644
index 0000000..86334b3
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_peaks.py
@@ -0,0 +1,149 @@
+"""``PeakMixin``: peak/valley detection and prominence ranking for ``Waveform1D``.
+
+See ``.claude/specs/waveformDsp.md`` §Family contracts (``PeakMixin``),
+§Numerical conventions, §Compliance 1-2. Swift reference:
+``Waveform1D/Extensions/Waveform1D-Peak.swift``;
+``Waveform1DPeakTests.swift`` (27 tests -- representative cases ported, not
+every case; see the module's own ``detectPeaks(threshold:prominence:
+minDistance:edgePeaks:)`` argument surface below).
+
+Backing: ``scipy.signal.find_peaks`` / ``scipy.signal.peak_prominences``.
+This diverges from the Swift extension's hand-rolled local-maxima scan
+(``threshold``/``prominence``/``minDistance``/``edgePeaks`` arguments, a
+custom base-level prominence walk) in favor of the better-tested scipy
+equivalent -- the spec explicitly allows this ("parity is judged per
+capability, not per Swift overload... scipy semantics win"), and the
+governing chunk (23-dsp-peaks.md) pins the resulting Python surface as
+``detect_peaks(min_height=None, min_distance=None, min_prominence=None)``,
+which maps directly onto ``find_peaks(height=, distance=, prominence=)``.
+
+``detect_peaks``/``detect_valleys`` are detectors (waveformDsp.md §Numerical
+conventions): they return ``[]`` on no-hit (empty waveform or no qualifying
+extrema) rather than raising. ``find_most_prominent_peaks`` is built
+directly on top of ``detect_peaks`` and shares that empty-result contract.
+
+Imports only ``scipy``/``numpy`` plus ``dsp/_protocol.py``/``dsp/_common.py``
+and ``waveforms/support.py`` (for the ``WaveformPeak``/
+``WaveformPeakWithProminence`` descriptor types) -- no sibling mixin imports
+(waveformDsp.md §Organization / §Compliance 2).
+
+**Not** ``class PeakMixin(WaveformProtocol)``: see ``dsp/_calc.py``'s module
+docstring / waveformDsp.md §Organization for the full account of why mixins
+type ``self`` as ``WaveformProtocol`` on each method instead of nominally
+subclassing it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from scipy.signal import find_peaks, peak_prominences
+
+from math_tools.waveforms.dsp._common import float_seconds
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformPeak, WaveformPeakWithProminence
+
+
+def _detect_peaks_in_array(
+    values: npt.NDArray[Any],
+    dt_seconds: float,
+    min_height: float | None,
+    min_distance: int | None,
+    min_prominence: float | None,
+) -> list[WaveformPeak]:
+    """Core ``find_peaks``-backed local-maxima scan shared by peaks and (negated) valleys."""
+    if values.shape[0] == 0:
+        return []
+    indices, _ = find_peaks(
+        values, height=min_height, distance=min_distance, prominence=min_prominence
+    )
+    return [
+        WaveformPeak(index=int(i), time_seconds=float(i) * dt_seconds, value=float(values[i]))
+        for i in indices
+    ]
+
+
+class PeakMixin:
+    """Adds peak/valley detection and prominence ranking to a ``WaveformProtocol`` host."""
+
+    def detect_peaks(
+        self: WaveformProtocol,
+        min_height: float | None = None,
+        min_distance: int | None = None,
+        min_prominence: float | None = None,
+    ) -> list[WaveformPeak]:
+        """Local maxima via ``scipy.signal.find_peaks``.
+
+        ``min_height``/``min_distance``/``min_prominence`` map directly onto
+        ``find_peaks``'s ``height``/``distance``/``prominence`` keyword
+        arguments. Returns ``[]`` on an empty waveform or when no sample
+        qualifies as a peak -- never raises (this is a detector, per
+        waveformDsp.md §Numerical conventions).
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        dt_seconds = float_seconds(self.dt)
+        return _detect_peaks_in_array(values, dt_seconds, min_height, min_distance, min_prominence)
+
+    def detect_valleys(
+        self: WaveformProtocol,
+        min_height: float | None = None,
+        min_distance: int | None = None,
+        min_prominence: float | None = None,
+    ) -> list[WaveformPeak]:
+        """Local minima: ``detect_peaks`` run on the negated signal, negated back.
+
+        ``min_height``/``min_distance``/``min_prominence`` are forwarded
+        unchanged to the negated-signal peak search (i.e. ``min_height``
+        bounds ``-value`` from below, meaning it bounds ``value`` from
+        above). Returns ``[]`` on an empty waveform or no qualifying valley.
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        dt_seconds = float_seconds(self.dt)
+        negated_peaks = _detect_peaks_in_array(
+            -values, dt_seconds, min_height, min_distance, min_prominence
+        )
+        return [
+            WaveformPeak(index=p.index, time_seconds=p.time_seconds, value=-p.value)
+            for p in negated_peaks
+        ]
+
+    def find_most_prominent_peaks(
+        self: WaveformProtocol,
+        count: int,
+        min_distance: int | None = None,
+    ) -> list[WaveformPeakWithProminence]:
+        """The ``count`` peaks with the highest ``scipy.signal.peak_prominences`` value.
+
+        Candidate peaks come from an unfiltered (no height/prominence
+        threshold) ``find_peaks`` pass, restricted only by ``min_distance``;
+        results are sorted by prominence descending and truncated to
+        ``count``. Returns ``[]`` when ``count <= 0``, the waveform is
+        empty, or it has no interior peaks.
+        """
+        if count <= 0:
+            return []
+        values = np.asarray(self.values, dtype=np.float64)
+        if values.shape[0] == 0:
+            return []
+        dt_seconds = float_seconds(self.dt)
+        indices, _ = find_peaks(values, distance=min_distance)
+        if indices.size == 0:
+            return []
+        prominences, _, _ = peak_prominences(values, indices)
+        descending_order = np.argsort(-prominences, kind="stable")
+        top_order = descending_order[:count]
+        result: list[WaveformPeakWithProminence] = []
+        for position in top_order:
+            index = int(indices[position])
+            peak = WaveformPeak(
+                index=index, time_seconds=float(index) * dt_seconds, value=float(values[index])
+            )
+            result.append(
+                WaveformPeakWithProminence(peak=peak, prominence=float(prominences[position]))
+            )
+        return result
+
+
+__all__ = ["PeakMixin"]
diff --git a/src/math_tools/waveforms/dsp/_phase.py b/src/math_tools/waveforms/dsp/_phase.py
new file mode 100644
index 0000000..73940e4
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_phase.py
@@ -0,0 +1,249 @@
+"""``PhaseMixin``: instantaneous phase/frequency and phase-synchrony analysis.
+
+See ``.claude/specs/waveformDsp.md`` §Family contracts (``PhaseMixin``),
+§Numerical conventions, §Compliance 1-2. Swift reference:
+``Waveform1D/Extensions/Waveform1D-PhaseAnalysis.swift``.
+
+Backing: ``scipy.signal.hilbert`` (analytic-signal phase), ``np.unwrap``,
+per waveformDsp.md's family-contract table. This diverges from the Swift
+extension's hand-rolled "quadrature filter" approximation of the Hilbert
+transform (a fixed-window finite-difference stand-in, see
+``Waveform1D-PhaseAnalysis.swift``'s private ``quadratureComponent``) in
+favor of the better-tested ``scipy.signal.hilbert`` -- the spec explicitly
+allows this ("parity is judged per capability, not per Swift overload...
+scipy semantics win").
+
+``instantaneous_phase``/``unwrap_phase``/``instantaneous_frequency`` raise
+``ValueError`` (naming the requirement) on an empty/too-short input waveform
+(waveformDsp.md §Numerical conventions -- none of these are in the
+``detect_*``/``zero_crossings`` detector family that gets the empty-result
+exemption). ``phase_difference``/``phase_coherence``/
+``phase_synchronization_index`` are binary: they raise
+``WaveformCompatibilityError`` when ``other.dt`` differs from ``self.dt`` or
+the two waveforms have a different sample count (``errors.py``'s
+``WaveformCompatibilityError`` docstring: "dt/shape mismatch").
+
+``group_delay`` is a ``staticmethod``: like the Swift reference's
+``groupDelay(frequencies:phases:)``, it operates purely on caller-supplied
+frequency/phase arrays (e.g. from ``SpectralMixin.fft``'s
+``WaveformSpectrum``) and never touches ``self.values``/``self.dt`` -- it
+does not need ``self: WaveformProtocol`` typing at all.
+
+Imports only ``scipy``/``numpy`` plus ``dsp/_protocol.py``/``dsp/_common.py``
+and ``waveforms/support.py`` (for ``WaveformInstantaneousFrequency``) -- no
+sibling mixin imports (waveformDsp.md §Organization / §Compliance 2).
+
+**Not** ``class PhaseMixin(WaveformProtocol)``: see ``dsp/_calc.py``'s
+module docstring / waveformDsp.md §Organization for the full account of why
+mixins type ``self`` as ``WaveformProtocol`` on each method instead of
+nominally subclassing it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from scipy.signal import hilbert
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.waveforms.dsp._common import float_seconds
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformInstantaneousFrequency
+
+
+def _analytic_phase(values: npt.NDArray[Any]) -> npt.NDArray[np.float64]:
+    """Wrapped instantaneous phase (``[-pi, pi]``) of ``values`` via the analytic signal."""
+    analytic = hilbert(np.asarray(values, dtype=np.float64))
+    result: npt.NDArray[np.float64] = np.angle(analytic)
+    return result
+
+
+def _wrap_to_pi(radians: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+    """Wrap ``radians`` into ``(-pi, pi]`` (via the unit complex exponential)."""
+    result: npt.NDArray[np.float64] = np.angle(np.exp(1j * radians))
+    return result
+
+
+def _plv(phase_difference_radians: npt.NDArray[np.float64]) -> float:
+    """Phase-locking value: magnitude of the mean unit vector at ``phase_difference_radians``."""
+    return float(np.abs(np.mean(np.exp(1j * phase_difference_radians))))
+
+
+def _require_compatible(waveform: WaveformProtocol, other: WaveformProtocol, op_name: str) -> None:
+    """Raise ``WaveformCompatibilityError`` unless ``other`` shares ``waveform``'s ``dt``
+    and sample count (errors.py's ``WaveformCompatibilityError``: "dt/shape mismatch")."""
+    if waveform.dt != other.dt:
+        raise WaveformCompatibilityError(
+            f"PhaseMixin.{op_name}: dt mismatch ({waveform.dt!r} vs {other.dt!r})"
+        )
+    self_count = waveform.values.shape[0]
+    other_count = other.values.shape[0]
+    if self_count != other_count:
+        raise WaveformCompatibilityError(
+            f"PhaseMixin.{op_name}: sample-count mismatch ({self_count} vs {other_count})"
+        )
+
+
+class PhaseMixin:
+    """Adds instantaneous phase/frequency and phase-synchrony methods to a
+    ``WaveformProtocol`` host."""
+
+    def instantaneous_phase(self: WaveformProtocol, unwrapped: bool = True) -> WaveformProtocol:
+        """Instantaneous phase via the analytic-signal angle (``scipy.signal.hilbert``).
+
+        Raises:
+            ValueError: If the waveform has no samples.
+        """
+        sample_count = self.values.shape[0]
+        if sample_count == 0:
+            raise ValueError("PhaseMixin.instantaneous_phase requires at least 1 sample, got 0")
+        phase = _analytic_phase(self.values)
+        if unwrapped:
+            phase = np.unwrap(phase)
+        return self._with_values(phase)
+
+    def unwrap_phase(self: WaveformProtocol, threshold: float = np.pi) -> WaveformProtocol:
+        """``np.unwrap`` applied to ``self.values`` as already-computed phase data.
+
+        ``threshold`` is ``np.unwrap``'s ``discont`` (a jump larger than this
+        many radians between consecutive samples is treated as a wraparound
+        and corrected); it defaults to pi, matching ``np.unwrap``'s own
+        default.
+
+        Raises:
+            ValueError: If the waveform has no samples.
+        """
+        sample_count = self.values.shape[0]
+        if sample_count == 0:
+            raise ValueError("PhaseMixin.unwrap_phase requires at least 1 sample, got 0")
+        unwrapped = np.unwrap(np.asarray(self.values, dtype=np.float64), discont=threshold)
+        return self._with_values(unwrapped)
+
+    def instantaneous_frequency(self: WaveformProtocol) -> WaveformInstantaneousFrequency:
+        """Instantaneous frequency (Hz): the unwrapped analytic-signal phase's time
+        gradient, scaled by ``1 / (2 * pi)`` (``np.gradient``, scaled by ``dt`` seconds).
+
+        Raises:
+            ValueError: If the waveform has fewer than 2 samples (``np.gradient``'s
+                minimum for a first-order estimate).
+        """
+        sample_count = self.values.shape[0]
+        if sample_count < 2:
+            raise ValueError(
+                f"PhaseMixin.instantaneous_frequency requires at least 2 samples, "
+                f"got {sample_count}"
+            )
+        dt_seconds = float_seconds(self.dt)
+        phase = np.unwrap(_analytic_phase(self.values))
+        frequencies_hz = np.gradient(phase, dt_seconds) / (2.0 * np.pi)
+        times_seconds = np.arange(sample_count, dtype=np.float64) * dt_seconds
+        return WaveformInstantaneousFrequency(
+            frequencies_hz=frequencies_hz, times_seconds=times_seconds
+        )
+
+    def phase_difference(self: WaveformProtocol, other: WaveformProtocol) -> WaveformProtocol:
+        """Wrapped phase difference (``self``'s analytic phase minus ``other``'s),
+        wrapped into ``(-pi, pi]``.
+
+        Raises:
+            WaveformCompatibilityError: If ``other.dt`` differs from ``self.dt``,
+                or the sample counts differ.
+            ValueError: If either waveform has no samples.
+        """
+        _require_compatible(self, other, "phase_difference")
+        if self.values.shape[0] == 0:
+            raise ValueError("PhaseMixin.phase_difference requires at least 1 sample, got 0")
+        phase_self = _analytic_phase(self.values)
+        phase_other = _analytic_phase(other.values)
+        return self._with_values(_wrap_to_pi(phase_self - phase_other))
+
+    def phase_coherence(
+        self: WaveformProtocol, other: WaveformProtocol, window: int | None = None
+    ) -> WaveformProtocol:
+        """Windowed phase-locking value between ``self`` and ``other`` (non-overlapping
+        windows of ``window`` samples; one coherence value per window).
+
+        ``window`` defaults to ``min(256, max(1, sample_count // 4))`` (mirrors the
+        Swift reference's default). The result's ``dt``/``t0`` are inherited unchanged
+        from ``self`` (the ``WaveformProtocol`` surface has no other way to construct
+        a result -- see ``_with_values``'s docstring; ``CorrelationMixin.auto_correlation``
+        establishes the same precedent of a differently-spaced result reusing the
+        source's ``dt`` as inherited metadata).
+
+        Raises:
+            WaveformCompatibilityError: If ``other.dt`` differs from ``self.dt``,
+                or the sample counts differ.
+            ValueError: If the waveform has fewer than 2 samples, or ``window``
+                is not in ``[1, sample_count]``.
+        """
+        _require_compatible(self, other, "phase_coherence")
+        sample_count = self.values.shape[0]
+        if sample_count < 2:
+            raise ValueError(
+                f"PhaseMixin.phase_coherence requires at least 2 samples, got {sample_count}"
+            )
+        resolved_window = window if window is not None else min(256, max(1, sample_count // 4))
+        if not (1 <= resolved_window <= sample_count):
+            raise ValueError(
+                f"PhaseMixin.phase_coherence: window must be in [1, {sample_count}], "
+                f"got {resolved_window}"
+            )
+
+        phase_diff = _analytic_phase(self.values) - _analytic_phase(other.values)
+        coherence_values = [
+            _plv(phase_diff[start : start + resolved_window])
+            for start in range(0, sample_count - resolved_window + 1, resolved_window)
+        ]
+        return self._with_values(np.asarray(coherence_values, dtype=np.float64))
+
+    def phase_synchronization_index(self: WaveformProtocol, other: WaveformProtocol) -> float:
+        """Phase-locking value (PLV) between ``self`` and ``other`` over the full
+        signal, in ``[0, 1]`` (``1.0`` = perfectly phase-locked, ``0.0`` = uniformly
+        random relative phase).
+
+        Raises:
+            WaveformCompatibilityError: If ``other.dt`` differs from ``self.dt``,
+                or the sample counts differ.
+            ValueError: If either waveform has no samples.
+        """
+        _require_compatible(self, other, "phase_synchronization_index")
+        if self.values.shape[0] == 0:
+            raise ValueError(
+                "PhaseMixin.phase_synchronization_index requires at least 1 sample, got 0"
+            )
+        phase_diff = _analytic_phase(self.values) - _analytic_phase(other.values)
+        return _plv(phase_diff)
+
+    @staticmethod
+    def group_delay(
+        frequencies: npt.NDArray[Any], phases: npt.NDArray[Any]
+    ) -> npt.NDArray[np.float64]:
+        """Group delay (seconds): the negative derivative of unwrapped ``phases``
+        (radians) with respect to ``frequencies`` (Hz), divided by ``2 * pi``.
+
+        A ``staticmethod`` -- see the module docstring for why it does not take
+        ``self``.
+
+        Raises:
+            ValueError: If ``frequencies``/``phases`` have mismatched shape, or
+                fewer than 2 samples.
+        """
+        freq = np.asarray(frequencies, dtype=np.float64)
+        phase = np.asarray(phases, dtype=np.float64)
+        if freq.shape != phase.shape:
+            raise ValueError(
+                f"PhaseMixin.group_delay: frequencies/phases shape mismatch "
+                f"({freq.shape} vs {phase.shape})"
+            )
+        if freq.shape[0] < 2:
+            raise ValueError(
+                f"PhaseMixin.group_delay requires at least 2 samples, got {freq.shape[0]}"
+            )
+        unwrapped = np.unwrap(phase)
+        result: npt.NDArray[np.float64] = -np.gradient(unwrapped, freq) / (2.0 * np.pi)
+        return result
+
+
+__all__ = ["PhaseMixin"]
diff --git a/src/math_tools/waveforms/dsp/_protocol.py b/src/math_tools/waveforms/dsp/_protocol.py
new file mode 100644
index 0000000..17e198d
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_protocol.py
@@ -0,0 +1,99 @@
+"""``WaveformProtocol``: the structural contract every DSP mixin depends on.
+
+See ``.claude/specs/waveformDsp.md`` §Organization. Mixins are stateless and
+touch only the public ``Waveform1D`` surface (``values``, ``dt``, ``t0``,
+constructors); declaring that surface as a ``Protocol`` (rather than each
+mixin inheriting ``Waveform1D`` directly) lets every mixin be independently
+mypy-strict-checkable without a circular import back into
+``waveforms/waveform1d.py`` (which imports nothing from ``dsp/``).
+
+References only ``PrecisionTimeInterval``/``PrecisionTimestamp`` and numpy
+typing -- never a concrete mixin or ``Waveform1D`` itself.
+
+**Mixins type their ``self`` as this Protocol; they do not nominally
+inherit it** (i.e. ``def integrate(self: WaveformProtocol, ...)``, not
+``class CalcMixin(WaveformProtocol)``). Nominal inheritance was the
+original design and is broken at runtime: explicitly subclassing a
+``Protocol`` turns its stub property bodies (``...``, so the getter
+returns ``None``) into concrete inherited implementations, and when a test
+composes ``class _W(SomeMixin, Waveform1D)``, C3 linearization places that
+inherited stub ahead of ``Waveform1D``'s real property -- ``self.values``
+silently returns ``None`` instead of the sample array. Self-typing avoids
+this because the mixin then carries no runtime base beyond ``object``, so
+composing it with ``Waveform1D`` never pulls ``WaveformProtocol`` into the
+MRO. See ``.claude/specs/waveformDsp.md`` §Organization (fixed in chunk 18,
+semver 0.0.3) for the full account.
+
+Deviation from the chunk doc's literal code block: ``_with_values`` returns
+``WaveformProtocol`` (self-type), not the quoted forward reference
+``"Waveform1D"`` shown there -- importing ``Waveform1D`` here (even under
+``TYPE_CHECKING``) is exactly what the hard constraint above forbids, and an
+unimported bare ``"Waveform1D"`` annotation is a mypy-strict "Name is not
+defined" error under ``from __future__ import annotations``. Returning the
+protocol itself is structurally equivalent for every caller (a mixin only
+ever needs the result to satisfy ``WaveformProtocol`` again) and
+``Waveform1D._with_values -> Waveform1D`` remains a valid (covariant)
+implementation of this method.
+
+**Added in chunk 25 (semver 0.0.4): ``_with_axis``.** Every mixin through
+chunk 24 only ever produces results that share ``self``'s ``dt`` -- so
+``_with_values`` (same ``dt``/``t0``, new samples) was a sufficient factory.
+``ResamplingMixin`` (``dsp/_resampling.py``) is the first family whose
+results have a genuinely different sample spacing (``decimated``/
+``interpolated``/``resampled``/``polyphase_resampled`` all compute a new
+``dt``), so the structural contract needs a second factory that also takes
+the new ``dt``. ``t0`` is deliberately not a parameter -- every
+``ResamplingMixin`` method keeps ``t0`` unchanged (waveformDsp.md §Family
+contracts (``ResamplingMixin``): "New ``t0`` is unchanged") -- so there is
+no caller yet that needs to vary it too; add that only when one does.
+
+**Added in chunk 26 (semver 0.0.5): ``_with_t0``.** ``TimeAlignmentMixin``
+(``dsp/_time_alignment.py``) is the first family whose results carry a
+genuinely different *start time* than their source: ``aligned`` shifts
+``t0`` by a detected (or reference) offset, ``synchronize`` slices every
+input down to a shared overlap window starting at a common ``t0``, and
+``time_windows``/``time_segments`` each cut out a sub-span starting partway
+through ``self``. None of these change ``dt``, so ``_with_axis`` (which
+pins ``t0`` to ``self``'s) does not fit; a third, single-purpose factory
+completes the same-dt / same-dt-and-t0 / same-t0 triangle
+(``_with_values``: same ``dt``, same ``t0``; ``_with_axis``: new ``dt``,
+same ``t0``; ``_with_t0``: same ``dt``, new ``t0``) rather than overloading
+either existing factory's meaning.
+"""
+
+from __future__ import annotations
+
+from typing import Any, Protocol, runtime_checkable
+
+import numpy.typing as npt
+
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.precision_time.precision_timestamp import PrecisionTimestamp
+
+
+@runtime_checkable
+class WaveformProtocol(Protocol):
+    """Structural surface a DSP mixin needs from its host ``Waveform1D``."""
+
+    @property
+    def values(self) -> npt.NDArray[Any]: ...
+
+    @property
+    def dt(self) -> PrecisionTimeInterval: ...
+
+    @property
+    def t0(self) -> PrecisionTimestamp: ...
+
+    @property
+    def sampling_frequency_hz(self) -> float: ...
+
+    def _with_values(self, values: npt.NDArray[Any]) -> WaveformProtocol: ...
+
+    def _with_axis(
+        self, values: npt.NDArray[Any], dt: PrecisionTimeInterval
+    ) -> WaveformProtocol: ...
+
+    def _with_t0(self, values: npt.NDArray[Any], t0: PrecisionTimestamp) -> WaveformProtocol: ...
+
+
+__all__ = ["WaveformProtocol"]
diff --git a/src/math_tools/waveforms/dsp/_resampling.py b/src/math_tools/waveforms/dsp/_resampling.py
new file mode 100644
index 0000000..ac30d81
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_resampling.py
@@ -0,0 +1,258 @@
+"""``ResamplingMixin``: sample-rate conversion for ``Waveform1D``.
+
+See ``.claude/specs/waveformDsp.md`` §Family contracts (``ResamplingMixin``),
+§Numerical conventions, §Compliance 1-2. Swift reference:
+``Waveform1D/Extensions/Waveform1D-Resampling.swift``.
+
+Backing: ``scipy.signal.decimate`` (``decimated``, built-in anti-aliasing
+filter), ``scipy.signal.resample`` / ``np.interp`` / ``scipy.interpolate.
+CubicSpline`` (``interpolated``, selected by the ``WaveformInterpolationMethod``
+kernel argument), ``scipy.signal.resample`` (``resampled``/
+``resampled_to_match``, FFT-based), ``scipy.signal.resample_poly``
+(``polyphase_resampled``) -- per waveformDsp.md's family-contract table.
+
+**dt bookkeeping (the chunk's own "tricky bit").** Every mixin through
+chunk 24 only ever produces results sharing ``self``'s ``dt`` (built via
+``_with_values``, see ``dsp/_protocol.py``'s and ``dsp/_phase.py``'s
+docstrings). ``ResamplingMixin`` is the first family whose results have a
+genuinely different sample spacing, so this chunk adds ``_with_axis`` to
+``WaveformProtocol``/``Waveform1D`` (``dsp/_protocol.py``, ``waveforms/
+waveform1d.py``; a forced contract change, waveformDsp.md bumped to
+semver 0.0.4) -- the dt-changing sibling of ``_with_values``. ``t0`` is
+never changed by any method here (waveformDsp.md: "New ``t0`` is
+unchanged").
+
+Integer-factor paths (``decimated``, ``interpolated``) compute the new
+``dt`` exactly via ``PrecisionTimeInterval`` arithmetic (``dt * factor`` /
+``dt / factor``, both exact or rounded to the nearest attosecond -- see
+``precision_time_interval.py``). ``polyphase_resampled(up, down)``
+generalizes this to a rational factor (``dt * down / up``).
+``resampled(target_frequency_hz)`` cannot use exact rational arithmetic in
+general (the achieved sample count is an integer, so the achieved rate is
+only ever an approximation of the requested one); its ``dt`` is derived
+from the *achieved* rate: ``new_dt = dt * sample_count / new_sample_count``
+(the same relationship ``scipy.signal.resample`` itself assumes between
+input/output length and sampling interval).
+
+``factor < 1`` or a non-int ``factor`` (``decimated``, ``interpolated``,
+and ``up``/``down`` of ``polyphase_resampled``) raises ``ValueError``
+(waveformDsp.md §Numerical conventions -- none of these are in the
+``detect_*``/``zero_crossings`` detector family that gets the empty-result
+exemption).
+
+Imports only ``scipy``/``numpy`` plus ``dsp/_protocol.py``/``dsp/_common.py``
+and ``waveforms/support.py`` (for the ``WaveformInterpolationMethod`` enum
+argument) -- no sibling mixin imports (waveformDsp.md §Organization /
+§Compliance 2).
+
+**Not** ``class ResamplingMixin(WaveformProtocol)``: see ``dsp/_calc.py``'s
+module docstring / waveformDsp.md §Organization for the full account of why
+mixins type ``self`` as ``WaveformProtocol`` on each method instead of
+nominally subclassing it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from scipy.interpolate import CubicSpline
+from scipy.signal import decimate as scipy_decimate
+from scipy.signal import resample as scipy_resample
+from scipy.signal import resample_poly as scipy_resample_poly
+
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.waveforms.dsp._common import float_seconds
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformInterpolationMethod
+
+
+def _validate_positive_int_factor(factor: int, op_name: str, param_name: str = "factor") -> None:
+    """Raise ``ValueError`` unless ``factor`` is a (non-``bool``) ``int`` ``>= 1``."""
+    if isinstance(factor, bool) or not isinstance(factor, int):
+        raise ValueError(
+            f"ResamplingMixin.{op_name}: {param_name} must be an int, got {factor!r}"
+        )
+    if factor < 1:
+        raise ValueError(
+            f"ResamplingMixin.{op_name}: {param_name} must be >= 1, got {factor}"
+        )
+
+
+def _require_min_samples(sample_count: int, minimum: int, op_name: str) -> None:
+    if sample_count < minimum:
+        raise ValueError(
+            f"ResamplingMixin.{op_name} requires at least {minimum} samples, got {sample_count}"
+        )
+
+
+def _interpolate(
+    values: npt.NDArray[Any], factor: int, method: WaveformInterpolationMethod
+) -> npt.NDArray[np.float64]:
+    """Insert ``factor - 1`` samples between every consecutive pair of ``values``
+    (endpoints preserved), per ``method``'s interpolation kernel.
+
+    New length is always ``(len(values) - 1) * factor + 1``.
+    """
+    float_values = np.asarray(values, dtype=np.float64)
+    sample_count = float_values.shape[0]
+    new_length = (sample_count - 1) * factor + 1
+
+    if method is WaveformInterpolationMethod.FOURIER:
+        result = scipy_resample(float_values, new_length)
+        return np.asarray(result, dtype=np.float64)
+
+    source_positions = np.arange(sample_count, dtype=np.float64)
+    target_positions = np.linspace(0.0, sample_count - 1, new_length)
+
+    if method is WaveformInterpolationMethod.LINEAR:
+        return np.asarray(
+            np.interp(target_positions, source_positions, float_values), dtype=np.float64
+        )
+    if method is WaveformInterpolationMethod.CUBIC:
+        spline = CubicSpline(source_positions, float_values)
+        return np.asarray(spline(target_positions), dtype=np.float64)
+    if method is WaveformInterpolationMethod.NEAREST:
+        nearest_indices = np.round(target_positions).astype(np.intp)
+        return float_values[nearest_indices]
+    # pragma: no cover -- WaveformInterpolationMethod is exhaustive above
+    raise ValueError(f"ResamplingMixin.interpolated: unsupported method {method!r}")
+
+
+def _resample_to_frequency(
+    self: WaveformProtocol, target_frequency_hz: float, op_name: str
+) -> WaveformProtocol:
+    """Shared implementation for ``resampled``/``resampled_to_match``: FFT-resample
+    to the sample count implied by ``target_frequency_hz``, deriving the result's
+    ``dt`` from the achieved (rounded) sample count -- see the module docstring.
+    """
+    values = self.values
+    sample_count = values.shape[0]
+    _require_min_samples(sample_count, 2, op_name)
+
+    original_frequency_hz = self.sampling_frequency_hz
+    new_length = max(1, round(sample_count * target_frequency_hz / original_frequency_hz))
+    if new_length < 2:
+        raise ValueError(
+            f"ResamplingMixin.{op_name}: target_frequency_hz={target_frequency_hz} yields "
+            f"fewer than 2 samples from {sample_count} samples at {original_frequency_hz} Hz"
+        )
+
+    resampled_values = np.asarray(scipy_resample(values, new_length), dtype=np.float64)
+    achieved_dt_seconds = float_seconds(self.dt) * sample_count / new_length
+    new_dt = PrecisionTimeInterval.from_seconds(achieved_dt_seconds)
+    return self._with_axis(resampled_values, new_dt)
+
+
+class ResamplingMixin:
+    """Adds sample-rate conversion (``decimated``/``interpolated``/``resampled``/
+    ``resampled_to_match``/``polyphase_resampled``) to a ``WaveformProtocol`` host."""
+
+    def decimated(self: WaveformProtocol, factor: int) -> WaveformProtocol:
+        """Reduce the sampling rate by the integer ``factor`` (``scipy.signal.decimate``,
+        which applies its own anti-aliasing filter). ``dt`` becomes ``dt * factor``
+        exactly; ``t0`` is unchanged.
+
+        Raises:
+            ValueError: If ``factor`` is not an int, or ``factor < 1``.
+            ValueError: If the waveform has fewer than 2 samples.
+        """
+        _validate_positive_int_factor(factor, "decimated")
+        values = self.values
+        if factor == 1:
+            return self._with_values(values.copy())
+        _require_min_samples(values.shape[0], 2, "decimated")
+
+        # ftype="fir": scipy.signal.decimate's default IIR (Chebyshev I) anti-alias
+        # filter has ~0.05 dB passband ripple, doubled by zero-phase filtfilt to
+        # ~1.1% amplitude error even deep in the passband -- enough to blow the
+        # interpolated().decimated() round-trip's rtol (waveformDsp.md §Compliance
+        # 1). The FIR variant (linear-phase, near-flat passband) round-trips to
+        # ~1e-6 on the same signal and also tolerates much shorter inputs (its
+        # padding requirement scales with taps, not a fixed minimum of 27+).
+        decimated_values = np.asarray(
+            scipy_decimate(values, factor, ftype="fir"), dtype=np.float64
+        )
+        new_dt = self.dt * factor
+        return self._with_axis(decimated_values, new_dt)
+
+    def interpolated(
+        self: WaveformProtocol,
+        factor: int,
+        method: WaveformInterpolationMethod = WaveformInterpolationMethod.LINEAR,
+    ) -> WaveformProtocol:
+        """Increase the sampling rate by the integer ``factor``, inserting
+        ``factor - 1`` new samples between every consecutive pair (per ``method``'s
+        kernel: LINEAR/CUBIC/NEAREST fit the original samples directly; FOURIER
+        uses ``scipy.signal.resample``). ``dt`` becomes ``dt / factor`` (rounded
+        to the nearest attosecond); ``t0`` is unchanged.
+
+        Raises:
+            ValueError: If ``factor`` is not an int, or ``factor < 1``.
+            ValueError: If the waveform has fewer than 2 samples.
+        """
+        _validate_positive_int_factor(factor, "interpolated")
+        values = self.values
+        if factor == 1:
+            return self._with_values(values.copy())
+        _require_min_samples(values.shape[0], 2, "interpolated")
+
+        interpolated_values = _interpolate(values, factor, method)
+        new_dt = self.dt / factor
+        return self._with_axis(interpolated_values, new_dt)
+
+    def resampled(self: WaveformProtocol, target_frequency_hz: float) -> WaveformProtocol:
+        """FFT-resample (``scipy.signal.resample``) to ``target_frequency_hz``.
+
+        The achieved sample count is ``round(sample_count * target_frequency_hz /
+        sampling_frequency_hz)``; ``dt`` is derived from that achieved count
+        rather than blindly set to ``1 / target_frequency_hz`` (waveformDsp.md:
+        "``resampled(hz)`` derives dt from the achieved rate"). ``t0`` is
+        unchanged.
+
+        Raises:
+            ValueError: If ``target_frequency_hz <= 0``.
+            ValueError: If the waveform has fewer than 2 samples, or the
+                achieved sample count would be fewer than 2.
+        """
+        if not target_frequency_hz > 0.0:
+            raise ValueError(
+                f"ResamplingMixin.resampled: target_frequency_hz must be > 0, "
+                f"got {target_frequency_hz}"
+            )
+        return _resample_to_frequency(self, target_frequency_hz, "resampled")
+
+    def resampled_to_match(self: WaveformProtocol, other: WaveformProtocol) -> WaveformProtocol:
+        """``resampled`` to ``other.sampling_frequency_hz`` -- resample ``self`` onto
+        (approximately) ``other``'s rate and length.
+
+        Raises:
+            ValueError: If the waveform has fewer than 2 samples, or the
+                achieved sample count would be fewer than 2.
+        """
+        return _resample_to_frequency(self, other.sampling_frequency_hz, "resampled_to_match")
+
+    def polyphase_resampled(self: WaveformProtocol, up: int, down: int) -> WaveformProtocol:
+        """Efficient polyphase resampling by the rational factor ``up / down``
+        (``scipy.signal.resample_poly``, which applies its own anti-aliasing
+        filter). ``dt`` becomes ``dt * down / up`` (rounded to the nearest
+        attosecond); ``t0`` is unchanged.
+
+        Raises:
+            ValueError: If ``up``/``down`` are not ints, or either is ``< 1``.
+            ValueError: If the waveform has fewer than 2 samples.
+        """
+        _validate_positive_int_factor(up, "polyphase_resampled", "up")
+        _validate_positive_int_factor(down, "polyphase_resampled", "down")
+        values = self.values
+        _require_min_samples(values.shape[0], 2, "polyphase_resampled")
+
+        resampled_values = np.asarray(
+            scipy_resample_poly(values, up, down), dtype=np.float64
+        )
+        new_dt = (self.dt * down) / up
+        return self._with_axis(resampled_values, new_dt)
+
+
+__all__ = ["ResamplingMixin"]
diff --git a/src/math_tools/waveforms/dsp/_spectral.py b/src/math_tools/waveforms/dsp/_spectral.py
new file mode 100644
index 0000000..ae6abd0
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_spectral.py
@@ -0,0 +1,408 @@
+"""``SpectralMixin``: FFT / PSD / spectrogram / mel-spectrogram / spectral features.
+
+See ``.claude/specs/waveformDsp.md`` §Family contracts (``SpectralMixin``),
+§Numerical conventions, §Compliance 1-2. Swift reference:
+``Waveform1D/Extensions/Waveform1D-FFT.swift``,
+``Waveform1D/Extensions/Waveform1D-Spectrogram.swift``.
+
+Backing: ``np.fft.rfft`` (one-sided FFT), ``scipy.signal.welch`` (Welch PSD),
+``scipy.signal.spectrogram`` (STFT magnitude surface), a hand-built
+triangular mel filterbank (numpy, applied to the STFT magnitude surface),
+per waveformDsp.md's family-contract table. Window arguments
+(``WaveformWindowType``) are mapped to concrete window arrays via
+``scipy.signal.get_window`` directly in this module (chunk 21's own design
+constraint -- chunk 28's ``WindowingMixin`` is for user-facing window
+utilities, not a dependency of this one; §Organization/§Compliance 2 forbid
+importing a sibling mixin module here regardless).
+
+**Window convention: periodic, by design (chunk 53).** ``_window_array``
+calls ``scipy.signal.get_window`` with scipy's default (``fftbins=True``,
+periodic) -- the correct convention for STFT frame tiling (``welch``,
+``spectrogram``), unlike ``dsp/_windowing.py``'s user-facing default
+(symmetric, ``fftbins=False``, for filter design / whole-waveform framing).
+Per waveformDsp.md's window-convention section this divergence is
+deliberate and unchanged by chunk 53; what chunk 53 fixed is that
+``WindowingMixin``'s gain helpers can now be asked (via
+``periodic=True``) to describe this exact window, so a caller correcting a
+``power_spectral_density``/``spectrogram`` estimate's scale gets the right
+factor. The Kaiser beta shape parameter is a single shared constant
+(``dsp/_common.DEFAULT_KAISER_BETA``) imported by both modules, replacing
+what were two independent ``14.0`` literals before chunk 53.
+
+**``spectral_features`` field-set divergence from the Swift reference.** The
+chunk doc for this module says to "mirror [the Swift ``extractSpectralFeatures``
+struct's] fields exactly", but that struct (``Waveform1D/Support/
+WaveformSpectralFeatures.swift``) is a *per-time-frame* result computed from
+a spectrogram (``spectralCentroids: [PrecisionTimestamp]``,
+``spectralRolloffs: [PrecisionTimeInterval]``, ``spectralFluxes: [Double]``,
+``timeFrames: [PrecisionTimestamp]``) -- not the four scalar whole-spectrum
+statistics the chunk doc's own method-list bullet names (``centroid, spread,
+rolloff, flatness``). The Python ``WaveformSpectralFeatures`` dataclass
+already shipped in ``waveforms/support.py`` (chunk 14, merged before this
+chunk) is the latter shape (``centroid: float``, ``spread: float``,
+``rolloff: float``, ``flatness: float``) and waveformDsp.md §Support
+descriptor types already documents it that way. This module implements
+against the already-accepted scalar shape (a single whole-spectrum summary
+computed from :func:`fft`, matching the spec/support.py that predate this
+chunk) rather than reopening ``support.py`` to switch to a per-frame
+time-series shape -- consistent with the spec's stated policy that "parity
+is judged per capability, not per Swift overload" when scipy/the existing
+Python design is the better-tested equivalent. No spec or support.py change
+was needed since both already agree with this shape; only the (stale)
+chunk-doc bullet disagreed.
+
+Imports only ``scipy``/``numpy`` plus ``dsp/_protocol.py``/``dsp/_common.py``
+and ``waveforms/support.py`` (for the enum/descriptor types) -- no sibling
+mixin imports (waveformDsp.md §Organization / §Compliance 2).
+
+**Not** ``class SpectralMixin(WaveformProtocol)``: see ``dsp/_calc.py``'s
+module docstring / waveformDsp.md §Organization for the full account of why
+mixins type ``self`` as ``WaveformProtocol`` on each method instead of
+nominally subclassing it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+from scipy.signal import get_window, welch
+from scipy.signal import spectrogram as _scipy_spectrogram
+
+from math_tools.waveforms.dsp._common import DEFAULT_KAISER_BETA, float_seconds
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import (
+    WaveformMelSpectrogram,
+    WaveformPSDScaling,
+    WaveformSpectralFeatures,
+    WaveformSpectrogram,
+    WaveformSpectrum,
+    WaveformWindowType,
+)
+
+_DEFAULT_NPERSEG = 256
+_DEFAULT_OVERLAP = 0.5
+_DEFAULT_N_MELS = 40
+_DEFAULT_ROLLOFF_FRACTION = 0.95
+
+_WINDOW_NAME_MAP: dict[WaveformWindowType, str] = {
+    WaveformWindowType.HANN: "hann",
+    WaveformWindowType.HAMMING: "hamming",
+    WaveformWindowType.BLACKMAN: "blackman",
+    WaveformWindowType.BARTLETT: "bartlett",
+    WaveformWindowType.RECTANGULAR: "boxcar",
+}
+
+
+def _scipy_window_spec(window: WaveformWindowType) -> str | tuple[str, float]:
+    """``WaveformWindowType`` -> a ``scipy.signal.get_window``-compatible spec."""
+    if window is WaveformWindowType.KAISER:
+        return ("kaiser", DEFAULT_KAISER_BETA)
+    return _WINDOW_NAME_MAP[window]
+
+
+def _window_array(window: WaveformWindowType, length: int) -> npt.NDArray[np.float64]:
+    """The concrete window coefficients for ``window`` at ``length`` samples."""
+    result: npt.NDArray[np.float64] = get_window(_scipy_window_spec(window), length)
+    return result
+
+
+def _resolve_nperseg(nperseg: int | None, sample_count: int, op_name: str) -> int:
+    """Resolve the analysis segment length: default ``min(256, sample_count)``, else
+    the caller's explicit value (validated against ``sample_count``)."""
+    if nperseg is None:
+        return min(_DEFAULT_NPERSEG, sample_count)
+    if nperseg < 1:
+        raise ValueError(f"SpectralMixin.{op_name}: nperseg must be >= 1, got {nperseg}")
+    if nperseg > sample_count:
+        raise ValueError(
+            f"SpectralMixin.{op_name}: nperseg ({nperseg}) exceeds sample_count "
+            f"({sample_count})"
+        )
+    return nperseg
+
+
+def _require_valid_overlap(overlap: float, op_name: str) -> None:
+    if not (0.0 <= overlap < 1.0):
+        raise ValueError(f"SpectralMixin.{op_name}: overlap must be in [0, 1), got {overlap}")
+
+
+def _stft_magnitude_surface(
+    values: npt.NDArray[Any],
+    fs: float,
+    window: WaveformWindowType,
+    nperseg: int,
+    overlap: float,
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """``(times, frequencies, magnitudes[time, frequency])`` via ``scipy.signal.spectrogram``.
+
+    Shared by :meth:`SpectralMixin.spectrogram` and
+    :meth:`SpectralMixin.mel_spectrogram` so both stay exactly consistent
+    about the STFT parameters and the ``[time, frequency]`` axis convention
+    (``waveforms/support.py``'s ``WaveformSpectrogram`` docstring; scipy's
+    native ``Sxx`` is ``[frequency, time]``, transposed here).
+    """
+    noverlap = int(nperseg * overlap)
+    window_array = _window_array(window, nperseg)
+    frequencies, times, sxx = _scipy_spectrogram(
+        values,
+        fs=fs,
+        window=window_array,
+        nperseg=nperseg,
+        noverlap=noverlap,
+        mode="magnitude",
+    )
+    magnitudes = np.asarray(sxx, dtype=np.float64).T
+    return (
+        np.asarray(times, dtype=np.float64),
+        np.asarray(frequencies, dtype=np.float64),
+        magnitudes,
+    )
+
+
+def _hz_to_mel(hz: float) -> float:
+    return 2595.0 * float(np.log10(1.0 + hz / 700.0))
+
+
+def _mel_to_hz(mel: npt.NDArray[np.float64]) -> npt.NDArray[np.float64]:
+    result: npt.NDArray[np.float64] = 700.0 * (10.0 ** (mel / 2595.0) - 1.0)
+    return result
+
+
+def _mel_filterbank(
+    frequency_bins_hz: npt.NDArray[np.float64],
+    n_mels: int,
+    min_frequency_hz: float,
+    max_frequency_hz: float,
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """Triangular mel filterbank: ``(filterbank, mel_center_frequencies_hz)``.
+
+    ``filterbank`` has shape ``(n_mels, len(frequency_bins_hz))``. Each row
+    is a triangle over ``[left, center, right]`` mel-spaced edges (converted
+    back to Hz), then normalized so it sums to ``~1`` whenever its support is
+    fully inside ``frequency_bins_hz`` (waveformDsp.md chunk 21's TDD step 1)
+    -- a row-sum normalization, not the usual peak-height-1 triangle or
+    Slaney-style bandwidth normalization.
+    """
+    mel_min = _hz_to_mel(min_frequency_hz)
+    mel_max = _hz_to_mel(max_frequency_hz)
+    mel_edges = np.linspace(mel_min, mel_max, n_mels + 2)
+    hz_edges = _mel_to_hz(mel_edges)
+
+    filterbank = np.zeros((n_mels, frequency_bins_hz.shape[0]), dtype=np.float64)
+    for m in range(n_mels):
+        left, center, right = hz_edges[m], hz_edges[m + 1], hz_edges[m + 2]
+        rising = (
+            (frequency_bins_hz - left) / (center - left)
+            if center > left
+            else np.zeros_like(frequency_bins_hz)
+        )
+        falling = (
+            (right - frequency_bins_hz) / (right - center)
+            if right > center
+            else np.zeros_like(frequency_bins_hz)
+        )
+        weights = np.clip(np.minimum(rising, falling), 0.0, None)
+        row_sum = float(np.sum(weights))
+        filterbank[m, :] = weights / row_sum if row_sum > 0.0 else weights
+
+    mel_centers_hz: npt.NDArray[np.float64] = hz_edges[1:-1].astype(np.float64)
+    return filterbank, mel_centers_hz
+
+
+class SpectralMixin:
+    """Adds FFT/PSD/spectrogram/mel-spectrogram/spectral-feature methods to a
+    ``WaveformProtocol`` host."""
+
+    def fft(self: WaveformProtocol) -> WaveformSpectrum:
+        """One-sided FFT (``np.fft.rfft``); frequencies in Hz from ``dt``.
+
+        Raises:
+            ValueError: If the waveform has fewer than 2 samples.
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        n = values.shape[0]
+        if n < 2:
+            raise ValueError(f"SpectralMixin.fft requires at least 2 samples, got {n}")
+        spectrum = np.fft.rfft(values)
+        frequencies = np.fft.rfftfreq(n, d=float_seconds(self.dt))
+        return WaveformSpectrum(
+            frequencies=frequencies.astype(np.float64),
+            magnitudes=np.abs(spectrum).astype(np.float64),
+            phases=np.angle(spectrum).astype(np.float64),
+        )
+
+    def power_spectral_density(
+        self: WaveformProtocol,
+        window: WaveformWindowType = WaveformWindowType.HANN,
+        scaling: WaveformPSDScaling = WaveformPSDScaling.DENSITY,
+        nperseg: int | None = None,
+    ) -> WaveformSpectrum:
+        """Welch's-method power spectral density (``scipy.signal.welch``).
+
+        ``phases`` is always all-zero: Welch's method discards phase by
+        construction (it averages the power across overlapping segments).
+
+        Raises:
+            ValueError: If the waveform has fewer than 2 samples, or
+                ``nperseg`` is out of range.
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        n = values.shape[0]
+        if n < 2:
+            raise ValueError(
+                f"SpectralMixin.power_spectral_density requires at least 2 samples, got {n}"
+            )
+        resolved_nperseg = _resolve_nperseg(nperseg, n, "power_spectral_density")
+        window_array = _window_array(window, resolved_nperseg)
+        frequencies, psd = welch(
+            values,
+            fs=self.sampling_frequency_hz,
+            window=window_array,
+            nperseg=resolved_nperseg,
+            scaling=scaling.value,
+        )
+        magnitudes = np.asarray(psd, dtype=np.float64)
+        return WaveformSpectrum(
+            frequencies=np.asarray(frequencies, dtype=np.float64),
+            magnitudes=magnitudes,
+            phases=np.zeros_like(magnitudes),
+        )
+
+    def spectrogram(
+        self: WaveformProtocol,
+        window: WaveformWindowType = WaveformWindowType.HANN,
+        nperseg: int | None = None,
+        overlap: float = _DEFAULT_OVERLAP,
+    ) -> WaveformSpectrogram:
+        """Short-time-Fourier-transform magnitude surface (``scipy.signal.spectrogram``).
+
+        Raises:
+            ValueError: If the waveform has fewer than 2 samples, ``overlap``
+                is outside ``[0, 1)``, or ``nperseg`` is out of range.
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        n = values.shape[0]
+        if n < 2:
+            raise ValueError(f"SpectralMixin.spectrogram requires at least 2 samples, got {n}")
+        _require_valid_overlap(overlap, "spectrogram")
+        resolved_nperseg = _resolve_nperseg(nperseg, n, "spectrogram")
+        times, frequencies, magnitudes = _stft_magnitude_surface(
+            values, self.sampling_frequency_hz, window, resolved_nperseg, overlap
+        )
+        return WaveformSpectrogram(times=times, frequencies=frequencies, magnitudes=magnitudes)
+
+    def mel_spectrogram(
+        self: WaveformProtocol,
+        n_mels: int = _DEFAULT_N_MELS,
+        window: WaveformWindowType = WaveformWindowType.HANN,
+        nperseg: int | None = None,
+        overlap: float = _DEFAULT_OVERLAP,
+        min_frequency_hz: float = 0.0,
+        max_frequency_hz: float | None = None,
+    ) -> WaveformMelSpectrogram:
+        """Mel-scale spectrogram: a triangular mel filterbank (hand-built, numpy)
+        applied to the STFT magnitude surface (``scipy.signal.spectrogram``-backed).
+
+        Raises:
+            ValueError: If the waveform has fewer than 2 samples, ``n_mels``
+                is < 1, ``overlap`` is outside ``[0, 1)``, ``nperseg`` is out
+                of range, or the resolved frequency band is empty/inverted.
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        n = values.shape[0]
+        if n < 2:
+            raise ValueError(
+                f"SpectralMixin.mel_spectrogram requires at least 2 samples, got {n}"
+            )
+        if n_mels < 1:
+            raise ValueError(f"SpectralMixin.mel_spectrogram: n_mels must be >= 1, got {n_mels}")
+        _require_valid_overlap(overlap, "mel_spectrogram")
+        resolved_nperseg = _resolve_nperseg(nperseg, n, "mel_spectrogram")
+        resolved_max_frequency_hz = (
+            max_frequency_hz if max_frequency_hz is not None else self.sampling_frequency_hz / 2.0
+        )
+        if resolved_max_frequency_hz <= min_frequency_hz:
+            raise ValueError(
+                "SpectralMixin.mel_spectrogram: max_frequency_hz must exceed min_frequency_hz "
+                f"(got min={min_frequency_hz}, max={resolved_max_frequency_hz})"
+            )
+
+        times, frequencies, magnitudes = _stft_magnitude_surface(
+            values, self.sampling_frequency_hz, window, resolved_nperseg, overlap
+        )
+        filterbank, mel_centers_hz = _mel_filterbank(
+            frequency_bins_hz=frequencies,
+            n_mels=n_mels,
+            min_frequency_hz=min_frequency_hz,
+            max_frequency_hz=resolved_max_frequency_hz,
+        )
+        mel_magnitudes = magnitudes @ filterbank.T
+        return WaveformMelSpectrogram(
+            times=times, mel_frequencies=mel_centers_hz, magnitudes=mel_magnitudes
+        )
+
+    def spectral_features(
+        self: WaveformProtocol, rolloff_fraction: float = _DEFAULT_ROLLOFF_FRACTION
+    ) -> WaveformSpectralFeatures:
+        """Whole-spectrum summary statistics from the FFT magnitude spectrum.
+
+        - ``centroid``: the magnitude-weighted mean frequency.
+        - ``spread``: the magnitude-weighted standard deviation around the centroid.
+        - ``rolloff``: the frequency below which ``rolloff_fraction`` of the
+          total magnitude is contained.
+        - ``flatness``: geometric-mean-over-arithmetic-mean of the magnitude
+          spectrum (Wiener entropy; ~0 = tonal, ~1 = noise-like).
+
+        See the module docstring for why this returns the scalar
+        (``centroid``/``spread``/``rolloff``/``flatness``) shape already
+        defined in ``waveforms/support.py`` rather than the Swift reference's
+        per-time-frame shape.
+
+        Raises:
+            ValueError: If the waveform has fewer than 2 samples, or
+                ``rolloff_fraction`` is outside ``(0, 1]``.
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        n = values.shape[0]
+        if n < 2:
+            raise ValueError(
+                f"SpectralMixin.spectral_features requires at least 2 samples, got {n}"
+            )
+        if not (0.0 < rolloff_fraction <= 1.0):
+            raise ValueError(
+                "SpectralMixin.spectral_features: rolloff_fraction must be in (0, 1], "
+                f"got {rolloff_fraction}"
+            )
+
+        magnitudes = np.abs(np.fft.rfft(values))
+        frequencies = np.fft.rfftfreq(n, d=float_seconds(self.dt))
+        total_energy = float(np.sum(magnitudes))
+        if total_energy <= 0.0:
+            return WaveformSpectralFeatures(centroid=0.0, spread=0.0, rolloff=0.0, flatness=0.0)
+
+        centroid = float(np.sum(frequencies * magnitudes) / total_energy)
+        spread = float(
+            np.sqrt(np.sum(magnitudes * (frequencies - centroid) ** 2) / total_energy)
+        )
+
+        cumulative = np.cumsum(magnitudes)
+        rolloff_index = int(np.searchsorted(cumulative, rolloff_fraction * total_energy))
+        rolloff_index = min(rolloff_index, frequencies.shape[0] - 1)
+        rolloff = float(frequencies[rolloff_index])
+
+        nonzero_magnitudes = magnitudes[magnitudes > 0.0]
+        if nonzero_magnitudes.size == 0:
+            flatness = 0.0
+        else:
+            geometric_mean = float(np.exp(np.mean(np.log(nonzero_magnitudes))))
+            arithmetic_mean = float(np.mean(magnitudes))
+            flatness = geometric_mean / arithmetic_mean if arithmetic_mean > 0.0 else 0.0
+
+        return WaveformSpectralFeatures(
+            centroid=centroid, spread=spread, rolloff=rolloff, flatness=flatness
+        )
+
+
+__all__ = ["SpectralMixin", "DEFAULT_KAISER_BETA"]
diff --git a/src/math_tools/waveforms/dsp/_time_alignment.py b/src/math_tools/waveforms/dsp/_time_alignment.py
new file mode 100644
index 0000000..cf2e122
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_time_alignment.py
@@ -0,0 +1,319 @@
+"""``TimeAlignmentMixin``: time-shift alignment, synchronization, and
+time-based windowing/segmentation for ``Waveform1D``.
+
+See ``.claude/specs/waveformDsp.md`` §Family contracts (``TimeAlignmentMixin``),
+§Numerical conventions, §Compliance 1-2. Swift reference:
+``Waveform1D/Extensions/Waveform1D-TimeAlignment.swift``.
+
+Backing: correlation-lag search via ``CorrelationMixin.find_max_correlation``
+(``aligned``'s ``CORRELATION`` method, ``time_lag``); plain
+``PrecisionTimestamp``/``PrecisionTimeInterval`` arithmetic for everything
+else (``aligned``'s ``START_TIME`` method, ``synchronize``, ``time_windows``,
+``time_segments``) -- per waveformDsp.md's family-contract table.
+
+**Exception to the no-sibling-imports rule ("via CorrelationMixin"), same
+shape as the risk chunk 19 flagged for ``support.py``.** This mixin needs
+``CorrelationMixin.find_max_correlation`` (``dsp/_correlation.py``) but must
+not import that module directly (waveformDsp.md §Organization / §Compliance
+2: no sibling mixin imports, enforced by
+``tests/test_package_layering.py::test_dsp_mixins_do_not_import_sibling_mixins``).
+Instead it types against a small local ``Protocol`` extension
+(``_CorrelatingWaveform`` below) declaring only the
+``find_max_correlation`` signature it calls; any host that actually
+composes both mixins (``Waveform1D`` from the compose chunk onward, and this
+module's own test subclass) satisfies it structurally. This mirrors chunk
+19's own resolution for importing ``WaveformTimeLag``/``WaveformAlignmentMethod``
+from ``waveforms/support.py`` below -- ``support.py`` imports
+``waveforms/waveform1d.py``, which (until the chunk-30 compose step) never
+imports back into ``dsp/``, so no cycle exists yet; flagged here again per
+chunk 26's own instructions, not worked around silently.
+
+``aligned``/``time_lag``/``synchronize`` are not detectors (waveformDsp.md
+§Numerical conventions): they raise ``ValueError``/``WaveformCompatibilityError``
+(naming the requirement) rather than silently returning an empty/degenerate
+result, with one deliberate exception -- ``time_lag`` returns ``None``
+(per its own ``WaveformTimeLag | None`` signature) when the strongest
+correlation match found carries exactly zero magnitude, since "no
+meaningful lag exists" is an expected outcome for that method, not an
+error. ``time_windows``/``time_segments`` likewise raise rather than
+returning `[]` when the input is too short for even one window/segment.
+
+``synchronize`` intentionally does **not** resample mismatched-rate inputs
+the way the Swift reference's ``synchronize(_:to:method:resampleToCommonRate:)``
+does -- chunk 26 §Out of scope: "Resampling to a common rate" is
+``ResamplingMixin.resampled_to_match``'s job (chunk 25), not this one's. All
+inputs to ``synchronize`` must already share the same ``dt``.
+
+Imports only ``dsp/_protocol.py``/``dsp/_common.py`` and
+``waveforms/support.py`` (for ``WaveformAlignmentMethod``/``WaveformTimeLag``)
+-- no sibling mixin imports (waveformDsp.md §Organization / §Compliance 2).
+
+**Not** ``class TimeAlignmentMixin(WaveformProtocol)``: see ``dsp/_calc.py``'s
+module docstring / waveformDsp.md §Organization for the full account of why
+mixins type ``self`` as ``WaveformProtocol`` on each method instead of
+nominally subclassing it.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Protocol
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.precision_time.precision_timestamp import PrecisionTimestamp
+from math_tools.waveforms.dsp._common import float_seconds
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformAlignmentMethod, WaveformTimeLag
+
+
+class _CorrelatingWaveform(WaveformProtocol, Protocol):
+    """``WaveformProtocol`` extended with the single ``CorrelationMixin`` method
+    (``find_max_correlation``) this mixin's ``CORRELATION``-method ``aligned``/
+    ``time_lag`` need -- declared locally instead of importing
+    ``dsp/_correlation.py`` (see the module docstring)."""
+
+    def find_max_correlation(
+        self, other: WaveformProtocol, max_lag: int | None = None
+    ) -> WaveformTimeLag: ...
+
+
+def _end_t0(waveform: WaveformProtocol) -> PrecisionTimestamp:
+    """The timestamp of ``waveform``'s last sample (``t0`` when ``sample_count <= 1``)."""
+    # int(...): `.shape[0]` on an `npt.NDArray[Any]` (the protocol's `values` type)
+    # resolves to `Any` under mypy strict; left uncast, `waveform.dt * (sample_count - 1)`
+    # and the `+` below would each become `Any`, tripping "Returning Any from function
+    # declared to return PrecisionTimestamp" (no-any-return) at the return statement.
+    sample_count = int(waveform.values.shape[0])
+    if sample_count <= 1:
+        return waveform.t0
+    return waveform.t0 + waveform.dt * (sample_count - 1)
+
+
+def _correlating_time_lag(
+    waveform: _CorrelatingWaveform, to: WaveformProtocol, max_lag: int | None
+) -> WaveformTimeLag | None:
+    """Shared implementation for ``TimeAlignmentMixin.time_lag`` and ``aligned``'s
+    ``CORRELATION`` branch -- a module-level helper (not a same-class ``self.time_lag(...)``
+    call) so both stay consistent without a mixin calling its own sibling method, matching
+    every other DSP mixin's internal-sharing convention (e.g. ``dsp/_resampling.py``'s
+    ``_resample_to_frequency``).
+
+    **Deliberately ``t0``-aware, unlike ``CorrelationMixin.find_max_correlation``.**
+    ``find_max_correlation`` is a pure value-domain measure: it correlates
+    ``waveform.values``/``to.values`` and never looks at either waveform's ``t0``
+    (see ``dsp/_correlation.py``'s module docstring). That is exactly right for a
+    "how similar are these sample arrays" question, but wrong for a method named
+    ``time_lag`` living in a mixin about time-axis reasoning -- two waveforms whose
+    ``t0``s already differ can have identical values (raw lag 0) yet clearly occur
+    at different real times. This function adds the existing ``t0`` offset (rounded
+    to the nearest sample) to the raw value-domain lag, producing the real-world
+    sample/second offset between the two waveforms' matching features. That
+    combination is also what makes ``aligned``'s ``CORRELATION`` method a true round
+    trip: shifting ``t0`` by ``-lag_samples * dt`` always drives a second call to
+    this function back to lag 0 (chunk 26's pinned acceptance criterion) -- a purely
+    value-domain lag could not guarantee that once the two waveforms' ``t0``s
+    already differ, since shifting ``t0`` never touches the values ``find_max_
+    correlation`` looks at.
+
+    Returns ``None`` when the strongest value-domain match found carries exactly
+    zero correlation magnitude (see ``time_lag``'s docstring).
+    """
+    raw = waveform.find_max_correlation(to, max_lag=max_lag)
+    if raw.correlation == 0.0:
+        return None
+    dt_seconds = float_seconds(waveform.dt)
+    existing_offset_samples = round((waveform.t0 - to.t0).seconds_as_float / dt_seconds)
+    combined_samples = existing_offset_samples + raw.lag_samples
+    return WaveformTimeLag(
+        lag_samples=combined_samples,
+        lag_seconds=combined_samples * dt_seconds,
+        correlation=raw.correlation,
+    )
+
+
+class TimeAlignmentMixin:
+    """Adds time-shift alignment, synchronization, and time windowing/segmentation
+    to a ``WaveformProtocol`` host."""
+
+    def aligned(
+        self: _CorrelatingWaveform,
+        to: WaveformProtocol,
+        method: WaveformAlignmentMethod = WaveformAlignmentMethod.CORRELATION,
+    ) -> WaveformProtocol:
+        """A copy of ``self`` with ``t0`` shifted to align with ``to``; ``values``/``dt``
+        unchanged.
+
+        ``WaveformAlignmentMethod.START_TIME`` simply adopts ``to.t0``.
+        ``WaveformAlignmentMethod.CORRELATION`` (default) shifts by the
+        lag ``time_lag(to)`` detects -- exact integer-sample arithmetic
+        (``self.dt * lag_samples``), not a float-seconds round trip -- so
+        that a subsequent ``time_lag(to)`` on the result lands back at lag
+        0. When ``time_lag`` finds no qualifying peak (returns ``None``),
+        ``self`` is returned unshifted.
+
+        Raises:
+            WaveformCompatibilityError: If ``method`` is ``CORRELATION`` and
+                ``to.dt`` differs from ``self.dt``.
+            ValueError: If ``method`` is ``CORRELATION`` and either waveform
+                has no samples.
+        """
+        if method is WaveformAlignmentMethod.START_TIME:
+            return self._with_t0(self.values, to.t0)
+        if method is WaveformAlignmentMethod.CORRELATION:
+            lag = _correlating_time_lag(self, to, max_lag=None)
+            if lag is None:
+                return self._with_values(self.values)
+            offset = self.dt * (-lag.lag_samples)
+            return self._with_t0(self.values, self.t0 + offset)
+        # pragma: no cover -- WaveformAlignmentMethod is exhaustive above
+        raise ValueError(f"TimeAlignmentMixin.aligned: unsupported method {method!r}")
+
+    def time_lag(
+        self: _CorrelatingWaveform, to: WaveformProtocol, max_lag: int | None = None
+    ) -> WaveformTimeLag | None:
+        """The real-world time lag between ``self`` and ``to``'s matching features:
+        the existing ``t0`` offset between them plus the value-domain lag
+        ``CorrelationMixin.find_max_correlation`` detects between their sample
+        arrays (see the module-level ``_correlating_time_lag`` docstring for why
+        this is ``t0``-aware, unlike ``find_max_correlation`` itself). ``None`` when
+        the strongest match found carries exactly zero correlation magnitude (e.g.
+        one of the waveforms carries no correlatable structure) -- an expected
+        "nothing to align on" outcome here, not an error.
+
+        Raises:
+            WaveformCompatibilityError: If ``to.dt`` differs from ``self.dt``.
+            ValueError: If either waveform has no samples, or ``max_lag`` is negative.
+        """
+        return _correlating_time_lag(self, to, max_lag)
+
+    @classmethod
+    def synchronize(cls, waveforms: Sequence[WaveformProtocol]) -> list[WaveformProtocol]:
+        """The common overlapping time span of ``waveforms``, sliced from each input.
+
+        Every result shares the same ``dt``, the same ``t0`` (the overlap's
+        start), and the same sample count. Unlike the Swift reference, this
+        does not resample mismatched-rate inputs first (see the module
+        docstring) -- every input must already share the same ``dt``.
+
+        Returns ``[]`` for an empty ``waveforms`` sequence.
+
+        Raises:
+            WaveformCompatibilityError: If the waveforms do not all share the same ``dt``.
+            ValueError: If any waveform has no samples, or the waveforms share
+                no overlapping time span.
+        """
+        if not waveforms:
+            return []
+
+        reference_dt = waveforms[0].dt
+        for waveform in waveforms:
+            if waveform.dt != reference_dt:
+                raise WaveformCompatibilityError(
+                    f"TimeAlignmentMixin.synchronize: dt mismatch "
+                    f"({reference_dt!r} vs {waveform.dt!r})"
+                )
+            if waveform.values.shape[0] == 0:
+                raise ValueError(
+                    "TimeAlignmentMixin.synchronize requires every waveform to have "
+                    "at least 1 sample"
+                )
+
+        overlap_start = max(waveform.t0 for waveform in waveforms)
+        overlap_end = min(_end_t0(waveform) for waveform in waveforms)
+        if overlap_end < overlap_start:
+            raise ValueError(
+                "TimeAlignmentMixin.synchronize: waveforms share no overlapping time span"
+            )
+        overlap_sample_count = round((overlap_end - overlap_start) / reference_dt) + 1
+
+        synchronized: list[WaveformProtocol] = []
+        for waveform in waveforms:
+            start_index = round((overlap_start - waveform.t0) / reference_dt)
+            segment = waveform.values[start_index : start_index + overlap_sample_count]
+            synchronized.append(waveform._with_t0(segment, overlap_start))
+        return synchronized
+
+    def time_windows(
+        self: WaveformProtocol, window_duration: float, overlap: float = 0.0
+    ) -> list[WaveformProtocol]:
+        """Overlapping fixed-length windows of ``window_duration`` seconds, stepping by
+        ``window_duration * (1 - overlap)``; only full-length windows are kept (a
+        trailing remainder shorter than a full window is dropped).
+
+        Raises:
+            ValueError: If ``window_duration <= 0``, ``overlap`` is outside
+                ``[0.0, 1.0)``, or the waveform has fewer samples than one window
+                needs.
+        """
+        if window_duration <= 0.0:
+            raise ValueError(
+                f"TimeAlignmentMixin.time_windows: window_duration must be > 0, "
+                f"got {window_duration}"
+            )
+        if not 0.0 <= overlap < 1.0:
+            raise ValueError(
+                f"TimeAlignmentMixin.time_windows: overlap must be in [0.0, 1.0), "
+                f"got {overlap}"
+            )
+        dt_seconds = float_seconds(self.dt)
+        window_samples = max(1, round(window_duration / dt_seconds))
+        sample_count = self.values.shape[0]
+        if window_samples > sample_count:
+            raise ValueError(
+                f"TimeAlignmentMixin.time_windows requires at least {window_samples} samples "
+                f"for a {window_duration}s window at dt={dt_seconds}s, got {sample_count}"
+            )
+        step_samples = max(1, round(window_samples * (1.0 - overlap)))
+
+        windows: list[WaveformProtocol] = []
+        start = 0
+        while start + window_samples <= sample_count:
+            segment = self.values[start : start + window_samples]
+            windows.append(self._with_t0(segment, self.t0 + self.dt * start))
+            start += step_samples
+        return windows
+
+    def time_segments(
+        self: WaveformProtocol, boundaries: Sequence[float]
+    ) -> list[WaveformProtocol]:
+        """Non-overlapping segments split at ``boundaries`` (strictly increasing float
+        seconds from ``t0``); an empty ``boundaries`` returns ``[self]`` unsplit.
+
+        Raises:
+            ValueError: If the waveform has no samples, or ``boundaries`` is not
+                strictly increasing and within the waveform's open time span
+                (``(0, duration_seconds)``), or two boundaries round to the same
+                sample index (a zero-length segment).
+        """
+        sample_count = self.values.shape[0]
+        if sample_count == 0:
+            raise ValueError("TimeAlignmentMixin.time_segments requires at least 1 sample")
+        dt_seconds = float_seconds(self.dt)
+        duration_seconds = (sample_count - 1) * dt_seconds
+
+        boundary_indices: list[int] = []
+        previous_seconds = 0.0
+        for boundary_seconds in boundaries:
+            if not (previous_seconds < boundary_seconds < duration_seconds):
+                raise ValueError(
+                    f"TimeAlignmentMixin.time_segments: boundaries must be strictly "
+                    f"increasing and within (0, {duration_seconds}), got {boundary_seconds}"
+                )
+            index = round(boundary_seconds / dt_seconds)
+            if boundary_indices and index <= boundary_indices[-1]:
+                raise ValueError(
+                    "TimeAlignmentMixin.time_segments: boundaries round to a "
+                    "zero-length segment"
+                )
+            boundary_indices.append(index)
+            previous_seconds = boundary_seconds
+
+        split_points = [0, *boundary_indices, sample_count]
+        segments: list[WaveformProtocol] = []
+        for start, stop in zip(split_points, split_points[1:], strict=False):
+            segment = self.values[start:stop]
+            segments.append(self._with_t0(segment, self.t0 + self.dt * start))
+        return segments
+
+
+__all__ = ["TimeAlignmentMixin"]
diff --git a/src/math_tools/waveforms/dsp/_triggers.py b/src/math_tools/waveforms/dsp/_triggers.py
new file mode 100644
index 0000000..8de4944
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_triggers.py
@@ -0,0 +1,396 @@
+"""``TriggerMixin``: edge/level/window/pattern trigger detection and event
+marking for ``Waveform1D``.
+
+See ``.claude/specs/waveformDsp.md`` §Family contracts (``TriggerMixin``),
+§Numerical conventions, §Compliance 1-2. Swift reference:
+``Waveform1D/Extensions/Waveform1D-TriggerDetection.swift``.
+
+Backing: numpy comparisons + sign-change indexing, per waveformDsp.md's
+family-contract table -- not the Swift extension's hand-rolled state
+machine, which the extension's own comments admit is "simplified" (e.g.
+``evaluateEdgeTrigger``'s ``.both`` case literally returns ``true``
+unconditionally, "would need state tracking"). This module implements the
+chunk's own design constraint directly instead: edge/level triggers are
+genuine sign changes of ``values - level`` (``RISING``: crosses from
+``<= 0`` to ``> 0``; ``FALLING``: the reverse; ``BOTH``: either), window
+triggers are enter/exit transitions of the ``[low, high]`` band, and
+pattern triggers are a sliding-window elementwise-tolerance match
+(``max(abs(segment - pattern)) <= tolerance``) -- deterministic and exact,
+unlike the Swift extension's normalized-correlation ``threshold`` (the spec
+explicitly allows this: "parity is judged per capability, not per Swift
+overload... scipy semantics win" applies equally to the better-tested/
+better-specified numpy equivalent here).
+
+All four ``detect_*`` methods are detectors (waveformDsp.md §Numerical
+conventions): they return ``[]`` on no-hit (empty/too-short waveform, an
+out-of-range band, a pattern longer than the waveform, ...) rather than
+raising -- there is deliberately no separate "invalid input" guard clause
+for these, since every out-of-range input degrades naturally to zero
+qualifying samples. ``detect_triggers`` (the generic ``WaveformTrigger``-
+driven dispatcher) is the one exception: it raises ``ValueError`` when the
+fields its ``trigger.kind`` requires are missing (``level`` for ``EDGE``/
+``LEVEL``, ``lower``/``upper`` for ``WINDOW``, ``pattern``/``tolerance`` for
+``PATTERN``) -- a malformed ``WaveformTrigger`` is a programmer error, not
+"no samples matched".
+
+``detect_level_triggers`` shares ``detect_edge_triggers``'s sign-change
+machinery (same private ``_sign_change_events`` helper, parametrized by the
+``WaveformTriggerType`` tag stamped onto the resulting events) rather than
+introducing a separate "level" concept -- the spec's ``WaveformTriggerType``
+distinguishes ``EDGE``/``LEVEL`` as a provenance tag, not a different
+detection algorithm, and the Swift reference's own ``evaluateLevelTrigger``
+is likewise just a threshold comparison. It defaults to ``RISING`` (crossing
+up into "at/above `level`") where ``detect_edge_triggers`` defaults to
+``BOTH``, matching the "a level trigger fires once you're at/above this
+level" reading distinct from "an edge trigger fires on either transition".
+
+``detect_triggers``'s dispatch for ``EDGE``/``LEVEL``/``WINDOW`` needs a
+direction/enter-exit selector that ``WaveformTrigger`` did not carry before
+this chunk; see ``waveforms/support.py``'s module docstring ("Forced
+contract change (chunk 27)") for the two optional fields
+(``edge``/``window_kind``) added to carry it, defaulting to ``BOTH``/
+``RISING``/``ENTER`` respectively when the caller leaves them unset (i.e.
+``detect_triggers`` and the direct methods agree on defaults).
+
+**``detect_triggers`` calls the same private module-level helpers the direct
+``detect_*`` methods call, never ``self.detect_edge_triggers(...)`` etc.**
+Every method here types ``self`` as ``WaveformProtocol`` (see below), which
+only declares the *host*'s surface (``values``/``dt``/``t0``/factories) --
+not this mixin's own sibling methods, so a same-class ``self.detect_edge_
+triggers(...)`` call would not type-check under mypy strict (no such
+attribute on ``WaveformProtocol``). This mirrors ``dsp/_time_alignment.py``'s
+``_correlating_time_lag`` and ``dsp/_resampling.py``'s
+``_resample_to_frequency``: shared logic between two public methods of the
+same mixin lives in a private module-level function that both call, not one
+public method calling another via ``self``.
+
+``with_event_markers`` is the first mixin method that embeds ``self``
+itself into a returned descriptor; see ``waveforms/support.py``'s module
+docstring for why ``WaveformWithEvents.waveform`` is typed
+``WaveformProtocol`` rather than concrete ``Waveform1D`` as a result.
+
+Imports only ``numpy`` plus ``dsp/_protocol.py``/``dsp/_common.py`` and
+``waveforms/support.py`` -- no sibling mixin imports (waveformDsp.md
+§Organization / §Compliance 2).
+
+**Not** ``class TriggerMixin(WaveformProtocol)``: see ``dsp/_calc.py``'s
+module docstring / waveformDsp.md §Organization for the full account of why
+mixins type ``self`` as ``WaveformProtocol`` on each method instead of
+nominally subclassing it.
+"""
+
+from __future__ import annotations
+
+from collections.abc import Sequence
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.waveforms.dsp._common import float_seconds
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import (
+    WaveformEdgeType,
+    WaveformEventMarker,
+    WaveformTrigger,
+    WaveformTriggerEvent,
+    WaveformTriggerType,
+    WaveformWindowTriggerType,
+    WaveformWithEvents,
+)
+
+
+def _events_from_indices(
+    indices: npt.NDArray[Any],
+    values: npt.NDArray[Any],
+    dt: PrecisionTimeInterval,
+    dt_seconds: float,
+    kind: WaveformTriggerType,
+    minimum_interval: PrecisionTimeInterval | None,
+) -> list[WaveformTriggerEvent]:
+    """Build ``WaveformTriggerEvent``s from candidate sample ``indices``, dropping any
+    that fall within ``minimum_interval`` of the previously emitted event (dedup, per
+    the Swift reference's ``lastTriggerIndex``/``minInterval`` bookkeeping)."""
+    events: list[WaveformTriggerEvent] = []
+    last_index: int | None = None
+    for raw_index in indices:
+        index = int(raw_index)
+        if minimum_interval is not None and last_index is not None:
+            elapsed = dt * (index - last_index)
+            if elapsed < minimum_interval:
+                continue
+        events.append(
+            WaveformTriggerEvent(
+                index=index,
+                time_seconds=index * dt_seconds,
+                value=float(values[index]),
+                kind=kind,
+            )
+        )
+        last_index = index
+    return events
+
+
+def _sign_change_events(
+    values: npt.NDArray[Any],
+    dt: PrecisionTimeInterval,
+    dt_seconds: float,
+    level: float,
+    edge: WaveformEdgeType,
+    kind: WaveformTriggerType,
+    minimum_interval: PrecisionTimeInterval | None,
+) -> list[WaveformTriggerEvent]:
+    """Sample indices where ``values - level`` changes sign, filtered by ``edge``
+    direction -- the shared implementation behind ``detect_edge_triggers`` and
+    ``detect_level_triggers`` (see module docstring)."""
+    if values.shape[0] < 2:
+        return []
+    shifted = values - level
+    previous = shifted[:-1]
+    current = shifted[1:]
+    rising = (previous <= 0.0) & (current > 0.0)
+    falling = (previous >= 0.0) & (current < 0.0)
+    if edge is WaveformEdgeType.RISING:
+        mask = rising
+    elif edge is WaveformEdgeType.FALLING:
+        mask = falling
+    else:
+        mask = rising | falling
+    # +1: the mask is computed over the (n-1)-length pair array `previous`/`current`,
+    # so a `True` at position i marks the crossing landing on original index i+1.
+    candidate_indices = np.flatnonzero(mask) + 1
+    return _events_from_indices(candidate_indices, values, dt, dt_seconds, kind, minimum_interval)
+
+
+def _window_trigger_events(
+    values: npt.NDArray[Any],
+    dt: PrecisionTimeInterval,
+    dt_seconds: float,
+    low: float,
+    high: float,
+    kind: WaveformWindowTriggerType,
+    minimum_interval: PrecisionTimeInterval | None,
+) -> list[WaveformTriggerEvent]:
+    """Sample indices where membership in the inclusive ``[low, high]`` band
+    transitions -- ``ENTER``: outside -> inside, ``EXIT``: inside -> outside. The
+    shared implementation behind ``detect_window_triggers`` (see module docstring)."""
+    if values.shape[0] < 2:
+        return []
+    inside = (values >= low) & (values <= high)
+    previous_inside = inside[:-1]
+    current_inside = inside[1:]
+    if kind is WaveformWindowTriggerType.ENTER:
+        mask = (~previous_inside) & current_inside
+    else:
+        mask = previous_inside & (~current_inside)
+    candidate_indices = np.flatnonzero(mask) + 1
+    return _events_from_indices(
+        candidate_indices, values, dt, dt_seconds, WaveformTriggerType.WINDOW, minimum_interval
+    )
+
+
+def _pattern_trigger_events(
+    values: npt.NDArray[Any],
+    dt: PrecisionTimeInterval,
+    dt_seconds: float,
+    pattern: Sequence[float],
+    tolerance: float,
+    minimum_interval: PrecisionTimeInterval | None,
+) -> list[WaveformTriggerEvent]:
+    """Start indices of sliding windows matching ``pattern`` within ``tolerance``
+    (``max(abs(segment - pattern)) <= tolerance``). The shared implementation behind
+    ``detect_pattern_triggers`` (see module docstring)."""
+    pattern_arr = np.asarray(pattern, dtype=np.float64)
+    pattern_length = pattern_arr.shape[0]
+    if pattern_length == 0 or pattern_length > values.shape[0]:
+        return []
+    windows = np.lib.stride_tricks.sliding_window_view(values, pattern_length)
+    max_abs_diff = np.max(np.abs(windows - pattern_arr), axis=1)
+    candidate_indices = np.flatnonzero(max_abs_diff <= tolerance)
+    return _events_from_indices(
+        candidate_indices, values, dt, dt_seconds, WaveformTriggerType.PATTERN, minimum_interval
+    )
+
+
+class TriggerMixin:
+    """Adds edge/level/window/pattern trigger detection and event marking to a
+    ``WaveformProtocol`` host."""
+
+    def detect_edge_triggers(
+        self: WaveformProtocol,
+        level: float,
+        edge: WaveformEdgeType = WaveformEdgeType.BOTH,
+        minimum_interval: PrecisionTimeInterval | None = None,
+    ) -> list[WaveformTriggerEvent]:
+        """Sign-change crossings of ``values - level``: ``RISING`` fires where the
+        previous sample was ``<= level`` and the current sample is ``> level``,
+        ``FALLING`` the reverse, ``BOTH`` (default) either. Event ``index``/
+        ``time_seconds`` mark the sample landing on the crossing.
+
+        Returns ``[]`` for a waveform with fewer than 2 samples or no qualifying
+        crossing -- never raises (detector, per waveformDsp.md §Numerical
+        conventions).
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        dt_seconds = float_seconds(self.dt)
+        return _sign_change_events(
+            values, self.dt, dt_seconds, level, edge, WaveformTriggerType.EDGE, minimum_interval
+        )
+
+    def detect_level_triggers(
+        self: WaveformProtocol,
+        level: float,
+        edge: WaveformEdgeType = WaveformEdgeType.RISING,
+        minimum_interval: PrecisionTimeInterval | None = None,
+    ) -> list[WaveformTriggerEvent]:
+        """Sign-change crossings of ``values - level``, same mechanics as
+        ``detect_edge_triggers`` (default ``RISING``: fires on crossing up to
+        at/above ``level``) but stamped with ``WaveformTriggerType.LEVEL``.
+
+        Returns ``[]`` for a waveform with fewer than 2 samples or no qualifying
+        crossing -- never raises (detector, per waveformDsp.md §Numerical
+        conventions).
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        dt_seconds = float_seconds(self.dt)
+        return _sign_change_events(
+            values, self.dt, dt_seconds, level, edge, WaveformTriggerType.LEVEL, minimum_interval
+        )
+
+    def detect_window_triggers(
+        self: WaveformProtocol,
+        low: float,
+        high: float,
+        kind: WaveformWindowTriggerType,
+        minimum_interval: PrecisionTimeInterval | None = None,
+    ) -> list[WaveformTriggerEvent]:
+        """Enter/exit transitions of the inclusive ``[low, high]`` band: ``ENTER``
+        fires where the previous sample was outside the band and the current
+        sample is inside it, ``EXIT`` the reverse.
+
+        Returns ``[]`` for a waveform with fewer than 2 samples, ``low > high``,
+        or no qualifying transition -- never raises (detector, per
+        waveformDsp.md §Numerical conventions).
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        dt_seconds = float_seconds(self.dt)
+        return _window_trigger_events(
+            values, self.dt, dt_seconds, low, high, kind, minimum_interval
+        )
+
+    def detect_pattern_triggers(
+        self: WaveformProtocol,
+        pattern: Sequence[float],
+        tolerance: float,
+        minimum_interval: PrecisionTimeInterval | None = None,
+    ) -> list[WaveformTriggerEvent]:
+        """Sliding-window elementwise match: a window starting at sample ``i``
+        qualifies when ``max(abs(values[i:i+len(pattern)] - pattern)) <= tolerance``.
+        Event ``index``/``time_seconds`` mark the start of the matching window.
+
+        Returns ``[]`` when ``pattern`` is empty, longer than the waveform, or no
+        window qualifies -- never raises (detector, per waveformDsp.md §Numerical
+        conventions).
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        dt_seconds = float_seconds(self.dt)
+        return _pattern_trigger_events(
+            values, self.dt, dt_seconds, pattern, tolerance, minimum_interval
+        )
+
+    def detect_triggers(
+        self: WaveformProtocol, trigger: WaveformTrigger
+    ) -> list[WaveformTriggerEvent]:
+        """Dispatch on ``trigger.kind`` to the matching sign-change/window/pattern
+        computation above, reading its arguments from ``trigger``'s fields
+        (``level``, ``lower``/``upper``, ``pattern``/``tolerance``,
+        ``minimum_interval``, and the ``edge``/``window_kind`` direction
+        selectors -- see module docstring).
+
+        Raises:
+            ValueError: If ``trigger.kind`` is missing the field(s) its detection
+                requires, or is not a recognized ``WaveformTriggerType`` member.
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        dt_seconds = float_seconds(self.dt)
+
+        if trigger.kind is WaveformTriggerType.EDGE:
+            if trigger.level is None:
+                raise ValueError("TriggerMixin.detect_triggers: EDGE trigger requires 'level'")
+            edge = trigger.edge if trigger.edge is not None else WaveformEdgeType.BOTH
+            return _sign_change_events(
+                values,
+                self.dt,
+                dt_seconds,
+                trigger.level,
+                edge,
+                WaveformTriggerType.EDGE,
+                trigger.minimum_interval,
+            )
+        if trigger.kind is WaveformTriggerType.LEVEL:
+            if trigger.level is None:
+                raise ValueError("TriggerMixin.detect_triggers: LEVEL trigger requires 'level'")
+            edge = trigger.edge if trigger.edge is not None else WaveformEdgeType.RISING
+            return _sign_change_events(
+                values,
+                self.dt,
+                dt_seconds,
+                trigger.level,
+                edge,
+                WaveformTriggerType.LEVEL,
+                trigger.minimum_interval,
+            )
+        if trigger.kind is WaveformTriggerType.WINDOW:
+            if trigger.lower is None or trigger.upper is None:
+                raise ValueError(
+                    "TriggerMixin.detect_triggers: WINDOW trigger requires 'lower' and 'upper'"
+                )
+            window_kind = (
+                trigger.window_kind
+                if trigger.window_kind is not None
+                else WaveformWindowTriggerType.ENTER
+            )
+            return _window_trigger_events(
+                values,
+                self.dt,
+                dt_seconds,
+                trigger.lower,
+                trigger.upper,
+                window_kind,
+                trigger.minimum_interval,
+            )
+        if trigger.kind is WaveformTriggerType.PATTERN:
+            if trigger.pattern is None or trigger.tolerance is None:
+                raise ValueError(
+                    "TriggerMixin.detect_triggers: PATTERN trigger requires 'pattern' "
+                    "and 'tolerance'"
+                )
+            return _pattern_trigger_events(
+                values,
+                self.dt,
+                dt_seconds,
+                trigger.pattern,
+                trigger.tolerance,
+                trigger.minimum_interval,
+            )
+        # pragma: no cover -- WaveformTriggerType is exhaustive above
+        raise ValueError(f"TriggerMixin.detect_triggers: unsupported kind {trigger.kind!r}")
+
+    def with_event_markers(
+        self: WaveformProtocol, events: Sequence[WaveformTriggerEvent]
+    ) -> WaveformWithEvents:
+        """Pair ``self`` with a marker per ``events`` entry (``label`` is the
+        event's ``kind`` value, e.g. ``"edge"``).
+
+        ``events`` is typically the result of one of this mixin's ``detect_*``
+        methods, but any ``WaveformTriggerEvent`` sequence works. An empty
+        ``events`` yields ``WaveformWithEvents`` with no markers (not an error).
+        """
+        markers = tuple(
+            WaveformEventMarker(index=event.index, label=event.kind.value) for event in events
+        )
+        return WaveformWithEvents(waveform=self, events=markers)
+
+
+__all__ = ["TriggerMixin"]
diff --git a/src/math_tools/waveforms/dsp/_windowing.py b/src/math_tools/waveforms/dsp/_windowing.py
new file mode 100644
index 0000000..9717edc
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_windowing.py
@@ -0,0 +1,167 @@
+"""``WindowingMixin``: user-facing window-function utilities for ``Waveform1D``.
+
+See ``.claude/specs/waveformDsp.md`` §Family contracts (``WindowingMixin``),
+§Window convention, §Numerical conventions, §Compliance 1-2. Swift reference:
+``Waveform1D/Extensions/Waveform1D-Windowing.swift``.
+
+Backing: ``scipy.signal.get_window``, **symmetric** (``fftbins=False``) by
+default -- matching the Swift reference's own ``n - 1``-denominator formulas,
+where a finite-length window's first and last samples are exactly the
+window's edge value and (for an odd length) the true midpoint sample is
+exactly the window's peak. scipy's periodic/``fftbins=True`` convention is
+built for STFT frame tiling -- ``SpectralMixin``'s own use (``dsp/_spectral.py``),
+not this module's default.
+
+**Reconciled seam (chunk 53).** Post-audit finding D-windowing-(c): this
+module's default (symmetric) and ``SpectralMixin``'s internal window use
+(periodic) are genuinely different conventions, so a caller who used
+``window_coherent_gain``/``window_processing_gain`` to correct a
+``power_spectral_density``/``spectrogram`` estimate got a subtly wrong scale
+factor -- the gain helpers described a different window than the one scipy
+actually applied. Per waveformDsp.md's window-convention section, both
+conventions stay legitimate and the per-family defaults are unchanged; the
+fix is an explicit ``periodic: bool = False`` parameter on
+``generate_window`` and both gain helpers so a caller correcting a
+periodic-windowed spectral estimate can request the exact matching
+convention (``periodic=True`` == ``fftbins=True`` == what ``SpectralMixin``
+applies). ``windowed`` keeps the symmetric default only -- applying a window
+to a whole waveform (filter design / analysis framing) is this module's own
+use case, not a PSD-correction helper.
+
+**Distinct, non-overlapping surface from ``SpectralMixin``'s internal STFT
+window use.** ``dsp/_spectral.py`` (chunk 21) already maps
+``WaveformWindowType`` to concrete scipy window arrays directly inside that
+module, per that chunk's own design constraint that this module's helpers
+are for "user-facing window utilities", not a dependency of chunk 21's. The
+two modules intentionally duplicate the small enum->scipy-name mapping
+rather than share one (waveformDsp.md §Organization / §Compliance 2 forbid a
+sibling mixin import here regardless) -- but the Kaiser beta shape parameter
+is now a single shared constant (``dsp/_common.DEFAULT_KAISER_BETA``,
+chunk 53) imported by both, closing the drift risk of two independent
+literals.
+
+``WaveformWindowType.KAISER`` carries no ``beta`` field (the type is a flat
+``str`` enum, unlike the Swift reference's ``.kaiser(beta:)`` associated
+value) and ``generate_window``'s signature exposes none either -- see
+``dsp/_common.py``'s docstring for why chunk 53 kept the flat enum
+(exposing beta would force an enum redesign) rather than closing that gap.
+YAGNI: expose ``beta`` directly only if a caller ever needs to vary it.
+
+Imports only ``scipy``/``numpy`` plus ``dsp/_protocol.py``/``dsp/_common.py``
+and ``waveforms/support.py`` (for ``WaveformWindowType``) -- no sibling
+mixin imports (waveformDsp.md §Organization / §Compliance 2).
+
+**Not** ``class WindowingMixin(WaveformProtocol)``: see ``dsp/_calc.py``'s
+module docstring / waveformDsp.md §Organization for the full account of why
+mixins type ``self`` as ``WaveformProtocol`` on each method instead of
+nominally subclassing it.
+"""
+
+from __future__ import annotations
+
+import numpy as np
+import numpy.typing as npt
+from scipy.signal import get_window
+
+from math_tools.waveforms.dsp._common import DEFAULT_KAISER_BETA
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformWindowType
+
+_WINDOW_NAME_MAP: dict[WaveformWindowType, str] = {
+    WaveformWindowType.HANN: "hann",
+    WaveformWindowType.HAMMING: "hamming",
+    WaveformWindowType.BLACKMAN: "blackman",
+    WaveformWindowType.BARTLETT: "bartlett",
+    WaveformWindowType.RECTANGULAR: "boxcar",
+}
+
+
+def _scipy_window_spec(window: WaveformWindowType) -> str | tuple[str, float]:
+    """``WaveformWindowType`` -> a ``scipy.signal.get_window``-compatible spec."""
+    if window is WaveformWindowType.KAISER:
+        return ("kaiser", DEFAULT_KAISER_BETA)
+    return _WINDOW_NAME_MAP[window]
+
+
+class WindowingMixin:
+    """Adds window-function generation and application to a ``WaveformProtocol`` host."""
+
+    @staticmethod
+    def generate_window(
+        window: WaveformWindowType, length: int, periodic: bool = False
+    ) -> npt.NDArray[np.float64]:
+        """The ``length``-sample coefficient array for ``window``.
+
+        ``periodic`` selects the convention: ``False`` (default) is the
+        symmetric convention (``scipy.signal.get_window(..., fftbins=False)``);
+        ``True`` is the periodic convention (``fftbins=True``) that
+        ``SpectralMixin.power_spectral_density``/``spectrogram`` actually
+        apply internally, for a caller correcting a periodic-windowed
+        spectral estimate.
+
+        Raises:
+            ValueError: If ``length`` is not a positive integer.
+        """
+        if length <= 0:
+            raise ValueError(f"WindowingMixin.generate_window requires length > 0, got {length}")
+        result: npt.NDArray[np.float64] = get_window(
+            _scipy_window_spec(window), length, fftbins=periodic
+        )
+        return result
+
+    def windowed(self: WaveformProtocol, window: WaveformWindowType) -> WaveformProtocol:
+        """A copy of ``self`` with ``window``'s coefficients applied elementwise
+        (``dt``/``t0`` unchanged). Always the symmetric convention (this
+        module's own use case, not a spectral-estimate correction).
+
+        Raises:
+            ValueError: If the waveform has no samples.
+        """
+        sample_count = self.values.shape[0]
+        if sample_count == 0:
+            raise ValueError("WindowingMixin.windowed requires at least 1 sample, got 0")
+        coefficients = WindowingMixin.generate_window(window, sample_count)
+        return self._with_values(self.values * coefficients)
+
+    def window_coherent_gain(
+        self: WaveformProtocol, window: WaveformWindowType, periodic: bool = False
+    ) -> float:
+        """The coherent gain (mean) of ``window``'s coefficients at ``self``'s length.
+
+        ``periodic`` (default ``False``, symmetric) selects the convention;
+        pass ``periodic=True`` to describe the exact window
+        ``power_spectral_density``/``spectrogram`` apply internally.
+
+        Raises:
+            ValueError: If the waveform has no samples.
+        """
+        sample_count = self.values.shape[0]
+        if sample_count == 0:
+            raise ValueError(
+                "WindowingMixin.window_coherent_gain requires at least 1 sample, got 0"
+            )
+        coefficients = WindowingMixin.generate_window(window, sample_count, periodic=periodic)
+        return float(np.mean(coefficients))
+
+    def window_processing_gain(
+        self: WaveformProtocol, window: WaveformWindowType, periodic: bool = False
+    ) -> float:
+        """The processing gain (RMS) of ``window``'s coefficients at ``self``'s length.
+
+        ``periodic`` (default ``False``, symmetric) selects the convention;
+        pass ``periodic=True`` to describe the exact window
+        ``power_spectral_density``/``spectrogram`` apply internally.
+
+        Raises:
+            ValueError: If the waveform has no samples.
+        """
+        sample_count = self.values.shape[0]
+        if sample_count == 0:
+            raise ValueError(
+                "WindowingMixin.window_processing_gain requires at least 1 sample, got 0"
+            )
+        coefficients = WindowingMixin.generate_window(window, sample_count, periodic=periodic)
+        return float(np.sqrt(np.mean(coefficients**2)))
+
+
+__all__ = ["WindowingMixin", "DEFAULT_KAISER_BETA"]
diff --git a/src/math_tools/waveforms/dsp/_zero_crossings.py b/src/math_tools/waveforms/dsp/_zero_crossings.py
new file mode 100644
index 0000000..750d8c5
--- /dev/null
+++ b/src/math_tools/waveforms/dsp/_zero_crossings.py
@@ -0,0 +1,213 @@
+"""``ZeroCrossingMixin``: sign-change detection with sub-sample linear
+interpolation, rate, and crossing-delimited segmentation for ``Waveform1D``.
+
+See ``.claude/specs/waveformDsp.md`` §Family contracts (``ZeroCrossingMixin``),
+§Numerical conventions, §Compliance 1-2. Swift reference:
+``Waveform1D/Extensions/Waveform1D-ZeroX.swift``.
+
+Backing: numpy sign-change indexing (the same ``previous``/``current`` mask
+technique ``dsp/_triggers.py``'s ``_sign_change_events`` uses for
+``level=0``) plus a sub-sample linear-interpolation refinement step for
+``time_seconds`` -- per waveformDsp.md's family-contract table
+("numpy sign-change indexing, sub-sample linear interp"). This diverges from
+the Swift reference's ``threshold``-parametrized "is this sample close
+enough to zero to ignore" scheme: the Python surface has no ``threshold``
+argument (not listed in the governing chunk's Design constraints), so a
+crossing is a strict sign change of ``values`` against exactly ``0.0``.
+"Exact zeros count once" (the chunk's own design constraint) falls out of
+using the same *non-strict-on-the-departed-side* comparison
+``_triggers.py`` uses (``previous <= 0 & current > 0`` for a rising
+crossing, the mirror for falling): a sample sitting exactly on zero is the
+"``<= 0``"/"``>= 0``" side of both its neighboring pairs, so it can only
+ever complete one crossing, never start a second one.
+
+``WaveformZeroCrossing.direction`` (``waveforms/support.py``) reuses
+``WaveformZeroCrossingDirection`` itself (``POSITIVE``/``NEGATIVE``/``BOTH``)
+rather than the Swift reference's separate ``WaveformZeroCrossingType``
+(``rising``/``falling``) -- a single enum with a ``BOTH`` query filter and a
+POSITIVE-or-NEGATIVE-per-event tag, matching this repo's existing convention
+of query/result enums doing double duty (e.g. ``WaveformEdgeType`` on
+``dsp/_triggers.py``, though that one keeps ``BOTH`` as a query-only value
+too -- no completed crossing event is ever literally "both").
+
+``zero_crossings`` is the family's one detector (waveformDsp.md §Numerical
+conventions: "detectors (``detect_*``, ``zero_crossings``) ... return empty
+lists on no-hit") -- empty/too-short input yields ``[]``, never raises.
+``zero_crossing_count``/``zero_crossing_rate`` are built directly on top of
+it and inherit that empty-result contract (0 / 0.0 respectively; ``rate``
+additionally guards a non-positive duration, mirroring the Swift
+reference's ``guard totalDuration > 0 else { return 0.0 }``).
+``zero_crossing_count``/``zero_crossing_rate`` both grew an optional
+``direction`` parameter (default ``BOTH``) beyond the governing chunk's
+literal ``zero_crossing_rate() -> float`` signature, for parity with the
+Swift reference's ``zeroCrossingRate(direction:)`` overload and with this
+mixin's own ``zero_crossings(direction=...)`` -- a backward-compatible
+superset (every call site the chunk names, ``zero_crossing_rate()``, still
+works unchanged), not a contract narrowing, so no spec bump is needed.
+
+``segments_between_zero_crossings`` mirrors the Swift reference's
+*inclusive*-range segmentation (``values[startIdx...endIdx]``) rather than
+``dsp/_time_alignment.py``'s exclusive, non-overlapping
+``time_segments``/``time_windows`` split: each interior zero-crossing
+sample is deliberately shared by the two segments it borders, so the
+segments' length sum slightly *overshoots* the source sample count (one
+extra sample per interior boundary) -- exactly the "lengths sum to ~= n"
+(not "``== n``") the governing chunk's own TDD step names. Always includes
+the leading/trailing partial segments (no ``includePartial`` flag, unlike
+the Swift reference -- not in the governing chunk's Design constraints);
+an empty waveform raises ``ValueError`` (there is nothing to segment, not a
+detector no-hit), while a single-sample or crossing-free waveform each
+degrade to the one segment that already covers all the data.
+
+Imports only ``numpy`` plus ``dsp/_protocol.py``/``dsp/_common.py`` and
+``waveforms/support.py`` -- no sibling mixin imports (waveformDsp.md
+§Organization / §Compliance 2).
+
+**Not** ``class ZeroCrossingMixin(WaveformProtocol)``: see ``dsp/_calc.py``'s
+module docstring / waveformDsp.md §Organization for the full account of why
+mixins type ``self`` as ``WaveformProtocol`` on each method instead of
+nominally subclassing it.
+"""
+
+from __future__ import annotations
+
+from typing import Any
+
+import numpy as np
+import numpy.typing as npt
+
+from math_tools.waveforms.dsp._common import float_seconds
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformZeroCrossing, WaveformZeroCrossingDirection
+
+
+def _zero_crossing_events(
+    values: npt.NDArray[Any],
+    dt_seconds: float,
+    direction: WaveformZeroCrossingDirection,
+) -> list[WaveformZeroCrossing]:
+    """Sample-pair sign changes of ``values`` against ``0.0``, filtered by
+    ``direction`` and refined to a sub-sample ``time_seconds`` via linear
+    interpolation between the two samples that bracket each crossing. The
+    shared implementation behind every public method on this mixin (see
+    module docstring)."""
+    if values.shape[0] < 2:
+        return []
+    previous = values[:-1]
+    current = values[1:]
+    rising = (previous <= 0.0) & (current > 0.0)
+    falling = (previous >= 0.0) & (current < 0.0)
+    if direction is WaveformZeroCrossingDirection.POSITIVE:
+        mask = rising
+    elif direction is WaveformZeroCrossingDirection.NEGATIVE:
+        mask = falling
+    else:
+        mask = rising | falling
+
+    events: list[WaveformZeroCrossing] = []
+    for pair_index in np.flatnonzero(mask):
+        i = int(pair_index)
+        prev_value = float(values[i])
+        curr_value = float(values[i + 1])
+        fraction = min(1.0, max(0.0, -prev_value / (curr_value - prev_value)))
+        interpolated_position = i + fraction
+        crossing_direction = (
+            WaveformZeroCrossingDirection.POSITIVE
+            if rising[i]
+            else WaveformZeroCrossingDirection.NEGATIVE
+        )
+        events.append(
+            WaveformZeroCrossing(
+                index=i + 1,
+                time_seconds=interpolated_position * dt_seconds,
+                direction=crossing_direction,
+            )
+        )
+    return events
+
+
+class ZeroCrossingMixin:
+    """Adds zero-crossing detection, rate, and crossing-delimited
+    segmentation to a ``WaveformProtocol`` host."""
+
+    def zero_crossings(
+        self: WaveformProtocol,
+        direction: WaveformZeroCrossingDirection = WaveformZeroCrossingDirection.BOTH,
+    ) -> list[WaveformZeroCrossing]:
+        """Sign-change crossings of ``values`` against ``0.0``, sub-sample
+        interpolated: ``time_seconds`` is the linearly-interpolated crossing
+        location between the two bracketing samples, not simply
+        ``index * dt``. ``index`` marks the sample landing just after the
+        crossing (matching ``dsp/_triggers.py``'s sign-change convention).
+
+        Returns ``[]`` for a waveform with fewer than 2 samples or no
+        qualifying crossing -- never raises (detector, per waveformDsp.md
+        §Numerical conventions).
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        dt_seconds = float_seconds(self.dt)
+        return _zero_crossing_events(values, dt_seconds, direction)
+
+    def zero_crossing_count(
+        self: WaveformProtocol,
+        direction: WaveformZeroCrossingDirection = WaveformZeroCrossingDirection.BOTH,
+    ) -> int:
+        """``len(self.zero_crossings(direction))`` (see module docstring for
+        why ``direction`` is accepted directly rather than only via
+        ``zero_crossings``)."""
+        values = np.asarray(self.values, dtype=np.float64)
+        dt_seconds = float_seconds(self.dt)
+        return len(_zero_crossing_events(values, dt_seconds, direction))
+
+    def zero_crossing_rate(
+        self: WaveformProtocol,
+        direction: WaveformZeroCrossingDirection = WaveformZeroCrossingDirection.BOTH,
+    ) -> float:
+        """Crossings per second: ``zero_crossing_count(direction) /
+        duration_seconds``. Returns ``0.0`` when the waveform spans zero
+        duration (0 or 1 samples) -- never raises or divides by zero."""
+        values = np.asarray(self.values, dtype=np.float64)
+        dt_seconds = float_seconds(self.dt)
+        sample_count = values.shape[0]
+        duration_seconds = (sample_count - 1) * dt_seconds if sample_count > 0 else 0.0
+        if duration_seconds <= 0.0:
+            return 0.0
+        count = len(_zero_crossing_events(values, dt_seconds, direction))
+        return count / duration_seconds
+
+    def segments_between_zero_crossings(self: WaveformProtocol) -> list[WaveformProtocol]:
+        """``self`` split at every (``BOTH``-direction) zero crossing into
+        inclusive segments; each segment's ``t0`` is shifted to its start
+        sample (see module docstring for why segment lengths sum to
+        approximately, not exactly, the source sample count).
+
+        A waveform with no crossings yields a single segment covering all of
+        ``self``; a single-sample waveform likewise yields one one-sample
+        segment. Segments are always ordered by strictly increasing ``t0``.
+
+        Raises:
+            ValueError: If the waveform has no samples.
+        """
+        values = np.asarray(self.values, dtype=np.float64)
+        sample_count = values.shape[0]
+        if sample_count == 0:
+            raise ValueError(
+                "ZeroCrossingMixin.segments_between_zero_crossings requires at least 1 sample"
+            )
+        dt_seconds = float_seconds(self.dt)
+        crossings = _zero_crossing_events(values, dt_seconds, WaveformZeroCrossingDirection.BOTH)
+        boundary_indices = [crossing.index for crossing in crossings]
+        split_points = [0, *boundary_indices, sample_count - 1]
+
+        segments: list[WaveformProtocol] = []
+        for start, stop in zip(split_points, split_points[1:], strict=False):
+            if start >= stop:
+                continue
+            segment = self.values[start : stop + 1]
+            segments.append(self._with_t0(segment, self.t0 + self.dt * start))
+        if not segments:
+            segments.append(self._with_t0(self.values, self.t0))
+        return segments
+
+
+__all__ = ["ZeroCrossingMixin"]
diff --git a/src/math_tools/waveforms/dsp/py.typed b/src/math_tools/waveforms/dsp/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/src/math_tools/waveforms/py.typed b/src/math_tools/waveforms/py.typed
new file mode 100644
index 0000000..e69de29
diff --git a/src/math_tools/waveforms/support.py b/src/math_tools/waveforms/support.py
new file mode 100644
index 0000000..0c34632
--- /dev/null
+++ b/src/math_tools/waveforms/support.py
@@ -0,0 +1,389 @@
+"""Support enums and descriptor dataclasses for the ``Waveform1D`` DSP surface.
+
+See ``.claude/specs/waveformDsp.md`` §Support descriptor types. Ported from
+the Swift ``Waveform1D/Support/`` types, but only the members/fields the
+Python mixin contracts (chunks 18-30) actually consume -- YAGNI on the rest.
+
+Every enum is a string-valued ``enum.Enum`` (snake_case values) so descriptor
+instances serialize/repr predictably. Every dataclass is
+``@dataclass(frozen=True, slots=True)``; descriptors holding numpy arrays
+additionally set ``eq=False`` because the dataclass-generated ``__eq__``
+would compare arrays with ``==`` and raise ``ValueError: ambiguous truth
+value`` (waveformDsp.md §Compliance 3). Scalar-only descriptors keep the
+default generated ``__eq__``.
+
+``WaveformTriggerType`` is not enumerated in the Python spec's enum list --
+the Swift source (``Support/WaveformTriggerType.swift``) defines it as a
+generic enum with associated values (``edge``, ``level``, ``window``,
+``pattern`` cases carrying thresholds/bounds). This module flattens it to a
+plain string-valued discriminator enum (its four case names) and moves the
+associated payload onto :class:`WaveformTrigger`'s optional fields --
+consistent with every other "kind" enum here and with
+``WaveformTrigger(kind: WaveformTriggerType, level, ...)`` in the spec text.
+
+**Forced contract change (chunk 27, semver 0.0.6):** :class:`WaveformTrigger`
+gained two optional fields, ``edge: WaveformEdgeType | None`` and
+``window_kind: WaveformWindowTriggerType | None`` -- needed for
+``TriggerMixin.detect_triggers`` (the generic ``WaveformTrigger``-driven
+dispatcher) to forward the same direction/enter-exit selector its direct
+``detect_edge_triggers``/``detect_level_triggers``/``detect_window_triggers``
+siblings take as an explicit argument; without a field to read, the generic
+path had no way to know which direction/selector the caller wanted. Both
+default to ``None`` (dispatch falls back to ``WaveformEdgeType.BOTH`` for
+``EDGE``, ``WaveformEdgeType.RISING`` for ``LEVEL``, and
+``WaveformWindowTriggerType.ENTER`` for ``WINDOW`` -- see
+``dsp/_triggers.py``), so this is backward-compatible with every existing
+``WaveformTrigger(...)`` call site.
+
+**Forced contract change (chunk 27, semver 0.0.6):**
+:class:`WaveformWithEvents`'s ``waveform`` field is typed
+``WaveformProtocol`` (``dsp/_protocol.py``), not the concrete ``Waveform1D``
+the field held through chunk 26. ``TriggerMixin.with_event_markers``
+(``dsp/_triggers.py``) is the first mixin method that has to embed ``self``
+itself into a descriptor -- every earlier descriptor holds only *derived*
+values (arrays, scalars, other descriptors), never the host waveform. Mixins
+type ``self`` as ``WaveformProtocol`` and must not import ``Waveform1D``
+(waveformDsp.md §Organization; see ``dsp/_protocol.py``'s docstring for why
+even a ``TYPE_CHECKING``-only import is disallowed), so a field typed
+concrete ``Waveform1D`` was never satisfiable from a mixin method without
+that forbidden import. Retyping the field as the structural
+``WaveformProtocol`` -- which ``Waveform1D`` already satisfies, both at
+runtime (``@runtime_checkable``) and under mypy strict, per
+``tests/waveforms/test_support.py::TestWaveformProtocol`` -- resolves this
+without touching the import-direction rule, and as a side effect removes
+this module's only import of ``waveforms/waveform1d.py`` (a real ``Waveform1D``
+instance is still exactly what every caller passes in and reads back out).
+"""
+
+from __future__ import annotations
+
+import enum
+from dataclasses import dataclass
+from typing import TYPE_CHECKING
+
+import numpy as np
+import numpy.typing as npt
+
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+
+if TYPE_CHECKING:
+    # Deferred to type-checking only (chunk 30, semver 0.0.7): a module-level import
+    # here forces Python to fully execute `waveforms/dsp/__init__.py` -- which, from
+    # this chunk onward, eagerly imports every mixin to re-export it (see that
+    # module's docstring) -- before this module (`support.py`) finishes executing.
+    # Several mixins (e.g. `dsp/_correlation.py`) import types back out of
+    # `support.py`, so that eager chain landed here mid-import and raised
+    # `ImportError: cannot import name 'WaveformTimeLag' from partially initialized
+    # module`. `WaveformProtocol` is only ever used as a dataclass field annotation
+    # below (`WaveformWithEvents.waveform`), and `from __future__ import
+    # annotations` (above) already defers every annotation in this module to a
+    # string -- so the import is never needed at runtime, only for mypy, which
+    # resolves `TYPE_CHECKING` imports without executing them. This is the opposite
+    # direction from the forbidden case in `dsp/_protocol.py`'s docstring (a DSP
+    # mixin importing `Waveform1D`, forbidden even under `TYPE_CHECKING` because a
+    # mixin must stay import-cycle-free with the class it composes onto); a support
+    # module importing the mixins' own protocol under `TYPE_CHECKING` carries no
+    # such restriction.
+    from math_tools.waveforms.dsp._protocol import WaveformProtocol
+
+# MARK: - Enums
+
+class WaveformFilterType(str, enum.Enum):
+    """Filter family selector for ``FilteringMixin.filtered``."""
+
+    LOW_PASS = "low_pass"
+    HIGH_PASS = "high_pass"
+    BAND_PASS = "band_pass"
+    BAND_STOP = "band_stop"
+
+
+class WaveformWindowType(str, enum.Enum):
+    """Window function selector for ``WindowingMixin``."""
+
+    HANN = "hann"
+    HAMMING = "hamming"
+    BLACKMAN = "blackman"
+    BARTLETT = "bartlett"
+    KAISER = "kaiser"
+    RECTANGULAR = "rectangular"
+
+
+class WaveformInterpolationMethod(str, enum.Enum):
+    """Interpolation kernel for ``ResamplingMixin.interpolated``."""
+
+    LINEAR = "linear"
+    CUBIC = "cubic"
+    NEAREST = "nearest"
+    FOURIER = "fourier"
+
+
+class WaveformInstantaneousMethod(str, enum.Enum):
+    """Estimator for ``EnvelopeMixin.instantaneous_amplitude``."""
+
+    HILBERT = "hilbert"
+    RMS = "rms"
+    PEAK = "peak"
+
+
+class WaveformEdgeType(str, enum.Enum):
+    """Edge direction for ``TriggerMixin.detect_edge_triggers``."""
+
+    RISING = "rising"
+    FALLING = "falling"
+    BOTH = "both"
+
+
+class WaveformWindowTriggerType(str, enum.Enum):
+    """Enter/exit selector for ``TriggerMixin.detect_window_triggers``."""
+
+    ENTER = "enter"
+    EXIT = "exit"
+
+
+class WaveformAlignmentMethod(str, enum.Enum):
+    """Alignment strategy for ``TimeAlignmentMixin.aligned``."""
+
+    CORRELATION = "correlation"
+    START_TIME = "start_time"
+
+
+class WaveformZeroCrossingDirection(str, enum.Enum):
+    """Direction filter for ``ZeroCrossingMixin.zero_crossings``."""
+
+    POSITIVE = "positive"
+    NEGATIVE = "negative"
+    BOTH = "both"
+
+
+class WaveformPaddingStrategy(str, enum.Enum):
+    """Edge-padding strategy shared by resampling/filtering helpers."""
+
+    ZERO = "zero"
+    EDGE = "edge"
+    REFLECT = "reflect"
+    WRAP = "wrap"
+
+
+class WaveformPSDScaling(str, enum.Enum):
+    """Scaling mode for ``SpectralMixin.power_spectral_density``."""
+
+    DENSITY = "density"
+    SPECTRUM = "spectrum"
+
+
+class WaveformSpectrogramScaling(str, enum.Enum):
+    """Magnitude scaling for ``SpectralMixin.spectrogram``."""
+
+    LINEAR = "linear"
+    DB = "db"
+    MEL = "mel"
+
+
+class WaveformTriggerType(str, enum.Enum):
+    """Trigger-kind discriminator for :class:`WaveformTrigger` / :class:`WaveformTriggerEvent`.
+
+    Flattened from the Swift generic ``WaveformTriggerType<T>`` enum's four
+    associated-value cases (``edge``, ``level``, ``window``, ``pattern``) --
+    see the module docstring.
+    """
+
+    EDGE = "edge"
+    LEVEL = "level"
+    WINDOW = "window"
+    PATTERN = "pattern"
+
+
+# MARK: - Descriptor dataclasses (ndarray-bearing -- eq=False)
+
+
+@dataclass(frozen=True, slots=True, eq=False)
+class WaveformSpectrum:
+    """A one-sided frequency-domain view: bin frequencies, magnitudes, phases.
+
+    Replaces the Swift ``fft`` extension's anonymous tuple return.
+    """
+
+    frequencies: npt.NDArray[np.float64]
+    magnitudes: npt.NDArray[np.float64]
+    phases: npt.NDArray[np.float64]
+
+
+@dataclass(frozen=True, slots=True, eq=False)
+class WaveformSpectrogram:
+    """Time-frequency magnitude surface (``magnitudes[time, frequency]``)."""
+
+    times: npt.NDArray[np.float64]
+    frequencies: npt.NDArray[np.float64]
+    magnitudes: npt.NDArray[np.float64]
+
+
+@dataclass(frozen=True, slots=True, eq=False)
+class WaveformMelSpectrogram:
+    """Mel-scale analogue of :class:`WaveformSpectrogram`."""
+
+    times: npt.NDArray[np.float64]
+    mel_frequencies: npt.NDArray[np.float64]
+    magnitudes: npt.NDArray[np.float64]
+
+
+@dataclass(frozen=True, slots=True, eq=False)
+class WaveformInstantaneousFrequency:
+    """Instantaneous-frequency track over time (``PhaseMixin.instantaneous_frequency``)."""
+
+    frequencies_hz: npt.NDArray[np.float64]
+    times_seconds: npt.NDArray[np.float64]
+
+
+@dataclass(frozen=True, slots=True, eq=False)
+class WaveformFilterCoefficients:
+    """IIR/FIR coefficients: ``numerator`` (feedforward) / ``denominator`` (feedback)."""
+
+    numerator: npt.NDArray[np.float64]
+    denominator: npt.NDArray[np.float64]
+
+
+# MARK: - Descriptor dataclasses (scalar-only -- default eq)
+
+
+@dataclass(frozen=True, slots=True)
+class WaveformSpectralFeatures:
+    """Whole-spectrum summary statistics (``SpectralMixin.spectral_features``)."""
+
+    centroid: float
+    spread: float
+    rolloff: float
+    flatness: float
+
+
+@dataclass(frozen=True, slots=True)
+class WaveformPeak:
+    """A single detected peak/valley sample."""
+
+    index: int
+    time_seconds: float
+    value: float
+
+
+@dataclass(frozen=True, slots=True)
+class WaveformPeakWithProminence:
+    """A peak plus its ``scipy.signal.peak_prominences`` value."""
+
+    peak: WaveformPeak
+    prominence: float
+
+
+@dataclass(frozen=True, slots=True)
+class WaveformTimeLag:
+    """Best-correlation lag between two waveforms."""
+
+    lag_samples: int
+    lag_seconds: float
+    correlation: float
+
+
+@dataclass(frozen=True, slots=True)
+class WaveformTrigger:
+    """Trigger configuration passed to ``TriggerMixin.detect_triggers``.
+
+    Only the fields relevant to ``kind`` are meaningful: ``level`` for
+    ``EDGE``/``LEVEL`` (direction via ``edge``, defaulting to ``BOTH``/
+    ``RISING`` respectively when unset), ``lower``/``upper`` for ``WINDOW``
+    (enter/exit via ``window_kind``, defaulting to ``ENTER`` when unset),
+    ``pattern``/``tolerance`` for ``PATTERN`` -- mirroring the Swift
+    associated-value cases collapsed into ``WaveformTriggerType`` (see
+    module docstring). ``edge``/``window_kind`` were added in chunk 27 (see
+    module docstring "Forced contract change") so the generic
+    ``detect_triggers`` dispatcher can forward the same direction/selector
+    its direct ``detect_edge_triggers``/``detect_level_triggers``/
+    ``detect_window_triggers`` siblings take explicitly.
+    """
+
+    kind: WaveformTriggerType
+    level: float | None = None
+    lower: float | None = None
+    upper: float | None = None
+    pattern: tuple[float, ...] | None = None
+    tolerance: float | None = None
+    minimum_interval: PrecisionTimeInterval | None = None
+    edge: WaveformEdgeType | None = None
+    window_kind: WaveformWindowTriggerType | None = None
+
+
+@dataclass(frozen=True, slots=True)
+class WaveformTriggerEvent:
+    """A single fired trigger."""
+
+    index: int
+    time_seconds: float
+    value: float
+    kind: WaveformTriggerType
+
+
+@dataclass(frozen=True, slots=True)
+class WaveformEventMarker:
+    """A labeled point of interest for annotating a waveform."""
+
+    index: int
+    label: str
+
+
+@dataclass(frozen=True, slots=True)
+class WaveformWithEvents:
+    """A waveform paired with its event markers (``TriggerMixin.with_event_markers``).
+
+    ``waveform`` is typed ``WaveformProtocol`` rather than the concrete
+    ``Waveform1D`` (see module docstring "Forced contract change", chunk 27)
+    -- callers always pass and read back an actual ``Waveform1D``, since it
+    is the only type that ever composes ``TriggerMixin``.
+    """
+
+    waveform: WaveformProtocol
+    events: tuple[WaveformEventMarker, ...]
+
+
+@dataclass(frozen=True, slots=True)
+class WaveformZeroCrossing:
+    """A single zero crossing."""
+
+    index: int
+    time_seconds: float
+    direction: WaveformZeroCrossingDirection
+
+
+@dataclass(frozen=True, slots=True)
+class WaveformFrequencyRange:
+    """An inclusive ``[low_hz, high_hz]`` band, e.g. for band-pass filtering."""
+
+    low_hz: float
+    high_hz: float
+
+
+__all__ = [
+    "WaveformFilterType",
+    "WaveformWindowType",
+    "WaveformInterpolationMethod",
+    "WaveformInstantaneousMethod",
+    "WaveformEdgeType",
+    "WaveformWindowTriggerType",
+    "WaveformAlignmentMethod",
+    "WaveformZeroCrossingDirection",
+    "WaveformPaddingStrategy",
+    "WaveformPSDScaling",
+    "WaveformSpectrogramScaling",
+    "WaveformTriggerType",
+    "WaveformSpectrum",
+    "WaveformSpectrogram",
+    "WaveformMelSpectrogram",
+    "WaveformSpectralFeatures",
+    "WaveformPeak",
+    "WaveformPeakWithProminence",
+    "WaveformTimeLag",
+    "WaveformTrigger",
+    "WaveformTriggerEvent",
+    "WaveformEventMarker",
+    "WaveformWithEvents",
+    "WaveformZeroCrossing",
+    "WaveformInstantaneousFrequency",
+    "WaveformFrequencyRange",
+    "WaveformFilterCoefficients",
+]
diff --git a/src/math_tools/waveforms/waveform1d.py b/src/math_tools/waveforms/waveform1d.py
new file mode 100644
index 0000000..a952d2e
--- /dev/null
+++ b/src/math_tools/waveforms/waveform1d.py
@@ -0,0 +1,1188 @@
+"""``Waveform1D``: a uniformly-sampled scalar time series.
+
+See ``.claude/specs/waveformCore.md`` (§ABC accessor, §Instantiability,
+§Time axis, §Waveform1D). Storage is a private 1-D ``np.ndarray`` (dtype
+preserved on construction; float64 default for non-integer input); ``dt``/
+``t0`` are the Tier-3 ``PrecisionTimeInterval``/``PrecisionTimestamp`` types
+so the time axis is attosecond-exact rather than float-accumulated.
+
+Constructors, statistics, indexing, and mutation below are a fresh
+numpy-idiomatic implementation, NOT a faithful port of the Swift
+``Waveform1D``: the Swift generator API is duration/samplingRate based,
+this one is sample-count (``n``) based, matching this repo's other
+constructors.
+
+Arithmetic/bitwise/comparison operators (``+ - * / // %``, ``& | ^ << >> ~``,
+``isclose``, ``elements_equal``, etc.) are chunk 12 -- see §Waveform1D
+Operators.
+
+**DSP mixin composition (waveformDsp.md §Organization "Composition
+phasing").** ``Waveform1D`` composes all twelve ``dsp/_*.py`` mixins ahead
+of ``Waveform1dABC`` in its base list, per the spec's pinned base-list
+order. Each mixin types its own ``self`` as ``dsp._protocol.WaveformProtocol``
+rather than nominally inheriting it (see ``dsp/_protocol.py`` /
+``dsp/_calc.py`` for why nominal inheritance is broken at runtime), so this
+module never imports ``dsp._protocol`` itself -- only the twelve concrete
+mixin classes, which is exactly what §Organization's code block shows.
+"""
+
+from __future__ import annotations
+
+import operator
+from collections.abc import Callable, Iterator, Sequence
+from typing import Any, overload
+
+import numpy as np
+import numpy.typing as npt
+from foundation_abc.math.waveformABCs import Waveform1dABC
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.precision_time.precision_timestamp import PrecisionTimestamp
+from math_tools.waveforms.dsp._calc import CalcMixin
+from math_tools.waveforms.dsp._correlation import CorrelationMixin
+from math_tools.waveforms.dsp._envelope import EnvelopeMixin
+from math_tools.waveforms.dsp._filtering import FilteringMixin
+from math_tools.waveforms.dsp._peaks import PeakMixin
+from math_tools.waveforms.dsp._phase import PhaseMixin
+from math_tools.waveforms.dsp._resampling import ResamplingMixin
+from math_tools.waveforms.dsp._spectral import SpectralMixin
+from math_tools.waveforms.dsp._time_alignment import TimeAlignmentMixin
+from math_tools.waveforms.dsp._triggers import TriggerMixin
+from math_tools.waveforms.dsp._windowing import WindowingMixin
+from math_tools.waveforms.dsp._zero_crossings import ZeroCrossingMixin
+
+
+def _resolve_dt_seconds(dt: PrecisionTimeInterval | None, dt_seconds: float | None) -> float:
+    """Resolve the axis spacing (seconds) for generator time-axis construction.
+
+    Mirrors the constructor's mutual-exclusivity rule between ``dt`` and
+    ``dt_seconds``, but does not validate strict positivity -- that is left
+    to the ``Waveform1D`` constructor the generator ultimately delegates to.
+    """
+    if dt is not None and dt_seconds is not None:
+        raise TypeError("Waveform1D: specify at most one of dt, dt_seconds")
+    if dt is not None:
+        return dt.seconds_as_float
+    return dt_seconds if dt_seconds is not None else 1.0
+
+
+def _span_seconds(n: int, dt_s: float) -> float:
+    """The sample span of an ``n``-sample waveform: ``(n - 1) * dt_s``.
+
+    waveformCore.md's generator span convention (endpoint-inclusive: the
+    last sample of an ``n``-sample waveform is at ``t0 + (n-1)*dt``, not
+    ``n*dt``). Every generator whose default/scaling parameter depends on
+    the waveform's total duration (``chirp``'s sweep rate, ``heaviside``'s
+    default ``step_time``, ``sigmoid``'s default ``center``) MUST derive it
+    from this helper rather than recomputing ``n * dt_s`` inline. ``n <= 1``
+    is a zero-length span, not a division-by-zero.
+    """
+    return (n - 1) * dt_s if n > 1 else 0.0
+
+
+_SCALAR_TYPES: tuple[type, ...] = (int, float, np.integer, np.floating, np.bool_)
+
+
+def _is_valid_operand(other: object) -> bool:
+    """True if ``other`` is a ``Waveform1D`` or a plain/numpy scalar -- the only operand
+    kinds the elementwise operators accept. Anything else must yield ``NotImplemented``
+    so Python's operator protocol (reflected methods, ``np.float64 + w``, etc.) behaves
+    correctly instead of us raising (waveformCore.md §Waveform1D Operators)."""
+    return isinstance(other, Waveform1D) or isinstance(other, _SCALAR_TYPES)
+
+
+class Waveform1D(
+    CalcMixin,
+    CorrelationMixin,
+    EnvelopeMixin,
+    SpectralMixin,
+    FilteringMixin,
+    PeakMixin,
+    PhaseMixin,
+    ResamplingMixin,
+    TimeAlignmentMixin,
+    TriggerMixin,
+    WindowingMixin,
+    ZeroCrossingMixin,
+    Waveform1dABC,
+):
+    """A mutable, uniformly-sampled scalar time series backed by a 1-D ndarray."""
+
+    # Opt out of numpy's ufunc protocol: without this, `np.float64(2.0) + w` or
+    # `np.array([...]) * w` silently unwraps `w` via `__array__` and returns a bare
+    # ndarray (dropping dt/t0) instead of calling `w.__radd__`/`w.__rmul__`. Setting
+    # this to None forces numpy to return NotImplemented, so Python's normal operator
+    # protocol (and this class's reflected dunders) takes over.
+    __array_ufunc__ = None
+
+    # MARK: - Construction
+
+    def __init__(
+        self,
+        values: npt.ArrayLike,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> None:
+        """Construct from array-like ``values`` (copied) and an optional time axis.
+
+        ``dt``/``dt_seconds`` are mutually exclusive (``dt_seconds`` defaults
+        to ``1.0`` when neither is given); likewise ``t0``/``t0_seconds``
+        (``t0`` defaults to ``PrecisionTimestamp.EPOCH``).
+
+        Raises:
+            TypeError: If both ``dt`` and ``dt_seconds``, or both ``t0`` and
+                ``t0_seconds``, are given.
+            ValueError: If ``values`` is not 1-D, or the resolved ``dt`` is
+                not strictly positive.
+        """
+        if dt is not None and dt_seconds is not None:
+            raise TypeError("Waveform1D: specify at most one of dt, dt_seconds")
+        if t0 is not None and t0_seconds is not None:
+            raise TypeError("Waveform1D: specify at most one of t0, t0_seconds")
+
+        resolved_dt = (
+            dt
+            if dt is not None
+            else PrecisionTimeInterval.from_seconds(dt_seconds if dt_seconds is not None else 1.0)
+        )
+        if resolved_dt.total_attoseconds <= 0:
+            raise ValueError(f"Waveform1D: dt must be strictly positive, got {resolved_dt!r}")
+
+        if t0 is not None:
+            resolved_t0 = t0
+        elif t0_seconds is not None:
+            resolved_t0 = PrecisionTimestamp.from_interval(
+                PrecisionTimeInterval.from_seconds(t0_seconds)
+            )
+        else:
+            resolved_t0 = PrecisionTimestamp.EPOCH
+
+        arr = np.asarray(values)
+        if arr.ndim != 1:
+            raise ValueError(f"Waveform1D: values must be 1-D, got shape {arr.shape}")
+        if np.issubdtype(arr.dtype, np.integer):
+            self._values: npt.NDArray[Any] = arr.copy()
+        else:
+            self._values = arr.astype(np.float64, copy=True)
+        self._dt = resolved_dt
+        self._t0 = resolved_t0
+
+    @classmethod
+    def from_dict(cls, obj: Any) -> Waveform1D:
+        """Construct from the ABC wire shape ``{"waveform", "t0", "dt"}``."""
+        if not isinstance(obj, dict):
+            raise TypeError(f"expected a dict, got {type(obj).__name__}")
+        dt = PrecisionTimeInterval.from_dict(obj["dt"])
+        t0 = PrecisionTimestamp.from_dict(obj["t0"])
+        return cls(obj.get("waveform", []), dt=dt, t0=t0)
+
+    # MARK: - Generators (sinusoidal)
+
+    @classmethod
+    def sine(
+        cls,
+        n: int,
+        frequency: float = 1.0,
+        amplitude: float = 1.0,
+        phase: float = 0.0,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate a sine wave: ``amplitude * sin(2*pi*frequency*t + phase)``.
+
+        ``frequency`` defaults to ``1.0`` Hz so that ``Waveform1D.sine(n=1000)``
+        is legal on its own (waveformCore.md's pinned example, §Time axis /
+        Compliance 4).
+        """
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        values = amplitude * np.sin(2.0 * np.pi * frequency * t + phase)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def cosine(
+        cls,
+        n: int,
+        frequency: float,
+        amplitude: float = 1.0,
+        phase: float = 0.0,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate a cosine wave: ``amplitude * cos(2*pi*frequency*t + phase)``."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        values = amplitude * np.cos(2.0 * np.pi * frequency * t + phase)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def square(
+        cls,
+        n: int,
+        frequency: float,
+        amplitude: float = 1.0,
+        duty_cycle: float = 0.5,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate a bipolar square wave with the given ``duty_cycle`` (clamped to [0, 1])."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        period = 1.0 / frequency
+        duty = min(1.0, max(0.0, duty_cycle))
+        phase_in_period = np.mod(t, period) / period
+        values = np.where(phase_in_period < duty, amplitude, -amplitude)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def triangle(
+        cls,
+        n: int,
+        frequency: float,
+        amplitude: float = 1.0,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate a triangle wave."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        period = 1.0 / frequency
+        phase_in_period = np.mod(t, period) / period
+        values = amplitude * np.where(
+            phase_in_period < 0.5,
+            4.0 * phase_in_period - 1.0,
+            3.0 - 4.0 * phase_in_period,
+        )
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def sawtooth(
+        cls,
+        n: int,
+        frequency: float,
+        amplitude: float = 1.0,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate a sawtooth wave ramping from ``-amplitude`` to ``amplitude``."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        period = 1.0 / frequency
+        phase_in_period = np.mod(t, period) / period
+        values = amplitude * (2.0 * phase_in_period - 1.0)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    # MARK: - Generators (chirp / exponential / polynomial)
+
+    @classmethod
+    def chirp(
+        cls,
+        n: int,
+        start_frequency: float,
+        end_frequency: float,
+        amplitude: float = 1.0,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate a linear chirp sweeping from ``start_frequency`` to ``end_frequency``
+        over the waveform's span (``(n-1) * dt`` -- the last sample's instantaneous
+        frequency is exactly ``end_frequency``)."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        duration = _span_seconds(n, dt_s)
+        sweep_rate = (end_frequency - start_frequency) / duration if duration != 0.0 else 0.0
+        phase = 2.0 * np.pi * (start_frequency * t + 0.5 * sweep_rate * t * t)
+        values = amplitude * np.sin(phase)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def exponential_decay(
+        cls,
+        n: int,
+        time_constant: float,
+        amplitude: float = 1.0,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate ``amplitude * exp(-t / time_constant)``."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        values = amplitude * np.exp(-t / time_constant)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def exponential_growth(
+        cls,
+        n: int,
+        time_constant: float,
+        amplitude: float = 1.0,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate ``amplitude * exp(t / time_constant)``."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        values = amplitude * np.exp(t / time_constant)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def polynomial(
+        cls,
+        n: int,
+        coefficients: Sequence[float],
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate ``a0 + a1*t + a2*t**2 + ...`` for ``coefficients = [a0, a1, a2, ...]``."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        values: npt.NDArray[Any]
+        if not coefficients:
+            values = np.zeros(n, dtype=np.float64)
+        else:
+            # np.polyval expects highest-degree coefficient first.
+            values = np.polyval(list(reversed(coefficients)), t)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def linear_ramp(
+        cls,
+        n: int,
+        start_value: float,
+        end_value: float,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate a linear ramp from ``start_value`` to ``end_value`` over ``n`` samples."""
+        if n > 1:
+            progress = np.arange(n, dtype=np.float64) / (n - 1)
+        else:
+            progress = np.zeros(n, dtype=np.float64)
+        values = start_value + (end_value - start_value) * progress
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    # MARK: - Generators (logarithmic / power)
+
+    @classmethod
+    def logarithm(
+        cls,
+        n: int,
+        amplitude: float = 1.0,
+        offset: float = 0.01,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate ``amplitude * ln(t + offset)`` (``offset`` avoids ``log(0)``)."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        values = amplitude * np.log(t + offset)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def logarithm10(
+        cls,
+        n: int,
+        amplitude: float = 1.0,
+        offset: float = 0.01,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate ``amplitude * log10(t + offset)`` (``offset`` avoids ``log10(0)``)."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        values = amplitude * np.log10(t + offset)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def square_root(
+        cls,
+        n: int,
+        amplitude: float = 1.0,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate ``amplitude * sqrt(t)``."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        values = amplitude * np.sqrt(t)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    # MARK: - Generators (step / activation)
+
+    @classmethod
+    def heaviside(
+        cls,
+        n: int,
+        amplitude: float = 1.0,
+        step_time: float | None = None,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate a Heaviside step: ``amplitude`` for ``t >= step_time`` else ``0``.
+
+        ``step_time`` defaults to the midpoint of the waveform's span
+        (``(n-1) * dt / 2``).
+        """
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        actual_step_time = step_time if step_time is not None else _span_seconds(n, dt_s) / 2.0
+        values = np.where(t >= actual_step_time, amplitude, 0.0)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def relu(
+        cls,
+        n: int,
+        slope: float = 1.0,
+        threshold: float = 0.0,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate ``slope * (t - threshold)`` where positive, else ``0``."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        x = t - threshold
+        values = np.where(x > 0.0, slope * x, 0.0)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def sigmoid(
+        cls,
+        n: int,
+        amplitude: float = 1.0,
+        steepness: float = 1.0,
+        center: float | None = None,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate a logistic sigmoid; ``center`` defaults to the span's midpoint
+        (``(n-1) * dt / 2``)."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        actual_center = center if center is not None else _span_seconds(n, dt_s) / 2.0
+        x = steepness * (t - actual_center)
+        values = amplitude / (1.0 + np.exp(-x))
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    # MARK: - Generators (noise / constant / impulse / composite)
+
+    @classmethod
+    def white_noise(
+        cls,
+        n: int,
+        amplitude: float = 1.0,
+        seed: int | None = None,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate Gaussian white noise; reproducible for a given ``seed``."""
+        rng = np.random.default_rng(seed)
+        values = amplitude * rng.standard_normal(n)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def constant(
+        cls,
+        n: int,
+        value: float,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate a constant (DC) signal of ``n`` samples."""
+        values = np.full(n, value)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def impulse(
+        cls,
+        n: int,
+        amplitude: float = 1.0,
+        impulse_index: int = 0,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate a unit impulse: ``amplitude`` at ``impulse_index``, ``0`` elsewhere."""
+        values = np.zeros(n, dtype=np.float64)
+        if 0 <= impulse_index < n:
+            values[impulse_index] = amplitude
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def damped_sinusoid(
+        cls,
+        n: int,
+        frequency: float,
+        damping_constant: float,
+        amplitude: float = 1.0,
+        phase: float = 0.0,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate an exponentially-decaying sinusoid."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        envelope = np.exp(-t / damping_constant)
+        values = amplitude * envelope * np.sin(2.0 * np.pi * frequency * t + phase)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def counter(
+        cls,
+        n: int,
+        start_value: float = 0,
+        increment: float = 1,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate an integer-friendly counter/ramp: ``start_value + i * increment``."""
+        values = start_value + increment * np.arange(n)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    @classmethod
+    def digital_square(
+        cls,
+        n: int,
+        frequency: float,
+        high_value: float,
+        low_value: float,
+        duty_cycle: float = 0.5,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> Waveform1D:
+        """Generate a two-level (``high_value``/``low_value``) square wave."""
+        dt_s = _resolve_dt_seconds(dt, dt_seconds)
+        t = np.arange(n, dtype=np.float64) * dt_s
+        period = 1.0 / frequency
+        duty = min(1.0, max(0.0, duty_cycle))
+        phase_in_period = np.mod(t, period) / period
+        values = np.where(phase_in_period < duty, high_value, low_value)
+        return cls(values, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds)
+
+    # MARK: - Properties (ABC-required)
+
+    @property
+    def waveform(self) -> Sequence[float]:
+        """The samples as a plain list of floats (the ABC-required accessor)."""
+        return [float(v) for v in self._values]
+
+    @property
+    def t0(self) -> PrecisionTimestamp:
+        return self._t0
+
+    @property
+    def dt(self) -> PrecisionTimeInterval:
+        return self._dt
+
+    # MARK: - Properties (numpy bulk accessor)
+
+    @property
+    def values(self) -> npt.NDArray[Any]:
+        """A copy of the sample array (dtype preserved)."""
+        return np.array(self._values, copy=True)
+
+    # MARK: - Properties (time axis)
+
+    @property
+    def duration(self) -> PrecisionTimeInterval:
+        """The span from the first to the last sample (``ZERO`` when ``n <= 1``)."""
+        n = len(self._values)
+        if n <= 1:
+            return PrecisionTimeInterval.ZERO
+        return self._dt * (n - 1)
+
+    @property
+    def duration_seconds(self) -> float:
+        return self.duration.seconds_as_float
+
+    @property
+    def sampling_frequency_hz(self) -> float:
+        return 1.0 / self._dt.seconds_as_float
+
+    @property
+    def nyquist_frequency_hz(self) -> float:
+        return self.sampling_frequency_hz / 2.0
+
+    @property
+    def sample_count(self) -> int:
+        return len(self._values)
+
+    def __len__(self) -> int:
+        return len(self._values)
+
+    def time_axis(self) -> npt.NDArray[np.float64]:
+        """Sample times (seconds, relative to ``t0``) as a float64 array."""
+        n = len(self._values)
+        return np.arange(n, dtype=np.float64) * self._dt.seconds_as_float
+
+    # MARK: - Properties (statistics; None on empty)
+
+    @property
+    def minimum(self) -> float | None:
+        return float(np.min(self._values)) if len(self._values) else None
+
+    @property
+    def maximum(self) -> float | None:
+        return float(np.max(self._values)) if len(self._values) else None
+
+    @property
+    def peak_to_peak(self) -> float | None:
+        if len(self._values) == 0:
+            return None
+        return float(np.max(self._values) - np.min(self._values))
+
+    @property
+    def mean(self) -> float | None:
+        return float(np.mean(self._values)) if len(self._values) else None
+
+    @property
+    def rms(self) -> float | None:
+        if len(self._values) == 0:
+            return None
+        return float(np.sqrt(np.mean(np.square(self._values.astype(np.float64)))))
+
+    @property
+    def standard_deviation(self) -> float | None:
+        """Population standard deviation (``ddof=0``, matches :attr:`variance`)."""
+        return float(np.std(self._values)) if len(self._values) else None
+
+    @property
+    def variance(self) -> float | None:
+        """Population variance (``ddof=0``) -- a deliberate, pinned choice.
+
+        See waveformCore.md §Compliance 5: pinned with a literal expected
+        value in the test suite, not merely asserted against ``np.var``.
+        """
+        return float(np.var(self._values)) if len(self._values) else None
+
+    @property
+    def sum(self) -> float | None:
+        return float(np.sum(self._values)) if len(self._values) else None
+
+    @property
+    def absolute_sum(self) -> float | None:
+        return float(np.sum(np.abs(self._values))) if len(self._values) else None
+
+    # MARK: - Indexing / slicing / sampling
+
+    @overload
+    def __getitem__(self, index: int) -> float: ...
+    @overload
+    def __getitem__(self, index: slice) -> Waveform1D: ...
+
+    def __getitem__(self, index: int | slice) -> float | Waveform1D:
+        if isinstance(index, slice):
+            if index.step is not None and index.step != 1:
+                raise ValueError(
+                    "Waveform1D slicing does not support step != 1; resampling is the "
+                    "explicit API"
+                )
+            start, stop, _ = index.indices(len(self._values))
+            new_t0 = self._t0 + self._dt * start
+            return Waveform1D(self._values[start:stop], dt=self._dt, t0=new_t0)
+        return float(self._values[index])
+
+    def _seconds_from_t0(self, t: PrecisionTimestamp | float) -> float:
+        if isinstance(t, PrecisionTimestamp):
+            return (t - self._t0).seconds_as_float
+        if isinstance(t, (int, float)) and not isinstance(t, bool):
+            return float(t)
+        raise TypeError(f"expected a PrecisionTimestamp or float seconds, got {type(t).__name__}")
+
+    def subset_time(
+        self, start_time: PrecisionTimestamp | float, end_time: PrecisionTimestamp | float
+    ) -> Waveform1D:
+        """Half-open time-range subset: samples with ``start_time <= t < end_time``.
+
+        Args:
+            start_time: A ``PrecisionTimestamp`` or float seconds relative to ``t0``.
+            end_time: Same units as ``start_time``.
+
+        Raises:
+            ValueError: If the resolved range is empty or invalid.
+        """
+        start_seconds = self._seconds_from_t0(start_time)
+        end_seconds = self._seconds_from_t0(end_time)
+        if end_seconds <= start_seconds:
+            raise ValueError("subset_time requires end_time > start_time")
+        axis = self.time_axis()
+        start_index = int(np.searchsorted(axis, start_seconds, side="left"))
+        end_index = int(np.searchsorted(axis, end_seconds, side="left"))
+        if start_index >= end_index or start_index >= len(self._values):
+            raise ValueError("subset_time selects an empty range")
+        return self[start_index:end_index]
+
+    def value_at_index(self, index: float) -> float:
+        """Linear interpolation between ``floor(index)`` and ``ceil(index)``.
+
+        Raises:
+            ValueError: If ``index`` is outside ``[0, sample_count - 1]``, or
+                the waveform is empty.
+        """
+        n = len(self._values)
+        if n == 0:
+            raise ValueError("value_at_index on an empty Waveform1D")
+        if index < 0 or index > n - 1:
+            raise ValueError(f"index {index} outside valid range [0, {n - 1}]")
+        lower = int(np.floor(index))
+        if lower == index:
+            return float(self._values[lower])
+        fraction = index - lower
+        return float(self._values[lower] * (1.0 - fraction) + self._values[lower + 1] * fraction)
+
+    def value_at_time(self, t: PrecisionTimestamp | float) -> float:
+        """Linear interpolation at time ``t`` (``PrecisionTimestamp`` or seconds from ``t0``).
+
+        Raises:
+            ValueError: If ``t`` falls outside the waveform's time span.
+        """
+        seconds = self._seconds_from_t0(t)
+        index = seconds / self._dt.seconds_as_float
+        try:
+            return self.value_at_index(index)
+        except ValueError as exc:
+            raise ValueError(f"time {seconds}s outside the waveform's span") from exc
+
+    # MARK: - Mutation
+
+    def append(self, value: float) -> None:
+        addition = np.asarray([value], dtype=self._values.dtype)
+        self._values = np.concatenate([self._values, addition])
+
+    def append_values(self, values: Sequence[float]) -> None:
+        addition = np.asarray(values, dtype=self._values.dtype)
+        self._values = np.concatenate([self._values, addition])
+
+    def prepend(self, value: float) -> None:
+        addition = np.asarray([value], dtype=self._values.dtype)
+        self._values = np.concatenate([addition, self._values])
+        self._t0 = self._t0 - self._dt
+
+    def prepend_values(self, values: Sequence[float]) -> None:
+        addition = np.asarray(values, dtype=self._values.dtype)
+        self._values = np.concatenate([addition, self._values])
+        self._t0 = self._t0 - self._dt * len(addition)
+
+    def insert(self, index: int, value: float) -> None:
+        self._values = np.insert(self._values, index, value)
+
+    def replace(self, index: int, value: float) -> None:
+        self._values[index] = value
+
+    def replace_range(self, index: slice, values: Sequence[float]) -> None:
+        self._values[index] = np.asarray(values, dtype=self._values.dtype)
+
+    def pop(self, index: int = -1) -> float:
+        """Remove and return the sample at ``index`` (default: last).
+
+        Raises:
+            IndexError: If the waveform is empty, or ``index`` is out of range.
+        """
+        if len(self._values) == 0:
+            raise IndexError("pop from an empty Waveform1D")
+        value = float(self._values[index])
+        self._values = np.delete(self._values, index)
+        return value
+
+    def clear(self) -> None:
+        self._values = np.array([], dtype=self._values.dtype)
+
+    # MARK: - Arithmetic / bitwise operators
+
+    def _check_compatible(self, other: Waveform1D, op_name: str) -> None:
+        """Raise ``WaveformCompatibilityError`` unless ``other`` shares this waveform's
+        ``dt`` and length (waveformCore.md §Compliance 2)."""
+        if self._dt != other._dt:
+            raise WaveformCompatibilityError(
+                f"Waveform1D.{op_name}: dt mismatch ({self._dt!r} vs {other._dt!r})"
+            )
+        if len(self._values) != len(other._values):
+            raise WaveformCompatibilityError(
+                f"Waveform1D.{op_name}: length mismatch "
+                f"({len(self._values)} vs {len(other._values)})"
+            )
+
+    def _elementwise(
+        self, other: object, op: Callable[[Any, Any], Any], op_name: str
+    ) -> Waveform1D:
+        """``op(self, other)``; ``dt``/``t0`` carried from ``self`` (the left operand)."""
+        if isinstance(other, Waveform1D):
+            self._check_compatible(other, op_name)
+            result = op(self._values, other._values)
+        else:
+            result = op(self._values, other)
+        return Waveform1D(result, dt=self._dt, t0=self._t0)
+
+    def _elementwise_reflected(
+        self, other: object, op: Callable[[Any, Any], Any], op_name: str
+    ) -> Waveform1D:
+        """``op(other, self)`` for reflected operators; ``dt``/``t0`` still carried from
+        ``self`` -- the only ``Waveform1D`` operand present when this is invoked."""
+        if isinstance(other, Waveform1D):
+            self._check_compatible(other, op_name)
+            result = op(other._values, self._values)
+        else:
+            result = op(other, self._values)
+        return Waveform1D(result, dt=self._dt, t0=self._t0)
+
+    def __add__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise(other, operator.add, "__add__")
+
+    def __radd__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise_reflected(other, operator.add, "__radd__")
+
+    def __iadd__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        self._values = self._elementwise(other, operator.add, "__iadd__")._values
+        return self
+
+    def __sub__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise(other, operator.sub, "__sub__")
+
+    def __rsub__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise_reflected(other, operator.sub, "__rsub__")
+
+    def __isub__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        self._values = self._elementwise(other, operator.sub, "__isub__")._values
+        return self
+
+    def __mul__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise(other, operator.mul, "__mul__")
+
+    def __rmul__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise_reflected(other, operator.mul, "__rmul__")
+
+    def __imul__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        self._values = self._elementwise(other, operator.mul, "__imul__")._values
+        return self
+
+    def __truediv__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise(other, operator.truediv, "__truediv__")
+
+    def __rtruediv__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise_reflected(other, operator.truediv, "__rtruediv__")
+
+    def __itruediv__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        self._values = self._elementwise(other, operator.truediv, "__itruediv__")._values
+        return self
+
+    def __floordiv__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise(other, operator.floordiv, "__floordiv__")
+
+    def __rfloordiv__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise_reflected(other, operator.floordiv, "__rfloordiv__")
+
+    def __ifloordiv__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        self._values = self._elementwise(other, operator.floordiv, "__ifloordiv__")._values
+        return self
+
+    def __mod__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise(other, operator.mod, "__mod__")
+
+    def __rmod__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise_reflected(other, operator.mod, "__rmod__")
+
+    def __imod__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        self._values = self._elementwise(other, operator.mod, "__imod__")._values
+        return self
+
+    # MARK: - Bitwise operators (integer dtype only; numpy raises TypeError otherwise)
+
+    def __and__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise(other, operator.and_, "__and__")
+
+    def __rand__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise_reflected(other, operator.and_, "__rand__")
+
+    def __iand__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        self._values = self._elementwise(other, operator.and_, "__iand__")._values
+        return self
+
+    def __or__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise(other, operator.or_, "__or__")
+
+    def __ror__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise_reflected(other, operator.or_, "__ror__")
+
+    def __ior__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        self._values = self._elementwise(other, operator.or_, "__ior__")._values
+        return self
+
+    def __xor__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise(other, operator.xor, "__xor__")
+
+    def __rxor__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise_reflected(other, operator.xor, "__rxor__")
+
+    def __ixor__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        self._values = self._elementwise(other, operator.xor, "__ixor__")._values
+        return self
+
+    def __lshift__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise(other, operator.lshift, "__lshift__")
+
+    def __rlshift__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise_reflected(other, operator.lshift, "__rlshift__")
+
+    def __ilshift__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        self._values = self._elementwise(other, operator.lshift, "__ilshift__")._values
+        return self
+
+    def __rshift__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise(other, operator.rshift, "__rshift__")
+
+    def __rrshift__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        return self._elementwise_reflected(other, operator.rshift, "__rrshift__")
+
+    def __irshift__(self, other: object) -> Waveform1D:
+        if not _is_valid_operand(other):
+            return NotImplemented
+        self._values = self._elementwise(other, operator.rshift, "__irshift__")._values
+        return self
+
+    def __invert__(self) -> Waveform1D:
+        return Waveform1D(~self._values, dt=self._dt, t0=self._t0)
+
+    # MARK: - Unary operators
+
+    def __neg__(self) -> Waveform1D:
+        return Waveform1D(-self._values, dt=self._dt, t0=self._t0)
+
+    def __pos__(self) -> Waveform1D:
+        return Waveform1D(+self._values, dt=self._dt, t0=self._t0)
+
+    def __abs__(self) -> Waveform1D:
+        return Waveform1D(np.abs(self._values), dt=self._dt, t0=self._t0)
+
+    # MARK: - Comparison
+
+    def __eq__(self, other: object) -> bool:
+        """Full equality: samples (exact), ``dt``, ``t0``."""
+        if not isinstance(other, Waveform1D):
+            return NotImplemented
+        return (
+            self._dt == other._dt
+            and self._t0 == other._t0
+            and bool(np.array_equal(self._values, other._values))
+        )
+
+    __hash__ = None  # type: ignore[assignment]
+
+    def _comparable_values(
+        self, other: Waveform1D | npt.ArrayLike, op_name: str
+    ) -> npt.NDArray[Any]:
+        """Resolve ``other`` to a bare ndarray for elementwise comparison producers,
+        enforcing the same dt/length compatibility as the arithmetic operators when
+        ``other`` is a ``Waveform1D``."""
+        if isinstance(other, Waveform1D):
+            self._check_compatible(other, op_name)
+            return other._values
+        return np.asarray(other)
+
+    def elements_equal(self, other: Waveform1D | npt.ArrayLike) -> npt.NDArray[np.bool_]:
+        """Elementwise equality (see :meth:`isclose_elementwise` for tolerance)."""
+        result: npt.NDArray[np.bool_] = np.equal(
+            self._values, self._comparable_values(other, "elements_equal")
+        )
+        return result
+
+    def elements_less_than(self, other: Waveform1D | npt.ArrayLike) -> npt.NDArray[np.bool_]:
+        """Elementwise ``<``."""
+        result: npt.NDArray[np.bool_] = np.less(
+            self._values, self._comparable_values(other, "elements_less_than")
+        )
+        return result
+
+    def elements_greater_than(self, other: Waveform1D | npt.ArrayLike) -> npt.NDArray[np.bool_]:
+        """Elementwise ``>``."""
+        result: npt.NDArray[np.bool_] = np.greater(
+            self._values, self._comparable_values(other, "elements_greater_than")
+        )
+        return result
+
+    def isclose_elementwise(
+        self, other: Waveform1D | npt.ArrayLike, rtol: float = 1e-9, atol: float = 0.0
+    ) -> npt.NDArray[np.bool_]:
+        """Elementwise ``np.isclose`` (numpy ``rtol``/``atol`` vocabulary)."""
+        other_values = self._comparable_values(other, "isclose_elementwise")
+        result: npt.NDArray[np.bool_] = np.isclose(
+            self._values, other_values, rtol=rtol, atol=atol
+        )
+        return result
+
+    def isclose(self, other: Waveform1D, rtol: float = 1e-9, atol: float = 0.0) -> bool:
+        """Whole-waveform approximate equality: same ``dt``, same ``t0``, all samples close."""
+        if self._dt != other._dt or self._t0 != other._t0:
+            return False
+        if len(self._values) != len(other._values):
+            return False
+        return bool(np.all(np.isclose(self._values, other._values, rtol=rtol, atol=atol)))
+
+    # MARK: - Iteration / array interop
+
+    def __iter__(self) -> Iterator[float]:
+        return (float(v) for v in self._values)
+
+    def __array__(
+        self, dtype: npt.DTypeLike | None = None, copy: bool | None = None
+    ) -> npt.NDArray[Any]:
+        """Return the samples for ``np.asarray(w)`` interop.
+
+        Raises:
+            ValueError: If ``copy=False`` is requested -- a copy is always required
+                since the returned array must not alias the mutable backing store.
+        """
+        if copy is False:
+            raise ValueError(
+                "Waveform1D.__array__: copy=False is not supported (a copy is required)"
+            )
+        return np.array(self._values, dtype=dtype, copy=True)
+
+    def __repr__(self) -> str:
+        return (
+            f"{type(self).__name__}(sample_count={len(self._values)}, dt={self._dt!r}, "
+            f"t0={self._t0!r})"
+        )
+
+    # MARK: - DSP substrate (waveformDsp.md §Organization)
+
+    def _with_values(self, values: npt.NDArray[Any]) -> Waveform1D:
+        """A new ``Waveform1D`` with ``values`` as samples, same ``dt``/``t0`` as ``self``.
+
+        The replace-values factory every DSP mixin (waveformDsp.md) uses to
+        build its results; satisfies ``dsp/_protocol.py``'s ``WaveformProtocol``.
+        """
+        return Waveform1D(values, dt=self._dt, t0=self._t0)
+
+    def _with_axis(self, values: npt.NDArray[Any], dt: PrecisionTimeInterval) -> Waveform1D:
+        """A new ``Waveform1D`` with ``values`` as samples, a new ``dt`` spacing, and
+        ``t0`` unchanged from ``self``.
+
+        The dt-changing sibling of ``_with_values`` -- added in chunk 25 for
+        ``dsp/_resampling.py``'s ``ResamplingMixin``, the first DSP family
+        whose results have a genuinely different sample spacing than their
+        source (see ``dsp/_protocol.py``'s docstring and waveformDsp.md
+        §Organization).
+        """
+        return Waveform1D(values, dt=dt, t0=self._t0)
+
+    def _with_t0(self, values: npt.NDArray[Any], t0: PrecisionTimestamp) -> Waveform1D:
+        """A new ``Waveform1D`` with ``values`` as samples, ``dt`` unchanged from
+        ``self``, and a new ``t0``.
+
+        The t0-changing sibling of ``_with_values``/``_with_axis`` -- added in
+        chunk 26 for ``dsp/_time_alignment.py``'s ``TimeAlignmentMixin``, the
+        first DSP family whose results carry a genuinely different start time
+        than their source (see ``dsp/_protocol.py``'s docstring and
+        waveformDsp.md §Organization).
+        """
+        return Waveform1D(values, dt=self._dt, t0=t0)
diff --git a/src/math_tools/waveforms/waveform_position.py b/src/math_tools/waveforms/waveform_position.py
new file mode 100644
index 0000000..617e50f
--- /dev/null
+++ b/src/math_tools/waveforms/waveform_position.py
@@ -0,0 +1,407 @@
+"""``WaveformPosition``: a uniformly-sampled 3D position time series.
+
+See ``.claude/specs/waveformCore.md`` (§ABC accessor, §Time axis,
+§Aggregate containers with ``Element = Position``). Storage is a private
+``(n, 3)`` float64 ``np.ndarray``; ``dt``/``t0`` are the same Tier-3
+``PrecisionTimeInterval``/``PrecisionTimestamp`` time-axis types used by
+``Waveform1D`` (``waveforms/waveform1d.py``) -- the ~6 small time properties
+are copied rather than shared via a base class, per the chunk's own design
+constraint (copying is acceptable; a shared base is not justified for this
+small a surface).
+
+The ABC-required ``positions`` accessor materializes a fresh list of
+:class:`~math_tools.spatial.position.Position` objects on each access (the
+serialization/contract surface); bulk paths (``positions_array``,
+``normalize``/``normalized``, ``component_waveforms``) stay vectorized over
+the numpy storage and never round-trip through materialized ``Position``
+objects (waveformCore.md §Compliance 10).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+from typing import Any, NamedTuple, cast, overload
+
+import numpy as np
+import numpy.typing as npt
+from foundation_abc.math.waveformABCs import PositionWaveformABC
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.precision_time.precision_timestamp import PrecisionTimestamp
+from math_tools.spatial.position import Position
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+class PositionComponentWaveforms(NamedTuple):
+    """Per-axis decomposition returned by :attr:`WaveformPosition.component_waveforms`."""
+
+    x: Waveform1D
+    y: Waveform1D
+    z: Waveform1D
+
+
+def _positions_to_array(positions: Sequence[Position] | npt.ArrayLike) -> npt.NDArray[np.float64]:
+    """Coerce constructor/mutation input to a fresh ``(n, 3)`` float64 array.
+
+    Accepts a sequence of :class:`Position` elements or any array-like
+    coercible to shape ``(n, 3)``; an empty sequence becomes an ``(0, 3)``
+    array so empty construction and empty mutation payloads both work.
+
+    Raises:
+        ValueError: If the resolved array is not shape ``(n, 3)``.
+    """
+    if isinstance(positions, np.ndarray):
+        arr = np.array(positions, dtype=np.float64, copy=True)
+    elif isinstance(positions, Sequence) and len(positions) == 0:
+        arr = np.zeros((0, 3), dtype=np.float64)
+    elif isinstance(positions, Sequence) and isinstance(positions[0], Position):
+        position_items = cast(Sequence[Position], positions)
+        arr = np.array([p.vector for p in position_items], dtype=np.float64)
+    else:
+        arr = np.array(positions, dtype=np.float64)
+    if arr.ndim != 2 or arr.shape[1] != 3:
+        raise ValueError(f"WaveformPosition: positions must have shape (n, 3), got {arr.shape}")
+    return arr
+
+
+class WaveformPosition(PositionWaveformABC):
+    """A mutable, uniformly-sampled 3D position time series backed by an ``(n, 3)`` ndarray."""
+
+    # MARK: - Construction
+
+    def __init__(
+        self,
+        positions: Sequence[Position] | npt.ArrayLike,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> None:
+        """Construct from a sequence of ``Position`` elements (or raw ``(n, 3)``
+        array-like, copied) and an optional time axis.
+
+        ``dt``/``dt_seconds`` are mutually exclusive (``dt_seconds`` defaults
+        to ``1.0`` when neither is given); likewise ``t0``/``t0_seconds``
+        (``t0`` defaults to ``PrecisionTimestamp.EPOCH``).
+
+        Raises:
+            TypeError: If both ``dt`` and ``dt_seconds``, or both ``t0`` and
+                ``t0_seconds``, are given.
+            ValueError: If ``positions`` does not coerce to shape ``(n, 3)``,
+                or the resolved ``dt`` is not strictly positive.
+        """
+        if dt is not None and dt_seconds is not None:
+            raise TypeError("WaveformPosition: specify at most one of dt, dt_seconds")
+        if t0 is not None and t0_seconds is not None:
+            raise TypeError("WaveformPosition: specify at most one of t0, t0_seconds")
+
+        resolved_dt = (
+            dt
+            if dt is not None
+            else PrecisionTimeInterval.from_seconds(dt_seconds if dt_seconds is not None else 1.0)
+        )
+        if resolved_dt.total_attoseconds <= 0:
+            raise ValueError(f"WaveformPosition: dt must be strictly positive, got {resolved_dt!r}")
+
+        if t0 is not None:
+            resolved_t0 = t0
+        elif t0_seconds is not None:
+            resolved_t0 = PrecisionTimestamp.from_interval(
+                PrecisionTimeInterval.from_seconds(t0_seconds)
+            )
+        else:
+            resolved_t0 = PrecisionTimestamp.EPOCH
+
+        self._positions: npt.NDArray[np.float64] = _positions_to_array(positions)
+        self._dt = resolved_dt
+        self._t0 = resolved_t0
+
+    @classmethod
+    def from_dict(cls, obj: Any) -> WaveformPosition:
+        """Construct from the ABC wire shape ``{"positions", "t0", "dt"}``."""
+        if not isinstance(obj, dict):
+            raise TypeError(f"expected a dict, got {type(obj).__name__}")
+        dt = PrecisionTimeInterval.from_dict(obj["dt"])
+        t0 = PrecisionTimestamp.from_dict(obj["t0"])
+        positions = [Position.from_dict(p) for p in obj.get("positions", [])]
+        return cls(positions, dt=dt, t0=t0)
+
+    @classmethod
+    def from_components(cls, x: Waveform1D, y: Waveform1D, z: Waveform1D) -> WaveformPosition:
+        """Build from three per-axis ``Waveform1D``s (``dt``/``t0`` taken from ``x``).
+
+        Raises:
+            ValueError: Unless ``x``, ``y``, ``z`` all have equal length and
+                equal ``dt`` (Swift's optional-returning ``init?`` becomes a
+                raise in this port).
+        """
+        if not (len(x) == len(y) == len(z)):
+            raise ValueError(
+                "WaveformPosition.from_components: x, y, z must have equal length "
+                f"(got {len(x)}, {len(y)}, {len(z)})"
+            )
+        if not (x.dt == y.dt == z.dt):
+            raise ValueError(
+                "WaveformPosition.from_components: x, y, z must have equal dt "
+                f"(got {x.dt!r}, {y.dt!r}, {z.dt!r})"
+            )
+        positions = np.stack([x.values, y.values, z.values], axis=1).astype(np.float64)
+        return cls(positions, dt=x.dt, t0=x.t0)
+
+    # MARK: - Properties (ABC-required)
+
+    @property
+    def positions(self) -> Sequence[Position]:
+        """A fresh list of materialized ``Position`` objects (the ABC-required accessor).
+
+        Materialized on demand from :attr:`positions_array`; bulk/vectorized
+        code paths use :attr:`positions_array` directly and never go through
+        this accessor internally (waveformCore.md §Compliance 10).
+        """
+        return [Position.from_vector(row) for row in self._positions]
+
+    @property
+    def t0(self) -> PrecisionTimestamp:
+        return self._t0
+
+    @property
+    def dt(self) -> PrecisionTimeInterval:
+        return self._dt
+
+    # MARK: - Properties (numpy bulk accessor)
+
+    @property
+    def positions_array(self) -> npt.NDArray[np.float64]:
+        """A copy of the ``(n, 3)`` sample array."""
+        return np.array(self._positions, dtype=np.float64, copy=True)
+
+    # MARK: - Properties (time axis; copied from Waveform1D, see module docstring)
+
+    @property
+    def duration(self) -> PrecisionTimeInterval:
+        """The span from the first to the last sample (``ZERO`` when ``n <= 1``)."""
+        n = len(self._positions)
+        if n <= 1:
+            return PrecisionTimeInterval.ZERO
+        return self._dt * (n - 1)
+
+    @property
+    def duration_seconds(self) -> float:
+        return self.duration.seconds_as_float
+
+    @property
+    def sampling_frequency_hz(self) -> float:
+        return 1.0 / self._dt.seconds_as_float
+
+    @property
+    def nyquist_frequency_hz(self) -> float:
+        return self.sampling_frequency_hz / 2.0
+
+    @property
+    def sample_count(self) -> int:
+        return len(self._positions)
+
+    def __len__(self) -> int:
+        return len(self._positions)
+
+    def time_axis(self) -> npt.NDArray[np.float64]:
+        """Sample times (seconds, relative to ``t0``) as a float64 array."""
+        n = len(self._positions)
+        return np.arange(n, dtype=np.float64) * self._dt.seconds_as_float
+
+    # MARK: - Component decomposition
+
+    @property
+    def component_waveforms(self) -> PositionComponentWaveforms:
+        """Decompose into per-axis ``(x, y, z)`` ``Waveform1D``s sharing this ``dt``/``t0``."""
+        return PositionComponentWaveforms(
+            x=Waveform1D(self._positions[:, 0], dt=self._dt, t0=self._t0),
+            y=Waveform1D(self._positions[:, 1], dt=self._dt, t0=self._t0),
+            z=Waveform1D(self._positions[:, 2], dt=self._dt, t0=self._t0),
+        )
+
+    # MARK: - Normalization
+
+    @property
+    def are_all_unit(self) -> bool:
+        """Whether every position is (approximately) a unit vector (vectorized)."""
+        if len(self._positions) == 0:
+            return True
+        norms = np.linalg.norm(self._positions, axis=1)
+        return bool(np.all(np.isclose(norms, 1.0, atol=1e-12)))
+
+    def normalize(self) -> None:
+        """Normalize every position to unit length, in place (vectorized).
+
+        Raises:
+            ValueError: If any row has zero magnitude (parity with
+                ``Position.normalize``'s own zero-magnitude ``ValueError``).
+        """
+        norms = np.linalg.norm(self._positions, axis=1)
+        zero_indices = np.flatnonzero(norms == 0.0)
+        if zero_indices.size > 0:
+            raise ValueError(
+                f"cannot normalize a zero-magnitude position at index {int(zero_indices[0])}"
+            )
+        self._positions = self._positions / norms[:, np.newaxis]
+
+    def normalized(self) -> WaveformPosition:
+        """Return a normalized (unit) copy of this waveform (vectorized).
+
+        Raises:
+            ValueError: If any row has zero magnitude.
+        """
+        result = WaveformPosition(self._positions, dt=self._dt, t0=self._t0)
+        result.normalize()
+        return result
+
+    # MARK: - Indexing / slicing
+
+    @overload
+    def __getitem__(self, index: int) -> Position: ...
+    @overload
+    def __getitem__(self, index: slice) -> WaveformPosition: ...
+
+    def __getitem__(self, index: int | slice) -> Position | WaveformPosition:
+        if isinstance(index, slice):
+            if index.step is not None and index.step != 1:
+                raise ValueError(
+                    "WaveformPosition slicing does not support step != 1; resampling is "
+                    "the explicit API"
+                )
+            start, stop, _ = index.indices(len(self._positions))
+            new_t0 = self._t0 + self._dt * start
+            return WaveformPosition(self._positions[start:stop], dt=self._dt, t0=new_t0)
+        return Position.from_vector(self._positions[index])
+
+    def get(self, index: int) -> Position | None:
+        """Like ``__getitem__(int)`` but returns ``None`` instead of raising when
+        ``index`` is out of range (Swift's ``subscript(safe:)``)."""
+        n = len(self._positions)
+        resolved = index + n if index < 0 else index
+        if resolved < 0 or resolved >= n:
+            return None
+        return Position.from_vector(self._positions[resolved])
+
+    def __iter__(self) -> Iterator[Position]:
+        return (Position.from_vector(row) for row in self._positions)
+
+    def __array__(
+        self, dtype: npt.DTypeLike | None = None, copy: bool | None = None
+    ) -> npt.NDArray[Any]:
+        """Return the ``(sample_count, 3)`` position array for ``np.asarray(w)`` interop
+        (mathToolsArchitecture.md §API idioms).
+
+        Raises:
+            ValueError: If ``copy=False`` is requested -- a copy is always required
+                since the returned array must not alias the mutable backing store.
+        """
+        if copy is False:
+            raise ValueError(
+                "WaveformPosition.__array__: copy=False is not supported (a copy is required)"
+            )
+        return np.array(self._positions, dtype=dtype, copy=True)
+
+    # MARK: - Mutation
+
+    def append(self, value: Position) -> None:
+        self._positions = np.concatenate([self._positions, value.vector.reshape(1, 3)], axis=0)
+
+    def append_values(self, values: Sequence[Position]) -> None:
+        addition = _positions_to_array(values)
+        self._positions = np.concatenate([self._positions, addition], axis=0)
+
+    def prepend(self, value: Position) -> None:
+        self._positions = np.concatenate([value.vector.reshape(1, 3), self._positions], axis=0)
+        self._t0 = self._t0 - self._dt
+
+    def prepend_values(self, values: Sequence[Position]) -> None:
+        addition = _positions_to_array(values)
+        self._positions = np.concatenate([addition, self._positions], axis=0)
+        self._t0 = self._t0 - self._dt * len(addition)
+
+    def insert(self, index: int, value: Position) -> None:
+        self._positions = np.insert(self._positions, index, value.vector, axis=0)
+
+    def replace(self, index: int, value: Position) -> None:
+        self._positions[index] = value.vector
+
+    def replace_range(self, index: slice, values: Sequence[Position]) -> None:
+        self._positions[index] = _positions_to_array(values)
+
+    def pop(self, index: int = -1) -> Position:
+        """Remove and return the position at ``index`` (default: last).
+
+        Raises:
+            IndexError: If the waveform is empty, or ``index`` is out of range.
+        """
+        if len(self._positions) == 0:
+            raise IndexError("pop from an empty WaveformPosition")
+        value = Position.from_vector(self._positions[index])
+        self._positions = np.delete(self._positions, index, axis=0)
+        return value
+
+    def clear(self) -> None:
+        self._positions = np.zeros((0, 3), dtype=np.float64)
+
+    # MARK: - Extend / concatenate
+
+    def _check_compatible_dt(self, other: WaveformPosition, op_name: str) -> None:
+        """Raise ``WaveformCompatibilityError`` unless ``other`` shares this waveform's ``dt``
+        (waveformCore.md §Aggregate containers Mutation; no length constraint -- these are
+        concatenation ops, not elementwise ones)."""
+        if self._dt != other._dt:
+            raise WaveformCompatibilityError(
+                f"WaveformPosition.{op_name}: dt mismatch ({self._dt!r} vs {other._dt!r})"
+            )
+
+    def extend(self, other: WaveformPosition) -> None:
+        """Append ``other``'s positions to this waveform, in place.
+
+        Raises:
+            WaveformCompatibilityError: If ``other.dt`` differs from ``self.dt``.
+        """
+        self._check_compatible_dt(other, "extend")
+        self._positions = np.concatenate([self._positions, other._positions], axis=0)
+
+    def concatenate(self, other: WaveformPosition) -> WaveformPosition:
+        """Return a new waveform with ``other``'s positions appended after this one's.
+
+        Raises:
+            WaveformCompatibilityError: If ``other.dt`` differs from ``self.dt``.
+        """
+        self._check_compatible_dt(other, "concatenate")
+        combined = np.concatenate([self._positions, other._positions], axis=0)
+        return WaveformPosition(combined, dt=self._dt, t0=self._t0)
+
+    # MARK: - Comparison
+
+    def __eq__(self, other: object) -> bool:
+        """Full equality: positions (exact), ``dt``, ``t0``."""
+        if not isinstance(other, WaveformPosition):
+            return NotImplemented
+        return (
+            self._dt == other._dt
+            and self._t0 == other._t0
+            and bool(np.array_equal(self._positions, other._positions))
+        )
+
+    def isclose(self, other: WaveformPosition, rtol: float = 1e-9, atol: float = 0.0) -> bool:
+        """Whole-waveform approximate equality: same ``sample_count``, same ``dt``,
+        same ``t0``, all positions close (numpy ``rtol``/``atol`` vocabulary, mirroring
+        :meth:`~math_tools.spatial.position.Position.isclose`'s parameter order/defaults).
+        """
+        if self.sample_count != other.sample_count:
+            return False
+        if self._dt != other._dt or self._t0 != other._t0:
+            return False
+        return bool(np.allclose(self._positions, other._positions, rtol=rtol, atol=atol))
+
+    __hash__ = None  # type: ignore[assignment]
+
+    def __repr__(self) -> str:
+        return (
+            f"{type(self).__name__}(sample_count={len(self._positions)}, dt={self._dt!r}, "
+            f"t0={self._t0!r})"
+        )
diff --git a/src/math_tools/waveforms/waveform_quaternion.py b/src/math_tools/waveforms/waveform_quaternion.py
new file mode 100644
index 0000000..3554851
--- /dev/null
+++ b/src/math_tools/waveforms/waveform_quaternion.py
@@ -0,0 +1,446 @@
+"""``WaveformQuaternion``: a uniformly-sampled quaternion (orientation) time series.
+
+See ``.claude/specs/waveformCore.md`` (§ABC accessor, §Time axis,
+§Aggregate containers with ``Element = Quaternion``). Storage is a private
+``(n, 4)`` float64 ``np.ndarray`` in **``(w, x, y, z)`` order** (pinned
+repo-wide -- NOT Swift's x-first order); ``dt``/``t0`` are the same Tier-3
+``PrecisionTimeInterval``/``PrecisionTimestamp`` time-axis types used by
+``Waveform1D`` (``waveforms/waveform1d.py``) -- the ~6 small time properties
+are copied rather than shared via a base class, mirroring
+``WaveformPosition``'s (chunk 15) own precedent (copying is acceptable; a
+shared base is not justified for this small a surface).
+
+The ABC-required ``quaternions`` accessor materializes a fresh list of
+:class:`~math_tools.spatial.quaternion.Quaternion` objects on each access
+(the serialization/contract surface); bulk paths (``quaternions_array``,
+``normalize``/``normalized``, ``component_waveforms``, ``are_all_unit``)
+stay vectorized over the numpy storage and never round-trip through
+materialized ``Quaternion`` objects (waveformCore.md §Compliance 10).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+from typing import Any, NamedTuple, cast, overload
+
+import numpy as np
+import numpy.typing as npt
+from foundation_abc.math.waveformABCs import QuaternionWaveformABC
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.precision_time.precision_timestamp import PrecisionTimestamp
+from math_tools.spatial.quaternion import Quaternion
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+class QuaternionComponentWaveforms(NamedTuple):
+    """Per-component decomposition returned by :attr:`WaveformQuaternion.component_waveforms`.
+
+    Field order is ``(w, x, y, z)`` -- w-first, matching storage order,
+    ``from_components``, and ``Quaternion.to_components()``. This is the one
+    place this container explicitly diverges from the Swift x-first tuple
+    order.
+    """
+
+    w: Waveform1D
+    x: Waveform1D
+    y: Waveform1D
+    z: Waveform1D
+
+
+def _quaternions_to_array(
+    quaternions: Sequence[Quaternion] | npt.ArrayLike,
+) -> npt.NDArray[np.float64]:
+    """Coerce constructor/mutation input to a fresh ``(n, 4)`` float64 array in
+    ``(w, x, y, z)`` order.
+
+    Accepts a sequence of :class:`Quaternion` elements or any array-like
+    coercible to shape ``(n, 4)``; an empty sequence becomes an ``(0, 4)``
+    array so empty construction and empty mutation payloads both work.
+
+    Raises:
+        ValueError: If the resolved array is not shape ``(n, 4)``.
+    """
+    if isinstance(quaternions, np.ndarray):
+        arr = np.array(quaternions, dtype=np.float64, copy=True)
+    elif isinstance(quaternions, Sequence) and len(quaternions) == 0:
+        arr = np.zeros((0, 4), dtype=np.float64)
+    elif isinstance(quaternions, Sequence) and isinstance(quaternions[0], Quaternion):
+        quaternion_items = cast(Sequence[Quaternion], quaternions)
+        arr = np.array([q.as_float_array() for q in quaternion_items], dtype=np.float64)
+    else:
+        arr = np.array(quaternions, dtype=np.float64)
+    if arr.ndim != 2 or arr.shape[1] != 4:
+        raise ValueError(f"WaveformQuaternion: quaternions must have shape (n, 4), got {arr.shape}")
+    return arr
+
+
+class WaveformQuaternion(QuaternionWaveformABC):
+    """A mutable, uniformly-sampled quaternion time series backed by an ``(n, 4)`` ndarray."""
+
+    # MARK: - Construction
+
+    def __init__(
+        self,
+        quaternions: Sequence[Quaternion] | npt.ArrayLike,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> None:
+        """Construct from a sequence of ``Quaternion`` elements (or raw ``(n, 4)``
+        array-like in ``(w, x, y, z)`` order, copied) and an optional time axis.
+
+        ``dt``/``dt_seconds`` are mutually exclusive (``dt_seconds`` defaults
+        to ``1.0`` when neither is given); likewise ``t0``/``t0_seconds``
+        (``t0`` defaults to ``PrecisionTimestamp.EPOCH``).
+
+        Raises:
+            TypeError: If both ``dt`` and ``dt_seconds``, or both ``t0`` and
+                ``t0_seconds``, are given.
+            ValueError: If ``quaternions`` does not coerce to shape
+                ``(n, 4)``, or the resolved ``dt`` is not strictly positive.
+        """
+        if dt is not None and dt_seconds is not None:
+            raise TypeError("WaveformQuaternion: specify at most one of dt, dt_seconds")
+        if t0 is not None and t0_seconds is not None:
+            raise TypeError("WaveformQuaternion: specify at most one of t0, t0_seconds")
+
+        resolved_dt = (
+            dt
+            if dt is not None
+            else PrecisionTimeInterval.from_seconds(dt_seconds if dt_seconds is not None else 1.0)
+        )
+        if resolved_dt.total_attoseconds <= 0:
+            raise ValueError(
+                f"WaveformQuaternion: dt must be strictly positive, got {resolved_dt!r}"
+            )
+
+        if t0 is not None:
+            resolved_t0 = t0
+        elif t0_seconds is not None:
+            resolved_t0 = PrecisionTimestamp.from_interval(
+                PrecisionTimeInterval.from_seconds(t0_seconds)
+            )
+        else:
+            resolved_t0 = PrecisionTimestamp.EPOCH
+
+        self._quaternions: npt.NDArray[np.float64] = _quaternions_to_array(quaternions)
+        self._dt = resolved_dt
+        self._t0 = resolved_t0
+
+    @classmethod
+    def from_dict(cls, obj: Any) -> WaveformQuaternion:
+        """Construct from the ABC wire shape ``{"quaternions", "t0", "dt"}``."""
+        if not isinstance(obj, dict):
+            raise TypeError(f"expected a dict, got {type(obj).__name__}")
+        dt = PrecisionTimeInterval.from_dict(obj["dt"])
+        t0 = PrecisionTimestamp.from_dict(obj["t0"])
+        quaternions = [Quaternion.from_dict(q) for q in obj.get("quaternions", [])]
+        return cls(quaternions, dt=dt, t0=t0)
+
+    @classmethod
+    def from_components(
+        cls, w: Waveform1D, x: Waveform1D, y: Waveform1D, z: Waveform1D
+    ) -> WaveformQuaternion:
+        """Build from four per-component ``Waveform1D``s (``dt``/``t0`` taken from ``w``).
+
+        Args:
+            w: The scalar (real) component waveform.
+            x: The x component (vector part) waveform.
+            y: The y component (vector part) waveform.
+            z: The z component (vector part) waveform.
+
+        Raises:
+            ValueError: Unless ``w``, ``x``, ``y``, ``z`` all have equal
+                length and equal ``dt`` (Swift's optional-returning ``init?``
+                becomes a raise in this port).
+        """
+        if not (len(w) == len(x) == len(y) == len(z)):
+            raise ValueError(
+                "WaveformQuaternion.from_components: w, x, y, z must have equal length "
+                f"(got {len(w)}, {len(x)}, {len(y)}, {len(z)})"
+            )
+        if not (w.dt == x.dt == y.dt == z.dt):
+            raise ValueError(
+                "WaveformQuaternion.from_components: w, x, y, z must have equal dt "
+                f"(got {w.dt!r}, {x.dt!r}, {y.dt!r}, {z.dt!r})"
+            )
+        quaternions = np.stack([w.values, x.values, y.values, z.values], axis=1).astype(np.float64)
+        return cls(quaternions, dt=w.dt, t0=w.t0)
+
+    # MARK: - Properties (ABC-required)
+
+    @property
+    def quaternions(self) -> Sequence[Quaternion]:
+        """A fresh list of materialized ``Quaternion`` objects (the ABC-required accessor).
+
+        Materialized on demand from :attr:`quaternions_array`; bulk/vectorized
+        code paths use :attr:`quaternions_array` directly and never go through
+        this accessor internally (waveformCore.md §Compliance 10).
+        """
+        return [Quaternion.from_float_array(row) for row in self._quaternions]
+
+    @property
+    def t0(self) -> PrecisionTimestamp:
+        return self._t0
+
+    @property
+    def dt(self) -> PrecisionTimeInterval:
+        return self._dt
+
+    # MARK: - Properties (numpy bulk accessor)
+
+    @property
+    def quaternions_array(self) -> npt.NDArray[np.float64]:
+        """A copy of the ``(n, 4)`` sample array, ``(w, x, y, z)`` order."""
+        return np.array(self._quaternions, dtype=np.float64, copy=True)
+
+    # MARK: - Properties (time axis; copied from Waveform1D, see module docstring)
+
+    @property
+    def duration(self) -> PrecisionTimeInterval:
+        """The span from the first to the last sample (``ZERO`` when ``n <= 1``)."""
+        n = len(self._quaternions)
+        if n <= 1:
+            return PrecisionTimeInterval.ZERO
+        return self._dt * (n - 1)
+
+    @property
+    def duration_seconds(self) -> float:
+        return self.duration.seconds_as_float
+
+    @property
+    def sampling_frequency_hz(self) -> float:
+        return 1.0 / self._dt.seconds_as_float
+
+    @property
+    def nyquist_frequency_hz(self) -> float:
+        return self.sampling_frequency_hz / 2.0
+
+    @property
+    def sample_count(self) -> int:
+        return len(self._quaternions)
+
+    def __len__(self) -> int:
+        return len(self._quaternions)
+
+    def time_axis(self) -> npt.NDArray[np.float64]:
+        """Sample times (seconds, relative to ``t0``) as a float64 array."""
+        n = len(self._quaternions)
+        return np.arange(n, dtype=np.float64) * self._dt.seconds_as_float
+
+    # MARK: - Component decomposition
+
+    @property
+    def component_waveforms(self) -> QuaternionComponentWaveforms:
+        """Decompose into per-component ``(w, x, y, z)`` ``Waveform1D``s sharing this
+        ``dt``/``t0``."""
+        return QuaternionComponentWaveforms(
+            w=Waveform1D(self._quaternions[:, 0], dt=self._dt, t0=self._t0),
+            x=Waveform1D(self._quaternions[:, 1], dt=self._dt, t0=self._t0),
+            y=Waveform1D(self._quaternions[:, 2], dt=self._dt, t0=self._t0),
+            z=Waveform1D(self._quaternions[:, 3], dt=self._dt, t0=self._t0),
+        )
+
+    # MARK: - Normalization
+
+    @property
+    def are_all_unit(self) -> bool:
+        """Whether every quaternion is (approximately) unit length (vectorized)."""
+        if len(self._quaternions) == 0:
+            return True
+        norms = np.linalg.norm(self._quaternions, axis=1)
+        return bool(np.all(np.isclose(norms, 1.0, atol=1e-12)))
+
+    def normalize(self) -> None:
+        """Normalize every quaternion to unit length, in place (vectorized).
+
+        Raises:
+            ValueError: If any row has zero magnitude (parity with
+                ``Position.normalize``'s own zero-magnitude ``ValueError``
+                style, mirroring ``WaveformPosition.normalize``).
+        """
+        norms = np.linalg.norm(self._quaternions, axis=1)
+        zero_indices = np.flatnonzero(norms == 0.0)
+        if zero_indices.size > 0:
+            raise ValueError(
+                f"cannot normalize a zero-magnitude quaternion at index {int(zero_indices[0])}"
+            )
+        self._quaternions = self._quaternions / norms[:, np.newaxis]
+
+    def normalized(self) -> WaveformQuaternion:
+        """Return a normalized (unit) copy of this waveform (vectorized).
+
+        Raises:
+            ValueError: If any row has zero magnitude.
+        """
+        result = WaveformQuaternion(self._quaternions, dt=self._dt, t0=self._t0)
+        result.normalize()
+        return result
+
+    # MARK: - Indexing / slicing
+
+    @overload
+    def __getitem__(self, index: int) -> Quaternion: ...
+    @overload
+    def __getitem__(self, index: slice) -> WaveformQuaternion: ...
+
+    def __getitem__(self, index: int | slice) -> Quaternion | WaveformQuaternion:
+        if isinstance(index, slice):
+            if index.step is not None and index.step != 1:
+                raise ValueError(
+                    "WaveformQuaternion slicing does not support step != 1; resampling is "
+                    "the explicit API"
+                )
+            start, stop, _ = index.indices(len(self._quaternions))
+            new_t0 = self._t0 + self._dt * start
+            return WaveformQuaternion(self._quaternions[start:stop], dt=self._dt, t0=new_t0)
+        return Quaternion.from_float_array(self._quaternions[index])
+
+    def get(self, index: int) -> Quaternion | None:
+        """Like ``__getitem__(int)`` but returns ``None`` instead of raising when
+        ``index`` is out of range (Swift's ``subscript(safe:)``)."""
+        n = len(self._quaternions)
+        resolved = index + n if index < 0 else index
+        if resolved < 0 or resolved >= n:
+            return None
+        return Quaternion.from_float_array(self._quaternions[resolved])
+
+    def __iter__(self) -> Iterator[Quaternion]:
+        return (Quaternion.from_float_array(row) for row in self._quaternions)
+
+    def __array__(
+        self, dtype: npt.DTypeLike | None = None, copy: bool | None = None
+    ) -> npt.NDArray[Any]:
+        """Return the ``(sample_count, 4)`` ``(w, x, y, z)`` quaternion array for
+        ``np.asarray(w)`` interop (mathToolsArchitecture.md §API idioms).
+
+        Raises:
+            ValueError: If ``copy=False`` is requested -- a copy is always required
+                since the returned array must not alias the mutable backing store.
+        """
+        if copy is False:
+            raise ValueError(
+                "WaveformQuaternion.__array__: copy=False is not supported (a copy is required)"
+            )
+        return np.array(self._quaternions, dtype=dtype, copy=True)
+
+    # MARK: - Mutation
+
+    def append(self, value: Quaternion) -> None:
+        self._quaternions = np.concatenate(
+            [self._quaternions, value.as_float_array().reshape(1, 4)], axis=0
+        )
+
+    def append_values(self, values: Sequence[Quaternion]) -> None:
+        addition = _quaternions_to_array(values)
+        self._quaternions = np.concatenate([self._quaternions, addition], axis=0)
+
+    def prepend(self, value: Quaternion) -> None:
+        self._quaternions = np.concatenate(
+            [value.as_float_array().reshape(1, 4), self._quaternions], axis=0
+        )
+        self._t0 = self._t0 - self._dt
+
+    def prepend_values(self, values: Sequence[Quaternion]) -> None:
+        addition = _quaternions_to_array(values)
+        self._quaternions = np.concatenate([addition, self._quaternions], axis=0)
+        self._t0 = self._t0 - self._dt * len(addition)
+
+    def insert(self, index: int, value: Quaternion) -> None:
+        self._quaternions = np.insert(self._quaternions, index, value.as_float_array(), axis=0)
+
+    def replace(self, index: int, value: Quaternion) -> None:
+        self._quaternions[index] = value.as_float_array()
+
+    def replace_range(self, index: slice, values: Sequence[Quaternion]) -> None:
+        self._quaternions[index] = _quaternions_to_array(values)
+
+    def pop(self, index: int = -1) -> Quaternion:
+        """Remove and return the quaternion at ``index`` (default: last).
+
+        Raises:
+            IndexError: If the waveform is empty, or ``index`` is out of range.
+        """
+        if len(self._quaternions) == 0:
+            raise IndexError("pop from an empty WaveformQuaternion")
+        value = Quaternion.from_float_array(self._quaternions[index])
+        self._quaternions = np.delete(self._quaternions, index, axis=0)
+        return value
+
+    def clear(self) -> None:
+        self._quaternions = np.zeros((0, 4), dtype=np.float64)
+
+    # MARK: - Extend / concatenate
+
+    def _check_compatible_dt(self, other: WaveformQuaternion, op_name: str) -> None:
+        """Raise ``WaveformCompatibilityError`` unless ``other`` shares this waveform's ``dt``
+        (waveformCore.md §Aggregate containers Mutation; no length constraint -- these are
+        concatenation ops, not elementwise ones)."""
+        if self._dt != other._dt:
+            raise WaveformCompatibilityError(
+                f"WaveformQuaternion.{op_name}: dt mismatch ({self._dt!r} vs {other._dt!r})"
+            )
+
+    def extend(self, other: WaveformQuaternion) -> None:
+        """Append ``other``'s quaternions to this waveform, in place.
+
+        Raises:
+            WaveformCompatibilityError: If ``other.dt`` differs from ``self.dt``.
+        """
+        self._check_compatible_dt(other, "extend")
+        self._quaternions = np.concatenate([self._quaternions, other._quaternions], axis=0)
+
+    def concatenate(self, other: WaveformQuaternion) -> WaveformQuaternion:
+        """Return a new waveform with ``other``'s quaternions appended after this one's.
+
+        Raises:
+            WaveformCompatibilityError: If ``other.dt`` differs from ``self.dt``.
+        """
+        self._check_compatible_dt(other, "concatenate")
+        combined = np.concatenate([self._quaternions, other._quaternions], axis=0)
+        return WaveformQuaternion(combined, dt=self._dt, t0=self._t0)
+
+    # MARK: - Comparison
+
+    def __eq__(self, other: object) -> bool:
+        """Full equality: quaternions (exact), ``dt``, ``t0``."""
+        if not isinstance(other, WaveformQuaternion):
+            return NotImplemented
+        return (
+            self._dt == other._dt
+            and self._t0 == other._t0
+            and bool(np.array_equal(self._quaternions, other._quaternions))
+        )
+
+    def isclose(
+        self, other: WaveformQuaternion, rtol: float = 1e-9, atol: float = 1e-11
+    ) -> bool:
+        """Whole-waveform approximate equality: same ``sample_count``, same ``dt``,
+        same ``t0``, all quaternions close (numpy ``rtol``/``atol`` vocabulary and
+        defaults mirroring :meth:`~math_tools.spatial.quaternion.Quaternion.isclose`).
+
+        Double-cover aware **per sample**: each row independently may match either
+        ``other``'s row or its negation (``q`` and ``-q`` are the same rotation), so
+        a copy with every quaternion row negated still compares ``isclose``.
+        """
+        if self.sample_count != other.sample_count:
+            return False
+        if self._dt != other._dt or self._t0 != other._t0:
+            return False
+        if self.sample_count == 0:
+            return True
+        same_sign = np.isclose(self._quaternions, other._quaternions, rtol=rtol, atol=atol)
+        flipped_sign = np.isclose(self._quaternions, -other._quaternions, rtol=rtol, atol=atol)
+        row_matches = np.all(same_sign, axis=1) | np.all(flipped_sign, axis=1)
+        return bool(np.all(row_matches))
+
+    __hash__ = None  # type: ignore[assignment]
+
+    def __repr__(self) -> str:
+        return (
+            f"{type(self).__name__}(sample_count={len(self._quaternions)}, dt={self._dt!r}, "
+            f"t0={self._t0!r})"
+        )
diff --git a/src/math_tools/waveforms/waveform_spatial_pose.py b/src/math_tools/waveforms/waveform_spatial_pose.py
new file mode 100644
index 0000000..5512370
--- /dev/null
+++ b/src/math_tools/waveforms/waveform_spatial_pose.py
@@ -0,0 +1,743 @@
+"""``WaveformSpatialPose``: a uniformly-sampled 6-DOF pose time series.
+
+See ``.claude/specs/waveformCore.md`` (§ABC accessor, §Time axis,
+§Aggregate containers, §Compliance 1, 2, 8, 9). Unlike
+:class:`~math_tools.waveforms.waveform_position.WaveformPosition` and
+:class:`~math_tools.waveforms.waveform_quaternion.WaveformQuaternion`, this
+container is backed by TWO independent parallel arrays -- a private
+``(n, 3)`` float64 position array and a private ``(n, 4)`` float64
+quaternion array (``(w, x, y, z)`` order, matching
+:class:`~math_tools.waveforms.waveform_quaternion.WaveformQuaternion`) --
+rather than one, because it composes a position-like array and a
+quaternion-like array side by side. ``dt``/``t0`` are the same Tier-3
+``PrecisionTimeInterval``/``PrecisionTimestamp`` time-axis types used
+elsewhere in this package; the ~6 small time properties are copied rather
+than shared via a base class, mirroring ``WaveformPosition``/
+``WaveformQuaternion``'s own precedent.
+
+**Load-bearing subtlety (waveformCore.md §Compliance 9):** the two arrays
+are allowed to have DIFFERENT lengths. The primary constructor deliberately
+does NOT require ``positions`` and ``quaternions`` to have equal length --
+only the higher-level ``from_waveforms`` convenience constructor validates
+count (and ``dt``) equality, raising ``ValueError``. This keeps
+``is_valid``/``sample_count`` real, reachable semantics: ``is_valid`` is
+``True`` only when the two arrays have equal length, and ``sample_count``
+(and ``__len__``) is ``min(len(positions), len(quaternions))`` -- NOT simply
+one array's length. All other time-axis properties (``duration``,
+``time_axis()``, slicing, ``get``/iteration bounds) are derived from
+``sample_count`` so they stay internally consistent with that "valid
+prefix" even when the two arrays have been directly manipulated into an
+unequal-length state. Higher-level constructors (``from_poses``,
+``from_waveforms``) naturally produce equal-length (valid) instances.
+
+The ABC-required ``positions``/``quaternions`` accessors materialize fresh
+lists of :class:`~math_tools.spatial.position.Position` /
+:class:`~math_tools.spatial.quaternion.Quaternion` objects on each access
+(the serialization/contract surface); bulk paths (``positions_array``,
+``quaternions_array``, ``normalize``/``normalized``, ``component_waveforms``,
+``are_all_positions_unit``/``are_all_quaternions_unit``) stay vectorized
+over the numpy storage and never round-trip through materialized objects
+(waveformCore.md §Compliance 10).
+"""
+
+from __future__ import annotations
+
+from collections.abc import Iterator, Sequence
+from typing import Any, NamedTuple, cast, overload
+
+import numpy as np
+import numpy.typing as npt
+from foundation_abc.math.waveformABCs import WaveformSpatialABC
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.precision_time.precision_timestamp import PrecisionTimestamp
+from math_tools.spatial.position import Position
+from math_tools.spatial.quaternion import Quaternion
+from math_tools.spatial.spatial_pose import SpatialPose
+from math_tools.waveforms.waveform1d import Waveform1D
+from math_tools.waveforms.waveform_position import PositionComponentWaveforms, WaveformPosition
+from math_tools.waveforms.waveform_quaternion import (
+    QuaternionComponentWaveforms,
+    WaveformQuaternion,
+)
+
+
+class SpatialPoseComponentWaveforms(NamedTuple):
+    """Nested per-component decomposition returned by
+    :attr:`WaveformSpatialPose.component_waveforms`.
+
+    ``position`` reuses :class:`PositionComponentWaveforms`
+    (``x, y, z``, chunk 15) and ``quaternion`` reuses
+    :class:`QuaternionComponentWaveforms` (``w, x, y, z``, w-first, chunk
+    16) rather than redefining equivalent ``NamedTuple``s.
+    """
+
+    position: PositionComponentWaveforms
+    quaternion: QuaternionComponentWaveforms
+
+
+def _positions_to_array(positions: Sequence[Position] | npt.ArrayLike) -> npt.NDArray[np.float64]:
+    """Coerce constructor/mutation input to a fresh ``(n, 3)`` float64 array.
+
+    Accepts a sequence of :class:`Position` elements or any array-like
+    coercible to shape ``(n, 3)``; an empty sequence becomes an ``(0, 3)``
+    array so empty construction and empty mutation payloads both work.
+
+    Raises:
+        ValueError: If the resolved array is not shape ``(n, 3)``.
+    """
+    if isinstance(positions, np.ndarray):
+        arr = np.array(positions, dtype=np.float64, copy=True)
+    elif isinstance(positions, Sequence) and len(positions) == 0:
+        arr = np.zeros((0, 3), dtype=np.float64)
+    elif isinstance(positions, Sequence) and isinstance(positions[0], Position):
+        position_items = cast(Sequence[Position], positions)
+        arr = np.array([p.vector for p in position_items], dtype=np.float64)
+    else:
+        arr = np.array(positions, dtype=np.float64)
+    if arr.ndim != 2 or arr.shape[1] != 3:
+        raise ValueError(f"WaveformSpatialPose: positions must have shape (n, 3), got {arr.shape}")
+    return arr
+
+
+def _quaternions_to_array(
+    quaternions: Sequence[Quaternion] | npt.ArrayLike,
+) -> npt.NDArray[np.float64]:
+    """Coerce constructor/mutation input to a fresh ``(n, 4)`` float64 array in
+    ``(w, x, y, z)`` order.
+
+    Accepts a sequence of :class:`Quaternion` elements or any array-like
+    coercible to shape ``(n, 4)``; an empty sequence becomes an ``(0, 4)``
+    array so empty construction and empty mutation payloads both work.
+
+    Raises:
+        ValueError: If the resolved array is not shape ``(n, 4)``.
+    """
+    if isinstance(quaternions, np.ndarray):
+        arr = np.array(quaternions, dtype=np.float64, copy=True)
+    elif isinstance(quaternions, Sequence) and len(quaternions) == 0:
+        arr = np.zeros((0, 4), dtype=np.float64)
+    elif isinstance(quaternions, Sequence) and isinstance(quaternions[0], Quaternion):
+        quaternion_items = cast(Sequence[Quaternion], quaternions)
+        arr = np.array([q.as_float_array() for q in quaternion_items], dtype=np.float64)
+    else:
+        arr = np.array(quaternions, dtype=np.float64)
+    if arr.ndim != 2 or arr.shape[1] != 4:
+        raise ValueError(
+            f"WaveformSpatialPose: quaternions must have shape (n, 4), got {arr.shape}"
+        )
+    return arr
+
+
+def _poses_to_arrays(
+    poses: Sequence[SpatialPose],
+) -> tuple[npt.NDArray[np.float64], npt.NDArray[np.float64]]:
+    """Decompose a sequence of :class:`SpatialPose` into parallel position/quaternion arrays."""
+    if len(poses) == 0:
+        return np.zeros((0, 3), dtype=np.float64), np.zeros((0, 4), dtype=np.float64)
+    positions = np.array([pose.position.vector for pose in poses], dtype=np.float64)
+    quaternions = np.array([pose.orientation.as_float_array() for pose in poses], dtype=np.float64)
+    return positions, quaternions
+
+
+class WaveformSpatialPose(WaveformSpatialABC):
+    """A mutable, uniformly-sampled 6-DOF pose time series backed by parallel
+    ``(n, 3)`` position and ``(n, 4)`` quaternion ndarrays."""
+
+    # MARK: - Construction
+
+    def __init__(
+        self,
+        positions: Sequence[Position] | npt.ArrayLike,
+        quaternions: Sequence[Quaternion] | npt.ArrayLike,
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> None:
+        """Construct from parallel position/quaternion sequences (each a
+        sequence of elements, or a raw array-like, copied) and an optional
+        time axis.
+
+        ``dt``/``dt_seconds`` are mutually exclusive (``dt_seconds`` defaults
+        to ``1.0`` when neither is given); likewise ``t0``/``t0_seconds``
+        (``t0`` defaults to ``PrecisionTimestamp.EPOCH``).
+
+        Unlike :meth:`from_waveforms`, this primary constructor does NOT
+        require ``positions`` and ``quaternions`` to have equal length --
+        see the module docstring's note on ``is_valid``/``sample_count``.
+
+        Raises:
+            TypeError: If both ``dt`` and ``dt_seconds``, or both ``t0`` and
+                ``t0_seconds``, are given.
+            ValueError: If ``positions``/``quaternions`` do not coerce to
+                shape ``(n, 3)``/``(n, 4)`` respectively, or the resolved
+                ``dt`` is not strictly positive.
+        """
+        if dt is not None and dt_seconds is not None:
+            raise TypeError("WaveformSpatialPose: specify at most one of dt, dt_seconds")
+        if t0 is not None and t0_seconds is not None:
+            raise TypeError("WaveformSpatialPose: specify at most one of t0, t0_seconds")
+
+        resolved_dt = (
+            dt
+            if dt is not None
+            else PrecisionTimeInterval.from_seconds(dt_seconds if dt_seconds is not None else 1.0)
+        )
+        if resolved_dt.total_attoseconds <= 0:
+            raise ValueError(
+                f"WaveformSpatialPose: dt must be strictly positive, got {resolved_dt!r}"
+            )
+
+        if t0 is not None:
+            resolved_t0 = t0
+        elif t0_seconds is not None:
+            resolved_t0 = PrecisionTimestamp.from_interval(
+                PrecisionTimeInterval.from_seconds(t0_seconds)
+            )
+        else:
+            resolved_t0 = PrecisionTimestamp.EPOCH
+
+        self._positions: npt.NDArray[np.float64] = _positions_to_array(positions)
+        self._quaternions: npt.NDArray[np.float64] = _quaternions_to_array(quaternions)
+        self._dt = resolved_dt
+        self._t0 = resolved_t0
+
+    @classmethod
+    def from_dict(cls, obj: Any) -> WaveformSpatialPose:
+        """Construct from the ABC wire shape ``{"positions", "quaternions", "t0", "dt"}``."""
+        if not isinstance(obj, dict):
+            raise TypeError(f"expected a dict, got {type(obj).__name__}")
+        dt = PrecisionTimeInterval.from_dict(obj["dt"])
+        t0 = PrecisionTimestamp.from_dict(obj["t0"])
+        positions = [Position.from_dict(p) for p in obj.get("positions", [])]
+        quaternions = [Quaternion.from_dict(q) for q in obj.get("quaternions", [])]
+        return cls(positions, quaternions, dt=dt, t0=t0)
+
+    @classmethod
+    def from_poses(
+        cls,
+        poses: list[SpatialPose],
+        dt: PrecisionTimeInterval | None = None,
+        dt_seconds: float | None = None,
+        t0: PrecisionTimestamp | None = None,
+        t0_seconds: float | None = None,
+    ) -> WaveformSpatialPose:
+        """Build from a list of :class:`SpatialPose` objects, decomposing each into
+        its ``.position``/``.orientation`` halves.
+
+        Always produces an equal-length (``is_valid``) instance.
+        """
+        positions = [pose.position for pose in poses]
+        quaternions = [pose.orientation for pose in poses]
+        return cls(
+            positions, quaternions, dt=dt, dt_seconds=dt_seconds, t0=t0, t0_seconds=t0_seconds
+        )
+
+    @classmethod
+    def from_components(
+        cls,
+        position_x: Waveform1D,
+        position_y: Waveform1D,
+        position_z: Waveform1D,
+        quaternion_w: Waveform1D,
+        quaternion_x: Waveform1D,
+        quaternion_y: Waveform1D,
+        quaternion_z: Waveform1D,
+    ) -> WaveformSpatialPose:
+        """Build from seven per-component ``Waveform1D``s -- three for the position
+        half (``x, y, z``) and four for the quaternion half (``w, x, y, z``) --
+        following :meth:`WaveformPosition.from_components`'s /
+        :meth:`WaveformQuaternion.from_components`'s shape exactly (``dt``/``t0``
+        taken from ``position_x``; waveformCore.md §Aggregate containers).
+
+        Raises:
+            ValueError: Unless all seven inputs have equal length and equal ``dt``
+                (Swift's optional-returning ``init?`` becomes a raise in this port).
+        """
+        components = (
+            position_x,
+            position_y,
+            position_z,
+            quaternion_w,
+            quaternion_x,
+            quaternion_y,
+            quaternion_z,
+        )
+        lengths = {len(component) for component in components}
+        if len(lengths) != 1:
+            raise ValueError(
+                "WaveformSpatialPose.from_components: all seven component waveforms must "
+                f"have equal length (got {[len(component) for component in components]})"
+            )
+        dts = {component.dt for component in components}
+        if len(dts) != 1:
+            raise ValueError(
+                "WaveformSpatialPose.from_components: all seven component waveforms must "
+                f"have equal dt (got {[component.dt for component in components]})"
+            )
+        positions = np.stack(
+            [position_x.values, position_y.values, position_z.values], axis=1
+        ).astype(np.float64)
+        quaternions = np.stack(
+            [quaternion_w.values, quaternion_x.values, quaternion_y.values, quaternion_z.values],
+            axis=1,
+        ).astype(np.float64)
+        return cls(positions, quaternions, dt=position_x.dt, t0=position_x.t0)
+
+    @classmethod
+    def from_waveforms(
+        cls, position_waveform: WaveformPosition, quaternion_waveform: WaveformQuaternion
+    ) -> WaveformSpatialPose:
+        """Build from a sibling :class:`WaveformPosition` and :class:`WaveformQuaternion`
+        pair, sharing ``dt``/``t0`` from ``position_waveform``.
+
+        Raises:
+            ValueError: If the two waveforms have unequal length or unequal
+                ``dt``.
+        """
+        if len(position_waveform) != len(quaternion_waveform):
+            raise ValueError(
+                "WaveformSpatialPose.from_waveforms: position_waveform and quaternion_waveform "
+                f"must have equal length (got {len(position_waveform)}, {len(quaternion_waveform)})"
+            )
+        if position_waveform.dt != quaternion_waveform.dt:
+            raise ValueError(
+                "WaveformSpatialPose.from_waveforms: position_waveform and quaternion_waveform "
+                f"must have equal dt (got {position_waveform.dt!r}, {quaternion_waveform.dt!r})"
+            )
+        return cls(
+            position_waveform.positions_array,
+            quaternion_waveform.quaternions_array,
+            dt=position_waveform.dt,
+            t0=position_waveform.t0,
+        )
+
+    # MARK: - Properties (ABC-required)
+
+    @property
+    def positions(self) -> Sequence[Position]:
+        """A fresh list of materialized ``Position`` objects (the ABC-required accessor).
+
+        Materialized on demand from :attr:`positions_array`; bulk/vectorized
+        code paths use :attr:`positions_array` directly and never go through
+        this accessor internally (waveformCore.md §Compliance 10).
+        """
+        return [Position.from_vector(row) for row in self._positions]
+
+    @property
+    def quaternions(self) -> Sequence[Quaternion]:
+        """A fresh list of materialized ``Quaternion`` objects (the ABC-required accessor).
+
+        Materialized on demand from :attr:`quaternions_array`; bulk/vectorized
+        code paths use :attr:`quaternions_array` directly and never go through
+        this accessor internally (waveformCore.md §Compliance 10).
+        """
+        return [Quaternion.from_float_array(row) for row in self._quaternions]
+
+    @property
+    def t0(self) -> PrecisionTimestamp:
+        return self._t0
+
+    @property
+    def dt(self) -> PrecisionTimeInterval:
+        return self._dt
+
+    # MARK: - Properties (numpy bulk accessor)
+
+    @property
+    def positions_array(self) -> npt.NDArray[np.float64]:
+        """A copy of the ``(n, 3)`` sample array."""
+        return np.array(self._positions, dtype=np.float64, copy=True)
+
+    @property
+    def quaternions_array(self) -> npt.NDArray[np.float64]:
+        """A copy of the ``(n, 4)`` sample array, ``(w, x, y, z)`` order."""
+        return np.array(self._quaternions, dtype=np.float64, copy=True)
+
+    # MARK: - Validity (waveformCore.md §Compliance 9)
+
+    @property
+    def is_valid(self) -> bool:
+        """Whether the parallel position/quaternion arrays have equal length."""
+        return len(self._positions) == len(self._quaternions)
+
+    # MARK: - Properties (time axis; copied from Waveform1D, see module docstring)
+    #
+    # Unlike WaveformPosition/WaveformQuaternion, every quantity below is
+    # derived from `sample_count` (the min of the two array lengths, per
+    # §Compliance 9) rather than a single array's length, so they stay
+    # consistent with each other and with slicing/iteration even when the
+    # two arrays have been directly manipulated into an unequal-length state.
+
+    @property
+    def duration(self) -> PrecisionTimeInterval:
+        """The span from the first to the last sample (``ZERO`` when ``n <= 1``)."""
+        n = self.sample_count
+        if n <= 1:
+            return PrecisionTimeInterval.ZERO
+        return self._dt * (n - 1)
+
+    @property
+    def duration_seconds(self) -> float:
+        return self.duration.seconds_as_float
+
+    @property
+    def sampling_frequency_hz(self) -> float:
+        return 1.0 / self._dt.seconds_as_float
+
+    @property
+    def nyquist_frequency_hz(self) -> float:
+        return self.sampling_frequency_hz / 2.0
+
+    @property
+    def sample_count(self) -> int:
+        """``min(len(positions), len(quaternions))`` -- NOT simply one array's length
+        (waveformCore.md §Compliance 9)."""
+        return min(len(self._positions), len(self._quaternions))
+
+    def __len__(self) -> int:
+        return self.sample_count
+
+    def time_axis(self) -> npt.NDArray[np.float64]:
+        """Sample times (seconds, relative to ``t0``) as a float64 array."""
+        n = self.sample_count
+        return np.arange(n, dtype=np.float64) * self._dt.seconds_as_float
+
+    # MARK: - Component decomposition
+
+    @property
+    def component_waveforms(self) -> SpatialPoseComponentWaveforms:
+        """Decompose into a nested ``(position, quaternion)`` tuple of per-component
+        ``Waveform1D``s sharing this ``dt``/``t0``."""
+        return SpatialPoseComponentWaveforms(
+            position=PositionComponentWaveforms(
+                x=Waveform1D(self._positions[:, 0], dt=self._dt, t0=self._t0),
+                y=Waveform1D(self._positions[:, 1], dt=self._dt, t0=self._t0),
+                z=Waveform1D(self._positions[:, 2], dt=self._dt, t0=self._t0),
+            ),
+            quaternion=QuaternionComponentWaveforms(
+                w=Waveform1D(self._quaternions[:, 0], dt=self._dt, t0=self._t0),
+                x=Waveform1D(self._quaternions[:, 1], dt=self._dt, t0=self._t0),
+                y=Waveform1D(self._quaternions[:, 2], dt=self._dt, t0=self._t0),
+                z=Waveform1D(self._quaternions[:, 3], dt=self._dt, t0=self._t0),
+            ),
+        )
+
+    @property
+    def position_waveform(self) -> WaveformPosition:
+        """The position half of this pose waveform, as a standalone ``WaveformPosition``
+        sharing this waveform's ``dt``/``t0`` (built directly from the stored array, not
+        via :attr:`component_waveforms`)."""
+        return WaveformPosition(self._positions, dt=self._dt, t0=self._t0)
+
+    @property
+    def quaternion_waveform(self) -> WaveformQuaternion:
+        """The orientation half of this pose waveform, as a standalone
+        ``WaveformQuaternion`` sharing this waveform's ``dt``/``t0`` (built directly
+        from the stored array, not via :attr:`component_waveforms`)."""
+        return WaveformQuaternion(self._quaternions, dt=self._dt, t0=self._t0)
+
+    # MARK: - Normalization
+
+    @property
+    def are_all_positions_unit(self) -> bool:
+        """Whether every position is (approximately) a unit vector (vectorized)."""
+        if len(self._positions) == 0:
+            return True
+        norms = np.linalg.norm(self._positions, axis=1)
+        return bool(np.all(np.isclose(norms, 1.0, atol=1e-12)))
+
+    @property
+    def are_all_quaternions_unit(self) -> bool:
+        """Whether every quaternion is (approximately) unit length (vectorized)."""
+        if len(self._quaternions) == 0:
+            return True
+        norms = np.linalg.norm(self._quaternions, axis=1)
+        return bool(np.all(np.isclose(norms, 1.0, atol=1e-12)))
+
+    def normalize(self) -> None:
+        """Normalize every position AND every quaternion to unit length, in place
+        (vectorized).
+
+        Both arrays are checked for zero-magnitude rows before either is
+        mutated, so a failure leaves this waveform unchanged.
+
+        Raises:
+            ValueError: If any row of either array has zero magnitude
+                (parity with ``WaveformPosition.normalize`` /
+                ``WaveformQuaternion.normalize``'s own zero-magnitude
+                ``ValueError``).
+        """
+        position_norms = np.linalg.norm(self._positions, axis=1)
+        position_zero_indices = np.flatnonzero(position_norms == 0.0)
+        if position_zero_indices.size > 0:
+            raise ValueError(
+                "cannot normalize a zero-magnitude position at index "
+                f"{int(position_zero_indices[0])}"
+            )
+        quaternion_norms = np.linalg.norm(self._quaternions, axis=1)
+        quaternion_zero_indices = np.flatnonzero(quaternion_norms == 0.0)
+        if quaternion_zero_indices.size > 0:
+            raise ValueError(
+                "cannot normalize a zero-magnitude quaternion at index "
+                f"{int(quaternion_zero_indices[0])}"
+            )
+        self._positions = self._positions / position_norms[:, np.newaxis]
+        self._quaternions = self._quaternions / quaternion_norms[:, np.newaxis]
+
+    def normalized(self) -> WaveformSpatialPose:
+        """Return a copy of this waveform with both arrays normalized (vectorized).
+
+        Raises:
+            ValueError: If any row of either array has zero magnitude.
+        """
+        result = WaveformSpatialPose(self._positions, self._quaternions, dt=self._dt, t0=self._t0)
+        result.normalize()
+        return result
+
+    # MARK: - Indexing / slicing
+
+    def _resolve_index(self, index: int) -> int:
+        """Normalize ``index`` against :attr:`sample_count` (the valid prefix, per
+        waveformCore.md §Compliance 9) to a non-negative raw-array index.
+
+        The single shared bounds helper for every entry point that indexes the
+        raw ``positions``/``quaternions`` arrays with an integer -- see the
+        module docstring's note that all index paths must derive from
+        ``sample_count``, not either raw array's own length.
+
+        Raises:
+            IndexError: If ``index`` is out of range for ``sample_count``.
+        """
+        n = self.sample_count
+        resolved = index + n if index < 0 else index
+        if resolved < 0 or resolved >= n:
+            raise IndexError(
+                f"WaveformSpatialPose index {index!r} out of range for sample_count={n}"
+            )
+        return resolved
+
+    @overload
+    def __getitem__(self, index: int) -> SpatialPose: ...
+    @overload
+    def __getitem__(self, index: slice) -> WaveformSpatialPose: ...
+
+    def __getitem__(self, index: int | slice) -> SpatialPose | WaveformSpatialPose:
+        if isinstance(index, slice):
+            if index.step is not None and index.step != 1:
+                raise ValueError(
+                    "WaveformSpatialPose slicing does not support step != 1; resampling is "
+                    "the explicit API"
+                )
+            start, stop, _ = index.indices(self.sample_count)
+            new_t0 = self._t0 + self._dt * start
+            return WaveformSpatialPose(
+                self._positions[start:stop],
+                self._quaternions[start:stop],
+                dt=self._dt,
+                t0=new_t0,
+            )
+        resolved = self._resolve_index(index)
+        return SpatialPose(
+            Position.from_vector(self._positions[resolved]),
+            Quaternion.from_float_array(self._quaternions[resolved]),
+        )
+
+    def get(self, index: int) -> SpatialPose | None:
+        """Like ``__getitem__(int)`` but returns ``None`` instead of raising when
+        ``index`` is out of range (Swift's ``subscript(safe:)``)."""
+        try:
+            resolved = self._resolve_index(index)
+        except IndexError:
+            return None
+        return SpatialPose(
+            Position.from_vector(self._positions[resolved]),
+            Quaternion.from_float_array(self._quaternions[resolved]),
+        )
+
+    def __iter__(self) -> Iterator[SpatialPose]:
+        return (
+            SpatialPose(
+                Position.from_vector(self._positions[i]),
+                Quaternion.from_float_array(self._quaternions[i]),
+            )
+            for i in range(self.sample_count)
+        )
+
+    def __array__(
+        self, dtype: npt.DTypeLike | None = None, copy: bool | None = None
+    ) -> npt.NDArray[Any]:
+        """Return this waveform's ``(sample_count, 7)`` stacked array, columns
+        ``[x, y, z, w, i, j, k]`` (position ``xyz`` then quaternion ``wxyz``, both
+        truncated to :attr:`sample_count` -- waveformCore.md §Array shape contract;
+        mathToolsArchitecture.md §API idioms).
+
+        Raises:
+            ValueError: If ``copy=False`` is requested -- a copy is always required
+                since the returned array must not alias the mutable backing stores.
+        """
+        if copy is False:
+            raise ValueError(
+                "WaveformSpatialPose.__array__: copy=False is not supported (a copy is "
+                "required)"
+            )
+        n = self.sample_count
+        combined = np.concatenate([self._positions[:n], self._quaternions[:n]], axis=1)
+        return np.array(combined, dtype=dtype, copy=True)
+
+    # MARK: - Mutation
+
+    def append(self, value: SpatialPose) -> None:
+        self._positions = np.concatenate(
+            [self._positions, value.position.vector.reshape(1, 3)], axis=0
+        )
+        self._quaternions = np.concatenate(
+            [self._quaternions, value.orientation.as_float_array().reshape(1, 4)], axis=0
+        )
+
+    def append_values(self, values: Sequence[SpatialPose]) -> None:
+        position_addition, quaternion_addition = _poses_to_arrays(values)
+        self._positions = np.concatenate([self._positions, position_addition], axis=0)
+        self._quaternions = np.concatenate([self._quaternions, quaternion_addition], axis=0)
+
+    def prepend(self, value: SpatialPose) -> None:
+        self._positions = np.concatenate(
+            [value.position.vector.reshape(1, 3), self._positions], axis=0
+        )
+        self._quaternions = np.concatenate(
+            [value.orientation.as_float_array().reshape(1, 4), self._quaternions], axis=0
+        )
+        self._t0 = self._t0 - self._dt
+
+    def prepend_values(self, values: Sequence[SpatialPose]) -> None:
+        position_addition, quaternion_addition = _poses_to_arrays(values)
+        self._positions = np.concatenate([position_addition, self._positions], axis=0)
+        self._quaternions = np.concatenate([quaternion_addition, self._quaternions], axis=0)
+        self._t0 = self._t0 - self._dt * len(values)
+
+    def insert(self, index: int, value: SpatialPose) -> None:
+        self._positions = np.insert(self._positions, index, value.position.vector, axis=0)
+        self._quaternions = np.insert(
+            self._quaternions, index, value.orientation.as_float_array(), axis=0
+        )
+
+    def replace(self, index: int, value: SpatialPose) -> None:
+        self._positions[index] = value.position.vector
+        self._quaternions[index] = value.orientation.as_float_array()
+
+    def replace_range(self, index: slice, values: Sequence[SpatialPose]) -> None:
+        position_values, quaternion_values = _poses_to_arrays(values)
+        self._positions[index] = position_values
+        self._quaternions[index] = quaternion_values
+
+    def pop(self, index: int = -1) -> SpatialPose:
+        """Remove and return the pose at ``index`` (default: last), from both arrays.
+
+        ``index`` is normalized against :attr:`sample_count`, so it removes the
+        same sample from both arrays even when they differ in length
+        (waveformCore.md §Compliance 9).
+
+        Raises:
+            IndexError: If the waveform is empty, or ``index`` is out of range.
+        """
+        if self.sample_count == 0:
+            raise IndexError("pop from an empty WaveformSpatialPose")
+        resolved = self._resolve_index(index)
+        value = SpatialPose(
+            Position.from_vector(self._positions[resolved]),
+            Quaternion.from_float_array(self._quaternions[resolved]),
+        )
+        self._positions = np.delete(self._positions, resolved, axis=0)
+        self._quaternions = np.delete(self._quaternions, resolved, axis=0)
+        return value
+
+    def clear(self) -> None:
+        self._positions = np.zeros((0, 3), dtype=np.float64)
+        self._quaternions = np.zeros((0, 4), dtype=np.float64)
+
+    # MARK: - Extend / concatenate
+
+    def _check_compatible_dt(self, other: WaveformSpatialPose, op_name: str) -> None:
+        """Raise ``WaveformCompatibilityError`` unless ``other`` shares this waveform's ``dt``
+        (waveformCore.md §Aggregate containers Mutation; no length constraint -- these are
+        concatenation ops, not elementwise ones)."""
+        if self._dt != other._dt:
+            raise WaveformCompatibilityError(
+                f"WaveformSpatialPose.{op_name}: dt mismatch ({self._dt!r} vs {other._dt!r})"
+            )
+
+    def extend(self, other: WaveformSpatialPose) -> None:
+        """Append ``other``'s poses to this waveform, in place.
+
+        Raises:
+            WaveformCompatibilityError: If ``other.dt`` differs from ``self.dt``.
+        """
+        self._check_compatible_dt(other, "extend")
+        self._positions = np.concatenate([self._positions, other._positions], axis=0)
+        self._quaternions = np.concatenate([self._quaternions, other._quaternions], axis=0)
+
+    def concatenate(self, other: WaveformSpatialPose) -> WaveformSpatialPose:
+        """Return a new waveform with ``other``'s poses appended after this one's.
+
+        Raises:
+            WaveformCompatibilityError: If ``other.dt`` differs from ``self.dt``.
+        """
+        self._check_compatible_dt(other, "concatenate")
+        combined_positions = np.concatenate([self._positions, other._positions], axis=0)
+        combined_quaternions = np.concatenate([self._quaternions, other._quaternions], axis=0)
+        return WaveformSpatialPose(
+            combined_positions, combined_quaternions, dt=self._dt, t0=self._t0
+        )
+
+    # MARK: - Comparison
+
+    def __eq__(self, other: object) -> bool:
+        """Full equality: positions (exact), quaternions (exact), ``dt``, ``t0``."""
+        if not isinstance(other, WaveformSpatialPose):
+            return NotImplemented
+        return (
+            self._dt == other._dt
+            and self._t0 == other._t0
+            and bool(np.array_equal(self._positions, other._positions))
+            and bool(np.array_equal(self._quaternions, other._quaternions))
+        )
+
+    def isclose(self, other: WaveformSpatialPose, rtol: float = 1e-9, atol: float = 0.0) -> bool:
+        """Whole-waveform approximate equality: same ``sample_count``, same ``dt``,
+        same ``t0``, all positions AND quaternions close (numpy ``rtol``/``atol``
+        vocabulary, mirroring :meth:`~math_tools.spatial.position.Position.isclose`'s
+        parameter order/defaults; the same ``rtol``/``atol`` is applied to both halves).
+
+        Double-cover aware **per sample** on the quaternion half: each row
+        independently may match either ``other``'s quaternion row or its negation
+        (``q`` and ``-q`` are the same rotation), mirroring
+        :meth:`WaveformQuaternion.isclose`.
+        """
+        n = self.sample_count
+        if n != other.sample_count:
+            return False
+        if self._dt != other._dt or self._t0 != other._t0:
+            return False
+        if n == 0:
+            return True
+        positions_close = np.allclose(
+            self._positions[:n], other._positions[:n], rtol=rtol, atol=atol
+        )
+        if not positions_close:
+            return False
+        self_quaternions = self._quaternions[:n]
+        other_quaternions = other._quaternions[:n]
+        same_sign = np.isclose(self_quaternions, other_quaternions, rtol=rtol, atol=atol)
+        flipped_sign = np.isclose(self_quaternions, -other_quaternions, rtol=rtol, atol=atol)
+        row_matches = np.all(same_sign, axis=1) | np.all(flipped_sign, axis=1)
+        return bool(np.all(row_matches))
+
+    __hash__ = None  # type: ignore[assignment]
+
+    def __repr__(self) -> str:
+        return (
+            f"{type(self).__name__}(sample_count={self.sample_count}, dt={self._dt!r}, "
+            f"t0={self._t0!r})"
+        )
diff --git a/tests/__init__.py b/tests/__init__.py
index 9469f0f..ef2f36a 100644
--- a/tests/__init__.py
+++ b/tests/__init__.py
@@ -1 +1 @@
-"""Unit test package for pyMathTools."""
+"""Unit test package for math_tools."""
diff --git a/tests/functional/__init__.py b/tests/functional/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/functional/test_polynomial.py b/tests/functional/test_polynomial.py
new file mode 100644
index 0000000..66df20b
--- /dev/null
+++ b/tests/functional/test_polynomial.py
@@ -0,0 +1,241 @@
+"""Unit tests for ``UnivariatePolynomial``.
+
+Covers polynomials.md §Compliance requirement 1, plus construction/trimming,
+accessors, calculus, roots (including multiplicity and the zero-polynomial
+raise), equality, repr, and immutability.
+"""
+
+import unittest
+
+import numpy as np
+
+from math_tools.errors import PolynomialSolveError
+from math_tools.functional.polynomial import POLYNOMIAL_ZERO_THRESHOLD, UnivariatePolynomial
+
+
+class TestConstruction(unittest.TestCase):
+    def test_empty_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            UnivariatePolynomial([])
+
+    def test_trims_trailing_zeros(self) -> None:
+        p = UnivariatePolynomial([1.0, 0.0, 0.0])
+        self.assertEqual(p.degree, 0)
+        np.testing.assert_array_equal(p.coefficients, np.array([1.0]))
+
+    def test_no_trim_when_leading_nonzero(self) -> None:
+        p = UnivariatePolynomial([1.0, 2.0, 3.0])
+        self.assertEqual(p.degree, 2)
+
+    def test_zero_polynomial_degree_zero(self) -> None:
+        p = UnivariatePolynomial([0.0])
+        self.assertEqual(p.degree, 0)
+
+    def test_all_zero_input_trims_to_single_zero(self) -> None:
+        p = UnivariatePolynomial([0.0, 0.0, 0.0])
+        self.assertEqual(p.degree, 0)
+        np.testing.assert_array_equal(p.coefficients, np.array([0.0]))
+
+
+class TestAccessors(unittest.TestCase):
+    def test_coefficient_at(self) -> None:
+        p = UnivariatePolynomial([1.0, 2.0, 3.0])
+        self.assertEqual(p.coefficient_at(0), 1.0)
+        self.assertEqual(p.coefficient_at(1), 2.0)
+        self.assertEqual(p.coefficient_at(2), 3.0)
+
+    def test_coefficient_at_beyond_degree_is_zero(self) -> None:
+        p = UnivariatePolynomial([1.0, 2.0])
+        self.assertEqual(p.coefficient_at(5), 0.0)
+
+    def test_coefficient_at_negative_is_zero(self) -> None:
+        p = UnivariatePolynomial([1.0, 2.0])
+        self.assertEqual(p.coefficient_at(-1), 0.0)
+
+
+class TestImmutability(unittest.TestCase):
+    def test_coefficients_property_is_a_copy(self) -> None:
+        p = UnivariatePolynomial([1.0, 2.0, 3.0])
+        out = p.coefficients
+        out[0] = 999.0
+        self.assertEqual(p.coefficient_at(0), 1.0)
+
+    def test_construction_does_not_alias_input(self) -> None:
+        source = np.array([1.0, 2.0, 3.0])
+        p = UnivariatePolynomial(source)
+        source[0] = 999.0
+        self.assertEqual(p.coefficient_at(0), 1.0)
+
+    def test_no_public_setters(self) -> None:
+        p = UnivariatePolynomial([1.0, 2.0])
+        with self.assertRaises(AttributeError):
+            p.coefficients = np.array([9.0])  # type: ignore[misc]
+
+
+class TestCall(unittest.TestCase):
+    def test_scalar_call_matches_horner(self) -> None:
+        # p(x) = 1 + 2x + 3x^2
+        p = UnivariatePolynomial([1.0, 2.0, 3.0])
+
+        def horner(x: float) -> float:
+            result = 0.0
+            for coeff in reversed([1.0, 2.0, 3.0]):
+                result = result * x + coeff
+            return result
+
+        for x in (-2.0, -0.5, 0.0, 1.0, 3.25):
+            self.assertAlmostEqual(float(p(x)), horner(x), places=12)
+
+    def test_scalar_call_returns_python_float(self) -> None:
+        p = UnivariatePolynomial([1.0, 2.0])
+        result = p(2.0)
+        self.assertIsInstance(result, float)
+
+    def test_vector_call_matches_horner_elementwise(self) -> None:
+        coeffs = [1.0, 2.0, 3.0]
+        p = UnivariatePolynomial(coeffs)
+        xs = np.array([-2.0, -0.5, 0.0, 1.0, 3.25])
+
+        def horner(x: float) -> float:
+            result = 0.0
+            for coeff in reversed(coeffs):
+                result = result * x + coeff
+            return result
+
+        expected = np.array([horner(x) for x in xs])
+        actual = p(xs)
+        np.testing.assert_allclose(actual, expected, atol=1e-12)
+
+    def test_vector_call_returns_ndarray(self) -> None:
+        p = UnivariatePolynomial([1.0, 2.0])
+        result = p(np.array([1.0, 2.0, 3.0]))
+        self.assertIsInstance(result, np.ndarray)
+
+
+class TestCalculus(unittest.TestCase):
+    def test_derivative_of_linear_is_constant(self) -> None:
+        p = UnivariatePolynomial([5.0, 3.0])  # 5 + 3x
+        d = p.derivative()
+        self.assertEqual(d.degree, 0)
+        self.assertEqual(d.coefficient_at(0), 3.0)
+
+    def test_derivative_of_constant_is_zero(self) -> None:
+        p = UnivariatePolynomial([7.0])
+        d = p.derivative()
+        self.assertEqual(d.degree, 0)
+        self.assertEqual(d.coefficient_at(0), 0.0)
+
+    def test_integrate_default_constant(self) -> None:
+        p = UnivariatePolynomial([3.0])  # constant 3
+        integral = p.integrate()
+        # antiderivative: 3x
+        self.assertEqual(integral.coefficient_at(0), 0.0)
+        self.assertEqual(integral.coefficient_at(1), 3.0)
+
+    def test_integrate_with_constant(self) -> None:
+        p = UnivariatePolynomial([3.0])
+        integral = p.integrate(constant=2.0)
+        self.assertEqual(integral.coefficient_at(0), 2.0)
+        self.assertEqual(integral.coefficient_at(1), 3.0)
+
+    def test_derivative_integrate_round_trip_up_to_constant(self) -> None:
+        p = UnivariatePolynomial([1.0, 2.0, 3.0, 4.0])
+        round_tripped = p.derivative().integrate(constant=p.coefficient_at(0))
+        self.assertEqual(round_tripped, p)
+
+    def test_integrate_derivative_round_trip(self) -> None:
+        p = UnivariatePolynomial([1.0, 2.0, 3.0])
+        round_tripped = p.integrate().derivative()
+        self.assertEqual(round_tripped, p)
+
+
+class TestRealRoots(unittest.TestCase):
+    def test_compliance_1_simple_roots(self) -> None:
+        """polynomials.md Compliance 1: [-1, 0, 1] -> roots [-1.0, 1.0]."""
+        p = UnivariatePolynomial([-1.0, 0.0, 1.0])  # x^2 - 1
+        self.assertEqual(p.real_roots(), [-1.0, 1.0])
+
+    def test_multiplicity_root_duplicated(self) -> None:
+        """(x - 1)^2 = x^2 - 2x + 1 -> duplicated root [1.0, 1.0]."""
+        p = UnivariatePolynomial([1.0, -2.0, 1.0])
+        roots = p.real_roots()
+        self.assertEqual(len(roots), 2)
+        for root in roots:
+            self.assertAlmostEqual(root, 1.0, places=6)
+
+    def test_zero_polynomial_raises(self) -> None:
+        p = UnivariatePolynomial([0.0])
+        with self.assertRaises(PolynomialSolveError):
+            p.real_roots()
+
+    def test_nonzero_constant_has_no_roots(self) -> None:
+        p = UnivariatePolynomial([5.0])
+        self.assertEqual(p.real_roots(), [])
+
+    def test_complex_pair_filtered_out(self) -> None:
+        # x^2 + 1 -> roots +-i, no real roots
+        p = UnivariatePolynomial([1.0, 0.0, 1.0])
+        self.assertEqual(p.real_roots(), [])
+
+    def test_cubic_one_real_two_complex(self) -> None:
+        # x^3 + 1 -> one real root at x = -1
+        p = UnivariatePolynomial([1.0, 0.0, 0.0, 1.0])
+        roots = p.real_roots()
+        self.assertEqual(len(roots), 1)
+        self.assertAlmostEqual(roots[0], -1.0, places=9)
+
+    def test_roots_sorted_ascending(self) -> None:
+        # (x+2)(x-1)(x-3) -> roots -2, 1, 3
+        coeffs_descending = np.poly([-2.0, 1.0, 3.0])  # descending, numpy.poly convention
+        coeffs_ascending = coeffs_descending[::-1]
+        p = UnivariatePolynomial(coeffs_ascending)
+        roots = p.real_roots()
+        self.assertEqual(len(roots), 3)
+        np.testing.assert_allclose(roots, [-2.0, 1.0, 3.0], atol=1e-8)
+
+    def test_default_tolerance_is_module_constant(self) -> None:
+        p = UnivariatePolynomial([-1.0, 0.0, 1.0])
+        self.assertEqual(p.real_roots(), p.real_roots(tolerance=POLYNOMIAL_ZERO_THRESHOLD))
+
+
+class TestEquality(unittest.TestCase):
+    def test_equal_trimmed_coefficients(self) -> None:
+        self.assertEqual(UnivariatePolynomial([1.0, 2.0]), UnivariatePolynomial([1.0, 2.0, 0.0]))
+
+    def test_not_equal_different_coefficients(self) -> None:
+        self.assertNotEqual(UnivariatePolynomial([1.0, 2.0]), UnivariatePolynomial([1.0, 3.0]))
+
+    def test_not_equal_to_other_type(self) -> None:
+        self.assertNotEqual(UnivariatePolynomial([1.0]), "not a polynomial")
+
+    def test_hash_is_none(self) -> None:
+        p = UnivariatePolynomial([1.0])
+        with self.assertRaises(TypeError):
+            hash(p)
+
+
+class TestRepr(unittest.TestCase):
+    def test_repr_two_term_shape(self) -> None:
+        # 3x^2 - 1 => coefficients ascending [-1.0, 0.0, 3.0]
+        p = UnivariatePolynomial([-1.0, 0.0, 3.0])
+        self.assertEqual(repr(p), "3.0·x² − 1.0")
+
+    def test_repr_constant(self) -> None:
+        p = UnivariatePolynomial([5.0])
+        self.assertEqual(repr(p), "5.0")
+
+    def test_repr_linear_term_no_superscript(self) -> None:
+        p = UnivariatePolynomial([0.0, 2.0])
+        self.assertEqual(repr(p), "2.0·x")
+
+    def test_repr_zero_polynomial(self) -> None:
+        p = UnivariatePolynomial([0.0])
+        self.assertEqual(repr(p), "0.0")
+
+    def test_repr_negative_leading_term(self) -> None:
+        p = UnivariatePolynomial([0.0, 0.0, -1.0])
+        self.assertEqual(repr(p), "−1.0·x²")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/functional/test_roots.py b/tests/functional/test_roots.py
new file mode 100644
index 0000000..d52589c
--- /dev/null
+++ b/tests/functional/test_roots.py
@@ -0,0 +1,355 @@
+"""Unit tests for the OTG analytic root kernel (``math_tools.functional.roots``).
+
+Covers polynomials.md §functional/roots.py Compliance requirements 2-6: a
+faithful port of ``Roots.swift`` / ``Utils.swift`` (Swift source under
+``spmMathTools/FoundationMathTypes/Functional/``). All test vectors below are
+either hand-computed and independently verifiable by factoring, or (for
+Compliance 2b) cross-checked against ``numpy.roots`` -- numpy is a test-only
+import per design constraint 4; ``roots.py`` itself imports only
+``math``/``sys``.
+"""
+
+from __future__ import annotations
+
+import ast
+import sys
+import unittest
+
+import numpy as np
+
+from math_tools.functional import roots
+
+
+class TestConstants(unittest.TestCase):
+    def test_eps16_pinned_to_16_times_float_epsilon(self) -> None:
+        """Compliance 5: guards against the 1e-16 transcription error."""
+        self.assertEqual(roots.EPS16, 16 * sys.float_info.epsilon)
+
+    def test_polynomial_tolerance_value(self) -> None:
+        self.assertEqual(roots.POLYNOMIAL_TOLERANCE, 1e-14)
+
+    def test_polynomial_zero_threshold_value(self) -> None:
+        self.assertEqual(roots.POLYNOMIAL_ZERO_THRESHOLD, 1e-9)
+
+
+class TestRootsModuleImportsOnlyStdlib(unittest.TestCase):
+    def test_no_numpy_or_scipy_import(self) -> None:
+        """Compliance 6: roots.py imports nothing beyond math/sys/stdlib."""
+        source_path = roots.__file__
+        assert source_path is not None
+        with open(source_path, encoding="utf-8") as handle:
+            tree = ast.parse(handle.read(), filename=source_path)
+
+        imported_roots: set[str] = set()
+        for node in ast.walk(tree):
+            if isinstance(node, ast.Import):
+                for alias in node.names:
+                    imported_roots.add(alias.name.split(".")[0])
+            elif isinstance(node, ast.ImportFrom):
+                if node.module is not None:
+                    imported_roots.add(node.module.split(".")[0])
+
+        # `__future__` isn't in sys.stdlib_module_names but is a language
+        # construct, not a dependency; allow it explicitly.
+        allowed = set(sys.stdlib_module_names) | {"__future__"}
+        self.assertTrue(
+            imported_roots.issubset(allowed),
+            f"roots.py imports outside stdlib: {imported_roots - allowed}",
+        )
+        self.assertNotIn("numpy", imported_roots)
+        self.assertNotIn("scipy", imported_roots)
+
+
+class TestSolveCubicLiteralVectors(unittest.TestCase):
+    """Compliance 2a: hand-computed cubic vectors, atol 1e-9."""
+
+    def test_three_distinct_positive_roots(self) -> None:
+        # (x-1)(x-2)(x-3) = x^3 - 6x^2 + 11x - 6
+        found = sorted(roots.solve_cubic(1.0, -6.0, 11.0, -6.0))
+        np.testing.assert_allclose(found, [1.0, 2.0, 3.0], atol=1e-9)
+
+    def test_mixed_sign_roots_drops_negative(self) -> None:
+        # (x+1)(x-2)(x-3) = x^3 - 4x^2 + x + 6 -> roots -1, 2, 3
+        found = sorted(roots.solve_cubic(1.0, -4.0, 1.0, 6.0))
+        np.testing.assert_allclose(found, [2.0, 3.0], atol=1e-9)
+
+    def test_repeated_root_via_discriminant_zero_quadratic_branch(self) -> None:
+        # a=0 forces the quadratic branch: x^2 - 2x + 1 = (x-1)^2, discriminant
+        # 0 -> both (-c+y)*inv2b and (-c-y)*inv2b formulas evaluate identically
+        # and are each inserted, so the double root IS duplicated in the output
+        # here (unlike the cubic "yy==0" branch below, which is not).
+        found = sorted(roots.solve_cubic(0.0, 1.0, -2.0, 1.0))
+        self.assertEqual(len(found), 2)
+        np.testing.assert_allclose(found, [1.0, 1.0], atol=1e-9)
+
+    def test_double_plus_simple_root_cubic_branch(self) -> None:
+        # (x-1)^2 (x-4) = x^3 - 6x^2 + 9x - 4 -> roots 1 (double), 4 (simple).
+        # The cubic "yy==0" branch (Roots.swift:107-114) emits each of its two
+        # closed-form values once, so the double root is NOT duplicated here
+        # (contrast with the quadratic-branch case above).
+        found = sorted(roots.solve_cubic(1.0, -6.0, 9.0, -4.0))
+        self.assertEqual(len(found), 2)
+        np.testing.assert_allclose(found, [1.0, 4.0], atol=1e-9)
+
+    def test_complex_pair_leaves_single_positive_real_root(self) -> None:
+        # x^3 - 8 = 0 -> real root 2, complex pair discarded
+        found = roots.solve_cubic(1.0, 0.0, 0.0, -8.0)
+        np.testing.assert_allclose(found, [2.0], atol=1e-9)
+
+    def test_all_negative_roots_filtered_to_empty(self) -> None:
+        # (x+1)(x+2)(x+3) = x^3 + 6x^2 + 11x + 6 -> roots -1, -2, -3
+        found = roots.solve_cubic(1.0, 6.0, 11.0, 6.0)
+        self.assertEqual(found, [])
+
+    def test_a_near_zero_falls_back_to_quadratic(self) -> None:
+        # a = 0: 2x^2 - 3x - 2 = 0 -> roots 2, -0.5 -> filtered to [2.0]
+        found = roots.solve_cubic(0.0, 2.0, -3.0, -2.0)
+        np.testing.assert_allclose(found, [2.0], atol=1e-9)
+
+    def test_d_near_zero_peels_off_x_equals_zero_root(self) -> None:
+        # x(x-1)(x-2) = x^3 - 3x^2 + 2x -> roots 0, 1, 2
+        found = sorted(roots.solve_cubic(1.0, -3.0, 2.0, 0.0))
+        np.testing.assert_allclose(found, [0.0, 1.0, 2.0], atol=1e-9)
+
+    def test_linear_degenerate_case(self) -> None:
+        # a=b=0, c=2, d=-4 -> linear: 2x - 4 = 0 -> x = 2
+        found = roots.solve_cubic(0.0, 0.0, 2.0, -4.0)
+        np.testing.assert_allclose(found, [2.0], atol=1e-9)
+
+
+class TestSolveCubicNearZeroLeadingCoefficient(unittest.TestCase):
+    """B-7: scale-relative degeneracy threshold for the leading coefficient.
+
+    polynomials.md rule 4 requires ``a ~= 0`` cubics to degrade to the
+    quadratic branch; the original ``_ULP`` (absolute) threshold let a
+    coefficient like ``1e-10`` take the cubic branch, whose ``1/a**3``
+    scaling collapses the solve (empirically confirmed: it returned []
+    instead of the real root near 2.0).
+    """
+
+    def test_a_1e10_matches_np_roots(self) -> None:
+        # Post-audit B-7 repro case.
+        found = roots.solve_cubic(1e-10, 2.0, -3.0, -2.0)
+        expected = np.roots([1e-10, 2.0, -3.0, -2.0])
+        mask = np.abs(expected.imag) < roots.POLYNOMIAL_ZERO_THRESHOLD
+        real_positive = sorted(
+            float(v) for v in expected.real[mask] if v >= 0.0
+        )
+        np.testing.assert_allclose(sorted(found), real_positive, atol=1e-8)
+
+    def test_leading_coefficient_decade_sweep_matches_np_roots(self) -> None:
+        """Sweep a across 1e-4..1e-14 -- this is what test_random_cubics's
+        old ``continue`` was suppressing. Below the degeneracy threshold,
+        solve_cubic drops to the quadratic branch, which introduces an
+        O(a) error relative to the true (a != 0) root -- so the tolerance
+        is scaled with `a` rather than fixed.
+        """
+        b, c, d = 2.0, -3.0, -2.0
+        for exponent in range(4, 15):
+            a = 10.0**-exponent
+            with self.subTest(a=a):
+                expected = np.roots([a, b, c, d])
+                mask = np.abs(expected.imag) < roots.POLYNOMIAL_ZERO_THRESHOLD
+                real_positive = sorted(
+                    float(v) for v in expected.real[mask] if v >= 0.0
+                )
+                found = sorted(roots.solve_cubic(a, b, c, d))
+                self.assertEqual(len(found), len(real_positive), msg=a)
+                np.testing.assert_allclose(
+                    found, real_positive, atol=max(2.0 * a, 1e-9)
+                )
+
+
+class TestSolveResolvent(unittest.TestCase):
+    """Design constraint 3 / acceptance criterion: the real-root count guard."""
+
+    def test_three_real_roots_case(self) -> None:
+        # Resolvent of Q1 (x^4-10x^3+35x^2-50x+24): y^3-35y^2+404y-1540
+        # factors as (y-10)(y-11)(y-14) -> 3 real roots.
+        found, count = roots.solve_resolvent(-35.0, 404.0, -1540.0)
+        self.assertEqual(count, 3)
+        np.testing.assert_allclose(sorted(found), [10.0, 11.0, 14.0], atol=1e-9)
+
+    def test_one_real_root_case(self) -> None:
+        # Resolvent of Q4 (x^4+x^2-2): y^3-y^2+8y-8 = (y-1)(y^2+8)
+        # -> exactly 1 real root (y=1); slot 2 holds imaginary-part scratch,
+        # not a root (Swift Roots.swift:234 guard).
+        found, count = roots.solve_resolvent(-1.0, 8.0, -8.0)
+        self.assertEqual(count, 1)
+        self.assertAlmostEqual(found[0], 1.0, places=9)
+
+    def test_two_real_roots_case(self) -> None:
+        # (y-2)^2(y+1) = y^3 -3y^2 +0y +4 -> roots -1, 2 (double). This
+        # takes the r2 >= q3 branch (roots.py:193-203); the repeated pair
+        # makes x[2] cancel to within _ULP, so the branch collapses to the
+        # count == 2 case (finding B-8, previously unexercised).
+        found, count = roots.solve_resolvent(-3.0, 0.0, 4.0)
+        self.assertEqual(count, 2)
+        np.testing.assert_allclose(sorted(found), [-1.0, 2.0, 2.0], atol=1e-9)
+
+
+class TestSolveQuarticMonicLiteralVectors(unittest.TestCase):
+    """Compliance 2a: hand-computed monic-quartic vectors, atol 1e-9."""
+
+    def test_four_distinct_positive_roots(self) -> None:
+        # (x-1)(x-2)(x-3)(x-4) = x^4 -10x^3 +35x^2 -50x +24
+        found = sorted(roots.solve_quartic_monic(-10.0, 35.0, -50.0, 24.0))
+        np.testing.assert_allclose(found, [1.0, 2.0, 3.0, 4.0], atol=1e-9)
+
+    def test_mixed_sign_roots_drops_negative(self) -> None:
+        # (x+1)(x-2)(x-3)(x-4) = x^4 -8x^3 +17x^2 +2x -24 -> roots -1,2,3,4
+        found = sorted(roots.solve_quartic_monic(-8.0, 17.0, 2.0, -24.0))
+        np.testing.assert_allclose(found, [2.0, 3.0, 4.0], atol=1e-9)
+
+    def test_repeated_roots(self) -> None:
+        # (x-1)^2(x-2)^2 = x^4 -6x^3 +13x^2 -12x +4 -> roots 1,1,2,2.
+        # A multiplicity-2 root is inherently ill-conditioned for a
+        # closed-form solver (error ~ sqrt(eps) ~ 1.5e-8, not eps itself), so
+        # this case alone uses a looser atol than the other literal vectors.
+        found = sorted(roots.solve_quartic_monic(-6.0, 13.0, -12.0, 4.0))
+        self.assertEqual(len(found), 4)
+        np.testing.assert_allclose(found, [1.0, 1.0, 2.0, 2.0], atol=1e-6)
+
+    def test_complex_pair_and_one_real_resolvent_root(self) -> None:
+        # x^4 + x^2 - 2 = (x^2-1)(x^2+2) -> real roots +-1, complex +-i*sqrt(2)
+        # non-negative filter keeps only 1.0. Resolvent of this quartic has
+        # exactly 1 real root (see TestSolveResolvent.test_one_real_root_case).
+        found = roots.solve_quartic_monic(0.0, 1.0, 0.0, -2.0)
+        np.testing.assert_allclose(found, [1.0], atol=1e-9)
+
+    def test_all_negative_roots_filtered_to_empty(self) -> None:
+        # (x+1)(x+2)(x+3)(x+4) = x^4 +10x^3 +35x^2 +50x +24
+        found = roots.solve_quartic_monic(10.0, 35.0, 50.0, 24.0)
+        self.assertEqual(found, [])
+
+    def test_d_and_c_near_zero_biquadratic_branch(self) -> None:
+        # x^2(x-2)(x-3) = x^4 -5x^3 +6x^2 -> roots 0 (single insertion), 2, 3
+        found = sorted(roots.solve_quartic_monic(-5.0, 6.0, 0.0, 0.0))
+        np.testing.assert_allclose(found, [0.0, 2.0, 3.0], atol=1e-9)
+
+    def test_d_and_c_near_zero_repeated_quadratic_factor(self) -> None:
+        # x^2(x-2)^2 = x^4 -4x^3 +4x^2 -> roots 0 (single insertion), 2
+        found = sorted(roots.solve_quartic_monic(-4.0, 4.0, 0.0, 0.0))
+        np.testing.assert_allclose(found, [0.0, 2.0], atol=1e-9)
+
+    def test_d_near_zero_a_and_b_near_zero_branch(self) -> None:
+        # x^4 - 8x = x(x-2)(x^2+2x+4) -> roots 0, 2 (real); complex pair discarded
+        found = sorted(roots.solve_quartic_monic(0.0, 0.0, -8.0, 0.0))
+        np.testing.assert_allclose(found, [0.0, 2.0], atol=1e-9)
+
+
+class TestCrossCheckAgainstNumpyRoots(unittest.TestCase):
+    """Compliance 2b: seeded-random cross-check against np.roots, atol 1e-8.
+
+    numpy is a test-only import (design constraint 4 forbids it in roots.py
+    itself).
+    """
+
+    def _non_negative_real_roots(self, coefficients_descending: list[float]) -> list[float]:
+        found = np.roots(coefficients_descending)
+        mask = np.abs(found.imag) < roots.POLYNOMIAL_ZERO_THRESHOLD
+        real_part = found.real[mask]
+        return sorted(float(value) for value in real_part if value >= 0.0)
+
+    def test_random_cubics(self) -> None:
+        rng = np.random.default_rng(1234)
+        for _ in range(30):
+            a, b, c, d = rng.uniform(-5.0, 5.0, size=4)
+            expected = self._non_negative_real_roots([a, b, c, d])
+            actual = sorted(roots.solve_cubic(a, b, c, d))
+            self.assertEqual(len(actual), len(expected), msg=(a, b, c, d))
+            np.testing.assert_allclose(actual, expected, atol=1e-8)
+
+    def test_random_monic_quartics(self) -> None:
+        rng = np.random.default_rng(5678)
+        for _ in range(30):
+            a, b, c, d = rng.uniform(-5.0, 5.0, size=4)
+            expected = self._non_negative_real_roots([1.0, a, b, c, d])
+            actual = sorted(roots.solve_quartic_monic(a, b, c, d))
+            self.assertEqual(len(actual), len(expected), msg=(a, b, c, d))
+            np.testing.assert_allclose(actual, expected, atol=1e-8)
+
+
+class TestEvaluatePolynomial(unittest.TestCase):
+    def test_horner_evaluation_highest_to_lowest(self) -> None:
+        # x^2 - 3x + 2 at x=5 -> 25-15+2=12
+        self.assertAlmostEqual(roots.evaluate_polynomial([1.0, -3.0, 2.0], 5.0), 12.0)
+
+    def test_empty_coefficients_is_zero(self) -> None:
+        self.assertEqual(roots.evaluate_polynomial([], 3.0), 0.0)
+
+    def test_constant_polynomial(self) -> None:
+        self.assertEqual(roots.evaluate_polynomial([7.0], -100.0), 7.0)
+
+
+class TestPolynomialDerivative(unittest.TestCase):
+    def test_derivative_of_quadratic(self) -> None:
+        # x^2 - 3x + 2 -> derivative 2x - 3
+        self.assertEqual(roots.polynomial_derivative([1.0, -3.0, 2.0]), [2.0, -3.0])
+
+    def test_derivative_of_constant_is_empty(self) -> None:
+        self.assertEqual(roots.polynomial_derivative([5.0]), [])
+
+    def test_derivative_of_empty_is_empty(self) -> None:
+        self.assertEqual(roots.polynomial_derivative([]), [])
+
+
+class TestPolynomialMonicDerivative(unittest.TestCase):
+    def test_monic_derivative_of_cube_plus_one(self) -> None:
+        # (x+1)^3 = x^3+3x^2+3x+1 -> monic-normalized derivative (x+1)^2 = x^2+2x+1
+        result = roots.polynomial_monic_derivative([1.0, 3.0, 3.0, 1.0])
+        np.testing.assert_allclose(result, [1.0, 2.0, 1.0], atol=1e-12)
+
+    def test_monic_derivative_of_linear_is_empty(self) -> None:
+        self.assertEqual(roots.polynomial_monic_derivative([1.0]), [])
+
+
+class TestShrinkInterval(unittest.TestCase):
+    def test_quintic_bracket_converges_to_root(self) -> None:
+        """Compliance 3: shrink_interval converges on a bracketed quintic root."""
+        # x^5 - 32 = 0 -> root at x=2, bracketed by [1, 3]
+        found = roots.shrink_interval([1.0, 0.0, 0.0, 0.0, 0.0, -32.0], 1.0, 3.0)
+        self.assertAlmostEqual(found, 2.0, delta=roots.POLYNOMIAL_TOLERANCE)
+
+    def test_root_exactly_at_left_bound(self) -> None:
+        found = roots.shrink_interval([1.0, -2.0], 2.0, 5.0)  # x - 2, root at x=2
+        self.assertEqual(found, 2.0)
+
+    def test_root_exactly_at_right_bound(self) -> None:
+        found = roots.shrink_interval([1.0, -2.0], -1.0, 2.0)  # x - 2, root at x=2
+        self.assertEqual(found, 2.0)
+
+    def test_multiple_root_hits_f_and_df_both_zero_without_raising(self) -> None:
+        """B-14: the Newton branch's dx = f / df traps as ZeroDivisionError
+        when f(rts) == 0.0 and df(rts) == 0.0. (x-2)^3 = x^3 -6x^2 +12x -8
+        bracketed by [1, 3] lands the initial guess exactly on the triple
+        root x=2, where both f and its derivative vanish -- the bisection
+        guard (roots.py:364-366) evaluates to False here, so it falls
+        through to the Newton branch on the very first iteration.
+        """
+        found = roots.shrink_interval([1.0, -6.0, 12.0, -8.0], 1.0, 3.0)
+        self.assertEqual(found, 2.0)
+
+
+class TestIntegrateJerk(unittest.TestCase):
+    def test_compliance_4_analytic_vector(self) -> None:
+        """Compliance 4: t=1, p0=0, v0=0, a0=0, j=6 -> (1.0, 3.0, 6.0)."""
+        p, v, a = roots.integrate_jerk(1.0, 0.0, 0.0, 0.0, 6.0)
+        self.assertAlmostEqual(p, 1.0)
+        self.assertAlmostEqual(v, 3.0)
+        self.assertAlmostEqual(a, 6.0)
+
+    def test_zero_time_is_identity(self) -> None:
+        p, v, a = roots.integrate_jerk(0.0, 1.0, 2.0, 3.0, 4.0)
+        self.assertEqual((p, v, a), (1.0, 2.0, 3.0))
+
+    def test_constant_jerk_matches_kinematics(self) -> None:
+        # p0=1, v0=2, a0=3, j=0, t=2 -> pure constant-acceleration kinematics
+        p, v, a = roots.integrate_jerk(2.0, 1.0, 2.0, 3.0, 0.0)
+        self.assertAlmostEqual(p, 1.0 + 2.0 * 2.0 + 0.5 * 3.0 * 2.0**2)
+        self.assertAlmostEqual(v, 2.0 + 3.0 * 2.0)
+        self.assertAlmostEqual(a, 3.0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/__init__.py b/tests/otg/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/otg/data/failed_trajectories.json b/tests/otg/data/failed_trajectories.json
new file mode 100644
index 0000000..b2bff7b
--- /dev/null
+++ b/tests/otg/data/failed_trajectories.json
@@ -0,0 +1,3878 @@
+[
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.57360072082836
+    ],
+    "currentVelocity": [
+      3.698449371444841
+    ],
+    "currentAcceleration": [
+      -1.131609989236103
+    ],
+    "targetPosition": [
+      1.168721815265073
+    ],
+    "targetVelocity": [
+      2.345295199230902
+    ],
+    "targetAcceleration": [
+      -0.4454515567015265
+    ],
+    "maxVelocity": [
+      2.208166789445759
+    ],
+    "maxAcceleration": [
+      3.017567270002812
+    ],
+    "maxJerk": [
+      5.01305754633113
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity 2.345295 of DoF 0 exceeds its maximum velocity limit 2.208167."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.325634447436885
+    ],
+    "currentVelocity": [
+      4.093811973161593
+    ],
+    "currentAcceleration": [
+      1.882104646880118
+    ],
+    "targetPosition": [
+      -7.861669332164061
+    ],
+    "targetVelocity": [
+      -2.7210514051841654
+    ],
+    "targetAcceleration": [
+      -0.6173232684287311
+    ],
+    "maxVelocity": [
+      2.4631035684858773
+    ],
+    "maxAcceleration": [
+      8.78682301089001
+    ],
+    "maxJerk": [
+      17.059119617353765
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.721051 of DoF 0 undercuts its minimum velocity limit -2.463104."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.6052936235697253
+    ],
+    "currentVelocity": [
+      0.9122767896119841
+    ],
+    "currentAcceleration": [
+      1.1143284887819083
+    ],
+    "targetPosition": [
+      -5.579980778542115
+    ],
+    "targetVelocity": [
+      -2.7654945181147292
+    ],
+    "targetAcceleration": [
+      0.5538168318870613
+    ],
+    "maxVelocity": [
+      2.7740058417217295
+    ],
+    "maxAcceleration": [
+      7.818245876624244
+    ],
+    "maxJerk": [
+      9.685700267813703
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -2.781328 from the target kinematic state that will undercut its minimum velocity limit -2.774006."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.635808841285806
+    ],
+    "currentVelocity": [
+      -2.636521830238563
+    ],
+    "currentAcceleration": [
+      -1.6579831455386285
+    ],
+    "targetPosition": [
+      -7.44875887773248
+    ],
+    "targetVelocity": [
+      -2.982321097871306
+    ],
+    "targetAcceleration": [
+      -0.7203536622938858
+    ],
+    "maxVelocity": [
+      2.285315695239664
+    ],
+    "maxAcceleration": [
+      7.244295913859068
+    ],
+    "maxJerk": [
+      17.711772432849777
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.982321 of DoF 0 undercuts its minimum velocity limit -2.285316."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.864357423229162
+    ],
+    "currentVelocity": [
+      3.0769662584199615
+    ],
+    "currentAcceleration": [
+      1.6252177120413673
+    ],
+    "targetPosition": [
+      -1.9500610290824625
+    ],
+    "targetVelocity": [
+      2.5294913560459786
+    ],
+    "targetAcceleration": [
+      -0.5557270425337628
+    ],
+    "maxVelocity": [
+      2.494845482917848
+    ],
+    "maxAcceleration": [
+      8.478167332882148
+    ],
+    "maxJerk": [
+      14.976182141694096
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity 2.529491 of DoF 0 exceeds its maximum velocity limit 2.494845."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.916866440100252
+    ],
+    "currentVelocity": [
+      3.452744649504613
+    ],
+    "currentAcceleration": [
+      -0.26404387880268887
+    ],
+    "targetPosition": [
+      -8.439820498664258
+    ],
+    "targetVelocity": [
+      2.3282345972167917
+    ],
+    "targetAcceleration": [
+      -0.5371187932875479
+    ],
+    "maxVelocity": [
+      2.0830382521781123
+    ],
+    "maxAcceleration": [
+      4.745609843560436
+    ],
+    "maxJerk": [
+      7.875527513556764
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity 2.328235 of DoF 0 exceeds its maximum velocity limit 2.083038."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.4874450057352604
+    ],
+    "currentVelocity": [
+      -2.6143954865655736
+    ],
+    "currentAcceleration": [
+      -1.2623379220249986
+    ],
+    "targetPosition": [
+      -2.8250718814435665
+    ],
+    "targetVelocity": [
+      2.8825617510582173
+    ],
+    "targetAcceleration": [
+      -0.5789857113089794
+    ],
+    "maxVelocity": [
+      2.021857826361347
+    ],
+    "maxAcceleration": [
+      7.12466838624233
+    ],
+    "maxJerk": [
+      16.418851785710594
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity 2.882562 of DoF 0 exceeds its maximum velocity limit 2.021858."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.545372603289465
+    ],
+    "currentVelocity": [
+      2.1678952644171456
+    ],
+    "currentAcceleration": [
+      -1.3868743842877058
+    ],
+    "targetPosition": [
+      9.117771958409026
+    ],
+    "targetVelocity": [
+      -2.883626038481729
+    ],
+    "targetAcceleration": [
+      0.27333748169572214
+    ],
+    "maxVelocity": [
+      2.036365051590601
+    ],
+    "maxAcceleration": [
+      4.94269915736699
+    ],
+    "maxJerk": [
+      9.88655960569988
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.883626 of DoF 0 undercuts its minimum velocity limit -2.036365."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.351755068434068
+    ],
+    "currentVelocity": [
+      1.1285927820714514
+    ],
+    "currentAcceleration": [
+      1.5284210315709736
+    ],
+    "targetPosition": [
+      -6.028289440281882
+    ],
+    "targetVelocity": [
+      2.9297845522841808
+    ],
+    "targetAcceleration": [
+      -0.6141648904997818
+    ],
+    "maxVelocity": [
+      2.3220509879094156
+    ],
+    "maxAcceleration": [
+      4.719729654159961
+    ],
+    "maxJerk": [
+      10.677924083313735
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity 2.929785 of DoF 0 exceeds its maximum velocity limit 2.322051."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.351642213152477
+    ],
+    "currentVelocity": [
+      1.9262477782316427
+    ],
+    "currentAcceleration": [
+      0.39345221878639824
+    ],
+    "targetPosition": [
+      8.19721292990549
+    ],
+    "targetVelocity": [
+      2.7715107209296823
+    ],
+    "targetAcceleration": [
+      0.9484474410948971
+    ],
+    "maxVelocity": [
+      2.6259341377836956
+    ],
+    "maxAcceleration": [
+      5.176991913645425
+    ],
+    "maxJerk": [
+      18.342900037885205
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity 2.771511 of DoF 0 exceeds its maximum velocity limit 2.625934."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6303562007943633
+    ],
+    "currentVelocity": [
+      -1.4713492550109697
+    ],
+    "currentAcceleration": [
+      1.8090707719072214
+    ],
+    "targetPosition": [
+      6.568742604737061
+    ],
+    "targetVelocity": [
+      -2.4561678884972977
+    ],
+    "targetAcceleration": [
+      -0.4826475646882846
+    ],
+    "maxVelocity": [
+      2.0179093126222716
+    ],
+    "maxAcceleration": [
+      6.30189150657942
+    ],
+    "maxJerk": [
+      6.813546131391397
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.456168 of DoF 0 undercuts its minimum velocity limit -2.017909."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.302418402437048
+    ],
+    "currentVelocity": [
+      -4.063995454489127
+    ],
+    "currentAcceleration": [
+      -1.1681995863978352
+    ],
+    "targetPosition": [
+      -2.450712904891798
+    ],
+    "targetVelocity": [
+      -2.266851564091764
+    ],
+    "targetAcceleration": [
+      -0.8981191633142234
+    ],
+    "maxVelocity": [
+      2.262600568199826
+    ],
+    "maxAcceleration": [
+      3.78012509046124
+    ],
+    "maxJerk": [
+      14.993735711678731
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.266852 of DoF 0 undercuts its minimum velocity limit -2.262601."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.444666669070947
+    ],
+    "currentVelocity": [
+      -1.6974616052956994
+    ],
+    "currentAcceleration": [
+      1.291990415962752
+    ],
+    "targetPosition": [
+      1.7090417394483204
+    ],
+    "targetVelocity": [
+      2.587203970014473
+    ],
+    "targetAcceleration": [
+      -0.17314881052867226
+    ],
+    "maxVelocity": [
+      2.169654039300433
+    ],
+    "maxAcceleration": [
+      3.6193037100997048
+    ],
+    "maxJerk": [
+      19.773164371198185
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity 2.587204 of DoF 0 exceeds its maximum velocity limit 2.169654."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.931288995647485
+    ],
+    "currentVelocity": [
+      -0.870140945357317
+    ],
+    "currentAcceleration": [
+      -1.4561541267020308
+    ],
+    "targetPosition": [
+      -6.2282978116303305
+    ],
+    "targetVelocity": [
+      -2.882035393508427
+    ],
+    "targetAcceleration": [
+      -0.5239509567858873
+    ],
+    "maxVelocity": [
+      2.3395503002142206
+    ],
+    "maxAcceleration": [
+      3.037910954065846
+    ],
+    "maxJerk": [
+      14.625649514119932
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.882035 of DoF 0 undercuts its minimum velocity limit -2.339550."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.6600820954284092
+    ],
+    "currentVelocity": [
+      -4.075488761626751
+    ],
+    "currentAcceleration": [
+      1.203979510110495
+    ],
+    "targetPosition": [
+      -1.5988848970637743
+    ],
+    "targetVelocity": [
+      -2.6868581654581605
+    ],
+    "targetAcceleration": [
+      0.0016678904883222767
+    ],
+    "maxVelocity": [
+      2.617080146349781
+    ],
+    "maxAcceleration": [
+      9.401670395679432
+    ],
+    "maxJerk": [
+      6.0325654925697325
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.686858 of DoF 0 undercuts its minimum velocity limit -2.617080."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.09314578070574
+    ],
+    "currentVelocity": [
+      -1.8404166237258925
+    ],
+    "currentAcceleration": [
+      -1.2079637562228238
+    ],
+    "targetPosition": [
+      -5.226380903713441
+    ],
+    "targetVelocity": [
+      2.7219893664807513
+    ],
+    "targetAcceleration": [
+      0.05532916755276651
+    ],
+    "maxVelocity": [
+      2.1306193381870853
+    ],
+    "maxAcceleration": [
+      8.844934059684768
+    ],
+    "maxJerk": [
+      17.97907979976527
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity 2.721989 of DoF 0 exceeds its maximum velocity limit 2.130619."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.927314734351874
+    ],
+    "currentVelocity": [
+      3.5354107590949866
+    ],
+    "currentAcceleration": [
+      0.6086059198947655
+    ],
+    "targetPosition": [
+      -0.21702711581733602
+    ],
+    "targetVelocity": [
+      -2.0312761390182494
+    ],
+    "targetAcceleration": [
+      -0.7915823700916447
+    ],
+    "maxVelocity": [
+      2.0295435365036116
+    ],
+    "maxAcceleration": [
+      3.7943491785011134
+    ],
+    "maxJerk": [
+      11.741123391652248
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.031276 of DoF 0 undercuts its minimum velocity limit -2.029544."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.106507962612941
+    ],
+    "currentVelocity": [
+      -1.5611428385475667
+    ],
+    "currentAcceleration": [
+      -0.26684007313732705
+    ],
+    "targetPosition": [
+      -3.314634136379939
+    ],
+    "targetVelocity": [
+      -2.74623017585111
+    ],
+    "targetAcceleration": [
+      -0.0038180495025259553
+    ],
+    "maxVelocity": [
+      2.6732628820758175
+    ],
+    "maxAcceleration": [
+      3.4887529982710577
+    ],
+    "maxJerk": [
+      15.97760157596163
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.746230 of DoF 0 undercuts its minimum velocity limit -2.673263."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.937928659439123
+    ],
+    "currentVelocity": [
+      1.0761679279978846
+    ],
+    "currentAcceleration": [
+      0.01136598865176941
+    ],
+    "targetPosition": [
+      -8.263758395474973
+    ],
+    "targetVelocity": [
+      2.9018910940148546
+    ],
+    "targetAcceleration": [
+      0.48176022087394865
+    ],
+    "maxVelocity": [
+      2.3847912338017325
+    ],
+    "maxAcceleration": [
+      8.213012929568404
+    ],
+    "maxJerk": [
+      15.692363476920857
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity 2.901891 of DoF 0 exceeds its maximum velocity limit 2.384791."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.5898931826032268
+    ],
+    "currentVelocity": [
+      2.2774627018315456
+    ],
+    "currentAcceleration": [
+      -0.3982897564888779
+    ],
+    "targetPosition": [
+      8.661863567855754
+    ],
+    "targetVelocity": [
+      -2.5212348209458257
+    ],
+    "targetAcceleration": [
+      -0.18438133455500227
+    ],
+    "maxVelocity": [
+      2.505932688173641
+    ],
+    "maxAcceleration": [
+      7.549120207502748
+    ],
+    "maxJerk": [
+      10.208408956931374
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.521235 of DoF 0 undercuts its minimum velocity limit -2.505933."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.490913491372721
+    ],
+    "currentVelocity": [
+      -0.842193436803635
+    ],
+    "currentAcceleration": [
+      -0.9239370957907722
+    ],
+    "targetPosition": [
+      -9.746633595054748
+    ],
+    "targetVelocity": [
+      -2.291113711407607
+    ],
+    "targetAcceleration": [
+      0.9528640104455501
+    ],
+    "maxVelocity": [
+      2.083108375784498
+    ],
+    "maxAcceleration": [
+      5.116592527343359
+    ],
+    "maxJerk": [
+      7.715791386119639
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.291114 of DoF 0 undercuts its minimum velocity limit -2.083108."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.935747019766495
+    ],
+    "currentVelocity": [
+      -1.541605130458914
+    ],
+    "currentAcceleration": [
+      -1.3696037190117964
+    ],
+    "targetPosition": [
+      2.2005884016656694
+    ],
+    "targetVelocity": [
+      2.982879005262782
+    ],
+    "targetAcceleration": [
+      0.7042105864372974
+    ],
+    "maxVelocity": [
+      2.5254595944835367
+    ],
+    "maxAcceleration": [
+      4.600424050305248
+    ],
+    "maxJerk": [
+      5.816602367648521
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity 2.982879 of DoF 0 exceeds its maximum velocity limit 2.525460."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.503567066035274
+    ],
+    "currentVelocity": [
+      2.113024057894286
+    ],
+    "currentAcceleration": [
+      -0.5777430516929409
+    ],
+    "targetPosition": [
+      -7.317162815607061
+    ],
+    "targetVelocity": [
+      2.532561000117555
+    ],
+    "targetAcceleration": [
+      -0.23093429016465672
+    ],
+    "maxVelocity": [
+      2.4658446920770145
+    ],
+    "maxAcceleration": [
+      8.803403272073963
+    ],
+    "maxJerk": [
+      7.256547261150691
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity 2.532561 of DoF 0 exceeds its maximum velocity limit 2.465845."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.283880746843444
+    ],
+    "currentVelocity": [
+      -2.614422572927826
+    ],
+    "currentAcceleration": [
+      -1.4865299573251773
+    ],
+    "targetPosition": [
+      6.131777106245384
+    ],
+    "targetVelocity": [
+      2.9379861423519396
+    ],
+    "targetAcceleration": [
+      0.7093844060257881
+    ],
+    "maxVelocity": [
+      2.049946901157694
+    ],
+    "maxAcceleration": [
+      9.12454174088792
+    ],
+    "maxJerk": [
+      6.668301247391638
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity 2.937986 of DoF 0 exceeds its maximum velocity limit 2.049947."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.04052847343727
+    ],
+    "currentVelocity": [
+      3.242778206554055
+    ],
+    "currentAcceleration": [
+      -1.4672933355779745
+    ],
+    "targetPosition": [
+      -6.06247955665842
+    ],
+    "targetVelocity": [
+      -2.5439100407882984
+    ],
+    "targetAcceleration": [
+      0.7723070877685643
+    ],
+    "maxVelocity": [
+      2.2229752741566537
+    ],
+    "maxAcceleration": [
+      5.982423191483794
+    ],
+    "maxJerk": [
+      15.799354919737711
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.543910 of DoF 0 undercuts its minimum velocity limit -2.222975."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.993488541437696
+    ],
+    "currentVelocity": [
+      -2.0347421522247586
+    ],
+    "currentAcceleration": [
+      -1.1114388837038733
+    ],
+    "targetPosition": [
+      -9.617423139420005
+    ],
+    "targetVelocity": [
+      -2.230034562105093
+    ],
+    "targetAcceleration": [
+      0.10829464659500099
+    ],
+    "maxVelocity": [
+      2.032983684573977
+    ],
+    "maxAcceleration": [
+      9.616829219020918
+    ],
+    "maxJerk": [
+      14.814458375145099
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.230035 of DoF 0 undercuts its minimum velocity limit -2.032984."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.283155397368763
+    ],
+    "currentVelocity": [
+      3.6302871289493552
+    ],
+    "currentAcceleration": [
+      1.5490992089996132
+    ],
+    "targetPosition": [
+      -0.4585194567938409
+    ],
+    "targetVelocity": [
+      -2.921391563060483
+    ],
+    "targetAcceleration": [
+      0.37085774058395105
+    ],
+    "maxVelocity": [
+      2.4069551982445168
+    ],
+    "maxAcceleration": [
+      8.579463132939114
+    ],
+    "maxJerk": [
+      15.14962283989605
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] target velocity -2.921392 of DoF 0 undercuts its minimum velocity limit -2.406955."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.19695597081183
+    ],
+    "currentVelocity": [
+      1.7549820151883626
+    ],
+    "currentAcceleration": [
+      -1.7093157698030659
+    ],
+    "targetPosition": [
+      -8.525925645889178
+    ],
+    "targetVelocity": [
+      -2.0529734494180127
+    ],
+    "targetAcceleration": [
+      4.272380346707411
+    ],
+    "maxVelocity": [
+      2.1157731084037574
+    ],
+    "maxAcceleration": [
+      9.05183887964812
+    ],
+    "maxJerk": [
+      10.644348027067387
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -2.910388 from the target kinematic state that will undercut its minimum velocity limit -2.115773."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.430958782953331
+    ],
+    "currentVelocity": [
+      -4.3464236337508035
+    ],
+    "currentAcceleration": [
+      -5.504032458051865
+    ],
+    "targetPosition": [
+      7.403448770117482
+    ],
+    "targetVelocity": [
+      5.463547654581321
+    ],
+    "targetAcceleration": [
+      -1.6930052986346755
+    ],
+    "maxVelocity": [
+      5.4666484504182336
+    ],
+    "maxAcceleration": [
+      7.970831382253024
+    ],
+    "maxJerk": [
+      9.409730380316498
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 5.615851 from the target kinematic state that will exceed its maximum velocity limit 5.466648."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.388670350097083
+    ],
+    "currentVelocity": [
+      4.074386032443326
+    ],
+    "currentAcceleration": [
+      2.2012639208308293
+    ],
+    "targetPosition": [
+      -1.3675547668573351
+    ],
+    "targetVelocity": [
+      4.094504520152619
+    ],
+    "targetAcceleration": [
+      -5.127806516148983
+    ],
+    "maxVelocity": [
+      4.497543129259065
+    ],
+    "maxAcceleration": [
+      8.568368839324178
+    ],
+    "maxJerk": [
+      14.900096376454293
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 4.976861 from the target kinematic state that will exceed its maximum velocity limit 4.497543."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.121529934848226
+    ],
+    "currentVelocity": [
+      5.018296940768277
+    ],
+    "currentAcceleration": [
+      6.908357840171487
+    ],
+    "targetPosition": [
+      -3.5492174891350015
+    ],
+    "targetVelocity": [
+      -5.32869851350113
+    ],
+    "targetAcceleration": [
+      6.902003089169018
+    ],
+    "maxVelocity": [
+      5.5216611439910945
+    ],
+    "maxAcceleration": [
+      9.869612266410865
+    ],
+    "maxJerk": [
+      17.187052287338712
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -6.714557 from the target kinematic state that will undercut its minimum velocity limit -5.521661."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.2891674877506656
+    ],
+    "currentVelocity": [
+      0.6542235839639474
+    ],
+    "currentAcceleration": [
+      2.3467874197418244
+    ],
+    "targetPosition": [
+      1.2288536141724666
+    ],
+    "targetVelocity": [
+      -1.8864476395622556
+    ],
+    "targetAcceleration": [
+      4.819213381770535
+    ],
+    "maxVelocity": [
+      2.2435202759615747
+    ],
+    "maxAcceleration": [
+      8.895146457675091
+    ],
+    "maxJerk": [
+      6.125716144231395
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -3.782129 from the target kinematic state that will undercut its minimum velocity limit -2.243520."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.42701652784638
+    ],
+    "currentVelocity": [
+      -1.9631071617747355
+    ],
+    "currentAcceleration": [
+      -3.881241358260355
+    ],
+    "targetPosition": [
+      -1.9493236454977847
+    ],
+    "targetVelocity": [
+      -2.64742960980581
+    ],
+    "targetAcceleration": [
+      3.1509581330960996
+    ],
+    "maxVelocity": [
+      3.0691902843948373
+    ],
+    "maxAcceleration": [
+      7.1313352485027215
+    ],
+    "maxJerk": [
+      6.293123941169535
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -3.436270 from the target kinematic state that will undercut its minimum velocity limit -3.069190."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.2055117562767057
+    ],
+    "currentVelocity": [
+      0.44318540163411235
+    ],
+    "currentAcceleration": [
+      -3.321804508983371
+    ],
+    "targetPosition": [
+      9.433264746707607
+    ],
+    "targetVelocity": [
+      -2.5200067073226586
+    ],
+    "targetAcceleration": [
+      5.721710122433701
+    ],
+    "maxVelocity": [
+      2.5739805251588104
+    ],
+    "maxAcceleration": [
+      7.86417317228634
+    ],
+    "maxJerk": [
+      10.961700346792075
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -4.013295 from the target kinematic state that will undercut its minimum velocity limit -2.573981."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.912583140358075
+    ],
+    "currentVelocity": [
+      0.8905133680336763
+    ],
+    "currentAcceleration": [
+      3.3690792021309033
+    ],
+    "targetPosition": [
+      3.4469536490116504
+    ],
+    "targetVelocity": [
+      -1.8759604904178555
+    ],
+    "targetAcceleration": [
+      3.0504090044497953
+    ],
+    "maxVelocity": [
+      2.298488432022256
+    ],
+    "maxAcceleration": [
+      3.6013333160567367
+    ],
+    "maxJerk": [
+      11.005884228048924
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -2.298689 from the target kinematic state that will undercut its minimum velocity limit -2.298488."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.530286990700139
+    ],
+    "currentVelocity": [
+      -2.6302606829755963
+    ],
+    "currentAcceleration": [
+      -2.7108210496429637
+    ],
+    "targetPosition": [
+      -7.246710944407095
+    ],
+    "targetVelocity": [
+      -2.7757025801054858
+    ],
+    "targetAcceleration": [
+      7.433702965316311
+    ],
+    "maxVelocity": [
+      2.8731258124916006
+    ],
+    "maxAcceleration": [
+      8.439008276754393
+    ],
+    "maxJerk": [
+      18.00396125741164
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -4.310363 from the target kinematic state that will undercut its minimum velocity limit -2.873126."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.2842970492964767
+    ],
+    "currentVelocity": [
+      0.7480223906928334
+    ],
+    "currentAcceleration": [
+      -4.448216616378472
+    ],
+    "targetPosition": [
+      8.06221138385757
+    ],
+    "targetVelocity": [
+      4.23535996423314
+    ],
+    "targetAcceleration": [
+      -1.5579183226210294
+    ],
+    "maxVelocity": [
+      4.271069573337508
+    ],
+    "maxAcceleration": [
+      9.762579432042541
+    ],
+    "maxJerk": [
+      16.372640672587888
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 4.309481 from the target kinematic state that will exceed its maximum velocity limit 4.271070."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.001091198977019
+    ],
+    "currentVelocity": [
+      -2.3012317341620516
+    ],
+    "currentAcceleration": [
+      -9.745982520999304
+    ],
+    "targetPosition": [
+      9.007131058325164
+    ],
+    "targetVelocity": [
+      1.6307901309138453
+    ],
+    "targetAcceleration": [
+      8.34277813391837
+    ],
+    "maxVelocity": [
+      4.1618739627377295
+    ],
+    "maxAcceleration": [
+      9.763128455306573
+    ],
+    "maxJerk": [
+      5.480078885342512
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -4.719661 from the target kinematic state that will undercut its minimum velocity limit -4.161874."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.878164700195766
+    ],
+    "currentVelocity": [
+      2.9202380761457842
+    ],
+    "currentAcceleration": [
+      -0.7309066729118783
+    ],
+    "targetPosition": [
+      -6.976202231819386
+    ],
+    "targetVelocity": [
+      -4.521212994987729
+    ],
+    "targetAcceleration": [
+      8.430271017995622
+    ],
+    "maxVelocity": [
+      5.5883466406999975
+    ],
+    "maxAcceleration": [
+      8.88854215045112
+    ],
+    "maxJerk": [
+      14.765977334801873
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -6.927741 from the target kinematic state that will undercut its minimum velocity limit -5.588347."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.196111202077059
+    ],
+    "currentVelocity": [
+      -2.546778556082705
+    ],
+    "currentAcceleration": [
+      -8.875212268142745
+    ],
+    "targetPosition": [
+      9.829820774370766
+    ],
+    "targetVelocity": [
+      -4.460075385088505
+    ],
+    "targetAcceleration": [
+      8.460314596474047
+    ],
+    "maxVelocity": [
+      5.166486291951001
+    ],
+    "maxAcceleration": [
+      9.461744769109695
+    ],
+    "maxJerk": [
+      6.391999874899028
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -10.059021 from the target kinematic state that will undercut its minimum velocity limit -5.166486."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.244893452048066
+    ],
+    "currentVelocity": [
+      2.920879400853698
+    ],
+    "currentAcceleration": [
+      -0.6785633421951429
+    ],
+    "targetPosition": [
+      7.896511440051039
+    ],
+    "targetVelocity": [
+      6.145686111151589
+    ],
+    "targetAcceleration": [
+      -7.793133604027107
+    ],
+    "maxVelocity": [
+      7.77535986058262
+    ],
+    "maxAcceleration": [
+      7.880391810382884
+    ],
+    "maxJerk": [
+      11.155528977771311
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 8.867786 from the target kinematic state that will exceed its maximum velocity limit 7.775360."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.822561970095979
+    ],
+    "currentVelocity": [
+      -3.3280368898090575
+    ],
+    "currentAcceleration": [
+      5.352046596389826
+    ],
+    "targetPosition": [
+      -9.78813465950612
+    ],
+    "targetVelocity": [
+      0.6969403530293308
+    ],
+    "targetAcceleration": [
+      -9.754831187697569
+    ],
+    "maxVelocity": [
+      3.5381273519680834
+    ],
+    "maxAcceleration": [
+      9.763802651575869
+    ],
+    "maxJerk": [
+      14.140605113521936
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 4.061603 from the target kinematic state that will exceed its maximum velocity limit 3.538127."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.744070239495398
+    ],
+    "currentVelocity": [
+      1.06453952027409
+    ],
+    "currentAcceleration": [
+      -6.081455810153754
+    ],
+    "targetPosition": [
+      6.930171033659924
+    ],
+    "targetVelocity": [
+      0.9274508789294642
+    ],
+    "targetAcceleration": [
+      -6.35772429628449
+    ],
+    "maxVelocity": [
+      2.0307573402507915
+    ],
+    "maxAcceleration": [
+      7.138948334002314
+    ],
+    "maxJerk": [
+      8.864219517197084
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 3.207441 from the target kinematic state that will exceed its maximum velocity limit 2.030757."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.2609431679475875
+    ],
+    "currentVelocity": [
+      2.8035882430085537
+    ],
+    "currentAcceleration": [
+      8.05459554459783
+    ],
+    "targetPosition": [
+      -3.3151788639485353
+    ],
+    "targetVelocity": [
+      2.857127664243602
+    ],
+    "targetAcceleration": [
+      -7.908693738312488
+    ],
+    "maxVelocity": [
+      3.624484539506055
+    ],
+    "maxAcceleration": [
+      8.353874360606184
+    ],
+    "maxJerk": [
+      9.942099909641232
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 6.002712 from the target kinematic state that will exceed its maximum velocity limit 3.624485."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.87039104081492
+    ],
+    "currentVelocity": [
+      4.425117557028944
+    ],
+    "currentAcceleration": [
+      1.5453285482427814
+    ],
+    "targetPosition": [
+      5.77324309837765
+    ],
+    "targetVelocity": [
+      -6.52939030443061
+    ],
+    "targetAcceleration": [
+      2.7516188813692164
+    ],
+    "maxVelocity": [
+      6.575698605323506
+    ],
+    "maxAcceleration": [
+      6.399820428492621
+    ],
+    "maxJerk": [
+      15.207794292760203
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -6.778322 from the target kinematic state that will undercut its minimum velocity limit -6.575699."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7640985206872113
+    ],
+    "currentVelocity": [
+      0.29650979785836995
+    ],
+    "currentAcceleration": [
+      -0.7868085083672067
+    ],
+    "targetPosition": [
+      1.2672933171742518
+    ],
+    "targetVelocity": [
+      2.658339032256177
+    ],
+    "targetAcceleration": [
+      -5.348771210520425
+    ],
+    "maxVelocity": [
+      3.806435588192464
+    ],
+    "maxAcceleration": [
+      9.748114858289934
+    ],
+    "maxJerk": [
+      8.918749834295996
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 4.262227 from the target kinematic state that will exceed its maximum velocity limit 3.806436."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.5469823704774406
+    ],
+    "currentVelocity": [
+      2.559602843995874
+    ],
+    "currentAcceleration": [
+      -0.9324866105669187
+    ],
+    "targetPosition": [
+      5.272417352987873
+    ],
+    "targetVelocity": [
+      -3.1147798410630374
+    ],
+    "targetAcceleration": [
+      7.943687429740866
+    ],
+    "maxVelocity": [
+      4.027247796414974
+    ],
+    "maxAcceleration": [
+      9.481334106508363
+    ],
+    "maxJerk": [
+      17.208346543642826
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -4.948256 from the target kinematic state that will undercut its minimum velocity limit -4.027248."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.6040451124395325
+    ],
+    "currentVelocity": [
+      -1.7795723646520216
+    ],
+    "currentAcceleration": [
+      0.8807307421219139
+    ],
+    "targetPosition": [
+      9.86882620751079
+    ],
+    "targetVelocity": [
+      2.620364711727346
+    ],
+    "targetAcceleration": [
+      -8.489337049894125
+    ],
+    "maxVelocity": [
+      3.3286751808435904
+    ],
+    "maxAcceleration": [
+      8.644883894641996
+    ],
+    "maxJerk": [
+      11.577549740423922
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 5.732804 from the target kinematic state that will exceed its maximum velocity limit 3.328675."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.18733734556149
+    ],
+    "currentVelocity": [
+      -1.2928802338712795
+    ],
+    "currentAcceleration": [
+      0.061192996249259224
+    ],
+    "targetPosition": [
+      -8.400295543896357
+    ],
+    "targetVelocity": [
+      1.8375507094123855
+    ],
+    "targetAcceleration": [
+      -2.5105069396195114
+    ],
+    "maxVelocity": [
+      2.0191737692666525
+    ],
+    "maxAcceleration": [
+      9.796975951374744
+    ],
+    "maxJerk": [
+      10.376676812751587
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 2.141244 from the target kinematic state that will exceed its maximum velocity limit 2.019174."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.9261569066684086
+    ],
+    "currentVelocity": [
+      -1.5357984702002887
+    ],
+    "currentAcceleration": [
+      -0.11135793157729079
+    ],
+    "targetPosition": [
+      0.2750773248753706
+    ],
+    "targetVelocity": [
+      1.4441787542866047
+    ],
+    "targetAcceleration": [
+      -4.151870356192392
+    ],
+    "maxVelocity": [
+      2.153292215694182
+    ],
+    "maxAcceleration": [
+      4.397276556587865
+    ],
+    "maxJerk": [
+      10.918599581628214
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 2.233567 from the target kinematic state that will exceed its maximum velocity limit 2.153292."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.6694114656642913
+    ],
+    "currentVelocity": [
+      2.6549498646573926
+    ],
+    "currentAcceleration": [
+      -4.774213145515481
+    ],
+    "targetPosition": [
+      -2.3956970635223085
+    ],
+    "targetVelocity": [
+      0.5932622862153321
+    ],
+    "targetAcceleration": [
+      -6.558874988330891
+    ],
+    "maxVelocity": [
+      3.235288125345987
+    ],
+    "maxAcceleration": [
+      6.581341678296301
+    ],
+    "maxJerk": [
+      5.915569511512762
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 4.229332 from the target kinematic state that will exceed its maximum velocity limit 3.235288."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.292827367635034
+    ],
+    "currentVelocity": [
+      1.078370311025079
+    ],
+    "currentAcceleration": [
+      -5.201752905456987
+    ],
+    "targetPosition": [
+      6.9926274158482755
+    ],
+    "targetVelocity": [
+      -2.956481560208076
+    ],
+    "targetAcceleration": [
+      4.801731695235505
+    ],
+    "maxVelocity": [
+      2.983542333570375
+    ],
+    "maxAcceleration": [
+      5.478559088317596
+    ],
+    "maxJerk": [
+      9.578378243535372
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -4.160058 from the target kinematic state that will undercut its minimum velocity limit -2.983542."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.256188285516522
+    ],
+    "currentVelocity": [
+      0.8800378722452793
+    ],
+    "currentAcceleration": [
+      -5.534627435534574
+    ],
+    "targetPosition": [
+      -2.6810758810169695
+    ],
+    "targetVelocity": [
+      2.6419579843440695
+    ],
+    "targetAcceleration": [
+      -6.966632574886354
+    ],
+    "maxVelocity": [
+      2.9976375667716355
+    ],
+    "maxAcceleration": [
+      9.756469890940334
+    ],
+    "maxJerk": [
+      9.511153279321906
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 5.193382 from the target kinematic state that will exceed its maximum velocity limit 2.997638."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.2533429583915616
+    ],
+    "currentVelocity": [
+      3.9809175470011784
+    ],
+    "currentAcceleration": [
+      -2.702555469271518
+    ],
+    "targetPosition": [
+      -1.183146069368659
+    ],
+    "targetVelocity": [
+      5.896617271704972
+    ],
+    "targetAcceleration": [
+      -5.217490898618907
+    ],
+    "maxVelocity": [
+      6.440974504533941
+    ],
+    "maxAcceleration": [
+      8.465588891968563
+    ],
+    "maxJerk": [
+      11.266197922604505
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 7.104754 from the target kinematic state that will exceed its maximum velocity limit 6.440975."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.6494048545825635
+    ],
+    "currentVelocity": [
+      0.33330766037189274
+    ],
+    "currentAcceleration": [
+      1.7246900195503159
+    ],
+    "targetPosition": [
+      -5.908246972443585
+    ],
+    "targetVelocity": [
+      -0.05814276165718901
+    ],
+    "targetAcceleration": [
+      7.447075687158939
+    ],
+    "maxVelocity": [
+      2.526715647415533
+    ],
+    "maxAcceleration": [
+      8.655921449981332
+    ],
+    "maxJerk": [
+      10.029046859158733
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -2.823058 from the target kinematic state that will undercut its minimum velocity limit -2.526716."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.753740627120353
+    ],
+    "currentVelocity": [
+      -4.4371088291985
+    ],
+    "currentAcceleration": [
+      -6.305162725564383
+    ],
+    "targetPosition": [
+      8.897123255815703
+    ],
+    "targetVelocity": [
+      -5.796662821998786
+    ],
+    "targetAcceleration": [
+      8.001449631464759
+    ],
+    "maxVelocity": [
+      7.75398145720785
+    ],
+    "maxAcceleration": [
+      8.205554795896482
+    ],
+    "maxJerk": [
+      12.982620343451632
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -8.262390 from the target kinematic state that will undercut its minimum velocity limit -7.753981."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6945232884478738
+    ],
+    "currentVelocity": [
+      0.153682398217863
+    ],
+    "currentAcceleration": [
+      -4.73496285162177
+    ],
+    "targetPosition": [
+      -0.24102007706163953
+    ],
+    "targetVelocity": [
+      2.688133033280341
+    ],
+    "targetAcceleration": [
+      -1.5927025509534762
+    ],
+    "maxVelocity": [
+      2.7249529278344573
+    ],
+    "maxAcceleration": [
+      4.957867067583906
+    ],
+    "maxJerk": [
+      15.682256795239157
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 2.769011 from the target kinematic state that will exceed its maximum velocity limit 2.724953."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.386330042411963
+    ],
+    "currentVelocity": [
+      -6.487306542772561
+    ],
+    "currentAcceleration": [
+      2.6236945710633197
+    ],
+    "targetPosition": [
+      4.736029601771577
+    ],
+    "targetVelocity": [
+      -6.447756564585993
+    ],
+    "targetAcceleration": [
+      4.133572201709914
+    ],
+    "maxVelocity": [
+      6.746996087405929
+    ],
+    "maxAcceleration": [
+      7.423908700503537
+    ],
+    "maxJerk": [
+      10.792399602237715
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -7.239352 from the target kinematic state that will undercut its minimum velocity limit -6.746996."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.538534857396318
+    ],
+    "currentVelocity": [
+      2.685849446174722
+    ],
+    "currentAcceleration": [
+      -0.9211777218831028
+    ],
+    "targetPosition": [
+      1.54225158315697
+    ],
+    "targetVelocity": [
+      2.6520366519942877
+    ],
+    "targetAcceleration": [
+      -4.38912773519213
+    ],
+    "maxVelocity": [
+      2.713438384996328
+    ],
+    "maxAcceleration": [
+      4.988202168613128
+    ],
+    "maxJerk": [
+      11.168592282135094
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 3.514475 from the target kinematic state that will exceed its maximum velocity limit 2.713438."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.099680489083994
+    ],
+    "currentVelocity": [
+      -1.0995703505226477
+    ],
+    "currentAcceleration": [
+      -6.405602140103541
+    ],
+    "targetPosition": [
+      -2.794046227509157
+    ],
+    "targetVelocity": [
+      -2.8453275289518256
+    ],
+    "targetAcceleration": [
+      8.83510113198096
+    ],
+    "maxVelocity": [
+      3.2338538437401976
+    ],
+    "maxAcceleration": [
+      9.062369488513635
+    ],
+    "maxJerk": [
+      10.152123642653361
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -6.689795 from the target kinematic state that will undercut its minimum velocity limit -3.233854."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.5686625238673315
+    ],
+    "currentVelocity": [
+      1.8981109164699106
+    ],
+    "currentAcceleration": [
+      7.182319571188426
+    ],
+    "targetPosition": [
+      5.120838320430197
+    ],
+    "targetVelocity": [
+      4.467309670929074
+    ],
+    "targetAcceleration": [
+      -8.16687772324347
+    ],
+    "maxVelocity": [
+      5.819066366653493
+    ],
+    "maxAcceleration": [
+      9.059191919382766
+    ],
+    "maxJerk": [
+      11.501782529975372
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 7.366769 from the target kinematic state that will exceed its maximum velocity limit 5.819066."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.267487116838989
+    ],
+    "currentVelocity": [
+      -0.20412758094893002
+    ],
+    "currentAcceleration": [
+      0.010772002025654537
+    ],
+    "targetPosition": [
+      7.429745703099158
+    ],
+    "targetVelocity": [
+      3.234991067924163
+    ],
+    "targetAcceleration": [
+      -4.8847361032600585
+    ],
+    "maxVelocity": [
+      3.4549819565939233
+    ],
+    "maxAcceleration": [
+      5.877185381752835
+    ],
+    "maxJerk": [
+      13.457778004562421
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 4.121491 from the target kinematic state that will exceed its maximum velocity limit 3.454982."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.48275917337778
+    ],
+    "currentVelocity": [
+      -1.4260885907186034
+    ],
+    "currentAcceleration": [
+      4.061657272973562
+    ],
+    "targetPosition": [
+      0.8450592907027765
+    ],
+    "targetVelocity": [
+      1.6636083450992278
+    ],
+    "targetAcceleration": [
+      -8.190072383395421
+    ],
+    "maxVelocity": [
+      3.655211053986998
+    ],
+    "maxAcceleration": [
+      9.389306858499918
+    ],
+    "maxJerk": [
+      6.601932103786433
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 6.743734 from the target kinematic state that will exceed its maximum velocity limit 3.655211."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.1356130067123313
+    ],
+    "currentVelocity": [
+      4.064050731864639
+    ],
+    "currentAcceleration": [
+      3.4935753076949325
+    ],
+    "targetPosition": [
+      8.990038812111848
+    ],
+    "targetVelocity": [
+      -4.168783073816337
+    ],
+    "targetAcceleration": [
+      7.091187512900062
+    ],
+    "maxVelocity": [
+      5.596165327041809
+    ],
+    "maxAcceleration": [
+      8.655454422545453
+    ],
+    "maxJerk": [
+      13.33215853245669
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -6.054634 from the target kinematic state that will undercut its minimum velocity limit -5.596165."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.758033137313145
+    ],
+    "currentVelocity": [
+      2.3916540630044265
+    ],
+    "currentAcceleration": [
+      -5.062699321514701
+    ],
+    "targetPosition": [
+      -2.004716031956793
+    ],
+    "targetVelocity": [
+      -3.097561789381981
+    ],
+    "targetAcceleration": [
+      7.866128338813894
+    ],
+    "maxVelocity": [
+      3.4029620409962966
+    ],
+    "maxAcceleration": [
+      9.729932469171146
+    ],
+    "maxJerk": [
+      19.566668413067966
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -4.678719 from the target kinematic state that will undercut its minimum velocity limit -3.402962."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.7250088410234223
+    ],
+    "currentVelocity": [
+      -3.9717588946325426
+    ],
+    "currentAcceleration": [
+      0.07597348287887762
+    ],
+    "targetPosition": [
+      8.995340701915705
+    ],
+    "targetVelocity": [
+      6.488102699808441
+    ],
+    "targetAcceleration": [
+      -4.030449818092619
+    ],
+    "maxVelocity": [
+      7.121587037151694
+    ],
+    "maxAcceleration": [
+      9.619975099320081
+    ],
+    "maxJerk": [
+      8.300514449923163
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 7.466628 from the target kinematic state that will exceed its maximum velocity limit 7.121587."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.518263683162914
+    ],
+    "currentVelocity": [
+      0.9777007561278923
+    ],
+    "currentAcceleration": [
+      0.8747095486730139
+    ],
+    "targetPosition": [
+      -9.877574226535833
+    ],
+    "targetVelocity": [
+      -3.723536245345396
+    ],
+    "targetAcceleration": [
+      6.968783127086423
+    ],
+    "maxVelocity": [
+      3.7498905247527716
+    ],
+    "maxAcceleration": [
+      8.844506389614558
+    ],
+    "maxJerk": [
+      16.50180448604969
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -5.195010 from the target kinematic state that will undercut its minimum velocity limit -3.749891."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.121581568082825
+    ],
+    "currentVelocity": [
+      1.7742359959524405
+    ],
+    "currentAcceleration": [
+      -2.7415234981309786
+    ],
+    "targetPosition": [
+      1.525003954814725
+    ],
+    "targetVelocity": [
+      -6.198992198178015
+    ],
+    "targetAcceleration": [
+      6.152627046811993
+    ],
+    "maxVelocity": [
+      6.9790844122237745
+    ],
+    "maxAcceleration": [
+      6.663843198663912
+    ],
+    "maxJerk": [
+      16.260028548849483
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -7.363037 from the target kinematic state that will undercut its minimum velocity limit -6.979084."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.2789856701489732
+    ],
+    "currentVelocity": [
+      -4.743986615276941
+    ],
+    "currentAcceleration": [
+      -8.247043499785697
+    ],
+    "targetPosition": [
+      7.616697715289558
+    ],
+    "targetVelocity": [
+      3.7483129637397985
+    ],
+    "targetAcceleration": [
+      -5.123291180008871
+    ],
+    "maxVelocity": [
+      4.985338383698623
+    ],
+    "maxAcceleration": [
+      8.281499851157143
+    ],
+    "maxJerk": [
+      7.373077418195061
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 5.528310 from the target kinematic state that will exceed its maximum velocity limit 4.985338."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.3114910095901813
+    ],
+    "currentVelocity": [
+      -1.8008790323742674
+    ],
+    "currentAcceleration": [
+      8.27562825712801
+    ],
+    "targetPosition": [
+      1.905339709825677
+    ],
+    "targetVelocity": [
+      -1.382863397283908
+    ],
+    "targetAcceleration": [
+      6.2168371165445375
+    ],
+    "maxVelocity": [
+      2.062449172596665
+    ],
+    "maxAcceleration": [
+      9.87888642261258
+    ],
+    "maxJerk": [
+      19.518148226033986
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -2.372944 from the target kinematic state that will undercut its minimum velocity limit -2.062449."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.8964758615018456
+    ],
+    "currentVelocity": [
+      -2.111582456647176
+    ],
+    "currentAcceleration": [
+      -5.256429863912214
+    ],
+    "targetPosition": [
+      7.366125570906995
+    ],
+    "targetVelocity": [
+      -1.835373897674943
+    ],
+    "targetAcceleration": [
+      4.296389444707162
+    ],
+    "maxVelocity": [
+      2.1400370927444405
+    ],
+    "maxAcceleration": [
+      7.308706882073971
+    ],
+    "maxJerk": [
+      8.643671017705143
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -2.903147 from the target kinematic state that will undercut its minimum velocity limit -2.140037."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.519402414609857
+    ],
+    "currentVelocity": [
+      0.2420462423419525
+    ],
+    "currentAcceleration": [
+      3.398453165059202
+    ],
+    "targetPosition": [
+      6.731538634297571
+    ],
+    "targetVelocity": [
+      -2.250174314820236
+    ],
+    "targetAcceleration": [
+      3.029687552901419
+    ],
+    "maxVelocity": [
+      2.2974244433089037
+    ],
+    "maxAcceleration": [
+      4.6985246924401185
+    ],
+    "maxJerk": [
+      12.185042655432932
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -2.626825 from the target kinematic state that will undercut its minimum velocity limit -2.297424."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.827285628747811
+    ],
+    "currentVelocity": [
+      2.8686122995818186
+    ],
+    "currentAcceleration": [
+      -3.393221870979775
+    ],
+    "targetPosition": [
+      7.421944085095383
+    ],
+    "targetVelocity": [
+      -3.146345170590508
+    ],
+    "targetAcceleration": [
+      3.968226618135983
+    ],
+    "maxVelocity": [
+      3.440609320438771
+    ],
+    "maxAcceleration": [
+      5.719298091464784
+    ],
+    "maxJerk": [
+      17.77762893829167
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -3.589228 from the target kinematic state that will undercut its minimum velocity limit -3.440609."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.9610245606907988
+    ],
+    "currentVelocity": [
+      1.7649097430311422
+    ],
+    "currentAcceleration": [
+      -4.473961092076808
+    ],
+    "targetPosition": [
+      -3.614252162653795
+    ],
+    "targetVelocity": [
+      0.9278729638279382
+    ],
+    "targetAcceleration": [
+      -4.921910589571415
+    ],
+    "maxVelocity": [
+      2.0247887706771186
+    ],
+    "maxAcceleration": [
+      6.583889624038473
+    ],
+    "maxJerk": [
+      10.113235950252
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 2.125571 from the target kinematic state that will exceed its maximum velocity limit 2.024789."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.687166858100838
+    ],
+    "currentVelocity": [
+      -3.514344426296338
+    ],
+    "currentAcceleration": [
+      -1.5172866317379299
+    ],
+    "targetPosition": [
+      -5.125133021923123
+    ],
+    "targetVelocity": [
+      4.594479079704941
+    ],
+    "targetAcceleration": [
+      -3.9942057135762017
+    ],
+    "maxVelocity": [
+      5.253612457848373
+    ],
+    "maxAcceleration": [
+      9.548575411360497
+    ],
+    "maxJerk": [
+      11.133754071148344
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 5.310935 from the target kinematic state that will exceed its maximum velocity limit 5.253612."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.1578396455632785
+    ],
+    "currentVelocity": [
+      1.3458392902640313
+    ],
+    "currentAcceleration": [
+      4.38593318739403
+    ],
+    "targetPosition": [
+      8.743617828114822
+    ],
+    "targetVelocity": [
+      -2.071501030274987
+    ],
+    "targetAcceleration": [
+      6.68094431033589
+    ],
+    "maxVelocity": [
+      5.440564666412946
+    ],
+    "maxAcceleration": [
+      7.546823874213012
+    ],
+    "maxJerk": [
+      5.221058127339642
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -6.346019 from the target kinematic state that will undercut its minimum velocity limit -5.440565."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.30118534790307
+    ],
+    "currentVelocity": [
+      -2.0409082854715694
+    ],
+    "currentAcceleration": [
+      -5.5980284606726265
+    ],
+    "targetPosition": [
+      9.862932402873554
+    ],
+    "targetVelocity": [
+      0.14033095964323383
+    ],
+    "targetAcceleration": [
+      -8.791051352010088
+    ],
+    "maxVelocity": [
+      2.592624763076091
+    ],
+    "maxAcceleration": [
+      9.595978552342658
+    ],
+    "maxJerk": [
+      7.503114199595792
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 5.290365 from the target kinematic state that will exceed its maximum velocity limit 2.592625."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.326410254761388
+    ],
+    "currentVelocity": [
+      1.7275989734386679
+    ],
+    "currentAcceleration": [
+      -1.4884498291825796
+    ],
+    "targetPosition": [
+      3.9358212462284126
+    ],
+    "targetVelocity": [
+      -2.664750182610304
+    ],
+    "targetAcceleration": [
+      6.338881861928838
+    ],
+    "maxVelocity": [
+      3.1418593130231995
+    ],
+    "maxAcceleration": [
+      8.444223208664106
+    ],
+    "maxJerk": [
+      5.039280272835576
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -6.651572 from the target kinematic state that will undercut its minimum velocity limit -3.141859."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.079012044688568
+    ],
+    "currentVelocity": [
+      1.5535895331696783
+    ],
+    "currentAcceleration": [
+      5.094587967125519
+    ],
+    "targetPosition": [
+      5.117019447564671
+    ],
+    "targetVelocity": [
+      -0.5850952569001744
+    ],
+    "targetAcceleration": [
+      4.335595001142734
+    ],
+    "maxVelocity": [
+      2.3048416505679947
+    ],
+    "maxAcceleration": [
+      5.815919238637606
+    ],
+    "maxJerk": [
+      5.361496751454934
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -2.338093 from the target kinematic state that will undercut its minimum velocity limit -2.304842."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.1139887786364469
+    ],
+    "currentVelocity": [
+      -0.475532096439669
+    ],
+    "currentAcceleration": [
+      3.1779860582238832
+    ],
+    "targetPosition": [
+      -7.143225129849324
+    ],
+    "targetVelocity": [
+      -4.815092908541947
+    ],
+    "targetAcceleration": [
+      1.1066123567372328
+    ],
+    "maxVelocity": [
+      4.838225386332638
+    ],
+    "maxAcceleration": [
+      5.084219003751768
+    ],
+    "maxJerk": [
+      18.215945288540205
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -4.848706 from the target kinematic state that will undercut its minimum velocity limit -4.838225."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.86258421132226
+    ],
+    "currentVelocity": [
+      -7.365691148304207
+    ],
+    "currentAcceleration": [
+      1.9944321480558225
+    ],
+    "targetPosition": [
+      8.985582145430332
+    ],
+    "targetVelocity": [
+      7.0083045754786735
+    ],
+    "targetAcceleration": [
+      -3.71308369499679
+    ],
+    "maxVelocity": [
+      7.424585165301018
+    ],
+    "maxAcceleration": [
+      4.998961909028498
+    ],
+    "maxJerk": [
+      10.952482839368141
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 7.637705 from the target kinematic state that will exceed its maximum velocity limit 7.424585."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.9147959019647285
+    ],
+    "currentVelocity": [
+      -4.306978621040855
+    ],
+    "currentAcceleration": [
+      0.9285605141193933
+    ],
+    "targetPosition": [
+      -2.603595694525273
+    ],
+    "targetVelocity": [
+      -3.798463994913667
+    ],
+    "targetAcceleration": [
+      6.751984743591982
+    ],
+    "maxVelocity": [
+      7.848635955789611
+    ],
+    "maxAcceleration": [
+      6.818677091721512
+    ],
+    "maxJerk": [
+      5.36834586357476
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -8.044586 from the target kinematic state that will undercut its minimum velocity limit -7.848636."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.08832666405732
+    ],
+    "currentVelocity": [
+      2.0562368022143502
+    ],
+    "currentAcceleration": [
+      -4.538430922470334
+    ],
+    "targetPosition": [
+      -8.986542689348694
+    ],
+    "targetVelocity": [
+      -1.8776343025729842
+    ],
+    "targetAcceleration": [
+      6.211385244031346
+    ],
+    "maxVelocity": [
+      3.125679770520695
+    ],
+    "maxAcceleration": [
+      8.275493366364447
+    ],
+    "maxJerk": [
+      5.9763133451553365
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -5.105486 from the target kinematic state that will undercut its minimum velocity limit -3.125680."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.458553349949973
+    ],
+    "currentVelocity": [
+      0.9914660848856784
+    ],
+    "currentAcceleration": [
+      -2.31824830793747
+    ],
+    "targetPosition": [
+      3.4698950548458445
+    ],
+    "targetVelocity": [
+      2.1440594858826367
+    ],
+    "targetAcceleration": [
+      -3.3577417567963432
+    ],
+    "maxVelocity": [
+      2.645003294515158
+    ],
+    "maxAcceleration": [
+      6.230403973383613
+    ],
+    "maxJerk": [
+      8.833154982652847
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 2.782248 from the target kinematic state that will exceed its maximum velocity limit 2.645003."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.536646990139867
+    ],
+    "currentVelocity": [
+      -1.947089198875175
+    ],
+    "currentAcceleration": [
+      -0.5280101978668359
+    ],
+    "targetPosition": [
+      4.223216422249347
+    ],
+    "targetVelocity": [
+      2.565255635482631
+    ],
+    "targetAcceleration": [
+      -4.718394035513306
+    ],
+    "maxVelocity": [
+      3.597704572318294
+    ],
+    "maxAcceleration": [
+      5.331224045613037
+    ],
+    "maxJerk": [
+      8.66197581636365
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 3.850369 from the target kinematic state that will exceed its maximum velocity limit 3.597705."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.022419106141040146
+    ],
+    "currentVelocity": [
+      0.1896844234435462
+    ],
+    "currentAcceleration": [
+      2.191683766608432
+    ],
+    "targetPosition": [
+      -4.206215385059508
+    ],
+    "targetVelocity": [
+      -2.2275142014880536
+    ],
+    "targetAcceleration": [
+      6.168119664023728
+    ],
+    "maxVelocity": [
+      3.8653940508567923
+    ],
+    "maxAcceleration": [
+      6.6373625520672475
+    ],
+    "maxJerk": [
+      10.3796315946973
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -4.060224 from the target kinematic state that will undercut its minimum velocity limit -3.865394."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.9088357061173795
+    ],
+    "currentVelocity": [
+      -0.4097121917315567
+    ],
+    "currentAcceleration": [
+      1.9220913235338992
+    ],
+    "targetPosition": [
+      7.526401156368454
+    ],
+    "targetVelocity": [
+      -2.0939812262372346
+    ],
+    "targetAcceleration": [
+      4.3589155340048595
+    ],
+    "maxVelocity": [
+      2.4386718907426808
+    ],
+    "maxAcceleration": [
+      4.417447602531098
+    ],
+    "maxJerk": [
+      12.068282285486374
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -2.881175 from the target kinematic state that will undercut its minimum velocity limit -2.438672."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.8363969535900377
+    ],
+    "currentVelocity": [
+      -7.767188487333319
+    ],
+    "currentAcceleration": [
+      2.656005256676522
+    ],
+    "targetPosition": [
+      7.288517318153396
+    ],
+    "targetVelocity": [
+      7.077199656131876
+    ],
+    "targetAcceleration": [
+      -5.398391808135651
+    ],
+    "maxVelocity": [
+      7.946448323945683
+    ],
+    "maxAcceleration": [
+      6.440401346876746
+    ],
+    "maxJerk": [
+      12.32358924348642
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 8.259592 from the target kinematic state that will exceed its maximum velocity limit 7.946448."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.059181705574174
+    ],
+    "currentVelocity": [
+      -6.008254827210749
+    ],
+    "currentAcceleration": [
+      0.6181715860901669
+    ],
+    "targetPosition": [
+      9.299744416063305
+    ],
+    "targetVelocity": [
+      7.403071726477259
+    ],
+    "targetAcceleration": [
+      -6.49353199461764
+    ],
+    "maxVelocity": [
+      7.503778879888888
+    ],
+    "maxAcceleration": [
+      8.591933522351464
+    ],
+    "maxJerk": [
+      9.212389323074415
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 9.691618 from the target kinematic state that will exceed its maximum velocity limit 7.503779."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.34016447710950004
+    ],
+    "currentVelocity": [
+      0.7909409891702008
+    ],
+    "currentAcceleration": [
+      -0.16083846119420198
+    ],
+    "targetPosition": [
+      2.6867458119794545
+    ],
+    "targetVelocity": [
+      -6.017015350381536
+    ],
+    "targetAcceleration": [
+      3.789153568662485
+    ],
+    "maxVelocity": [
+      6.357827372825611
+    ],
+    "maxAcceleration": [
+      4.308478053396602
+    ],
+    "maxJerk": [
+      13.973494184944073
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -6.530762 from the target kinematic state that will undercut its minimum velocity limit -6.357827."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.877412605456508
+    ],
+    "currentVelocity": [
+      0.07665791721265602
+    ],
+    "currentAcceleration": [
+      -1.4400045989184358
+    ],
+    "targetPosition": [
+      5.280778186107929
+    ],
+    "targetVelocity": [
+      3.934536308943775
+    ],
+    "targetAcceleration": [
+      -6.0020488201162046
+    ],
+    "maxVelocity": [
+      4.0084711397058514
+    ],
+    "maxAcceleration": [
+      8.44157062739118
+    ],
+    "maxJerk": [
+      9.461891167913123
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 5.838204 from the target kinematic state that will exceed its maximum velocity limit 4.008471."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.7436232714451645
+    ],
+    "currentVelocity": [
+      -1.338242841030001
+    ],
+    "currentAcceleration": [
+      8.235661759150066
+    ],
+    "targetPosition": [
+      3.1308139823054084
+    ],
+    "targetVelocity": [
+      -1.6002345807567526
+    ],
+    "targetAcceleration": [
+      7.404119646975644
+    ],
+    "maxVelocity": [
+      2.1036629075688027
+    ],
+    "maxAcceleration": [
+      8.236921711888712
+    ],
+    "maxJerk": [
+      9.52740287660265
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -4.477251 from the target kinematic state that will undercut its minimum velocity limit -2.103663."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.9521552293170394
+    ],
+    "currentVelocity": [
+      -1.5627898924829262
+    ],
+    "currentAcceleration": [
+      -4.9955130821895
+    ],
+    "targetPosition": [
+      1.6394608074396153
+    ],
+    "targetVelocity": [
+      6.167968987838818
+    ],
+    "targetAcceleration": [
+      -5.1557873744536895
+    ],
+    "maxVelocity": [
+      6.75752873452677
+    ],
+    "maxAcceleration": [
+      5.290034355524481
+    ],
+    "maxJerk": [
+      11.721675779617936
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 7.301857 from the target kinematic state that will exceed its maximum velocity limit 6.757529."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.0290627146508564
+    ],
+    "currentVelocity": [
+      -0.04778002642120471
+    ],
+    "currentAcceleration": [
+      -0.2226530760381582
+    ],
+    "targetPosition": [
+      4.0903438372246
+    ],
+    "targetVelocity": [
+      -1.3888734516512884
+    ],
+    "targetAcceleration": [
+      7.611858820766684
+    ],
+    "maxVelocity": [
+      3.159207060280306
+    ],
+    "maxAcceleration": [
+      7.933444149377112
+    ],
+    "maxJerk": [
+      11.864604537150317
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -3.830607 from the target kinematic state that will undercut its minimum velocity limit -3.159207."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.9382699741970093
+    ],
+    "currentVelocity": [
+      -1.024558533659801
+    ],
+    "currentAcceleration": [
+      -4.748212823360032
+    ],
+    "targetPosition": [
+      9.85753935705916
+    ],
+    "targetVelocity": [
+      3.134361271230022
+    ],
+    "targetAcceleration": [
+      -4.4537737549765914
+    ],
+    "maxVelocity": [
+      3.1877805495830533
+    ],
+    "maxAcceleration": [
+      9.278534474834165
+    ],
+    "maxJerk": [
+      16.4275480057523
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 3.738106 from the target kinematic state that will exceed its maximum velocity limit 3.187781."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.29423181792999
+    ],
+    "currentVelocity": [
+      2.675112409026381
+    ],
+    "currentAcceleration": [
+      0.024315571139113867
+    ],
+    "targetPosition": [
+      7.996660745805826
+    ],
+    "targetVelocity": [
+      3.117340925072381
+    ],
+    "targetAcceleration": [
+      -3.501741849295518
+    ],
+    "maxVelocity": [
+      3.261565628528844
+    ],
+    "maxAcceleration": [
+      3.864149923951909
+    ],
+    "maxJerk": [
+      12.322942895357452
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 3.614876 from the target kinematic state that will exceed its maximum velocity limit 3.261566."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.20167441204696956
+    ],
+    "currentVelocity": [
+      -2.37420635116897
+    ],
+    "currentAcceleration": [
+      3.702647790584976
+    ],
+    "targetPosition": [
+      -0.8348608918834479
+    ],
+    "targetVelocity": [
+      2.327132447588945
+    ],
+    "targetAcceleration": [
+      -2.3687309873517637
+    ],
+    "maxVelocity": [
+      2.4000727641488337
+    ],
+    "maxAcceleration": [
+      4.851389620188884
+    ],
+    "maxJerk": [
+      18.72146575114001
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 2.476984 from the target kinematic state that will exceed its maximum velocity limit 2.400073."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.561364149104392
+    ],
+    "currentVelocity": [
+      -0.6672787537781961
+    ],
+    "currentAcceleration": [
+      -1.4970048591644822
+    ],
+    "targetPosition": [
+      6.981379460872695
+    ],
+    "targetVelocity": [
+      -1.5208062351891563
+    ],
+    "targetAcceleration": [
+      8.716640839210303
+    ],
+    "maxVelocity": [
+      2.180350283198078
+    ],
+    "maxAcceleration": [
+      9.977158437253806
+    ],
+    "maxJerk": [
+      5.92976462366596
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -7.927454 from the target kinematic state that will undercut its minimum velocity limit -2.180350."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.2565550894780397
+    ],
+    "currentVelocity": [
+      3.0007511529710786
+    ],
+    "currentAcceleration": [
+      -0.008362785814755469
+    ],
+    "targetPosition": [
+      -4.891912036569838
+    ],
+    "targetVelocity": [
+      -5.530120687386226
+    ],
+    "targetAcceleration": [
+      4.906082549735162
+    ],
+    "maxVelocity": [
+      6.43487788281678
+    ],
+    "maxAcceleration": [
+      8.50130243141033
+    ],
+    "maxJerk": [
+      11.882474138299605
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -6.542942 from the target kinematic state that will undercut its minimum velocity limit -6.434878."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0851330562592523
+    ],
+    "currentVelocity": [
+      -0.69107852096935
+    ],
+    "currentAcceleration": [
+      -2.238556611084661
+    ],
+    "targetPosition": [
+      7.90909630480812
+    ],
+    "targetVelocity": [
+      2.801290105003645
+    ],
+    "targetAcceleration": [
+      -7.547266903669583
+    ],
+    "maxVelocity": [
+      3.365011550567424
+    ],
+    "maxAcceleration": [
+      7.907104926464803
+    ],
+    "maxJerk": [
+      18.435329453083074
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity 4.346184 from the target kinematic state that will exceed its maximum velocity limit 3.365012."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.7133173198042115
+    ],
+    "currentVelocity": [
+      3.1762258475021596
+    ],
+    "currentAcceleration": [
+      1.027297526632788
+    ],
+    "targetPosition": [
+      -7.9101952096296335
+    ],
+    "targetVelocity": [
+      -2.766803633087375
+    ],
+    "targetAcceleration": [
+      6.1979537530340565
+    ],
+    "maxVelocity": [
+      3.5252375929802984
+    ],
+    "maxAcceleration": [
+      9.860243814543555
+    ],
+    "maxJerk": [
+      11.736134858046949
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -4.403400 from the target kinematic state that will undercut its minimum velocity limit -3.525238."
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.423521634610218
+    ],
+    "currentVelocity": [
+      -3.1577816197007413
+    ],
+    "currentAcceleration": [
+      3.0499102362931323
+    ],
+    "targetPosition": [
+      3.3537099878971883
+    ],
+    "targetVelocity": [
+      -3.075900239661898
+    ],
+    "targetAcceleration": [
+      2.065501697214134
+    ],
+    "maxVelocity": [
+      3.242377056001931
+    ],
+    "maxAcceleration": [
+      4.82761215763945
+    ],
+    "maxJerk": [
+      5.2807888261095535
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ],
+    "error": "\n[ruckig] DoF 0 will inevitably have reached a velocity -3.479845 from the target kinematic state that will undercut its minimum velocity limit -3.242377."
+  }
+]
\ No newline at end of file
diff --git a/tests/otg/data/generate_multi_dof_corpus.py b/tests/otg/data/generate_multi_dof_corpus.py
new file mode 100644
index 0000000..b56181b
--- /dev/null
+++ b/tests/otg/data/generate_multi_dof_corpus.py
@@ -0,0 +1,136 @@
+"""Generator for ``successful_trajectories_multi_dof.json``.
+
+Post-audit finding E-4 (``.claude/action-plan/56-test-closure-otg-oracles.md``
+gap 1): the entire ``successful_trajectories.json`` / ``failed_trajectories.json``
+classification corpus (1,784 cases) is 1-DOF, and 1-DOF ``calculate()`` calls
+take the dedicated fast path at ``calculator_target.py:553`` (``if dofs == 1
+and input_parameter.minimum_duration is None and not discrete_duration``),
+which never invokes ``PositionThirdOrderStep2.get_profile`` -- it copies the
+Step1-computed extremal profile directly. Step2 (the largest, hardest-to-port
+module in the whole subsystem) therefore has zero oracle coverage from the
+existing corpus.
+
+**Method.** Reuses the existing 1-DOF ``successful_trajectories.json`` cases
+(each already a validated, individually-solvable boundary condition) as raw
+material: groups of 2/3/4 are drawn (without replacement, fixed-seed shuffle)
+and combined into one multi-DOF ``InputParameter`` each, under the default
+``Synchronization.TIME``. Synchronizing DOFs with different individual
+optimal durations to the slowest one is exactly what forces the non-limiting
+DOFs through ``PositionThirdOrderStep2`` (``calculator_target.py``'s "Time
+Synchronization" loop) -- this is *why* Step2 exists in the Ruckig algorithm,
+so it is the natural way to reach it, rather than hand-authoring boundary
+conditions.
+
+Each combination is verified against ``Otg.calculate`` at generation time and
+only kept if it returns a non-error ``Result`` -- mirroring how the original
+``successful_trajectories.json`` corpus is itself a curated "known-good"
+set, not an assertion that every random combination of independently-valid
+1-DOF cases remains solvable once synchronized (some do fail, e.g. when the
+combination happens to trip ``ERROR_SYNCHRONIZATION_CALCULATION``; empirically
+0/450 did in the run that produced the committed file, but the filter is kept
+so the generator stays correct if the source corpus or grouping changes).
+
+**Reproducibility (otg.md-adjacent design constraint 4).** Fixed seed
+``_SEED``; deterministic shuffle of the source corpus' indices; deterministic
+group sizes and counts. Re-running this script against an unchanged
+``successful_trajectories.json`` reproduces ``successful_trajectories_multi_dof.json``
+byte-for-byte.
+
+Run: ``python tests/otg/data/generate_multi_dof_corpus.py`` from the repo
+root (with ``src/`` on ``sys.path``, e.g. via the project's ``.venv``).
+"""
+
+from __future__ import annotations
+
+import json
+import random
+import sys
+from pathlib import Path
+from typing import Any
+
+_DATA_DIR = Path(__file__).parent
+_SOURCE = _DATA_DIR / "successful_trajectories.json"
+_OUTPUT = _DATA_DIR / "successful_trajectories_multi_dof.json"
+
+_SEED = 20260722
+_GROUP_SIZES = (2, 3, 4)
+_GROUPS_PER_SIZE = 150
+
+
+def _combine(cases: list[dict[str, Any]]) -> dict[str, Any]:
+    """Merge ``len(cases)`` 1-DOF classification-corpus entries into one
+    multi-DOF entry (default ``Position``/``Time``/``Continuous``, all DOFs
+    enabled -- the ordinary multi-DOF configuration)."""
+    dofs = len(cases)
+
+    def field(name: str) -> list[float]:
+        return [case[name][0] for case in cases]
+
+    return {
+        "degreesOfFreedom": dofs,
+        "controlInterface": "Position",
+        "synchronization": "Time",
+        "durationDiscretization": "Continuous",
+        "currentPosition": field("currentPosition"),
+        "currentVelocity": field("currentVelocity"),
+        "currentAcceleration": field("currentAcceleration"),
+        "targetPosition": field("targetPosition"),
+        "targetVelocity": field("targetVelocity"),
+        "targetAcceleration": field("targetAcceleration"),
+        "maxVelocity": field("maxVelocity"),
+        "maxAcceleration": field("maxAcceleration"),
+        "maxJerk": field("maxJerk"),
+        "intermediatePositions": [],
+        "enabled": [True] * dofs,
+    }
+
+
+def generate() -> list[dict[str, Any]]:
+    # sys.path setup so this script is runnable standalone.
+    repo_root = _DATA_DIR.parents[2]
+    src_path = str(repo_root / "src")
+    if src_path not in sys.path:
+        sys.path.insert(0, src_path)
+
+    from math_tools.otg.input_parameter import InputParameter
+    from math_tools.otg.otg import Otg
+    from math_tools.otg.output_parameter import OutputParameter
+
+    with _SOURCE.open() as f:
+        source = json.load(f)
+
+    rng = random.Random(_SEED)
+    indices = list(range(len(source)))
+    rng.shuffle(indices)
+
+    combos: list[dict[str, Any]] = []
+    pos = 0
+    for size in _GROUP_SIZES:
+        for _ in range(_GROUPS_PER_SIZE):
+            group = indices[pos : pos + size]
+            pos += size
+            combos.append(_combine([source[i] for i in group]))
+
+    kept: list[dict[str, Any]] = []
+    rejected = 0
+    for combo in combos:
+        inp = InputParameter.from_dict(combo)
+        dofs = inp.degrees_of_freedom
+        otg = Otg(0.01, dofs=dofs)
+        output = OutputParameter(dofs=dofs)
+        result = otg.calculate(inp, output)
+        if result >= 0:
+            kept.append(combo)
+        else:
+            rejected += 1
+
+    print(f"generated {len(combos)} combinations, kept {len(kept)}, rejected {rejected}")
+    return kept
+
+
+if __name__ == "__main__":
+    cases = generate()
+    with _OUTPUT.open("w") as f:
+        json.dump(cases, f, indent=2)
+        f.write("\n")
+    print(f"wrote {len(cases)} cases to {_OUTPUT}")
diff --git a/tests/otg/data/otg_numeric_truth.json b/tests/otg/data/otg_numeric_truth.json
new file mode 100644
index 0000000..8be211d
--- /dev/null
+++ b/tests/otg/data/otg_numeric_truth.json
@@ -0,0 +1,725 @@
+{
+  "_meta": {
+    "source": "SWIFT_TESTS/OTGTests/OTGTruthTableTests.swift lines 27-490 (the `truthTable` array literal), transcribed verbatim.",
+    "note": "31 entries (Test Case 1..31, no gaps), all transcribed.",
+    "tolerances": {
+      "duration": "rtol 1e-6 (otg.md \u00a7Oracle and test strategy 2)",
+      "time_intervals": "atol 1e-6 (otg.md \u00a7Oracle and test strategy 2; capped by the Swift source literals' own 6-decimal-place precision)"
+    }
+  },
+  "cases": [
+    {
+      "id": 1,
+      "description": "Zero initial state to positive target (vel & acc limits hit)",
+      "currentPosition": 0.0,
+      "currentVelocity": 0.0,
+      "currentAcceleration": 0.0,
+      "targetPosition": 10.0,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.8,
+      "expectedTimeIntervals": [
+        0.5,
+        0.3,
+        0.5,
+        1.2,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 2,
+      "description": "Negative position to positive target (vel & acc limits hit)",
+      "currentPosition": -4.775541085840058,
+      "currentVelocity": 0.0,
+      "currentAcceleration": 0.0,
+      "targetPosition": 10.0,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 4.993885,
+      "expectedTimeIntervals": [
+        0.5,
+        0.3,
+        0.5,
+        2.393885,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 3,
+      "description": "Negative initial velocity (vel & acc limits hit)",
+      "currentPosition": 0.0,
+      "currentVelocity": -2.933699789068232,
+      "currentAcceleration": 0.0,
+      "targetPosition": 10.0,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 4.785261,
+      "expectedTimeIntervals": [
+        0.5,
+        0.88674,
+        0.5,
+        1.598521,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 4,
+      "description": "Negative initial acceleration (vel & acc limits hit)",
+      "currentPosition": 0.0,
+      "currentVelocity": 0.0,
+      "currentAcceleration": -2.2867181768158473,
+      "targetPosition": 10.0,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 4.108977,
+      "expectedTimeIntervals": [
+        0.728672,
+        0.352291,
+        0.5,
+        1.228014,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 5,
+      "description": "Higher velocity limit (acc limit hit, vel limit not hit)",
+      "currentPosition": -6.139891324284666,
+      "currentVelocity": 0.0,
+      "currentAcceleration": 0.0,
+      "targetPosition": 10.0,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 9.097991562729273,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 4.127935,
+      "expectedTimeIntervals": [
+        0.5,
+        1.063968,
+        0.5,
+        0.0,
+        0.5,
+        1.063968,
+        0.5
+      ]
+    },
+    {
+      "id": 6,
+      "description": "Higher acceleration limit (vel limit hit, acc limit not hit)",
+      "currentPosition": -6.139891324284666,
+      "currentVelocity": 0.0,
+      "currentAcceleration": 0.0,
+      "targetPosition": 10.0,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 7.24409333730741,
+      "maxJerk": 10.0,
+      "expectedDuration": 5.299884,
+      "expectedTimeIntervals": [
+        0.632456,
+        0.0,
+        0.632456,
+        2.770062,
+        0.632456,
+        0.0,
+        0.632456
+      ]
+    },
+    {
+      "id": 7,
+      "description": "High velocity and acceleration limits (no limits hit)",
+      "currentPosition": -6.139891324284666,
+      "currentVelocity": 0.0,
+      "currentAcceleration": 0.0,
+      "targetPosition": 10.0,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 10.0,
+      "maxAcceleration": 10.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.724062,
+      "expectedTimeIntervals": [
+        0.931015,
+        0.0,
+        1.862031,
+        0.0,
+        0.0,
+        0.0,
+        0.931015
+      ]
+    },
+    {
+      "id": 8,
+      "description": "Negative position and velocity (vel & acc limits hit)",
+      "currentPosition": -6.139891324284666,
+      "currentVelocity": -2.9076772285399857,
+      "currentAcceleration": 0.0,
+      "targetPosition": 10.0,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 6.309603,
+      "expectedTimeIntervals": [
+        0.5,
+        0.881535,
+        0.5,
+        3.128067,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 9,
+      "description": "Negative position and acceleration (vel & acc limits hit)",
+      "currentPosition": -6.139891324284666,
+      "currentVelocity": 0.0,
+      "currentAcceleration": -2.5220102714600143,
+      "targetPosition": 10.0,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 5.686552,
+      "expectedTimeIntervals": [
+        0.752201,
+        0.363605,
+        0.5,
+        2.770746,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 10,
+      "description": "All negative initial states (vel & acc limits hit)",
+      "currentPosition": -6.139891324284666,
+      "currentVelocity": -2.4332813646368305,
+      "currentAcceleration": -2.3549270909757887,
+      "targetPosition": 10.0,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 6.619806,
+      "expectedTimeIntervals": [
+        0.735493,
+        0.842113,
+        0.5,
+        3.2422,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 11,
+      "description": "Lower acceleration limit with symmetric profile (vel & acc limits hit)",
+      "currentPosition": -6.139891324284666,
+      "currentVelocity": 0.0,
+      "currentAcceleration": 0.0,
+      "targetPosition": 10.0,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 3.058381671863536,
+      "maxJerk": 10.0,
+      "expectedDuration": 5.648692,
+      "expectedTimeIntervals": [
+        0.305838,
+        1.002043,
+        0.305838,
+        2.421253,
+        0.305838,
+        1.002043,
+        0.305838
+      ]
+    },
+    {
+      "id": 12,
+      "description": "Complex state transitions (negative to positive)",
+      "currentPosition": -2.2569699192956714,
+      "currentVelocity": -2.2910170579603815,
+      "currentAcceleration": -2.2093383162142333,
+      "targetPosition": 6.790054108584006,
+      "targetVelocity": 0.5880296221570069,
+      "targetAcceleration": 0.57461711298606,
+      "maxVelocity": 3.9501329787234045,
+      "maxAcceleration": 10.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 4.516839,
+      "expectedTimeIntervals": [
+        1.026242,
+        0.0,
+        0.805308,
+        1.465311,
+        0.581258,
+        0.0,
+        0.63872
+      ]
+    },
+    {
+      "id": 13,
+      "description": "Complex state transitions (positive to negative) A",
+      "currentPosition": -2.2569699192956714,
+      "currentVelocity": 0.6924924339691851,
+      "currentAcceleration": 0.6756694790902418,
+      "targetPosition": 6.790054108584006,
+      "targetVelocity": -1.159379585473221,
+      "targetAcceleration": -1.2629539618488628,
+      "maxVelocity": 3.9501329787234045,
+      "maxAcceleration": 10.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.491257,
+      "expectedTimeIntervals": [
+        0.505187,
+        0.0,
+        0.572754,
+        1.098882,
+        0.720366,
+        0.0,
+        0.59407
+      ]
+    },
+    {
+      "id": 14,
+      "description": "Complex state transitions with higher velocity limit",
+      "currentPosition": -2.2569699192956714,
+      "currentVelocity": 0.6924924339691851,
+      "currentAcceleration": 0.6756694790902418,
+      "targetPosition": 6.790054108584006,
+      "targetVelocity": -1.159379585473221,
+      "targetAcceleration": -1.2629539618488628,
+      "maxVelocity": 5.783597189104916,
+      "maxAcceleration": 10.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.001705,
+      "expectedTimeIntervals": [
+        0.647551,
+        0.0,
+        0.715118,
+        0.089298,
+        0.838017,
+        0.0,
+        0.711722
+      ]
+    },
+    {
+      "id": 15,
+      "description": "Mixed velocity and acceleration signs (negative vel, positive acc)",
+      "currentPosition": -2.2569699192956714,
+      "currentVelocity": -0.9487630685986792,
+      "currentAcceleration": 0.6756694790902418,
+      "targetPosition": 6.790054108584006,
+      "targetVelocity": 0.6247420671313275,
+      "targetAcceleration": -1.2629539618488628,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 10.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.453726,
+      "expectedTimeIntervals": [
+        0.637528,
+        0.0,
+        0.705095,
+        1.061812,
+        0.587793,
+        0.0,
+        0.461498
+      ]
+    },
+    {
+      "id": 16,
+      "description": "Mixed velocity and acceleration signs (positive vel, negative acc) A",
+      "currentPosition": -2.2569699192956714,
+      "currentVelocity": 1.0843211206896552,
+      "currentAcceleration": -0.908898110785033,
+      "targetPosition": 6.790054108584006,
+      "targetVelocity": -0.8658519809244314,
+      "targetAcceleration": 0.8345847853998534,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 10.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.690308,
+      "expectedTimeIntervals": [
+        0.634671,
+        0.0,
+        0.543782,
+        1.0283,
+        0.700048,
+        0.0,
+        0.783507
+      ]
+    },
+    {
+      "id": 17,
+      "description": "Mixed velocity and acceleration signs (positive vel, negative acc) B",
+      "currentPosition": -2.2569699192956714,
+      "currentVelocity": 1.0843211206896552,
+      "currentAcceleration": -0.908898110785033,
+      "targetPosition": 6.790054108584006,
+      "targetVelocity": 0.7905642424798243,
+      "targetAcceleration": -1.0706220194424065,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 10.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.110478,
+      "expectedTimeIntervals": [
+        0.634671,
+        0.0,
+        0.543782,
+        0.895978,
+        0.571555,
+        0.0,
+        0.464492
+      ]
+    },
+    {
+      "id": 18,
+      "description": "Positive to negative target (vel & acc limits hit)",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": 0.0,
+      "currentAcceleration": 0.0,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.539361,
+      "expectedTimeIntervals": [
+        0.5,
+        0.3,
+        0.5,
+        0.939361,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 19,
+      "description": "Positive to negative with negative initial velocity (vel & acc limits hit)",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": -1.1073731185756241,
+      "currentAcceleration": 0.0,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.279332,
+      "expectedTimeIntervals": [
+        0.5,
+        0.078525,
+        0.5,
+        0.900807,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 20,
+      "description": "Positive to negative with negative initial acceleration (vel & acc limits hit)",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": 0.0,
+      "currentAcceleration": -1.3502374724669601,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.426422,
+      "expectedTimeIntervals": [
+        0.364976,
+        0.318231,
+        0.5,
+        0.943215,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 21,
+      "description": "Positive to negative with higher velocity limit (acc limit hit, vel limit not hit)",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": 0.0,
+      "currentAcceleration": 0.0,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 9.363831910792952,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.223225,
+      "expectedTimeIntervals": [
+        0.5,
+        0.611613,
+        0.5,
+        0.0,
+        0.5,
+        0.611613,
+        0.5
+      ]
+    },
+    {
+      "id": 22,
+      "description": "Positive to negative with higher acceleration limit (vel limit hit, acc limit not hit)",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": 0.0,
+      "currentAcceleration": 0.0,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 7.814659622797357,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.504272,
+      "expectedTimeIntervals": [
+        0.632456,
+        0.0,
+        0.632456,
+        0.97445,
+        0.632456,
+        0.0,
+        0.632456
+      ]
+    },
+    {
+      "id": 23,
+      "description": "Positive to negative with high velocity and acceleration limits (no limits hit)",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": 0.0,
+      "currentAcceleration": 0.0,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 9.045025123898679,
+      "maxAcceleration": 9.155501445484582,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.060399,
+      "expectedTimeIntervals": [
+        0.7651,
+        0.0,
+        1.530199,
+        0.0,
+        0.0,
+        0.0,
+        0.7651
+      ]
+    },
+    {
+      "id": 24,
+      "description": "Positive to negative with negative velocity (vel & acc limits hit)",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": -2.5442249449339207,
+      "currentAcceleration": 0.0,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.028222,
+      "expectedTimeIntervals": [
+        0.381546,
+        0.0,
+        0.381546,
+        0.96513,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 25,
+      "description": "Positive to negative with negative acceleration (vel & acc limits hit)",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": 0.0,
+      "currentAcceleration": -3.347616097650514,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.328272,
+      "expectedTimeIntervals": [
+        0.165238,
+        0.412065,
+        0.5,
+        0.950968,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 26,
+      "description": "Positive to negative with negative velocity and acceleration (vel & acc limits hit)",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": -2.5039578744493394,
+      "currentAcceleration": -3.347616097650514,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 2.96602,
+      "expectedTimeIntervals": [
+        0.11871,
+        0.0,
+        0.453472,
+        1.093838,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 27,
+      "description": "Positive to negative with negative velocity and acceleration variant (vel & acc limits hit)",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": -2.5536320668135097,
+      "currentAcceleration": -3.8897875367107195,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 2.958146,
+      "expectedTimeIntervals": [
+        0.080371,
+        0.0,
+        0.46935,
+        1.108425,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 28,
+      "description": "Positive to negative at max velocity with negative acceleration (vel & acc limits hit)",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": -4.0,
+      "currentAcceleration": -3.0555937958883996,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": 0.0,
+      "targetAcceleration": 0.0,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 5.0,
+      "maxJerk": 10.0,
+      "expectedDuration": 2.890803,
+      "expectedTimeIntervals": [
+        0.521622,
+        0.0,
+        0.216063,
+        0.241999,
+        0.5,
+        0.3,
+        0.5
+      ]
+    },
+    {
+      "id": 29,
+      "description": "Positive to negative with complex state transitions (negative to positive targets)",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": -2.9630139500734214,
+      "currentAcceleration": -3.0555937958883996,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": 1.0698019915565349,
+      "targetAcceleration": 1.8217407764317184,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 9.973774779735683,
+      "maxJerk": 10.0,
+      "expectedDuration": 2.993353,
+      "expectedTimeIntervals": [
+        0.082232,
+        0.0,
+        0.387791,
+        1.258336,
+        0.723584,
+        0.0,
+        0.54141
+      ]
+    },
+    {
+      "id": 30,
+      "description": "Positive to negative with complex state transitions (positive to negative targets)",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": 1.9695301027900147,
+      "currentAcceleration": 1.972541529001468,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": -1.5414200165198237,
+      "targetAcceleration": -1.5255311582232012,
+      "maxVelocity": 4.0,
+      "maxAcceleration": 9.973774779735683,
+      "maxJerk": 10.0,
+      "expectedDuration": 4.173396,
+      "expectedTimeIntervals": [
+        0.98237,
+        0.0,
+        0.785116,
+        1.238478,
+        0.507439,
+        0.0,
+        0.659992
+      ]
+    },
+    {
+      "id": 31,
+      "description": "Positive to negative with complex state transitions and higher velocity limit",
+      "currentPosition": 2.6603799559471364,
+      "currentVelocity": 1.9695301027900147,
+      "currentAcceleration": 1.972541529001468,
+      "targetPosition": -6.297064289647577,
+      "targetVelocity": -1.5414200165198237,
+      "targetAcceleration": -1.5255311582232012,
+      "maxVelocity": 6.155966065528634,
+      "maxAcceleration": 9.973774779735683,
+      "maxJerk": 10.0,
+      "expectedDuration": 3.59727,
+      "expectedTimeIntervals": [
+        1.109397,
+        0.0,
+        0.912143,
+        0.047546,
+        0.687816,
+        0.0,
+        0.840369
+      ]
+    }
+  ]
+}
diff --git a/tests/otg/data/successful_trajectories.json b/tests/otg/data/successful_trajectories.json
new file mode 100644
index 0000000..d17999a
--- /dev/null
+++ b/tests/otg/data/successful_trajectories.json
@@ -0,0 +1,62236 @@
+[
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.649087426675152
+    ],
+    "currentVelocity": [
+      -1.7196585619659843
+    ],
+    "currentAcceleration": [
+      -3.6835022695742996
+    ],
+    "targetPosition": [
+      -4.632519332535045
+    ],
+    "targetVelocity": [
+      1.9218188748830034
+    ],
+    "targetAcceleration": [
+      5.820923498653984
+    ],
+    "maxVelocity": [
+      2.36187254995664
+    ],
+    "maxAcceleration": [
+      8.000641420127906
+    ],
+    "maxJerk": [
+      13.235404890387207
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.5538404165884447
+    ],
+    "currentVelocity": [
+      2.719975387749111
+    ],
+    "currentAcceleration": [
+      -2.7125222627136645
+    ],
+    "targetPosition": [
+      -0.29046487634462714
+    ],
+    "targetVelocity": [
+      -4.073356367653726
+    ],
+    "targetAcceleration": [
+      -2.6715862543516153
+    ],
+    "maxVelocity": [
+      4.100752292333544
+    ],
+    "maxAcceleration": [
+      3.0971430585007496
+    ],
+    "maxJerk": [
+      9.155863766915962
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.171466517174686
+    ],
+    "currentVelocity": [
+      0.45940226623023594
+    ],
+    "currentAcceleration": [
+      -7.6185706240953746
+    ],
+    "targetPosition": [
+      -7.698235698267604
+    ],
+    "targetVelocity": [
+      -1.9244240825270946
+    ],
+    "targetAcceleration": [
+      2.523213127246084
+    ],
+    "maxVelocity": [
+      5.282555703083902
+    ],
+    "maxAcceleration": [
+      8.175397863099679
+    ],
+    "maxJerk": [
+      7.632569873047119
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.7885355787228079
+    ],
+    "currentVelocity": [
+      -5.0769013685124635
+    ],
+    "currentAcceleration": [
+      -6.3393671084365195
+    ],
+    "targetPosition": [
+      -6.3474560377469675
+    ],
+    "targetVelocity": [
+      -3.254186145563377
+    ],
+    "targetAcceleration": [
+      -2.014042244144176
+    ],
+    "maxVelocity": [
+      7.75898245727236
+    ],
+    "maxAcceleration": [
+      9.309018311542676
+    ],
+    "maxJerk": [
+      19.907251286632416
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.0428521414445413
+    ],
+    "currentVelocity": [
+      5.126192262001746
+    ],
+    "currentAcceleration": [
+      -4.995768901714416
+    ],
+    "targetPosition": [
+      -4.483913053238567
+    ],
+    "targetVelocity": [
+      -2.614054949423065
+    ],
+    "targetAcceleration": [
+      -0.8523927014178412
+    ],
+    "maxVelocity": [
+      7.4019008561936666
+    ],
+    "maxAcceleration": [
+      9.91233011967789
+    ],
+    "maxJerk": [
+      16.509785183924954
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.716816303995234
+    ],
+    "currentVelocity": [
+      1.8984274628930642
+    ],
+    "currentAcceleration": [
+      -2.4829778683868566
+    ],
+    "targetPosition": [
+      5.016931873174022
+    ],
+    "targetVelocity": [
+      1.2005684652643582
+    ],
+    "targetAcceleration": [
+      2.1227323360831782
+    ],
+    "maxVelocity": [
+      2.466425276470951
+    ],
+    "maxAcceleration": [
+      4.131605100905477
+    ],
+    "maxJerk": [
+      13.362036948948761
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.484214793931489
+    ],
+    "currentVelocity": [
+      -1.1644338882919012
+    ],
+    "currentAcceleration": [
+      4.704331813930919
+    ],
+    "targetPosition": [
+      9.338185049530686
+    ],
+    "targetVelocity": [
+      2.8957269622507456
+    ],
+    "targetAcceleration": [
+      0.6927412350080404
+    ],
+    "maxVelocity": [
+      6.909905940431707
+    ],
+    "maxAcceleration": [
+      4.7729057748561345
+    ],
+    "maxJerk": [
+      13.837603584367923
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.0730201348198865
+    ],
+    "currentVelocity": [
+      3.5468196803960783
+    ],
+    "currentAcceleration": [
+      -3.072663650731063
+    ],
+    "targetPosition": [
+      7.284124614037456
+    ],
+    "targetVelocity": [
+      -3.171888149947334
+    ],
+    "targetAcceleration": [
+      4.044374554962667
+    ],
+    "maxVelocity": [
+      3.947829526028764
+    ],
+    "maxAcceleration": [
+      4.491037488477156
+    ],
+    "maxJerk": [
+      19.000979848076778
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.104675265441371
+    ],
+    "currentVelocity": [
+      -2.6107550970846605
+    ],
+    "currentAcceleration": [
+      4.509234498811809
+    ],
+    "targetPosition": [
+      1.9038183889525495
+    ],
+    "targetVelocity": [
+      -3.0969556820695967
+    ],
+    "targetAcceleration": [
+      -0.4438231583775636
+    ],
+    "maxVelocity": [
+      7.053612787875815
+    ],
+    "maxAcceleration": [
+      6.561593642596504
+    ],
+    "maxJerk": [
+      10.21856744156889
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.765641326738844
+    ],
+    "currentVelocity": [
+      -3.6869447202506116
+    ],
+    "currentAcceleration": [
+      2.922554926497562
+    ],
+    "targetPosition": [
+      -6.793693886360943
+    ],
+    "targetVelocity": [
+      0.146659248152873
+    ],
+    "targetAcceleration": [
+      -1.7374235231396291
+    ],
+    "maxVelocity": [
+      5.144049275911598
+    ],
+    "maxAcceleration": [
+      3.348257870050679
+    ],
+    "maxJerk": [
+      5.732242294570205
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.9209812910323727
+    ],
+    "currentVelocity": [
+      -0.06260316353689
+    ],
+    "currentAcceleration": [
+      -1.8942991982260025
+    ],
+    "targetPosition": [
+      -8.88993986863905
+    ],
+    "targetVelocity": [
+      4.455272163411078
+    ],
+    "targetAcceleration": [
+      3.6898819321625966
+    ],
+    "maxVelocity": [
+      5.146711715011697
+    ],
+    "maxAcceleration": [
+      4.947403835583695
+    ],
+    "maxJerk": [
+      7.808722474904138
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.192354201480825
+    ],
+    "currentVelocity": [
+      1.2855317420120826
+    ],
+    "currentAcceleration": [
+      -4.357683897952078
+    ],
+    "targetPosition": [
+      2.4280150281455697
+    ],
+    "targetVelocity": [
+      -3.5474499044465224
+    ],
+    "targetAcceleration": [
+      -3.884879689490396
+    ],
+    "maxVelocity": [
+      5.780050860918487
+    ],
+    "maxAcceleration": [
+      4.362891633192847
+    ],
+    "maxJerk": [
+      6.858845001790431
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.863013362677135
+    ],
+    "currentVelocity": [
+      0.8518480993361326
+    ],
+    "currentAcceleration": [
+      -3.7883638212530513
+    ],
+    "targetPosition": [
+      -9.485485112795784
+    ],
+    "targetVelocity": [
+      2.23536673693829
+    ],
+    "targetAcceleration": [
+      5.223250978857271
+    ],
+    "maxVelocity": [
+      5.5199080160120335
+    ],
+    "maxAcceleration": [
+      5.7322759166303445
+    ],
+    "maxJerk": [
+      19.70799534508022
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7457503451334837
+    ],
+    "currentVelocity": [
+      -0.9326036368729849
+    ],
+    "currentAcceleration": [
+      3.0430575353859677
+    ],
+    "targetPosition": [
+      8.120175275352569
+    ],
+    "targetVelocity": [
+      -1.451536751290746
+    ],
+    "targetAcceleration": [
+      -0.4105592445403978
+    ],
+    "maxVelocity": [
+      5.481990323266505
+    ],
+    "maxAcceleration": [
+      8.427787825967606
+    ],
+    "maxJerk": [
+      7.917149857632398
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.184794927869043
+    ],
+    "currentVelocity": [
+      1.3101924419731592
+    ],
+    "currentAcceleration": [
+      -2.525859325529046
+    ],
+    "targetPosition": [
+      -4.743965161057799
+    ],
+    "targetVelocity": [
+      1.4485976275804457
+    ],
+    "targetAcceleration": [
+      -0.9133760530524735
+    ],
+    "maxVelocity": [
+      5.909116510120188
+    ],
+    "maxAcceleration": [
+      3.044929229331602
+    ],
+    "maxJerk": [
+      11.363834358802613
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.765793416750806
+    ],
+    "currentVelocity": [
+      -5.254884790726454
+    ],
+    "currentAcceleration": [
+      2.34372118330879
+    ],
+    "targetPosition": [
+      4.466195858883186
+    ],
+    "targetVelocity": [
+      4.876257197473979
+    ],
+    "targetAcceleration": [
+      2.3665465514142694
+    ],
+    "maxVelocity": [
+      7.328148620789161
+    ],
+    "maxAcceleration": [
+      3.4142849325227145
+    ],
+    "maxJerk": [
+      9.279325265870462
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.209032431992739
+    ],
+    "currentVelocity": [
+      -5.1398917531005175
+    ],
+    "currentAcceleration": [
+      -1.1741869865110015
+    ],
+    "targetPosition": [
+      5.7887256769333995
+    ],
+    "targetVelocity": [
+      0.6249756579831525
+    ],
+    "targetAcceleration": [
+      3.4740913787910594
+    ],
+    "maxVelocity": [
+      6.910703077030304
+    ],
+    "maxAcceleration": [
+      5.395876153845909
+    ],
+    "maxJerk": [
+      11.878893269935524
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.200512778856988
+    ],
+    "currentVelocity": [
+      -0.45618332881481116
+    ],
+    "currentAcceleration": [
+      -7.015294109006877
+    ],
+    "targetPosition": [
+      2.3643041997289522
+    ],
+    "targetVelocity": [
+      2.9611289548687036
+    ],
+    "targetAcceleration": [
+      -6.089580831329684
+    ],
+    "maxVelocity": [
+      5.5423467739583625
+    ],
+    "maxAcceleration": [
+      8.923860012678775
+    ],
+    "maxJerk": [
+      7.64738528125276
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.463796977937445
+    ],
+    "currentVelocity": [
+      -3.7227619146659983
+    ],
+    "currentAcceleration": [
+      -2.854625256076217
+    ],
+    "targetPosition": [
+      -5.815120858805982
+    ],
+    "targetVelocity": [
+      -4.147701234815729
+    ],
+    "targetAcceleration": [
+      1.2729920457267712
+    ],
+    "maxVelocity": [
+      4.5173873636235555
+    ],
+    "maxAcceleration": [
+      5.234790022138223
+    ],
+    "maxJerk": [
+      5.8663600451713265
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.794594690635094
+    ],
+    "currentVelocity": [
+      5.303279329527417
+    ],
+    "currentAcceleration": [
+      -1.881286518712357
+    ],
+    "targetPosition": [
+      2.188402958608812
+    ],
+    "targetVelocity": [
+      -3.545162640993775
+    ],
+    "targetAcceleration": [
+      1.0005035721939608
+    ],
+    "maxVelocity": [
+      6.597518964451018
+    ],
+    "maxAcceleration": [
+      3.676876840868098
+    ],
+    "maxJerk": [
+      14.706498650788147
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.608430555538781
+    ],
+    "currentVelocity": [
+      -0.7005974857007304
+    ],
+    "currentAcceleration": [
+      -2.836169710511254
+    ],
+    "targetPosition": [
+      -8.177923909559532
+    ],
+    "targetVelocity": [
+      0.9659353940723934
+    ],
+    "targetAcceleration": [
+      -0.35698598150559313
+    ],
+    "maxVelocity": [
+      2.537894197486642
+    ],
+    "maxAcceleration": [
+      4.091510616134878
+    ],
+    "maxJerk": [
+      11.533789879130344
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.4449740029574425
+    ],
+    "currentVelocity": [
+      5.377777523724907
+    ],
+    "currentAcceleration": [
+      1.5640235834021494
+    ],
+    "targetPosition": [
+      5.232966725489369
+    ],
+    "targetVelocity": [
+      -4.787611128076056
+    ],
+    "targetAcceleration": [
+      -3.7444042451132344
+    ],
+    "maxVelocity": [
+      6.806588794091626
+    ],
+    "maxAcceleration": [
+      5.620691135588594
+    ],
+    "maxJerk": [
+      15.335912936086544
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.6120181203187567
+    ],
+    "currentVelocity": [
+      -5.550570289647071
+    ],
+    "currentAcceleration": [
+      4.641056446573167
+    ],
+    "targetPosition": [
+      0.9784501866504556
+    ],
+    "targetVelocity": [
+      2.1006793505845147
+    ],
+    "targetAcceleration": [
+      -2.0762093671265403
+    ],
+    "maxVelocity": [
+      6.949275091636712
+    ],
+    "maxAcceleration": [
+      5.6595315283170535
+    ],
+    "maxJerk": [
+      15.878475919656884
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.027603743493955
+    ],
+    "currentVelocity": [
+      -5.097370829383896
+    ],
+    "currentAcceleration": [
+      -1.843966286138396
+    ],
+    "targetPosition": [
+      -5.579372922612171
+    ],
+    "targetVelocity": [
+      7.803170545736137
+    ],
+    "targetAcceleration": [
+      2.4634117816863634
+    ],
+    "maxVelocity": [
+      7.863221160923079
+    ],
+    "maxAcceleration": [
+      5.4131440596184355
+    ],
+    "maxJerk": [
+      14.077060453642432
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.001756027262974
+    ],
+    "currentVelocity": [
+      2.1356070262719813
+    ],
+    "currentAcceleration": [
+      0.21648646808063532
+    ],
+    "targetPosition": [
+      8.813542661042291
+    ],
+    "targetVelocity": [
+      -3.458589225251854
+    ],
+    "targetAcceleration": [
+      -0.9977984776646762
+    ],
+    "maxVelocity": [
+      4.317220142957623
+    ],
+    "maxAcceleration": [
+      3.1973497067366474
+    ],
+    "maxJerk": [
+      16.099166257063352
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.2944994563352594
+    ],
+    "currentVelocity": [
+      -2.458708285023529
+    ],
+    "currentAcceleration": [
+      -3.7769279998343226
+    ],
+    "targetPosition": [
+      -6.7359635422721365
+    ],
+    "targetVelocity": [
+      0.36524495679242364
+    ],
+    "targetAcceleration": [
+      -4.879037663064994
+    ],
+    "maxVelocity": [
+      3.7033255667614
+    ],
+    "maxAcceleration": [
+      8.59556314435911
+    ],
+    "maxJerk": [
+      10.68907843801523
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.144269956617418
+    ],
+    "currentVelocity": [
+      -2.2955196855569304
+    ],
+    "currentAcceleration": [
+      2.3417603496029336
+    ],
+    "targetPosition": [
+      2.9070518143957784
+    ],
+    "targetVelocity": [
+      1.2439112701424442
+    ],
+    "targetAcceleration": [
+      -0.6955882333059686
+    ],
+    "maxVelocity": [
+      2.504815302695518
+    ],
+    "maxAcceleration": [
+      3.9629144979123176
+    ],
+    "maxJerk": [
+      13.253962607053577
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.87380790060438
+    ],
+    "currentVelocity": [
+      4.913147357458906
+    ],
+    "currentAcceleration": [
+      -0.3142448431910214
+    ],
+    "targetPosition": [
+      1.8035388398452916
+    ],
+    "targetVelocity": [
+      1.6410670839315236
+    ],
+    "targetAcceleration": [
+      -3.594716191112711
+    ],
+    "maxVelocity": [
+      5.8211492467608155
+    ],
+    "maxAcceleration": [
+      5.763892245760393
+    ],
+    "maxJerk": [
+      9.672049426528819
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.816246760373593
+    ],
+    "currentVelocity": [
+      -0.841169210182247
+    ],
+    "currentAcceleration": [
+      -5.191484981166499
+    ],
+    "targetPosition": [
+      -3.5071098600021022
+    ],
+    "targetVelocity": [
+      1.4387979050122217
+    ],
+    "targetAcceleration": [
+      3.188095278180139
+    ],
+    "maxVelocity": [
+      4.2020080918752525
+    ],
+    "maxAcceleration": [
+      5.409775335574038
+    ],
+    "maxJerk": [
+      8.158436669588696
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.321474086408514
+    ],
+    "currentVelocity": [
+      -2.1067036060738933
+    ],
+    "currentAcceleration": [
+      8.535144355757652
+    ],
+    "targetPosition": [
+      2.067149228005672
+    ],
+    "targetVelocity": [
+      -0.7739724724558679
+    ],
+    "targetAcceleration": [
+      6.558359954996215
+    ],
+    "maxVelocity": [
+      5.994778361944384
+    ],
+    "maxAcceleration": [
+      9.093612647577586
+    ],
+    "maxJerk": [
+      5.332684659702532
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.9159937026869933
+    ],
+    "currentVelocity": [
+      3.9463394049351264
+    ],
+    "currentAcceleration": [
+      0.5893515144161032
+    ],
+    "targetPosition": [
+      1.8304722238672149
+    ],
+    "targetVelocity": [
+      -2.5880589615852116
+    ],
+    "targetAcceleration": [
+      -1.7446976748656444
+    ],
+    "maxVelocity": [
+      4.536194222087436
+    ],
+    "maxAcceleration": [
+      3.4532400617030348
+    ],
+    "maxJerk": [
+      9.708938188374047
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.761672990971469
+    ],
+    "currentVelocity": [
+      0.5964701332004343
+    ],
+    "currentAcceleration": [
+      2.1188993890016077
+    ],
+    "targetPosition": [
+      -0.7757995332680814
+    ],
+    "targetVelocity": [
+      -1.1513995208379035
+    ],
+    "targetAcceleration": [
+      2.812579068579809
+    ],
+    "maxVelocity": [
+      2.2231584431420304
+    ],
+    "maxAcceleration": [
+      4.697202168625656
+    ],
+    "maxJerk": [
+      16.30723569213522
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.604390007269267
+    ],
+    "currentVelocity": [
+      0.126084036107466
+    ],
+    "currentAcceleration": [
+      2.621293285691234
+    ],
+    "targetPosition": [
+      2.1553976350952393
+    ],
+    "targetVelocity": [
+      3.0024721119367666
+    ],
+    "targetAcceleration": [
+      -3.4572779892331877
+    ],
+    "maxVelocity": [
+      4.159280081535483
+    ],
+    "maxAcceleration": [
+      3.7181006325862374
+    ],
+    "maxJerk": [
+      8.047373698941197
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.4479601761668306
+    ],
+    "currentVelocity": [
+      -2.5722385247817243
+    ],
+    "currentAcceleration": [
+      0.042305854621441874
+    ],
+    "targetPosition": [
+      0.07345971939480478
+    ],
+    "targetVelocity": [
+      -1.6101276358074814
+    ],
+    "targetAcceleration": [
+      0.036196268490902295
+    ],
+    "maxVelocity": [
+      2.8355611534095795
+    ],
+    "maxAcceleration": [
+      3.460151677166814
+    ],
+    "maxJerk": [
+      5.647568920947183
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.806345134071854
+    ],
+    "currentVelocity": [
+      0.3823806001078207
+    ],
+    "currentAcceleration": [
+      1.8663710141225796
+    ],
+    "targetPosition": [
+      5.981462820825584
+    ],
+    "targetVelocity": [
+      -1.1753345430473545
+    ],
+    "targetAcceleration": [
+      2.6156935863959196
+    ],
+    "maxVelocity": [
+      4.446613621772062
+    ],
+    "maxAcceleration": [
+      3.06121606471618
+    ],
+    "maxJerk": [
+      16.34350419554033
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.8911097600709041
+    ],
+    "currentVelocity": [
+      1.164592909045206
+    ],
+    "currentAcceleration": [
+      3.4180930377025422
+    ],
+    "targetPosition": [
+      5.094195527326624
+    ],
+    "targetVelocity": [
+      2.901191308516479
+    ],
+    "targetAcceleration": [
+      -6.163007983551527
+    ],
+    "maxVelocity": [
+      4.869611266463959
+    ],
+    "maxAcceleration": [
+      8.528979950606647
+    ],
+    "maxJerk": [
+      15.227517109280862
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.086452969330022
+    ],
+    "currentVelocity": [
+      2.8002472822704636
+    ],
+    "currentAcceleration": [
+      -2.8424290669500367
+    ],
+    "targetPosition": [
+      8.36388505457748
+    ],
+    "targetVelocity": [
+      3.347741495819408
+    ],
+    "targetAcceleration": [
+      -6.248589984920411
+    ],
+    "maxVelocity": [
+      4.9797409564316
+    ],
+    "maxAcceleration": [
+      9.125787276490833
+    ],
+    "maxJerk": [
+      17.269318151258197
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.643581439275824
+    ],
+    "currentVelocity": [
+      1.0477249356136191
+    ],
+    "currentAcceleration": [
+      -2.41768501783754
+    ],
+    "targetPosition": [
+      6.557257027416767
+    ],
+    "targetVelocity": [
+      2.6116878515554864
+    ],
+    "targetAcceleration": [
+      1.2006844420004068
+    ],
+    "maxVelocity": [
+      3.407051765303917
+    ],
+    "maxAcceleration": [
+      7.624941848125086
+    ],
+    "maxJerk": [
+      9.020820696717351
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.2487212800423606
+    ],
+    "currentVelocity": [
+      -2.095519671484536
+    ],
+    "currentAcceleration": [
+      0.2887227869848088
+    ],
+    "targetPosition": [
+      -3.230442486606835
+    ],
+    "targetVelocity": [
+      -5.179291751215883
+    ],
+    "targetAcceleration": [
+      6.885459535561445
+    ],
+    "maxVelocity": [
+      7.719578066257892
+    ],
+    "maxAcceleration": [
+      7.475838309070099
+    ],
+    "maxJerk": [
+      19.104618365863196
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.44890196706406726
+    ],
+    "currentVelocity": [
+      -4.398412360857957
+    ],
+    "currentAcceleration": [
+      4.045558487228986
+    ],
+    "targetPosition": [
+      -6.6223076283506614
+    ],
+    "targetVelocity": [
+      -4.916629936844243
+    ],
+    "targetAcceleration": [
+      0.08025344355919373
+    ],
+    "maxVelocity": [
+      6.667253001193995
+    ],
+    "maxAcceleration": [
+      5.350380883755314
+    ],
+    "maxJerk": [
+      19.803996150498357
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7302943966192785
+    ],
+    "currentVelocity": [
+      -2.089596579454291
+    ],
+    "currentAcceleration": [
+      7.328545678569718
+    ],
+    "targetPosition": [
+      -4.522728157741474
+    ],
+    "targetVelocity": [
+      -1.1004258055144143
+    ],
+    "targetAcceleration": [
+      -7.8200665516807755
+    ],
+    "maxVelocity": [
+      3.789799184180584
+    ],
+    "maxAcceleration": [
+      8.928131297553414
+    ],
+    "maxJerk": [
+      17.937116749128478
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.575061878543179
+    ],
+    "currentVelocity": [
+      -1.7342873918085673
+    ],
+    "currentAcceleration": [
+      -0.05813867958782071
+    ],
+    "targetPosition": [
+      -0.17449917236211476
+    ],
+    "targetVelocity": [
+      -0.4530371699890723
+    ],
+    "targetAcceleration": [
+      2.3128267293139713
+    ],
+    "maxVelocity": [
+      2.4918755243371837
+    ],
+    "maxAcceleration": [
+      3.044361381035226
+    ],
+    "maxJerk": [
+      16.81308060765888
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.814301662609452
+    ],
+    "currentVelocity": [
+      -1.5989595754847272
+    ],
+    "currentAcceleration": [
+      1.1226788831840881
+    ],
+    "targetPosition": [
+      -1.3454970420554968
+    ],
+    "targetVelocity": [
+      0.3509363789822606
+    ],
+    "targetAcceleration": [
+      -4.232406091090064
+    ],
+    "maxVelocity": [
+      2.158978236845219
+    ],
+    "maxAcceleration": [
+      8.3171335463672
+    ],
+    "maxJerk": [
+      18.56638396679216
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.194587701055617
+    ],
+    "currentVelocity": [
+      -0.7126118934373646
+    ],
+    "currentAcceleration": [
+      -1.863654002878976
+    ],
+    "targetPosition": [
+      -0.6553193347421526
+    ],
+    "targetVelocity": [
+      -0.13056321809790994
+    ],
+    "targetAcceleration": [
+      -2.1170332734611867
+    ],
+    "maxVelocity": [
+      2.654576407555255
+    ],
+    "maxAcceleration": [
+      5.182346973250556
+    ],
+    "maxJerk": [
+      19.026320230116376
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.591822635039939
+    ],
+    "currentVelocity": [
+      1.1223631534219942
+    ],
+    "currentAcceleration": [
+      2.4926141280709766
+    ],
+    "targetPosition": [
+      -2.9920477569415604
+    ],
+    "targetVelocity": [
+      1.905000222294169
+    ],
+    "targetAcceleration": [
+      2.5699593733073938
+    ],
+    "maxVelocity": [
+      5.368281618715594
+    ],
+    "maxAcceleration": [
+      4.624208650604588
+    ],
+    "maxJerk": [
+      15.712657746344677
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.933205170089707
+    ],
+    "currentVelocity": [
+      0.6402894421095073
+    ],
+    "currentAcceleration": [
+      -2.6157359827853837
+    ],
+    "targetPosition": [
+      5.155763800672272
+    ],
+    "targetVelocity": [
+      -1.0238071623699447
+    ],
+    "targetAcceleration": [
+      2.27507813023018
+    ],
+    "maxVelocity": [
+      3.626906733477873
+    ],
+    "maxAcceleration": [
+      4.071341882185873
+    ],
+    "maxJerk": [
+      19.216887661099467
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.237639380072153
+    ],
+    "currentVelocity": [
+      -4.165749932382208
+    ],
+    "currentAcceleration": [
+      2.935160600833809
+    ],
+    "targetPosition": [
+      9.233377377313236
+    ],
+    "targetVelocity": [
+      0.9465550167524341
+    ],
+    "targetAcceleration": [
+      -0.990777157404505
+    ],
+    "maxVelocity": [
+      5.624004692313129
+    ],
+    "maxAcceleration": [
+      7.703760088086042
+    ],
+    "maxJerk": [
+      14.099991255798413
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.421740827564619
+    ],
+    "currentVelocity": [
+      0.7617213275956227
+    ],
+    "currentAcceleration": [
+      -7.153365695815531
+    ],
+    "targetPosition": [
+      1.954390639126533
+    ],
+    "targetVelocity": [
+      0.618122177984485
+    ],
+    "targetAcceleration": [
+      6.134803049733767
+    ],
+    "maxVelocity": [
+      3.041008011372477
+    ],
+    "maxAcceleration": [
+      7.338608759973342
+    ],
+    "maxJerk": [
+      15.37612069302424
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.629250028407792
+    ],
+    "currentVelocity": [
+      -0.10502425233968538
+    ],
+    "currentAcceleration": [
+      -3.8156910895975953
+    ],
+    "targetPosition": [
+      -4.541380833511028
+    ],
+    "targetVelocity": [
+      -2.862968874387139
+    ],
+    "targetAcceleration": [
+      -2.084686943660036
+    ],
+    "maxVelocity": [
+      3.8028153006695575
+    ],
+    "maxAcceleration": [
+      6.61038939115746
+    ],
+    "maxJerk": [
+      10.410593089222804
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.016143777495752
+    ],
+    "currentVelocity": [
+      3.8611750097024817
+    ],
+    "currentAcceleration": [
+      -0.48917921772589956
+    ],
+    "targetPosition": [
+      8.08629304061466
+    ],
+    "targetVelocity": [
+      4.134460760476463
+    ],
+    "targetAcceleration": [
+      3.779582678070412
+    ],
+    "maxVelocity": [
+      4.996171002942129
+    ],
+    "maxAcceleration": [
+      8.796446386055424
+    ],
+    "maxJerk": [
+      19.133407609522873
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.5485244422925817
+    ],
+    "currentVelocity": [
+      2.089885890515961
+    ],
+    "currentAcceleration": [
+      1.4223696212770607
+    ],
+    "targetPosition": [
+      8.586381836437841
+    ],
+    "targetVelocity": [
+      -0.5898926571506626
+    ],
+    "targetAcceleration": [
+      0.47308210839282516
+    ],
+    "maxVelocity": [
+      7.927263421768996
+    ],
+    "maxAcceleration": [
+      5.9283150795171125
+    ],
+    "maxJerk": [
+      7.457571107344215
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.3652277378157684
+    ],
+    "currentVelocity": [
+      -0.6259931869761575
+    ],
+    "currentAcceleration": [
+      1.753787778819187
+    ],
+    "targetPosition": [
+      8.20489198294431
+    ],
+    "targetVelocity": [
+      2.3147321719554323
+    ],
+    "targetAcceleration": [
+      -0.8294286024028446
+    ],
+    "maxVelocity": [
+      2.875485640861913
+    ],
+    "maxAcceleration": [
+      3.395715120235148
+    ],
+    "maxJerk": [
+      16.94647814898973
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.485818760898898
+    ],
+    "currentVelocity": [
+      1.4468119256874132
+    ],
+    "currentAcceleration": [
+      0.3710627765163599
+    ],
+    "targetPosition": [
+      7.5091668817077775
+    ],
+    "targetVelocity": [
+      -0.8580067327807206
+    ],
+    "targetAcceleration": [
+      -3.5962849742968332
+    ],
+    "maxVelocity": [
+      2.000673204385655
+    ],
+    "maxAcceleration": [
+      5.903200875643165
+    ],
+    "maxJerk": [
+      13.751263623490626
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.979497095978329
+    ],
+    "currentVelocity": [
+      1.896325195562921
+    ],
+    "currentAcceleration": [
+      -0.655268633858122
+    ],
+    "targetPosition": [
+      -8.311610405469779
+    ],
+    "targetVelocity": [
+      0.4132723462303245
+    ],
+    "targetAcceleration": [
+      -2.6191483949682954
+    ],
+    "maxVelocity": [
+      2.8019421803900744
+    ],
+    "maxAcceleration": [
+      6.396056652401995
+    ],
+    "maxJerk": [
+      7.690586884159296
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.010843594792266
+    ],
+    "currentVelocity": [
+      -0.1016680993844572
+    ],
+    "currentAcceleration": [
+      -4.549766379877756
+    ],
+    "targetPosition": [
+      6.478563408681431
+    ],
+    "targetVelocity": [
+      -1.279000691663807
+    ],
+    "targetAcceleration": [
+      2.5864406712761454
+    ],
+    "maxVelocity": [
+      3.3600806133583974
+    ],
+    "maxAcceleration": [
+      7.446632313112103
+    ],
+    "maxJerk": [
+      7.529325525661075
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.4529800894464495
+    ],
+    "currentVelocity": [
+      -5.137470689018533
+    ],
+    "currentAcceleration": [
+      0.8004575649714631
+    ],
+    "targetPosition": [
+      7.946866977702566
+    ],
+    "targetVelocity": [
+      -6.149837565537483
+    ],
+    "targetAcceleration": [
+      -2.234402329136006
+    ],
+    "maxVelocity": [
+      6.25418294749327
+    ],
+    "maxAcceleration": [
+      9.970025220066624
+    ],
+    "maxJerk": [
+      18.632661999876127
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.9432265396594666
+    ],
+    "currentVelocity": [
+      2.299811341507594
+    ],
+    "currentAcceleration": [
+      -0.19085600031044692
+    ],
+    "targetPosition": [
+      -1.1165434307976856
+    ],
+    "targetVelocity": [
+      -5.180128087778378
+    ],
+    "targetAcceleration": [
+      2.317987369983605
+    ],
+    "maxVelocity": [
+      5.737475545943388
+    ],
+    "maxAcceleration": [
+      6.654170099152704
+    ],
+    "maxJerk": [
+      18.57125273808002
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.5266197210830903
+    ],
+    "currentVelocity": [
+      1.7089727687690095
+    ],
+    "currentAcceleration": [
+      2.2036680677051788
+    ],
+    "targetPosition": [
+      -9.108907735370577
+    ],
+    "targetVelocity": [
+      1.5246278572809109
+    ],
+    "targetAcceleration": [
+      0.6361018847417714
+    ],
+    "maxVelocity": [
+      5.117774210085229
+    ],
+    "maxAcceleration": [
+      8.248994086958575
+    ],
+    "maxJerk": [
+      10.544629868637545
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.13419071076746825
+    ],
+    "currentVelocity": [
+      -3.905661770174693
+    ],
+    "currentAcceleration": [
+      -4.609174567115087
+    ],
+    "targetPosition": [
+      1.9785751945185108
+    ],
+    "targetVelocity": [
+      -0.9009636407725372
+    ],
+    "targetAcceleration": [
+      2.5496771051703107
+    ],
+    "maxVelocity": [
+      7.7355526860978925
+    ],
+    "maxAcceleration": [
+      7.501372467990523
+    ],
+    "maxJerk": [
+      8.19930378810514
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.49674395009677
+    ],
+    "currentVelocity": [
+      3.189617339990029
+    ],
+    "currentAcceleration": [
+      4.697697193638757
+    ],
+    "targetPosition": [
+      8.463643325307281
+    ],
+    "targetVelocity": [
+      0.46702204341519593
+    ],
+    "targetAcceleration": [
+      4.654737167709404
+    ],
+    "maxVelocity": [
+      5.579199957424494
+    ],
+    "maxAcceleration": [
+      6.961383631564204
+    ],
+    "maxJerk": [
+      6.638134050543929
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.3801879316540955
+    ],
+    "currentVelocity": [
+      -5.012713743803273
+    ],
+    "currentAcceleration": [
+      0.9953952680596556
+    ],
+    "targetPosition": [
+      7.323322024307423
+    ],
+    "targetVelocity": [
+      -4.820990246523079
+    ],
+    "targetAcceleration": [
+      1.1260447542072063
+    ],
+    "maxVelocity": [
+      7.947320597538097
+    ],
+    "maxAcceleration": [
+      4.287242922607535
+    ],
+    "maxJerk": [
+      11.563480394956441
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.32894841663523344
+    ],
+    "currentVelocity": [
+      2.7559707031484066
+    ],
+    "currentAcceleration": [
+      2.0520055267597144
+    ],
+    "targetPosition": [
+      5.190986630678548
+    ],
+    "targetVelocity": [
+      0.16828842585109882
+    ],
+    "targetAcceleration": [
+      0.9155005235789435
+    ],
+    "maxVelocity": [
+      4.759752572531788
+    ],
+    "maxAcceleration": [
+      4.049258523739931
+    ],
+    "maxJerk": [
+      11.220218776411764
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.414258238450431
+    ],
+    "currentVelocity": [
+      3.2544127751809677
+    ],
+    "currentAcceleration": [
+      -1.9723168354973175
+    ],
+    "targetPosition": [
+      -9.76110417948787
+    ],
+    "targetVelocity": [
+      1.3467437580513506
+    ],
+    "targetAcceleration": [
+      -3.286902372993239
+    ],
+    "maxVelocity": [
+      7.667638221867063
+    ],
+    "maxAcceleration": [
+      3.6387160845773163
+    ],
+    "maxJerk": [
+      8.610033297469139
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.073776666504877
+    ],
+    "currentVelocity": [
+      5.239953771585489
+    ],
+    "currentAcceleration": [
+      2.530486914624856
+    ],
+    "targetPosition": [
+      -7.0135599838824465
+    ],
+    "targetVelocity": [
+      4.230550592980723
+    ],
+    "targetAcceleration": [
+      3.5140086787143345
+    ],
+    "maxVelocity": [
+      7.766836507550726
+    ],
+    "maxAcceleration": [
+      3.942063662150464
+    ],
+    "maxJerk": [
+      18.904387207772753
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.441125954469709
+    ],
+    "currentVelocity": [
+      -1.803658949334249
+    ],
+    "currentAcceleration": [
+      -1.6255149418056911
+    ],
+    "targetPosition": [
+      7.713084196415053
+    ],
+    "targetVelocity": [
+      0.14332756693939386
+    ],
+    "targetAcceleration": [
+      3.4800927422222543
+    ],
+    "maxVelocity": [
+      2.0332500057381346
+    ],
+    "maxAcceleration": [
+      6.02918590956352
+    ],
+    "maxJerk": [
+      15.4310168194645
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.774539832740267
+    ],
+    "currentVelocity": [
+      -1.5662721189483895
+    ],
+    "currentAcceleration": [
+      -7.112450712167883
+    ],
+    "targetPosition": [
+      4.005077565301388
+    ],
+    "targetVelocity": [
+      4.280318750429992
+    ],
+    "targetAcceleration": [
+      2.319127750313738
+    ],
+    "maxVelocity": [
+      6.243295653958268
+    ],
+    "maxAcceleration": [
+      9.7238793462084
+    ],
+    "maxJerk": [
+      14.697276167746248
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.834424832441189
+    ],
+    "currentVelocity": [
+      1.8959635636465952
+    ],
+    "currentAcceleration": [
+      3.495086873323573
+    ],
+    "targetPosition": [
+      3.6097753850639833
+    ],
+    "targetVelocity": [
+      -4.049643108087749
+    ],
+    "targetAcceleration": [
+      -3.8560984777262397
+    ],
+    "maxVelocity": [
+      5.71912513826008
+    ],
+    "maxAcceleration": [
+      5.458773049266459
+    ],
+    "maxJerk": [
+      5.717527735274484
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.025668831377359425
+    ],
+    "currentVelocity": [
+      2.365035542125021
+    ],
+    "currentAcceleration": [
+      3.8016418078285623
+    ],
+    "targetPosition": [
+      -5.664054656653046
+    ],
+    "targetVelocity": [
+      0.5183479977168819
+    ],
+    "targetAcceleration": [
+      3.4905251705025693
+    ],
+    "maxVelocity": [
+      3.381312214231632
+    ],
+    "maxAcceleration": [
+      4.975574637026432
+    ],
+    "maxJerk": [
+      15.536954122326362
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.1111936903104258
+    ],
+    "currentVelocity": [
+      0.4730844822744924
+    ],
+    "currentAcceleration": [
+      -5.408699183002234
+    ],
+    "targetPosition": [
+      -5.367164997304339
+    ],
+    "targetVelocity": [
+      0.797506227323387
+    ],
+    "targetAcceleration": [
+      7.453792576485581
+    ],
+    "maxVelocity": [
+      7.265344513906248
+    ],
+    "maxAcceleration": [
+      8.768131821956475
+    ],
+    "maxJerk": [
+      16.74797721691416
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.272611432732532
+    ],
+    "currentVelocity": [
+      -1.256139503718365
+    ],
+    "currentAcceleration": [
+      4.33313903468207
+    ],
+    "targetPosition": [
+      -5.474116229923949
+    ],
+    "targetVelocity": [
+      1.5226566614164234
+    ],
+    "targetAcceleration": [
+      -0.6977571473209982
+    ],
+    "maxVelocity": [
+      3.6165263243235355
+    ],
+    "maxAcceleration": [
+      8.072248960143757
+    ],
+    "maxJerk": [
+      18.858456468850818
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.042903057198334
+    ],
+    "currentVelocity": [
+      5.745484452475534
+    ],
+    "currentAcceleration": [
+      3.3389797220258144
+    ],
+    "targetPosition": [
+      0.2744133068096062
+    ],
+    "targetVelocity": [
+      3.219270655627488
+    ],
+    "targetAcceleration": [
+      -5.08290502307492
+    ],
+    "maxVelocity": [
+      6.716995946153082
+    ],
+    "maxAcceleration": [
+      5.144663682712303
+    ],
+    "maxJerk": [
+      7.167859978865341
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.198466925246152
+    ],
+    "currentVelocity": [
+      1.723434853049747
+    ],
+    "currentAcceleration": [
+      -4.613073190920112
+    ],
+    "targetPosition": [
+      2.5536499392863536
+    ],
+    "targetVelocity": [
+      -1.7243778333680047
+    ],
+    "targetAcceleration": [
+      -6.228356838516879
+    ],
+    "maxVelocity": [
+      2.7613428854020943
+    ],
+    "maxAcceleration": [
+      8.336692750034238
+    ],
+    "maxJerk": [
+      12.727050014068382
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.142468835179024
+    ],
+    "currentVelocity": [
+      1.0386814827632662
+    ],
+    "currentAcceleration": [
+      -1.7811578729088313
+    ],
+    "targetPosition": [
+      -9.853866821044475
+    ],
+    "targetVelocity": [
+      -3.9441240452883255
+    ],
+    "targetAcceleration": [
+      3.5291792053571722
+    ],
+    "maxVelocity": [
+      4.957420378582366
+    ],
+    "maxAcceleration": [
+      4.935970183905514
+    ],
+    "maxJerk": [
+      7.011542901043742
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.054055204830618
+    ],
+    "currentVelocity": [
+      -3.353377804985107
+    ],
+    "currentAcceleration": [
+      8.15709340255621
+    ],
+    "targetPosition": [
+      8.142044144244675
+    ],
+    "targetVelocity": [
+      -2.418033282573571
+    ],
+    "targetAcceleration": [
+      -2.140035187286518
+    ],
+    "maxVelocity": [
+      4.321016706893298
+    ],
+    "maxAcceleration": [
+      8.5564735708974
+    ],
+    "maxJerk": [
+      14.353682040736803
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.7579575218829895
+    ],
+    "currentVelocity": [
+      3.7897981165726353
+    ],
+    "currentAcceleration": [
+      -2.378910331552758
+    ],
+    "targetPosition": [
+      6.61801769880833
+    ],
+    "targetVelocity": [
+      0.4974093129946118
+    ],
+    "targetAcceleration": [
+      -4.1051981842672784
+    ],
+    "maxVelocity": [
+      4.420587533751576
+    ],
+    "maxAcceleration": [
+      7.416098455162331
+    ],
+    "maxJerk": [
+      15.625658971869882
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.463431679682673
+    ],
+    "currentVelocity": [
+      -4.176623205395582
+    ],
+    "currentAcceleration": [
+      -7.893489217991621
+    ],
+    "targetPosition": [
+      3.0357247466301622
+    ],
+    "targetVelocity": [
+      -0.928534771384494
+    ],
+    "targetAcceleration": [
+      -5.082504412168003
+    ],
+    "maxVelocity": [
+      6.5969370965084355
+    ],
+    "maxAcceleration": [
+      9.626002427076259
+    ],
+    "maxJerk": [
+      19.850846004904525
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.631504360935759
+    ],
+    "currentVelocity": [
+      -5.014986027842985
+    ],
+    "currentAcceleration": [
+      1.0222706946251598
+    ],
+    "targetPosition": [
+      -7.751603782996104
+    ],
+    "targetVelocity": [
+      -0.27527941330036665
+    ],
+    "targetAcceleration": [
+      -4.007995159159863
+    ],
+    "maxVelocity": [
+      7.860235554418752
+    ],
+    "maxAcceleration": [
+      5.36870087677969
+    ],
+    "maxJerk": [
+      18.95951327080166
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.950629915574169
+    ],
+    "currentVelocity": [
+      2.8343553341821863
+    ],
+    "currentAcceleration": [
+      -0.6810888435479105
+    ],
+    "targetPosition": [
+      -5.462942622132165
+    ],
+    "targetVelocity": [
+      -0.8642225958673473
+    ],
+    "targetAcceleration": [
+      -7.471863592838734
+    ],
+    "maxVelocity": [
+      3.4726640084502067
+    ],
+    "maxAcceleration": [
+      7.916326861916948
+    ],
+    "maxJerk": [
+      7.358555549042412
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.5758335444217604
+    ],
+    "currentVelocity": [
+      0.44800292352602566
+    ],
+    "currentAcceleration": [
+      -1.4372900058993308
+    ],
+    "targetPosition": [
+      -6.449637328181317
+    ],
+    "targetVelocity": [
+      2.2865493461044086
+    ],
+    "targetAcceleration": [
+      -1.3885672313856476
+    ],
+    "maxVelocity": [
+      3.8537993386213345
+    ],
+    "maxAcceleration": [
+      5.875762062743355
+    ],
+    "maxJerk": [
+      15.562854214183604
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.2748653615106775
+    ],
+    "currentVelocity": [
+      -2.04680174444849
+    ],
+    "currentAcceleration": [
+      -2.012593754002724
+    ],
+    "targetPosition": [
+      -1.0405453433201153
+    ],
+    "targetVelocity": [
+      0.7049925803377906
+    ],
+    "targetAcceleration": [
+      0.026090078291264085
+    ],
+    "maxVelocity": [
+      3.6169136844298317
+    ],
+    "maxAcceleration": [
+      3.043545571780834
+    ],
+    "maxJerk": [
+      12.320109898487775
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.149185957021373
+    ],
+    "currentVelocity": [
+      -1.3599825263855385
+    ],
+    "currentAcceleration": [
+      -2.913806438751787
+    ],
+    "targetPosition": [
+      -5.065344011767625
+    ],
+    "targetVelocity": [
+      2.0149938425539045
+    ],
+    "targetAcceleration": [
+      -3.4587612325858004
+    ],
+    "maxVelocity": [
+      2.5342631505159696
+    ],
+    "maxAcceleration": [
+      3.6349062830283985
+    ],
+    "maxJerk": [
+      17.80487293171196
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.631473326560025
+    ],
+    "currentVelocity": [
+      -2.1591497263064774
+    ],
+    "currentAcceleration": [
+      -8.329446748349099
+    ],
+    "targetPosition": [
+      5.480995325507163
+    ],
+    "targetVelocity": [
+      4.617452527589658
+    ],
+    "targetAcceleration": [
+      6.860377174764647
+    ],
+    "maxVelocity": [
+      7.7337975035485735
+    ],
+    "maxAcceleration": [
+      9.386305687181206
+    ],
+    "maxJerk": [
+      13.295991043337942
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.468367969922564
+    ],
+    "currentVelocity": [
+      4.786758484499221
+    ],
+    "currentAcceleration": [
+      3.572498344141499
+    ],
+    "targetPosition": [
+      9.76178947128465
+    ],
+    "targetVelocity": [
+      0.0896808764574395
+    ],
+    "targetAcceleration": [
+      -1.2112199459659347
+    ],
+    "maxVelocity": [
+      7.79897398560822
+    ],
+    "maxAcceleration": [
+      9.935614218423776
+    ],
+    "maxJerk": [
+      14.209139905052387
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.789388809650426
+    ],
+    "currentVelocity": [
+      -3.8274582451932733
+    ],
+    "currentAcceleration": [
+      -0.6996316515939727
+    ],
+    "targetPosition": [
+      9.829732016866483
+    ],
+    "targetVelocity": [
+      -0.04893195705232678
+    ],
+    "targetAcceleration": [
+      2.8783891927484415
+    ],
+    "maxVelocity": [
+      7.3345044658774095
+    ],
+    "maxAcceleration": [
+      3.1489191437064132
+    ],
+    "maxJerk": [
+      8.336405831525743
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.576169253200794
+    ],
+    "currentVelocity": [
+      -1.7787522852127986
+    ],
+    "currentAcceleration": [
+      -3.032876682829552
+    ],
+    "targetPosition": [
+      -6.001484976969911
+    ],
+    "targetVelocity": [
+      2.9670627344814813
+    ],
+    "targetAcceleration": [
+      3.6072864136351024
+    ],
+    "maxVelocity": [
+      4.468792421150821
+    ],
+    "maxAcceleration": [
+      7.357713549422265
+    ],
+    "maxJerk": [
+      17.028688541516363
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.3118295178406036
+    ],
+    "currentVelocity": [
+      -2.541662900148709
+    ],
+    "currentAcceleration": [
+      3.015604885425703
+    ],
+    "targetPosition": [
+      8.476093936256198
+    ],
+    "targetVelocity": [
+      6.103647418989794
+    ],
+    "targetAcceleration": [
+      -5.347007524256732
+    ],
+    "maxVelocity": [
+      7.792254904539996
+    ],
+    "maxAcceleration": [
+      7.593077286332854
+    ],
+    "maxJerk": [
+      11.517120026773632
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.319879656592548
+    ],
+    "currentVelocity": [
+      -1.8105529370392652
+    ],
+    "currentAcceleration": [
+      4.70775726891151
+    ],
+    "targetPosition": [
+      -0.5681973501430164
+    ],
+    "targetVelocity": [
+      -3.8356997294637583
+    ],
+    "targetAcceleration": [
+      0.5639554913651192
+    ],
+    "maxVelocity": [
+      7.402129198404133
+    ],
+    "maxAcceleration": [
+      7.371334565167319
+    ],
+    "maxJerk": [
+      18.05091087321956
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.946342100096512
+    ],
+    "currentVelocity": [
+      1.2512427974195663
+    ],
+    "currentAcceleration": [
+      -1.25500863992155
+    ],
+    "targetPosition": [
+      0.17623722408823284
+    ],
+    "targetVelocity": [
+      2.641322763432669
+    ],
+    "targetAcceleration": [
+      2.6042685323550163
+    ],
+    "maxVelocity": [
+      7.607511235359407
+    ],
+    "maxAcceleration": [
+      4.34696880698154
+    ],
+    "maxJerk": [
+      7.765029554736945
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.852037102014053
+    ],
+    "currentVelocity": [
+      -2.990627544244798
+    ],
+    "currentAcceleration": [
+      -5.20750752352964
+    ],
+    "targetPosition": [
+      8.661682134981675
+    ],
+    "targetVelocity": [
+      4.199127586916223
+    ],
+    "targetAcceleration": [
+      -2.7024525029108757
+    ],
+    "maxVelocity": [
+      4.635065669031237
+    ],
+    "maxAcceleration": [
+      5.571289949259034
+    ],
+    "maxJerk": [
+      12.397289407799425
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.5476749288446587
+    ],
+    "currentVelocity": [
+      -4.48156348877842
+    ],
+    "currentAcceleration": [
+      2.4085223001130593
+    ],
+    "targetPosition": [
+      7.571373583553882
+    ],
+    "targetVelocity": [
+      -4.855591782000856
+    ],
+    "targetAcceleration": [
+      1.0477222071807955
+    ],
+    "maxVelocity": [
+      7.795472587471678
+    ],
+    "maxAcceleration": [
+      7.294358440607164
+    ],
+    "maxJerk": [
+      15.425985127025672
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.323347107332566
+    ],
+    "currentVelocity": [
+      -5.615597356769315
+    ],
+    "currentAcceleration": [
+      2.891595256196061
+    ],
+    "targetPosition": [
+      9.758263941681982
+    ],
+    "targetVelocity": [
+      1.2977764168569834
+    ],
+    "targetAcceleration": [
+      -2.2863014790448384
+    ],
+    "maxVelocity": [
+      5.652818751447159
+    ],
+    "maxAcceleration": [
+      3.7562699521846032
+    ],
+    "maxJerk": [
+      7.532245738177229
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.563107124791319
+    ],
+    "currentVelocity": [
+      -3.8167396583429727
+    ],
+    "currentAcceleration": [
+      3.1802359410162495
+    ],
+    "targetPosition": [
+      -4.1562508508325235
+    ],
+    "targetVelocity": [
+      2.0150547217694985
+    ],
+    "targetAcceleration": [
+      0.8964785586965238
+    ],
+    "maxVelocity": [
+      6.645537586879135
+    ],
+    "maxAcceleration": [
+      8.316438760386022
+    ],
+    "maxJerk": [
+      11.709460651406111
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.946839875216721
+    ],
+    "currentVelocity": [
+      1.4322337670217236
+    ],
+    "currentAcceleration": [
+      3.519637656138009
+    ],
+    "targetPosition": [
+      1.1660400652358192
+    ],
+    "targetVelocity": [
+      0.18757676360992814
+    ],
+    "targetAcceleration": [
+      -6.181613541304269
+    ],
+    "maxVelocity": [
+      3.112714860050408
+    ],
+    "maxAcceleration": [
+      9.572506467363635
+    ],
+    "maxJerk": [
+      8.741515876639605
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.645021199230925
+    ],
+    "currentVelocity": [
+      -0.8097570422616203
+    ],
+    "currentAcceleration": [
+      1.7215433505807098
+    ],
+    "targetPosition": [
+      -5.070275263895915
+    ],
+    "targetVelocity": [
+      -3.510663862680045
+    ],
+    "targetAcceleration": [
+      -2.7857834866164426
+    ],
+    "maxVelocity": [
+      7.62703773768164
+    ],
+    "maxAcceleration": [
+      3.0988318274675777
+    ],
+    "maxJerk": [
+      14.354563256026385
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.59387353511169
+    ],
+    "currentVelocity": [
+      0.6448356004364646
+    ],
+    "currentAcceleration": [
+      0.14984224880894104
+    ],
+    "targetPosition": [
+      -1.1818973180884544
+    ],
+    "targetVelocity": [
+      3.3281206313559855
+    ],
+    "targetAcceleration": [
+      5.24471715060135
+    ],
+    "maxVelocity": [
+      3.6003034605500224
+    ],
+    "maxAcceleration": [
+      9.63150828057319
+    ],
+    "maxJerk": [
+      6.0206115228872505
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.5848683965776456
+    ],
+    "currentVelocity": [
+      0.09427548110240647
+    ],
+    "currentAcceleration": [
+      3.5134775443455872
+    ],
+    "targetPosition": [
+      -4.710797871270723
+    ],
+    "targetVelocity": [
+      -1.104088323050941
+    ],
+    "targetAcceleration": [
+      -1.726705956386673
+    ],
+    "maxVelocity": [
+      3.351616915114578
+    ],
+    "maxAcceleration": [
+      8.319559369171667
+    ],
+    "maxJerk": [
+      13.806042661727979
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.688097876509633
+    ],
+    "currentVelocity": [
+      -1.7015296152458483
+    ],
+    "currentAcceleration": [
+      -0.42670376374772445
+    ],
+    "targetPosition": [
+      -7.958483789617363
+    ],
+    "targetVelocity": [
+      -0.5462221726163543
+    ],
+    "targetAcceleration": [
+      0.6644656541982181
+    ],
+    "maxVelocity": [
+      5.110972297050291
+    ],
+    "maxAcceleration": [
+      5.006371997847216
+    ],
+    "maxJerk": [
+      9.137968132643184
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.4001560901951269
+    ],
+    "currentVelocity": [
+      2.9175105402869885
+    ],
+    "currentAcceleration": [
+      4.09975394634874
+    ],
+    "targetPosition": [
+      -3.600990086782021
+    ],
+    "targetVelocity": [
+      3.7782360619752016
+    ],
+    "targetAcceleration": [
+      2.647755713508044
+    ],
+    "maxVelocity": [
+      4.880879604430854
+    ],
+    "maxAcceleration": [
+      7.225821222881347
+    ],
+    "maxJerk": [
+      19.691665791573733
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.3447525018226685
+    ],
+    "currentVelocity": [
+      -5.809566695559364
+    ],
+    "currentAcceleration": [
+      -1.746332443001417
+    ],
+    "targetPosition": [
+      -6.876719261152811
+    ],
+    "targetVelocity": [
+      0.4689648343973012
+    ],
+    "targetAcceleration": [
+      -0.5619292172057397
+    ],
+    "maxVelocity": [
+      6.466361255544058
+    ],
+    "maxAcceleration": [
+      3.4308000709987305
+    ],
+    "maxJerk": [
+      7.400515400099126
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.9600963396739886
+    ],
+    "currentVelocity": [
+      1.9659029782417865
+    ],
+    "currentAcceleration": [
+      3.0589116676752157
+    ],
+    "targetPosition": [
+      2.2504253126426406
+    ],
+    "targetVelocity": [
+      -1.6557525572727516
+    ],
+    "targetAcceleration": [
+      1.2908522959238473
+    ],
+    "maxVelocity": [
+      3.7479402233689902
+    ],
+    "maxAcceleration": [
+      3.358975463562172
+    ],
+    "maxJerk": [
+      15.312111968653891
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.868177731258285
+    ],
+    "currentVelocity": [
+      -2.857696336715259
+    ],
+    "currentAcceleration": [
+      1.7350483538803343
+    ],
+    "targetPosition": [
+      -4.4569143582268005
+    ],
+    "targetVelocity": [
+      1.392514159044679
+    ],
+    "targetAcceleration": [
+      2.14786569257616
+    ],
+    "maxVelocity": [
+      3.869163355300892
+    ],
+    "maxAcceleration": [
+      3.1317244205526458
+    ],
+    "maxJerk": [
+      16.884414235311986
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.606544896778736
+    ],
+    "currentVelocity": [
+      -0.34570682592796764
+    ],
+    "currentAcceleration": [
+      -0.8164171975112202
+    ],
+    "targetPosition": [
+      -2.6807675200806464
+    ],
+    "targetVelocity": [
+      2.8182203742009904
+    ],
+    "targetAcceleration": [
+      -0.9254340740772644
+    ],
+    "maxVelocity": [
+      5.117172461117553
+    ],
+    "maxAcceleration": [
+      4.878601982870034
+    ],
+    "maxJerk": [
+      10.742982235043238
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.0848262802921305
+    ],
+    "currentVelocity": [
+      4.429630982104062
+    ],
+    "currentAcceleration": [
+      -7.026537573682639
+    ],
+    "targetPosition": [
+      3.700900954260643
+    ],
+    "targetVelocity": [
+      -0.07125684229812901
+    ],
+    "targetAcceleration": [
+      3.9676629299894994
+    ],
+    "maxVelocity": [
+      7.406793568762433
+    ],
+    "maxAcceleration": [
+      9.74007310666629
+    ],
+    "maxJerk": [
+      11.019736983101446
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.842380974599982
+    ],
+    "currentVelocity": [
+      -0.48599416279598096
+    ],
+    "currentAcceleration": [
+      -8.956000282183762
+    ],
+    "targetPosition": [
+      -4.310565821618684
+    ],
+    "targetVelocity": [
+      -5.174520173349745
+    ],
+    "targetAcceleration": [
+      -5.67526749847906
+    ],
+    "maxVelocity": [
+      6.152955017695302
+    ],
+    "maxAcceleration": [
+      9.279909108157252
+    ],
+    "maxJerk": [
+      16.40724364702436
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.512077002148425
+    ],
+    "currentVelocity": [
+      -2.2301853985550015
+    ],
+    "currentAcceleration": [
+      4.482069838975773
+    ],
+    "targetPosition": [
+      6.065829624549245
+    ],
+    "targetVelocity": [
+      -3.5920697876329473
+    ],
+    "targetAcceleration": [
+      5.554375965743876
+    ],
+    "maxVelocity": [
+      5.6766473845298915
+    ],
+    "maxAcceleration": [
+      5.997895103894223
+    ],
+    "maxJerk": [
+      9.411696967428924
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.578798027493967
+    ],
+    "currentVelocity": [
+      0.8097792170128364
+    ],
+    "currentAcceleration": [
+      -4.789850189338888
+    ],
+    "targetPosition": [
+      -3.1432519385516144
+    ],
+    "targetVelocity": [
+      0.7375812594248847
+    ],
+    "targetAcceleration": [
+      2.090552905941271
+    ],
+    "maxVelocity": [
+      2.427732741114278
+    ],
+    "maxAcceleration": [
+      9.683372764932153
+    ],
+    "maxJerk": [
+      13.845026165041684
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.085333246857942
+    ],
+    "currentVelocity": [
+      6.187951588823341
+    ],
+    "currentAcceleration": [
+      -2.116377358597932
+    ],
+    "targetPosition": [
+      -9.56052780947102
+    ],
+    "targetVelocity": [
+      2.6212522013961026
+    ],
+    "targetAcceleration": [
+      1.6858210159126652
+    ],
+    "maxVelocity": [
+      6.4551309255090485
+    ],
+    "maxAcceleration": [
+      3.5862441211336242
+    ],
+    "maxJerk": [
+      14.092553780064454
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.863725656307446
+    ],
+    "currentVelocity": [
+      3.541423407005862
+    ],
+    "currentAcceleration": [
+      -5.820150317421675
+    ],
+    "targetPosition": [
+      -1.1173832772554846
+    ],
+    "targetVelocity": [
+      6.267693769834825
+    ],
+    "targetAcceleration": [
+      5.16157642946503
+    ],
+    "maxVelocity": [
+      7.839093042713545
+    ],
+    "maxAcceleration": [
+      6.785912039982459
+    ],
+    "maxJerk": [
+      10.224369967607712
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.834913467362542
+    ],
+    "currentVelocity": [
+      -1.2067144641267737
+    ],
+    "currentAcceleration": [
+      1.9314520402217394
+    ],
+    "targetPosition": [
+      6.819401511662139
+    ],
+    "targetVelocity": [
+      0.5077697932088947
+    ],
+    "targetAcceleration": [
+      0.5172958400422356
+    ],
+    "maxVelocity": [
+      3.0022483525139982
+    ],
+    "maxAcceleration": [
+      3.4133181376862445
+    ],
+    "maxJerk": [
+      12.61168583771586
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.9129127843317217
+    ],
+    "currentVelocity": [
+      -1.4331227070409538
+    ],
+    "currentAcceleration": [
+      -0.5776484871355745
+    ],
+    "targetPosition": [
+      -2.167702442022714
+    ],
+    "targetVelocity": [
+      1.3963117751119931
+    ],
+    "targetAcceleration": [
+      3.221413872375326
+    ],
+    "maxVelocity": [
+      7.039726535424899
+    ],
+    "maxAcceleration": [
+      9.09898649675835
+    ],
+    "maxJerk": [
+      6.148325627117323
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.737235526355693
+    ],
+    "currentVelocity": [
+      1.6123316313378915
+    ],
+    "currentAcceleration": [
+      1.9447781577790852
+    ],
+    "targetPosition": [
+      9.162559852701634
+    ],
+    "targetVelocity": [
+      0.7914566068262712
+    ],
+    "targetAcceleration": [
+      6.361566589093709
+    ],
+    "maxVelocity": [
+      7.633329574671029
+    ],
+    "maxAcceleration": [
+      7.4018308310022185
+    ],
+    "maxJerk": [
+      17.988255598172806
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.6442746063018046
+    ],
+    "currentVelocity": [
+      -2.12248146857147
+    ],
+    "currentAcceleration": [
+      0.7403527414075848
+    ],
+    "targetPosition": [
+      5.235063939250404
+    ],
+    "targetVelocity": [
+      2.499704908112342
+    ],
+    "targetAcceleration": [
+      1.9483246812893062
+    ],
+    "maxVelocity": [
+      3.7865925490454924
+    ],
+    "maxAcceleration": [
+      4.387531342030556
+    ],
+    "maxJerk": [
+      14.131951160762915
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.376031586563876
+    ],
+    "currentVelocity": [
+      -3.619442577105701
+    ],
+    "currentAcceleration": [
+      -1.6837222971861143
+    ],
+    "targetPosition": [
+      3.6188394628671094
+    ],
+    "targetVelocity": [
+      -2.1827017056964504
+    ],
+    "targetAcceleration": [
+      -6.463724421126914
+    ],
+    "maxVelocity": [
+      6.73869859267785
+    ],
+    "maxAcceleration": [
+      8.952483756279388
+    ],
+    "maxJerk": [
+      12.49371677937948
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.4929235821328355
+    ],
+    "currentVelocity": [
+      5.7172442754957515
+    ],
+    "currentAcceleration": [
+      5.2594916155943405
+    ],
+    "targetPosition": [
+      4.624251365180683
+    ],
+    "targetVelocity": [
+      4.965765242739566
+    ],
+    "targetAcceleration": [
+      7.9613484496288365
+    ],
+    "maxVelocity": [
+      6.896579006106554
+    ],
+    "maxAcceleration": [
+      9.749173570844924
+    ],
+    "maxJerk": [
+      16.465479507102046
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.071766694857919
+    ],
+    "currentVelocity": [
+      1.191278798522018
+    ],
+    "currentAcceleration": [
+      1.6368040695837287
+    ],
+    "targetPosition": [
+      5.417486678353658
+    ],
+    "targetVelocity": [
+      1.9786704358864284
+    ],
+    "targetAcceleration": [
+      -0.9895950814833387
+    ],
+    "maxVelocity": [
+      3.028744716468327
+    ],
+    "maxAcceleration": [
+      6.743314149452127
+    ],
+    "maxJerk": [
+      5.648450937520653
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.215498233842329
+    ],
+    "currentVelocity": [
+      1.1283704441231972
+    ],
+    "currentAcceleration": [
+      8.120197792017914
+    ],
+    "targetPosition": [
+      8.353111204935004
+    ],
+    "targetVelocity": [
+      1.7772055767457307
+    ],
+    "targetAcceleration": [
+      4.969336834136637
+    ],
+    "maxVelocity": [
+      7.478764823550421
+    ],
+    "maxAcceleration": [
+      8.71075670688892
+    ],
+    "maxJerk": [
+      14.278741888074617
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.08501510745564
+    ],
+    "currentVelocity": [
+      0.38605598978414335
+    ],
+    "currentAcceleration": [
+      2.5142872268547176
+    ],
+    "targetPosition": [
+      -3.3917472646870213
+    ],
+    "targetVelocity": [
+      0.8904316894927509
+    ],
+    "targetAcceleration": [
+      1.0713580283378326
+    ],
+    "maxVelocity": [
+      2.3816201423500543
+    ],
+    "maxAcceleration": [
+      3.5027396515909395
+    ],
+    "maxJerk": [
+      10.129946911670292
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.0421375079301836
+    ],
+    "currentVelocity": [
+      3.113786459836194
+    ],
+    "currentAcceleration": [
+      -3.2519655198860056
+    ],
+    "targetPosition": [
+      -9.896901668484633
+    ],
+    "targetVelocity": [
+      -3.0507557873994116
+    ],
+    "targetAcceleration": [
+      -4.6061606082589694
+    ],
+    "maxVelocity": [
+      6.797152134540386
+    ],
+    "maxAcceleration": [
+      5.1788089869745555
+    ],
+    "maxJerk": [
+      17.784692795298184
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.048486579990605
+    ],
+    "currentVelocity": [
+      1.7397482628426548
+    ],
+    "currentAcceleration": [
+      0.33316886684305924
+    ],
+    "targetPosition": [
+      0.6151222346794292
+    ],
+    "targetVelocity": [
+      -1.494279957698071
+    ],
+    "targetAcceleration": [
+      0.7779452024786568
+    ],
+    "maxVelocity": [
+      3.013676324084188
+    ],
+    "maxAcceleration": [
+      6.397924036508207
+    ],
+    "maxJerk": [
+      8.885775422426843
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.67457542524151
+    ],
+    "currentVelocity": [
+      2.7444848897697147
+    ],
+    "currentAcceleration": [
+      8.002040900132249
+    ],
+    "targetPosition": [
+      -7.53079875129152
+    ],
+    "targetVelocity": [
+      3.438871354406106
+    ],
+    "targetAcceleration": [
+      -1.3633123725477674
+    ],
+    "maxVelocity": [
+      6.725641778789295
+    ],
+    "maxAcceleration": [
+      8.77361023401876
+    ],
+    "maxJerk": [
+      16.607232206820573
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.7802977820439025
+    ],
+    "currentVelocity": [
+      1.3672503882358553
+    ],
+    "currentAcceleration": [
+      2.8918934619110273
+    ],
+    "targetPosition": [
+      -0.7779709111359701
+    ],
+    "targetVelocity": [
+      -1.5041921050639608
+    ],
+    "targetAcceleration": [
+      2.934738288021115
+    ],
+    "maxVelocity": [
+      6.596267493678864
+    ],
+    "maxAcceleration": [
+      3.1336251545215204
+    ],
+    "maxJerk": [
+      10.32548024184084
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.3563113009550545
+    ],
+    "currentVelocity": [
+      1.6209213438004504
+    ],
+    "currentAcceleration": [
+      -2.4262362140152858
+    ],
+    "targetPosition": [
+      7.40015908056834
+    ],
+    "targetVelocity": [
+      4.26435558589473
+    ],
+    "targetAcceleration": [
+      -4.247261545311548
+    ],
+    "maxVelocity": [
+      7.735983203093525
+    ],
+    "maxAcceleration": [
+      9.789571651088181
+    ],
+    "maxJerk": [
+      5.743085731532436
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.7264898004242877
+    ],
+    "currentVelocity": [
+      0.6582328792402583
+    ],
+    "currentAcceleration": [
+      -2.2964568243618286
+    ],
+    "targetPosition": [
+      8.893350946914968
+    ],
+    "targetVelocity": [
+      4.61939039435553
+    ],
+    "targetAcceleration": [
+      -3.263390713940281
+    ],
+    "maxVelocity": [
+      7.086463724808918
+    ],
+    "maxAcceleration": [
+      3.87734653238598
+    ],
+    "maxJerk": [
+      8.867667805170797
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.7501172055851235
+    ],
+    "currentVelocity": [
+      1.3176755879379787
+    ],
+    "currentAcceleration": [
+      -2.2473130702110318
+    ],
+    "targetPosition": [
+      5.844055311972172
+    ],
+    "targetVelocity": [
+      2.5993331499178662
+    ],
+    "targetAcceleration": [
+      4.4892599696828315
+    ],
+    "maxVelocity": [
+      7.892567028311083
+    ],
+    "maxAcceleration": [
+      6.549927457598188
+    ],
+    "maxJerk": [
+      10.935045887728414
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.259024673545749
+    ],
+    "currentVelocity": [
+      0.6371604437329381
+    ],
+    "currentAcceleration": [
+      -8.241772655187907
+    ],
+    "targetPosition": [
+      -2.0381719938164755
+    ],
+    "targetVelocity": [
+      -1.9810586264481227
+    ],
+    "targetAcceleration": [
+      -5.203795509464519
+    ],
+    "maxVelocity": [
+      7.363395812026463
+    ],
+    "maxAcceleration": [
+      9.419824239713021
+    ],
+    "maxJerk": [
+      10.204068328794833
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.877561579174147
+    ],
+    "currentVelocity": [
+      4.3441425890079
+    ],
+    "currentAcceleration": [
+      -2.9821031915467
+    ],
+    "targetPosition": [
+      9.808975163949786
+    ],
+    "targetVelocity": [
+      1.236966878734246
+    ],
+    "targetAcceleration": [
+      1.8185190112617846
+    ],
+    "maxVelocity": [
+      4.414957646434299
+    ],
+    "maxAcceleration": [
+      4.035576393901956
+    ],
+    "maxJerk": [
+      17.347839053705194
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.977225237719246
+    ],
+    "currentVelocity": [
+      4.477050092361779
+    ],
+    "currentAcceleration": [
+      0.848403607506298
+    ],
+    "targetPosition": [
+      6.314501619607114
+    ],
+    "targetVelocity": [
+      0.4058719374052009
+    ],
+    "targetAcceleration": [
+      4.520249161682824
+    ],
+    "maxVelocity": [
+      6.499217846483983
+    ],
+    "maxAcceleration": [
+      4.667150377557921
+    ],
+    "maxJerk": [
+      12.307256970397875
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.666655931535251
+    ],
+    "currentVelocity": [
+      -2.229057359025846
+    ],
+    "currentAcceleration": [
+      0.8625231225721635
+    ],
+    "targetPosition": [
+      5.333769857455497
+    ],
+    "targetVelocity": [
+      0.08876008463936635
+    ],
+    "targetAcceleration": [
+      -3.2788223667482974
+    ],
+    "maxVelocity": [
+      4.400188775545737
+    ],
+    "maxAcceleration": [
+      7.686678241539054
+    ],
+    "maxJerk": [
+      9.435044285819854
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.900995153548609
+    ],
+    "currentVelocity": [
+      0.9966260744352424
+    ],
+    "currentAcceleration": [
+      5.5185662846693715
+    ],
+    "targetPosition": [
+      -4.458575561050708
+    ],
+    "targetVelocity": [
+      0.7619839927287528
+    ],
+    "targetAcceleration": [
+      2.874209466204186
+    ],
+    "maxVelocity": [
+      3.1709904371644435
+    ],
+    "maxAcceleration": [
+      5.680197200456807
+    ],
+    "maxJerk": [
+      9.093825701380897
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.9520626645028472
+    ],
+    "currentVelocity": [
+      0.781899698700756
+    ],
+    "currentAcceleration": [
+      1.2848047441551937
+    ],
+    "targetPosition": [
+      -3.8801742368108556
+    ],
+    "targetVelocity": [
+      -2.3690705426653196
+    ],
+    "targetAcceleration": [
+      -0.28215185921725716
+    ],
+    "maxVelocity": [
+      3.3623209797694535
+    ],
+    "maxAcceleration": [
+      7.211175023201937
+    ],
+    "maxJerk": [
+      7.678526150496438
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.802618972921472
+    ],
+    "currentVelocity": [
+      -0.8143012757858927
+    ],
+    "currentAcceleration": [
+      -3.0411273462060633
+    ],
+    "targetPosition": [
+      -3.9968725404568506
+    ],
+    "targetVelocity": [
+      -3.339479683847774
+    ],
+    "targetAcceleration": [
+      0.5645149613391789
+    ],
+    "maxVelocity": [
+      4.367839414039749
+    ],
+    "maxAcceleration": [
+      5.784868724408131
+    ],
+    "maxJerk": [
+      13.814643351191194
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.006929330504764
+    ],
+    "currentVelocity": [
+      -4.055602788258898
+    ],
+    "currentAcceleration": [
+      7.690626320907246
+    ],
+    "targetPosition": [
+      -3.2427554020254394
+    ],
+    "targetVelocity": [
+      -5.817242372887431
+    ],
+    "targetAcceleration": [
+      5.370482669620769
+    ],
+    "maxVelocity": [
+      7.457096863822846
+    ],
+    "maxAcceleration": [
+      8.812396943620026
+    ],
+    "maxJerk": [
+      16.012331744007398
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.921175975152348
+    ],
+    "currentVelocity": [
+      4.781039818710029
+    ],
+    "currentAcceleration": [
+      2.8923246902194526
+    ],
+    "targetPosition": [
+      9.015066495426424
+    ],
+    "targetVelocity": [
+      -3.4476240936095643
+    ],
+    "targetAcceleration": [
+      2.5297537256773577
+    ],
+    "maxVelocity": [
+      5.88831812472797
+    ],
+    "maxAcceleration": [
+      3.2268353276315427
+    ],
+    "maxJerk": [
+      17.71691692282047
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.223546329775132
+    ],
+    "currentVelocity": [
+      -0.23285112408648923
+    ],
+    "currentAcceleration": [
+      2.4534786729561553
+    ],
+    "targetPosition": [
+      -4.382498497738667
+    ],
+    "targetVelocity": [
+      -2.2414068900283457
+    ],
+    "targetAcceleration": [
+      -8.118655164876833
+    ],
+    "maxVelocity": [
+      2.9057381044036363
+    ],
+    "maxAcceleration": [
+      9.985851811701465
+    ],
+    "maxJerk": [
+      8.670185986004922
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.753227645583969
+    ],
+    "currentVelocity": [
+      4.877421401710057
+    ],
+    "currentAcceleration": [
+      -8.228586009162303
+    ],
+    "targetPosition": [
+      1.0771141618547375
+    ],
+    "targetVelocity": [
+      -5.613608296919911
+    ],
+    "targetAcceleration": [
+      3.432968327971871
+    ],
+    "maxVelocity": [
+      7.472627777734006
+    ],
+    "maxAcceleration": [
+      9.82642261073242
+    ],
+    "maxJerk": [
+      16.122478717179604
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.5048180621047145
+    ],
+    "currentVelocity": [
+      0.36092197452795993
+    ],
+    "currentAcceleration": [
+      -2.6616753607163774
+    ],
+    "targetPosition": [
+      -7.1180331643179295
+    ],
+    "targetVelocity": [
+      -3.839756494533759
+    ],
+    "targetAcceleration": [
+      2.1856445024623996
+    ],
+    "maxVelocity": [
+      5.137128193853599
+    ],
+    "maxAcceleration": [
+      5.837439167992589
+    ],
+    "maxJerk": [
+      15.703511127658594
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.09335481705699
+    ],
+    "currentVelocity": [
+      0.9239037092491733
+    ],
+    "currentAcceleration": [
+      4.140350737989301
+    ],
+    "targetPosition": [
+      -5.3349521674554286
+    ],
+    "targetVelocity": [
+      0.1358459882772305
+    ],
+    "targetAcceleration": [
+      -1.0786836488637093
+    ],
+    "maxVelocity": [
+      3.986731101434537
+    ],
+    "maxAcceleration": [
+      4.55649850725271
+    ],
+    "maxJerk": [
+      17.140384650358925
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.195676988153231
+    ],
+    "currentVelocity": [
+      -3.362744980181951
+    ],
+    "currentAcceleration": [
+      2.8536315474429843
+    ],
+    "targetPosition": [
+      -0.36699153085470826
+    ],
+    "targetVelocity": [
+      -2.900460457562131
+    ],
+    "targetAcceleration": [
+      -2.0831479325988607
+    ],
+    "maxVelocity": [
+      6.953876694314575
+    ],
+    "maxAcceleration": [
+      3.38556743524612
+    ],
+    "maxJerk": [
+      17.95744162854546
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.652804984055201
+    ],
+    "currentVelocity": [
+      -3.714220962515693
+    ],
+    "currentAcceleration": [
+      3.195846626784464
+    ],
+    "targetPosition": [
+      3.317679005234176
+    ],
+    "targetVelocity": [
+      5.164626209323723
+    ],
+    "targetAcceleration": [
+      -2.9686969965896495
+    ],
+    "maxVelocity": [
+      7.687146678192757
+    ],
+    "maxAcceleration": [
+      5.694652136043457
+    ],
+    "maxJerk": [
+      11.954305306766333
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.68710709023176
+    ],
+    "currentVelocity": [
+      2.5046363709117117
+    ],
+    "currentAcceleration": [
+      0.25848050357546093
+    ],
+    "targetPosition": [
+      -1.3461246994357534
+    ],
+    "targetVelocity": [
+      -1.91803623053283
+    ],
+    "targetAcceleration": [
+      -6.5647211205932265
+    ],
+    "maxVelocity": [
+      7.344790520621364
+    ],
+    "maxAcceleration": [
+      8.402993953941715
+    ],
+    "maxJerk": [
+      18.19805951523582
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7425595310555657
+    ],
+    "currentVelocity": [
+      -0.2771032747798443
+    ],
+    "currentAcceleration": [
+      4.60692996152879
+    ],
+    "targetPosition": [
+      0.5136040504637691
+    ],
+    "targetVelocity": [
+      2.005878522204174
+    ],
+    "targetAcceleration": [
+      -0.7510909930864029
+    ],
+    "maxVelocity": [
+      2.041483368414066
+    ],
+    "maxAcceleration": [
+      5.67147003298434
+    ],
+    "maxJerk": [
+      13.055289564702596
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6506824619148297
+    ],
+    "currentVelocity": [
+      -1.927863630772534
+    ],
+    "currentAcceleration": [
+      3.1655919360221763
+    ],
+    "targetPosition": [
+      -6.241997403847179
+    ],
+    "targetVelocity": [
+      -2.3800640473780117
+    ],
+    "targetAcceleration": [
+      1.1053196929427047
+    ],
+    "maxVelocity": [
+      3.9583225408158254
+    ],
+    "maxAcceleration": [
+      6.4897913308591235
+    ],
+    "maxJerk": [
+      9.272205718119189
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.7579065340242686
+    ],
+    "currentVelocity": [
+      -1.221038394555391
+    ],
+    "currentAcceleration": [
+      -7.182386003905659
+    ],
+    "targetPosition": [
+      0.049881028762044366
+    ],
+    "targetVelocity": [
+      2.308840154099487
+    ],
+    "targetAcceleration": [
+      7.827151030496719
+    ],
+    "maxVelocity": [
+      6.095020108300087
+    ],
+    "maxAcceleration": [
+      8.212466000434052
+    ],
+    "maxJerk": [
+      12.50549165165761
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.031282713523684
+    ],
+    "currentVelocity": [
+      0.7518575710412168
+    ],
+    "currentAcceleration": [
+      -1.2143601787351308
+    ],
+    "targetPosition": [
+      -1.0493347010950949
+    ],
+    "targetVelocity": [
+      2.268143692321444
+    ],
+    "targetAcceleration": [
+      4.168877972925337
+    ],
+    "maxVelocity": [
+      2.5906671634544303
+    ],
+    "maxAcceleration": [
+      8.797486127044511
+    ],
+    "maxJerk": [
+      16.944078480693364
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.025076997164756
+    ],
+    "currentVelocity": [
+      1.18892605499616
+    ],
+    "currentAcceleration": [
+      -2.0149341918303305
+    ],
+    "targetPosition": [
+      -7.246384719512655
+    ],
+    "targetVelocity": [
+      -3.913584390389503
+    ],
+    "targetAcceleration": [
+      3.2671299979775332
+    ],
+    "maxVelocity": [
+      6.687442784934073
+    ],
+    "maxAcceleration": [
+      3.6071773551977957
+    ],
+    "maxJerk": [
+      9.052229396179992
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.274828757370422
+    ],
+    "currentVelocity": [
+      2.400525442026468
+    ],
+    "currentAcceleration": [
+      -3.021569671087216
+    ],
+    "targetPosition": [
+      9.87529131723992
+    ],
+    "targetVelocity": [
+      0.31324539094631554
+    ],
+    "targetAcceleration": [
+      3.263000373438139
+    ],
+    "maxVelocity": [
+      5.6084455534367
+    ],
+    "maxAcceleration": [
+      3.6764578272008492
+    ],
+    "maxJerk": [
+      12.440617297831409
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.782050599156927
+    ],
+    "currentVelocity": [
+      3.765071214059958
+    ],
+    "currentAcceleration": [
+      -1.2570333943446226
+    ],
+    "targetPosition": [
+      6.850438483000577
+    ],
+    "targetVelocity": [
+      -3.2454676857793174
+    ],
+    "targetAcceleration": [
+      -3.957551730974441
+    ],
+    "maxVelocity": [
+      5.143153664743123
+    ],
+    "maxAcceleration": [
+      7.652922346391999
+    ],
+    "maxJerk": [
+      10.276797115447994
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.918107736217168
+    ],
+    "currentVelocity": [
+      2.4529384864411075
+    ],
+    "currentAcceleration": [
+      0.5569201983663472
+    ],
+    "targetPosition": [
+      -3.5894170768670435
+    ],
+    "targetVelocity": [
+      2.0149774027877143
+    ],
+    "targetAcceleration": [
+      0.011203213739026996
+    ],
+    "maxVelocity": [
+      3.565733195526798
+    ],
+    "maxAcceleration": [
+      3.386717819939628
+    ],
+    "maxJerk": [
+      19.60736977088454
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.222589481264663
+    ],
+    "currentVelocity": [
+      -4.1752750107559855
+    ],
+    "currentAcceleration": [
+      1.7735255080288628
+    ],
+    "targetPosition": [
+      4.141286085548092
+    ],
+    "targetVelocity": [
+      -1.5269096425052346
+    ],
+    "targetAcceleration": [
+      -2.3537808191385334
+    ],
+    "maxVelocity": [
+      7.088621217893617
+    ],
+    "maxAcceleration": [
+      8.848522758216355
+    ],
+    "maxJerk": [
+      6.7076532849157555
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.060532935396594
+    ],
+    "currentVelocity": [
+      0.4458023751216169
+    ],
+    "currentAcceleration": [
+      -1.3775903019462166
+    ],
+    "targetPosition": [
+      6.808771052229723
+    ],
+    "targetVelocity": [
+      2.4079894231438264
+    ],
+    "targetAcceleration": [
+      1.859876977256456
+    ],
+    "maxVelocity": [
+      3.3551600631496843
+    ],
+    "maxAcceleration": [
+      3.4975280655109984
+    ],
+    "maxJerk": [
+      12.083050375021346
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.413533690738202
+    ],
+    "currentVelocity": [
+      1.2255255576593727
+    ],
+    "currentAcceleration": [
+      4.008560587573696
+    ],
+    "targetPosition": [
+      5.037343965128327
+    ],
+    "targetVelocity": [
+      -1.7542744702870037
+    ],
+    "targetAcceleration": [
+      1.1441933135983646
+    ],
+    "maxVelocity": [
+      2.52035048479833
+    ],
+    "maxAcceleration": [
+      5.032925206206015
+    ],
+    "maxJerk": [
+      12.962738165630416
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.5180286492787864
+    ],
+    "currentVelocity": [
+      -2.6366907677785667
+    ],
+    "currentAcceleration": [
+      -0.6218217761572418
+    ],
+    "targetPosition": [
+      8.63942023990236
+    ],
+    "targetVelocity": [
+      -2.5349130344625355
+    ],
+    "targetAcceleration": [
+      2.2776028547442504
+    ],
+    "maxVelocity": [
+      3.183769317009931
+    ],
+    "maxAcceleration": [
+      3.5154867080860273
+    ],
+    "maxJerk": [
+      17.044056540179753
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.6576654087142693
+    ],
+    "currentVelocity": [
+      -3.929410333765044
+    ],
+    "currentAcceleration": [
+      2.4238552879720627
+    ],
+    "targetPosition": [
+      1.8506000485664593
+    ],
+    "targetVelocity": [
+      2.824574221273215
+    ],
+    "targetAcceleration": [
+      -4.005767210306743
+    ],
+    "maxVelocity": [
+      7.028580980480379
+    ],
+    "maxAcceleration": [
+      4.947650474307437
+    ],
+    "maxJerk": [
+      10.497955755189347
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.5841676892767
+    ],
+    "currentVelocity": [
+      1.3777474704871802
+    ],
+    "currentAcceleration": [
+      -1.6023563597423331
+    ],
+    "targetPosition": [
+      -8.78469214824057
+    ],
+    "targetVelocity": [
+      -0.6765558854256482
+    ],
+    "targetAcceleration": [
+      -3.0220633642807386
+    ],
+    "maxVelocity": [
+      2.3070598878817314
+    ],
+    "maxAcceleration": [
+      4.097664396984813
+    ],
+    "maxJerk": [
+      9.542804843370075
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.20534992193452
+    ],
+    "currentVelocity": [
+      -1.2500459562096156
+    ],
+    "currentAcceleration": [
+      -7.073970553638256
+    ],
+    "targetPosition": [
+      -5.712035637201154
+    ],
+    "targetVelocity": [
+      0.17872135445351045
+    ],
+    "targetAcceleration": [
+      5.709931035105083
+    ],
+    "maxVelocity": [
+      5.19356365437023
+    ],
+    "maxAcceleration": [
+      7.8311934621381
+    ],
+    "maxJerk": [
+      14.696284712135279
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.549528077268965
+    ],
+    "currentVelocity": [
+      0.30226270815536704
+    ],
+    "currentAcceleration": [
+      -1.4852325362018615
+    ],
+    "targetPosition": [
+      7.662954249501777
+    ],
+    "targetVelocity": [
+      -1.3941965315202483
+    ],
+    "targetAcceleration": [
+      -0.6794062419942106
+    ],
+    "maxVelocity": [
+      6.948572238472744
+    ],
+    "maxAcceleration": [
+      6.31200182815156
+    ],
+    "maxJerk": [
+      12.813611814092749
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0218359037171822
+    ],
+    "currentVelocity": [
+      -3.116197990386109
+    ],
+    "currentAcceleration": [
+      6.091720251235069
+    ],
+    "targetPosition": [
+      1.5105681119142105
+    ],
+    "targetVelocity": [
+      -2.264064668673404
+    ],
+    "targetAcceleration": [
+      6.331395037598197
+    ],
+    "maxVelocity": [
+      3.9310314410386025
+    ],
+    "maxAcceleration": [
+      7.351899487318303
+    ],
+    "maxJerk": [
+      13.98633854736861
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.508649517640862
+    ],
+    "currentVelocity": [
+      0.6646541311796463
+    ],
+    "currentAcceleration": [
+      -2.594959805076195
+    ],
+    "targetPosition": [
+      -5.903827359103895
+    ],
+    "targetVelocity": [
+      -4.685534450143441
+    ],
+    "targetAcceleration": [
+      -3.239427247887769
+    ],
+    "maxVelocity": [
+      6.95529382033365
+    ],
+    "maxAcceleration": [
+      4.638072165536161
+    ],
+    "maxJerk": [
+      6.414668743497192
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.6696410128116632
+    ],
+    "currentVelocity": [
+      -6.835823077569033
+    ],
+    "currentAcceleration": [
+      -2.7960757776385257
+    ],
+    "targetPosition": [
+      -1.9735240861508707
+    ],
+    "targetVelocity": [
+      6.538862103841547
+    ],
+    "targetAcceleration": [
+      -2.3709079371933433
+    ],
+    "maxVelocity": [
+      7.3031584295535446
+    ],
+    "maxAcceleration": [
+      3.0509823718041926
+    ],
+    "maxJerk": [
+      15.086313849229617
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.81407785319388
+    ],
+    "currentVelocity": [
+      -1.6232121226401142
+    ],
+    "currentAcceleration": [
+      -2.8901405189450005
+    ],
+    "targetPosition": [
+      3.2094248103973335
+    ],
+    "targetVelocity": [
+      -0.2901182480339175
+    ],
+    "targetAcceleration": [
+      0.5210605815849578
+    ],
+    "maxVelocity": [
+      2.871374372204128
+    ],
+    "maxAcceleration": [
+      3.124527054235267
+    ],
+    "maxJerk": [
+      18.971581299893018
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.7086111881264561
+    ],
+    "currentVelocity": [
+      -6.324617506699468
+    ],
+    "currentAcceleration": [
+      0.9096327360177798
+    ],
+    "targetPosition": [
+      6.315695264504612
+    ],
+    "targetVelocity": [
+      1.2592366767129937
+    ],
+    "targetAcceleration": [
+      -3.383697011199907
+    ],
+    "maxVelocity": [
+      6.918257235193262
+    ],
+    "maxAcceleration": [
+      3.7732637698350664
+    ],
+    "maxJerk": [
+      18.467064085812478
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.0535899196739393
+    ],
+    "currentVelocity": [
+      0.6151458732916435
+    ],
+    "currentAcceleration": [
+      -6.298339455969524
+    ],
+    "targetPosition": [
+      -4.782700258913383
+    ],
+    "targetVelocity": [
+      0.605453776087149
+    ],
+    "targetAcceleration": [
+      -3.196799688288973
+    ],
+    "maxVelocity": [
+      4.213045126951401
+    ],
+    "maxAcceleration": [
+      7.657509193243687
+    ],
+    "maxJerk": [
+      12.532853701458102
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.680595558603578
+    ],
+    "currentVelocity": [
+      2.123102332109112
+    ],
+    "currentAcceleration": [
+      0.018779295150565645
+    ],
+    "targetPosition": [
+      -4.392101784909226
+    ],
+    "targetVelocity": [
+      -1.3142194825618914
+    ],
+    "targetAcceleration": [
+      -3.339359972674708
+    ],
+    "maxVelocity": [
+      6.79568302778845
+    ],
+    "maxAcceleration": [
+      4.872020996291528
+    ],
+    "maxJerk": [
+      7.263560732943623
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.408817705009096
+    ],
+    "currentVelocity": [
+      2.93947860490392
+    ],
+    "currentAcceleration": [
+      -4.46605273212935
+    ],
+    "targetPosition": [
+      8.301126151843889
+    ],
+    "targetVelocity": [
+      -0.619247620553383
+    ],
+    "targetAcceleration": [
+      -3.0219940203125013
+    ],
+    "maxVelocity": [
+      3.1245339499606155
+    ],
+    "maxAcceleration": [
+      5.5602806984115105
+    ],
+    "maxJerk": [
+      19.006014056554854
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7067755332894947
+    ],
+    "currentVelocity": [
+      1.4458886631629109
+    ],
+    "currentAcceleration": [
+      -3.914744586036486
+    ],
+    "targetPosition": [
+      9.90338570188603
+    ],
+    "targetVelocity": [
+      0.48670849442450814
+    ],
+    "targetAcceleration": [
+      -2.235534258992488
+    ],
+    "maxVelocity": [
+      2.1080585397888125
+    ],
+    "maxAcceleration": [
+      5.462999535765241
+    ],
+    "maxJerk": [
+      13.759391622869087
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.317058365178608
+    ],
+    "currentVelocity": [
+      3.853991785915686
+    ],
+    "currentAcceleration": [
+      -3.0944744102556867
+    ],
+    "targetPosition": [
+      -0.5743202701188999
+    ],
+    "targetVelocity": [
+      0.9618231034913522
+    ],
+    "targetAcceleration": [
+      -4.6889072919604775
+    ],
+    "maxVelocity": [
+      4.342632724573062
+    ],
+    "maxAcceleration": [
+      6.378245860861346
+    ],
+    "maxJerk": [
+      13.915621866282375
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.131620825777542
+    ],
+    "currentVelocity": [
+      4.6944923360523685
+    ],
+    "currentAcceleration": [
+      -1.6707207365058627
+    ],
+    "targetPosition": [
+      -6.325542306118042
+    ],
+    "targetVelocity": [
+      4.607726017829529
+    ],
+    "targetAcceleration": [
+      4.71753897177309
+    ],
+    "maxVelocity": [
+      6.917322559101095
+    ],
+    "maxAcceleration": [
+      7.189122375244702
+    ],
+    "maxJerk": [
+      9.961084053580525
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.5915537729217597
+    ],
+    "currentVelocity": [
+      2.386531014694089
+    ],
+    "currentAcceleration": [
+      -1.5479075412586063
+    ],
+    "targetPosition": [
+      3.426167872506035
+    ],
+    "targetVelocity": [
+      -2.3973545052196554
+    ],
+    "targetAcceleration": [
+      -2.174533628290681
+    ],
+    "maxVelocity": [
+      3.0219641353856077
+    ],
+    "maxAcceleration": [
+      3.6760933365873374
+    ],
+    "maxJerk": [
+      7.797916943110419
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.904327496321461
+    ],
+    "currentVelocity": [
+      3.5433679635028863
+    ],
+    "currentAcceleration": [
+      -3.602037129220674
+    ],
+    "targetPosition": [
+      9.613676188960515
+    ],
+    "targetVelocity": [
+      -0.6704850389635091
+    ],
+    "targetAcceleration": [
+      -1.217116144403514
+    ],
+    "maxVelocity": [
+      5.347955752195112
+    ],
+    "maxAcceleration": [
+      5.397975849420245
+    ],
+    "maxJerk": [
+      12.392337715658487
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.056814414657081
+    ],
+    "currentVelocity": [
+      1.489797037321316
+    ],
+    "currentAcceleration": [
+      -2.823861901098275
+    ],
+    "targetPosition": [
+      -3.882248469706104
+    ],
+    "targetVelocity": [
+      1.9515781857878567
+    ],
+    "targetAcceleration": [
+      -3.32737945498192
+    ],
+    "maxVelocity": [
+      3.2508783866695623
+    ],
+    "maxAcceleration": [
+      5.053363997458378
+    ],
+    "maxJerk": [
+      9.850911540672005
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.14342537856196813
+    ],
+    "currentVelocity": [
+      -3.6234989626695073
+    ],
+    "currentAcceleration": [
+      2.336598082191676
+    ],
+    "targetPosition": [
+      -0.8863720191675384
+    ],
+    "targetVelocity": [
+      -4.593707366241659
+    ],
+    "targetAcceleration": [
+      3.5948532231856056
+    ],
+    "maxVelocity": [
+      5.524716114413106
+    ],
+    "maxAcceleration": [
+      6.013492890666015
+    ],
+    "maxJerk": [
+      15.938032432896115
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.3501513457807643
+    ],
+    "currentVelocity": [
+      1.443936602337896
+    ],
+    "currentAcceleration": [
+      2.3262180825224057
+    ],
+    "targetPosition": [
+      4.629741830328808
+    ],
+    "targetVelocity": [
+      0.7053659450953229
+    ],
+    "targetAcceleration": [
+      -1.9030182030592475
+    ],
+    "maxVelocity": [
+      3.2397642715018735
+    ],
+    "maxAcceleration": [
+      3.0762693683253213
+    ],
+    "maxJerk": [
+      13.908379444304906
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.2455241858769615
+    ],
+    "currentVelocity": [
+      -0.7901125671994071
+    ],
+    "currentAcceleration": [
+      -1.5601923846930106
+    ],
+    "targetPosition": [
+      -3.8731670666043394
+    ],
+    "targetVelocity": [
+      2.922106210489
+    ],
+    "targetAcceleration": [
+      7.730859895838753
+    ],
+    "maxVelocity": [
+      3.6547594182164183
+    ],
+    "maxAcceleration": [
+      7.8490953461396895
+    ],
+    "maxJerk": [
+      15.54554546542243
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.159881133942401
+    ],
+    "currentVelocity": [
+      0.4778299062683322
+    ],
+    "currentAcceleration": [
+      -3.400920920504091
+    ],
+    "targetPosition": [
+      5.856821641780368
+    ],
+    "targetVelocity": [
+      -1.4630638803782847
+    ],
+    "targetAcceleration": [
+      1.1729827046953218
+    ],
+    "maxVelocity": [
+      2.6456297186506195
+    ],
+    "maxAcceleration": [
+      4.217714240524083
+    ],
+    "maxJerk": [
+      13.194006683574235
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7879344321085018
+    ],
+    "currentVelocity": [
+      -5.0375835862851766
+    ],
+    "currentAcceleration": [
+      1.685440670063194
+    ],
+    "targetPosition": [
+      -5.002416094394134
+    ],
+    "targetVelocity": [
+      -0.7883280717871184
+    ],
+    "targetAcceleration": [
+      3.9304583739724936
+    ],
+    "maxVelocity": [
+      6.596095965078858
+    ],
+    "maxAcceleration": [
+      6.385421119067871
+    ],
+    "maxJerk": [
+      13.356935699337686
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.8459093014758778
+    ],
+    "currentVelocity": [
+      -0.050855738783726956
+    ],
+    "currentAcceleration": [
+      0.17760824917673368
+    ],
+    "targetPosition": [
+      5.952162197841766
+    ],
+    "targetVelocity": [
+      4.509844695028569
+    ],
+    "targetAcceleration": [
+      -0.3295601130611807
+    ],
+    "maxVelocity": [
+      4.862459999173955
+    ],
+    "maxAcceleration": [
+      3.24892767437969
+    ],
+    "maxJerk": [
+      7.1194011366815415
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.392167872893495
+    ],
+    "currentVelocity": [
+      -1.3411355464282009
+    ],
+    "currentAcceleration": [
+      -1.2328688298643242
+    ],
+    "targetPosition": [
+      -3.6407240406879975
+    ],
+    "targetVelocity": [
+      -0.24990789291225646
+    ],
+    "targetAcceleration": [
+      -0.15029681918270432
+    ],
+    "maxVelocity": [
+      6.248789410061408
+    ],
+    "maxAcceleration": [
+      3.6115194332307334
+    ],
+    "maxJerk": [
+      16.359540231302823
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.521454405669683
+    ],
+    "currentVelocity": [
+      2.881899912710492
+    ],
+    "currentAcceleration": [
+      0.9259604504958912
+    ],
+    "targetPosition": [
+      -7.964368570447283
+    ],
+    "targetVelocity": [
+      -0.5458344190722082
+    ],
+    "targetAcceleration": [
+      2.266195489043991
+    ],
+    "maxVelocity": [
+      6.182019176745432
+    ],
+    "maxAcceleration": [
+      6.590102539204004
+    ],
+    "maxJerk": [
+      5.818857049896644
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.7191424692975428
+    ],
+    "currentVelocity": [
+      1.3726963321240815
+    ],
+    "currentAcceleration": [
+      5.2291922516436475
+    ],
+    "targetPosition": [
+      5.683814655697866
+    ],
+    "targetVelocity": [
+      1.5500173992014021
+    ],
+    "targetAcceleration": [
+      -1.3457429705239932
+    ],
+    "maxVelocity": [
+      3.115453125044149
+    ],
+    "maxAcceleration": [
+      5.683701674309525
+    ],
+    "maxJerk": [
+      8.243611311642201
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.7220646094838656
+    ],
+    "currentVelocity": [
+      -0.9747276724092304
+    ],
+    "currentAcceleration": [
+      -3.4120007387531053
+    ],
+    "targetPosition": [
+      9.415720564092645
+    ],
+    "targetVelocity": [
+      0.1998764297980351
+    ],
+    "targetAcceleration": [
+      -2.1806122364219553
+    ],
+    "maxVelocity": [
+      2.0364527399439663
+    ],
+    "maxAcceleration": [
+      4.258456064279086
+    ],
+    "maxJerk": [
+      8.478120980165723
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.1477159664625862
+    ],
+    "currentVelocity": [
+      0.8555142607626101
+    ],
+    "currentAcceleration": [
+      -4.0145388647887925
+    ],
+    "targetPosition": [
+      -5.004928172673413
+    ],
+    "targetVelocity": [
+      -0.12151762910664421
+    ],
+    "targetAcceleration": [
+      -0.15752708369267854
+    ],
+    "maxVelocity": [
+      2.0662070120894285
+    ],
+    "maxAcceleration": [
+      4.27160665461333
+    ],
+    "maxJerk": [
+      9.395969801875678
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.28948411708703503
+    ],
+    "currentVelocity": [
+      -0.20965112740500969
+    ],
+    "currentAcceleration": [
+      -0.6787013938861186
+    ],
+    "targetPosition": [
+      -9.717231632688183
+    ],
+    "targetVelocity": [
+      0.3597685630683136
+    ],
+    "targetAcceleration": [
+      -0.1793216629000316
+    ],
+    "maxVelocity": [
+      4.18559114948035
+    ],
+    "maxAcceleration": [
+      4.693564757014466
+    ],
+    "maxJerk": [
+      5.049542120185034
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.524592371737964
+    ],
+    "currentVelocity": [
+      -0.7836172331597906
+    ],
+    "currentAcceleration": [
+      -3.0376595368744486
+    ],
+    "targetPosition": [
+      6.840529066135193
+    ],
+    "targetVelocity": [
+      -1.7134518560854852
+    ],
+    "targetAcceleration": [
+      3.004155072314367
+    ],
+    "maxVelocity": [
+      6.540105764509907
+    ],
+    "maxAcceleration": [
+      7.54586743850272
+    ],
+    "maxJerk": [
+      18.78793147920097
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.87017824042503
+    ],
+    "currentVelocity": [
+      -2.8967637440761003
+    ],
+    "currentAcceleration": [
+      1.8175024220439218
+    ],
+    "targetPosition": [
+      0.97379052450313
+    ],
+    "targetVelocity": [
+      1.501566594332819
+    ],
+    "targetAcceleration": [
+      -3.0110443925502377
+    ],
+    "maxVelocity": [
+      6.159536316566256
+    ],
+    "maxAcceleration": [
+      4.0410794444373845
+    ],
+    "maxJerk": [
+      17.851175069591655
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.625698185464454
+    ],
+    "currentVelocity": [
+      -2.0920672362767836
+    ],
+    "currentAcceleration": [
+      -0.9802838056009429
+    ],
+    "targetPosition": [
+      -9.043695255580273
+    ],
+    "targetVelocity": [
+      0.3465158135068842
+    ],
+    "targetAcceleration": [
+      -3.910910836407986
+    ],
+    "maxVelocity": [
+      2.201288296394451
+    ],
+    "maxAcceleration": [
+      3.9819066244240977
+    ],
+    "maxJerk": [
+      5.267509037308684
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.592823500766711
+    ],
+    "currentVelocity": [
+      -4.099147351209801
+    ],
+    "currentAcceleration": [
+      -1.0485743716622604
+    ],
+    "targetPosition": [
+      8.925786536147633
+    ],
+    "targetVelocity": [
+      1.2048698589592757
+    ],
+    "targetAcceleration": [
+      -1.8970541422863612
+    ],
+    "maxVelocity": [
+      6.723203503624577
+    ],
+    "maxAcceleration": [
+      8.80022090961439
+    ],
+    "maxJerk": [
+      7.314003515769291
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.927000760986216
+    ],
+    "currentVelocity": [
+      -0.5126912393749272
+    ],
+    "currentAcceleration": [
+      -2.8864357735652133
+    ],
+    "targetPosition": [
+      -2.170681272585533
+    ],
+    "targetVelocity": [
+      2.2405821910949815
+    ],
+    "targetAcceleration": [
+      1.400045494838487
+    ],
+    "maxVelocity": [
+      7.272980477988892
+    ],
+    "maxAcceleration": [
+      4.20891134647316
+    ],
+    "maxJerk": [
+      17.28230877231886
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.15040241901322204
+    ],
+    "currentVelocity": [
+      -1.8843739989351767
+    ],
+    "currentAcceleration": [
+      -3.944179408062868
+    ],
+    "targetPosition": [
+      7.5166723272655105
+    ],
+    "targetVelocity": [
+      -1.6119214963365043
+    ],
+    "targetAcceleration": [
+      6.547460013398479
+    ],
+    "maxVelocity": [
+      3.0732001405350244
+    ],
+    "maxAcceleration": [
+      6.746321268498215
+    ],
+    "maxJerk": [
+      17.9510182884145
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.8024811705678392
+    ],
+    "currentVelocity": [
+      0.3700302217734919
+    ],
+    "currentAcceleration": [
+      0.07564653502324248
+    ],
+    "targetPosition": [
+      -6.717322515711901
+    ],
+    "targetVelocity": [
+      -0.4788371602233692
+    ],
+    "targetAcceleration": [
+      -2.8391848897697987
+    ],
+    "maxVelocity": [
+      6.281922566917556
+    ],
+    "maxAcceleration": [
+      4.125184024965528
+    ],
+    "maxJerk": [
+      19.925238653787574
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.1402632454229344
+    ],
+    "currentVelocity": [
+      -6.768669023953456
+    ],
+    "currentAcceleration": [
+      2.577544437709121
+    ],
+    "targetPosition": [
+      -4.3192238841712545
+    ],
+    "targetVelocity": [
+      -0.503953738592231
+    ],
+    "targetAcceleration": [
+      1.465953012996084
+    ],
+    "maxVelocity": [
+      7.297131335739385
+    ],
+    "maxAcceleration": [
+      3.983234037183143
+    ],
+    "maxJerk": [
+      17.705885676697015
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.8555372403315662
+    ],
+    "currentVelocity": [
+      -3.0982947362279494
+    ],
+    "currentAcceleration": [
+      0.9224367050160485
+    ],
+    "targetPosition": [
+      8.348516899451894
+    ],
+    "targetVelocity": [
+      2.654620888797057
+    ],
+    "targetAcceleration": [
+      2.1079590756514532
+    ],
+    "maxVelocity": [
+      3.6351640186505927
+    ],
+    "maxAcceleration": [
+      3.9295794285069476
+    ],
+    "maxJerk": [
+      15.435910836590505
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.161192998118263
+    ],
+    "currentVelocity": [
+      -0.2286177182599225
+    ],
+    "currentAcceleration": [
+      -2.775158189266986
+    ],
+    "targetPosition": [
+      -0.9267235441857213
+    ],
+    "targetVelocity": [
+      1.795939823006604
+    ],
+    "targetAcceleration": [
+      -0.9160404069841341
+    ],
+    "maxVelocity": [
+      4.306728055258967
+    ],
+    "maxAcceleration": [
+      3.8250894183964936
+    ],
+    "maxJerk": [
+      5.233988694841159
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.0673486793959768
+    ],
+    "currentVelocity": [
+      3.489792157568359
+    ],
+    "currentAcceleration": [
+      -1.528437059146361
+    ],
+    "targetPosition": [
+      3.7610689819484797
+    ],
+    "targetVelocity": [
+      6.62257313361187
+    ],
+    "targetAcceleration": [
+      -0.19274613917306915
+    ],
+    "maxVelocity": [
+      7.791923589071016
+    ],
+    "maxAcceleration": [
+      8.325149252792336
+    ],
+    "maxJerk": [
+      14.14911557872816
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.103108790642626
+    ],
+    "currentVelocity": [
+      -3.276861738506243
+    ],
+    "currentAcceleration": [
+      5.288622589075361
+    ],
+    "targetPosition": [
+      -8.152144649874156
+    ],
+    "targetVelocity": [
+      3.9468065905806693
+    ],
+    "targetAcceleration": [
+      -0.3976439209525129
+    ],
+    "maxVelocity": [
+      6.858306968732586
+    ],
+    "maxAcceleration": [
+      9.318324081146578
+    ],
+    "maxJerk": [
+      11.594457536096662
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.6159485781770329
+    ],
+    "currentVelocity": [
+      -1.5685832817885523
+    ],
+    "currentAcceleration": [
+      -2.3253425752640657
+    ],
+    "targetPosition": [
+      5.998076916035524
+    ],
+    "targetVelocity": [
+      2.559058649702581
+    ],
+    "targetAcceleration": [
+      -1.7678550981266743
+    ],
+    "maxVelocity": [
+      3.2974171934323078
+    ],
+    "maxAcceleration": [
+      4.277178494260148
+    ],
+    "maxJerk": [
+      11.047669126303537
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.73890085049289
+    ],
+    "currentVelocity": [
+      -2.3350933838321604
+    ],
+    "currentAcceleration": [
+      -5.218233782864602
+    ],
+    "targetPosition": [
+      -5.577636774577539
+    ],
+    "targetVelocity": [
+      0.4437348820031648
+    ],
+    "targetAcceleration": [
+      -2.746276877429712
+    ],
+    "maxVelocity": [
+      4.230967268528627
+    ],
+    "maxAcceleration": [
+      8.115697691564145
+    ],
+    "maxJerk": [
+      11.879619249939484
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.121879914605059
+    ],
+    "currentVelocity": [
+      -4.004122480951047
+    ],
+    "currentAcceleration": [
+      5.456026522806713
+    ],
+    "targetPosition": [
+      -4.943723995104532
+    ],
+    "targetVelocity": [
+      -5.894693870450614
+    ],
+    "targetAcceleration": [
+      -1.0582065315701161
+    ],
+    "maxVelocity": [
+      6.590588200262892
+    ],
+    "maxAcceleration": [
+      5.653654954393431
+    ],
+    "maxJerk": [
+      10.720013045083872
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.330624311308928
+    ],
+    "currentVelocity": [
+      -0.25383129082121547
+    ],
+    "currentAcceleration": [
+      -4.3853848660739825
+    ],
+    "targetPosition": [
+      -2.5192345227127415
+    ],
+    "targetVelocity": [
+      -3.6606263275489885
+    ],
+    "targetAcceleration": [
+      2.393541437374898
+    ],
+    "maxVelocity": [
+      4.100056072251624
+    ],
+    "maxAcceleration": [
+      6.959246017646068
+    ],
+    "maxJerk": [
+      7.660503824401484
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.688000013788585
+    ],
+    "currentVelocity": [
+      -3.14259691674478
+    ],
+    "currentAcceleration": [
+      -2.9532393170958486
+    ],
+    "targetPosition": [
+      3.698530996222276
+    ],
+    "targetVelocity": [
+      1.9870783128820229
+    ],
+    "targetAcceleration": [
+      -1.9754619949070356
+    ],
+    "maxVelocity": [
+      4.090491578622533
+    ],
+    "maxAcceleration": [
+      4.47584848905108
+    ],
+    "maxJerk": [
+      13.127969599115703
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.0817019441009261
+    ],
+    "currentVelocity": [
+      0.13118854184420403
+    ],
+    "currentAcceleration": [
+      0.9387948349636073
+    ],
+    "targetPosition": [
+      -1.9242680676409307
+    ],
+    "targetVelocity": [
+      4.806705485126123
+    ],
+    "targetAcceleration": [
+      7.4190707106350935
+    ],
+    "maxVelocity": [
+      5.771961736128381
+    ],
+    "maxAcceleration": [
+      9.158352994087473
+    ],
+    "maxJerk": [
+      15.32335973543808
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.089772865661
+    ],
+    "currentVelocity": [
+      -3.560492758059991
+    ],
+    "currentAcceleration": [
+      1.2321072084461786
+    ],
+    "targetPosition": [
+      -9.538205578315246
+    ],
+    "targetVelocity": [
+      -3.6978335097230888
+    ],
+    "targetAcceleration": [
+      -0.6981727495888217
+    ],
+    "maxVelocity": [
+      6.968519711746256
+    ],
+    "maxAcceleration": [
+      6.684231950061678
+    ],
+    "maxJerk": [
+      11.56540933274507
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.452597020181745
+    ],
+    "currentVelocity": [
+      -5.856504398262631
+    ],
+    "currentAcceleration": [
+      -0.4360433674191877
+    ],
+    "targetPosition": [
+      5.128236948754299
+    ],
+    "targetVelocity": [
+      -0.3478464462353017
+    ],
+    "targetAcceleration": [
+      -0.002494160197723083
+    ],
+    "maxVelocity": [
+      6.481095300650178
+    ],
+    "maxAcceleration": [
+      4.212334494342655
+    ],
+    "maxJerk": [
+      15.55715703262873
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.98654613657974
+    ],
+    "currentVelocity": [
+      6.34870569581397
+    ],
+    "currentAcceleration": [
+      -0.005255438385773914
+    ],
+    "targetPosition": [
+      4.358271329335819
+    ],
+    "targetVelocity": [
+      -5.375706497456665
+    ],
+    "targetAcceleration": [
+      2.4803072321171946
+    ],
+    "maxVelocity": [
+      6.6637713546185084
+    ],
+    "maxAcceleration": [
+      4.08050982002943
+    ],
+    "maxJerk": [
+      6.134354006694142
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.538141196640094
+    ],
+    "currentVelocity": [
+      2.0638455516854988
+    ],
+    "currentAcceleration": [
+      -2.8179055865965017
+    ],
+    "targetPosition": [
+      -4.194185195217608
+    ],
+    "targetVelocity": [
+      0.5584780829926919
+    ],
+    "targetAcceleration": [
+      -1.210493507172668
+    ],
+    "maxVelocity": [
+      4.193017591611173
+    ],
+    "maxAcceleration": [
+      5.847540482920088
+    ],
+    "maxJerk": [
+      5.848347899106797
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.5796406957093545
+    ],
+    "currentVelocity": [
+      2.16726895364482
+    ],
+    "currentAcceleration": [
+      -2.5982583880745374
+    ],
+    "targetPosition": [
+      4.540489818362952
+    ],
+    "targetVelocity": [
+      -0.8723195574250044
+    ],
+    "targetAcceleration": [
+      6.161365667247194
+    ],
+    "maxVelocity": [
+      3.786600259260556
+    ],
+    "maxAcceleration": [
+      9.008407778054007
+    ],
+    "maxJerk": [
+      18.913628313119425
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.424756804731999
+    ],
+    "currentVelocity": [
+      0.03952087482412425
+    ],
+    "currentAcceleration": [
+      -2.5495065952175096
+    ],
+    "targetPosition": [
+      6.933692391795827
+    ],
+    "targetVelocity": [
+      -0.9000886326684818
+    ],
+    "targetAcceleration": [
+      -1.2468046076833335
+    ],
+    "maxVelocity": [
+      3.1326559149682307
+    ],
+    "maxAcceleration": [
+      4.771046615446632
+    ],
+    "maxJerk": [
+      10.621948299319001
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7263021572298847
+    ],
+    "currentVelocity": [
+      4.248194060119963
+    ],
+    "currentAcceleration": [
+      -1.187052149633673
+    ],
+    "targetPosition": [
+      0.19613231876474302
+    ],
+    "targetVelocity": [
+      5.096604267063708
+    ],
+    "targetAcceleration": [
+      -4.874495488554629
+    ],
+    "maxVelocity": [
+      7.644377370308869
+    ],
+    "maxAcceleration": [
+      6.125576162890064
+    ],
+    "maxJerk": [
+      15.481478397234989
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.672636731928755
+    ],
+    "currentVelocity": [
+      1.7732192733305068
+    ],
+    "currentAcceleration": [
+      -6.861471705831908
+    ],
+    "targetPosition": [
+      5.210479946887347
+    ],
+    "targetVelocity": [
+      -0.671982162823666
+    ],
+    "targetAcceleration": [
+      -3.821190755160781
+    ],
+    "maxVelocity": [
+      2.921839883325859
+    ],
+    "maxAcceleration": [
+      7.132876784844589
+    ],
+    "maxJerk": [
+      19.942508125437655
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.655617776358728
+    ],
+    "currentVelocity": [
+      -2.083997636333928
+    ],
+    "currentAcceleration": [
+      -0.8057209624082939
+    ],
+    "targetPosition": [
+      9.593458233998454
+    ],
+    "targetVelocity": [
+      -2.8239732182684913
+    ],
+    "targetAcceleration": [
+      -0.6280121516155446
+    ],
+    "maxVelocity": [
+      5.375211991798743
+    ],
+    "maxAcceleration": [
+      4.431448275547485
+    ],
+    "maxJerk": [
+      6.710457583364136
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6101574933576401
+    ],
+    "currentVelocity": [
+      -0.9452221280718902
+    ],
+    "currentAcceleration": [
+      -1.4681479008901066
+    ],
+    "targetPosition": [
+      9.27743391535444
+    ],
+    "targetVelocity": [
+      5.076825662383273
+    ],
+    "targetAcceleration": [
+      3.2775442329185545
+    ],
+    "maxVelocity": [
+      7.013791230370117
+    ],
+    "maxAcceleration": [
+      6.001136337937842
+    ],
+    "maxJerk": [
+      8.842529799897374
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.7055403045221276
+    ],
+    "currentVelocity": [
+      1.645662234245945
+    ],
+    "currentAcceleration": [
+      -2.279981650633094
+    ],
+    "targetPosition": [
+      0.27662190483153104
+    ],
+    "targetVelocity": [
+      -0.09886399911133958
+    ],
+    "targetAcceleration": [
+      3.032331966250164
+    ],
+    "maxVelocity": [
+      2.9806017982293733
+    ],
+    "maxAcceleration": [
+      3.228046968398344
+    ],
+    "maxJerk": [
+      17.948151939067763
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.364495503483942
+    ],
+    "currentVelocity": [
+      -0.4188343093946756
+    ],
+    "currentAcceleration": [
+      2.263863503553294
+    ],
+    "targetPosition": [
+      -8.724732617914508
+    ],
+    "targetVelocity": [
+      2.8607295158096457
+    ],
+    "targetAcceleration": [
+      7.3168255402415845
+    ],
+    "maxVelocity": [
+      4.608104291686022
+    ],
+    "maxAcceleration": [
+      7.727354463846458
+    ],
+    "maxJerk": [
+      16.847176057805164
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.0679069507877195
+    ],
+    "currentVelocity": [
+      -1.344591291009778
+    ],
+    "currentAcceleration": [
+      2.32216091260187
+    ],
+    "targetPosition": [
+      4.891678194605582
+    ],
+    "targetVelocity": [
+      3.631911909974341
+    ],
+    "targetAcceleration": [
+      -2.738237188954575
+    ],
+    "maxVelocity": [
+      3.9761962071421166
+    ],
+    "maxAcceleration": [
+      5.317941595732783
+    ],
+    "maxJerk": [
+      16.27535098162891
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.653992220904003
+    ],
+    "currentVelocity": [
+      5.9617276826120555
+    ],
+    "currentAcceleration": [
+      1.7385668387864506
+    ],
+    "targetPosition": [
+      5.417713947459962
+    ],
+    "targetVelocity": [
+      3.4495761144127624
+    ],
+    "targetAcceleration": [
+      -0.09507725246300591
+    ],
+    "maxVelocity": [
+      6.16083785134987
+    ],
+    "maxAcceleration": [
+      3.853393517786544
+    ],
+    "maxJerk": [
+      16.21638633927833
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.851918445105678
+    ],
+    "currentVelocity": [
+      3.864319865433708
+    ],
+    "currentAcceleration": [
+      3.4212396318695237
+    ],
+    "targetPosition": [
+      -9.489674627582097
+    ],
+    "targetVelocity": [
+      -3.781584406883991
+    ],
+    "targetAcceleration": [
+      0.009271647737081778
+    ],
+    "maxVelocity": [
+      7.86274196772164
+    ],
+    "maxAcceleration": [
+      6.096680330733337
+    ],
+    "maxJerk": [
+      17.09325315846535
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.043299998852813
+    ],
+    "currentVelocity": [
+      -2.861584280177613
+    ],
+    "currentAcceleration": [
+      1.1396690030642276
+    ],
+    "targetPosition": [
+      -7.112897827351148
+    ],
+    "targetVelocity": [
+      2.008162323309466
+    ],
+    "targetAcceleration": [
+      1.790908533241403
+    ],
+    "maxVelocity": [
+      4.605664389506119
+    ],
+    "maxAcceleration": [
+      9.96240309913362
+    ],
+    "maxJerk": [
+      15.110286226663359
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.3170302058901022
+    ],
+    "currentVelocity": [
+      -0.5765491259011162
+    ],
+    "currentAcceleration": [
+      2.327033748344796
+    ],
+    "targetPosition": [
+      -6.326298129535539
+    ],
+    "targetVelocity": [
+      -7.515689820072432
+    ],
+    "targetAcceleration": [
+      3.5995892422220557
+    ],
+    "maxVelocity": [
+      7.9353091185446285
+    ],
+    "maxAcceleration": [
+      4.6587776185728025
+    ],
+    "maxJerk": [
+      17.18237989524826
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.938710467939913
+    ],
+    "currentVelocity": [
+      0.3125742213943177
+    ],
+    "currentAcceleration": [
+      -9.313439224493028
+    ],
+    "targetPosition": [
+      -3.5135823610052324
+    ],
+    "targetVelocity": [
+      -4.609744379829655
+    ],
+    "targetAcceleration": [
+      -1.414302228950599
+    ],
+    "maxVelocity": [
+      4.803746445093571
+    ],
+    "maxAcceleration": [
+      9.31745946039794
+    ],
+    "maxJerk": [
+      15.086407058672089
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.8124834333571229
+    ],
+    "currentVelocity": [
+      -1.808882359237859
+    ],
+    "currentAcceleration": [
+      4.068380399973004
+    ],
+    "targetPosition": [
+      1.1898246412826694
+    ],
+    "targetVelocity": [
+      1.5499939599704642
+    ],
+    "targetAcceleration": [
+      5.860593123201345
+    ],
+    "maxVelocity": [
+      2.002861352003359
+    ],
+    "maxAcceleration": [
+      7.537813836567341
+    ],
+    "maxJerk": [
+      14.46276789748143
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.05814523525193849
+    ],
+    "currentVelocity": [
+      -0.6591407091811421
+    ],
+    "currentAcceleration": [
+      -3.127676357028382
+    ],
+    "targetPosition": [
+      9.051322859820466
+    ],
+    "targetVelocity": [
+      2.852512590639538
+    ],
+    "targetAcceleration": [
+      1.4710475658717463
+    ],
+    "maxVelocity": [
+      7.010583311019447
+    ],
+    "maxAcceleration": [
+      3.9080035387630367
+    ],
+    "maxJerk": [
+      11.559725981672784
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.9937108897888223
+    ],
+    "currentVelocity": [
+      -5.649952237064803
+    ],
+    "currentAcceleration": [
+      4.372290050833389
+    ],
+    "targetPosition": [
+      5.666738262225836
+    ],
+    "targetVelocity": [
+      4.589454457375716
+    ],
+    "targetAcceleration": [
+      4.449967941469668
+    ],
+    "maxVelocity": [
+      5.922492035032882
+    ],
+    "maxAcceleration": [
+      5.6833257260755925
+    ],
+    "maxJerk": [
+      12.93167051990691
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.445379835879615
+    ],
+    "currentVelocity": [
+      -5.289166184506987
+    ],
+    "currentAcceleration": [
+      -2.178885610918206
+    ],
+    "targetPosition": [
+      -9.96173534082654
+    ],
+    "targetVelocity": [
+      -3.5882142072728067
+    ],
+    "targetAcceleration": [
+      -1.6453258599919418
+    ],
+    "maxVelocity": [
+      6.536242149620643
+    ],
+    "maxAcceleration": [
+      3.2159898266976157
+    ],
+    "maxJerk": [
+      13.963192320871642
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.402225542124187
+    ],
+    "currentVelocity": [
+      -4.590335013683294
+    ],
+    "currentAcceleration": [
+      0.5261179903479585
+    ],
+    "targetPosition": [
+      3.3400463157464895
+    ],
+    "targetVelocity": [
+      3.2690642786704007
+    ],
+    "targetAcceleration": [
+      -1.5581244663240237
+    ],
+    "maxVelocity": [
+      7.938965895574125
+    ],
+    "maxAcceleration": [
+      3.819165390932999
+    ],
+    "maxJerk": [
+      14.778884079000008
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.049554726094918
+    ],
+    "currentVelocity": [
+      -1.3462836442425345
+    ],
+    "currentAcceleration": [
+      -3.136728746108729
+    ],
+    "targetPosition": [
+      -3.7470240427239476
+    ],
+    "targetVelocity": [
+      0.2546318865662327
+    ],
+    "targetAcceleration": [
+      5.43940475416851
+    ],
+    "maxVelocity": [
+      4.345630585458035
+    ],
+    "maxAcceleration": [
+      7.84964633499818
+    ],
+    "maxJerk": [
+      8.001166296915347
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.103158531975332
+    ],
+    "currentVelocity": [
+      -4.519040755510829
+    ],
+    "currentAcceleration": [
+      0.29487782721552236
+    ],
+    "targetPosition": [
+      -0.2557379548225551
+    ],
+    "targetVelocity": [
+      1.977949949592535
+    ],
+    "targetAcceleration": [
+      -4.255195739381503
+    ],
+    "maxVelocity": [
+      5.522642661341995
+    ],
+    "maxAcceleration": [
+      7.78619659093445
+    ],
+    "maxJerk": [
+      7.205259468562671
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.432615596289647
+    ],
+    "currentVelocity": [
+      -1.7148245732797744
+    ],
+    "currentAcceleration": [
+      -3.844942114451772
+    ],
+    "targetPosition": [
+      0.7954488762357474
+    ],
+    "targetVelocity": [
+      -1.8784572763800955
+    ],
+    "targetAcceleration": [
+      -1.3660893695605392
+    ],
+    "maxVelocity": [
+      3.662811825887754
+    ],
+    "maxAcceleration": [
+      4.366197009664759
+    ],
+    "maxJerk": [
+      10.948079902563562
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.765702951693958
+    ],
+    "currentVelocity": [
+      2.5787443633548186
+    ],
+    "currentAcceleration": [
+      5.295172227711559
+    ],
+    "targetPosition": [
+      -0.47720389535995444
+    ],
+    "targetVelocity": [
+      6.01484860580238
+    ],
+    "targetAcceleration": [
+      6.015901718548697
+    ],
+    "maxVelocity": [
+      7.2407595985323265
+    ],
+    "maxAcceleration": [
+      9.680365384445533
+    ],
+    "maxJerk": [
+      7.702142693143065
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.0634680506963292
+    ],
+    "currentVelocity": [
+      -4.470656594415888
+    ],
+    "currentAcceleration": [
+      0.15955260546693406
+    ],
+    "targetPosition": [
+      8.78152215969785
+    ],
+    "targetVelocity": [
+      -1.1263072079801706
+    ],
+    "targetAcceleration": [
+      -5.307854309783158
+    ],
+    "maxVelocity": [
+      7.14159471698346
+    ],
+    "maxAcceleration": [
+      6.799602681466968
+    ],
+    "maxJerk": [
+      18.15471240803096
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.120101035852219
+    ],
+    "currentVelocity": [
+      2.027492781944343
+    ],
+    "currentAcceleration": [
+      -1.9265780801389512
+    ],
+    "targetPosition": [
+      -9.268717722798215
+    ],
+    "targetVelocity": [
+      -2.5409545337830695
+    ],
+    "targetAcceleration": [
+      -1.5728227300585127
+    ],
+    "maxVelocity": [
+      2.785275281569453
+    ],
+    "maxAcceleration": [
+      4.791041213693216
+    ],
+    "maxJerk": [
+      6.325146749729001
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.274314139849082
+    ],
+    "currentVelocity": [
+      -2.2174219703490983
+    ],
+    "currentAcceleration": [
+      0.6181015469259754
+    ],
+    "targetPosition": [
+      9.928910671174602
+    ],
+    "targetVelocity": [
+      3.5933295091729107
+    ],
+    "targetAcceleration": [
+      -0.2787736056544481
+    ],
+    "maxVelocity": [
+      4.2310492776905
+    ],
+    "maxAcceleration": [
+      3.605250750225372
+    ],
+    "maxJerk": [
+      8.1062819589449
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.870587205553761
+    ],
+    "currentVelocity": [
+      0.23260662461815507
+    ],
+    "currentAcceleration": [
+      -1.3416471551251234
+    ],
+    "targetPosition": [
+      0.1147712304898807
+    ],
+    "targetVelocity": [
+      3.4435141559005977
+    ],
+    "targetAcceleration": [
+      -4.756500602280601
+    ],
+    "maxVelocity": [
+      4.475278518416021
+    ],
+    "maxAcceleration": [
+      5.620721324996599
+    ],
+    "maxJerk": [
+      14.453653222746928
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.695584309242436
+    ],
+    "currentVelocity": [
+      -1.9328806360550206
+    ],
+    "currentAcceleration": [
+      2.307495666840101
+    ],
+    "targetPosition": [
+      -3.4707353344393477
+    ],
+    "targetVelocity": [
+      -3.9815223152584394
+    ],
+    "targetAcceleration": [
+      -3.3318574664109537
+    ],
+    "maxVelocity": [
+      4.436920969218756
+    ],
+    "maxAcceleration": [
+      3.687137742987289
+    ],
+    "maxJerk": [
+      6.4702440058300255
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.4360859869133655
+    ],
+    "currentVelocity": [
+      4.444240055897545
+    ],
+    "currentAcceleration": [
+      1.3983845561741353
+    ],
+    "targetPosition": [
+      -8.192986608078686
+    ],
+    "targetVelocity": [
+      -0.0914573898670783
+    ],
+    "targetAcceleration": [
+      -1.3109832174872702
+    ],
+    "maxVelocity": [
+      6.44074793775577
+    ],
+    "maxAcceleration": [
+      3.0705175823540554
+    ],
+    "maxJerk": [
+      9.072809839295305
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.3151148125945813
+    ],
+    "currentVelocity": [
+      -1.4303351116458025
+    ],
+    "currentAcceleration": [
+      -4.875088399877218
+    ],
+    "targetPosition": [
+      8.776480668890343
+    ],
+    "targetVelocity": [
+      2.140504825261136
+    ],
+    "targetAcceleration": [
+      -4.836053622217638
+    ],
+    "maxVelocity": [
+      3.106063582423765
+    ],
+    "maxAcceleration": [
+      5.902483473408733
+    ],
+    "maxJerk": [
+      17.82104355182762
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.50113888964278
+    ],
+    "currentVelocity": [
+      4.560057176784051
+    ],
+    "currentAcceleration": [
+      3.8897726806096564
+    ],
+    "targetPosition": [
+      6.368040299688651
+    ],
+    "targetVelocity": [
+      -4.533712573010834
+    ],
+    "targetAcceleration": [
+      -0.22322387470568827
+    ],
+    "maxVelocity": [
+      7.954559851481397
+    ],
+    "maxAcceleration": [
+      9.751507589415628
+    ],
+    "maxJerk": [
+      18.665395585920052
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.976372095928678
+    ],
+    "currentVelocity": [
+      -5.224576488542392
+    ],
+    "currentAcceleration": [
+      4.545036996494341
+    ],
+    "targetPosition": [
+      7.59604818119098
+    ],
+    "targetVelocity": [
+      5.163405823223929
+    ],
+    "targetAcceleration": [
+      -3.8566329650396995
+    ],
+    "maxVelocity": [
+      7.6569806689009745
+    ],
+    "maxAcceleration": [
+      5.951396985138754
+    ],
+    "maxJerk": [
+      18.18747354392684
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.031803725184087
+    ],
+    "currentVelocity": [
+      2.683094346361462
+    ],
+    "currentAcceleration": [
+      -3.126585765331506
+    ],
+    "targetPosition": [
+      1.732857875300768
+    ],
+    "targetVelocity": [
+      -3.9909654783519612
+    ],
+    "targetAcceleration": [
+      -5.879290616064067
+    ],
+    "maxVelocity": [
+      4.10124561592361
+    ],
+    "maxAcceleration": [
+      7.243177547407558
+    ],
+    "maxJerk": [
+      18.60615862659882
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0572785414300192
+    ],
+    "currentVelocity": [
+      -0.013722464361489273
+    ],
+    "currentAcceleration": [
+      2.6105898039881534
+    ],
+    "targetPosition": [
+      0.21814239027651006
+    ],
+    "targetVelocity": [
+      -0.30608586632057655
+    ],
+    "targetAcceleration": [
+      -2.5986868386310666
+    ],
+    "maxVelocity": [
+      3.562716438019081
+    ],
+    "maxAcceleration": [
+      5.199456320385025
+    ],
+    "maxJerk": [
+      6.554683519171375
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.576399190848332
+    ],
+    "currentVelocity": [
+      -0.23397721770050595
+    ],
+    "currentAcceleration": [
+      4.204074560022656
+    ],
+    "targetPosition": [
+      4.896826266423078
+    ],
+    "targetVelocity": [
+      6.7497446127250305
+    ],
+    "targetAcceleration": [
+      3.010907946577321
+    ],
+    "maxVelocity": [
+      7.6461984538603085
+    ],
+    "maxAcceleration": [
+      8.381692926703924
+    ],
+    "maxJerk": [
+      14.160179056922454
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.1165030846080644
+    ],
+    "currentVelocity": [
+      1.4904302207307683
+    ],
+    "currentAcceleration": [
+      -0.3063629889395969
+    ],
+    "targetPosition": [
+      7.991821750034973
+    ],
+    "targetVelocity": [
+      -2.752108369280863
+    ],
+    "targetAcceleration": [
+      0.4208054203176639
+    ],
+    "maxVelocity": [
+      3.3365913115685664
+    ],
+    "maxAcceleration": [
+      5.021677292276426
+    ],
+    "maxJerk": [
+      13.575856745041214
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.653102946565548
+    ],
+    "currentVelocity": [
+      3.005195366538576
+    ],
+    "currentAcceleration": [
+      -3.1893361337448054
+    ],
+    "targetPosition": [
+      -3.583577550424093
+    ],
+    "targetVelocity": [
+      0.7785628922193224
+    ],
+    "targetAcceleration": [
+      2.2356516311323733
+    ],
+    "maxVelocity": [
+      6.0202000741079775
+    ],
+    "maxAcceleration": [
+      3.919222250704372
+    ],
+    "maxJerk": [
+      6.341515979462034
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.302129425588923
+    ],
+    "currentVelocity": [
+      0.388652948650539
+    ],
+    "currentAcceleration": [
+      -3.2005667519009426
+    ],
+    "targetPosition": [
+      -4.285422469596368
+    ],
+    "targetVelocity": [
+      1.2107209281430755
+    ],
+    "targetAcceleration": [
+      0.7906698981763656
+    ],
+    "maxVelocity": [
+      5.068993439865818
+    ],
+    "maxAcceleration": [
+      5.097444518159552
+    ],
+    "maxJerk": [
+      6.387334689308027
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.290498752488347
+    ],
+    "currentVelocity": [
+      -1.5261309124123512
+    ],
+    "currentAcceleration": [
+      2.2033826273607406
+    ],
+    "targetPosition": [
+      3.97286831481634
+    ],
+    "targetVelocity": [
+      -1.3571003652746443
+    ],
+    "targetAcceleration": [
+      -2.0822852401937326
+    ],
+    "maxVelocity": [
+      3.8057539021209736
+    ],
+    "maxAcceleration": [
+      4.849515709149539
+    ],
+    "maxJerk": [
+      15.807283946142695
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.547932259627132
+    ],
+    "currentVelocity": [
+      0.1688146981579428
+    ],
+    "currentAcceleration": [
+      0.6132505836493163
+    ],
+    "targetPosition": [
+      -5.601152807371768
+    ],
+    "targetVelocity": [
+      -0.5639861922158289
+    ],
+    "targetAcceleration": [
+      -1.7366636028042217
+    ],
+    "maxVelocity": [
+      2.1539742012955143
+    ],
+    "maxAcceleration": [
+      4.968947937846942
+    ],
+    "maxJerk": [
+      13.238762594978722
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.49723168996426637
+    ],
+    "currentVelocity": [
+      3.250038549403155
+    ],
+    "currentAcceleration": [
+      1.8570739862010726
+    ],
+    "targetPosition": [
+      -3.231335263222168
+    ],
+    "targetVelocity": [
+      0.5899185764609864
+    ],
+    "targetAcceleration": [
+      -1.7017541310771078
+    ],
+    "maxVelocity": [
+      4.335588919979802
+    ],
+    "maxAcceleration": [
+      3.617636910679493
+    ],
+    "maxJerk": [
+      19.122114531822625
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.410538925244015
+    ],
+    "currentVelocity": [
+      5.171800002077639
+    ],
+    "currentAcceleration": [
+      -1.9922512179112415
+    ],
+    "targetPosition": [
+      2.4983485325212023
+    ],
+    "targetVelocity": [
+      7.238294751193267
+    ],
+    "targetAcceleration": [
+      -4.691090213681741
+    ],
+    "maxVelocity": [
+      7.9185231213815666
+    ],
+    "maxAcceleration": [
+      5.914355586505311
+    ],
+    "maxJerk": [
+      17.013153892451722
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.547549398768563
+    ],
+    "currentVelocity": [
+      -0.41863581717454235
+    ],
+    "currentAcceleration": [
+      -0.30554549878507054
+    ],
+    "targetPosition": [
+      3.721845544646561
+    ],
+    "targetVelocity": [
+      1.760245139825475
+    ],
+    "targetAcceleration": [
+      -2.713788532010863
+    ],
+    "maxVelocity": [
+      5.509121271023494
+    ],
+    "maxAcceleration": [
+      3.1441046338844725
+    ],
+    "maxJerk": [
+      5.489782187725193
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.8991569946193145
+    ],
+    "currentVelocity": [
+      2.4203338011052065
+    ],
+    "currentAcceleration": [
+      2.088479613526626
+    ],
+    "targetPosition": [
+      1.0689598110574963
+    ],
+    "targetVelocity": [
+      -0.43997087862197004
+    ],
+    "targetAcceleration": [
+      -3.3706280971669584
+    ],
+    "maxVelocity": [
+      4.195493012117612
+    ],
+    "maxAcceleration": [
+      3.8571714787727926
+    ],
+    "maxJerk": [
+      6.929379220042099
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.422772459743808
+    ],
+    "currentVelocity": [
+      2.1585636843316145
+    ],
+    "currentAcceleration": [
+      -5.62070746693794
+    ],
+    "targetPosition": [
+      7.946378225838732
+    ],
+    "targetVelocity": [
+      0.9105372428554817
+    ],
+    "targetAcceleration": [
+      1.4554377095450963
+    ],
+    "maxVelocity": [
+      2.964381554954733
+    ],
+    "maxAcceleration": [
+      7.36614192565721
+    ],
+    "maxJerk": [
+      10.906315772342909
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.411643223148793
+    ],
+    "currentVelocity": [
+      2.1200318268818528
+    ],
+    "currentAcceleration": [
+      3.4952069452686034
+    ],
+    "targetPosition": [
+      -9.634595906585936
+    ],
+    "targetVelocity": [
+      -1.36956072842954
+    ],
+    "targetAcceleration": [
+      -4.941191667500332
+    ],
+    "maxVelocity": [
+      3.180652463595421
+    ],
+    "maxAcceleration": [
+      5.429785820138577
+    ],
+    "maxJerk": [
+      14.933796169073306
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.6309627137841
+    ],
+    "currentVelocity": [
+      -3.585848217882533
+    ],
+    "currentAcceleration": [
+      0.7809807879656341
+    ],
+    "targetPosition": [
+      4.419972901828395
+    ],
+    "targetVelocity": [
+      -1.7798354671789802
+    ],
+    "targetAcceleration": [
+      1.6882017491300867
+    ],
+    "maxVelocity": [
+      3.739893254765832
+    ],
+    "maxAcceleration": [
+      3.8044762674575874
+    ],
+    "maxJerk": [
+      17.577161617563288
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.969296087555958
+    ],
+    "currentVelocity": [
+      1.0530662531995603
+    ],
+    "currentAcceleration": [
+      0.30749207109909804
+    ],
+    "targetPosition": [
+      0.7405797086451003
+    ],
+    "targetVelocity": [
+      1.2055866628560103
+    ],
+    "targetAcceleration": [
+      0.6037230415936419
+    ],
+    "maxVelocity": [
+      4.069420969859748
+    ],
+    "maxAcceleration": [
+      4.590099928906473
+    ],
+    "maxJerk": [
+      17.61517069751001
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.604823442017622
+    ],
+    "currentVelocity": [
+      -3.12750164827998
+    ],
+    "currentAcceleration": [
+      -3.1760590150929056
+    ],
+    "targetPosition": [
+      1.3236510370870551
+    ],
+    "targetVelocity": [
+      0.25104507800234277
+    ],
+    "targetAcceleration": [
+      -2.2938087926386865
+    ],
+    "maxVelocity": [
+      4.637952680866072
+    ],
+    "maxAcceleration": [
+      3.2346086672426866
+    ],
+    "maxJerk": [
+      13.940014303141284
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.1262464556155436
+    ],
+    "currentVelocity": [
+      -0.8091235968028059
+    ],
+    "currentAcceleration": [
+      2.2979442321359915
+    ],
+    "targetPosition": [
+      -6.37587842531225
+    ],
+    "targetVelocity": [
+      6.192561743776843
+    ],
+    "targetAcceleration": [
+      6.104476864492611
+    ],
+    "maxVelocity": [
+      7.222004120158505
+    ],
+    "maxAcceleration": [
+      9.855426579185922
+    ],
+    "maxJerk": [
+      10.543156617103794
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.7874469482976316
+    ],
+    "currentVelocity": [
+      3.494164228297212
+    ],
+    "currentAcceleration": [
+      -3.381384980603935
+    ],
+    "targetPosition": [
+      -3.997845657579804
+    ],
+    "targetVelocity": [
+      1.119659259340585
+    ],
+    "targetAcceleration": [
+      0.23923123520540202
+    ],
+    "maxVelocity": [
+      4.577774723706177
+    ],
+    "maxAcceleration": [
+      5.3166498015942
+    ],
+    "maxJerk": [
+      14.491304666192237
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.302626245736985
+    ],
+    "currentVelocity": [
+      -3.347978212467694
+    ],
+    "currentAcceleration": [
+      1.327715433451166
+    ],
+    "targetPosition": [
+      4.805379385404624
+    ],
+    "targetVelocity": [
+      -0.28710357550682675
+    ],
+    "targetAcceleration": [
+      0.8131942041706157
+    ],
+    "maxVelocity": [
+      4.111064378764669
+    ],
+    "maxAcceleration": [
+      9.158967364025294
+    ],
+    "maxJerk": [
+      10.96083364863365
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.171581177682608
+    ],
+    "currentVelocity": [
+      1.5742453816374171
+    ],
+    "currentAcceleration": [
+      -4.5829765471922626
+    ],
+    "targetPosition": [
+      -3.6936526516835677
+    ],
+    "targetVelocity": [
+      -2.781134760960569
+    ],
+    "targetAcceleration": [
+      3.2566797904602423
+    ],
+    "maxVelocity": [
+      6.376555840479875
+    ],
+    "maxAcceleration": [
+      6.257502976139651
+    ],
+    "maxJerk": [
+      14.244179406038533
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.053398799542446
+    ],
+    "currentVelocity": [
+      3.296518525588729
+    ],
+    "currentAcceleration": [
+      -4.41559390096147
+    ],
+    "targetPosition": [
+      0.9486306860009304
+    ],
+    "targetVelocity": [
+      3.835074262719325
+    ],
+    "targetAcceleration": [
+      1.1282247098479523
+    ],
+    "maxVelocity": [
+      4.187470039184725
+    ],
+    "maxAcceleration": [
+      8.122218115381068
+    ],
+    "maxJerk": [
+      19.821378225541878
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.182633224453667
+    ],
+    "currentVelocity": [
+      0.60007718560664
+    ],
+    "currentAcceleration": [
+      3.111930999063582
+    ],
+    "targetPosition": [
+      -4.736698164049955
+    ],
+    "targetVelocity": [
+      1.4782117138688955
+    ],
+    "targetAcceleration": [
+      2.405374156009824
+    ],
+    "maxVelocity": [
+      5.216877996763265
+    ],
+    "maxAcceleration": [
+      3.2339368841736587
+    ],
+    "maxJerk": [
+      19.86931231245945
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.186421854362972
+    ],
+    "currentVelocity": [
+      -4.641411843812039
+    ],
+    "currentAcceleration": [
+      -4.750201345823886
+    ],
+    "targetPosition": [
+      3.8537130289753527
+    ],
+    "targetVelocity": [
+      4.515610893964693
+    ],
+    "targetAcceleration": [
+      -3.2627511980712347
+    ],
+    "maxVelocity": [
+      7.917410156109657
+    ],
+    "maxAcceleration": [
+      5.865695379272671
+    ],
+    "maxJerk": [
+      7.416814339594776
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.394546174766571
+    ],
+    "currentVelocity": [
+      -2.1458653413597975
+    ],
+    "currentAcceleration": [
+      -1.1584876031994336
+    ],
+    "targetPosition": [
+      -7.401098354248921
+    ],
+    "targetVelocity": [
+      1.0495642386494848
+    ],
+    "targetAcceleration": [
+      2.101550082739804
+    ],
+    "maxVelocity": [
+      3.1218573682431736
+    ],
+    "maxAcceleration": [
+      6.0320318230868
+    ],
+    "maxJerk": [
+      19.906927951733504
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.190887868665381
+    ],
+    "currentVelocity": [
+      1.1893999004177593
+    ],
+    "currentAcceleration": [
+      -6.9551920627811405
+    ],
+    "targetPosition": [
+      -8.904836539369539
+    ],
+    "targetVelocity": [
+      0.3248244159005935
+    ],
+    "targetAcceleration": [
+      -1.3466111197775348
+    ],
+    "maxVelocity": [
+      2.548248910737863
+    ],
+    "maxAcceleration": [
+      9.615312525999453
+    ],
+    "maxJerk": [
+      7.567279657400243
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.9861084388428054
+    ],
+    "currentVelocity": [
+      -2.267485932962661
+    ],
+    "currentAcceleration": [
+      -2.1689224951050714
+    ],
+    "targetPosition": [
+      9.055229530508456
+    ],
+    "targetVelocity": [
+      -1.46827528230991
+    ],
+    "targetAcceleration": [
+      -3.4970288010666017
+    ],
+    "maxVelocity": [
+      5.6742866384636885
+    ],
+    "maxAcceleration": [
+      4.538436267221968
+    ],
+    "maxJerk": [
+      15.16232725576755
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.4031168012434456
+    ],
+    "currentVelocity": [
+      -1.1475274117010343
+    ],
+    "currentAcceleration": [
+      1.0714428447403037
+    ],
+    "targetPosition": [
+      8.067564878132366
+    ],
+    "targetVelocity": [
+      -1.2032542319208908
+    ],
+    "targetAcceleration": [
+      -7.392933581112979
+    ],
+    "maxVelocity": [
+      4.831619837493182
+    ],
+    "maxAcceleration": [
+      9.662344785153167
+    ],
+    "maxJerk": [
+      18.54890244508003
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.4904655766008847
+    ],
+    "currentVelocity": [
+      -3.9362508924171142
+    ],
+    "currentAcceleration": [
+      -3.323054116329702
+    ],
+    "targetPosition": [
+      8.940618795133851
+    ],
+    "targetVelocity": [
+      -1.7904713909156724
+    ],
+    "targetAcceleration": [
+      5.112618875092437
+    ],
+    "maxVelocity": [
+      7.5936661908618515
+    ],
+    "maxAcceleration": [
+      6.09616470526648
+    ],
+    "maxJerk": [
+      8.321050400720088
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.574981304906977
+    ],
+    "currentVelocity": [
+      1.094750488189291
+    ],
+    "currentAcceleration": [
+      2.8199967904853867
+    ],
+    "targetPosition": [
+      -5.25005880574734
+    ],
+    "targetVelocity": [
+      -4.23980705820944
+    ],
+    "targetAcceleration": [
+      0.8520638078330101
+    ],
+    "maxVelocity": [
+      7.793898969841294
+    ],
+    "maxAcceleration": [
+      3.8707501430361044
+    ],
+    "maxJerk": [
+      15.416341304628451
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.6178497469642394
+    ],
+    "currentVelocity": [
+      -0.9643472386609471
+    ],
+    "currentAcceleration": [
+      1.669730132957401
+    ],
+    "targetPosition": [
+      -2.111117874756241
+    ],
+    "targetVelocity": [
+      -3.268996678024623
+    ],
+    "targetAcceleration": [
+      -0.7182227685639617
+    ],
+    "maxVelocity": [
+      3.271075171064677
+    ],
+    "maxAcceleration": [
+      7.402144053937096
+    ],
+    "maxJerk": [
+      6.432784122844851
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.8749627426354
+    ],
+    "currentVelocity": [
+      5.017825836374491
+    ],
+    "currentAcceleration": [
+      -0.6321116075917619
+    ],
+    "targetPosition": [
+      1.220800357219689
+    ],
+    "targetVelocity": [
+      3.708254940657297
+    ],
+    "targetAcceleration": [
+      3.7087454337236636
+    ],
+    "maxVelocity": [
+      5.541435836707264
+    ],
+    "maxAcceleration": [
+      4.780687282679162
+    ],
+    "maxJerk": [
+      12.082965216750324
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.828239677844575
+    ],
+    "currentVelocity": [
+      1.2798904140210388
+    ],
+    "currentAcceleration": [
+      -4.178105772378553
+    ],
+    "targetPosition": [
+      9.396121441270022
+    ],
+    "targetVelocity": [
+      1.7826156354916654
+    ],
+    "targetAcceleration": [
+      -4.394191460902431
+    ],
+    "maxVelocity": [
+      2.7091297554424107
+    ],
+    "maxAcceleration": [
+      4.8067303289365135
+    ],
+    "maxJerk": [
+      10.474093474963198
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.053399127178984
+    ],
+    "currentVelocity": [
+      4.863471883515268
+    ],
+    "currentAcceleration": [
+      -3.104923044119557
+    ],
+    "targetPosition": [
+      0.35460498045283906
+    ],
+    "targetVelocity": [
+      4.403999612025889
+    ],
+    "targetAcceleration": [
+      3.5269921553079984
+    ],
+    "maxVelocity": [
+      7.797018730338084
+    ],
+    "maxAcceleration": [
+      3.661843822809355
+    ],
+    "maxJerk": [
+      17.366253768308464
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.083017191820309
+    ],
+    "currentVelocity": [
+      4.098325220000701
+    ],
+    "currentAcceleration": [
+      -1.9279382847224809
+    ],
+    "targetPosition": [
+      -1.8970219574356797
+    ],
+    "targetVelocity": [
+      4.8008865834181655
+    ],
+    "targetAcceleration": [
+      2.7881441275388243
+    ],
+    "maxVelocity": [
+      5.309751012389256
+    ],
+    "maxAcceleration": [
+      3.8420025338182637
+    ],
+    "maxJerk": [
+      7.060855704267809
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.9711496319197988
+    ],
+    "currentVelocity": [
+      3.0419113214716678
+    ],
+    "currentAcceleration": [
+      -1.208275024267886
+    ],
+    "targetPosition": [
+      -7.020362325567433
+    ],
+    "targetVelocity": [
+      -1.523206480802462
+    ],
+    "targetAcceleration": [
+      -4.268621115850289
+    ],
+    "maxVelocity": [
+      7.238403233414365
+    ],
+    "maxAcceleration": [
+      9.485698469906502
+    ],
+    "maxJerk": [
+      19.26818098246345
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.7630597876779763
+    ],
+    "currentVelocity": [
+      0.7105121145315323
+    ],
+    "currentAcceleration": [
+      -3.4385142827079602
+    ],
+    "targetPosition": [
+      2.4159679487338597
+    ],
+    "targetVelocity": [
+      -2.0903898567975645
+    ],
+    "targetAcceleration": [
+      -4.681969752646566
+    ],
+    "maxVelocity": [
+      3.537642604861446
+    ],
+    "maxAcceleration": [
+      5.510824845893741
+    ],
+    "maxJerk": [
+      19.739271295399135
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.310980095665462
+    ],
+    "currentVelocity": [
+      -2.5537020685580494
+    ],
+    "currentAcceleration": [
+      0.7250167001201069
+    ],
+    "targetPosition": [
+      -4.746008783095359
+    ],
+    "targetVelocity": [
+      0.3261346185169707
+    ],
+    "targetAcceleration": [
+      0.9560111439770749
+    ],
+    "maxVelocity": [
+      3.851686478167756
+    ],
+    "maxAcceleration": [
+      4.889478316373785
+    ],
+    "maxJerk": [
+      9.224528132250011
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.371345198866589
+    ],
+    "currentVelocity": [
+      0.5262959905995022
+    ],
+    "currentAcceleration": [
+      4.447911994654833
+    ],
+    "targetPosition": [
+      -8.762121960567729
+    ],
+    "targetVelocity": [
+      -2.4649047581138954
+    ],
+    "targetAcceleration": [
+      -2.3163155446167756
+    ],
+    "maxVelocity": [
+      6.393028224620358
+    ],
+    "maxAcceleration": [
+      5.950737920602965
+    ],
+    "maxJerk": [
+      12.908267760231048
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.099835575095376
+    ],
+    "currentVelocity": [
+      -3.545134281762869
+    ],
+    "currentAcceleration": [
+      2.4948086819918265
+    ],
+    "targetPosition": [
+      -5.330184557662687
+    ],
+    "targetVelocity": [
+      3.0659402160020055
+    ],
+    "targetAcceleration": [
+      0.31103365244262404
+    ],
+    "maxVelocity": [
+      3.8248491575395565
+    ],
+    "maxAcceleration": [
+      3.1916395986776234
+    ],
+    "maxJerk": [
+      6.4566307286726365
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.3989691470361496
+    ],
+    "currentVelocity": [
+      -1.8506325931675294
+    ],
+    "currentAcceleration": [
+      -4.616785886438176
+    ],
+    "targetPosition": [
+      8.07133379203625
+    ],
+    "targetVelocity": [
+      1.2843984195853508
+    ],
+    "targetAcceleration": [
+      1.9035122449089261
+    ],
+    "maxVelocity": [
+      4.88340189384333
+    ],
+    "maxAcceleration": [
+      5.703903462816274
+    ],
+    "maxJerk": [
+      7.382254617431286
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.5797314267240914
+    ],
+    "currentVelocity": [
+      2.555312647403184
+    ],
+    "currentAcceleration": [
+      5.203688683639897
+    ],
+    "targetPosition": [
+      4.213263218207054
+    ],
+    "targetVelocity": [
+      -4.515976416238583
+    ],
+    "targetAcceleration": [
+      3.9839429248337472
+    ],
+    "maxVelocity": [
+      7.077547874639702
+    ],
+    "maxAcceleration": [
+      5.217251276241654
+    ],
+    "maxJerk": [
+      11.312268647695674
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.315410784703399
+    ],
+    "currentVelocity": [
+      4.978278029722681
+    ],
+    "currentAcceleration": [
+      -5.257403308329745
+    ],
+    "targetPosition": [
+      3.743375153244049
+    ],
+    "targetVelocity": [
+      -3.9982486873515213
+    ],
+    "targetAcceleration": [
+      3.834386330351254
+    ],
+    "maxVelocity": [
+      5.18754732147012
+    ],
+    "maxAcceleration": [
+      6.911133108316125
+    ],
+    "maxJerk": [
+      7.43729697980988
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.7565985129466171
+    ],
+    "currentVelocity": [
+      2.1920654029228475
+    ],
+    "currentAcceleration": [
+      0.7879897621022334
+    ],
+    "targetPosition": [
+      1.1910642521741757
+    ],
+    "targetVelocity": [
+      2.1506358728305655
+    ],
+    "targetAcceleration": [
+      5.1201980596678
+    ],
+    "maxVelocity": [
+      3.548248459418873
+    ],
+    "maxAcceleration": [
+      8.566360079531107
+    ],
+    "maxJerk": [
+      9.947588730668212
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.03557462911801679
+    ],
+    "currentVelocity": [
+      -3.7670415691799617
+    ],
+    "currentAcceleration": [
+      1.2899276980679346
+    ],
+    "targetPosition": [
+      6.170364454626263
+    ],
+    "targetVelocity": [
+      0.7903795848462423
+    ],
+    "targetAcceleration": [
+      -0.12369122351098527
+    ],
+    "maxVelocity": [
+      5.239457209108657
+    ],
+    "maxAcceleration": [
+      3.634396630110145
+    ],
+    "maxJerk": [
+      12.672710673276018
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.1559296491586863
+    ],
+    "currentVelocity": [
+      -3.2610058460450646
+    ],
+    "currentAcceleration": [
+      0.8275285454901304
+    ],
+    "targetPosition": [
+      -5.364404724397247
+    ],
+    "targetVelocity": [
+      -6.376030288588114
+    ],
+    "targetAcceleration": [
+      -0.09560135508748813
+    ],
+    "maxVelocity": [
+      6.864678551010375
+    ],
+    "maxAcceleration": [
+      3.4577766428192147
+    ],
+    "maxJerk": [
+      18.00842465061819
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.755762932872846
+    ],
+    "currentVelocity": [
+      3.899204480278697
+    ],
+    "currentAcceleration": [
+      -2.225903980230393
+    ],
+    "targetPosition": [
+      -4.629415826885275
+    ],
+    "targetVelocity": [
+      0.971482083563135
+    ],
+    "targetAcceleration": [
+      -0.14216167156626947
+    ],
+    "maxVelocity": [
+      3.9348571669822148
+    ],
+    "maxAcceleration": [
+      3.5183297837570713
+    ],
+    "maxJerk": [
+      13.751465262754449
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.507313094578695
+    ],
+    "currentVelocity": [
+      -6.344911479502117
+    ],
+    "currentAcceleration": [
+      -0.9333434680647401
+    ],
+    "targetPosition": [
+      -6.290110635169266
+    ],
+    "targetVelocity": [
+      3.8452737741882927
+    ],
+    "targetAcceleration": [
+      -1.896457638230479
+    ],
+    "maxVelocity": [
+      7.992064856429298
+    ],
+    "maxAcceleration": [
+      3.1272176857213996
+    ],
+    "maxJerk": [
+      10.528444699088293
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.162347763939032
+    ],
+    "currentVelocity": [
+      -0.8265446286722784
+    ],
+    "currentAcceleration": [
+      -3.3689932987269477
+    ],
+    "targetPosition": [
+      -5.329612064957954
+    ],
+    "targetVelocity": [
+      1.2671838528238792
+    ],
+    "targetAcceleration": [
+      -7.193130249983087
+    ],
+    "maxVelocity": [
+      4.344533132465868
+    ],
+    "maxAcceleration": [
+      8.266638723365196
+    ],
+    "maxJerk": [
+      14.791923646672444
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.500393153480338
+    ],
+    "currentVelocity": [
+      0.30972719420776773
+    ],
+    "currentAcceleration": [
+      -3.127090925801402
+    ],
+    "targetPosition": [
+      -6.652537878728408
+    ],
+    "targetVelocity": [
+      1.2720554103916761
+    ],
+    "targetAcceleration": [
+      5.962182901916939
+    ],
+    "maxVelocity": [
+      4.4233047026963765
+    ],
+    "maxAcceleration": [
+      6.013276840750188
+    ],
+    "maxJerk": [
+      15.321786033501311
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.747890014088632
+    ],
+    "currentVelocity": [
+      -1.2001885868903095
+    ],
+    "currentAcceleration": [
+      2.475176072022971
+    ],
+    "targetPosition": [
+      2.102997918302634
+    ],
+    "targetVelocity": [
+      3.268684183630995
+    ],
+    "targetAcceleration": [
+      -4.933559852022798
+    ],
+    "maxVelocity": [
+      6.897042001535233
+    ],
+    "maxAcceleration": [
+      5.620180960894101
+    ],
+    "maxJerk": [
+      8.52272029068801
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.40204378246402
+    ],
+    "currentVelocity": [
+      -0.7449533106906232
+    ],
+    "currentAcceleration": [
+      -1.13651344948881
+    ],
+    "targetPosition": [
+      -9.40252035563147
+    ],
+    "targetVelocity": [
+      0.25682054646580665
+    ],
+    "targetAcceleration": [
+      2.582780266176402
+    ],
+    "maxVelocity": [
+      2.3747583712937352
+    ],
+    "maxAcceleration": [
+      3.194049587558951
+    ],
+    "maxJerk": [
+      7.2403209973347975
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.446025742227949
+    ],
+    "currentVelocity": [
+      -3.5943360106825772
+    ],
+    "currentAcceleration": [
+      4.035332808918664
+    ],
+    "targetPosition": [
+      2.6157899384131404
+    ],
+    "targetVelocity": [
+      4.053086618627005
+    ],
+    "targetAcceleration": [
+      -2.370821644348588
+    ],
+    "maxVelocity": [
+      6.824570022608158
+    ],
+    "maxAcceleration": [
+      9.432212335258457
+    ],
+    "maxJerk": [
+      10.199505787346864
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.985308626913515
+    ],
+    "currentVelocity": [
+      0.7678397970006223
+    ],
+    "currentAcceleration": [
+      -6.718471491124038
+    ],
+    "targetPosition": [
+      9.18029980432187
+    ],
+    "targetVelocity": [
+      -0.9134591021099716
+    ],
+    "targetAcceleration": [
+      -6.886817170824783
+    ],
+    "maxVelocity": [
+      7.271847242365617
+    ],
+    "maxAcceleration": [
+      8.432877150230256
+    ],
+    "maxJerk": [
+      12.059203526241255
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.76966081573614
+    ],
+    "currentVelocity": [
+      1.283426310763478
+    ],
+    "currentAcceleration": [
+      2.468453436928778
+    ],
+    "targetPosition": [
+      -4.201063003135534
+    ],
+    "targetVelocity": [
+      1.6758132854591241
+    ],
+    "targetAcceleration": [
+      3.2091081492674594
+    ],
+    "maxVelocity": [
+      3.401316093803375
+    ],
+    "maxAcceleration": [
+      7.641196322407774
+    ],
+    "maxJerk": [
+      10.986320909794905
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.209782138056859
+    ],
+    "currentVelocity": [
+      -4.1154620576284575
+    ],
+    "currentAcceleration": [
+      -6.0834230317757445
+    ],
+    "targetPosition": [
+      -3.5644225053369745
+    ],
+    "targetVelocity": [
+      3.2042428987383094
+    ],
+    "targetAcceleration": [
+      -3.430539456575167
+    ],
+    "maxVelocity": [
+      6.745116264286514
+    ],
+    "maxAcceleration": [
+      6.648899635059139
+    ],
+    "maxJerk": [
+      16.286068029878212
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.8362886014717557
+    ],
+    "currentVelocity": [
+      -4.306867262889366
+    ],
+    "currentAcceleration": [
+      3.0775150496983885
+    ],
+    "targetPosition": [
+      5.221192103992374
+    ],
+    "targetVelocity": [
+      -4.42448212238965
+    ],
+    "targetAcceleration": [
+      6.1179807515994975
+    ],
+    "maxVelocity": [
+      7.470165431963039
+    ],
+    "maxAcceleration": [
+      6.414897521102371
+    ],
+    "maxJerk": [
+      7.569771268091229
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7840765935628582
+    ],
+    "currentVelocity": [
+      -6.968822651057721
+    ],
+    "currentAcceleration": [
+      -2.3049982385674417
+    ],
+    "targetPosition": [
+      7.377517697780473
+    ],
+    "targetVelocity": [
+      6.471948708612654
+    ],
+    "targetAcceleration": [
+      -5.27823041690245
+    ],
+    "maxVelocity": [
+      7.536741861084488
+    ],
+    "maxAcceleration": [
+      7.671981220241577
+    ],
+    "maxJerk": [
+      14.864414848393356
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.1680678039951502
+    ],
+    "currentVelocity": [
+      1.635201843464206
+    ],
+    "currentAcceleration": [
+      -1.9795253770760324
+    ],
+    "targetPosition": [
+      -7.939727912710981
+    ],
+    "targetVelocity": [
+      -0.35509905654966545
+    ],
+    "targetAcceleration": [
+      4.329467864174124
+    ],
+    "maxVelocity": [
+      2.6664410393177973
+    ],
+    "maxAcceleration": [
+      5.024590628131189
+    ],
+    "maxJerk": [
+      19.091283893316195
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.4823161639693883
+    ],
+    "currentVelocity": [
+      1.4731059106900597
+    ],
+    "currentAcceleration": [
+      -3.86526262038012
+    ],
+    "targetPosition": [
+      3.842571898279745
+    ],
+    "targetVelocity": [
+      2.574226481636142
+    ],
+    "targetAcceleration": [
+      3.1475531046575167
+    ],
+    "maxVelocity": [
+      6.401542246172561
+    ],
+    "maxAcceleration": [
+      9.958594786366655
+    ],
+    "maxJerk": [
+      18.06987138556332
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.719418956384593
+    ],
+    "currentVelocity": [
+      -2.3012033008732633
+    ],
+    "currentAcceleration": [
+      2.030898025447409
+    ],
+    "targetPosition": [
+      -0.9784338723897346
+    ],
+    "targetVelocity": [
+      -1.4102604045791498
+    ],
+    "targetAcceleration": [
+      0.5925173932360748
+    ],
+    "maxVelocity": [
+      4.084554808547608
+    ],
+    "maxAcceleration": [
+      4.333276459279578
+    ],
+    "maxJerk": [
+      15.729100502102053
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.4260844142059934
+    ],
+    "currentVelocity": [
+      2.951902855021959
+    ],
+    "currentAcceleration": [
+      0.8709447558720536
+    ],
+    "targetPosition": [
+      -5.073376025095846
+    ],
+    "targetVelocity": [
+      -1.83527725088022
+    ],
+    "targetAcceleration": [
+      0.6259008445539669
+    ],
+    "maxVelocity": [
+      3.685526657798967
+    ],
+    "maxAcceleration": [
+      7.447260348515537
+    ],
+    "maxJerk": [
+      11.391107188237088
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.566851790500686
+    ],
+    "currentVelocity": [
+      0.8570267973178352
+    ],
+    "currentAcceleration": [
+      -8.50351816464377
+    ],
+    "targetPosition": [
+      0.5621071670580928
+    ],
+    "targetVelocity": [
+      4.336243014573035
+    ],
+    "targetAcceleration": [
+      7.247532957927618
+    ],
+    "maxVelocity": [
+      7.239005968372765
+    ],
+    "maxAcceleration": [
+      8.94872131998293
+    ],
+    "maxJerk": [
+      15.42613828590882
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.742962886363234
+    ],
+    "currentVelocity": [
+      -2.807084435611441
+    ],
+    "currentAcceleration": [
+      -5.700684751261463
+    ],
+    "targetPosition": [
+      7.344649891312901
+    ],
+    "targetVelocity": [
+      -2.247204432272061
+    ],
+    "targetAcceleration": [
+      1.840515507807707
+    ],
+    "maxVelocity": [
+      4.929651223627014
+    ],
+    "maxAcceleration": [
+      5.903256721645632
+    ],
+    "maxJerk": [
+      9.7171631636621
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.002100253039367
+    ],
+    "currentVelocity": [
+      2.1126064435275556
+    ],
+    "currentAcceleration": [
+      -1.296666224125537
+    ],
+    "targetPosition": [
+      2.3235131203453125
+    ],
+    "targetVelocity": [
+      -3.381171797224816
+    ],
+    "targetAcceleration": [
+      3.6838936728836877
+    ],
+    "maxVelocity": [
+      7.275388048477431
+    ],
+    "maxAcceleration": [
+      5.950472311216959
+    ],
+    "maxJerk": [
+      12.918511710639402
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.470447067757073
+    ],
+    "currentVelocity": [
+      -3.405865934838526
+    ],
+    "currentAcceleration": [
+      2.0975841095463554
+    ],
+    "targetPosition": [
+      0.4288858041289636
+    ],
+    "targetVelocity": [
+      -3.24406244499281
+    ],
+    "targetAcceleration": [
+      4.610261045435175
+    ],
+    "maxVelocity": [
+      5.530677342081229
+    ],
+    "maxAcceleration": [
+      8.218803013007427
+    ],
+    "maxJerk": [
+      9.180307355383539
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.7095829814112076
+    ],
+    "currentVelocity": [
+      -4.132450920281402
+    ],
+    "currentAcceleration": [
+      1.8838209310232106
+    ],
+    "targetPosition": [
+      1.7390131483404758
+    ],
+    "targetVelocity": [
+      1.8823334649115129
+    ],
+    "targetAcceleration": [
+      0.4591813687810795
+    ],
+    "maxVelocity": [
+      6.573956174188821
+    ],
+    "maxAcceleration": [
+      7.880983244740566
+    ],
+    "maxJerk": [
+      12.422321347549563
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.257936735757863
+    ],
+    "currentVelocity": [
+      -0.23999988003028472
+    ],
+    "currentAcceleration": [
+      -1.9019361010352793
+    ],
+    "targetPosition": [
+      -4.648616849771765
+    ],
+    "targetVelocity": [
+      0.14610443889533542
+    ],
+    "targetAcceleration": [
+      0.21482322142547217
+    ],
+    "maxVelocity": [
+      2.39643780298041
+    ],
+    "maxAcceleration": [
+      3.683728487555241
+    ],
+    "maxJerk": [
+      11.631279282346313
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.8184158355550633
+    ],
+    "currentVelocity": [
+      3.6103895493478673
+    ],
+    "currentAcceleration": [
+      2.428736038951204
+    ],
+    "targetPosition": [
+      9.096297750761071
+    ],
+    "targetVelocity": [
+      0.2025107648314295
+    ],
+    "targetAcceleration": [
+      5.026226577718308
+    ],
+    "maxVelocity": [
+      6.822313949426166
+    ],
+    "maxAcceleration": [
+      8.107534559361762
+    ],
+    "maxJerk": [
+      7.779594225461652
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.685835782151738
+    ],
+    "currentVelocity": [
+      -3.795537399113318
+    ],
+    "currentAcceleration": [
+      1.9011659620593786
+    ],
+    "targetPosition": [
+      5.4711055392891765
+    ],
+    "targetVelocity": [
+      -2.578519311419806
+    ],
+    "targetAcceleration": [
+      -5.013070125478909
+    ],
+    "maxVelocity": [
+      4.431531289554462
+    ],
+    "maxAcceleration": [
+      9.941262464580804
+    ],
+    "maxJerk": [
+      17.218042007610684
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.947499711071636
+    ],
+    "currentVelocity": [
+      0.4239698116150121
+    ],
+    "currentAcceleration": [
+      -3.06652698358488
+    ],
+    "targetPosition": [
+      3.443554286383444
+    ],
+    "targetVelocity": [
+      1.2946702123708507
+    ],
+    "targetAcceleration": [
+      4.089345968959617
+    ],
+    "maxVelocity": [
+      2.481687513063851
+    ],
+    "maxAcceleration": [
+      4.936416586652501
+    ],
+    "maxJerk": [
+      11.294292516758528
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.801418360618953
+    ],
+    "currentVelocity": [
+      0.26569654946258137
+    ],
+    "currentAcceleration": [
+      -4.276919282659111
+    ],
+    "targetPosition": [
+      0.8168839229352223
+    ],
+    "targetVelocity": [
+      5.0752125102292664
+    ],
+    "targetAcceleration": [
+      -2.5346129324446887
+    ],
+    "maxVelocity": [
+      5.729753087317854
+    ],
+    "maxAcceleration": [
+      9.200263449863252
+    ],
+    "maxJerk": [
+      9.233864100490585
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.348121552389031
+    ],
+    "currentVelocity": [
+      -0.29416537806394194
+    ],
+    "currentAcceleration": [
+      3.6779540754354922
+    ],
+    "targetPosition": [
+      -0.9077753159017234
+    ],
+    "targetVelocity": [
+      1.0638820259219819
+    ],
+    "targetAcceleration": [
+      2.7561560708214543
+    ],
+    "maxVelocity": [
+      3.6841410916428594
+    ],
+    "maxAcceleration": [
+      5.821459508857199
+    ],
+    "maxJerk": [
+      13.542564616295232
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.059765926885651
+    ],
+    "currentVelocity": [
+      2.462033655950016
+    ],
+    "currentAcceleration": [
+      0.457006511415198
+    ],
+    "targetPosition": [
+      -0.44746876808271274
+    ],
+    "targetVelocity": [
+      -1.1913570946379615
+    ],
+    "targetAcceleration": [
+      2.8872577014338408
+    ],
+    "maxVelocity": [
+      2.9228868039953566
+    ],
+    "maxAcceleration": [
+      3.95309490721358
+    ],
+    "maxJerk": [
+      13.886037351044555
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.419663902452243
+    ],
+    "currentVelocity": [
+      -0.9606615076997298
+    ],
+    "currentAcceleration": [
+      5.775677123840493
+    ],
+    "targetPosition": [
+      0.10480296752551688
+    ],
+    "targetVelocity": [
+      -3.299242448114253
+    ],
+    "targetAcceleration": [
+      -0.3723908463094894
+    ],
+    "maxVelocity": [
+      3.773992007907247
+    ],
+    "maxAcceleration": [
+      8.479818269977242
+    ],
+    "maxJerk": [
+      18.46290964734784
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.938184495220053
+    ],
+    "currentVelocity": [
+      -2.4159130331875174
+    ],
+    "currentAcceleration": [
+      0.8148850126364993
+    ],
+    "targetPosition": [
+      6.616040023975319
+    ],
+    "targetVelocity": [
+      -0.49885900217222545
+    ],
+    "targetAcceleration": [
+      1.2800148803157523
+    ],
+    "maxVelocity": [
+      7.211713147412144
+    ],
+    "maxAcceleration": [
+      3.6100929036728875
+    ],
+    "maxJerk": [
+      5.945675847102084
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.642313732026341
+    ],
+    "currentVelocity": [
+      -1.6689956623721538
+    ],
+    "currentAcceleration": [
+      4.191809902761582
+    ],
+    "targetPosition": [
+      -5.872662889785223
+    ],
+    "targetVelocity": [
+      1.8778373036795877
+    ],
+    "targetAcceleration": [
+      -0.9153988604970982
+    ],
+    "maxVelocity": [
+      4.934412277390488
+    ],
+    "maxAcceleration": [
+      5.674423006679895
+    ],
+    "maxJerk": [
+      6.36288807677168
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.18470828455354
+    ],
+    "currentVelocity": [
+      -2.4469940818675258
+    ],
+    "currentAcceleration": [
+      2.091903478154217
+    ],
+    "targetPosition": [
+      4.751401929828447
+    ],
+    "targetVelocity": [
+      2.0789339426772564
+    ],
+    "targetAcceleration": [
+      -2.005118894340865
+    ],
+    "maxVelocity": [
+      3.558709392570032
+    ],
+    "maxAcceleration": [
+      5.340436307850792
+    ],
+    "maxJerk": [
+      13.631310575737475
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.914529006436464
+    ],
+    "currentVelocity": [
+      -1.7871053498294858
+    ],
+    "currentAcceleration": [
+      -0.7401822241218974
+    ],
+    "targetPosition": [
+      -0.009278540624075404
+    ],
+    "targetVelocity": [
+      2.521548115094462
+    ],
+    "targetAcceleration": [
+      2.714671681164508
+    ],
+    "maxVelocity": [
+      3.1498948154191897
+    ],
+    "maxAcceleration": [
+      3.196720119877341
+    ],
+    "maxJerk": [
+      18.97055208344358
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.348434556187438
+    ],
+    "currentVelocity": [
+      -1.489220179228016
+    ],
+    "currentAcceleration": [
+      0.916939635853284
+    ],
+    "targetPosition": [
+      5.408031364366741
+    ],
+    "targetVelocity": [
+      5.1627096229729785
+    ],
+    "targetAcceleration": [
+      -2.617735432332341
+    ],
+    "maxVelocity": [
+      5.570740593907353
+    ],
+    "maxAcceleration": [
+      9.183554447768355
+    ],
+    "maxJerk": [
+      16.300095103480498
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.689170123733102
+    ],
+    "currentVelocity": [
+      2.139718809945072
+    ],
+    "currentAcceleration": [
+      3.8712590543266368
+    ],
+    "targetPosition": [
+      7.771975217342323
+    ],
+    "targetVelocity": [
+      5.117544857095183
+    ],
+    "targetAcceleration": [
+      -0.9763124620976589
+    ],
+    "maxVelocity": [
+      5.59799675505095
+    ],
+    "maxAcceleration": [
+      6.928361959985065
+    ],
+    "maxJerk": [
+      5.712800495047806
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.890176420265995
+    ],
+    "currentVelocity": [
+      -0.964163096104313
+    ],
+    "currentAcceleration": [
+      -4.1590738352085665
+    ],
+    "targetPosition": [
+      1.6676439941331331
+    ],
+    "targetVelocity": [
+      0.7241418267183883
+    ],
+    "targetAcceleration": [
+      -3.8896723055600955
+    ],
+    "maxVelocity": [
+      6.800890019358946
+    ],
+    "maxAcceleration": [
+      4.452252993342526
+    ],
+    "maxJerk": [
+      14.141289681115566
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.2893134657590899
+    ],
+    "currentVelocity": [
+      0.664332425458785
+    ],
+    "currentAcceleration": [
+      -6.184384522188629
+    ],
+    "targetPosition": [
+      9.428141483646325
+    ],
+    "targetVelocity": [
+      0.26165706131781397
+    ],
+    "targetAcceleration": [
+      5.303145792884813
+    ],
+    "maxVelocity": [
+      2.433371408923225
+    ],
+    "maxAcceleration": [
+      8.09876398213207
+    ],
+    "maxJerk": [
+      6.464418233298432
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.1903343272226401
+    ],
+    "currentVelocity": [
+      -4.267159034699107
+    ],
+    "currentAcceleration": [
+      -1.907880503982767
+    ],
+    "targetPosition": [
+      5.155947955681617
+    ],
+    "targetVelocity": [
+      -2.1491195758935526
+    ],
+    "targetAcceleration": [
+      2.2216740147604703
+    ],
+    "maxVelocity": [
+      5.592602518606083
+    ],
+    "maxAcceleration": [
+      9.111175060356414
+    ],
+    "maxJerk": [
+      9.667431078828029
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.492218247733735
+    ],
+    "currentVelocity": [
+      -0.6729522536724577
+    ],
+    "currentAcceleration": [
+      2.9576526562556897
+    ],
+    "targetPosition": [
+      1.689870828161519
+    ],
+    "targetVelocity": [
+      -0.3018062033706692
+    ],
+    "targetAcceleration": [
+      -1.6191863087232121
+    ],
+    "maxVelocity": [
+      3.126982833174725
+    ],
+    "maxAcceleration": [
+      3.2796383933258473
+    ],
+    "maxJerk": [
+      5.094404605148904
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.2778197188172005
+    ],
+    "currentVelocity": [
+      -5.779899092732634
+    ],
+    "currentAcceleration": [
+      -3.9691215482347015
+    ],
+    "targetPosition": [
+      3.7243863327707096
+    ],
+    "targetVelocity": [
+      4.435125885318447
+    ],
+    "targetAcceleration": [
+      4.100338757904834
+    ],
+    "maxVelocity": [
+      7.921932458644337
+    ],
+    "maxAcceleration": [
+      5.5933080701701146
+    ],
+    "maxJerk": [
+      13.433724118812648
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.097011053430244
+    ],
+    "currentVelocity": [
+      4.153983564508648
+    ],
+    "currentAcceleration": [
+      5.751719305423142
+    ],
+    "targetPosition": [
+      9.723796599049706
+    ],
+    "targetVelocity": [
+      1.7379330372789994
+    ],
+    "targetAcceleration": [
+      5.3699247621554775
+    ],
+    "maxVelocity": [
+      6.186282653971142
+    ],
+    "maxAcceleration": [
+      6.757356751599994
+    ],
+    "maxJerk": [
+      11.261083535298267
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.351182507055443
+    ],
+    "currentVelocity": [
+      -4.55636362333871
+    ],
+    "currentAcceleration": [
+      0.08117918772684263
+    ],
+    "targetPosition": [
+      8.416773837589616
+    ],
+    "targetVelocity": [
+      5.02599918641749
+    ],
+    "targetAcceleration": [
+      -0.5471639962164407
+    ],
+    "maxVelocity": [
+      6.872077421783834
+    ],
+    "maxAcceleration": [
+      4.363964489856386
+    ],
+    "maxJerk": [
+      18.733559023871365
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.6786372488868686
+    ],
+    "currentVelocity": [
+      -4.006406585252507
+    ],
+    "currentAcceleration": [
+      2.351927297304921
+    ],
+    "targetPosition": [
+      7.956951022026239
+    ],
+    "targetVelocity": [
+      -2.9299493263845506
+    ],
+    "targetAcceleration": [
+      3.3309937696406786
+    ],
+    "maxVelocity": [
+      6.339519056956917
+    ],
+    "maxAcceleration": [
+      5.806972789697336
+    ],
+    "maxJerk": [
+      6.52028480030439
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.300193035337081
+    ],
+    "currentVelocity": [
+      -2.964085637730299
+    ],
+    "currentAcceleration": [
+      -1.3016187025950003
+    ],
+    "targetPosition": [
+      -8.712294635150863
+    ],
+    "targetVelocity": [
+      6.147696676651877
+    ],
+    "targetAcceleration": [
+      7.5946740852881955
+    ],
+    "maxVelocity": [
+      6.4172492933813094
+    ],
+    "maxAcceleration": [
+      9.733057449855833
+    ],
+    "maxJerk": [
+      11.47945536169704
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.72057459209445
+    ],
+    "currentVelocity": [
+      4.951061223243542
+    ],
+    "currentAcceleration": [
+      -1.4285291842379344
+    ],
+    "targetPosition": [
+      -6.764998005367153
+    ],
+    "targetVelocity": [
+      -1.8799000230731426
+    ],
+    "targetAcceleration": [
+      4.418808264123482
+    ],
+    "maxVelocity": [
+      6.073477642219997
+    ],
+    "maxAcceleration": [
+      5.287545554963075
+    ],
+    "maxJerk": [
+      18.050781997184785
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.939849520762019
+    ],
+    "currentVelocity": [
+      2.0536855928749747
+    ],
+    "currentAcceleration": [
+      -0.6619103340965373
+    ],
+    "targetPosition": [
+      8.86394903298563
+    ],
+    "targetVelocity": [
+      -1.5437317685491507
+    ],
+    "targetAcceleration": [
+      0.9018385496034522
+    ],
+    "maxVelocity": [
+      5.593517564307069
+    ],
+    "maxAcceleration": [
+      3.511122402558443
+    ],
+    "maxJerk": [
+      8.956810031429825
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.184348566257125
+    ],
+    "currentVelocity": [
+      -3.8330370786960657
+    ],
+    "currentAcceleration": [
+      4.685199749596462
+    ],
+    "targetPosition": [
+      -5.14152470460747
+    ],
+    "targetVelocity": [
+      -2.1367372639071376
+    ],
+    "targetAcceleration": [
+      5.69019975897457
+    ],
+    "maxVelocity": [
+      4.211733245950682
+    ],
+    "maxAcceleration": [
+      9.485202934669966
+    ],
+    "maxJerk": [
+      18.069469129757763
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.391976933243999
+    ],
+    "currentVelocity": [
+      2.649192680653066
+    ],
+    "currentAcceleration": [
+      -3.364677501491811
+    ],
+    "targetPosition": [
+      -4.977866155484674
+    ],
+    "targetVelocity": [
+      -1.6135159879392889
+    ],
+    "targetAcceleration": [
+      1.8992383351864417
+    ],
+    "maxVelocity": [
+      2.6887273802308553
+    ],
+    "maxAcceleration": [
+      4.298054653859427
+    ],
+    "maxJerk": [
+      18.051070391921638
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.533154374567438
+    ],
+    "currentVelocity": [
+      4.701312170883153
+    ],
+    "currentAcceleration": [
+      -0.4429104166762503
+    ],
+    "targetPosition": [
+      -0.8556781841862033
+    ],
+    "targetVelocity": [
+      0.2528178732283717
+    ],
+    "targetAcceleration": [
+      -8.382519786799588
+    ],
+    "maxVelocity": [
+      6.439154247298697
+    ],
+    "maxAcceleration": [
+      9.678682536567049
+    ],
+    "maxJerk": [
+      6.651430219525466
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.007526782982831
+    ],
+    "currentVelocity": [
+      5.986647697180181
+    ],
+    "currentAcceleration": [
+      -4.959399264525562
+    ],
+    "targetPosition": [
+      8.865538223736745
+    ],
+    "targetVelocity": [
+      6.6665632172458915
+    ],
+    "targetAcceleration": [
+      -0.6909971142371569
+    ],
+    "maxVelocity": [
+      7.0562940349322
+    ],
+    "maxAcceleration": [
+      7.385532176523603
+    ],
+    "maxJerk": [
+      10.3485221861281
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.1117316878954888
+    ],
+    "currentVelocity": [
+      5.072266787646439
+    ],
+    "currentAcceleration": [
+      -3.89804030124217
+    ],
+    "targetPosition": [
+      -0.9660468733027052
+    ],
+    "targetVelocity": [
+      4.389346181296893
+    ],
+    "targetAcceleration": [
+      -2.9157465428960734
+    ],
+    "maxVelocity": [
+      6.614161316014996
+    ],
+    "maxAcceleration": [
+      8.774046115021095
+    ],
+    "maxJerk": [
+      18.60227281603091
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.9172038883606497
+    ],
+    "currentVelocity": [
+      0.03980771374657088
+    ],
+    "currentAcceleration": [
+      -7.2668088549753715
+    ],
+    "targetPosition": [
+      5.446505600195522
+    ],
+    "targetVelocity": [
+      2.087916393773762
+    ],
+    "targetAcceleration": [
+      1.0558129985068536
+    ],
+    "maxVelocity": [
+      4.442542385082236
+    ],
+    "maxAcceleration": [
+      8.067407359534059
+    ],
+    "maxJerk": [
+      11.778163868892154
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.518505492020875
+    ],
+    "currentVelocity": [
+      -2.468130525285267
+    ],
+    "currentAcceleration": [
+      6.020082749692984
+    ],
+    "targetPosition": [
+      -1.6028481092924878
+    ],
+    "targetVelocity": [
+      -1.3782861728462645
+    ],
+    "targetAcceleration": [
+      2.364334429800131
+    ],
+    "maxVelocity": [
+      7.386841031275873
+    ],
+    "maxAcceleration": [
+      9.065740018525464
+    ],
+    "maxJerk": [
+      15.688188754091225
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.864883241875962
+    ],
+    "currentVelocity": [
+      1.8792780648269298
+    ],
+    "currentAcceleration": [
+      -5.681205278605111
+    ],
+    "targetPosition": [
+      8.543309635682895
+    ],
+    "targetVelocity": [
+      3.820644905195704
+    ],
+    "targetAcceleration": [
+      5.737154791951909
+    ],
+    "maxVelocity": [
+      7.386793945864521
+    ],
+    "maxAcceleration": [
+      6.048237247914441
+    ],
+    "maxJerk": [
+      12.982428957591356
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.739263942838932
+    ],
+    "currentVelocity": [
+      3.831288126896328
+    ],
+    "currentAcceleration": [
+      -6.350803607507572
+    ],
+    "targetPosition": [
+      -8.916826308611263
+    ],
+    "targetVelocity": [
+      1.1455093930982647
+    ],
+    "targetAcceleration": [
+      -5.284044489341255
+    ],
+    "maxVelocity": [
+      5.386181774655866
+    ],
+    "maxAcceleration": [
+      7.616888247378099
+    ],
+    "maxJerk": [
+      18.650790267606332
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.814926428738795
+    ],
+    "currentVelocity": [
+      -0.12680347182319673
+    ],
+    "currentAcceleration": [
+      0.9961112478374021
+    ],
+    "targetPosition": [
+      6.849619514710852
+    ],
+    "targetVelocity": [
+      0.18809243061094083
+    ],
+    "targetAcceleration": [
+      -2.0476238821760213
+    ],
+    "maxVelocity": [
+      2.839617367910373
+    ],
+    "maxAcceleration": [
+      5.399536845576678
+    ],
+    "maxJerk": [
+      13.568019088431479
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.9909627046485614
+    ],
+    "currentVelocity": [
+      5.498383232150393
+    ],
+    "currentAcceleration": [
+      0.04784440641467569
+    ],
+    "targetPosition": [
+      7.585393645067967
+    ],
+    "targetVelocity": [
+      2.410300566763609
+    ],
+    "targetAcceleration": [
+      5.287856065557358
+    ],
+    "maxVelocity": [
+      6.501307385407132
+    ],
+    "maxAcceleration": [
+      6.025802897306503
+    ],
+    "maxJerk": [
+      19.779449762228115
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.184836996726494
+    ],
+    "currentVelocity": [
+      -1.1051390630593803
+    ],
+    "currentAcceleration": [
+      6.362141507452271
+    ],
+    "targetPosition": [
+      -7.860324751920422
+    ],
+    "targetVelocity": [
+      -1.25440809299538
+    ],
+    "targetAcceleration": [
+      -5.365732702498235
+    ],
+    "maxVelocity": [
+      6.799929552550416
+    ],
+    "maxAcceleration": [
+      6.935639414397488
+    ],
+    "maxJerk": [
+      18.3259299857102
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.4849651257065304
+    ],
+    "currentVelocity": [
+      -4.720693368543782
+    ],
+    "currentAcceleration": [
+      -3.1893420709302247
+    ],
+    "targetPosition": [
+      -1.516679307216931
+    ],
+    "targetVelocity": [
+      -0.46942509630717577
+    ],
+    "targetAcceleration": [
+      1.9554077198304292
+    ],
+    "maxVelocity": [
+      6.541529831733362
+    ],
+    "maxAcceleration": [
+      4.350975019482352
+    ],
+    "maxJerk": [
+      8.248703830193525
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.297970840859632
+    ],
+    "currentVelocity": [
+      -0.8472085182200702
+    ],
+    "currentAcceleration": [
+      -5.5435409893848036
+    ],
+    "targetPosition": [
+      -8.066091873099587
+    ],
+    "targetVelocity": [
+      2.2061151852446574
+    ],
+    "targetAcceleration": [
+      4.827670785733387
+    ],
+    "maxVelocity": [
+      4.4514677756288545
+    ],
+    "maxAcceleration": [
+      7.302980492255632
+    ],
+    "maxJerk": [
+      5.215051975141457
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.717316212677664
+    ],
+    "currentVelocity": [
+      -0.07865478543024729
+    ],
+    "currentAcceleration": [
+      -2.358808992339049
+    ],
+    "targetPosition": [
+      -4.540713864472401
+    ],
+    "targetVelocity": [
+      -3.006072516977446
+    ],
+    "targetAcceleration": [
+      4.307467163946369
+    ],
+    "maxVelocity": [
+      5.414111794431883
+    ],
+    "maxAcceleration": [
+      5.389608700285966
+    ],
+    "maxJerk": [
+      11.257001410527742
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.169207317681568
+    ],
+    "currentVelocity": [
+      -3.4496497889894604
+    ],
+    "currentAcceleration": [
+      -2.7332130081068504
+    ],
+    "targetPosition": [
+      -4.474839236508661
+    ],
+    "targetVelocity": [
+      3.1804864333225016
+    ],
+    "targetAcceleration": [
+      0.23025672102478367
+    ],
+    "maxVelocity": [
+      5.531455261108702
+    ],
+    "maxAcceleration": [
+      3.239352021770211
+    ],
+    "maxJerk": [
+      18.977139087617495
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6777997670210318
+    ],
+    "currentVelocity": [
+      2.294546729358882
+    ],
+    "currentAcceleration": [
+      -1.8637825052289587
+    ],
+    "targetPosition": [
+      0.26968490309401183
+    ],
+    "targetVelocity": [
+      1.3087383292905592
+    ],
+    "targetAcceleration": [
+      0.07462103675638776
+    ],
+    "maxVelocity": [
+      2.882726878252564
+    ],
+    "maxAcceleration": [
+      6.305320239729994
+    ],
+    "maxJerk": [
+      18.307191544713667
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.959396264408262
+    ],
+    "currentVelocity": [
+      -6.096407243886405
+    ],
+    "currentAcceleration": [
+      -1.000432953438323
+    ],
+    "targetPosition": [
+      -3.6742809358813737
+    ],
+    "targetVelocity": [
+      1.7759530157171248
+    ],
+    "targetAcceleration": [
+      -3.5211328519822773
+    ],
+    "maxVelocity": [
+      6.483778927629654
+    ],
+    "maxAcceleration": [
+      6.869581949279123
+    ],
+    "maxJerk": [
+      6.207853536934479
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.605093984250626
+    ],
+    "currentVelocity": [
+      1.6841616051960209
+    ],
+    "currentAcceleration": [
+      -4.842525751852989
+    ],
+    "targetPosition": [
+      -3.6326491072307228
+    ],
+    "targetVelocity": [
+      -2.046937745016021
+    ],
+    "targetAcceleration": [
+      -3.6980138162886362
+    ],
+    "maxVelocity": [
+      6.895416127506262
+    ],
+    "maxAcceleration": [
+      6.148570604575803
+    ],
+    "maxJerk": [
+      7.415821621901806
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.214598282284575
+    ],
+    "currentVelocity": [
+      -0.06984366303047551
+    ],
+    "currentAcceleration": [
+      -1.7112454916258288
+    ],
+    "targetPosition": [
+      0.4711391359453021
+    ],
+    "targetVelocity": [
+      -0.017211904848581483
+    ],
+    "targetAcceleration": [
+      -0.6536325668989713
+    ],
+    "maxVelocity": [
+      4.268886225707194
+    ],
+    "maxAcceleration": [
+      6.1100104300996065
+    ],
+    "maxJerk": [
+      16.130910746747055
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.223176438939788
+    ],
+    "currentVelocity": [
+      2.463625767187808
+    ],
+    "currentAcceleration": [
+      -4.147075997421599
+    ],
+    "targetPosition": [
+      0.36882145017912293
+    ],
+    "targetVelocity": [
+      -2.5259723488467487
+    ],
+    "targetAcceleration": [
+      -6.637668459218165
+    ],
+    "maxVelocity": [
+      3.6039193055526644
+    ],
+    "maxAcceleration": [
+      6.816917672499283
+    ],
+    "maxJerk": [
+      18.243406088073954
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.4708505604147035
+    ],
+    "currentVelocity": [
+      0.8144588707707694
+    ],
+    "currentAcceleration": [
+      -5.936461375840537
+    ],
+    "targetPosition": [
+      -1.4756737992340767
+    ],
+    "targetVelocity": [
+      2.3238865465847667
+    ],
+    "targetAcceleration": [
+      3.811161164020998
+    ],
+    "maxVelocity": [
+      5.060207537212011
+    ],
+    "maxAcceleration": [
+      9.58151010789551
+    ],
+    "maxJerk": [
+      6.5959602497575665
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.6140367991664579
+    ],
+    "currentVelocity": [
+      -0.04797914419998506
+    ],
+    "currentAcceleration": [
+      2.736616652859553
+    ],
+    "targetPosition": [
+      9.232505671048742
+    ],
+    "targetVelocity": [
+      -2.77997708524682
+    ],
+    "targetAcceleration": [
+      2.871237669701154
+    ],
+    "maxVelocity": [
+      3.6547199609224874
+    ],
+    "maxAcceleration": [
+      6.301092158636898
+    ],
+    "maxJerk": [
+      16.649503602974804
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.325641485391788
+    ],
+    "currentVelocity": [
+      -5.641627932134126
+    ],
+    "currentAcceleration": [
+      3.795288084461659
+    ],
+    "targetPosition": [
+      4.124408266702327
+    ],
+    "targetVelocity": [
+      -5.246710563317169
+    ],
+    "targetAcceleration": [
+      0.4445159958567215
+    ],
+    "maxVelocity": [
+      6.578073510197693
+    ],
+    "maxAcceleration": [
+      4.0100616320847005
+    ],
+    "maxJerk": [
+      7.01711655717679
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.324500886237834
+    ],
+    "currentVelocity": [
+      1.7341231509882293
+    ],
+    "currentAcceleration": [
+      -4.520846525422841
+    ],
+    "targetPosition": [
+      -4.000736192336136
+    ],
+    "targetVelocity": [
+      2.3903912196037274
+    ],
+    "targetAcceleration": [
+      1.6931860003817523
+    ],
+    "maxVelocity": [
+      3.7281229272053986
+    ],
+    "maxAcceleration": [
+      8.500926155077284
+    ],
+    "maxJerk": [
+      13.25904315900449
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.586851623146009
+    ],
+    "currentVelocity": [
+      -2.1130559644176343
+    ],
+    "currentAcceleration": [
+      5.216194839174301
+    ],
+    "targetPosition": [
+      7.331185414220766
+    ],
+    "targetVelocity": [
+      -1.7997331825914733
+    ],
+    "targetAcceleration": [
+      -3.843250116408365
+    ],
+    "maxVelocity": [
+      2.630504646355533
+    ],
+    "maxAcceleration": [
+      5.2773761562524335
+    ],
+    "maxJerk": [
+      14.169678342328785
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.045262945189981
+    ],
+    "currentVelocity": [
+      -3.9058249114651398
+    ],
+    "currentAcceleration": [
+      3.2473842164903868
+    ],
+    "targetPosition": [
+      -3.210386717235063
+    ],
+    "targetVelocity": [
+      -4.472164879459379
+    ],
+    "targetAcceleration": [
+      -4.228609766749671
+    ],
+    "maxVelocity": [
+      5.2192003651446175
+    ],
+    "maxAcceleration": [
+      4.779503104509152
+    ],
+    "maxJerk": [
+      15.550687101499435
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.42975955505144725
+    ],
+    "currentVelocity": [
+      1.2424739290810183
+    ],
+    "currentAcceleration": [
+      -0.10627042548190158
+    ],
+    "targetPosition": [
+      0.001002197956463391
+    ],
+    "targetVelocity": [
+      2.2640728138154693
+    ],
+    "targetAcceleration": [
+      -0.4184778340122226
+    ],
+    "maxVelocity": [
+      3.1697806754497164
+    ],
+    "maxAcceleration": [
+      3.8676401050488973
+    ],
+    "maxJerk": [
+      13.835116070087096
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.625958475151386
+    ],
+    "currentVelocity": [
+      -2.0709918474677744
+    ],
+    "currentAcceleration": [
+      -0.5860476829927359
+    ],
+    "targetPosition": [
+      1.3703923834000538
+    ],
+    "targetVelocity": [
+      -1.0369421454049552
+    ],
+    "targetAcceleration": [
+      0.1554117422317205
+    ],
+    "maxVelocity": [
+      2.7075041969639018
+    ],
+    "maxAcceleration": [
+      4.389042890964676
+    ],
+    "maxJerk": [
+      14.551034705912144
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.4828620935386425
+    ],
+    "currentVelocity": [
+      1.4951641531122393
+    ],
+    "currentAcceleration": [
+      5.807234021402679
+    ],
+    "targetPosition": [
+      3.389842409185606
+    ],
+    "targetVelocity": [
+      -0.12117166994181794
+    ],
+    "targetAcceleration": [
+      2.2334358705146196
+    ],
+    "maxVelocity": [
+      7.984854105016383
+    ],
+    "maxAcceleration": [
+      6.128262032494091
+    ],
+    "maxJerk": [
+      18.303253187026076
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.172964835017506
+    ],
+    "currentVelocity": [
+      -2.29834862616702
+    ],
+    "currentAcceleration": [
+      -2.4850855021343543
+    ],
+    "targetPosition": [
+      -1.1693915503913708
+    ],
+    "targetVelocity": [
+      -2.9256794194650717
+    ],
+    "targetAcceleration": [
+      -3.6431743990708116
+    ],
+    "maxVelocity": [
+      3.0313619156604625
+    ],
+    "maxAcceleration": [
+      4.218178134188407
+    ],
+    "maxJerk": [
+      12.833792078391518
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.4673319101053437
+    ],
+    "currentVelocity": [
+      4.667700437640027
+    ],
+    "currentAcceleration": [
+      -5.330187931114482
+    ],
+    "targetPosition": [
+      7.2009135762033125
+    ],
+    "targetVelocity": [
+      6.22158551219578
+    ],
+    "targetAcceleration": [
+      2.4956608346681524
+    ],
+    "maxVelocity": [
+      6.7574904088955865
+    ],
+    "maxAcceleration": [
+      7.530870730208255
+    ],
+    "maxJerk": [
+      16.546466502126478
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.654027124382255
+    ],
+    "currentVelocity": [
+      3.685784002320645
+    ],
+    "currentAcceleration": [
+      5.002440147022684
+    ],
+    "targetPosition": [
+      1.0760871996832222
+    ],
+    "targetVelocity": [
+      4.038418712284907
+    ],
+    "targetAcceleration": [
+      -1.418206485897045
+    ],
+    "maxVelocity": [
+      5.358358871177813
+    ],
+    "maxAcceleration": [
+      7.299968706300909
+    ],
+    "maxJerk": [
+      8.389033808964248
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.49578188294163716
+    ],
+    "currentVelocity": [
+      5.397426427851542
+    ],
+    "currentAcceleration": [
+      -3.996300899943046
+    ],
+    "targetPosition": [
+      -5.999350448433489
+    ],
+    "targetVelocity": [
+      3.6955209759214416
+    ],
+    "targetAcceleration": [
+      -6.434794457210197
+    ],
+    "maxVelocity": [
+      5.720177888511682
+    ],
+    "maxAcceleration": [
+      9.122030413832563
+    ],
+    "maxJerk": [
+      19.90852242888552
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.365884338662687
+    ],
+    "currentVelocity": [
+      2.3833793534478445
+    ],
+    "currentAcceleration": [
+      3.995247087543346
+    ],
+    "targetPosition": [
+      -5.416250194273136
+    ],
+    "targetVelocity": [
+      -1.9369947290631266
+    ],
+    "targetAcceleration": [
+      5.19117702118008
+    ],
+    "maxVelocity": [
+      2.8300848937985648
+    ],
+    "maxAcceleration": [
+      7.797861616564402
+    ],
+    "maxJerk": [
+      19.00068620436227
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.228748191806046
+    ],
+    "currentVelocity": [
+      2.2171178673236778
+    ],
+    "currentAcceleration": [
+      -3.104540447010063
+    ],
+    "targetPosition": [
+      7.239011937592348
+    ],
+    "targetVelocity": [
+      1.913907795165339
+    ],
+    "targetAcceleration": [
+      4.330806128552343
+    ],
+    "maxVelocity": [
+      5.787183568465531
+    ],
+    "maxAcceleration": [
+      7.425048159523747
+    ],
+    "maxJerk": [
+      8.844012646730118
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.958716324608357
+    ],
+    "currentVelocity": [
+      1.7985121076186683
+    ],
+    "currentAcceleration": [
+      -0.5764858209168073
+    ],
+    "targetPosition": [
+      1.8349344038180995
+    ],
+    "targetVelocity": [
+      -1.4174227461612556
+    ],
+    "targetAcceleration": [
+      -4.5678540238126795
+    ],
+    "maxVelocity": [
+      5.961993696147229
+    ],
+    "maxAcceleration": [
+      4.596829801861849
+    ],
+    "maxJerk": [
+      18.881178435910236
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.653046163852206
+    ],
+    "currentVelocity": [
+      0.07588190997434996
+    ],
+    "currentAcceleration": [
+      4.877560969472821
+    ],
+    "targetPosition": [
+      -7.439100079444372
+    ],
+    "targetVelocity": [
+      0.2949546912755361
+    ],
+    "targetAcceleration": [
+      -0.5140412668132512
+    ],
+    "maxVelocity": [
+      4.2206092240832715
+    ],
+    "maxAcceleration": [
+      6.950601588761371
+    ],
+    "maxJerk": [
+      5.012395983382033
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.41709757137537373
+    ],
+    "currentVelocity": [
+      -0.6563374310011802
+    ],
+    "currentAcceleration": [
+      -0.915341047869445
+    ],
+    "targetPosition": [
+      6.358779280490179
+    ],
+    "targetVelocity": [
+      -2.4569709107901234
+    ],
+    "targetAcceleration": [
+      -8.689595194774194
+    ],
+    "maxVelocity": [
+      4.65635849946019
+    ],
+    "maxAcceleration": [
+      9.222267308801355
+    ],
+    "maxJerk": [
+      13.95008687725599
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.147695868842696
+    ],
+    "currentVelocity": [
+      2.5648638715588836
+    ],
+    "currentAcceleration": [
+      4.43716443312051
+    ],
+    "targetPosition": [
+      -7.627336877651825
+    ],
+    "targetVelocity": [
+      5.269077217205274
+    ],
+    "targetAcceleration": [
+      3.377961697698061
+    ],
+    "maxVelocity": [
+      5.4137083688928955
+    ],
+    "maxAcceleration": [
+      7.594821529438852
+    ],
+    "maxJerk": [
+      7.361153860283425
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.496566380871666
+    ],
+    "currentVelocity": [
+      -1.6848662155108571
+    ],
+    "currentAcceleration": [
+      8.574836059160958
+    ],
+    "targetPosition": [
+      8.060693107862654
+    ],
+    "targetVelocity": [
+      -3.2253565739099987
+    ],
+    "targetAcceleration": [
+      2.4273123912360983
+    ],
+    "maxVelocity": [
+      5.56280741410994
+    ],
+    "maxAcceleration": [
+      8.764635353023795
+    ],
+    "maxJerk": [
+      18.128993241811372
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.21449554783172076
+    ],
+    "currentVelocity": [
+      6.8461596909965365
+    ],
+    "currentAcceleration": [
+      -0.17667723175098082
+    ],
+    "targetPosition": [
+      1.0359681228424318
+    ],
+    "targetVelocity": [
+      -4.660655324286236
+    ],
+    "targetAcceleration": [
+      4.1391961960052
+    ],
+    "maxVelocity": [
+      7.964344115917669
+    ],
+    "maxAcceleration": [
+      9.179241386546243
+    ],
+    "maxJerk": [
+      19.445379616989165
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.148088235757182
+    ],
+    "currentVelocity": [
+      -0.7063817634119633
+    ],
+    "currentAcceleration": [
+      -4.237487339575976
+    ],
+    "targetPosition": [
+      4.474802463068775
+    ],
+    "targetVelocity": [
+      1.172272530611202
+    ],
+    "targetAcceleration": [
+      -1.0327675092150441
+    ],
+    "maxVelocity": [
+      2.2150373391160745
+    ],
+    "maxAcceleration": [
+      4.330096121201491
+    ],
+    "maxJerk": [
+      14.995055837010298
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.8989479495390977
+    ],
+    "currentVelocity": [
+      -4.970448680307678
+    ],
+    "currentAcceleration": [
+      0.5991457671943117
+    ],
+    "targetPosition": [
+      -0.12333861559240056
+    ],
+    "targetVelocity": [
+      -2.054079966067649
+    ],
+    "targetAcceleration": [
+      -3.998242126641337
+    ],
+    "maxVelocity": [
+      5.099658747720369
+    ],
+    "maxAcceleration": [
+      5.661295437317374
+    ],
+    "maxJerk": [
+      17.884678324140705
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.448315582670805
+    ],
+    "currentVelocity": [
+      -4.361588842531042
+    ],
+    "currentAcceleration": [
+      4.606287474800858
+    ],
+    "targetPosition": [
+      -2.777036332508871
+    ],
+    "targetVelocity": [
+      4.43190259289036
+    ],
+    "targetAcceleration": [
+      -1.7803982460431045
+    ],
+    "maxVelocity": [
+      5.034430756505042
+    ],
+    "maxAcceleration": [
+      5.159808485507526
+    ],
+    "maxJerk": [
+      9.864598260227528
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.192664348619056
+    ],
+    "currentVelocity": [
+      -4.3413133586763815
+    ],
+    "currentAcceleration": [
+      -3.9236263339410193
+    ],
+    "targetPosition": [
+      -7.180477956783817
+    ],
+    "targetVelocity": [
+      6.852729037883761
+    ],
+    "targetAcceleration": [
+      6.075626717275318
+    ],
+    "maxVelocity": [
+      7.300055552300669
+    ],
+    "maxAcceleration": [
+      9.291349418131606
+    ],
+    "maxJerk": [
+      16.289335975192202
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.22992712551099
+    ],
+    "currentVelocity": [
+      1.5677475092315207
+    ],
+    "currentAcceleration": [
+      1.6440295589728446
+    ],
+    "targetPosition": [
+      -5.501214511311834
+    ],
+    "targetVelocity": [
+      -1.4928035630072896
+    ],
+    "targetAcceleration": [
+      0.6337478262767462
+    ],
+    "maxVelocity": [
+      5.1232079398780375
+    ],
+    "maxAcceleration": [
+      7.824129712515228
+    ],
+    "maxJerk": [
+      10.319365504881624
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.22432081411064
+    ],
+    "currentVelocity": [
+      -0.441612831311045
+    ],
+    "currentAcceleration": [
+      3.469101619427236
+    ],
+    "targetPosition": [
+      -6.171568139163551
+    ],
+    "targetVelocity": [
+      -1.3780756092458426
+    ],
+    "targetAcceleration": [
+      2.7969471974452578
+    ],
+    "maxVelocity": [
+      3.4970301324576893
+    ],
+    "maxAcceleration": [
+      4.00799051612821
+    ],
+    "maxJerk": [
+      16.48381080694903
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.3167507270422085
+    ],
+    "currentVelocity": [
+      0.45735877855438156
+    ],
+    "currentAcceleration": [
+      -2.77140965549441
+    ],
+    "targetPosition": [
+      -6.8684497155424085
+    ],
+    "targetVelocity": [
+      -0.6978420102446616
+    ],
+    "targetAcceleration": [
+      1.9834480206644827
+    ],
+    "maxVelocity": [
+      3.102255249589941
+    ],
+    "maxAcceleration": [
+      8.928801375276851
+    ],
+    "maxJerk": [
+      6.96312194881465
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.006875458763521
+    ],
+    "currentVelocity": [
+      1.0350360653681916
+    ],
+    "currentAcceleration": [
+      6.120669007515273
+    ],
+    "targetPosition": [
+      -3.3917923615525147
+    ],
+    "targetVelocity": [
+      -0.055186690862297105
+    ],
+    "targetAcceleration": [
+      6.435404971929454
+    ],
+    "maxVelocity": [
+      2.5263817841472505
+    ],
+    "maxAcceleration": [
+      9.22243168407282
+    ],
+    "maxJerk": [
+      13.607452899860117
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.2326253332283468
+    ],
+    "currentVelocity": [
+      2.1149123427781173
+    ],
+    "currentAcceleration": [
+      -2.0243910567745926
+    ],
+    "targetPosition": [
+      0.9031488573746334
+    ],
+    "targetVelocity": [
+      6.600171619955384
+    ],
+    "targetAcceleration": [
+      -2.3288028011218884
+    ],
+    "maxVelocity": [
+      7.159007947615464
+    ],
+    "maxAcceleration": [
+      5.264120251976022
+    ],
+    "maxJerk": [
+      9.870994812974576
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.822449893281323
+    ],
+    "currentVelocity": [
+      -4.531197545297434
+    ],
+    "currentAcceleration": [
+      -1.3188886357272551
+    ],
+    "targetPosition": [
+      6.4925757347239745
+    ],
+    "targetVelocity": [
+      4.694674061263107
+    ],
+    "targetAcceleration": [
+      7.934550487951604
+    ],
+    "maxVelocity": [
+      4.858254511782101
+    ],
+    "maxAcceleration": [
+      9.438798282337526
+    ],
+    "maxJerk": [
+      18.063603067265795
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.075554047799342
+    ],
+    "currentVelocity": [
+      -0.6302301069099756
+    ],
+    "currentAcceleration": [
+      3.3205674116622426
+    ],
+    "targetPosition": [
+      -1.2624534780203245
+    ],
+    "targetVelocity": [
+      -2.6411202338974795
+    ],
+    "targetAcceleration": [
+      -5.771711219848459
+    ],
+    "maxVelocity": [
+      2.831203688599886
+    ],
+    "maxAcceleration": [
+      9.728147131242533
+    ],
+    "maxJerk": [
+      16.902955639667105
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.847374938440261
+    ],
+    "currentVelocity": [
+      -3.5836217953764873
+    ],
+    "currentAcceleration": [
+      6.508165490965702
+    ],
+    "targetPosition": [
+      3.118246661283635
+    ],
+    "targetVelocity": [
+      2.8726342545438524
+    ],
+    "targetAcceleration": [
+      -4.0647456403604085
+    ],
+    "maxVelocity": [
+      6.415407400685972
+    ],
+    "maxAcceleration": [
+      8.50333269758654
+    ],
+    "maxJerk": [
+      6.35576764979918
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.8291371321997083
+    ],
+    "currentVelocity": [
+      6.597831782799248
+    ],
+    "currentAcceleration": [
+      -4.715581788389152
+    ],
+    "targetPosition": [
+      -6.535301899336712
+    ],
+    "targetVelocity": [
+      -4.821452360986112
+    ],
+    "targetAcceleration": [
+      1.937313073115991
+    ],
+    "maxVelocity": [
+      7.792192322408211
+    ],
+    "maxAcceleration": [
+      8.044706522157952
+    ],
+    "maxJerk": [
+      15.932705534917186
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.205117988955982
+    ],
+    "currentVelocity": [
+      2.1605063441571506
+    ],
+    "currentAcceleration": [
+      -6.964375631737476
+    ],
+    "targetPosition": [
+      8.799863597603665
+    ],
+    "targetVelocity": [
+      2.196500375514084
+    ],
+    "targetAcceleration": [
+      0.001929456097730764
+    ],
+    "maxVelocity": [
+      3.8924149743942698
+    ],
+    "maxAcceleration": [
+      7.399469377702749
+    ],
+    "maxJerk": [
+      15.44558119948902
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.154777904390695
+    ],
+    "currentVelocity": [
+      1.415179697932461
+    ],
+    "currentAcceleration": [
+      -2.694256956215999
+    ],
+    "targetPosition": [
+      -9.409148549181953
+    ],
+    "targetVelocity": [
+      -2.6172978096479547
+    ],
+    "targetAcceleration": [
+      1.5032516138284189
+    ],
+    "maxVelocity": [
+      3.6803583005853056
+    ],
+    "maxAcceleration": [
+      3.9709968491727263
+    ],
+    "maxJerk": [
+      18.978070793954437
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.200673611684543
+    ],
+    "currentVelocity": [
+      0.9831342585931919
+    ],
+    "currentAcceleration": [
+      2.074305197966239
+    ],
+    "targetPosition": [
+      -1.7024471132918038
+    ],
+    "targetVelocity": [
+      -1.9128734665108218
+    ],
+    "targetAcceleration": [
+      -1.0897026625388953
+    ],
+    "maxVelocity": [
+      2.631624942061793
+    ],
+    "maxAcceleration": [
+      3.950610657080059
+    ],
+    "maxJerk": [
+      17.492262999711805
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.351133751345831
+    ],
+    "currentVelocity": [
+      2.294139390639284
+    ],
+    "currentAcceleration": [
+      -2.2482842978304536
+    ],
+    "targetPosition": [
+      -8.806876909215884
+    ],
+    "targetVelocity": [
+      3.2247734053138117
+    ],
+    "targetAcceleration": [
+      4.580522882233415
+    ],
+    "maxVelocity": [
+      3.5398783936018585
+    ],
+    "maxAcceleration": [
+      6.4824859467622495
+    ],
+    "maxJerk": [
+      16.784786592479193
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.5304987688024472
+    ],
+    "currentVelocity": [
+      2.7244128909561014
+    ],
+    "currentAcceleration": [
+      -1.0939315446071216
+    ],
+    "targetPosition": [
+      -0.18211092885830027
+    ],
+    "targetVelocity": [
+      0.852425338847548
+    ],
+    "targetAcceleration": [
+      5.4480694299351065
+    ],
+    "maxVelocity": [
+      3.8745830110691846
+    ],
+    "maxAcceleration": [
+      7.7700420354837885
+    ],
+    "maxJerk": [
+      17.36908658920231
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.23638907520419
+    ],
+    "currentVelocity": [
+      0.33236303025418845
+    ],
+    "currentAcceleration": [
+      -1.480267519248002
+    ],
+    "targetPosition": [
+      -3.02093472330907
+    ],
+    "targetVelocity": [
+      5.070180603382503
+    ],
+    "targetAcceleration": [
+      -2.8870864851393767
+    ],
+    "maxVelocity": [
+      5.894217432541304
+    ],
+    "maxAcceleration": [
+      4.005039775013537
+    ],
+    "maxJerk": [
+      10.483023492979084
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.187091823171993
+    ],
+    "currentVelocity": [
+      1.1151382214386398
+    ],
+    "currentAcceleration": [
+      4.898214850881252
+    ],
+    "targetPosition": [
+      -5.337161615850265
+    ],
+    "targetVelocity": [
+      -1.1789563194258297
+    ],
+    "targetAcceleration": [
+      1.2284465240924343
+    ],
+    "maxVelocity": [
+      4.352964369315609
+    ],
+    "maxAcceleration": [
+      6.90716871095212
+    ],
+    "maxJerk": [
+      17.280044546962436
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.208401275354635
+    ],
+    "currentVelocity": [
+      -0.48329951843415486
+    ],
+    "currentAcceleration": [
+      6.928510333627411
+    ],
+    "targetPosition": [
+      1.7165667284839614
+    ],
+    "targetVelocity": [
+      0.9236979917468138
+    ],
+    "targetAcceleration": [
+      2.4137319215946675
+    ],
+    "maxVelocity": [
+      2.8777410723988286
+    ],
+    "maxAcceleration": [
+      9.05414593273057
+    ],
+    "maxJerk": [
+      8.160430333934482
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.88462898668862
+    ],
+    "currentVelocity": [
+      -0.5467074697933016
+    ],
+    "currentAcceleration": [
+      -4.157717332549625
+    ],
+    "targetPosition": [
+      -2.813785387686309
+    ],
+    "targetVelocity": [
+      0.07790603406284369
+    ],
+    "targetAcceleration": [
+      -1.1844626692435436
+    ],
+    "maxVelocity": [
+      6.319680750983376
+    ],
+    "maxAcceleration": [
+      4.1884483497641565
+    ],
+    "maxJerk": [
+      11.398944168864283
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.781390943954851
+    ],
+    "currentVelocity": [
+      -3.810655710809957
+    ],
+    "currentAcceleration": [
+      -2.627319334169567
+    ],
+    "targetPosition": [
+      -1.8537404219421312
+    ],
+    "targetVelocity": [
+      4.316549741655266
+    ],
+    "targetAcceleration": [
+      -1.8728898132742946
+    ],
+    "maxVelocity": [
+      5.123511881493836
+    ],
+    "maxAcceleration": [
+      3.6926412155273582
+    ],
+    "maxJerk": [
+      9.733653278056071
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.460360423825829
+    ],
+    "currentVelocity": [
+      -3.805697064250758
+    ],
+    "currentAcceleration": [
+      -1.7919644432345718
+    ],
+    "targetPosition": [
+      3.9260110930000245
+    ],
+    "targetVelocity": [
+      3.707131737231613
+    ],
+    "targetAcceleration": [
+      -1.693756273907944
+    ],
+    "maxVelocity": [
+      7.4408174186403215
+    ],
+    "maxAcceleration": [
+      5.310489088995009
+    ],
+    "maxJerk": [
+      6.761737928341757
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.5064253955123075
+    ],
+    "currentVelocity": [
+      0.01819389864391141
+    ],
+    "currentAcceleration": [
+      -3.273402015788749
+    ],
+    "targetPosition": [
+      -5.673510225777944
+    ],
+    "targetVelocity": [
+      -0.45964569588041515
+    ],
+    "targetAcceleration": [
+      -4.3289659330293535
+    ],
+    "maxVelocity": [
+      3.46168194921916
+    ],
+    "maxAcceleration": [
+      6.475459493235958
+    ],
+    "maxJerk": [
+      11.90800457020524
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.990413994512091
+    ],
+    "currentVelocity": [
+      0.5435292137799248
+    ],
+    "currentAcceleration": [
+      0.8711597621886527
+    ],
+    "targetPosition": [
+      0.02208860684299907
+    ],
+    "targetVelocity": [
+      -1.6138784796131045
+    ],
+    "targetAcceleration": [
+      -1.3150971978003563
+    ],
+    "maxVelocity": [
+      2.0733679404665395
+    ],
+    "maxAcceleration": [
+      3.4478692639286703
+    ],
+    "maxJerk": [
+      15.621962188392123
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.19875799207878941
+    ],
+    "currentVelocity": [
+      -0.060398785924637544
+    ],
+    "currentAcceleration": [
+      2.7616077086831745
+    ],
+    "targetPosition": [
+      3.612280292835937
+    ],
+    "targetVelocity": [
+      -5.2261962139880955
+    ],
+    "targetAcceleration": [
+      -2.6990121461797267
+    ],
+    "maxVelocity": [
+      7.034266025434986
+    ],
+    "maxAcceleration": [
+      3.2422192798267973
+    ],
+    "maxJerk": [
+      16.189516774757905
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.017304935496778
+    ],
+    "currentVelocity": [
+      4.096805970990641
+    ],
+    "currentAcceleration": [
+      -5.169578612626479
+    ],
+    "targetPosition": [
+      -4.51456938728811
+    ],
+    "targetVelocity": [
+      3.9446817591179286
+    ],
+    "targetAcceleration": [
+      -0.8766523150323318
+    ],
+    "maxVelocity": [
+      5.678614599092102
+    ],
+    "maxAcceleration": [
+      6.6552827216164445
+    ],
+    "maxJerk": [
+      11.127803532273411
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.2907158647562476
+    ],
+    "currentVelocity": [
+      -4.042952412690705
+    ],
+    "currentAcceleration": [
+      -1.0740253478821526
+    ],
+    "targetPosition": [
+      7.431384765237272
+    ],
+    "targetVelocity": [
+      3.1923778314494715
+    ],
+    "targetAcceleration": [
+      2.819410811079778
+    ],
+    "maxVelocity": [
+      4.193964005413749
+    ],
+    "maxAcceleration": [
+      3.8815939709511253
+    ],
+    "maxJerk": [
+      19.235238331231482
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.186109268136278
+    ],
+    "currentVelocity": [
+      0.7895387402665426
+    ],
+    "currentAcceleration": [
+      5.637599625656188
+    ],
+    "targetPosition": [
+      9.337918359266467
+    ],
+    "targetVelocity": [
+      -6.362900777347186
+    ],
+    "targetAcceleration": [
+      -3.6132905296991673
+    ],
+    "maxVelocity": [
+      6.430027629987025
+    ],
+    "maxAcceleration": [
+      7.052729011527328
+    ],
+    "maxJerk": [
+      12.241454434315392
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.601830116496583
+    ],
+    "currentVelocity": [
+      0.3762465744406551
+    ],
+    "currentAcceleration": [
+      5.481530838580667
+    ],
+    "targetPosition": [
+      4.060193923529404
+    ],
+    "targetVelocity": [
+      0.25050456296611534
+    ],
+    "targetAcceleration": [
+      -3.1788387442101858
+    ],
+    "maxVelocity": [
+      2.3180454974398694
+    ],
+    "maxAcceleration": [
+      8.243077127385561
+    ],
+    "maxJerk": [
+      13.648656521355544
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.12232949277497
+    ],
+    "currentVelocity": [
+      -1.518732242307658
+    ],
+    "currentAcceleration": [
+      6.764218456651288
+    ],
+    "targetPosition": [
+      -1.495654449659039
+    ],
+    "targetVelocity": [
+      -1.0101427602612023
+    ],
+    "targetAcceleration": [
+      -6.0556322580458
+    ],
+    "maxVelocity": [
+      2.0751124414866817
+    ],
+    "maxAcceleration": [
+      6.99277530195979
+    ],
+    "maxJerk": [
+      19.564340061683687
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.0246078154261236
+    ],
+    "currentVelocity": [
+      2.9504360214288976
+    ],
+    "currentAcceleration": [
+      -3.0057267018426357
+    ],
+    "targetPosition": [
+      -8.391055533806542
+    ],
+    "targetVelocity": [
+      3.3203344144768305
+    ],
+    "targetAcceleration": [
+      1.698192120561413
+    ],
+    "maxVelocity": [
+      5.620691722615328
+    ],
+    "maxAcceleration": [
+      3.205748195491223
+    ],
+    "maxJerk": [
+      10.191614515799374
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.568324057175582
+    ],
+    "currentVelocity": [
+      -1.9500615781280368
+    ],
+    "currentAcceleration": [
+      0.5543888786309941
+    ],
+    "targetPosition": [
+      0.25091271575273844
+    ],
+    "targetVelocity": [
+      4.699511256550574
+    ],
+    "targetAcceleration": [
+      -4.269017800834229
+    ],
+    "maxVelocity": [
+      6.384148303348875
+    ],
+    "maxAcceleration": [
+      4.955137737304313
+    ],
+    "maxJerk": [
+      7.176897321408098
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.036297896016389
+    ],
+    "currentVelocity": [
+      -1.102591640939039
+    ],
+    "currentAcceleration": [
+      1.5547584343217151
+    ],
+    "targetPosition": [
+      5.480150945660796
+    ],
+    "targetVelocity": [
+      1.5840108744994446
+    ],
+    "targetAcceleration": [
+      -0.545963762407049
+    ],
+    "maxVelocity": [
+      5.3533963447330875
+    ],
+    "maxAcceleration": [
+      5.976880006751024
+    ],
+    "maxJerk": [
+      8.622605409523448
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.110927365029166
+    ],
+    "currentVelocity": [
+      -0.5913039996962275
+    ],
+    "currentAcceleration": [
+      3.1057670345791317
+    ],
+    "targetPosition": [
+      1.8383502438168904
+    ],
+    "targetVelocity": [
+      1.1620730890180697
+    ],
+    "targetAcceleration": [
+      4.316333875348946
+    ],
+    "maxVelocity": [
+      2.927603278000009
+    ],
+    "maxAcceleration": [
+      5.2345202516957565
+    ],
+    "maxJerk": [
+      12.012994520518761
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.107089279138524
+    ],
+    "currentVelocity": [
+      5.727797524026964
+    ],
+    "currentAcceleration": [
+      4.236002845392779
+    ],
+    "targetPosition": [
+      -1.0638291208805573
+    ],
+    "targetVelocity": [
+      3.4884240691601276
+    ],
+    "targetAcceleration": [
+      8.308127541932043
+    ],
+    "maxVelocity": [
+      6.876377200747188
+    ],
+    "maxAcceleration": [
+      9.512559506189438
+    ],
+    "maxJerk": [
+      9.817020364194983
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.3772627066899261
+    ],
+    "currentVelocity": [
+      5.399043371852546
+    ],
+    "currentAcceleration": [
+      -2.5115605558953247
+    ],
+    "targetPosition": [
+      9.197353751691892
+    ],
+    "targetVelocity": [
+      3.575633465137681
+    ],
+    "targetAcceleration": [
+      0.8765072296801426
+    ],
+    "maxVelocity": [
+      5.588285489645047
+    ],
+    "maxAcceleration": [
+      4.865960065244393
+    ],
+    "maxJerk": [
+      18.12837092653377
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.710857008922424
+    ],
+    "currentVelocity": [
+      -0.4518419526819404
+    ],
+    "currentAcceleration": [
+      -3.706437269376259
+    ],
+    "targetPosition": [
+      4.250867545674772
+    ],
+    "targetVelocity": [
+      -4.025717347202887
+    ],
+    "targetAcceleration": [
+      0.39341384582338
+    ],
+    "maxVelocity": [
+      7.239462917167815
+    ],
+    "maxAcceleration": [
+      4.163258678956294
+    ],
+    "maxJerk": [
+      15.55047783225935
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.279120397665309
+    ],
+    "currentVelocity": [
+      0.7883913097286364
+    ],
+    "currentAcceleration": [
+      4.151241906259424
+    ],
+    "targetPosition": [
+      8.487202577247295
+    ],
+    "targetVelocity": [
+      1.070420473097478
+    ],
+    "targetAcceleration": [
+      0.8481425606247228
+    ],
+    "maxVelocity": [
+      2.9745960166666636
+    ],
+    "maxAcceleration": [
+      6.809976918568285
+    ],
+    "maxJerk": [
+      13.78513261187451
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.753172498969313
+    ],
+    "currentVelocity": [
+      1.3289436921627709
+    ],
+    "currentAcceleration": [
+      2.749128893723105
+    ],
+    "targetPosition": [
+      -6.985420560736959
+    ],
+    "targetVelocity": [
+      -1.7155327919103405
+    ],
+    "targetAcceleration": [
+      1.755705505965797
+    ],
+    "maxVelocity": [
+      3.2323685753805855
+    ],
+    "maxAcceleration": [
+      4.265591423849664
+    ],
+    "maxJerk": [
+      15.429636007628538
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.3662874364292019
+    ],
+    "currentVelocity": [
+      4.436644402391878
+    ],
+    "currentAcceleration": [
+      -7.8914622817263345
+    ],
+    "targetPosition": [
+      -1.7609322597095378
+    ],
+    "targetVelocity": [
+      5.087698639007502
+    ],
+    "targetAcceleration": [
+      -0.7480503242806193
+    ],
+    "maxVelocity": [
+      6.032661517542061
+    ],
+    "maxAcceleration": [
+      8.537454254761784
+    ],
+    "maxJerk": [
+      11.60056605736258
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.908566255669811
+    ],
+    "currentVelocity": [
+      2.1009059343851844
+    ],
+    "currentAcceleration": [
+      -4.200022999412029
+    ],
+    "targetPosition": [
+      3.726741029954974
+    ],
+    "targetVelocity": [
+      -0.37566570523465526
+    ],
+    "targetAcceleration": [
+      -0.32978984875820494
+    ],
+    "maxVelocity": [
+      2.7533268575276324
+    ],
+    "maxAcceleration": [
+      9.762889403417391
+    ],
+    "maxJerk": [
+      9.342530702973148
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.271882227780626
+    ],
+    "currentVelocity": [
+      -2.578378927888033
+    ],
+    "currentAcceleration": [
+      -2.5120385547729214
+    ],
+    "targetPosition": [
+      -4.327978935003247
+    ],
+    "targetVelocity": [
+      -0.3816238993020793
+    ],
+    "targetAcceleration": [
+      2.590393800726863
+    ],
+    "maxVelocity": [
+      7.9657155601388165
+    ],
+    "maxAcceleration": [
+      8.389164979625024
+    ],
+    "maxJerk": [
+      7.390739079534593
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.028109591660575
+    ],
+    "currentVelocity": [
+      1.001516653281497
+    ],
+    "currentAcceleration": [
+      3.102442815452374
+    ],
+    "targetPosition": [
+      5.455006098414826
+    ],
+    "targetVelocity": [
+      -2.8563037302067205
+    ],
+    "targetAcceleration": [
+      4.068177037685436
+    ],
+    "maxVelocity": [
+      7.273127052656092
+    ],
+    "maxAcceleration": [
+      8.759520752884736
+    ],
+    "maxJerk": [
+      6.14627209124381
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.109716596387212
+    ],
+    "currentVelocity": [
+      -3.4622245490235435
+    ],
+    "currentAcceleration": [
+      -0.673546479646788
+    ],
+    "targetPosition": [
+      -2.5234185422696527
+    ],
+    "targetVelocity": [
+      -3.2962954346194957
+    ],
+    "targetAcceleration": [
+      1.0176196196008815
+    ],
+    "maxVelocity": [
+      7.339623115919589
+    ],
+    "maxAcceleration": [
+      3.3035914400200594
+    ],
+    "maxJerk": [
+      9.982386215421316
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.39998356007010116
+    ],
+    "currentVelocity": [
+      5.334934855368337
+    ],
+    "currentAcceleration": [
+      0.5083102387916023
+    ],
+    "targetPosition": [
+      -7.595375895950093
+    ],
+    "targetVelocity": [
+      1.892624988006384
+    ],
+    "targetAcceleration": [
+      -3.3671234860351547
+    ],
+    "maxVelocity": [
+      6.56013096540765
+    ],
+    "maxAcceleration": [
+      3.52914085660921
+    ],
+    "maxJerk": [
+      15.201337558199228
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.418282596419575
+    ],
+    "currentVelocity": [
+      2.473027244356305
+    ],
+    "currentAcceleration": [
+      4.036466995932722
+    ],
+    "targetPosition": [
+      2.396341989834694
+    ],
+    "targetVelocity": [
+      -0.6176374959637956
+    ],
+    "targetAcceleration": [
+      5.527957624964284
+    ],
+    "maxVelocity": [
+      7.671505057775179
+    ],
+    "maxAcceleration": [
+      6.429704785254824
+    ],
+    "maxJerk": [
+      18.137581659900576
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.714509713412069
+    ],
+    "currentVelocity": [
+      3.3824455837772858
+    ],
+    "currentAcceleration": [
+      -6.91938991077363
+    ],
+    "targetPosition": [
+      -7.622839976321596
+    ],
+    "targetVelocity": [
+      5.304099435522551
+    ],
+    "targetAcceleration": [
+      -0.32358900698865956
+    ],
+    "maxVelocity": [
+      6.36608282596849
+    ],
+    "maxAcceleration": [
+      7.311801782325062
+    ],
+    "maxJerk": [
+      8.169966685129355
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7331998741499692
+    ],
+    "currentVelocity": [
+      -4.2234525139230685
+    ],
+    "currentAcceleration": [
+      -0.3860396258136771
+    ],
+    "targetPosition": [
+      3.6096885993574723
+    ],
+    "targetVelocity": [
+      -4.765476229737153
+    ],
+    "targetAcceleration": [
+      -1.684399143883888
+    ],
+    "maxVelocity": [
+      5.155319683258487
+    ],
+    "maxAcceleration": [
+      4.305484662411649
+    ],
+    "maxJerk": [
+      19.734457036513643
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.6662317114799894
+    ],
+    "currentVelocity": [
+      1.8740851054801002
+    ],
+    "currentAcceleration": [
+      3.2995728024550157
+    ],
+    "targetPosition": [
+      2.3963014226693566
+    ],
+    "targetVelocity": [
+      -0.34117957427563717
+    ],
+    "targetAcceleration": [
+      0.16552832105270632
+    ],
+    "maxVelocity": [
+      4.7374852238720155
+    ],
+    "maxAcceleration": [
+      4.036358914561013
+    ],
+    "maxJerk": [
+      8.71469852812571
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.005584575738692976
+    ],
+    "currentVelocity": [
+      -0.6449806451131277
+    ],
+    "currentAcceleration": [
+      1.2447070908648614
+    ],
+    "targetPosition": [
+      2.687340759034738
+    ],
+    "targetVelocity": [
+      3.367521616926183
+    ],
+    "targetAcceleration": [
+      -5.577628723809308
+    ],
+    "maxVelocity": [
+      5.107093239255681
+    ],
+    "maxAcceleration": [
+      5.839596763181921
+    ],
+    "maxJerk": [
+      11.46123165094609
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0284185555071996
+    ],
+    "currentVelocity": [
+      -3.450228220222047
+    ],
+    "currentAcceleration": [
+      -0.9546738406464428
+    ],
+    "targetPosition": [
+      -2.6877498849746484
+    ],
+    "targetVelocity": [
+      0.2432261602514263
+    ],
+    "targetAcceleration": [
+      5.261827867276008
+    ],
+    "maxVelocity": [
+      7.0899253371470685
+    ],
+    "maxAcceleration": [
+      7.202568645478042
+    ],
+    "maxJerk": [
+      12.459378664657335
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.7476996746287856
+    ],
+    "currentVelocity": [
+      4.840567315885447
+    ],
+    "currentAcceleration": [
+      -0.83886000639699
+    ],
+    "targetPosition": [
+      3.1506941204579775
+    ],
+    "targetVelocity": [
+      -2.932777781232046
+    ],
+    "targetAcceleration": [
+      1.4515957262638866
+    ],
+    "maxVelocity": [
+      7.018468432246798
+    ],
+    "maxAcceleration": [
+      3.351125618246151
+    ],
+    "maxJerk": [
+      11.879215174491051
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.342934573038047
+    ],
+    "currentVelocity": [
+      1.3975166807651878
+    ],
+    "currentAcceleration": [
+      -4.934792979737985
+    ],
+    "targetPosition": [
+      -0.9846021846036841
+    ],
+    "targetVelocity": [
+      1.1612659813035329
+    ],
+    "targetAcceleration": [
+      -5.398344039083595
+    ],
+    "maxVelocity": [
+      4.019486473863271
+    ],
+    "maxAcceleration": [
+      7.911180421885964
+    ],
+    "maxJerk": [
+      17.199187304686475
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.142160792261381
+    ],
+    "currentVelocity": [
+      -2.071350938946806
+    ],
+    "currentAcceleration": [
+      -4.189393484339826
+    ],
+    "targetPosition": [
+      6.96775939693935
+    ],
+    "targetVelocity": [
+      3.933664817398782
+    ],
+    "targetAcceleration": [
+      5.397262226657981
+    ],
+    "maxVelocity": [
+      5.64642770717311
+    ],
+    "maxAcceleration": [
+      8.008649407961386
+    ],
+    "maxJerk": [
+      19.99438544964702
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.486959582130401
+    ],
+    "currentVelocity": [
+      -1.2536847384842336
+    ],
+    "currentAcceleration": [
+      -5.5110982864886395
+    ],
+    "targetPosition": [
+      -0.02499208988114532
+    ],
+    "targetVelocity": [
+      3.027457091824118
+    ],
+    "targetAcceleration": [
+      -5.718398183961111
+    ],
+    "maxVelocity": [
+      7.175038160805455
+    ],
+    "maxAcceleration": [
+      5.952765636155873
+    ],
+    "maxJerk": [
+      15.659780805196878
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.240291661546827
+    ],
+    "currentVelocity": [
+      5.52272442922803
+    ],
+    "currentAcceleration": [
+      -3.4716898428648104
+    ],
+    "targetPosition": [
+      -5.2812090001886265
+    ],
+    "targetVelocity": [
+      -2.2207927764018116
+    ],
+    "targetAcceleration": [
+      4.653892590446626
+    ],
+    "maxVelocity": [
+      6.681902330019192
+    ],
+    "maxAcceleration": [
+      5.539423100576613
+    ],
+    "maxJerk": [
+      15.609212233833917
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.443994617439678
+    ],
+    "currentVelocity": [
+      -1.9039234850562525
+    ],
+    "currentAcceleration": [
+      -6.761719577918806
+    ],
+    "targetPosition": [
+      7.014426169538083
+    ],
+    "targetVelocity": [
+      1.4320996330698317
+    ],
+    "targetAcceleration": [
+      4.651861335458236
+    ],
+    "maxVelocity": [
+      3.8299819887861326
+    ],
+    "maxAcceleration": [
+      7.796051086808891
+    ],
+    "maxJerk": [
+      16.88817775624209
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.84078611080092
+    ],
+    "currentVelocity": [
+      -2.5363553952270808
+    ],
+    "currentAcceleration": [
+      -0.6277049568803794
+    ],
+    "targetPosition": [
+      5.994936589898661
+    ],
+    "targetVelocity": [
+      -0.6336180172419863
+    ],
+    "targetAcceleration": [
+      2.1749857633890466
+    ],
+    "maxVelocity": [
+      2.9682967738923076
+    ],
+    "maxAcceleration": [
+      3.715160164007746
+    ],
+    "maxJerk": [
+      9.27589631100679
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.772551754701921
+    ],
+    "currentVelocity": [
+      -2.6073588657020186
+    ],
+    "currentAcceleration": [
+      -2.455880348229546
+    ],
+    "targetPosition": [
+      7.1096934558953535
+    ],
+    "targetVelocity": [
+      -3.649761120542981
+    ],
+    "targetAcceleration": [
+      -0.24322276978146062
+    ],
+    "maxVelocity": [
+      6.114834304744772
+    ],
+    "maxAcceleration": [
+      3.0451275934930084
+    ],
+    "maxJerk": [
+      15.91876438290569
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.651260180087625
+    ],
+    "currentVelocity": [
+      -1.9978365306399228
+    ],
+    "currentAcceleration": [
+      -0.36921878139551323
+    ],
+    "targetPosition": [
+      5.40454399979285
+    ],
+    "targetVelocity": [
+      -1.3259174119715853
+    ],
+    "targetAcceleration": [
+      2.3370485089969826
+    ],
+    "maxVelocity": [
+      2.089731701727321
+    ],
+    "maxAcceleration": [
+      4.137229800104138
+    ],
+    "maxJerk": [
+      16.540239103924613
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.8105166285943355
+    ],
+    "currentVelocity": [
+      3.1575777347555976
+    ],
+    "currentAcceleration": [
+      -2.9515859092198107
+    ],
+    "targetPosition": [
+      8.78482023344247
+    ],
+    "targetVelocity": [
+      2.8003178568756306
+    ],
+    "targetAcceleration": [
+      -1.334240392886155
+    ],
+    "maxVelocity": [
+      4.546981827083831
+    ],
+    "maxAcceleration": [
+      6.861802296692391
+    ],
+    "maxJerk": [
+      11.14718002391486
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.5125162484293178
+    ],
+    "currentVelocity": [
+      -2.189905250828372
+    ],
+    "currentAcceleration": [
+      -2.4264583181685078
+    ],
+    "targetPosition": [
+      -6.854866849782077
+    ],
+    "targetVelocity": [
+      -0.4664320020771848
+    ],
+    "targetAcceleration": [
+      -1.3051132368555587
+    ],
+    "maxVelocity": [
+      2.9247754074083816
+    ],
+    "maxAcceleration": [
+      6.231179865079104
+    ],
+    "maxJerk": [
+      6.750876543021842
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.567276947205993
+    ],
+    "currentVelocity": [
+      2.385578724506457
+    ],
+    "currentAcceleration": [
+      -1.4215202752748732
+    ],
+    "targetPosition": [
+      -3.6344823949798055
+    ],
+    "targetVelocity": [
+      2.5441848211833746
+    ],
+    "targetAcceleration": [
+      4.863246181452407
+    ],
+    "maxVelocity": [
+      3.86086916009214
+    ],
+    "maxAcceleration": [
+      8.355762052011674
+    ],
+    "maxJerk": [
+      16.823921561103795
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.738516571317401
+    ],
+    "currentVelocity": [
+      1.4261509386616167
+    ],
+    "currentAcceleration": [
+      -3.4357625594494854
+    ],
+    "targetPosition": [
+      -8.078128883703643
+    ],
+    "targetVelocity": [
+      1.0607774165176354
+    ],
+    "targetAcceleration": [
+      -0.3469839211184871
+    ],
+    "maxVelocity": [
+      2.623371355804438
+    ],
+    "maxAcceleration": [
+      4.639180525322342
+    ],
+    "maxJerk": [
+      12.603947136185816
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.61137661942532
+    ],
+    "currentVelocity": [
+      2.576540806700656
+    ],
+    "currentAcceleration": [
+      -1.5938103635630383
+    ],
+    "targetPosition": [
+      -6.218494020885139
+    ],
+    "targetVelocity": [
+      -6.14198152624964
+    ],
+    "targetAcceleration": [
+      -1.1089451512694817
+    ],
+    "maxVelocity": [
+      7.550339308027485
+    ],
+    "maxAcceleration": [
+      3.9127265925099133
+    ],
+    "maxJerk": [
+      16.680488005592103
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.121988512900394
+    ],
+    "currentVelocity": [
+      -0.19287665413327781
+    ],
+    "currentAcceleration": [
+      8.824374850352546
+    ],
+    "targetPosition": [
+      6.319997318637419
+    ],
+    "targetVelocity": [
+      0.4243012209800443
+    ],
+    "targetAcceleration": [
+      6.030567505536567
+    ],
+    "maxVelocity": [
+      2.2542662247791796
+    ],
+    "maxAcceleration": [
+      9.110314741317575
+    ],
+    "maxJerk": [
+      17.790836597155355
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.363659774813428
+    ],
+    "currentVelocity": [
+      -3.125522568032956
+    ],
+    "currentAcceleration": [
+      -2.879287739812324
+    ],
+    "targetPosition": [
+      -2.3479478400431404
+    ],
+    "targetVelocity": [
+      -2.907251255657155
+    ],
+    "targetAcceleration": [
+      6.456110277140333
+    ],
+    "maxVelocity": [
+      6.649691470568364
+    ],
+    "maxAcceleration": [
+      7.92898921992559
+    ],
+    "maxJerk": [
+      18.07387199383299
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0914903328877479
+    ],
+    "currentVelocity": [
+      1.5875157613146063
+    ],
+    "currentAcceleration": [
+      -7.017448835998226
+    ],
+    "targetPosition": [
+      -8.968446567761728
+    ],
+    "targetVelocity": [
+      -1.6825981816279656
+    ],
+    "targetAcceleration": [
+      -6.813374627858135
+    ],
+    "maxVelocity": [
+      2.277556418397288
+    ],
+    "maxAcceleration": [
+      8.989991837927011
+    ],
+    "maxJerk": [
+      19.31607760479441
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.73055542023497
+    ],
+    "currentVelocity": [
+      -2.3740816655457877
+    ],
+    "currentAcceleration": [
+      -1.2959146344648556
+    ],
+    "targetPosition": [
+      -1.004949461525511
+    ],
+    "targetVelocity": [
+      -3.071837528300721
+    ],
+    "targetAcceleration": [
+      -4.764146860464926
+    ],
+    "maxVelocity": [
+      7.139276004891104
+    ],
+    "maxAcceleration": [
+      5.493084411963238
+    ],
+    "maxJerk": [
+      13.239185408604593
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.612365644638814
+    ],
+    "currentVelocity": [
+      -0.1466888909421291
+    ],
+    "currentAcceleration": [
+      -6.373266512256636
+    ],
+    "targetPosition": [
+      -9.066983957811885
+    ],
+    "targetVelocity": [
+      -0.6033496187635783
+    ],
+    "targetAcceleration": [
+      4.288333129705244
+    ],
+    "maxVelocity": [
+      2.9532889106341433
+    ],
+    "maxAcceleration": [
+      9.5023624966354
+    ],
+    "maxJerk": [
+      13.706211487591577
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.0043659995702363
+    ],
+    "currentVelocity": [
+      -1.4781661997015636
+    ],
+    "currentAcceleration": [
+      3.806834710874278
+    ],
+    "targetPosition": [
+      1.9357478220012467
+    ],
+    "targetVelocity": [
+      -6.382972704195527
+    ],
+    "targetAcceleration": [
+      -0.7921143006742826
+    ],
+    "maxVelocity": [
+      7.599385116240962
+    ],
+    "maxAcceleration": [
+      6.485777924943386
+    ],
+    "maxJerk": [
+      8.774313831723337
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.294508154736555
+    ],
+    "currentVelocity": [
+      4.053405339837149
+    ],
+    "currentAcceleration": [
+      4.24213814333669
+    ],
+    "targetPosition": [
+      -0.19770827715541017
+    ],
+    "targetVelocity": [
+      -2.407814554721579
+    ],
+    "targetAcceleration": [
+      -2.9638395656732075
+    ],
+    "maxVelocity": [
+      6.067070310624341
+    ],
+    "maxAcceleration": [
+      6.341546633349863
+    ],
+    "maxJerk": [
+      19.917829740630623
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.13411937839832
+    ],
+    "currentVelocity": [
+      1.4654653357147165
+    ],
+    "currentAcceleration": [
+      -3.4063867651606277
+    ],
+    "targetPosition": [
+      0.2442926378501653
+    ],
+    "targetVelocity": [
+      -0.9618218379525205
+    ],
+    "targetAcceleration": [
+      -2.886279953342482
+    ],
+    "maxVelocity": [
+      2.747153529977897
+    ],
+    "maxAcceleration": [
+      5.952233938502445
+    ],
+    "maxJerk": [
+      6.707327555403526
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.928679489603464
+    ],
+    "currentVelocity": [
+      -0.6096060800306331
+    ],
+    "currentAcceleration": [
+      2.71235836785959
+    ],
+    "targetPosition": [
+      -3.2704821162785036
+    ],
+    "targetVelocity": [
+      1.9925304087306301
+    ],
+    "targetAcceleration": [
+      -0.8471669454579529
+    ],
+    "maxVelocity": [
+      3.105744533871765
+    ],
+    "maxAcceleration": [
+      4.8210268955841205
+    ],
+    "maxJerk": [
+      13.383598633034811
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.966671318342893
+    ],
+    "currentVelocity": [
+      4.865686485272358
+    ],
+    "currentAcceleration": [
+      -7.221419854188063
+    ],
+    "targetPosition": [
+      -7.19410866276635
+    ],
+    "targetVelocity": [
+      -5.554292544025175
+    ],
+    "targetAcceleration": [
+      -0.42266492176961634
+    ],
+    "maxVelocity": [
+      7.748627649250668
+    ],
+    "maxAcceleration": [
+      9.961962375422024
+    ],
+    "maxJerk": [
+      16.3221311899839
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.6612655167921915
+    ],
+    "currentVelocity": [
+      2.1855169340007254
+    ],
+    "currentAcceleration": [
+      -3.28402909879184
+    ],
+    "targetPosition": [
+      1.0149195954701682
+    ],
+    "targetVelocity": [
+      1.5106057429269582
+    ],
+    "targetAcceleration": [
+      -1.7132924141844246
+    ],
+    "maxVelocity": [
+      4.29577078595378
+    ],
+    "maxAcceleration": [
+      4.3592696925647285
+    ],
+    "maxJerk": [
+      5.203740501856599
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.2662859204513417
+    ],
+    "currentVelocity": [
+      1.7653750851467693
+    ],
+    "currentAcceleration": [
+      -4.846566244205055
+    ],
+    "targetPosition": [
+      -6.995453286325799
+    ],
+    "targetVelocity": [
+      3.74146667026275
+    ],
+    "targetAcceleration": [
+      7.790064051235813
+    ],
+    "maxVelocity": [
+      6.74994159784788
+    ],
+    "maxAcceleration": [
+      8.518721025207295
+    ],
+    "maxJerk": [
+      12.684668302034705
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.1282187414989142
+    ],
+    "currentVelocity": [
+      -0.6813522133605936
+    ],
+    "currentAcceleration": [
+      -4.5796944301244755
+    ],
+    "targetPosition": [
+      0.15816525171302942
+    ],
+    "targetVelocity": [
+      2.857957493996971
+    ],
+    "targetAcceleration": [
+      -4.274413168835935
+    ],
+    "maxVelocity": [
+      5.800702367624445
+    ],
+    "maxAcceleration": [
+      9.18293611532823
+    ],
+    "maxJerk": [
+      16.930836881784025
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.78672472868985
+    ],
+    "currentVelocity": [
+      2.1948614493470253
+    ],
+    "currentAcceleration": [
+      3.486705481414755
+    ],
+    "targetPosition": [
+      2.6155213457088866
+    ],
+    "targetVelocity": [
+      2.1593745755422593
+    ],
+    "targetAcceleration": [
+      -0.6799533301706253
+    ],
+    "maxVelocity": [
+      3.186971715708139
+    ],
+    "maxAcceleration": [
+      4.175399285376679
+    ],
+    "maxJerk": [
+      17.556966235982884
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.4154730762232717
+    ],
+    "currentVelocity": [
+      -1.5988198403771314
+    ],
+    "currentAcceleration": [
+      1.3006741932162118
+    ],
+    "targetPosition": [
+      -0.6175508514458876
+    ],
+    "targetVelocity": [
+      1.7479494357552552
+    ],
+    "targetAcceleration": [
+      0.1617435119739632
+    ],
+    "maxVelocity": [
+      2.8521911887670974
+    ],
+    "maxAcceleration": [
+      8.070897663827939
+    ],
+    "maxJerk": [
+      6.347789398804024
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6228756522666252
+    ],
+    "currentVelocity": [
+      4.991179584875985
+    ],
+    "currentAcceleration": [
+      -5.747036272312577
+    ],
+    "targetPosition": [
+      -9.184212184601625
+    ],
+    "targetVelocity": [
+      -0.5306043501958122
+    ],
+    "targetAcceleration": [
+      1.3631532011092347
+    ],
+    "maxVelocity": [
+      7.452147588531981
+    ],
+    "maxAcceleration": [
+      7.6586868457158275
+    ],
+    "maxJerk": [
+      17.540493380017686
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.296172588676843
+    ],
+    "currentVelocity": [
+      -1.2170668632682018
+    ],
+    "currentAcceleration": [
+      -0.922663922017112
+    ],
+    "targetPosition": [
+      -3.224903863463531
+    ],
+    "targetVelocity": [
+      -5.315691589988385
+    ],
+    "targetAcceleration": [
+      2.282887109561632
+    ],
+    "maxVelocity": [
+      5.751174660332188
+    ],
+    "maxAcceleration": [
+      3.763231877516739
+    ],
+    "maxJerk": [
+      9.818175056166057
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.0670779265241475
+    ],
+    "currentVelocity": [
+      2.183684776505726
+    ],
+    "currentAcceleration": [
+      2.4887335041561487
+    ],
+    "targetPosition": [
+      -5.393918588138522
+    ],
+    "targetVelocity": [
+      -0.0027353898554300926
+    ],
+    "targetAcceleration": [
+      -0.8163852977945663
+    ],
+    "maxVelocity": [
+      3.8860763715484605
+    ],
+    "maxAcceleration": [
+      4.5533021011897095
+    ],
+    "maxJerk": [
+      7.287716227946234
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.9014644310574687
+    ],
+    "currentVelocity": [
+      1.9113964710789046
+    ],
+    "currentAcceleration": [
+      8.922642562622595
+    ],
+    "targetPosition": [
+      -2.489516271571608
+    ],
+    "targetVelocity": [
+      -5.344600003877657
+    ],
+    "targetAcceleration": [
+      -6.04793599110679
+    ],
+    "maxVelocity": [
+      7.2293716020639165
+    ],
+    "maxAcceleration": [
+      9.711783273543748
+    ],
+    "maxJerk": [
+      7.497665926422558
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.073174970950056
+    ],
+    "currentVelocity": [
+      0.9441722168508178
+    ],
+    "currentAcceleration": [
+      -4.577858528056095
+    ],
+    "targetPosition": [
+      6.129434662577971
+    ],
+    "targetVelocity": [
+      -1.0636177192571128
+    ],
+    "targetAcceleration": [
+      5.2717258646784195
+    ],
+    "maxVelocity": [
+      3.308717602912608
+    ],
+    "maxAcceleration": [
+      8.427628542577372
+    ],
+    "maxJerk": [
+      11.265897403113803
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.696817597593613
+    ],
+    "currentVelocity": [
+      -1.2633880063247453
+    ],
+    "currentAcceleration": [
+      4.618862849257308
+    ],
+    "targetPosition": [
+      4.715795918126215
+    ],
+    "targetVelocity": [
+      -0.4990546632559947
+    ],
+    "targetAcceleration": [
+      -1.4498275736434945
+    ],
+    "maxVelocity": [
+      3.0911086280202587
+    ],
+    "maxAcceleration": [
+      8.404480081448662
+    ],
+    "maxJerk": [
+      11.202638573501483
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.3746792353340229
+    ],
+    "currentVelocity": [
+      -6.632517582858336
+    ],
+    "currentAcceleration": [
+      0.7714126076914551
+    ],
+    "targetPosition": [
+      4.714691574115687
+    ],
+    "targetVelocity": [
+      -5.055694772756717
+    ],
+    "targetAcceleration": [
+      -6.184775700890051
+    ],
+    "maxVelocity": [
+      6.751337004180279
+    ],
+    "maxAcceleration": [
+      7.2503051203872895
+    ],
+    "maxJerk": [
+      13.905818614132311
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.126240551574789
+    ],
+    "currentVelocity": [
+      -0.7783674990430902
+    ],
+    "currentAcceleration": [
+      -1.9519610732499069
+    ],
+    "targetPosition": [
+      -9.339538725522356
+    ],
+    "targetVelocity": [
+      1.9892354060279356
+    ],
+    "targetAcceleration": [
+      0.6567604016624005
+    ],
+    "maxVelocity": [
+      2.5275316208062577
+    ],
+    "maxAcceleration": [
+      4.076014293540675
+    ],
+    "maxJerk": [
+      6.485319627481134
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.928217896137195
+    ],
+    "currentVelocity": [
+      -4.032894708688067
+    ],
+    "currentAcceleration": [
+      -0.5087771589238139
+    ],
+    "targetPosition": [
+      0.4968390826339313
+    ],
+    "targetVelocity": [
+      -1.7616689981729294
+    ],
+    "targetAcceleration": [
+      -0.3327155149486658
+    ],
+    "maxVelocity": [
+      5.626414240875446
+    ],
+    "maxAcceleration": [
+      3.420976030507642
+    ],
+    "maxJerk": [
+      6.175653487272584
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.331672865632772
+    ],
+    "currentVelocity": [
+      2.431705899239562
+    ],
+    "currentAcceleration": [
+      2.7708854135132484
+    ],
+    "targetPosition": [
+      5.509800910238582
+    ],
+    "targetVelocity": [
+      4.19980411857936
+    ],
+    "targetAcceleration": [
+      0.3661363586688253
+    ],
+    "maxVelocity": [
+      5.379592887812729
+    ],
+    "maxAcceleration": [
+      6.507847466723675
+    ],
+    "maxJerk": [
+      6.402714591597038
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.861222344569299
+    ],
+    "currentVelocity": [
+      -0.9143756049326237
+    ],
+    "currentAcceleration": [
+      3.1892198047348783
+    ],
+    "targetPosition": [
+      8.80251480353931
+    ],
+    "targetVelocity": [
+      -1.7096529141978158
+    ],
+    "targetAcceleration": [
+      -5.43924991326777
+    ],
+    "maxVelocity": [
+      2.4332992640963997
+    ],
+    "maxAcceleration": [
+      7.377432681903403
+    ],
+    "maxJerk": [
+      6.790302007251096
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.867924998030448
+    ],
+    "currentVelocity": [
+      2.4990991481136478
+    ],
+    "currentAcceleration": [
+      2.14676264089033
+    ],
+    "targetPosition": [
+      6.047299165833191
+    ],
+    "targetVelocity": [
+      -1.4645609829518635
+    ],
+    "targetAcceleration": [
+      2.0800870744210833
+    ],
+    "maxVelocity": [
+      6.9288944730917015
+    ],
+    "maxAcceleration": [
+      4.356909919741629
+    ],
+    "maxJerk": [
+      12.994887124501435
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.109575733318377
+    ],
+    "currentVelocity": [
+      3.6823482726513035
+    ],
+    "currentAcceleration": [
+      2.8797654043803638
+    ],
+    "targetPosition": [
+      7.928812097554417
+    ],
+    "targetVelocity": [
+      2.7431046236946077
+    ],
+    "targetAcceleration": [
+      2.5021751379738966
+    ],
+    "maxVelocity": [
+      4.777014729548357
+    ],
+    "maxAcceleration": [
+      3.780930816070665
+    ],
+    "maxJerk": [
+      11.185904669236633
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.03668089293532972
+    ],
+    "currentVelocity": [
+      -1.0970385756223378
+    ],
+    "currentAcceleration": [
+      -0.8317277816334085
+    ],
+    "targetPosition": [
+      -6.774830154124327
+    ],
+    "targetVelocity": [
+      1.661112675649301
+    ],
+    "targetAcceleration": [
+      0.7676271945531798
+    ],
+    "maxVelocity": [
+      4.160511031619346
+    ],
+    "maxAcceleration": [
+      8.181553850525884
+    ],
+    "maxJerk": [
+      12.766050839761505
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.8496808876344275
+    ],
+    "currentVelocity": [
+      3.2501337120701774
+    ],
+    "currentAcceleration": [
+      -2.693018140014791
+    ],
+    "targetPosition": [
+      -4.359865090615407
+    ],
+    "targetVelocity": [
+      -2.2212074097159933
+    ],
+    "targetAcceleration": [
+      -3.3108608576673006
+    ],
+    "maxVelocity": [
+      3.340113913882839
+    ],
+    "maxAcceleration": [
+      4.186580219774843
+    ],
+    "maxJerk": [
+      19.881734451866155
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.391238803649305
+    ],
+    "currentVelocity": [
+      2.0722207819529785
+    ],
+    "currentAcceleration": [
+      -2.3274154943873158
+    ],
+    "targetPosition": [
+      9.825634737420707
+    ],
+    "targetVelocity": [
+      -1.331593542620885
+    ],
+    "targetAcceleration": [
+      -5.089280940837537
+    ],
+    "maxVelocity": [
+      5.271014457972733
+    ],
+    "maxAcceleration": [
+      5.327914308386553
+    ],
+    "maxJerk": [
+      5.9163163421634914
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.7958441608375839
+    ],
+    "currentVelocity": [
+      -1.2643541505945493
+    ],
+    "currentAcceleration": [
+      -4.121488078245095
+    ],
+    "targetPosition": [
+      -0.40908016488033994
+    ],
+    "targetVelocity": [
+      3.3728170459744824
+    ],
+    "targetAcceleration": [
+      1.3192254366228653
+    ],
+    "maxVelocity": [
+      3.4553764258781685
+    ],
+    "maxAcceleration": [
+      8.860760916024319
+    ],
+    "maxJerk": [
+      16.242607472275164
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.619231182786558
+    ],
+    "currentVelocity": [
+      4.015276689602237
+    ],
+    "currentAcceleration": [
+      -1.5615331527856209
+    ],
+    "targetPosition": [
+      -1.8276812324738891
+    ],
+    "targetVelocity": [
+      1.4895659200183617
+    ],
+    "targetAcceleration": [
+      -0.3678111128148922
+    ],
+    "maxVelocity": [
+      4.898618204952948
+    ],
+    "maxAcceleration": [
+      5.0988995380718745
+    ],
+    "maxJerk": [
+      13.639733839915602
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.0957984906826308
+    ],
+    "currentVelocity": [
+      -4.191109908185699
+    ],
+    "currentAcceleration": [
+      -1.4191115581667795
+    ],
+    "targetPosition": [
+      -4.777152178165918
+    ],
+    "targetVelocity": [
+      -3.582697915042175
+    ],
+    "targetAcceleration": [
+      -5.083458334031141
+    ],
+    "maxVelocity": [
+      4.6335936012592205
+    ],
+    "maxAcceleration": [
+      9.684101270723144
+    ],
+    "maxJerk": [
+      14.811958917856579
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.211542446902168
+    ],
+    "currentVelocity": [
+      -4.74324817887951
+    ],
+    "currentAcceleration": [
+      2.729838512912826
+    ],
+    "targetPosition": [
+      1.6107948650561088
+    ],
+    "targetVelocity": [
+      -4.536931475101703
+    ],
+    "targetAcceleration": [
+      -1.8371670821882433
+    ],
+    "maxVelocity": [
+      7.045554266524292
+    ],
+    "maxAcceleration": [
+      4.632361928674181
+    ],
+    "maxJerk": [
+      11.97993292291719
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.776517396987346
+    ],
+    "currentVelocity": [
+      1.717282574027624
+    ],
+    "currentAcceleration": [
+      -0.16557721651606894
+    ],
+    "targetPosition": [
+      -3.5872788880264217
+    ],
+    "targetVelocity": [
+      -1.5662721437822573
+    ],
+    "targetAcceleration": [
+      4.696937883807234
+    ],
+    "maxVelocity": [
+      3.3850244063717763
+    ],
+    "maxAcceleration": [
+      6.399807127096203
+    ],
+    "maxJerk": [
+      11.646455156547827
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.330192161288174
+    ],
+    "currentVelocity": [
+      -5.256332578303525
+    ],
+    "currentAcceleration": [
+      6.348521297509
+    ],
+    "targetPosition": [
+      5.594467749531491
+    ],
+    "targetVelocity": [
+      0.4763180304885868
+    ],
+    "targetAcceleration": [
+      2.4527488028784212
+    ],
+    "maxVelocity": [
+      6.006658921698751
+    ],
+    "maxAcceleration": [
+      8.188790475138198
+    ],
+    "maxJerk": [
+      18.405142879732
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.8865856489638873
+    ],
+    "currentVelocity": [
+      -1.9610313587758816
+    ],
+    "currentAcceleration": [
+      1.8752595376767882
+    ],
+    "targetPosition": [
+      2.09120024805868
+    ],
+    "targetVelocity": [
+      0.9280704664383137
+    ],
+    "targetAcceleration": [
+      -0.1724138446468375
+    ],
+    "maxVelocity": [
+      5.665490221148496
+    ],
+    "maxAcceleration": [
+      4.068696452239601
+    ],
+    "maxJerk": [
+      6.777290741470453
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.489769426314844
+    ],
+    "currentVelocity": [
+      1.8167895616084073
+    ],
+    "currentAcceleration": [
+      -8.824982079018081
+    ],
+    "targetPosition": [
+      -5.230004770645207
+    ],
+    "targetVelocity": [
+      0.9506747179736528
+    ],
+    "targetAcceleration": [
+      8.603926272123768
+    ],
+    "maxVelocity": [
+      3.0917996761405804
+    ],
+    "maxAcceleration": [
+      9.561238068090066
+    ],
+    "maxJerk": [
+      13.423293134548992
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.580477713488056
+    ],
+    "currentVelocity": [
+      5.232626301623777
+    ],
+    "currentAcceleration": [
+      -3.8672519309773645
+    ],
+    "targetPosition": [
+      -3.2101306610226317
+    ],
+    "targetVelocity": [
+      -3.9712582496785163
+    ],
+    "targetAcceleration": [
+      -3.9997881760170584
+    ],
+    "maxVelocity": [
+      5.793961434300901
+    ],
+    "maxAcceleration": [
+      7.820614092562263
+    ],
+    "maxJerk": [
+      5.299553126898248
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.801897347386333
+    ],
+    "currentVelocity": [
+      -0.25334963386481046
+    ],
+    "currentAcceleration": [
+      3.8072414832996193
+    ],
+    "targetPosition": [
+      -0.717905184047245
+    ],
+    "targetVelocity": [
+      0.3280804980101042
+    ],
+    "targetAcceleration": [
+      -4.084270112431626
+    ],
+    "maxVelocity": [
+      6.215398061919336
+    ],
+    "maxAcceleration": [
+      5.068506597475488
+    ],
+    "maxJerk": [
+      16.50739432341026
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.22211610558963635
+    ],
+    "currentVelocity": [
+      1.1363687614029052
+    ],
+    "currentAcceleration": [
+      -0.04085819976098337
+    ],
+    "targetPosition": [
+      -0.519416077103628
+    ],
+    "targetVelocity": [
+      6.353813822652444
+    ],
+    "targetAcceleration": [
+      -2.9404739220772975
+    ],
+    "maxVelocity": [
+      7.194758521387787
+    ],
+    "maxAcceleration": [
+      3.149576785311461
+    ],
+    "maxJerk": [
+      6.098696836407848
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.819142878618936
+    ],
+    "currentVelocity": [
+      -1.3868263985408893
+    ],
+    "currentAcceleration": [
+      -3.0488131470699136
+    ],
+    "targetPosition": [
+      -0.07839499816282469
+    ],
+    "targetVelocity": [
+      -0.36158666584473
+    ],
+    "targetAcceleration": [
+      -1.9157379595038484
+    ],
+    "maxVelocity": [
+      3.8543470105587248
+    ],
+    "maxAcceleration": [
+      5.636218444740115
+    ],
+    "maxJerk": [
+      7.889070210286783
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.2277265363967675
+    ],
+    "currentVelocity": [
+      -4.266480826440351
+    ],
+    "currentAcceleration": [
+      6.518530670817551
+    ],
+    "targetPosition": [
+      0.42946461896329424
+    ],
+    "targetVelocity": [
+      0.28661120313619737
+    ],
+    "targetAcceleration": [
+      2.726095860817349
+    ],
+    "maxVelocity": [
+      5.46152602543342
+    ],
+    "maxAcceleration": [
+      8.343623148482948
+    ],
+    "maxJerk": [
+      18.47910162153206
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.233520588295219
+    ],
+    "currentVelocity": [
+      -1.2446286499584565
+    ],
+    "currentAcceleration": [
+      -0.024419444403472657
+    ],
+    "targetPosition": [
+      1.5536431636519197
+    ],
+    "targetVelocity": [
+      -3.0780166253418404
+    ],
+    "targetAcceleration": [
+      -3.1761500585338847
+    ],
+    "maxVelocity": [
+      4.026953396923467
+    ],
+    "maxAcceleration": [
+      3.3389963388378967
+    ],
+    "maxJerk": [
+      17.34844598059142
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.3343887468231497
+    ],
+    "currentVelocity": [
+      -1.1579431278979913
+    ],
+    "currentAcceleration": [
+      3.5099786244591193
+    ],
+    "targetPosition": [
+      8.613932538655614
+    ],
+    "targetVelocity": [
+      -1.768366320566162
+    ],
+    "targetAcceleration": [
+      1.6032979809385637
+    ],
+    "maxVelocity": [
+      5.228926508214162
+    ],
+    "maxAcceleration": [
+      6.774268522618836
+    ],
+    "maxJerk": [
+      7.980235500445183
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.161374222432029
+    ],
+    "currentVelocity": [
+      -0.4432384357188228
+    ],
+    "currentAcceleration": [
+      -2.930260145435071
+    ],
+    "targetPosition": [
+      -1.5220048854271244
+    ],
+    "targetVelocity": [
+      -0.2826303299097024
+    ],
+    "targetAcceleration": [
+      -1.5642991560637198
+    ],
+    "maxVelocity": [
+      6.138851644504391
+    ],
+    "maxAcceleration": [
+      5.037539199135253
+    ],
+    "maxJerk": [
+      12.980649088725603
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.629905118738158
+    ],
+    "currentVelocity": [
+      1.5452441763511047
+    ],
+    "currentAcceleration": [
+      0.9065629181187909
+    ],
+    "targetPosition": [
+      3.0275769651985645
+    ],
+    "targetVelocity": [
+      -1.1856458934778225
+    ],
+    "targetAcceleration": [
+      -2.3253338427889765
+    ],
+    "maxVelocity": [
+      7.16467834233061
+    ],
+    "maxAcceleration": [
+      4.781357593929197
+    ],
+    "maxJerk": [
+      17.584106709651337
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.813965652075225
+    ],
+    "currentVelocity": [
+      -3.0658784075329946
+    ],
+    "currentAcceleration": [
+      3.632830916480291
+    ],
+    "targetPosition": [
+      -8.319663908610735
+    ],
+    "targetVelocity": [
+      2.291436330458021
+    ],
+    "targetAcceleration": [
+      -7.0870978784940775
+    ],
+    "maxVelocity": [
+      7.088532386447206
+    ],
+    "maxAcceleration": [
+      9.72616538230937
+    ],
+    "maxJerk": [
+      14.050984777609841
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.419194376540007
+    ],
+    "currentVelocity": [
+      4.66847738878429
+    ],
+    "currentAcceleration": [
+      -0.53550278527173
+    ],
+    "targetPosition": [
+      -3.046881156409702
+    ],
+    "targetVelocity": [
+      -2.4016759063672977
+    ],
+    "targetAcceleration": [
+      0.2012259646988266
+    ],
+    "maxVelocity": [
+      7.559464244441341
+    ],
+    "maxAcceleration": [
+      4.2690266213604176
+    ],
+    "maxJerk": [
+      8.830316882102831
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6373834151522786
+    ],
+    "currentVelocity": [
+      4.68732977747341
+    ],
+    "currentAcceleration": [
+      4.166673491675432
+    ],
+    "targetPosition": [
+      2.028862415455844
+    ],
+    "targetVelocity": [
+      -1.5164077888185856
+    ],
+    "targetAcceleration": [
+      -2.0601993410937682
+    ],
+    "maxVelocity": [
+      6.156175519587029
+    ],
+    "maxAcceleration": [
+      6.057176617841051
+    ],
+    "maxJerk": [
+      15.392546259773939
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7034138034607516
+    ],
+    "currentVelocity": [
+      -2.029677451280847
+    ],
+    "currentAcceleration": [
+      3.4112787933769626
+    ],
+    "targetPosition": [
+      -2.34814543785562
+    ],
+    "targetVelocity": [
+      -4.665979589198242
+    ],
+    "targetAcceleration": [
+      2.776714599121937
+    ],
+    "maxVelocity": [
+      7.214986518423469
+    ],
+    "maxAcceleration": [
+      7.918636448342016
+    ],
+    "maxJerk": [
+      17.324802953620463
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.5532683147358437
+    ],
+    "currentVelocity": [
+      -0.4501502913361004
+    ],
+    "currentAcceleration": [
+      -1.747381659978283
+    ],
+    "targetPosition": [
+      -8.480960716930534
+    ],
+    "targetVelocity": [
+      0.326841798196142
+    ],
+    "targetAcceleration": [
+      -0.8216631954421034
+    ],
+    "maxVelocity": [
+      3.443977736843644
+    ],
+    "maxAcceleration": [
+      3.9782148169733618
+    ],
+    "maxJerk": [
+      14.906105312332564
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.126083853866727
+    ],
+    "currentVelocity": [
+      1.9387532270154448
+    ],
+    "currentAcceleration": [
+      -1.5428445060910514
+    ],
+    "targetPosition": [
+      -9.59901707370177
+    ],
+    "targetVelocity": [
+      4.247249598898911
+    ],
+    "targetAcceleration": [
+      5.624528248297482
+    ],
+    "maxVelocity": [
+      4.524575341543773
+    ],
+    "maxAcceleration": [
+      8.264678832093706
+    ],
+    "maxJerk": [
+      5.928211661278678
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.133169812031635
+    ],
+    "currentVelocity": [
+      -2.3924897492079906
+    ],
+    "currentAcceleration": [
+      -3.7101046379757827
+    ],
+    "targetPosition": [
+      -0.11228853545317818
+    ],
+    "targetVelocity": [
+      3.831222711390428
+    ],
+    "targetAcceleration": [
+      -2.4667950576237994
+    ],
+    "maxVelocity": [
+      5.343532863692136
+    ],
+    "maxAcceleration": [
+      4.458712517319909
+    ],
+    "maxJerk": [
+      15.531883811889882
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.601914114802284
+    ],
+    "currentVelocity": [
+      3.775443621165728
+    ],
+    "currentAcceleration": [
+      -3.8981672103285874
+    ],
+    "targetPosition": [
+      2.8113690833878575
+    ],
+    "targetVelocity": [
+      -6.031871692904235
+    ],
+    "targetAcceleration": [
+      -0.28537277680601214
+    ],
+    "maxVelocity": [
+      7.148801949992425
+    ],
+    "maxAcceleration": [
+      6.73380077709537
+    ],
+    "maxJerk": [
+      10.922950470154477
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.2790368331170807
+    ],
+    "currentVelocity": [
+      -2.29833794997004
+    ],
+    "currentAcceleration": [
+      5.6024206267329895
+    ],
+    "targetPosition": [
+      -6.544937095450671
+    ],
+    "targetVelocity": [
+      -3.045764499922784
+    ],
+    "targetAcceleration": [
+      3.955614359621256
+    ],
+    "maxVelocity": [
+      4.275460083667069
+    ],
+    "maxAcceleration": [
+      6.498117384492529
+    ],
+    "maxJerk": [
+      7.7420661348412025
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.68856657930572
+    ],
+    "currentVelocity": [
+      5.586624694422591
+    ],
+    "currentAcceleration": [
+      1.0985472066595392
+    ],
+    "targetPosition": [
+      8.857181110017823
+    ],
+    "targetVelocity": [
+      -3.462418137684392
+    ],
+    "targetAcceleration": [
+      3.0131941607952752
+    ],
+    "maxVelocity": [
+      6.197592873532221
+    ],
+    "maxAcceleration": [
+      3.670616278466957
+    ],
+    "maxJerk": [
+      19.74360889593848
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.459797629555815
+    ],
+    "currentVelocity": [
+      1.7175174773741286
+    ],
+    "currentAcceleration": [
+      5.897341255965674
+    ],
+    "targetPosition": [
+      7.721052762916653
+    ],
+    "targetVelocity": [
+      -1.0095204877519222
+    ],
+    "targetAcceleration": [
+      -5.446500497269399
+    ],
+    "maxVelocity": [
+      3.1363466924411627
+    ],
+    "maxAcceleration": [
+      7.424282035350755
+    ],
+    "maxJerk": [
+      16.828392976951186
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.309432043472228
+    ],
+    "currentVelocity": [
+      -0.9546388602470248
+    ],
+    "currentAcceleration": [
+      3.313413425065832
+    ],
+    "targetPosition": [
+      7.7684890106562605
+    ],
+    "targetVelocity": [
+      -1.7196651519070656
+    ],
+    "targetAcceleration": [
+      4.514285148589332
+    ],
+    "maxVelocity": [
+      4.2527156521288205
+    ],
+    "maxAcceleration": [
+      6.784392207569219
+    ],
+    "maxJerk": [
+      12.447747009836386
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.935933186181945
+    ],
+    "currentVelocity": [
+      6.5513262716634895
+    ],
+    "currentAcceleration": [
+      2.986575975398429
+    ],
+    "targetPosition": [
+      -8.098358712660099
+    ],
+    "targetVelocity": [
+      -5.550241277111107
+    ],
+    "targetAcceleration": [
+      -2.3449004327018184
+    ],
+    "maxVelocity": [
+      7.2594008194699775
+    ],
+    "maxAcceleration": [
+      7.779635999501009
+    ],
+    "maxJerk": [
+      13.677150511658287
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.279882025621969
+    ],
+    "currentVelocity": [
+      1.9890558281188255
+    ],
+    "currentAcceleration": [
+      4.124439824951063
+    ],
+    "targetPosition": [
+      1.0948018302350064
+    ],
+    "targetVelocity": [
+      -0.3379547145466404
+    ],
+    "targetAcceleration": [
+      -0.2809398532119367
+    ],
+    "maxVelocity": [
+      4.805613288561435
+    ],
+    "maxAcceleration": [
+      6.295967463155533
+    ],
+    "maxJerk": [
+      13.029770919870089
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.25194640676070357
+    ],
+    "currentVelocity": [
+      2.546516093723251
+    ],
+    "currentAcceleration": [
+      -3.2503570831750466
+    ],
+    "targetPosition": [
+      3.023684640444902
+    ],
+    "targetVelocity": [
+      -0.7606945265231246
+    ],
+    "targetAcceleration": [
+      1.8153864376467688
+    ],
+    "maxVelocity": [
+      5.083620557619884
+    ],
+    "maxAcceleration": [
+      5.63642276712565
+    ],
+    "maxJerk": [
+      14.900099240986217
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.345978163185642
+    ],
+    "currentVelocity": [
+      0.8040950931841739
+    ],
+    "currentAcceleration": [
+      5.9711628139278385
+    ],
+    "targetPosition": [
+      3.51126983937764
+    ],
+    "targetVelocity": [
+      0.4206616628181674
+    ],
+    "targetAcceleration": [
+      9.08922864738025
+    ],
+    "maxVelocity": [
+      2.223896739346137
+    ],
+    "maxAcceleration": [
+      9.855209191480668
+    ],
+    "maxJerk": [
+      17.202993360006825
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.231723481593534
+    ],
+    "currentVelocity": [
+      1.882319056280899
+    ],
+    "currentAcceleration": [
+      1.6401840253264348
+    ],
+    "targetPosition": [
+      8.200628829713793
+    ],
+    "targetVelocity": [
+      -3.932929356768295
+    ],
+    "targetAcceleration": [
+      4.228435885708812
+    ],
+    "maxVelocity": [
+      4.580996237032831
+    ],
+    "maxAcceleration": [
+      4.757774507914956
+    ],
+    "maxJerk": [
+      14.419256103439064
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.2213246622168263
+    ],
+    "currentVelocity": [
+      1.309426092162533
+    ],
+    "currentAcceleration": [
+      3.034264987521677
+    ],
+    "targetPosition": [
+      -5.081558148245131
+    ],
+    "targetVelocity": [
+      4.494738936350635
+    ],
+    "targetAcceleration": [
+      -2.784555748516928
+    ],
+    "maxVelocity": [
+      6.255841070018604
+    ],
+    "maxAcceleration": [
+      5.3570748488545785
+    ],
+    "maxJerk": [
+      15.82770683064815
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.0499736760773146
+    ],
+    "currentVelocity": [
+      1.0530474958691949
+    ],
+    "currentAcceleration": [
+      0.11903674708559109
+    ],
+    "targetPosition": [
+      4.205085874909981
+    ],
+    "targetVelocity": [
+      -1.8827931280322963
+    ],
+    "targetAcceleration": [
+      -4.859876895066627
+    ],
+    "maxVelocity": [
+      2.4275052672499484
+    ],
+    "maxAcceleration": [
+      6.63424240527433
+    ],
+    "maxJerk": [
+      8.97802190666522
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.7314458192541196
+    ],
+    "currentVelocity": [
+      -3.046473886750241
+    ],
+    "currentAcceleration": [
+      -2.63325608705372
+    ],
+    "targetPosition": [
+      -0.7384802671738573
+    ],
+    "targetVelocity": [
+      -3.724196080235247
+    ],
+    "targetAcceleration": [
+      0.5424138297954695
+    ],
+    "maxVelocity": [
+      4.4488726441608435
+    ],
+    "maxAcceleration": [
+      4.388553084087321
+    ],
+    "maxJerk": [
+      6.3980250015122015
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.87938406075782
+    ],
+    "currentVelocity": [
+      -1.8544922936161323
+    ],
+    "currentAcceleration": [
+      3.598891584578545
+    ],
+    "targetPosition": [
+      3.870790946467748
+    ],
+    "targetVelocity": [
+      2.4076410848862446
+    ],
+    "targetAcceleration": [
+      1.6914887395490017
+    ],
+    "maxVelocity": [
+      4.144031550813094
+    ],
+    "maxAcceleration": [
+      3.85958510439962
+    ],
+    "maxJerk": [
+      14.533102999112282
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.871529917171198
+    ],
+    "currentVelocity": [
+      -3.233692007211606
+    ],
+    "currentAcceleration": [
+      -2.0934689908093
+    ],
+    "targetPosition": [
+      7.371152550346437
+    ],
+    "targetVelocity": [
+      -1.5034435584881076
+    ],
+    "targetAcceleration": [
+      -1.0079611292306234
+    ],
+    "maxVelocity": [
+      4.5165586432184694
+    ],
+    "maxAcceleration": [
+      6.663634933202164
+    ],
+    "maxJerk": [
+      17.146059411623447
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.501765432108405
+    ],
+    "currentVelocity": [
+      6.344924740650627
+    ],
+    "currentAcceleration": [
+      -5.287192078683961
+    ],
+    "targetPosition": [
+      3.6045983510464943
+    ],
+    "targetVelocity": [
+      -2.6921954797229413
+    ],
+    "targetAcceleration": [
+      -0.22171396263999288
+    ],
+    "maxVelocity": [
+      6.50269910189071
+    ],
+    "maxAcceleration": [
+      7.220834087804628
+    ],
+    "maxJerk": [
+      15.265328096050562
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.1596205974463345
+    ],
+    "currentVelocity": [
+      -4.742473848131953
+    ],
+    "currentAcceleration": [
+      -5.153906362197835
+    ],
+    "targetPosition": [
+      3.0837193828181046
+    ],
+    "targetVelocity": [
+      -0.0515764148121125
+    ],
+    "targetAcceleration": [
+      -3.6899017003487664
+    ],
+    "maxVelocity": [
+      6.7045876102502575
+    ],
+    "maxAcceleration": [
+      7.803710481435836
+    ],
+    "maxJerk": [
+      11.595301474929503
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.035337057758547
+    ],
+    "currentVelocity": [
+      -0.3649360461473652
+    ],
+    "currentAcceleration": [
+      -3.6107420840239595
+    ],
+    "targetPosition": [
+      -5.794367600329924
+    ],
+    "targetVelocity": [
+      2.598674322788901
+    ],
+    "targetAcceleration": [
+      1.9491430438641428
+    ],
+    "maxVelocity": [
+      3.7273694767870658
+    ],
+    "maxAcceleration": [
+      3.8307439535948804
+    ],
+    "maxJerk": [
+      8.108418370204811
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.725375121401521
+    ],
+    "currentVelocity": [
+      -2.180481071373261
+    ],
+    "currentAcceleration": [
+      3.2108986432302977
+    ],
+    "targetPosition": [
+      -4.460772411796476
+    ],
+    "targetVelocity": [
+      2.723863708344328
+    ],
+    "targetAcceleration": [
+      1.4996267153694358
+    ],
+    "maxVelocity": [
+      3.954336177799603
+    ],
+    "maxAcceleration": [
+      6.580242659253491
+    ],
+    "maxJerk": [
+      8.420276362972269
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.3322197351479295
+    ],
+    "currentVelocity": [
+      5.391705640794572
+    ],
+    "currentAcceleration": [
+      5.785914545340674
+    ],
+    "targetPosition": [
+      1.2282060593337576
+    ],
+    "targetVelocity": [
+      -5.057154045746023
+    ],
+    "targetAcceleration": [
+      -1.2603941718648537
+    ],
+    "maxVelocity": [
+      6.898958753149656
+    ],
+    "maxAcceleration": [
+      6.816959664985692
+    ],
+    "maxJerk": [
+      15.6267675380961
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.679686284493517
+    ],
+    "currentVelocity": [
+      0.8120359481335018
+    ],
+    "currentAcceleration": [
+      -1.963592013351
+    ],
+    "targetPosition": [
+      -0.3715291856412364
+    ],
+    "targetVelocity": [
+      1.4864256958974238
+    ],
+    "targetAcceleration": [
+      -0.719344756894011
+    ],
+    "maxVelocity": [
+      2.1366222686084515
+    ],
+    "maxAcceleration": [
+      5.0469924479409745
+    ],
+    "maxJerk": [
+      12.306419698146211
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.166709906841481
+    ],
+    "currentVelocity": [
+      -0.5575326144490811
+    ],
+    "currentAcceleration": [
+      -6.7404030548145295
+    ],
+    "targetPosition": [
+      1.3593316423504938
+    ],
+    "targetVelocity": [
+      1.0900362732746567
+    ],
+    "targetAcceleration": [
+      -5.625464341202761
+    ],
+    "maxVelocity": [
+      4.676172237277625
+    ],
+    "maxAcceleration": [
+      7.150761798069775
+    ],
+    "maxJerk": [
+      18.321243166961136
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.4627076810609285
+    ],
+    "currentVelocity": [
+      0.14555698363102954
+    ],
+    "currentAcceleration": [
+      -1.6312109780391268
+    ],
+    "targetPosition": [
+      9.129407999782696
+    ],
+    "targetVelocity": [
+      -0.7473937721849002
+    ],
+    "targetAcceleration": [
+      -4.169607865716884
+    ],
+    "maxVelocity": [
+      2.4398199983217026
+    ],
+    "maxAcceleration": [
+      4.421283491421928
+    ],
+    "maxJerk": [
+      12.848126083724317
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.629476285171474
+    ],
+    "currentVelocity": [
+      4.284531502664967
+    ],
+    "currentAcceleration": [
+      -1.6769331161011412
+    ],
+    "targetPosition": [
+      -1.943827302431142
+    ],
+    "targetVelocity": [
+      -2.55228832240711
+    ],
+    "targetAcceleration": [
+      -2.7238709133840633
+    ],
+    "maxVelocity": [
+      6.16597401570635
+    ],
+    "maxAcceleration": [
+      6.534851344746279
+    ],
+    "maxJerk": [
+      8.715293414894141
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.460534565262278
+    ],
+    "currentVelocity": [
+      -2.9718261090137608
+    ],
+    "currentAcceleration": [
+      7.608147762774234
+    ],
+    "targetPosition": [
+      6.919134781938958
+    ],
+    "targetVelocity": [
+      -5.964789568495416
+    ],
+    "targetAcceleration": [
+      -2.311473069282605
+    ],
+    "maxVelocity": [
+      7.202377895044315
+    ],
+    "maxAcceleration": [
+      8.066504954442589
+    ],
+    "maxJerk": [
+      9.391448947163877
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.177099036387055
+    ],
+    "currentVelocity": [
+      0.8501917583372158
+    ],
+    "currentAcceleration": [
+      1.2296815564475896
+    ],
+    "targetPosition": [
+      -2.632657740856345
+    ],
+    "targetVelocity": [
+      -2.3928330252026875
+    ],
+    "targetAcceleration": [
+      -3.4657044519322135
+    ],
+    "maxVelocity": [
+      6.350949926021999
+    ],
+    "maxAcceleration": [
+      4.033812780972429
+    ],
+    "maxJerk": [
+      9.438824378787515
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.2196362108266321
+    ],
+    "currentVelocity": [
+      0.5778609651885755
+    ],
+    "currentAcceleration": [
+      -4.730258421481403
+    ],
+    "targetPosition": [
+      7.992590676584982
+    ],
+    "targetVelocity": [
+      -1.078331306679953
+    ],
+    "targetAcceleration": [
+      5.040688125561394
+    ],
+    "maxVelocity": [
+      5.9261757165467905
+    ],
+    "maxAcceleration": [
+      5.176783174608685
+    ],
+    "maxJerk": [
+      18.364967265718665
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.1523547752688703
+    ],
+    "currentVelocity": [
+      4.9686154278488495
+    ],
+    "currentAcceleration": [
+      1.2167111446364007
+    ],
+    "targetPosition": [
+      0.21821279903218027
+    ],
+    "targetVelocity": [
+      -2.370125888594937
+    ],
+    "targetAcceleration": [
+      4.808690919660691
+    ],
+    "maxVelocity": [
+      6.9608971114307145
+    ],
+    "maxAcceleration": [
+      7.609881472301987
+    ],
+    "maxJerk": [
+      9.082699711024333
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.11925772350300434
+    ],
+    "currentVelocity": [
+      -0.010419332472216603
+    ],
+    "currentAcceleration": [
+      3.5456367661333417
+    ],
+    "targetPosition": [
+      1.406309118019042
+    ],
+    "targetVelocity": [
+      2.1661746555395816
+    ],
+    "targetAcceleration": [
+      -5.2820855649891625
+    ],
+    "maxVelocity": [
+      6.505848093002246
+    ],
+    "maxAcceleration": [
+      6.608326991597689
+    ],
+    "maxJerk": [
+      16.90213239687518
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.2425565322000214
+    ],
+    "currentVelocity": [
+      6.049468035341316
+    ],
+    "currentAcceleration": [
+      0.45709665266888555
+    ],
+    "targetPosition": [
+      -6.140676355907326
+    ],
+    "targetVelocity": [
+      -3.606660129838998
+    ],
+    "targetAcceleration": [
+      -2.990077628824933
+    ],
+    "maxVelocity": [
+      7.583384797731312
+    ],
+    "maxAcceleration": [
+      3.1432008102420275
+    ],
+    "maxJerk": [
+      7.278009960634789
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.031976164058860945
+    ],
+    "currentVelocity": [
+      -3.8763675395672794
+    ],
+    "currentAcceleration": [
+      -0.4428475317540297
+    ],
+    "targetPosition": [
+      -7.510892182285578
+    ],
+    "targetVelocity": [
+      1.7680589587862983
+    ],
+    "targetAcceleration": [
+      -4.370656114135757
+    ],
+    "maxVelocity": [
+      7.0956594856983894
+    ],
+    "maxAcceleration": [
+      6.434554465312916
+    ],
+    "maxJerk": [
+      17.81119108203096
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.222821201292449
+    ],
+    "currentVelocity": [
+      -4.740650784370526
+    ],
+    "currentAcceleration": [
+      2.077967017964201
+    ],
+    "targetPosition": [
+      1.9967336097073414
+    ],
+    "targetVelocity": [
+      -5.468929851868068
+    ],
+    "targetAcceleration": [
+      3.1938747262573033
+    ],
+    "maxVelocity": [
+      5.971719443616548
+    ],
+    "maxAcceleration": [
+      6.424161406287433
+    ],
+    "maxJerk": [
+      18.03065454667337
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.998249828320834
+    ],
+    "currentVelocity": [
+      -3.9775858544730007
+    ],
+    "currentAcceleration": [
+      -0.38196869992904503
+    ],
+    "targetPosition": [
+      -7.26443294117149
+    ],
+    "targetVelocity": [
+      -2.7563217292107027
+    ],
+    "targetAcceleration": [
+      -2.4516278535143647
+    ],
+    "maxVelocity": [
+      5.998255100589034
+    ],
+    "maxAcceleration": [
+      4.680344652505592
+    ],
+    "maxJerk": [
+      6.13400205801906
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.3174061613739756
+    ],
+    "currentVelocity": [
+      -2.660698288848329
+    ],
+    "currentAcceleration": [
+      -4.4938778909744945
+    ],
+    "targetPosition": [
+      -5.410825279579496
+    ],
+    "targetVelocity": [
+      2.5628265479686574
+    ],
+    "targetAcceleration": [
+      -3.213527191392127
+    ],
+    "maxVelocity": [
+      3.674558072680102
+    ],
+    "maxAcceleration": [
+      4.750072539956035
+    ],
+    "maxJerk": [
+      19.782440574814075
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.6900478564479755
+    ],
+    "currentVelocity": [
+      0.2083030653472937
+    ],
+    "currentAcceleration": [
+      1.090352975220128
+    ],
+    "targetPosition": [
+      -5.13640731217146
+    ],
+    "targetVelocity": [
+      -1.3675107541564853
+    ],
+    "targetAcceleration": [
+      -2.544542579341364
+    ],
+    "maxVelocity": [
+      2.983774130908108
+    ],
+    "maxAcceleration": [
+      9.313960079140625
+    ],
+    "maxJerk": [
+      9.122051101033293
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.0407414769006902
+    ],
+    "currentVelocity": [
+      -3.8292965599330735
+    ],
+    "currentAcceleration": [
+      -4.2832299754648675
+    ],
+    "targetPosition": [
+      -6.620916132180481
+    ],
+    "targetVelocity": [
+      -3.722688483867162
+    ],
+    "targetAcceleration": [
+      -4.076493441172541
+    ],
+    "maxVelocity": [
+      7.246259437047819
+    ],
+    "maxAcceleration": [
+      5.987833305556838
+    ],
+    "maxJerk": [
+      9.499049713141414
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.9430659216186648
+    ],
+    "currentVelocity": [
+      0.5171572411239098
+    ],
+    "currentAcceleration": [
+      7.971289103655373
+    ],
+    "targetPosition": [
+      0.20534063717812856
+    ],
+    "targetVelocity": [
+      -1.7017335356096983
+    ],
+    "targetAcceleration": [
+      7.50805410280465
+    ],
+    "maxVelocity": [
+      3.718462089854859
+    ],
+    "maxAcceleration": [
+      8.593433660592208
+    ],
+    "maxJerk": [
+      14.124101294112206
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.058788768583225
+    ],
+    "currentVelocity": [
+      4.178927741529947
+    ],
+    "currentAcceleration": [
+      -0.2727159257097922
+    ],
+    "targetPosition": [
+      6.214324072884445
+    ],
+    "targetVelocity": [
+      1.283623281086677
+    ],
+    "targetAcceleration": [
+      6.597837225354372
+    ],
+    "maxVelocity": [
+      5.194597415685198
+    ],
+    "maxAcceleration": [
+      7.556570794162852
+    ],
+    "maxJerk": [
+      15.368440535030867
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.030187235155893
+    ],
+    "currentVelocity": [
+      -2.5741392642477385
+    ],
+    "currentAcceleration": [
+      2.549309248432623
+    ],
+    "targetPosition": [
+      -5.4646527386109085
+    ],
+    "targetVelocity": [
+      0.20282912867739622
+    ],
+    "targetAcceleration": [
+      2.9753103187109167
+    ],
+    "maxVelocity": [
+      2.598080133200069
+    ],
+    "maxAcceleration": [
+      3.0802171660918765
+    ],
+    "maxJerk": [
+      6.6234867257785535
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.1947222002085045
+    ],
+    "currentVelocity": [
+      2.175091138980034
+    ],
+    "currentAcceleration": [
+      -3.110188891124672
+    ],
+    "targetPosition": [
+      8.90649830344189
+    ],
+    "targetVelocity": [
+      -1.907830600658539
+    ],
+    "targetAcceleration": [
+      -6.9248304849128886
+    ],
+    "maxVelocity": [
+      5.8944228716617255
+    ],
+    "maxAcceleration": [
+      9.008320656647676
+    ],
+    "maxJerk": [
+      11.99223128317151
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.821249343122087
+    ],
+    "currentVelocity": [
+      -0.8588036346830119
+    ],
+    "currentAcceleration": [
+      -2.2034670485103085
+    ],
+    "targetPosition": [
+      0.9398550260341647
+    ],
+    "targetVelocity": [
+      -0.8316162168863954
+    ],
+    "targetAcceleration": [
+      4.313041554069789
+    ],
+    "maxVelocity": [
+      5.895759288177307
+    ],
+    "maxAcceleration": [
+      9.416968992771181
+    ],
+    "maxJerk": [
+      10.943551698461633
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.06109945618066
+    ],
+    "currentVelocity": [
+      0.7985393970803152
+    ],
+    "currentAcceleration": [
+      -2.9518235260756627
+    ],
+    "targetPosition": [
+      -8.608863405621843
+    ],
+    "targetVelocity": [
+      1.9681435897731632
+    ],
+    "targetAcceleration": [
+      -0.26858378603473465
+    ],
+    "maxVelocity": [
+      5.714526900315828
+    ],
+    "maxAcceleration": [
+      5.139043789457887
+    ],
+    "maxJerk": [
+      17.967647961398967
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.1847437758402055
+    ],
+    "currentVelocity": [
+      0.9522802461510045
+    ],
+    "currentAcceleration": [
+      -2.107142350950544
+    ],
+    "targetPosition": [
+      -0.6672314775497767
+    ],
+    "targetVelocity": [
+      -2.965337544613007
+    ],
+    "targetAcceleration": [
+      -0.25499707730477184
+    ],
+    "maxVelocity": [
+      4.756601836770922
+    ],
+    "maxAcceleration": [
+      6.747486522184999
+    ],
+    "maxJerk": [
+      5.628832157894729
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.7700663515349753
+    ],
+    "currentVelocity": [
+      -0.10240235457069247
+    ],
+    "currentAcceleration": [
+      -7.098721773963993
+    ],
+    "targetPosition": [
+      -4.873736977455216
+    ],
+    "targetVelocity": [
+      -5.589141863596092
+    ],
+    "targetAcceleration": [
+      -0.24790684462660906
+    ],
+    "maxVelocity": [
+      7.194459964356574
+    ],
+    "maxAcceleration": [
+      9.224923974180467
+    ],
+    "maxJerk": [
+      15.91087165667119
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.037602893685651
+    ],
+    "currentVelocity": [
+      3.1926046531391963
+    ],
+    "currentAcceleration": [
+      -0.867237586594082
+    ],
+    "targetPosition": [
+      4.481437637270533
+    ],
+    "targetVelocity": [
+      1.231058260207921
+    ],
+    "targetAcceleration": [
+      2.15617724110513
+    ],
+    "maxVelocity": [
+      5.200793342934717
+    ],
+    "maxAcceleration": [
+      5.73256646050759
+    ],
+    "maxJerk": [
+      12.467159726906118
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.7853646238607013
+    ],
+    "currentVelocity": [
+      -4.016800831676671
+    ],
+    "currentAcceleration": [
+      -1.5829129171209368
+    ],
+    "targetPosition": [
+      -9.80809087190976
+    ],
+    "targetVelocity": [
+      -5.7331692826616765
+    ],
+    "targetAcceleration": [
+      2.3999054879452277
+    ],
+    "maxVelocity": [
+      6.531105514823596
+    ],
+    "maxAcceleration": [
+      8.051089430937548
+    ],
+    "maxJerk": [
+      7.829045905412646
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.432992680407841
+    ],
+    "currentVelocity": [
+      -0.4918076334145747
+    ],
+    "currentAcceleration": [
+      -7.915416312571514
+    ],
+    "targetPosition": [
+      -0.7850289444690777
+    ],
+    "targetVelocity": [
+      -1.7332108480091213
+    ],
+    "targetAcceleration": [
+      -0.9744108155576461
+    ],
+    "maxVelocity": [
+      7.7906197192063935
+    ],
+    "maxAcceleration": [
+      8.683010938943639
+    ],
+    "maxJerk": [
+      11.269613437734517
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.225362565124476
+    ],
+    "currentVelocity": [
+      0.7671498187718648
+    ],
+    "currentAcceleration": [
+      0.26577268811567833
+    ],
+    "targetPosition": [
+      -2.0766830654224044
+    ],
+    "targetVelocity": [
+      1.2544031961214328
+    ],
+    "targetAcceleration": [
+      -0.9396471359933285
+    ],
+    "maxVelocity": [
+      2.7066135145810124
+    ],
+    "maxAcceleration": [
+      5.138173916769009
+    ],
+    "maxJerk": [
+      13.293474111723627
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.4559792016814299
+    ],
+    "currentVelocity": [
+      0.022104126925922785
+    ],
+    "currentAcceleration": [
+      -6.684189970480805
+    ],
+    "targetPosition": [
+      -9.753500635661538
+    ],
+    "targetVelocity": [
+      -0.6239802228933167
+    ],
+    "targetAcceleration": [
+      -4.065257022930508
+    ],
+    "maxVelocity": [
+      7.0556688279384066
+    ],
+    "maxAcceleration": [
+      7.495496674478087
+    ],
+    "maxJerk": [
+      13.244484074962799
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0701529110471455
+    ],
+    "currentVelocity": [
+      -0.8485041470413135
+    ],
+    "currentAcceleration": [
+      -0.7589410222572077
+    ],
+    "targetPosition": [
+      -7.369203451219177
+    ],
+    "targetVelocity": [
+      0.5210737834666008
+    ],
+    "targetAcceleration": [
+      2.841578700602323
+    ],
+    "maxVelocity": [
+      2.3300328264780075
+    ],
+    "maxAcceleration": [
+      3.8898852828377954
+    ],
+    "maxJerk": [
+      11.820917532611762
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.5972635948140237
+    ],
+    "currentVelocity": [
+      -1.1008685268316896
+    ],
+    "currentAcceleration": [
+      -2.53210311844215
+    ],
+    "targetPosition": [
+      -2.463031446521904
+    ],
+    "targetVelocity": [
+      3.3451896172092894
+    ],
+    "targetAcceleration": [
+      -3.5799437620181016
+    ],
+    "maxVelocity": [
+      5.152249137543404
+    ],
+    "maxAcceleration": [
+      3.6673670759850667
+    ],
+    "maxJerk": [
+      14.093561642426804
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.7034024019438974
+    ],
+    "currentVelocity": [
+      -5.124219106091177
+    ],
+    "currentAcceleration": [
+      5.620889685158865
+    ],
+    "targetPosition": [
+      4.928180642281397
+    ],
+    "targetVelocity": [
+      -4.2945258825434856
+    ],
+    "targetAcceleration": [
+      2.52564589728307
+    ],
+    "maxVelocity": [
+      6.559807076263359
+    ],
+    "maxAcceleration": [
+      6.11011396220937
+    ],
+    "maxJerk": [
+      19.853036153154967
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.7534119224077411
+    ],
+    "currentVelocity": [
+      3.66319963954955
+    ],
+    "currentAcceleration": [
+      -1.7013709453553307
+    ],
+    "targetPosition": [
+      -7.776600862492426
+    ],
+    "targetVelocity": [
+      1.0161960299609651
+    ],
+    "targetAcceleration": [
+      6.634995756671783
+    ],
+    "maxVelocity": [
+      4.461813883886826
+    ],
+    "maxAcceleration": [
+      7.308047997883488
+    ],
+    "maxJerk": [
+      16.945899456197726
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.208936864381876
+    ],
+    "currentVelocity": [
+      2.1069563004960754
+    ],
+    "currentAcceleration": [
+      -3.876520181909473
+    ],
+    "targetPosition": [
+      7.843021519381804
+    ],
+    "targetVelocity": [
+      -0.014559156330751222
+    ],
+    "targetAcceleration": [
+      1.4695404473467555
+    ],
+    "maxVelocity": [
+      3.841398592968419
+    ],
+    "maxAcceleration": [
+      6.714700938985105
+    ],
+    "maxJerk": [
+      11.545856394985872
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.472175890109739
+    ],
+    "currentVelocity": [
+      -4.486486205515318
+    ],
+    "currentAcceleration": [
+      -0.7041644958258089
+    ],
+    "targetPosition": [
+      -1.8387066398222078
+    ],
+    "targetVelocity": [
+      1.7089880854824262
+    ],
+    "targetAcceleration": [
+      0.8685745556162927
+    ],
+    "maxVelocity": [
+      4.647550104285131
+    ],
+    "maxAcceleration": [
+      3.6482923499199127
+    ],
+    "maxJerk": [
+      11.624333693471465
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.3502065986753795
+    ],
+    "currentVelocity": [
+      3.8528753482944857
+    ],
+    "currentAcceleration": [
+      1.2770028514667855
+    ],
+    "targetPosition": [
+      3.3741708466226576
+    ],
+    "targetVelocity": [
+      4.716532757345721
+    ],
+    "targetAcceleration": [
+      0.570948431968092
+    ],
+    "maxVelocity": [
+      6.8494011983039
+    ],
+    "maxAcceleration": [
+      7.577971264784138
+    ],
+    "maxJerk": [
+      9.522296017102738
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.8067795459988609
+    ],
+    "currentVelocity": [
+      -1.7688470599494002
+    ],
+    "currentAcceleration": [
+      -0.24440231824415193
+    ],
+    "targetPosition": [
+      1.674631385022634
+    ],
+    "targetVelocity": [
+      -0.09628663015475603
+    ],
+    "targetAcceleration": [
+      -1.0098057713159783
+    ],
+    "maxVelocity": [
+      5.856193633059659
+    ],
+    "maxAcceleration": [
+      4.522718653974591
+    ],
+    "maxJerk": [
+      6.3056576880247155
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.4354227430129995
+    ],
+    "currentVelocity": [
+      1.755375487109459
+    ],
+    "currentAcceleration": [
+      3.7823623861432507
+    ],
+    "targetPosition": [
+      9.94926235641551
+    ],
+    "targetVelocity": [
+      1.5717851687760755
+    ],
+    "targetAcceleration": [
+      3.544395733550771
+    ],
+    "maxVelocity": [
+      2.1823133278651414
+    ],
+    "maxAcceleration": [
+      5.401918368245252
+    ],
+    "maxJerk": [
+      18.766247967698163
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.2129425314245008
+    ],
+    "currentVelocity": [
+      -0.7947532655650296
+    ],
+    "currentAcceleration": [
+      -2.009647274913474
+    ],
+    "targetPosition": [
+      -0.13673160300015752
+    ],
+    "targetVelocity": [
+      1.064423620843277
+    ],
+    "targetAcceleration": [
+      2.261781364105441
+    ],
+    "maxVelocity": [
+      4.97828403469763
+    ],
+    "maxAcceleration": [
+      3.236824499685845
+    ],
+    "maxJerk": [
+      5.804395436004637
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.056354544349073
+    ],
+    "currentVelocity": [
+      -3.507543608106759
+    ],
+    "currentAcceleration": [
+      -4.704905155260897
+    ],
+    "targetPosition": [
+      -2.5014299160614417
+    ],
+    "targetVelocity": [
+      -1.5612463391832359
+    ],
+    "targetAcceleration": [
+      -2.352661387387001
+    ],
+    "maxVelocity": [
+      6.797586848283647
+    ],
+    "maxAcceleration": [
+      6.784827653799553
+    ],
+    "maxJerk": [
+      19.29188929933715
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.36657271567324123
+    ],
+    "currentVelocity": [
+      -2.8965539517625833
+    ],
+    "currentAcceleration": [
+      -1.7684879808658902
+    ],
+    "targetPosition": [
+      -3.3927978690689304
+    ],
+    "targetVelocity": [
+      -1.2730370545479706
+    ],
+    "targetAcceleration": [
+      -4.066187600117958
+    ],
+    "maxVelocity": [
+      3.0261995534361334
+    ],
+    "maxAcceleration": [
+      7.927963868305811
+    ],
+    "maxJerk": [
+      14.137079274784469
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.1884379457710885
+    ],
+    "currentVelocity": [
+      -2.157520656038751
+    ],
+    "currentAcceleration": [
+      0.7453967064968605
+    ],
+    "targetPosition": [
+      -3.699739253561159
+    ],
+    "targetVelocity": [
+      4.930224255486659
+    ],
+    "targetAcceleration": [
+      5.029373911334214
+    ],
+    "maxVelocity": [
+      7.723150796844064
+    ],
+    "maxAcceleration": [
+      5.739978039545604
+    ],
+    "maxJerk": [
+      19.46730279013871
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.831232736576705
+    ],
+    "currentVelocity": [
+      -2.054805872480907
+    ],
+    "currentAcceleration": [
+      -7.095529392716081
+    ],
+    "targetPosition": [
+      0.5155264720678225
+    ],
+    "targetVelocity": [
+      0.05497807265523047
+    ],
+    "targetAcceleration": [
+      2.585318492587458
+    ],
+    "maxVelocity": [
+      4.725038082295841
+    ],
+    "maxAcceleration": [
+      8.928616411289443
+    ],
+    "maxJerk": [
+      18.806452518492357
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.899875372298442
+    ],
+    "currentVelocity": [
+      2.366906637297851
+    ],
+    "currentAcceleration": [
+      3.444510807897209
+    ],
+    "targetPosition": [
+      -4.732193668521174
+    ],
+    "targetVelocity": [
+      -3.541345720799201
+    ],
+    "targetAcceleration": [
+      -4.291609281783034
+    ],
+    "maxVelocity": [
+      6.207437448274585
+    ],
+    "maxAcceleration": [
+      4.416768449695677
+    ],
+    "maxJerk": [
+      15.510367823005216
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.6741522188083202
+    ],
+    "currentVelocity": [
+      0.9042205919293664
+    ],
+    "currentAcceleration": [
+      4.421586108957152
+    ],
+    "targetPosition": [
+      1.6867337534640985
+    ],
+    "targetVelocity": [
+      5.609532218644454
+    ],
+    "targetAcceleration": [
+      6.194124732705607
+    ],
+    "maxVelocity": [
+      5.906338144735403
+    ],
+    "maxAcceleration": [
+      7.337663019488618
+    ],
+    "maxJerk": [
+      19.7431816694138
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.736677400163654
+    ],
+    "currentVelocity": [
+      -2.6916080217671885
+    ],
+    "currentAcceleration": [
+      -1.175255076979361
+    ],
+    "targetPosition": [
+      -4.6261484241816
+    ],
+    "targetVelocity": [
+      0.3415412190303684
+    ],
+    "targetAcceleration": [
+      0.31619426247959126
+    ],
+    "maxVelocity": [
+      5.023860347288414
+    ],
+    "maxAcceleration": [
+      4.278205138894512
+    ],
+    "maxJerk": [
+      12.946884991705696
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.0031738302925355
+    ],
+    "currentVelocity": [
+      -0.5134399924282762
+    ],
+    "currentAcceleration": [
+      7.402279291996686
+    ],
+    "targetPosition": [
+      -4.2405317476337085
+    ],
+    "targetVelocity": [
+      0.5882120923767973
+    ],
+    "targetAcceleration": [
+      6.754613147242658
+    ],
+    "maxVelocity": [
+      2.394320648598572
+    ],
+    "maxAcceleration": [
+      8.175385615036124
+    ],
+    "maxJerk": [
+      19.328960377197642
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.815384734774664
+    ],
+    "currentVelocity": [
+      2.6996733119094154
+    ],
+    "currentAcceleration": [
+      2.583235929851707
+    ],
+    "targetPosition": [
+      3.7324420325663805
+    ],
+    "targetVelocity": [
+      0.7956506830300789
+    ],
+    "targetAcceleration": [
+      -1.4175529382718226
+    ],
+    "maxVelocity": [
+      3.4451731475346703
+    ],
+    "maxAcceleration": [
+      6.295362676184448
+    ],
+    "maxJerk": [
+      10.598658321860349
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.8031339332596747
+    ],
+    "currentVelocity": [
+      -3.7637258976379626
+    ],
+    "currentAcceleration": [
+      0.7646749952908403
+    ],
+    "targetPosition": [
+      6.715555731685235
+    ],
+    "targetVelocity": [
+      1.340430116302314
+    ],
+    "targetAcceleration": [
+      -2.309698982509084
+    ],
+    "maxVelocity": [
+      5.779576168790957
+    ],
+    "maxAcceleration": [
+      3.6909250000144826
+    ],
+    "maxJerk": [
+      14.677800940234642
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.243499423147494
+    ],
+    "currentVelocity": [
+      -2.639342507268696
+    ],
+    "currentAcceleration": [
+      0.11305485848164487
+    ],
+    "targetPosition": [
+      0.6419990702783807
+    ],
+    "targetVelocity": [
+      4.804508591766684
+    ],
+    "targetAcceleration": [
+      3.607130378795121
+    ],
+    "maxVelocity": [
+      5.017123813666943
+    ],
+    "maxAcceleration": [
+      4.404974440509951
+    ],
+    "maxJerk": [
+      10.931068590704237
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.968513981982028
+    ],
+    "currentVelocity": [
+      -3.7279858580515315
+    ],
+    "currentAcceleration": [
+      3.9824547204976692
+    ],
+    "targetPosition": [
+      -4.571518716315897
+    ],
+    "targetVelocity": [
+      -1.344493998224236
+    ],
+    "targetAcceleration": [
+      2.3464837431380587
+    ],
+    "maxVelocity": [
+      4.382277317426908
+    ],
+    "maxAcceleration": [
+      5.560885058130648
+    ],
+    "maxJerk": [
+      7.048630168863372
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.586482970400636
+    ],
+    "currentVelocity": [
+      -3.716011256375883
+    ],
+    "currentAcceleration": [
+      2.2068651491161955
+    ],
+    "targetPosition": [
+      -3.0947274501252675
+    ],
+    "targetVelocity": [
+      -2.015473147525168
+    ],
+    "targetAcceleration": [
+      2.433821018245089
+    ],
+    "maxVelocity": [
+      4.719132062111276
+    ],
+    "maxAcceleration": [
+      7.300568470912372
+    ],
+    "maxJerk": [
+      18.693459269027784
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.5399310979417
+    ],
+    "currentVelocity": [
+      -5.617654230112627
+    ],
+    "currentAcceleration": [
+      3.2094340907601087
+    ],
+    "targetPosition": [
+      -5.8865369237474034
+    ],
+    "targetVelocity": [
+      -0.9463207902125657
+    ],
+    "targetAcceleration": [
+      6.524289631767951
+    ],
+    "maxVelocity": [
+      7.975321907464189
+    ],
+    "maxAcceleration": [
+      8.633309589573454
+    ],
+    "maxJerk": [
+      19.868149828858165
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.6353456519673024
+    ],
+    "currentVelocity": [
+      -2.6701075561382357
+    ],
+    "currentAcceleration": [
+      1.9949134297984328
+    ],
+    "targetPosition": [
+      -5.323608457824525
+    ],
+    "targetVelocity": [
+      3.3021124177290613
+    ],
+    "targetAcceleration": [
+      2.295175832011446
+    ],
+    "maxVelocity": [
+      4.021011141370414
+    ],
+    "maxAcceleration": [
+      4.158444744942704
+    ],
+    "maxJerk": [
+      11.688282404337949
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.115696809513091
+    ],
+    "currentVelocity": [
+      1.9758795948195367
+    ],
+    "currentAcceleration": [
+      3.2988462613661653
+    ],
+    "targetPosition": [
+      -8.543222825323449
+    ],
+    "targetVelocity": [
+      -5.203548946525073
+    ],
+    "targetAcceleration": [
+      -6.5383513684248005
+    ],
+    "maxVelocity": [
+      5.536017387809478
+    ],
+    "maxAcceleration": [
+      8.756835155697878
+    ],
+    "maxJerk": [
+      18.792026170466848
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.79475441396244
+    ],
+    "currentVelocity": [
+      -1.4791897130194638
+    ],
+    "currentAcceleration": [
+      -4.339638743153997
+    ],
+    "targetPosition": [
+      -3.4318734920860354
+    ],
+    "targetVelocity": [
+      -4.49577338255643
+    ],
+    "targetAcceleration": [
+      4.002405764253145
+    ],
+    "maxVelocity": [
+      6.109070251393966
+    ],
+    "maxAcceleration": [
+      5.35011768873428
+    ],
+    "maxJerk": [
+      9.367647998815777
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.267938869160734
+    ],
+    "currentVelocity": [
+      3.7561178082581534
+    ],
+    "currentAcceleration": [
+      -0.7580489068499361
+    ],
+    "targetPosition": [
+      9.901089462053502
+    ],
+    "targetVelocity": [
+      2.3458980418532738
+    ],
+    "targetAcceleration": [
+      -4.579671061385863
+    ],
+    "maxVelocity": [
+      3.7729715662789527
+    ],
+    "maxAcceleration": [
+      6.0935216257894345
+    ],
+    "maxJerk": [
+      16.16053859969741
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.315926097902
+    ],
+    "currentVelocity": [
+      -0.6596511616945566
+    ],
+    "currentAcceleration": [
+      5.797353651412078
+    ],
+    "targetPosition": [
+      9.963850194804632
+    ],
+    "targetVelocity": [
+      2.1247532892101875
+    ],
+    "targetAcceleration": [
+      4.86076586682002
+    ],
+    "maxVelocity": [
+      6.479087435389988
+    ],
+    "maxAcceleration": [
+      5.825530324749349
+    ],
+    "maxJerk": [
+      9.085313955816076
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.2549535885256455
+    ],
+    "currentVelocity": [
+      -2.5946526084316717
+    ],
+    "currentAcceleration": [
+      0.0506258586659607
+    ],
+    "targetPosition": [
+      8.857650754399838
+    ],
+    "targetVelocity": [
+      -0.4275959906300786
+    ],
+    "targetAcceleration": [
+      3.777059301730092
+    ],
+    "maxVelocity": [
+      3.515206353713203
+    ],
+    "maxAcceleration": [
+      4.697773769774792
+    ],
+    "maxJerk": [
+      7.786728646321764
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.9484413255450157
+    ],
+    "currentVelocity": [
+      -5.534783532442184
+    ],
+    "currentAcceleration": [
+      4.565029666892484
+    ],
+    "targetPosition": [
+      1.2308016998053954
+    ],
+    "targetVelocity": [
+      4.794724532353419
+    ],
+    "targetAcceleration": [
+      -0.801313276416896
+    ],
+    "maxVelocity": [
+      7.523679864963146
+    ],
+    "maxAcceleration": [
+      5.9267702217226015
+    ],
+    "maxJerk": [
+      7.0462391095340475
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.4117940535299383
+    ],
+    "currentVelocity": [
+      0.7501506970005147
+    ],
+    "currentAcceleration": [
+      7.7754191222637985
+    ],
+    "targetPosition": [
+      1.2082142152805595
+    ],
+    "targetVelocity": [
+      -3.888935052064305
+    ],
+    "targetAcceleration": [
+      -7.448650857034215
+    ],
+    "maxVelocity": [
+      7.423175766707778
+    ],
+    "maxAcceleration": [
+      8.74437300951168
+    ],
+    "maxJerk": [
+      17.5324232724669
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.086665011321589
+    ],
+    "currentVelocity": [
+      5.207144718420371
+    ],
+    "currentAcceleration": [
+      0.1823211343517004
+    ],
+    "targetPosition": [
+      6.672634471572589
+    ],
+    "targetVelocity": [
+      -4.218968808818595
+    ],
+    "targetAcceleration": [
+      -0.8791527566858592
+    ],
+    "maxVelocity": [
+      5.6824820166690495
+    ],
+    "maxAcceleration": [
+      5.440122316200616
+    ],
+    "maxJerk": [
+      17.70864230256958
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.7523425716774454
+    ],
+    "currentVelocity": [
+      -2.032619846006711
+    ],
+    "currentAcceleration": [
+      -1.8759752027452326
+    ],
+    "targetPosition": [
+      -6.745180757390403
+    ],
+    "targetVelocity": [
+      0.45029616002582884
+    ],
+    "targetAcceleration": [
+      -2.9539357202161707
+    ],
+    "maxVelocity": [
+      4.096627720649795
+    ],
+    "maxAcceleration": [
+      4.648949606733234
+    ],
+    "maxJerk": [
+      7.961066216493059
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.8744523464670007
+    ],
+    "currentVelocity": [
+      5.116924263745067
+    ],
+    "currentAcceleration": [
+      0.6467441851794287
+    ],
+    "targetPosition": [
+      -8.427205620371037
+    ],
+    "targetVelocity": [
+      -0.2678360929224848
+    ],
+    "targetAcceleration": [
+      -1.9380939333510907
+    ],
+    "maxVelocity": [
+      5.976320665244002
+    ],
+    "maxAcceleration": [
+      3.7544292544653293
+    ],
+    "maxJerk": [
+      17.995339588253618
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.998546506581542
+    ],
+    "currentVelocity": [
+      -0.16607105572673486
+    ],
+    "currentAcceleration": [
+      1.1726364370325335
+    ],
+    "targetPosition": [
+      -7.610874718611176
+    ],
+    "targetVelocity": [
+      -0.05648194807771123
+    ],
+    "targetAcceleration": [
+      -3.389871144823978
+    ],
+    "maxVelocity": [
+      4.464757255281805
+    ],
+    "maxAcceleration": [
+      4.0372989774567225
+    ],
+    "maxJerk": [
+      12.324972310318373
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.85562656591701
+    ],
+    "currentVelocity": [
+      -3.650011828994096
+    ],
+    "currentAcceleration": [
+      -3.7915877820264
+    ],
+    "targetPosition": [
+      3.0806487355287775
+    ],
+    "targetVelocity": [
+      -5.072762004840355
+    ],
+    "targetAcceleration": [
+      -1.4439695146507256
+    ],
+    "maxVelocity": [
+      5.712517217166152
+    ],
+    "maxAcceleration": [
+      6.64259015469687
+    ],
+    "maxJerk": [
+      13.819681848584896
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.9967623621387567
+    ],
+    "currentVelocity": [
+      3.132710751002503
+    ],
+    "currentAcceleration": [
+      3.284826971124608
+    ],
+    "targetPosition": [
+      0.037293131743261654
+    ],
+    "targetVelocity": [
+      2.301857473527858
+    ],
+    "targetAcceleration": [
+      -0.9774356790002479
+    ],
+    "maxVelocity": [
+      5.634124156484332
+    ],
+    "maxAcceleration": [
+      3.4651424310090873
+    ],
+    "maxJerk": [
+      18.808791808484166
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.4352827455483332
+    ],
+    "currentVelocity": [
+      3.01315394527113
+    ],
+    "currentAcceleration": [
+      -2.6013927169709783
+    ],
+    "targetPosition": [
+      6.259227961784703
+    ],
+    "targetVelocity": [
+      -0.8199661172042925
+    ],
+    "targetAcceleration": [
+      3.539711697548091
+    ],
+    "maxVelocity": [
+      6.507194402000016
+    ],
+    "maxAcceleration": [
+      4.562018407827116
+    ],
+    "maxJerk": [
+      13.451692940035283
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.5092893296138161
+    ],
+    "currentVelocity": [
+      -1.4876497897695549
+    ],
+    "currentAcceleration": [
+      -5.553733592162488
+    ],
+    "targetPosition": [
+      -1.399640884562185
+    ],
+    "targetVelocity": [
+      3.1509617306917868
+    ],
+    "targetAcceleration": [
+      5.234727376471594
+    ],
+    "maxVelocity": [
+      5.836521325425773
+    ],
+    "maxAcceleration": [
+      6.6396739491155214
+    ],
+    "maxJerk": [
+      9.507338139720613
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.3497986478656276
+    ],
+    "currentVelocity": [
+      1.3173416677438823
+    ],
+    "currentAcceleration": [
+      5.039771096600136
+    ],
+    "targetPosition": [
+      -8.086021831762087
+    ],
+    "targetVelocity": [
+      -0.428639645029925
+    ],
+    "targetAcceleration": [
+      4.542651619241353
+    ],
+    "maxVelocity": [
+      5.061473573560605
+    ],
+    "maxAcceleration": [
+      6.125037319211177
+    ],
+    "maxJerk": [
+      10.087573062004974
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.7850945775243883
+    ],
+    "currentVelocity": [
+      -2.9091840681751076
+    ],
+    "currentAcceleration": [
+      -4.943484467520072
+    ],
+    "targetPosition": [
+      6.09056632699253
+    ],
+    "targetVelocity": [
+      4.633157773262024
+    ],
+    "targetAcceleration": [
+      3.0609937814779338
+    ],
+    "maxVelocity": [
+      5.213920641724176
+    ],
+    "maxAcceleration": [
+      5.701580555160937
+    ],
+    "maxJerk": [
+      10.190417825392897
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.052650922101883
+    ],
+    "currentVelocity": [
+      -3.542313215672821
+    ],
+    "currentAcceleration": [
+      -0.4671484334893483
+    ],
+    "targetPosition": [
+      8.288437507216702
+    ],
+    "targetVelocity": [
+      2.268489787920733
+    ],
+    "targetAcceleration": [
+      0.9308193722082843
+    ],
+    "maxVelocity": [
+      4.356187920886782
+    ],
+    "maxAcceleration": [
+      3.0462585769539876
+    ],
+    "maxJerk": [
+      15.05466828089387
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.498300775111071
+    ],
+    "currentVelocity": [
+      2.9973076978413102
+    ],
+    "currentAcceleration": [
+      0.8226367610388587
+    ],
+    "targetPosition": [
+      -3.1309444526413515
+    ],
+    "targetVelocity": [
+      1.404041167241104
+    ],
+    "targetAcceleration": [
+      -2.7410888641075193
+    ],
+    "maxVelocity": [
+      3.6096396853955195
+    ],
+    "maxAcceleration": [
+      4.006202644248583
+    ],
+    "maxJerk": [
+      5.56828216577053
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.966583468924721
+    ],
+    "currentVelocity": [
+      3.098764443272273
+    ],
+    "currentAcceleration": [
+      -0.8143891057994379
+    ],
+    "targetPosition": [
+      -7.1355879671766225
+    ],
+    "targetVelocity": [
+      -1.4819729024973416
+    ],
+    "targetAcceleration": [
+      -6.287986100413165
+    ],
+    "maxVelocity": [
+      4.376825978017955
+    ],
+    "maxAcceleration": [
+      6.469893975656962
+    ],
+    "maxJerk": [
+      19.980575783911615
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.280101935939589
+    ],
+    "currentVelocity": [
+      0.5885049833225402
+    ],
+    "currentAcceleration": [
+      -1.0587547078271207
+    ],
+    "targetPosition": [
+      -4.0866013158587045
+    ],
+    "targetVelocity": [
+      1.7204262123377898
+    ],
+    "targetAcceleration": [
+      -1.691895891813744
+    ],
+    "maxVelocity": [
+      4.0597897726673375
+    ],
+    "maxAcceleration": [
+      3.045575229998925
+    ],
+    "maxJerk": [
+      9.107900966422987
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.921796057102199
+    ],
+    "currentVelocity": [
+      3.426734249939239
+    ],
+    "currentAcceleration": [
+      -1.4280819210240763
+    ],
+    "targetPosition": [
+      -0.8691790951238083
+    ],
+    "targetVelocity": [
+      -1.5306852293644653
+    ],
+    "targetAcceleration": [
+      -4.003843137980002
+    ],
+    "maxVelocity": [
+      3.951413187337959
+    ],
+    "maxAcceleration": [
+      7.60280461651158
+    ],
+    "maxJerk": [
+      6.7414994594884625
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.787167282531684
+    ],
+    "currentVelocity": [
+      2.4036095465285925
+    ],
+    "currentAcceleration": [
+      2.3843818898194655
+    ],
+    "targetPosition": [
+      4.188183752148763
+    ],
+    "targetVelocity": [
+      -4.374149597935105
+    ],
+    "targetAcceleration": [
+      2.1707202235146745
+    ],
+    "maxVelocity": [
+      5.129100703870414
+    ],
+    "maxAcceleration": [
+      5.780061241935188
+    ],
+    "maxJerk": [
+      5.25636627849212
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.019254788594925
+    ],
+    "currentVelocity": [
+      -1.1210518578399649
+    ],
+    "currentAcceleration": [
+      -2.140476910442106
+    ],
+    "targetPosition": [
+      -6.689667183377033
+    ],
+    "targetVelocity": [
+      -0.9857427577351068
+    ],
+    "targetAcceleration": [
+      -2.3614353150447247
+    ],
+    "maxVelocity": [
+      5.855556865532581
+    ],
+    "maxAcceleration": [
+      7.9663150000008045
+    ],
+    "maxJerk": [
+      13.423859473585534
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.29553552296877
+    ],
+    "currentVelocity": [
+      -0.6638404096300721
+    ],
+    "currentAcceleration": [
+      -6.647613689005271
+    ],
+    "targetPosition": [
+      8.995689401251198
+    ],
+    "targetVelocity": [
+      -0.7808259535198121
+    ],
+    "targetAcceleration": [
+      4.5836463450757154
+    ],
+    "maxVelocity": [
+      4.3043908057321705
+    ],
+    "maxAcceleration": [
+      6.732455523259318
+    ],
+    "maxJerk": [
+      17.308759341394513
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.799927474882576
+    ],
+    "currentVelocity": [
+      3.4386845330248894
+    ],
+    "currentAcceleration": [
+      3.5422253295719113
+    ],
+    "targetPosition": [
+      -2.293254585681554
+    ],
+    "targetVelocity": [
+      -1.0656554907665052
+    ],
+    "targetAcceleration": [
+      1.8758914102346722
+    ],
+    "maxVelocity": [
+      4.1198884947505645
+    ],
+    "maxAcceleration": [
+      9.618897406550767
+    ],
+    "maxJerk": [
+      11.916396608765687
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.7763260551586484
+    ],
+    "currentVelocity": [
+      -5.1307106480634666
+    ],
+    "currentAcceleration": [
+      6.435958080331055
+    ],
+    "targetPosition": [
+      -4.733174189550249
+    ],
+    "targetVelocity": [
+      -2.0062430734853773
+    ],
+    "targetAcceleration": [
+      -0.664063405385602
+    ],
+    "maxVelocity": [
+      6.208005536703329
+    ],
+    "maxAcceleration": [
+      6.741088521171095
+    ],
+    "maxJerk": [
+      17.54617558102322
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.9766406926423272
+    ],
+    "currentVelocity": [
+      0.5003380496414209
+    ],
+    "currentAcceleration": [
+      -5.67092245425503
+    ],
+    "targetPosition": [
+      -0.06410998813898416
+    ],
+    "targetVelocity": [
+      4.07690891679899
+    ],
+    "targetAcceleration": [
+      3.791737017516853
+    ],
+    "maxVelocity": [
+      6.733888652712304
+    ],
+    "maxAcceleration": [
+      9.672042477591091
+    ],
+    "maxJerk": [
+      18.900552391763622
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.607554883535812
+    ],
+    "currentVelocity": [
+      -0.9001376189831118
+    ],
+    "currentAcceleration": [
+      2.8924757991642833
+    ],
+    "targetPosition": [
+      1.526649403599107
+    ],
+    "targetVelocity": [
+      0.21539320753986768
+    ],
+    "targetAcceleration": [
+      -0.2396721577934784
+    ],
+    "maxVelocity": [
+      6.42613558463516
+    ],
+    "maxAcceleration": [
+      7.827711648636993
+    ],
+    "maxJerk": [
+      11.543752725526822
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.478393030620461
+    ],
+    "currentVelocity": [
+      1.4658358154356925
+    ],
+    "currentAcceleration": [
+      -0.2792606810306193
+    ],
+    "targetPosition": [
+      -9.616712630962652
+    ],
+    "targetVelocity": [
+      1.263224511902549
+    ],
+    "targetAcceleration": [
+      -5.354654358838767
+    ],
+    "maxVelocity": [
+      6.663615687389459
+    ],
+    "maxAcceleration": [
+      8.73423696224831
+    ],
+    "maxJerk": [
+      15.838495999715066
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.958566797566142
+    ],
+    "currentVelocity": [
+      -2.209324478663294
+    ],
+    "currentAcceleration": [
+      6.610504880441598
+    ],
+    "targetPosition": [
+      -5.186923604453339
+    ],
+    "targetVelocity": [
+      -1.9730670006393625
+    ],
+    "targetAcceleration": [
+      4.464872942092633
+    ],
+    "maxVelocity": [
+      2.9524586220870983
+    ],
+    "maxAcceleration": [
+      6.681846421251983
+    ],
+    "maxJerk": [
+      16.673835059376643
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.160055209221912
+    ],
+    "currentVelocity": [
+      -3.0523980666331534
+    ],
+    "currentAcceleration": [
+      0.03317355483663054
+    ],
+    "targetPosition": [
+      -1.0174273209531766
+    ],
+    "targetVelocity": [
+      4.020330146743763
+    ],
+    "targetAcceleration": [
+      -1.8433100487058596
+    ],
+    "maxVelocity": [
+      4.396548170268666
+    ],
+    "maxAcceleration": [
+      5.103123679664612
+    ],
+    "maxJerk": [
+      5.732656877677727
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.996954292556936
+    ],
+    "currentVelocity": [
+      -3.2557241896711755
+    ],
+    "currentAcceleration": [
+      2.0752136807455654
+    ],
+    "targetPosition": [
+      -9.96708150834353
+    ],
+    "targetVelocity": [
+      -1.7926023003601992
+    ],
+    "targetAcceleration": [
+      -2.9302403422804106
+    ],
+    "maxVelocity": [
+      3.3300884420256445
+    ],
+    "maxAcceleration": [
+      4.587672180530585
+    ],
+    "maxJerk": [
+      14.915798550082984
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.3353084920008023
+    ],
+    "currentVelocity": [
+      -4.178711180270909
+    ],
+    "currentAcceleration": [
+      -0.06448810763166835
+    ],
+    "targetPosition": [
+      -2.696143491319642
+    ],
+    "targetVelocity": [
+      -4.612922127834903
+    ],
+    "targetAcceleration": [
+      -2.029479842713592
+    ],
+    "maxVelocity": [
+      6.5023746854076006
+    ],
+    "maxAcceleration": [
+      4.0155830130844965
+    ],
+    "maxJerk": [
+      7.741586109572788
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.00817244366494
+    ],
+    "currentVelocity": [
+      -5.8957931353052695
+    ],
+    "currentAcceleration": [
+      1.1355819525122097
+    ],
+    "targetPosition": [
+      8.367425874912893
+    ],
+    "targetVelocity": [
+      -2.1683199695834885
+    ],
+    "targetAcceleration": [
+      6.04870128638011
+    ],
+    "maxVelocity": [
+      7.252344577875103
+    ],
+    "maxAcceleration": [
+      7.237472791517108
+    ],
+    "maxJerk": [
+      6.460427985276913
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.982614677516423
+    ],
+    "currentVelocity": [
+      -0.27406376455072223
+    ],
+    "currentAcceleration": [
+      -1.5874581895375246
+    ],
+    "targetPosition": [
+      -5.989208920328384
+    ],
+    "targetVelocity": [
+      -2.381424962441388
+    ],
+    "targetAcceleration": [
+      -0.07597548801212373
+    ],
+    "maxVelocity": [
+      4.2400100333421165
+    ],
+    "maxAcceleration": [
+      5.119768770140281
+    ],
+    "maxJerk": [
+      14.468383616362193
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.2955081385977909
+    ],
+    "currentVelocity": [
+      4.440624430599721
+    ],
+    "currentAcceleration": [
+      -2.928875927583263
+    ],
+    "targetPosition": [
+      -4.944459724520929
+    ],
+    "targetVelocity": [
+      -1.7305473257127373
+    ],
+    "targetAcceleration": [
+      -6.7093775068005055
+    ],
+    "maxVelocity": [
+      5.864811487348883
+    ],
+    "maxAcceleration": [
+      9.453977180637585
+    ],
+    "maxJerk": [
+      14.233922866877768
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.9585995060460366
+    ],
+    "currentVelocity": [
+      -3.190630318558219
+    ],
+    "currentAcceleration": [
+      4.083578931209144
+    ],
+    "targetPosition": [
+      -1.9806873420260924
+    ],
+    "targetVelocity": [
+      -2.418900503036973
+    ],
+    "targetAcceleration": [
+      0.4771732771008734
+    ],
+    "maxVelocity": [
+      6.543414624396318
+    ],
+    "maxAcceleration": [
+      7.126896637386024
+    ],
+    "maxJerk": [
+      13.630131303091972
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.5462942405217746
+    ],
+    "currentVelocity": [
+      -3.429029641862179
+    ],
+    "currentAcceleration": [
+      -2.5590469584549282
+    ],
+    "targetPosition": [
+      2.9443074227226873
+    ],
+    "targetVelocity": [
+      -2.4489717625921843
+    ],
+    "targetAcceleration": [
+      -3.830442948221843
+    ],
+    "maxVelocity": [
+      3.8046985135628018
+    ],
+    "maxAcceleration": [
+      7.813622093373859
+    ],
+    "maxJerk": [
+      11.453638137340615
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.3241608208747806
+    ],
+    "currentVelocity": [
+      -1.0309513017040288
+    ],
+    "currentAcceleration": [
+      -0.2683731206859399
+    ],
+    "targetPosition": [
+      6.608112715631247
+    ],
+    "targetVelocity": [
+      -2.6391894306160544
+    ],
+    "targetAcceleration": [
+      1.1368238865094225
+    ],
+    "maxVelocity": [
+      5.283744220540882
+    ],
+    "maxAcceleration": [
+      3.4102926377814984
+    ],
+    "maxJerk": [
+      13.965940531541506
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.8114403184603187
+    ],
+    "currentVelocity": [
+      -2.6479061668959782
+    ],
+    "currentAcceleration": [
+      2.553033503134122
+    ],
+    "targetPosition": [
+      -1.5518487065417155
+    ],
+    "targetVelocity": [
+      -1.483628824376738
+    ],
+    "targetAcceleration": [
+      0.25446256783745014
+    ],
+    "maxVelocity": [
+      5.797676792001423
+    ],
+    "maxAcceleration": [
+      8.819908413292765
+    ],
+    "maxJerk": [
+      11.396780831569007
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.997724501824834
+    ],
+    "currentVelocity": [
+      2.1400645775035825
+    ],
+    "currentAcceleration": [
+      1.4656446783833053
+    ],
+    "targetPosition": [
+      9.225653628635207
+    ],
+    "targetVelocity": [
+      -5.31644192891943
+    ],
+    "targetAcceleration": [
+      2.065676436788044
+    ],
+    "maxVelocity": [
+      5.77365191505699
+    ],
+    "maxAcceleration": [
+      3.148024837943111
+    ],
+    "maxJerk": [
+      15.4312547168068
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.8138376323703547
+    ],
+    "currentVelocity": [
+      -1.2613217205099654
+    ],
+    "currentAcceleration": [
+      2.298783539745595
+    ],
+    "targetPosition": [
+      -4.592916770739198
+    ],
+    "targetVelocity": [
+      2.017657314863219
+    ],
+    "targetAcceleration": [
+      0.5208464566093154
+    ],
+    "maxVelocity": [
+      2.5402997605687947
+    ],
+    "maxAcceleration": [
+      5.654566405245288
+    ],
+    "maxJerk": [
+      12.240293873789483
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.058850381301616
+    ],
+    "currentVelocity": [
+      0.16073908277442595
+    ],
+    "currentAcceleration": [
+      -3.3537272063190837
+    ],
+    "targetPosition": [
+      4.136208265067765
+    ],
+    "targetVelocity": [
+      -1.209725132044067
+    ],
+    "targetAcceleration": [
+      1.1926504189914997
+    ],
+    "maxVelocity": [
+      5.684773491295309
+    ],
+    "maxAcceleration": [
+      5.03142919632411
+    ],
+    "maxJerk": [
+      12.040289666040717
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.2315835037770917
+    ],
+    "currentVelocity": [
+      -1.9123390142238827
+    ],
+    "currentAcceleration": [
+      -4.145560144373316
+    ],
+    "targetPosition": [
+      -9.928297319294613
+    ],
+    "targetVelocity": [
+      2.665579969397811
+    ],
+    "targetAcceleration": [
+      -1.9084422854721055
+    ],
+    "maxVelocity": [
+      6.81837964231393
+    ],
+    "maxAcceleration": [
+      4.750665952079222
+    ],
+    "maxJerk": [
+      14.458324610197982
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.358358917403677
+    ],
+    "currentVelocity": [
+      2.1276350277655274
+    ],
+    "currentAcceleration": [
+      2.2826674367319804
+    ],
+    "targetPosition": [
+      -9.14780881277837
+    ],
+    "targetVelocity": [
+      -1.9959540886041385
+    ],
+    "targetAcceleration": [
+      3.4205477403435527
+    ],
+    "maxVelocity": [
+      4.1515669194403175
+    ],
+    "maxAcceleration": [
+      6.719830227115656
+    ],
+    "maxJerk": [
+      13.764761005044223
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.015739974021462544
+    ],
+    "currentVelocity": [
+      -3.321534215979595
+    ],
+    "currentAcceleration": [
+      1.7557061703414636
+    ],
+    "targetPosition": [
+      -5.443658189025744
+    ],
+    "targetVelocity": [
+      2.8474982979816756
+    ],
+    "targetAcceleration": [
+      0.4646614095628694
+    ],
+    "maxVelocity": [
+      5.098400522577871
+    ],
+    "maxAcceleration": [
+      5.7145691534333745
+    ],
+    "maxJerk": [
+      10.095960479500423
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.0561390036856784
+    ],
+    "currentVelocity": [
+      2.561233953938655
+    ],
+    "currentAcceleration": [
+      5.794270595230307
+    ],
+    "targetPosition": [
+      1.0651560097231325
+    ],
+    "targetVelocity": [
+      1.1242622360105123
+    ],
+    "targetAcceleration": [
+      -5.731572435101741
+    ],
+    "maxVelocity": [
+      5.38903350915716
+    ],
+    "maxAcceleration": [
+      7.919839026169463
+    ],
+    "maxJerk": [
+      15.501522531053558
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.888782394730562
+    ],
+    "currentVelocity": [
+      -0.9426690882222282
+    ],
+    "currentAcceleration": [
+      4.094445599732608
+    ],
+    "targetPosition": [
+      2.313862852938648
+    ],
+    "targetVelocity": [
+      0.593502092544965
+    ],
+    "targetAcceleration": [
+      -0.3743486921505017
+    ],
+    "maxVelocity": [
+      2.1188983418684852
+    ],
+    "maxAcceleration": [
+      5.642552746230346
+    ],
+    "maxJerk": [
+      18.84036164611062
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.123850393112514
+    ],
+    "currentVelocity": [
+      1.065217452385955
+    ],
+    "currentAcceleration": [
+      -3.3274091742091887
+    ],
+    "targetPosition": [
+      -8.865237768837384
+    ],
+    "targetVelocity": [
+      2.577782480479015
+    ],
+    "targetAcceleration": [
+      -0.30461579530420124
+    ],
+    "maxVelocity": [
+      6.900177863713034
+    ],
+    "maxAcceleration": [
+      6.840179510457849
+    ],
+    "maxJerk": [
+      6.854618134300827
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.196285066916879
+    ],
+    "currentVelocity": [
+      -0.6507168301604362
+    ],
+    "currentAcceleration": [
+      -5.400574630753138
+    ],
+    "targetPosition": [
+      -3.040219403238229
+    ],
+    "targetVelocity": [
+      0.8405828749503135
+    ],
+    "targetAcceleration": [
+      2.924423239435802
+    ],
+    "maxVelocity": [
+      2.126632267351044
+    ],
+    "maxAcceleration": [
+      6.2822691369151205
+    ],
+    "maxJerk": [
+      15.2697517342439
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.635209126485721
+    ],
+    "currentVelocity": [
+      -3.4356158119768128
+    ],
+    "currentAcceleration": [
+      2.393525529004836
+    ],
+    "targetPosition": [
+      2.0714898771880463
+    ],
+    "targetVelocity": [
+      -4.115321285272872
+    ],
+    "targetAcceleration": [
+      -1.8320976852511335
+    ],
+    "maxVelocity": [
+      4.897314966721744
+    ],
+    "maxAcceleration": [
+      3.7908507354209675
+    ],
+    "maxJerk": [
+      18.087796949555745
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.8985573819198613
+    ],
+    "currentVelocity": [
+      -2.5718231665139877
+    ],
+    "currentAcceleration": [
+      -2.2376796585227057
+    ],
+    "targetPosition": [
+      -9.70588848758289
+    ],
+    "targetVelocity": [
+      3.9142252317861965
+    ],
+    "targetAcceleration": [
+      -3.968250278521438
+    ],
+    "maxVelocity": [
+      5.1784840565454155
+    ],
+    "maxAcceleration": [
+      5.734273817728515
+    ],
+    "maxJerk": [
+      16.51402983733465
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.2761788817823252
+    ],
+    "currentVelocity": [
+      0.34739446015509623
+    ],
+    "currentAcceleration": [
+      0.9880983377859809
+    ],
+    "targetPosition": [
+      6.016217371815593
+    ],
+    "targetVelocity": [
+      -0.4158061861304472
+    ],
+    "targetAcceleration": [
+      0.07521292759544362
+    ],
+    "maxVelocity": [
+      2.199261363691747
+    ],
+    "maxAcceleration": [
+      3.6655326429170345
+    ],
+    "maxJerk": [
+      10.099015132596739
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.0401961276997547
+    ],
+    "currentVelocity": [
+      -1.4047186240466534
+    ],
+    "currentAcceleration": [
+      -6.914871220768694
+    ],
+    "targetPosition": [
+      -6.443624749705201
+    ],
+    "targetVelocity": [
+      -0.2919923672667917
+    ],
+    "targetAcceleration": [
+      2.4435631220790768
+    ],
+    "maxVelocity": [
+      5.887913454123245
+    ],
+    "maxAcceleration": [
+      9.564689016639893
+    ],
+    "maxJerk": [
+      13.018634811415428
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.503547445161528
+    ],
+    "currentVelocity": [
+      2.8916997480473663
+    ],
+    "currentAcceleration": [
+      1.1508767736848577
+    ],
+    "targetPosition": [
+      2.843641748161499
+    ],
+    "targetVelocity": [
+      -2.036046299115231
+    ],
+    "targetAcceleration": [
+      -5.5175293925157805
+    ],
+    "maxVelocity": [
+      6.062462176929649
+    ],
+    "maxAcceleration": [
+      6.387096079019634
+    ],
+    "maxJerk": [
+      8.984227350098433
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.214940357437589
+    ],
+    "currentVelocity": [
+      4.631924301722208
+    ],
+    "currentAcceleration": [
+      1.0263458599887372
+    ],
+    "targetPosition": [
+      -1.183752697700335
+    ],
+    "targetVelocity": [
+      -0.33708655153085765
+    ],
+    "targetAcceleration": [
+      1.3498376179286957
+    ],
+    "maxVelocity": [
+      7.8875907779416465
+    ],
+    "maxAcceleration": [
+      4.390254608327181
+    ],
+    "maxJerk": [
+      10.925892333159522
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.808902697619148
+    ],
+    "currentVelocity": [
+      -3.366709141258747
+    ],
+    "currentAcceleration": [
+      -4.0159646504312185
+    ],
+    "targetPosition": [
+      -6.661902615675787
+    ],
+    "targetVelocity": [
+      -5.665010613157333
+    ],
+    "targetAcceleration": [
+      0.022623868931580304
+    ],
+    "maxVelocity": [
+      6.760779919729308
+    ],
+    "maxAcceleration": [
+      4.470401823235115
+    ],
+    "maxJerk": [
+      18.937254634087886
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.474863646175903
+    ],
+    "currentVelocity": [
+      0.9016807097972928
+    ],
+    "currentAcceleration": [
+      -2.63454447871214
+    ],
+    "targetPosition": [
+      -4.499633177350284
+    ],
+    "targetVelocity": [
+      0.7839378899372109
+    ],
+    "targetAcceleration": [
+      -5.339633495171823
+    ],
+    "maxVelocity": [
+      6.408629841567061
+    ],
+    "maxAcceleration": [
+      7.219235232606779
+    ],
+    "maxJerk": [
+      15.425356625234881
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.20282675222032687
+    ],
+    "currentVelocity": [
+      4.540307693591824
+    ],
+    "currentAcceleration": [
+      -0.9569945903408703
+    ],
+    "targetPosition": [
+      -8.050857564542264
+    ],
+    "targetVelocity": [
+      -3.390525628893966
+    ],
+    "targetAcceleration": [
+      -0.6503795010741777
+    ],
+    "maxVelocity": [
+      4.8430928783143745
+    ],
+    "maxAcceleration": [
+      4.6617545324690335
+    ],
+    "maxJerk": [
+      9.870104504548536
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.9506612659135723
+    ],
+    "currentVelocity": [
+      4.463071523937817
+    ],
+    "currentAcceleration": [
+      2.4860719936261813
+    ],
+    "targetPosition": [
+      -4.20490665582401
+    ],
+    "targetVelocity": [
+      0.19005930998904397
+    ],
+    "targetAcceleration": [
+      3.443882405758158
+    ],
+    "maxVelocity": [
+      5.780150901694753
+    ],
+    "maxAcceleration": [
+      4.900290520927394
+    ],
+    "maxJerk": [
+      6.143782675373115
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.663507843329874
+    ],
+    "currentVelocity": [
+      2.4850264636246306
+    ],
+    "currentAcceleration": [
+      -0.667458408453852
+    ],
+    "targetPosition": [
+      -6.348311474619541
+    ],
+    "targetVelocity": [
+      -0.049544354217352815
+    ],
+    "targetAcceleration": [
+      0.9550544795755336
+    ],
+    "maxVelocity": [
+      2.6109285666171314
+    ],
+    "maxAcceleration": [
+      8.70442631457481
+    ],
+    "maxJerk": [
+      16.198501379611763
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.951947792424907
+    ],
+    "currentVelocity": [
+      -3.2081180303316605
+    ],
+    "currentAcceleration": [
+      -4.064769941459868
+    ],
+    "targetPosition": [
+      7.650473947479956
+    ],
+    "targetVelocity": [
+      0.03340189619997602
+    ],
+    "targetAcceleration": [
+      -4.8911670763851465
+    ],
+    "maxVelocity": [
+      4.0982139694409945
+    ],
+    "maxAcceleration": [
+      9.62714253758109
+    ],
+    "maxJerk": [
+      12.178205159379836
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.976375282778918
+    ],
+    "currentVelocity": [
+      -1.0066442421388175
+    ],
+    "currentAcceleration": [
+      -2.0148419710233565
+    ],
+    "targetPosition": [
+      -7.104185916494254
+    ],
+    "targetVelocity": [
+      -1.4118385554451867
+    ],
+    "targetAcceleration": [
+      0.11200582996559838
+    ],
+    "maxVelocity": [
+      3.2268623683927444
+    ],
+    "maxAcceleration": [
+      4.0390419776177
+    ],
+    "maxJerk": [
+      13.512835815759844
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.8907544688264597
+    ],
+    "currentVelocity": [
+      0.36905604185629315
+    ],
+    "currentAcceleration": [
+      4.334156472257466
+    ],
+    "targetPosition": [
+      7.023941228529953
+    ],
+    "targetVelocity": [
+      0.7079625348565362
+    ],
+    "targetAcceleration": [
+      -4.931636581098514
+    ],
+    "maxVelocity": [
+      2.5380110128851516
+    ],
+    "maxAcceleration": [
+      5.67845055689306
+    ],
+    "maxJerk": [
+      18.587543579319455
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.32597328482425425
+    ],
+    "currentVelocity": [
+      0.07779808771622498
+    ],
+    "currentAcceleration": [
+      6.489738959277151
+    ],
+    "targetPosition": [
+      -2.515626901062573
+    ],
+    "targetVelocity": [
+      5.082697025217304
+    ],
+    "targetAcceleration": [
+      2.055449902317367
+    ],
+    "maxVelocity": [
+      7.44466823507297
+    ],
+    "maxAcceleration": [
+      8.088435546753695
+    ],
+    "maxJerk": [
+      7.524742527840899
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.36332288007323577
+    ],
+    "currentVelocity": [
+      -1.557616489349976
+    ],
+    "currentAcceleration": [
+      -1.52371905672087
+    ],
+    "targetPosition": [
+      8.505416827885114
+    ],
+    "targetVelocity": [
+      0.5715156684251985
+    ],
+    "targetAcceleration": [
+      -1.7852426448471994
+    ],
+    "maxVelocity": [
+      2.1909128017996844
+    ],
+    "maxAcceleration": [
+      5.114020537424063
+    ],
+    "maxJerk": [
+      14.967681587398847
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.0964077718747482
+    ],
+    "currentVelocity": [
+      3.5002958997646987
+    ],
+    "currentAcceleration": [
+      0.02457667417937781
+    ],
+    "targetPosition": [
+      5.628881733303457
+    ],
+    "targetVelocity": [
+      2.215954866926265
+    ],
+    "targetAcceleration": [
+      4.401949539882635
+    ],
+    "maxVelocity": [
+      4.038908602980053
+    ],
+    "maxAcceleration": [
+      7.2071919544863245
+    ],
+    "maxJerk": [
+      19.085252409109017
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.597688989985908
+    ],
+    "currentVelocity": [
+      0.3144364561590183
+    ],
+    "currentAcceleration": [
+      -4.759594478775645
+    ],
+    "targetPosition": [
+      0.5597599928305907
+    ],
+    "targetVelocity": [
+      -0.37353255392432905
+    ],
+    "targetAcceleration": [
+      -3.511838703354978
+    ],
+    "maxVelocity": [
+      2.2884698461278696
+    ],
+    "maxAcceleration": [
+      4.874929525797825
+    ],
+    "maxJerk": [
+      9.174291755325779
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.922486367998273
+    ],
+    "currentVelocity": [
+      2.0934266964420276
+    ],
+    "currentAcceleration": [
+      2.186819456322069
+    ],
+    "targetPosition": [
+      -0.15203685449941418
+    ],
+    "targetVelocity": [
+      0.16452214228604678
+    ],
+    "targetAcceleration": [
+      -2.271574891268503
+    ],
+    "maxVelocity": [
+      5.936206838735855
+    ],
+    "maxAcceleration": [
+      4.054491646617594
+    ],
+    "maxJerk": [
+      9.459696870370916
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.9316002826878105
+    ],
+    "currentVelocity": [
+      0.26497715699943836
+    ],
+    "currentAcceleration": [
+      2.758530111293579
+    ],
+    "targetPosition": [
+      8.8690055846359
+    ],
+    "targetVelocity": [
+      4.316493765591
+    ],
+    "targetAcceleration": [
+      5.301546852683707
+    ],
+    "maxVelocity": [
+      6.06714727247785
+    ],
+    "maxAcceleration": [
+      6.486593058756476
+    ],
+    "maxJerk": [
+      5.8334901465108855
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.8512149440173733
+    ],
+    "currentVelocity": [
+      0.8882803328779025
+    ],
+    "currentAcceleration": [
+      -3.224092358976002
+    ],
+    "targetPosition": [
+      -4.258017722494136
+    ],
+    "targetVelocity": [
+      -2.182097808013678
+    ],
+    "targetAcceleration": [
+      -3.3133244366261363
+    ],
+    "maxVelocity": [
+      2.689025301888808
+    ],
+    "maxAcceleration": [
+      3.4825990692101363
+    ],
+    "maxJerk": [
+      16.757762601650082
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.766504738353442
+    ],
+    "currentVelocity": [
+      0.31099382361337957
+    ],
+    "currentAcceleration": [
+      7.8458554925413075
+    ],
+    "targetPosition": [
+      6.373127470919002
+    ],
+    "targetVelocity": [
+      -0.4988003041239195
+    ],
+    "targetAcceleration": [
+      0.3823538912686253
+    ],
+    "maxVelocity": [
+      2.8107682173932957
+    ],
+    "maxAcceleration": [
+      8.888620271816837
+    ],
+    "maxJerk": [
+      19.7318685567081
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.982083213159314
+    ],
+    "currentVelocity": [
+      1.3904596677089889
+    ],
+    "currentAcceleration": [
+      -2.164106839546525
+    ],
+    "targetPosition": [
+      -2.8884688105955414
+    ],
+    "targetVelocity": [
+      0.8760407065897824
+    ],
+    "targetAcceleration": [
+      -2.3730638554210985
+    ],
+    "maxVelocity": [
+      3.210673041425713
+    ],
+    "maxAcceleration": [
+      3.0084481033177846
+    ],
+    "maxJerk": [
+      16.99784634049704
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.80888904928561
+    ],
+    "currentVelocity": [
+      2.3863931005461794
+    ],
+    "currentAcceleration": [
+      2.282612076018859
+    ],
+    "targetPosition": [
+      -8.065381441829604
+    ],
+    "targetVelocity": [
+      -3.084533250972436
+    ],
+    "targetAcceleration": [
+      -5.108012463364347
+    ],
+    "maxVelocity": [
+      3.170160467318005
+    ],
+    "maxAcceleration": [
+      9.97079715863271
+    ],
+    "maxJerk": [
+      16.171900259172524
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.280107807997406
+    ],
+    "currentVelocity": [
+      1.9353362472183262
+    ],
+    "currentAcceleration": [
+      1.2613440546611354
+    ],
+    "targetPosition": [
+      -1.064747528593859
+    ],
+    "targetVelocity": [
+      -2.4337051540460903
+    ],
+    "targetAcceleration": [
+      -0.7184240496528256
+    ],
+    "maxVelocity": [
+      3.422393531991812
+    ],
+    "maxAcceleration": [
+      5.490811921569261
+    ],
+    "maxJerk": [
+      17.107614546983804
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.132147773228986
+    ],
+    "currentVelocity": [
+      0.4342187840674194
+    ],
+    "currentAcceleration": [
+      1.0055478341366308
+    ],
+    "targetPosition": [
+      -6.128132963376949
+    ],
+    "targetVelocity": [
+      3.8814636208733804
+    ],
+    "targetAcceleration": [
+      2.0733114578020615
+    ],
+    "maxVelocity": [
+      7.056836203764187
+    ],
+    "maxAcceleration": [
+      4.293560907543204
+    ],
+    "maxJerk": [
+      11.995560831600713
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.8054027436380142
+    ],
+    "currentVelocity": [
+      3.7198767343271157
+    ],
+    "currentAcceleration": [
+      3.4808678651955702
+    ],
+    "targetPosition": [
+      -7.776927747656872
+    ],
+    "targetVelocity": [
+      -3.05569001667143
+    ],
+    "targetAcceleration": [
+      -2.6119056187182235
+    ],
+    "maxVelocity": [
+      4.279589727442556
+    ],
+    "maxAcceleration": [
+      4.324355699228851
+    ],
+    "maxJerk": [
+      12.862626212640894
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.7816587216843232
+    ],
+    "currentVelocity": [
+      1.6264740607121433
+    ],
+    "currentAcceleration": [
+      -2.535465079170989
+    ],
+    "targetPosition": [
+      4.422288119460196
+    ],
+    "targetVelocity": [
+      1.971775297526003
+    ],
+    "targetAcceleration": [
+      6.171794068943749
+    ],
+    "maxVelocity": [
+      2.070112440103193
+    ],
+    "maxAcceleration": [
+      9.000750263984912
+    ],
+    "maxJerk": [
+      19.147214981128755
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.982293964364606
+    ],
+    "currentVelocity": [
+      -1.009472787621208
+    ],
+    "currentAcceleration": [
+      3.5886710340824086
+    ],
+    "targetPosition": [
+      -0.15199692092913963
+    ],
+    "targetVelocity": [
+      -4.272160261355867
+    ],
+    "targetAcceleration": [
+      3.3149446210376956
+    ],
+    "maxVelocity": [
+      4.898881302064586
+    ],
+    "maxAcceleration": [
+      5.414991283749001
+    ],
+    "maxJerk": [
+      17.071419146366317
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.8050109315459952
+    ],
+    "currentVelocity": [
+      0.7801524151110586
+    ],
+    "currentAcceleration": [
+      0.7118410469982352
+    ],
+    "targetPosition": [
+      2.3685431774088244
+    ],
+    "targetVelocity": [
+      4.326956969119127
+    ],
+    "targetAcceleration": [
+      1.7700262444037778
+    ],
+    "maxVelocity": [
+      5.8612597189953135
+    ],
+    "maxAcceleration": [
+      7.848211020639641
+    ],
+    "maxJerk": [
+      18.656424677807408
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.6394106444084358
+    ],
+    "currentVelocity": [
+      -0.47153070915391027
+    ],
+    "currentAcceleration": [
+      2.031162484491725
+    ],
+    "targetPosition": [
+      -2.350151067338901
+    ],
+    "targetVelocity": [
+      1.2605020895133268
+    ],
+    "targetAcceleration": [
+      -4.25467139215631
+    ],
+    "maxVelocity": [
+      2.7810546770465243
+    ],
+    "maxAcceleration": [
+      5.432404480788587
+    ],
+    "maxJerk": [
+      19.140334950771702
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.357782434644156
+    ],
+    "currentVelocity": [
+      -1.3158682702590951
+    ],
+    "currentAcceleration": [
+      5.598413275785733
+    ],
+    "targetPosition": [
+      -8.410969052757677
+    ],
+    "targetVelocity": [
+      6.078857764118505
+    ],
+    "targetAcceleration": [
+      -0.7604058395603897
+    ],
+    "maxVelocity": [
+      6.19363011581898
+    ],
+    "maxAcceleration": [
+      6.395107791189783
+    ],
+    "maxJerk": [
+      5.777972900616286
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.48176263293437
+    ],
+    "currentVelocity": [
+      -3.615066309447441
+    ],
+    "currentAcceleration": [
+      1.8106827567783168
+    ],
+    "targetPosition": [
+      1.900554461746065
+    ],
+    "targetVelocity": [
+      3.7792578394281504
+    ],
+    "targetAcceleration": [
+      2.988179232977869
+    ],
+    "maxVelocity": [
+      5.787434148605642
+    ],
+    "maxAcceleration": [
+      3.5432291247220777
+    ],
+    "maxJerk": [
+      5.975011570545376
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.898821502363901
+    ],
+    "currentVelocity": [
+      -1.725729441345492
+    ],
+    "currentAcceleration": [
+      -1.9905014170372075
+    ],
+    "targetPosition": [
+      -9.359932285301893
+    ],
+    "targetVelocity": [
+      -2.0829999124873755
+    ],
+    "targetAcceleration": [
+      6.774429876722287
+    ],
+    "maxVelocity": [
+      6.536055672464679
+    ],
+    "maxAcceleration": [
+      9.529898657356771
+    ],
+    "maxJerk": [
+      7.496157946420311
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.424989778768261
+    ],
+    "currentVelocity": [
+      -5.309539563665892
+    ],
+    "currentAcceleration": [
+      0.2308920896304314
+    ],
+    "targetPosition": [
+      -0.44083536563439907
+    ],
+    "targetVelocity": [
+      5.129305454783794
+    ],
+    "targetAcceleration": [
+      0.9765919119629518
+    ],
+    "maxVelocity": [
+      7.354717930318894
+    ],
+    "maxAcceleration": [
+      3.4378140593141233
+    ],
+    "maxJerk": [
+      9.42696156247976
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.11553449708184
+    ],
+    "currentVelocity": [
+      -1.5242633418338793
+    ],
+    "currentAcceleration": [
+      4.81503295793285
+    ],
+    "targetPosition": [
+      6.513030730313332
+    ],
+    "targetVelocity": [
+      0.08865410150085529
+    ],
+    "targetAcceleration": [
+      -4.246010508424053
+    ],
+    "maxVelocity": [
+      2.9482556651254352
+    ],
+    "maxAcceleration": [
+      5.726424022337353
+    ],
+    "maxJerk": [
+      7.591314972118245
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.299749592782234
+    ],
+    "currentVelocity": [
+      -1.3021178107665738
+    ],
+    "currentAcceleration": [
+      -0.9007885164883338
+    ],
+    "targetPosition": [
+      -1.7534592138738105
+    ],
+    "targetVelocity": [
+      3.767559670468608
+    ],
+    "targetAcceleration": [
+      -2.330326187967219
+    ],
+    "maxVelocity": [
+      4.8121131280317
+    ],
+    "maxAcceleration": [
+      4.181348959880297
+    ],
+    "maxJerk": [
+      5.600743848578404
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.591119493521658
+    ],
+    "currentVelocity": [
+      5.79614458282753
+    ],
+    "currentAcceleration": [
+      0.5266919730256525
+    ],
+    "targetPosition": [
+      -8.26716709838247
+    ],
+    "targetVelocity": [
+      -4.595846787233562
+    ],
+    "targetAcceleration": [
+      -1.9664034704660271
+    ],
+    "maxVelocity": [
+      7.551477270907139
+    ],
+    "maxAcceleration": [
+      5.011050772783504
+    ],
+    "maxJerk": [
+      14.766501783531588
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.0674657029080503
+    ],
+    "currentVelocity": [
+      3.5806544224473056
+    ],
+    "currentAcceleration": [
+      -8.37698399059665
+    ],
+    "targetPosition": [
+      -6.180450796448871
+    ],
+    "targetVelocity": [
+      7.5990880277602395
+    ],
+    "targetAcceleration": [
+      1.6090547187120183
+    ],
+    "maxVelocity": [
+      7.826506404195022
+    ],
+    "maxAcceleration": [
+      9.143213457345336
+    ],
+    "maxJerk": [
+      17.48444098969039
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.616556635015034
+    ],
+    "currentVelocity": [
+      -1.7498596980016825
+    ],
+    "currentAcceleration": [
+      3.8353290352203926
+    ],
+    "targetPosition": [
+      -8.878031928396283
+    ],
+    "targetVelocity": [
+      3.330058882214499
+    ],
+    "targetAcceleration": [
+      4.094791104994683
+    ],
+    "maxVelocity": [
+      4.003692245740501
+    ],
+    "maxAcceleration": [
+      5.566770721238163
+    ],
+    "maxJerk": [
+      10.133464629508214
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.629355724537394
+    ],
+    "currentVelocity": [
+      -2.076819113547958
+    ],
+    "currentAcceleration": [
+      8.787559296991397
+    ],
+    "targetPosition": [
+      1.0029376404304013
+    ],
+    "targetVelocity": [
+      -2.240065095350893
+    ],
+    "targetAcceleration": [
+      -8.721915915303283
+    ],
+    "maxVelocity": [
+      7.472909187026016
+    ],
+    "maxAcceleration": [
+      8.992786686776537
+    ],
+    "maxJerk": [
+      6.799206008849156
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.267342394245565
+    ],
+    "currentVelocity": [
+      2.203817875600084
+    ],
+    "currentAcceleration": [
+      4.903283232161037
+    ],
+    "targetPosition": [
+      -2.0969186251308747
+    ],
+    "targetVelocity": [
+      2.957092113215742
+    ],
+    "targetAcceleration": [
+      3.321989682490752
+    ],
+    "maxVelocity": [
+      5.9275751077603935
+    ],
+    "maxAcceleration": [
+      9.046244701714583
+    ],
+    "maxJerk": [
+      12.391612081741169
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.1660945863887964
+    ],
+    "currentVelocity": [
+      6.02878799968402
+    ],
+    "currentAcceleration": [
+      0.6688902117275939
+    ],
+    "targetPosition": [
+      -7.535660023044548
+    ],
+    "targetVelocity": [
+      5.831030764291235
+    ],
+    "targetAcceleration": [
+      -0.4115976604605365
+    ],
+    "maxVelocity": [
+      6.1208284708517695
+    ],
+    "maxAcceleration": [
+      4.739388735371627
+    ],
+    "maxJerk": [
+      14.391725362506822
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.708930982436852
+    ],
+    "currentVelocity": [
+      6.823610070786697
+    ],
+    "currentAcceleration": [
+      -1.9243076151533032
+    ],
+    "targetPosition": [
+      4.549682452253901
+    ],
+    "targetVelocity": [
+      6.927949084011863
+    ],
+    "targetAcceleration": [
+      2.482418656262425
+    ],
+    "maxVelocity": [
+      7.53428288283624
+    ],
+    "maxAcceleration": [
+      5.500666187823182
+    ],
+    "maxJerk": [
+      16.032666289701147
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.720862569356612
+    ],
+    "currentVelocity": [
+      3.9865319292551895
+    ],
+    "currentAcceleration": [
+      2.6797117195295836
+    ],
+    "targetPosition": [
+      9.010883184820333
+    ],
+    "targetVelocity": [
+      3.9602593244156648
+    ],
+    "targetAcceleration": [
+      1.4707007642375336
+    ],
+    "maxVelocity": [
+      5.820857206129906
+    ],
+    "maxAcceleration": [
+      4.445756384483298
+    ],
+    "maxJerk": [
+      8.550653803431803
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.5935548775489536
+    ],
+    "currentVelocity": [
+      -1.315655337819118
+    ],
+    "currentAcceleration": [
+      1.0930383632201988
+    ],
+    "targetPosition": [
+      2.458148644801387
+    ],
+    "targetVelocity": [
+      2.0985428701473854
+    ],
+    "targetAcceleration": [
+      -4.9252843912291535
+    ],
+    "maxVelocity": [
+      3.0130540999327193
+    ],
+    "maxAcceleration": [
+      9.236013442025623
+    ],
+    "maxJerk": [
+      15.559438301188562
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.382034659860031
+    ],
+    "currentVelocity": [
+      0.007745892983586522
+    ],
+    "currentAcceleration": [
+      8.891335286086019
+    ],
+    "targetPosition": [
+      0.7666181418667701
+    ],
+    "targetVelocity": [
+      1.1631352566681077
+    ],
+    "targetAcceleration": [
+      4.564823052477735
+    ],
+    "maxVelocity": [
+      2.5834479156434047
+    ],
+    "maxAcceleration": [
+      9.810441081168818
+    ],
+    "maxJerk": [
+      19.090605427825004
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.4647173092914674
+    ],
+    "currentVelocity": [
+      1.3664785970935749
+    ],
+    "currentAcceleration": [
+      3.8293454466544974
+    ],
+    "targetPosition": [
+      -6.404861032960603
+    ],
+    "targetVelocity": [
+      2.799941915817445
+    ],
+    "targetAcceleration": [
+      -0.977616616859251
+    ],
+    "maxVelocity": [
+      3.419396085912392
+    ],
+    "maxAcceleration": [
+      7.951350378502551
+    ],
+    "maxJerk": [
+      11.9420933378338
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.141428921338008
+    ],
+    "currentVelocity": [
+      3.3239006929922015
+    ],
+    "currentAcceleration": [
+      -5.037600036345424
+    ],
+    "targetPosition": [
+      -5.508481345133507
+    ],
+    "targetVelocity": [
+      -0.251070283866496
+    ],
+    "targetAcceleration": [
+      6.18977401967595
+    ],
+    "maxVelocity": [
+      4.106227533314197
+    ],
+    "maxAcceleration": [
+      7.0928720112617345
+    ],
+    "maxJerk": [
+      5.993154983436112
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.219398642139913
+    ],
+    "currentVelocity": [
+      -6.267712327445796
+    ],
+    "currentAcceleration": [
+      -3.0074649632854262
+    ],
+    "targetPosition": [
+      1.4442593037602354
+    ],
+    "targetVelocity": [
+      2.156742539234756
+    ],
+    "targetAcceleration": [
+      0.22011029204682941
+    ],
+    "maxVelocity": [
+      7.096945102067547
+    ],
+    "maxAcceleration": [
+      3.306407693737407
+    ],
+    "maxJerk": [
+      18.119666816044
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.312737231676245
+    ],
+    "currentVelocity": [
+      0.8000992765456321
+    ],
+    "currentAcceleration": [
+      -3.745373544953254
+    ],
+    "targetPosition": [
+      -6.234053029480222
+    ],
+    "targetVelocity": [
+      0.4969015878025993
+    ],
+    "targetAcceleration": [
+      -3.973313080415022
+    ],
+    "maxVelocity": [
+      2.911823444645246
+    ],
+    "maxAcceleration": [
+      5.555851080249994
+    ],
+    "maxJerk": [
+      6.032270927164278
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.425116636767573
+    ],
+    "currentVelocity": [
+      -1.0803986997448911
+    ],
+    "currentAcceleration": [
+      3.011916892908033
+    ],
+    "targetPosition": [
+      -0.6606500844531578
+    ],
+    "targetVelocity": [
+      2.5688641209980707
+    ],
+    "targetAcceleration": [
+      -1.539454584909739
+    ],
+    "maxVelocity": [
+      5.029534116239958
+    ],
+    "maxAcceleration": [
+      4.258836741569321
+    ],
+    "maxJerk": [
+      9.531597931297025
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.5482322274274125
+    ],
+    "currentVelocity": [
+      4.8593409433971555
+    ],
+    "currentAcceleration": [
+      1.646180858769842
+    ],
+    "targetPosition": [
+      5.513326137232202
+    ],
+    "targetVelocity": [
+      -2.506800518872478
+    ],
+    "targetAcceleration": [
+      -2.4990952789052012
+    ],
+    "maxVelocity": [
+      5.13090108188837
+    ],
+    "maxAcceleration": [
+      6.278057406599294
+    ],
+    "maxJerk": [
+      10.677769358702344
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7422021903327636
+    ],
+    "currentVelocity": [
+      3.3142615428839886
+    ],
+    "currentAcceleration": [
+      -0.7844902561558129
+    ],
+    "targetPosition": [
+      -7.213683457139705
+    ],
+    "targetVelocity": [
+      -6.091220916482791
+    ],
+    "targetAcceleration": [
+      -6.2522466155471506
+    ],
+    "maxVelocity": [
+      6.256530093359901
+    ],
+    "maxAcceleration": [
+      8.195012970655618
+    ],
+    "maxJerk": [
+      18.38781710005226
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.4496460899723296
+    ],
+    "currentVelocity": [
+      -1.1457193200757927
+    ],
+    "currentAcceleration": [
+      -1.6183506894570088
+    ],
+    "targetPosition": [
+      -9.615352336263335
+    ],
+    "targetVelocity": [
+      -2.730889371055311
+    ],
+    "targetAcceleration": [
+      -3.287847584579504
+    ],
+    "maxVelocity": [
+      4.691043000945112
+    ],
+    "maxAcceleration": [
+      4.6362775555137805
+    ],
+    "maxJerk": [
+      11.95980828929418
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.968378066154989
+    ],
+    "currentVelocity": [
+      -2.659240804582298
+    ],
+    "currentAcceleration": [
+      5.053721249103615
+    ],
+    "targetPosition": [
+      2.6989336391227408
+    ],
+    "targetVelocity": [
+      -1.7797668462174456
+    ],
+    "targetAcceleration": [
+      5.004990387183234
+    ],
+    "maxVelocity": [
+      3.538099238804643
+    ],
+    "maxAcceleration": [
+      9.951981024252934
+    ],
+    "maxJerk": [
+      8.74309436708833
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.151486504154274
+    ],
+    "currentVelocity": [
+      3.982973691617236
+    ],
+    "currentAcceleration": [
+      2.45892118420179
+    ],
+    "targetPosition": [
+      4.513587187629049
+    ],
+    "targetVelocity": [
+      -1.5561158009558884
+    ],
+    "targetAcceleration": [
+      -2.5159854300263182
+    ],
+    "maxVelocity": [
+      6.2982894944626135
+    ],
+    "maxAcceleration": [
+      3.440946873241045
+    ],
+    "maxJerk": [
+      6.927203413975433
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.453697764310423
+    ],
+    "currentVelocity": [
+      0.049834588641711086
+    ],
+    "currentAcceleration": [
+      -2.480274093724282
+    ],
+    "targetPosition": [
+      -1.1195774203892164
+    ],
+    "targetVelocity": [
+      -4.5668141125210635
+    ],
+    "targetAcceleration": [
+      0.19449669753505638
+    ],
+    "maxVelocity": [
+      5.27428976491167
+    ],
+    "maxAcceleration": [
+      4.042859127980651
+    ],
+    "maxJerk": [
+      16.488593162757894
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.7344362456350773
+    ],
+    "currentVelocity": [
+      4.348654257882651
+    ],
+    "currentAcceleration": [
+      1.9428130173090903
+    ],
+    "targetPosition": [
+      3.3687120408221833
+    ],
+    "targetVelocity": [
+      -0.047377965741373984
+    ],
+    "targetAcceleration": [
+      3.0431117131392096
+    ],
+    "maxVelocity": [
+      4.5929721508426615
+    ],
+    "maxAcceleration": [
+      8.378109292111938
+    ],
+    "maxJerk": [
+      18.08863568929123
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.379535024336981
+    ],
+    "currentVelocity": [
+      3.205535685299477
+    ],
+    "currentAcceleration": [
+      4.179482762262946
+    ],
+    "targetPosition": [
+      -5.8826352782171405
+    ],
+    "targetVelocity": [
+      -1.5986336669427184
+    ],
+    "targetAcceleration": [
+      -0.8064079116218368
+    ],
+    "maxVelocity": [
+      5.646196641872768
+    ],
+    "maxAcceleration": [
+      4.971496024325397
+    ],
+    "maxJerk": [
+      8.279116240174538
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7603845620488237
+    ],
+    "currentVelocity": [
+      -0.7738164578598137
+    ],
+    "currentAcceleration": [
+      4.184172633537244
+    ],
+    "targetPosition": [
+      -6.131325527721369
+    ],
+    "targetVelocity": [
+      3.532514238864505
+    ],
+    "targetAcceleration": [
+      6.85858533156363
+    ],
+    "maxVelocity": [
+      3.9423307155078744
+    ],
+    "maxAcceleration": [
+      8.268870406937342
+    ],
+    "maxJerk": [
+      7.852646427718944
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.734150763906449
+    ],
+    "currentVelocity": [
+      4.038996730121021
+    ],
+    "currentAcceleration": [
+      -2.9696197235607453
+    ],
+    "targetPosition": [
+      1.4196640880640121
+    ],
+    "targetVelocity": [
+      -4.307969816750651
+    ],
+    "targetAcceleration": [
+      2.274292664380839
+    ],
+    "maxVelocity": [
+      7.187791042239562
+    ],
+    "maxAcceleration": [
+      5.1293582619742715
+    ],
+    "maxJerk": [
+      14.75684512273961
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.48539005047658
+    ],
+    "currentVelocity": [
+      1.3219089848708792
+    ],
+    "currentAcceleration": [
+      -0.3911096153981264
+    ],
+    "targetPosition": [
+      8.137521185474547
+    ],
+    "targetVelocity": [
+      2.281690428641301
+    ],
+    "targetAcceleration": [
+      -1.3889858386519487
+    ],
+    "maxVelocity": [
+      3.8924310382667815
+    ],
+    "maxAcceleration": [
+      4.63265766887638
+    ],
+    "maxJerk": [
+      16.34570942034997
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.748070317416465
+    ],
+    "currentVelocity": [
+      2.051218311788583
+    ],
+    "currentAcceleration": [
+      -0.12967423742846051
+    ],
+    "targetPosition": [
+      -2.3031074160713345
+    ],
+    "targetVelocity": [
+      -1.3992836697258586
+    ],
+    "targetAcceleration": [
+      -0.5520107067294457
+    ],
+    "maxVelocity": [
+      2.506071991587679
+    ],
+    "maxAcceleration": [
+      4.734578077200518
+    ],
+    "maxJerk": [
+      16.903135921130136
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.747611524312017
+    ],
+    "currentVelocity": [
+      4.04955310119626
+    ],
+    "currentAcceleration": [
+      -1.2555239707883938
+    ],
+    "targetPosition": [
+      9.848704326377472
+    ],
+    "targetVelocity": [
+      -3.050194942326324
+    ],
+    "targetAcceleration": [
+      -3.3912525451521134
+    ],
+    "maxVelocity": [
+      5.1854932854734805
+    ],
+    "maxAcceleration": [
+      7.762867223119757
+    ],
+    "maxJerk": [
+      13.469233735758191
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.271598791185758
+    ],
+    "currentVelocity": [
+      -4.075770864267978
+    ],
+    "currentAcceleration": [
+      -4.490416169065114
+    ],
+    "targetPosition": [
+      -6.8223225529378
+    ],
+    "targetVelocity": [
+      2.9573202778040226
+    ],
+    "targetAcceleration": [
+      -1.8474978117217953
+    ],
+    "maxVelocity": [
+      6.384702017319565
+    ],
+    "maxAcceleration": [
+      5.2469106627447335
+    ],
+    "maxJerk": [
+      15.158331807194456
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.0094058637454175
+    ],
+    "currentVelocity": [
+      -2.9545558429519554
+    ],
+    "currentAcceleration": [
+      -2.8320462145259846
+    ],
+    "targetPosition": [
+      -1.862950640899001
+    ],
+    "targetVelocity": [
+      2.982426859847518
+    ],
+    "targetAcceleration": [
+      4.679778152332437
+    ],
+    "maxVelocity": [
+      4.723539541818123
+    ],
+    "maxAcceleration": [
+      9.704774259990353
+    ],
+    "maxJerk": [
+      7.287076702891749
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.520880835876811
+    ],
+    "currentVelocity": [
+      4.225625928903786
+    ],
+    "currentAcceleration": [
+      -1.710363495327429
+    ],
+    "targetPosition": [
+      -9.222762805343656
+    ],
+    "targetVelocity": [
+      1.7734776810873596
+    ],
+    "targetAcceleration": [
+      -0.03749002761675113
+    ],
+    "maxVelocity": [
+      5.1146666101806
+    ],
+    "maxAcceleration": [
+      3.7879116522658824
+    ],
+    "maxJerk": [
+      11.451855598986734
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.506839633744718
+    ],
+    "currentVelocity": [
+      1.6601074289318962
+    ],
+    "currentAcceleration": [
+      -1.6354785703478143
+    ],
+    "targetPosition": [
+      1.3771293147926578
+    ],
+    "targetVelocity": [
+      1.3421244048216074
+    ],
+    "targetAcceleration": [
+      3.927779277270739
+    ],
+    "maxVelocity": [
+      2.2118398927664242
+    ],
+    "maxAcceleration": [
+      5.747421062662461
+    ],
+    "maxJerk": [
+      5.9157520456693184
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.213175367041426
+    ],
+    "currentVelocity": [
+      1.532225160242258
+    ],
+    "currentAcceleration": [
+      -0.5020014578543757
+    ],
+    "targetPosition": [
+      -8.387326290791975
+    ],
+    "targetVelocity": [
+      2.9833665330280335
+    ],
+    "targetAcceleration": [
+      -2.288838570851963
+    ],
+    "maxVelocity": [
+      3.209824616158884
+    ],
+    "maxAcceleration": [
+      5.5790359328112045
+    ],
+    "maxJerk": [
+      17.604834617119394
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.986554954754778
+    ],
+    "currentVelocity": [
+      6.3621864404300545
+    ],
+    "currentAcceleration": [
+      2.539892876776787
+    ],
+    "targetPosition": [
+      -0.23565762076764152
+    ],
+    "targetVelocity": [
+      -4.458367155226924
+    ],
+    "targetAcceleration": [
+      4.926132334361761
+    ],
+    "maxVelocity": [
+      7.321276578813885
+    ],
+    "maxAcceleration": [
+      5.027773753025941
+    ],
+    "maxJerk": [
+      7.997847403028089
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.810988283263143
+    ],
+    "currentVelocity": [
+      3.1344596872711517
+    ],
+    "currentAcceleration": [
+      -4.373380912777449
+    ],
+    "targetPosition": [
+      -0.5883219471574535
+    ],
+    "targetVelocity": [
+      1.569978877025429
+    ],
+    "targetAcceleration": [
+      2.988510718604452
+    ],
+    "maxVelocity": [
+      6.1228673226900145
+    ],
+    "maxAcceleration": [
+      8.861561791674614
+    ],
+    "maxJerk": [
+      18.840931863759963
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.387172755598542
+    ],
+    "currentVelocity": [
+      4.122883435623606
+    ],
+    "currentAcceleration": [
+      -2.059735272164822
+    ],
+    "targetPosition": [
+      -2.0151640230277597
+    ],
+    "targetVelocity": [
+      0.09637792823805746
+    ],
+    "targetAcceleration": [
+      -3.8653107219039717
+    ],
+    "maxVelocity": [
+      4.637709200186546
+    ],
+    "maxAcceleration": [
+      6.110667372734619
+    ],
+    "maxJerk": [
+      9.259265368152867
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.4397605228574779
+    ],
+    "currentVelocity": [
+      -1.034318554656673
+    ],
+    "currentAcceleration": [
+      -3.561867851129036
+    ],
+    "targetPosition": [
+      0.06281144917503134
+    ],
+    "targetVelocity": [
+      -1.6256303040700297
+    ],
+    "targetAcceleration": [
+      5.1840582373102455
+    ],
+    "maxVelocity": [
+      2.499069866753208
+    ],
+    "maxAcceleration": [
+      5.437943466516679
+    ],
+    "maxJerk": [
+      16.827131933631936
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.384310878537239
+    ],
+    "currentVelocity": [
+      -1.56028896596785
+    ],
+    "currentAcceleration": [
+      2.9295699921133576
+    ],
+    "targetPosition": [
+      -4.26514669471755
+    ],
+    "targetVelocity": [
+      -4.154163367509211
+    ],
+    "targetAcceleration": [
+      -1.4488844861212895
+    ],
+    "maxVelocity": [
+      4.239768725376244
+    ],
+    "maxAcceleration": [
+      6.105085116105238
+    ],
+    "maxJerk": [
+      6.938231774194412
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.994500344620739
+    ],
+    "currentVelocity": [
+      -0.15486362946567622
+    ],
+    "currentAcceleration": [
+      -3.245345957737817
+    ],
+    "targetPosition": [
+      6.130190056761457
+    ],
+    "targetVelocity": [
+      -0.3147277564912927
+    ],
+    "targetAcceleration": [
+      -3.0606286997839676
+    ],
+    "maxVelocity": [
+      2.4193678499611675
+    ],
+    "maxAcceleration": [
+      3.94731606285167
+    ],
+    "maxJerk": [
+      8.25944126608691
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.275074429362228
+    ],
+    "currentVelocity": [
+      0.3465523136633015
+    ],
+    "currentAcceleration": [
+      -0.5905230874943257
+    ],
+    "targetPosition": [
+      5.916704061262594
+    ],
+    "targetVelocity": [
+      3.1783458939175295
+    ],
+    "targetAcceleration": [
+      -6.411434447515518
+    ],
+    "maxVelocity": [
+      6.203158929575005
+    ],
+    "maxAcceleration": [
+      9.070128097445908
+    ],
+    "maxJerk": [
+      10.246237328137415
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.735174965731776
+    ],
+    "currentVelocity": [
+      2.0531429402872643
+    ],
+    "currentAcceleration": [
+      -2.0862691860183444
+    ],
+    "targetPosition": [
+      2.260247899019099
+    ],
+    "targetVelocity": [
+      2.6385869279720735
+    ],
+    "targetAcceleration": [
+      -0.5067992754157373
+    ],
+    "maxVelocity": [
+      2.65066529155371
+    ],
+    "maxAcceleration": [
+      9.98721978568031
+    ],
+    "maxJerk": [
+      14.299471087604033
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.865620335862118
+    ],
+    "currentVelocity": [
+      -0.5480866211580997
+    ],
+    "currentAcceleration": [
+      -2.5631188040888833
+    ],
+    "targetPosition": [
+      -3.4433001043507883
+    ],
+    "targetVelocity": [
+      -0.07139221738558632
+    ],
+    "targetAcceleration": [
+      4.368561781932337
+    ],
+    "maxVelocity": [
+      2.8636607606330258
+    ],
+    "maxAcceleration": [
+      5.409629940686225
+    ],
+    "maxJerk": [
+      16.653348312867728
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.338298181183724
+    ],
+    "currentVelocity": [
+      -0.9603101031201358
+    ],
+    "currentAcceleration": [
+      0.2877471631652897
+    ],
+    "targetPosition": [
+      0.6465914343948356
+    ],
+    "targetVelocity": [
+      -2.1960184630416535
+    ],
+    "targetAcceleration": [
+      -2.008127944140393
+    ],
+    "maxVelocity": [
+      3.1151860101961297
+    ],
+    "maxAcceleration": [
+      4.165871982681261
+    ],
+    "maxJerk": [
+      16.553551157676395
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.5670927279152504
+    ],
+    "currentVelocity": [
+      0.9176772631256114
+    ],
+    "currentAcceleration": [
+      -0.5430675614198925
+    ],
+    "targetPosition": [
+      0.881071754941873
+    ],
+    "targetVelocity": [
+      3.4631495641889103
+    ],
+    "targetAcceleration": [
+      8.832354143799195
+    ],
+    "maxVelocity": [
+      6.034304169492263
+    ],
+    "maxAcceleration": [
+      8.927949160363672
+    ],
+    "maxJerk": [
+      13.095435073757159
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.040041112162746
+    ],
+    "currentVelocity": [
+      5.374674161470896
+    ],
+    "currentAcceleration": [
+      -1.4084951791000193
+    ],
+    "targetPosition": [
+      -4.423111895928358
+    ],
+    "targetVelocity": [
+      4.836424684949
+    ],
+    "targetAcceleration": [
+      -0.3288673191574296
+    ],
+    "maxVelocity": [
+      5.988761625759549
+    ],
+    "maxAcceleration": [
+      3.405451490756529
+    ],
+    "maxJerk": [
+      12.42715288246701
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.857859064683808
+    ],
+    "currentVelocity": [
+      -1.162655554597385
+    ],
+    "currentAcceleration": [
+      -3.0871605415128878
+    ],
+    "targetPosition": [
+      -1.245236072169277
+    ],
+    "targetVelocity": [
+      -1.6631026498101749
+    ],
+    "targetAcceleration": [
+      -1.6012512078963432
+    ],
+    "maxVelocity": [
+      6.936529600279618
+    ],
+    "maxAcceleration": [
+      6.691751226150874
+    ],
+    "maxJerk": [
+      10.337395726382196
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0815679962199347
+    ],
+    "currentVelocity": [
+      2.696000409652685
+    ],
+    "currentAcceleration": [
+      -0.681013240201704
+    ],
+    "targetPosition": [
+      -0.6512768666204831
+    ],
+    "targetVelocity": [
+      -1.9577707007044851
+    ],
+    "targetAcceleration": [
+      -6.609824893311996
+    ],
+    "maxVelocity": [
+      5.713544769199567
+    ],
+    "maxAcceleration": [
+      7.613951525229516
+    ],
+    "maxJerk": [
+      16.62155077196728
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.002449124881922
+    ],
+    "currentVelocity": [
+      -4.035676852484208
+    ],
+    "currentAcceleration": [
+      -5.122549607957124
+    ],
+    "targetPosition": [
+      2.029659132538848
+    ],
+    "targetVelocity": [
+      -3.29513484278709
+    ],
+    "targetAcceleration": [
+      4.162021828090099
+    ],
+    "maxVelocity": [
+      5.232752122470632
+    ],
+    "maxAcceleration": [
+      6.266388125760603
+    ],
+    "maxJerk": [
+      13.053847004009276
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.632159416992085
+    ],
+    "currentVelocity": [
+      -2.3932512006635256
+    ],
+    "currentAcceleration": [
+      3.3582513084287733
+    ],
+    "targetPosition": [
+      9.461204109804655
+    ],
+    "targetVelocity": [
+      3.461688991704656
+    ],
+    "targetAcceleration": [
+      -2.538481969810654
+    ],
+    "maxVelocity": [
+      5.429041726330287
+    ],
+    "maxAcceleration": [
+      4.273358884715426
+    ],
+    "maxJerk": [
+      8.210928039081995
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.552444902334743
+    ],
+    "currentVelocity": [
+      -0.4950628315895287
+    ],
+    "currentAcceleration": [
+      -6.817441697726766
+    ],
+    "targetPosition": [
+      -1.7093700975230064
+    ],
+    "targetVelocity": [
+      5.164813301839534
+    ],
+    "targetAcceleration": [
+      0.22404139333507267
+    ],
+    "maxVelocity": [
+      5.416371879418782
+    ],
+    "maxAcceleration": [
+      9.414490551834287
+    ],
+    "maxJerk": [
+      7.500468016755603
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.7880758274397355
+    ],
+    "currentVelocity": [
+      -3.0706733142316915
+    ],
+    "currentAcceleration": [
+      -4.9615534975193505
+    ],
+    "targetPosition": [
+      0.6976165970378112
+    ],
+    "targetVelocity": [
+      -4.889183053464729
+    ],
+    "targetAcceleration": [
+      -2.4348253993970577
+    ],
+    "maxVelocity": [
+      4.965159358080063
+    ],
+    "maxAcceleration": [
+      7.974410695681795
+    ],
+    "maxJerk": [
+      12.025716394445457
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.540724727483578
+    ],
+    "currentVelocity": [
+      1.8463162417841792
+    ],
+    "currentAcceleration": [
+      1.229993793474332
+    ],
+    "targetPosition": [
+      9.957404069329428
+    ],
+    "targetVelocity": [
+      -2.3399109164301826
+    ],
+    "targetAcceleration": [
+      -0.264780809214189
+    ],
+    "maxVelocity": [
+      2.8145775123970953
+    ],
+    "maxAcceleration": [
+      8.919657499111295
+    ],
+    "maxJerk": [
+      16.689976670583516
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.057569713169409
+    ],
+    "currentVelocity": [
+      1.0094668543223237
+    ],
+    "currentAcceleration": [
+      -1.2352448716894386
+    ],
+    "targetPosition": [
+      3.9209950371760662
+    ],
+    "targetVelocity": [
+      3.6264215085218465
+    ],
+    "targetAcceleration": [
+      -1.0598875744576195
+    ],
+    "maxVelocity": [
+      6.304046931373651
+    ],
+    "maxAcceleration": [
+      3.767393769099069
+    ],
+    "maxJerk": [
+      17.394320612597376
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.227948822210273
+    ],
+    "currentVelocity": [
+      -2.502084828317873
+    ],
+    "currentAcceleration": [
+      1.0250362160510438
+    ],
+    "targetPosition": [
+      -5.683130915925281
+    ],
+    "targetVelocity": [
+      -1.0767862538017385
+    ],
+    "targetAcceleration": [
+      0.8880207311477175
+    ],
+    "maxVelocity": [
+      3.607953807151824
+    ],
+    "maxAcceleration": [
+      3.0612674551625245
+    ],
+    "maxJerk": [
+      8.639745119422024
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.5685702709338756
+    ],
+    "currentVelocity": [
+      -0.9860143562097425
+    ],
+    "currentAcceleration": [
+      -3.0346581446421723
+    ],
+    "targetPosition": [
+      -2.013205059107454
+    ],
+    "targetVelocity": [
+      -3.6181248967537485
+    ],
+    "targetAcceleration": [
+      -5.537089851815437
+    ],
+    "maxVelocity": [
+      4.678289202908052
+    ],
+    "maxAcceleration": [
+      7.870268435696049
+    ],
+    "maxJerk": [
+      17.4399136195971
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.907618078798004
+    ],
+    "currentVelocity": [
+      -4.242903356775208
+    ],
+    "currentAcceleration": [
+      2.206828575819415
+    ],
+    "targetPosition": [
+      -0.6979410271104776
+    ],
+    "targetVelocity": [
+      2.4117860477700974
+    ],
+    "targetAcceleration": [
+      6.784262954542012
+    ],
+    "maxVelocity": [
+      4.564601685205788
+    ],
+    "maxAcceleration": [
+      9.225536211126254
+    ],
+    "maxJerk": [
+      12.251342741841786
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.491746452745199
+    ],
+    "currentVelocity": [
+      -3.0316610909638144
+    ],
+    "currentAcceleration": [
+      -1.3655146350563885
+    ],
+    "targetPosition": [
+      6.963674933430816
+    ],
+    "targetVelocity": [
+      0.2425250068765208
+    ],
+    "targetAcceleration": [
+      2.566502777499876
+    ],
+    "maxVelocity": [
+      3.27441816903408
+    ],
+    "maxAcceleration": [
+      3.7889705251383186
+    ],
+    "maxJerk": [
+      18.09849605939524
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.883085559885391
+    ],
+    "currentVelocity": [
+      -1.2924484463494657
+    ],
+    "currentAcceleration": [
+      3.505653454148394
+    ],
+    "targetPosition": [
+      7.7604590791133035
+    ],
+    "targetVelocity": [
+      -3.2936522228256306
+    ],
+    "targetAcceleration": [
+      4.405839298999181
+    ],
+    "maxVelocity": [
+      4.62168323640398
+    ],
+    "maxAcceleration": [
+      7.569151336863332
+    ],
+    "maxJerk": [
+      12.543103575861073
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.112407060517894
+    ],
+    "currentVelocity": [
+      -0.9171743998458013
+    ],
+    "currentAcceleration": [
+      -1.7934757510959303
+    ],
+    "targetPosition": [
+      5.666479536762331
+    ],
+    "targetVelocity": [
+      2.6939073972811642
+    ],
+    "targetAcceleration": [
+      3.441915242887827
+    ],
+    "maxVelocity": [
+      2.8404471311415302
+    ],
+    "maxAcceleration": [
+      8.586446230191525
+    ],
+    "maxJerk": [
+      19.30867247593327
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.681956496314405
+    ],
+    "currentVelocity": [
+      1.0111407968237058
+    ],
+    "currentAcceleration": [
+      -2.723867041964284
+    ],
+    "targetPosition": [
+      2.1701780122722596
+    ],
+    "targetVelocity": [
+      -2.0745253785464217
+    ],
+    "targetAcceleration": [
+      0.5465658086693699
+    ],
+    "maxVelocity": [
+      3.0213839991203644
+    ],
+    "maxAcceleration": [
+      6.30663977538406
+    ],
+    "maxJerk": [
+      16.16421114255691
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.26204651189293
+    ],
+    "currentVelocity": [
+      4.394947839528155
+    ],
+    "currentAcceleration": [
+      0.3563969780537981
+    ],
+    "targetPosition": [
+      1.5644497100138999
+    ],
+    "targetVelocity": [
+      4.507213234522795
+    ],
+    "targetAcceleration": [
+      -0.8948633636906962
+    ],
+    "maxVelocity": [
+      5.739491358451855
+    ],
+    "maxAcceleration": [
+      3.520589230250714
+    ],
+    "maxJerk": [
+      7.694579686175283
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.116417242780468
+    ],
+    "currentVelocity": [
+      3.0094063908071735
+    ],
+    "currentAcceleration": [
+      1.6217020420481223
+    ],
+    "targetPosition": [
+      -9.751570965372522
+    ],
+    "targetVelocity": [
+      3.553432734005339
+    ],
+    "targetAcceleration": [
+      1.8204884216384043
+    ],
+    "maxVelocity": [
+      5.888221584503178
+    ],
+    "maxAcceleration": [
+      4.718808976559243
+    ],
+    "maxJerk": [
+      13.372732519705654
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.587278547867925
+    ],
+    "currentVelocity": [
+      4.242200438783367
+    ],
+    "currentAcceleration": [
+      -0.7003778876949713
+    ],
+    "targetPosition": [
+      -0.1985955319253776
+    ],
+    "targetVelocity": [
+      -1.6425074032162836
+    ],
+    "targetAcceleration": [
+      -1.1737057005333593
+    ],
+    "maxVelocity": [
+      4.663149455011665
+    ],
+    "maxAcceleration": [
+      5.065461591443578
+    ],
+    "maxJerk": [
+      12.785009183905466
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.535723922259342
+    ],
+    "currentVelocity": [
+      -4.318324423120752
+    ],
+    "currentAcceleration": [
+      0.542354516424326
+    ],
+    "targetPosition": [
+      3.7131956209803167
+    ],
+    "targetVelocity": [
+      1.5007315513076191
+    ],
+    "targetAcceleration": [
+      -6.205045586492628
+    ],
+    "maxVelocity": [
+      5.955469219179127
+    ],
+    "maxAcceleration": [
+      6.921701617615398
+    ],
+    "maxJerk": [
+      9.662088861495684
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.528494025790653
+    ],
+    "currentVelocity": [
+      -3.7768810163942437
+    ],
+    "currentAcceleration": [
+      4.790234535788869
+    ],
+    "targetPosition": [
+      4.349765407866666
+    ],
+    "targetVelocity": [
+      -2.830808789314688
+    ],
+    "targetAcceleration": [
+      -4.942624603915474
+    ],
+    "maxVelocity": [
+      5.222430545048145
+    ],
+    "maxAcceleration": [
+      5.65747205371604
+    ],
+    "maxJerk": [
+      11.496110415409227
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.292712471432342
+    ],
+    "currentVelocity": [
+      1.6712452976857541
+    ],
+    "currentAcceleration": [
+      -5.980034426813605
+    ],
+    "targetPosition": [
+      -5.243494457844431
+    ],
+    "targetVelocity": [
+      7.220176459418294
+    ],
+    "targetAcceleration": [
+      1.278703673690119
+    ],
+    "maxVelocity": [
+      7.5586966921895336
+    ],
+    "maxAcceleration": [
+      9.043709016368808
+    ],
+    "maxJerk": [
+      10.140176019682414
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.5323845563807232
+    ],
+    "currentVelocity": [
+      -2.479165979969073
+    ],
+    "currentAcceleration": [
+      2.5492677475249748
+    ],
+    "targetPosition": [
+      -7.928929485511242
+    ],
+    "targetVelocity": [
+      -3.1941072589021924
+    ],
+    "targetAcceleration": [
+      0.9068309320601395
+    ],
+    "maxVelocity": [
+      3.453056325627823
+    ],
+    "maxAcceleration": [
+      3.012775112059999
+    ],
+    "maxJerk": [
+      11.862648560686537
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.032776094975816
+    ],
+    "currentVelocity": [
+      -1.6554539861577462
+    ],
+    "currentAcceleration": [
+      -3.548676326101619
+    ],
+    "targetPosition": [
+      -0.5991674803292764
+    ],
+    "targetVelocity": [
+      2.107058327452573
+    ],
+    "targetAcceleration": [
+      -2.9701641614017777
+    ],
+    "maxVelocity": [
+      6.3318403220609225
+    ],
+    "maxAcceleration": [
+      4.468961297230791
+    ],
+    "maxJerk": [
+      8.347356387272452
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.6516494879477097
+    ],
+    "currentVelocity": [
+      1.8458842748391446
+    ],
+    "currentAcceleration": [
+      -2.5869892805334
+    ],
+    "targetPosition": [
+      -4.483775928593998
+    ],
+    "targetVelocity": [
+      -2.238903545519854
+    ],
+    "targetAcceleration": [
+      -8.068135422937093
+    ],
+    "maxVelocity": [
+      2.348096758303948
+    ],
+    "maxAcceleration": [
+      8.670363284946207
+    ],
+    "maxJerk": [
+      14.152646772344047
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.549156340061273
+    ],
+    "currentVelocity": [
+      -3.042610602357278
+    ],
+    "currentAcceleration": [
+      1.0277027787141657
+    ],
+    "targetPosition": [
+      6.2126331219009465
+    ],
+    "targetVelocity": [
+      1.7791517696798365
+    ],
+    "targetAcceleration": [
+      -3.968438643883983
+    ],
+    "maxVelocity": [
+      3.193411178346501
+    ],
+    "maxAcceleration": [
+      4.265236756732129
+    ],
+    "maxJerk": [
+      13.874500395230948
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.889160785420932
+    ],
+    "currentVelocity": [
+      2.0800141397427687
+    ],
+    "currentAcceleration": [
+      0.06254214922901769
+    ],
+    "targetPosition": [
+      9.918995117027777
+    ],
+    "targetVelocity": [
+      -2.9258155144156888
+    ],
+    "targetAcceleration": [
+      -1.9801776688897796
+    ],
+    "maxVelocity": [
+      4.947071422570107
+    ],
+    "maxAcceleration": [
+      3.700885651135982
+    ],
+    "maxJerk": [
+      15.40936863242707
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6590807138545429
+    ],
+    "currentVelocity": [
+      0.00943400139345929
+    ],
+    "currentAcceleration": [
+      5.640867162159854
+    ],
+    "targetPosition": [
+      -3.4557407451686633
+    ],
+    "targetVelocity": [
+      0.9960715339919854
+    ],
+    "targetAcceleration": [
+      -4.747598903132512
+    ],
+    "maxVelocity": [
+      3.091399678551543
+    ],
+    "maxAcceleration": [
+      6.481861608719592
+    ],
+    "maxJerk": [
+      11.4715517052434
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.493447542174906
+    ],
+    "currentVelocity": [
+      -3.688830742575996
+    ],
+    "currentAcceleration": [
+      7.543712738788473
+    ],
+    "targetPosition": [
+      1.991350284082575
+    ],
+    "targetVelocity": [
+      -0.3219660595028424
+    ],
+    "targetAcceleration": [
+      -0.6220554510898051
+    ],
+    "maxVelocity": [
+      5.001977543811648
+    ],
+    "maxAcceleration": [
+      9.45946784289834
+    ],
+    "maxJerk": [
+      15.504440741547743
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.338100861929302
+    ],
+    "currentVelocity": [
+      -0.20524924044078174
+    ],
+    "currentAcceleration": [
+      -4.007135084810699
+    ],
+    "targetPosition": [
+      -2.343251601052545
+    ],
+    "targetVelocity": [
+      -0.11945643975926412
+    ],
+    "targetAcceleration": [
+      1.9062788988445858
+    ],
+    "maxVelocity": [
+      2.4323683668028466
+    ],
+    "maxAcceleration": [
+      5.663430444939986
+    ],
+    "maxJerk": [
+      12.38647051703502
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.375605556432642
+    ],
+    "currentVelocity": [
+      2.155348821143239
+    ],
+    "currentAcceleration": [
+      5.301403721321158
+    ],
+    "targetPosition": [
+      0.8177615399937608
+    ],
+    "targetVelocity": [
+      2.3009379894150648
+    ],
+    "targetAcceleration": [
+      -4.784119365958949
+    ],
+    "maxVelocity": [
+      6.494527935356123
+    ],
+    "maxAcceleration": [
+      6.618564059194595
+    ],
+    "maxJerk": [
+      16.581533330965584
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.8539483621758936
+    ],
+    "currentVelocity": [
+      0.01884352777355769
+    ],
+    "currentAcceleration": [
+      -0.8325501051526167
+    ],
+    "targetPosition": [
+      -4.0853450309519745
+    ],
+    "targetVelocity": [
+      -1.9789421415637554
+    ],
+    "targetAcceleration": [
+      -1.640602065751792
+    ],
+    "maxVelocity": [
+      2.397579259258649
+    ],
+    "maxAcceleration": [
+      3.2052705214263733
+    ],
+    "maxJerk": [
+      14.22811036878029
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.880128372154952
+    ],
+    "currentVelocity": [
+      3.473838468360092
+    ],
+    "currentAcceleration": [
+      0.2849034342709009
+    ],
+    "targetPosition": [
+      3.048831407789663
+    ],
+    "targetVelocity": [
+      3.233792730425008
+    ],
+    "targetAcceleration": [
+      -0.5990095995732059
+    ],
+    "maxVelocity": [
+      4.395912676627415
+    ],
+    "maxAcceleration": [
+      6.9973439182419
+    ],
+    "maxJerk": [
+      5.069059506163742
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.3931687488437081
+    ],
+    "currentVelocity": [
+      -1.9050661619961022
+    ],
+    "currentAcceleration": [
+      1.9271554052338038
+    ],
+    "targetPosition": [
+      -4.073755120020661
+    ],
+    "targetVelocity": [
+      -2.3771924927702384
+    ],
+    "targetAcceleration": [
+      1.9220919783985027
+    ],
+    "maxVelocity": [
+      2.5373918709170784
+    ],
+    "maxAcceleration": [
+      5.249918540140724
+    ],
+    "maxJerk": [
+      18.39213292947479
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.472679006334046
+    ],
+    "currentVelocity": [
+      1.325360200692339
+    ],
+    "currentAcceleration": [
+      -8.116895430939907
+    ],
+    "targetPosition": [
+      2.297219860364109
+    ],
+    "targetVelocity": [
+      -2.7253286933676564
+    ],
+    "targetAcceleration": [
+      -9.086687258124694
+    ],
+    "maxVelocity": [
+      6.574180004208159
+    ],
+    "maxAcceleration": [
+      9.297641354256378
+    ],
+    "maxJerk": [
+      9.524415631766272
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.9083885729271506
+    ],
+    "currentVelocity": [
+      0.2647601097653709
+    ],
+    "currentAcceleration": [
+      5.17656594164302
+    ],
+    "targetPosition": [
+      7.832231436886751
+    ],
+    "targetVelocity": [
+      -1.8730958976933045
+    ],
+    "targetAcceleration": [
+      -0.7892930540708143
+    ],
+    "maxVelocity": [
+      2.1671312307734443
+    ],
+    "maxAcceleration": [
+      6.452416386038783
+    ],
+    "maxJerk": [
+      17.509216556610646
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.103590984273708
+    ],
+    "currentVelocity": [
+      -5.858599198677482
+    ],
+    "currentAcceleration": [
+      -3.6864996327113007
+    ],
+    "targetPosition": [
+      -2.6565258928776148
+    ],
+    "targetVelocity": [
+      -4.394414078799445
+    ],
+    "targetAcceleration": [
+      5.1474888267408545
+    ],
+    "maxVelocity": [
+      7.872699440633665
+    ],
+    "maxAcceleration": [
+      9.585609079246499
+    ],
+    "maxJerk": [
+      12.956466655719463
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.690643200036298
+    ],
+    "currentVelocity": [
+      1.2336222143872342
+    ],
+    "currentAcceleration": [
+      -1.6831798752045228
+    ],
+    "targetPosition": [
+      -0.7616905399239506
+    ],
+    "targetVelocity": [
+      1.3711256019352196
+    ],
+    "targetAcceleration": [
+      -0.8620430645086254
+    ],
+    "maxVelocity": [
+      2.508156165764929
+    ],
+    "maxAcceleration": [
+      3.330850425209271
+    ],
+    "maxJerk": [
+      8.053517828118686
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.6885746886168036
+    ],
+    "currentVelocity": [
+      1.9750712890111846
+    ],
+    "currentAcceleration": [
+      -0.21570454674755446
+    ],
+    "targetPosition": [
+      -5.626473915950429
+    ],
+    "targetVelocity": [
+      -0.44051456230863106
+    ],
+    "targetAcceleration": [
+      -1.8773794654428153
+    ],
+    "maxVelocity": [
+      3.693745014288143
+    ],
+    "maxAcceleration": [
+      8.720511968741059
+    ],
+    "maxJerk": [
+      18.730152367970803
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.432974384341591
+    ],
+    "currentVelocity": [
+      4.226473170361669
+    ],
+    "currentAcceleration": [
+      0.7175596874091541
+    ],
+    "targetPosition": [
+      4.49976385726737
+    ],
+    "targetVelocity": [
+      -3.3789639145556776
+    ],
+    "targetAcceleration": [
+      2.210808995694764
+    ],
+    "maxVelocity": [
+      6.638193623828053
+    ],
+    "maxAcceleration": [
+      5.537949719255483
+    ],
+    "maxJerk": [
+      8.410806849360533
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.642775430513339
+    ],
+    "currentVelocity": [
+      1.8900029050951312
+    ],
+    "currentAcceleration": [
+      -0.5995722423188159
+    ],
+    "targetPosition": [
+      -2.8694353746725216
+    ],
+    "targetVelocity": [
+      -0.26013515447636415
+    ],
+    "targetAcceleration": [
+      1.6192623052127946
+    ],
+    "maxVelocity": [
+      2.298936319305847
+    ],
+    "maxAcceleration": [
+      4.6629068298874605
+    ],
+    "maxJerk": [
+      8.850574242892806
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.9942873119284972
+    ],
+    "currentVelocity": [
+      -4.4579115998725065
+    ],
+    "currentAcceleration": [
+      -4.209936384424925
+    ],
+    "targetPosition": [
+      7.507827729288714
+    ],
+    "targetVelocity": [
+      -0.2454862750063409
+    ],
+    "targetAcceleration": [
+      -2.80354810569498
+    ],
+    "maxVelocity": [
+      6.447435973183849
+    ],
+    "maxAcceleration": [
+      8.85805687802471
+    ],
+    "maxJerk": [
+      17.007399685614235
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.6037424203078423
+    ],
+    "currentVelocity": [
+      2.614107115354104
+    ],
+    "currentAcceleration": [
+      2.464601567798402
+    ],
+    "targetPosition": [
+      8.352731202981236
+    ],
+    "targetVelocity": [
+      0.8671779542990024
+    ],
+    "targetAcceleration": [
+      4.820854713086792
+    ],
+    "maxVelocity": [
+      3.502548784350804
+    ],
+    "maxAcceleration": [
+      5.156459876947764
+    ],
+    "maxJerk": [
+      18.69396098619995
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.8073306235625957
+    ],
+    "currentVelocity": [
+      3.9102217537686634
+    ],
+    "currentAcceleration": [
+      -5.784121974120143
+    ],
+    "targetPosition": [
+      8.58124481996498
+    ],
+    "targetVelocity": [
+      -3.4465722257128406
+    ],
+    "targetAcceleration": [
+      2.920689137316236
+    ],
+    "maxVelocity": [
+      5.656077770172335
+    ],
+    "maxAcceleration": [
+      7.407451208820941
+    ],
+    "maxJerk": [
+      15.318572933637851
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.104589572627088
+    ],
+    "currentVelocity": [
+      2.9529973018236007
+    ],
+    "currentAcceleration": [
+      4.520210918664267
+    ],
+    "targetPosition": [
+      -5.086555633195697
+    ],
+    "targetVelocity": [
+      -1.1030689000384166
+    ],
+    "targetAcceleration": [
+      -3.562802872544218
+    ],
+    "maxVelocity": [
+      3.8477869469556865
+    ],
+    "maxAcceleration": [
+      5.135378431457713
+    ],
+    "maxJerk": [
+      12.468266276010391
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.75454940697243
+    ],
+    "currentVelocity": [
+      -1.7319564922138366
+    ],
+    "currentAcceleration": [
+      -3.6574768740995687
+    ],
+    "targetPosition": [
+      -9.046578126637923
+    ],
+    "targetVelocity": [
+      -1.5638392770071725
+    ],
+    "targetAcceleration": [
+      -1.6153081155457283
+    ],
+    "maxVelocity": [
+      2.64336601887919
+    ],
+    "maxAcceleration": [
+      9.09990562959044
+    ],
+    "maxJerk": [
+      13.866874243115948
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.187942788449378
+    ],
+    "currentVelocity": [
+      -0.5039618251784561
+    ],
+    "currentAcceleration": [
+      3.329715596832039
+    ],
+    "targetPosition": [
+      -8.395729954041741
+    ],
+    "targetVelocity": [
+      -2.5277594656121076
+    ],
+    "targetAcceleration": [
+      -1.9600208998739639
+    ],
+    "maxVelocity": [
+      3.6022710562488243
+    ],
+    "maxAcceleration": [
+      4.436733079859438
+    ],
+    "maxJerk": [
+      12.17811750189552
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.33268112212298107
+    ],
+    "currentVelocity": [
+      -1.2356186066083152
+    ],
+    "currentAcceleration": [
+      3.9476216425481514
+    ],
+    "targetPosition": [
+      0.5747611779485347
+    ],
+    "targetVelocity": [
+      4.703632376990387
+    ],
+    "targetAcceleration": [
+      -4.0574889293295024
+    ],
+    "maxVelocity": [
+      5.719002967030163
+    ],
+    "maxAcceleration": [
+      6.488581474805654
+    ],
+    "maxJerk": [
+      8.872115347397038
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7918702243523281
+    ],
+    "currentVelocity": [
+      3.5677217371726346
+    ],
+    "currentAcceleration": [
+      6.897343378516721
+    ],
+    "targetPosition": [
+      7.704642420827646
+    ],
+    "targetVelocity": [
+      -2.7521769285406643
+    ],
+    "targetAcceleration": [
+      -2.5828836808918334
+    ],
+    "maxVelocity": [
+      5.732283664998629
+    ],
+    "maxAcceleration": [
+      9.824917695401817
+    ],
+    "maxJerk": [
+      16.300119709366356
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.17822845239246
+    ],
+    "currentVelocity": [
+      -4.556934780830629
+    ],
+    "currentAcceleration": [
+      2.554866170657621
+    ],
+    "targetPosition": [
+      -5.795852427930761
+    ],
+    "targetVelocity": [
+      3.807018250710108
+    ],
+    "targetAcceleration": [
+      -1.2591520878405613
+    ],
+    "maxVelocity": [
+      4.836948909162221
+    ],
+    "maxAcceleration": [
+      3.9484185172104658
+    ],
+    "maxJerk": [
+      8.696374242294604
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.6346971414472975
+    ],
+    "currentVelocity": [
+      -3.430346588924345
+    ],
+    "currentAcceleration": [
+      7.693628930009323
+    ],
+    "targetPosition": [
+      -1.4185634335590418
+    ],
+    "targetVelocity": [
+      -4.194304681601796
+    ],
+    "targetAcceleration": [
+      -2.286059294485928
+    ],
+    "maxVelocity": [
+      7.668255682377555
+    ],
+    "maxAcceleration": [
+      8.125829166297446
+    ],
+    "maxJerk": [
+      19.586659376314522
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0369034677433397
+    ],
+    "currentVelocity": [
+      1.084025141425414
+    ],
+    "currentAcceleration": [
+      3.8170119087014944
+    ],
+    "targetPosition": [
+      -1.5631722678049407
+    ],
+    "targetVelocity": [
+      -4.222437148602975
+    ],
+    "targetAcceleration": [
+      0.16132654210072594
+    ],
+    "maxVelocity": [
+      7.657702313360208
+    ],
+    "maxAcceleration": [
+      5.255969990902238
+    ],
+    "maxJerk": [
+      19.176706113225542
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.8194447134140486
+    ],
+    "currentVelocity": [
+      -0.7992928367758099
+    ],
+    "currentAcceleration": [
+      2.8558738433153747
+    ],
+    "targetPosition": [
+      9.013144793300818
+    ],
+    "targetVelocity": [
+      2.652449326224408
+    ],
+    "targetAcceleration": [
+      1.6117728203825576
+    ],
+    "maxVelocity": [
+      3.992917018618523
+    ],
+    "maxAcceleration": [
+      4.261495926370529
+    ],
+    "maxJerk": [
+      15.973615760729343
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.120746431654403
+    ],
+    "currentVelocity": [
+      -2.1293376007166462
+    ],
+    "currentAcceleration": [
+      3.5772445833471593
+    ],
+    "targetPosition": [
+      -4.14328798163818
+    ],
+    "targetVelocity": [
+      1.233404367485984
+    ],
+    "targetAcceleration": [
+      6.711455509649857
+    ],
+    "maxVelocity": [
+      2.612859572248409
+    ],
+    "maxAcceleration": [
+      6.875795213938831
+    ],
+    "maxJerk": [
+      18.39949480190237
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.37652607985291
+    ],
+    "currentVelocity": [
+      0.5990435022269005
+    ],
+    "currentAcceleration": [
+      -4.729946835519614
+    ],
+    "targetPosition": [
+      -1.5687594189069127
+    ],
+    "targetVelocity": [
+      -1.0683215200057297
+    ],
+    "targetAcceleration": [
+      -5.517212454818642
+    ],
+    "maxVelocity": [
+      3.606918217253605
+    ],
+    "maxAcceleration": [
+      9.534576630195918
+    ],
+    "maxJerk": [
+      17.664039114952942
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.877212863729195
+    ],
+    "currentVelocity": [
+      -3.5518925063673836
+    ],
+    "currentAcceleration": [
+      -2.6479118549776715
+    ],
+    "targetPosition": [
+      -6.688111987712412
+    ],
+    "targetVelocity": [
+      -0.4819723273699399
+    ],
+    "targetAcceleration": [
+      -2.999944939330743
+    ],
+    "maxVelocity": [
+      5.071046389328823
+    ],
+    "maxAcceleration": [
+      7.019287464405994
+    ],
+    "maxJerk": [
+      18.58417425743327
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.22805679327999
+    ],
+    "currentVelocity": [
+      3.638449586224465
+    ],
+    "currentAcceleration": [
+      0.408276960070058
+    ],
+    "targetPosition": [
+      -5.881239862983493
+    ],
+    "targetVelocity": [
+      3.286377132769239
+    ],
+    "targetAcceleration": [
+      1.8380414674651373
+    ],
+    "maxVelocity": [
+      4.026453169622959
+    ],
+    "maxAcceleration": [
+      6.8296862508626734
+    ],
+    "maxJerk": [
+      8.023908940310346
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.53909110138493
+    ],
+    "currentVelocity": [
+      -0.21180344340075052
+    ],
+    "currentAcceleration": [
+      0.38608686392875136
+    ],
+    "targetPosition": [
+      -6.76202059044204
+    ],
+    "targetVelocity": [
+      1.2739495165964017
+    ],
+    "targetAcceleration": [
+      7.052082174193252
+    ],
+    "maxVelocity": [
+      3.1912520630028216
+    ],
+    "maxAcceleration": [
+      8.428224320978973
+    ],
+    "maxJerk": [
+      9.179070906369816
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.8194136045077345
+    ],
+    "currentVelocity": [
+      -1.846694509144092
+    ],
+    "currentAcceleration": [
+      -0.3869185224460301
+    ],
+    "targetPosition": [
+      -8.244941194121086
+    ],
+    "targetVelocity": [
+      2.9597729263859396
+    ],
+    "targetAcceleration": [
+      3.534619471640143
+    ],
+    "maxVelocity": [
+      5.828435192613263
+    ],
+    "maxAcceleration": [
+      5.547470094306133
+    ],
+    "maxJerk": [
+      13.938041442228378
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.389154728622719
+    ],
+    "currentVelocity": [
+      -5.04568289320452
+    ],
+    "currentAcceleration": [
+      2.48044320750075
+    ],
+    "targetPosition": [
+      -5.097940807559329
+    ],
+    "targetVelocity": [
+      0.4582230746949385
+    ],
+    "targetAcceleration": [
+      -4.737899700962359
+    ],
+    "maxVelocity": [
+      7.60178778567008
+    ],
+    "maxAcceleration": [
+      7.48456216195917
+    ],
+    "maxJerk": [
+      13.359544765808884
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.5778272169201841
+    ],
+    "currentVelocity": [
+      -2.18195210818383
+    ],
+    "currentAcceleration": [
+      3.765907656111338
+    ],
+    "targetPosition": [
+      -9.678010489123741
+    ],
+    "targetVelocity": [
+      -0.16615143075283356
+    ],
+    "targetAcceleration": [
+      -1.2173445675625927
+    ],
+    "maxVelocity": [
+      5.481245819956939
+    ],
+    "maxAcceleration": [
+      4.589082464567124
+    ],
+    "maxJerk": [
+      5.497281170590699
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.751077013919155
+    ],
+    "currentVelocity": [
+      -2.987108669426934
+    ],
+    "currentAcceleration": [
+      -4.570763964161532
+    ],
+    "targetPosition": [
+      -4.348214766592042
+    ],
+    "targetVelocity": [
+      -3.83595439277707
+    ],
+    "targetAcceleration": [
+      4.756648587492791
+    ],
+    "maxVelocity": [
+      6.074698764082451
+    ],
+    "maxAcceleration": [
+      6.863999676734636
+    ],
+    "maxJerk": [
+      17.303180211500127
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0886357363612476
+    ],
+    "currentVelocity": [
+      1.8848830014454556
+    ],
+    "currentAcceleration": [
+      -3.394342140561498
+    ],
+    "targetPosition": [
+      -1.0137976619158913
+    ],
+    "targetVelocity": [
+      2.416458972827246
+    ],
+    "targetAcceleration": [
+      -3.3286480850252937
+    ],
+    "maxVelocity": [
+      2.7428470469921686
+    ],
+    "maxAcceleration": [
+      5.37408899718792
+    ],
+    "maxJerk": [
+      17.846202583290758
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.8494376613277588
+    ],
+    "currentVelocity": [
+      -0.15484669831341957
+    ],
+    "currentAcceleration": [
+      2.08504020612847
+    ],
+    "targetPosition": [
+      -5.571788164189524
+    ],
+    "targetVelocity": [
+      -1.4476145275479668
+    ],
+    "targetAcceleration": [
+      -0.7725444925130809
+    ],
+    "maxVelocity": [
+      3.3210761742754005
+    ],
+    "maxAcceleration": [
+      5.327850552240246
+    ],
+    "maxJerk": [
+      5.724280743200301
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.69597912621326
+    ],
+    "currentVelocity": [
+      2.3469180871350446
+    ],
+    "currentAcceleration": [
+      -3.0919889787233963
+    ],
+    "targetPosition": [
+      -2.721248988039841
+    ],
+    "targetVelocity": [
+      1.3560658543176656
+    ],
+    "targetAcceleration": [
+      0.4267041133561271
+    ],
+    "maxVelocity": [
+      3.1625910902768792
+    ],
+    "maxAcceleration": [
+      4.710603922518158
+    ],
+    "maxJerk": [
+      15.649413743624262
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.405498495706524
+    ],
+    "currentVelocity": [
+      0.19549031012218254
+    ],
+    "currentAcceleration": [
+      3.4118858942154286
+    ],
+    "targetPosition": [
+      6.580179881574534
+    ],
+    "targetVelocity": [
+      -2.756627203118472
+    ],
+    "targetAcceleration": [
+      4.023429707719595
+    ],
+    "maxVelocity": [
+      7.4651567869669995
+    ],
+    "maxAcceleration": [
+      7.3756123246395635
+    ],
+    "maxJerk": [
+      11.19215374980853
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.838626857533759
+    ],
+    "currentVelocity": [
+      2.51569691820953
+    ],
+    "currentAcceleration": [
+      -6.4908713027718346
+    ],
+    "targetPosition": [
+      7.387594038961641
+    ],
+    "targetVelocity": [
+      2.393261722095289
+    ],
+    "targetAcceleration": [
+      -0.1513638728029676
+    ],
+    "maxVelocity": [
+      6.689960958729838
+    ],
+    "maxAcceleration": [
+      8.620643116941
+    ],
+    "maxJerk": [
+      14.379900699558407
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.78271080444655
+    ],
+    "currentVelocity": [
+      1.2130881518238903
+    ],
+    "currentAcceleration": [
+      1.0998491756004363
+    ],
+    "targetPosition": [
+      4.693620600278873
+    ],
+    "targetVelocity": [
+      1.7274269230372719
+    ],
+    "targetAcceleration": [
+      -1.6608897595165808
+    ],
+    "maxVelocity": [
+      5.239971619714017
+    ],
+    "maxAcceleration": [
+      4.877298848941128
+    ],
+    "maxJerk": [
+      16.989670266052723
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.4527269272751067
+    ],
+    "currentVelocity": [
+      0.6783876915403422
+    ],
+    "currentAcceleration": [
+      4.268327779535751
+    ],
+    "targetPosition": [
+      -1.2125513817202442
+    ],
+    "targetVelocity": [
+      2.3239035371680634
+    ],
+    "targetAcceleration": [
+      -3.449809119840339
+    ],
+    "maxVelocity": [
+      3.5288920541862296
+    ],
+    "maxAcceleration": [
+      7.345887560779804
+    ],
+    "maxJerk": [
+      17.731661551762286
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.797758283948159
+    ],
+    "currentVelocity": [
+      -2.2889270846926264
+    ],
+    "currentAcceleration": [
+      -7.245188988351876
+    ],
+    "targetPosition": [
+      5.9176006810803266
+    ],
+    "targetVelocity": [
+      1.8299265418497965
+    ],
+    "targetAcceleration": [
+      -7.787532242543209
+    ],
+    "maxVelocity": [
+      7.43213630657035
+    ],
+    "maxAcceleration": [
+      9.018644086125526
+    ],
+    "maxJerk": [
+      11.675986386821638
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.534791292656081
+    ],
+    "currentVelocity": [
+      -1.1880200919989985
+    ],
+    "currentAcceleration": [
+      3.4788688079524666
+    ],
+    "targetPosition": [
+      -5.253142371589088
+    ],
+    "targetVelocity": [
+      4.5771499221212215
+    ],
+    "targetAcceleration": [
+      -2.6741961586867724
+    ],
+    "maxVelocity": [
+      6.954223587983933
+    ],
+    "maxAcceleration": [
+      3.6937399366792225
+    ],
+    "maxJerk": [
+      8.66279215888467
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.191029548518628
+    ],
+    "currentVelocity": [
+      6.2420330829585495
+    ],
+    "currentAcceleration": [
+      -4.477774673958878
+    ],
+    "targetPosition": [
+      7.232677088160603
+    ],
+    "targetVelocity": [
+      4.247735930081573
+    ],
+    "targetAcceleration": [
+      3.1636932221890017
+    ],
+    "maxVelocity": [
+      7.111190868966629
+    ],
+    "maxAcceleration": [
+      7.596140374964408
+    ],
+    "maxJerk": [
+      7.6953009384730375
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.4888746741959364
+    ],
+    "currentVelocity": [
+      2.063631407481715
+    ],
+    "currentAcceleration": [
+      -1.080260252497716
+    ],
+    "targetPosition": [
+      -0.7613361385790736
+    ],
+    "targetVelocity": [
+      0.4329924327135952
+    ],
+    "targetAcceleration": [
+      -3.5986241724868044
+    ],
+    "maxVelocity": [
+      3.328437167396939
+    ],
+    "maxAcceleration": [
+      5.029603275096711
+    ],
+    "maxJerk": [
+      17.84146030883025
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.622479346253243
+    ],
+    "currentVelocity": [
+      1.5519215529552368
+    ],
+    "currentAcceleration": [
+      2.341696167362084
+    ],
+    "targetPosition": [
+      4.245862803319046
+    ],
+    "targetVelocity": [
+      -1.878599152946638
+    ],
+    "targetAcceleration": [
+      0.8488921345602503
+    ],
+    "maxVelocity": [
+      2.610822588342264
+    ],
+    "maxAcceleration": [
+      4.292755761211435
+    ],
+    "maxJerk": [
+      6.123835951717055
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.282705776080274
+    ],
+    "currentVelocity": [
+      0.871833744776576
+    ],
+    "currentAcceleration": [
+      1.7612073581084342
+    ],
+    "targetPosition": [
+      3.9791850623459872
+    ],
+    "targetVelocity": [
+      1.8613091369746533
+    ],
+    "targetAcceleration": [
+      -3.931354345631772
+    ],
+    "maxVelocity": [
+      3.2801537527920086
+    ],
+    "maxAcceleration": [
+      9.666595811967268
+    ],
+    "maxJerk": [
+      9.833765989105625
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.5882420588765402
+    ],
+    "currentVelocity": [
+      0.4049180020933374
+    ],
+    "currentAcceleration": [
+      -1.7532361179224472
+    ],
+    "targetPosition": [
+      8.406083774713924
+    ],
+    "targetVelocity": [
+      -1.4910214499061814
+    ],
+    "targetAcceleration": [
+      4.3505126654788615
+    ],
+    "maxVelocity": [
+      2.8421299653625836
+    ],
+    "maxAcceleration": [
+      8.415296410322393
+    ],
+    "maxJerk": [
+      18.22410410828938
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.184816388458895
+    ],
+    "currentVelocity": [
+      -1.0548308475479198
+    ],
+    "currentAcceleration": [
+      -2.0428829263283372
+    ],
+    "targetPosition": [
+      -3.4908131807532445
+    ],
+    "targetVelocity": [
+      5.2420535799854955
+    ],
+    "targetAcceleration": [
+      -2.77232002193001
+    ],
+    "maxVelocity": [
+      5.849878963209753
+    ],
+    "maxAcceleration": [
+      3.2303413428607377
+    ],
+    "maxJerk": [
+      17.015788450383965
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.570166190307871
+    ],
+    "currentVelocity": [
+      -1.1964126683414578
+    ],
+    "currentAcceleration": [
+      1.137313898660313
+    ],
+    "targetPosition": [
+      -3.203342896307344
+    ],
+    "targetVelocity": [
+      -0.9384797308139985
+    ],
+    "targetAcceleration": [
+      -7.4346977047487055
+    ],
+    "maxVelocity": [
+      2.9177490063425378
+    ],
+    "maxAcceleration": [
+      8.41541212251785
+    ],
+    "maxJerk": [
+      16.389687083629504
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.287131279702418
+    ],
+    "currentVelocity": [
+      1.56237078402012
+    ],
+    "currentAcceleration": [
+      3.4612196975772775
+    ],
+    "targetPosition": [
+      -2.274129649384518
+    ],
+    "targetVelocity": [
+      2.300595853494307
+    ],
+    "targetAcceleration": [
+      5.127494212001409
+    ],
+    "maxVelocity": [
+      2.806089141381093
+    ],
+    "maxAcceleration": [
+      8.32293790133172
+    ],
+    "maxJerk": [
+      10.116015962189945
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.925744739842977
+    ],
+    "currentVelocity": [
+      0.6206357947430297
+    ],
+    "currentAcceleration": [
+      -1.9121451482239489
+    ],
+    "targetPosition": [
+      -1.3993696382820549
+    ],
+    "targetVelocity": [
+      1.2214255929510305
+    ],
+    "targetAcceleration": [
+      1.048238604588743
+    ],
+    "maxVelocity": [
+      2.180513818400934
+    ],
+    "maxAcceleration": [
+      4.687976228762934
+    ],
+    "maxJerk": [
+      18.93353258716472
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.8386634635667694
+    ],
+    "currentVelocity": [
+      -4.90102876086357
+    ],
+    "currentAcceleration": [
+      -0.6003245685423035
+    ],
+    "targetPosition": [
+      -5.132435763615204
+    ],
+    "targetVelocity": [
+      5.250142671663085
+    ],
+    "targetAcceleration": [
+      -0.8998223454149654
+    ],
+    "maxVelocity": [
+      6.51425190081466
+    ],
+    "maxAcceleration": [
+      4.078492031678824
+    ],
+    "maxJerk": [
+      12.122444678684584
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.8391471649251407
+    ],
+    "currentVelocity": [
+      -2.00012348994698
+    ],
+    "currentAcceleration": [
+      -2.6910723186005634
+    ],
+    "targetPosition": [
+      -4.589106251351169
+    ],
+    "targetVelocity": [
+      4.87041587353197
+    ],
+    "targetAcceleration": [
+      -0.13086851381126952
+    ],
+    "maxVelocity": [
+      7.275364795372541
+    ],
+    "maxAcceleration": [
+      4.485950804466425
+    ],
+    "maxJerk": [
+      10.070497738232888
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.218005502355732
+    ],
+    "currentVelocity": [
+      0.26509781348780415
+    ],
+    "currentAcceleration": [
+      -6.005057221165607
+    ],
+    "targetPosition": [
+      -8.726069926542843
+    ],
+    "targetVelocity": [
+      -1.4034016630191042
+    ],
+    "targetAcceleration": [
+      1.5181100049164993
+    ],
+    "maxVelocity": [
+      4.916403417488814
+    ],
+    "maxAcceleration": [
+      7.152634963370682
+    ],
+    "maxJerk": [
+      5.531251798167077
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.813806156022274
+    ],
+    "currentVelocity": [
+      -0.021971619203639214
+    ],
+    "currentAcceleration": [
+      6.18164565795791
+    ],
+    "targetPosition": [
+      8.606167432634393
+    ],
+    "targetVelocity": [
+      0.26716333324883124
+    ],
+    "targetAcceleration": [
+      3.47929617654731
+    ],
+    "maxVelocity": [
+      6.91229896306007
+    ],
+    "maxAcceleration": [
+      6.290113807863079
+    ],
+    "maxJerk": [
+      16.135038254270867
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.8819513902985463
+    ],
+    "currentVelocity": [
+      0.1540025007552397
+    ],
+    "currentAcceleration": [
+      1.2944492785359634
+    ],
+    "targetPosition": [
+      6.0916337152315805
+    ],
+    "targetVelocity": [
+      -1.3455654214945758
+    ],
+    "targetAcceleration": [
+      0.9475610842658044
+    ],
+    "maxVelocity": [
+      2.168735593456722
+    ],
+    "maxAcceleration": [
+      5.990813111134877
+    ],
+    "maxJerk": [
+      11.097572505923083
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.236740140932994
+    ],
+    "currentVelocity": [
+      -4.664026054354633
+    ],
+    "currentAcceleration": [
+      -3.594408157513173
+    ],
+    "targetPosition": [
+      -0.004440927073014578
+    ],
+    "targetVelocity": [
+      0.46902261326535033
+    ],
+    "targetAcceleration": [
+      1.5597828395516053
+    ],
+    "maxVelocity": [
+      7.478542299047494
+    ],
+    "maxAcceleration": [
+      7.421158003526941
+    ],
+    "maxJerk": [
+      6.445975959879729
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.517300482400914
+    ],
+    "currentVelocity": [
+      -1.6237338347068997
+    ],
+    "currentAcceleration": [
+      -0.62314293721652
+    ],
+    "targetPosition": [
+      8.043251464702081
+    ],
+    "targetVelocity": [
+      -2.809776899148865
+    ],
+    "targetAcceleration": [
+      2.97196493856406
+    ],
+    "maxVelocity": [
+      6.420732654174643
+    ],
+    "maxAcceleration": [
+      6.230030480108708
+    ],
+    "maxJerk": [
+      17.747962680833318
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.52578758077
+    ],
+    "currentVelocity": [
+      2.7360396010312975
+    ],
+    "currentAcceleration": [
+      6.245629259834062
+    ],
+    "targetPosition": [
+      1.6708237801175123
+    ],
+    "targetVelocity": [
+      -2.741001534403469
+    ],
+    "targetAcceleration": [
+      -1.6834950090564336
+    ],
+    "maxVelocity": [
+      4.645715909451397
+    ],
+    "maxAcceleration": [
+      7.423611095006682
+    ],
+    "maxJerk": [
+      14.271959027580422
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.424510385777993
+    ],
+    "currentVelocity": [
+      -2.061248435350196
+    ],
+    "currentAcceleration": [
+      2.0932688630946004
+    ],
+    "targetPosition": [
+      -0.04514762990256038
+    ],
+    "targetVelocity": [
+      -0.5963952914910999
+    ],
+    "targetAcceleration": [
+      0.04922545412581458
+    ],
+    "maxVelocity": [
+      2.471417538096583
+    ],
+    "maxAcceleration": [
+      3.721451460018754
+    ],
+    "maxJerk": [
+      11.001648070291413
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.360747526596118
+    ],
+    "currentVelocity": [
+      3.3316781818446595
+    ],
+    "currentAcceleration": [
+      -0.05494141325930624
+    ],
+    "targetPosition": [
+      -7.805614553936826
+    ],
+    "targetVelocity": [
+      0.915390548384643
+    ],
+    "targetAcceleration": [
+      -2.3919446671916047
+    ],
+    "maxVelocity": [
+      6.133374085327731
+    ],
+    "maxAcceleration": [
+      4.309435036128729
+    ],
+    "maxJerk": [
+      7.982988552149983
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.909143442780055
+    ],
+    "currentVelocity": [
+      7.186286269421111
+    ],
+    "currentAcceleration": [
+      -1.3261381967296266
+    ],
+    "targetPosition": [
+      2.471715363611967
+    ],
+    "targetVelocity": [
+      1.2594014064884407
+    ],
+    "targetAcceleration": [
+      1.0355566491872406
+    ],
+    "maxVelocity": [
+      7.8418590778565695
+    ],
+    "maxAcceleration": [
+      9.132915449132145
+    ],
+    "maxJerk": [
+      11.20874043830788
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.545751928854859
+    ],
+    "currentVelocity": [
+      0.5974066852849798
+    ],
+    "currentAcceleration": [
+      -2.6235856703480227
+    ],
+    "targetPosition": [
+      8.372413517732522
+    ],
+    "targetVelocity": [
+      -0.15140247193813838
+    ],
+    "targetAcceleration": [
+      5.4978922761149
+    ],
+    "maxVelocity": [
+      2.9732990261994034
+    ],
+    "maxAcceleration": [
+      8.242450722537077
+    ],
+    "maxJerk": [
+      6.691483046695024
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.44971145878506746
+    ],
+    "currentVelocity": [
+      0.6487919339079187
+    ],
+    "currentAcceleration": [
+      1.717175902233917
+    ],
+    "targetPosition": [
+      -6.02409056618193
+    ],
+    "targetVelocity": [
+      1.9069775671801574
+    ],
+    "targetAcceleration": [
+      5.423016671406202
+    ],
+    "maxVelocity": [
+      2.3301507917934465
+    ],
+    "maxAcceleration": [
+      7.7597516707492264
+    ],
+    "maxJerk": [
+      12.405432943367558
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.6290797728372652
+    ],
+    "currentVelocity": [
+      1.5548807688157789
+    ],
+    "currentAcceleration": [
+      -6.621075769187761
+    ],
+    "targetPosition": [
+      -1.8682068389203046
+    ],
+    "targetVelocity": [
+      -0.5951339980166392
+    ],
+    "targetAcceleration": [
+      -4.638502763006442
+    ],
+    "maxVelocity": [
+      2.998570020606839
+    ],
+    "maxAcceleration": [
+      8.719991120178985
+    ],
+    "maxJerk": [
+      16.67955456416997
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.0786392346988176
+    ],
+    "currentVelocity": [
+      1.2721688066315728
+    ],
+    "currentAcceleration": [
+      -3.4774493019555432
+    ],
+    "targetPosition": [
+      -3.914863205839345
+    ],
+    "targetVelocity": [
+      -2.9109314460575786
+    ],
+    "targetAcceleration": [
+      0.4925614468599857
+    ],
+    "maxVelocity": [
+      5.6663704921530496
+    ],
+    "maxAcceleration": [
+      9.073604134841036
+    ],
+    "maxJerk": [
+      18.288873112663225
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.6107219471508589
+    ],
+    "currentVelocity": [
+      5.3108292608425245
+    ],
+    "currentAcceleration": [
+      -0.6133189196069462
+    ],
+    "targetPosition": [
+      9.992931841310629
+    ],
+    "targetVelocity": [
+      -4.919600286111355
+    ],
+    "targetAcceleration": [
+      3.019977530278773
+    ],
+    "maxVelocity": [
+      6.734699738865354
+    ],
+    "maxAcceleration": [
+      4.380469160777901
+    ],
+    "maxJerk": [
+      9.26012046241952
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.6202597912719607
+    ],
+    "currentVelocity": [
+      -2.1009428366412237
+    ],
+    "currentAcceleration": [
+      2.96390736270574
+    ],
+    "targetPosition": [
+      -0.4732981960295142
+    ],
+    "targetVelocity": [
+      -1.4296649246465427
+    ],
+    "targetAcceleration": [
+      1.9560003336018488
+    ],
+    "maxVelocity": [
+      2.948805061870778
+    ],
+    "maxAcceleration": [
+      5.192681658508404
+    ],
+    "maxJerk": [
+      14.116584455414069
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.210504091385875
+    ],
+    "currentVelocity": [
+      4.435397870149449
+    ],
+    "currentAcceleration": [
+      -2.862864985436355
+    ],
+    "targetPosition": [
+      2.818181803066718
+    ],
+    "targetVelocity": [
+      -2.095831042035138
+    ],
+    "targetAcceleration": [
+      -0.7579454436482562
+    ],
+    "maxVelocity": [
+      4.545220586631295
+    ],
+    "maxAcceleration": [
+      4.861075187660729
+    ],
+    "maxJerk": [
+      9.957472256944197
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.063385267395876
+    ],
+    "currentVelocity": [
+      1.038816732251636
+    ],
+    "currentAcceleration": [
+      1.161118679823005
+    ],
+    "targetPosition": [
+      3.2988493961742105
+    ],
+    "targetVelocity": [
+      -4.453903378405528
+    ],
+    "targetAcceleration": [
+      3.4199550292316694
+    ],
+    "maxVelocity": [
+      7.930224464690241
+    ],
+    "maxAcceleration": [
+      8.0403079970305
+    ],
+    "maxJerk": [
+      16.976106676217185
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.386748132071602
+    ],
+    "currentVelocity": [
+      -1.9645045604980025
+    ],
+    "currentAcceleration": [
+      -1.1507944880012717
+    ],
+    "targetPosition": [
+      -0.46329071427454593
+    ],
+    "targetVelocity": [
+      0.37887721365935967
+    ],
+    "targetAcceleration": [
+      -3.757288238178186
+    ],
+    "maxVelocity": [
+      6.40048901367535
+    ],
+    "maxAcceleration": [
+      4.213998146155085
+    ],
+    "maxJerk": [
+      7.71026413234709
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.171062428926161
+    ],
+    "currentVelocity": [
+      -2.54883832526486
+    ],
+    "currentAcceleration": [
+      4.223655688686115
+    ],
+    "targetPosition": [
+      -4.999470061165288
+    ],
+    "targetVelocity": [
+      -0.8638345345905325
+    ],
+    "targetAcceleration": [
+      0.31919550747458825
+    ],
+    "maxVelocity": [
+      2.651743285693673
+    ],
+    "maxAcceleration": [
+      5.018071835467671
+    ],
+    "maxJerk": [
+      13.072806559066033
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.89475167518135
+    ],
+    "currentVelocity": [
+      1.8090119542616527
+    ],
+    "currentAcceleration": [
+      5.62494747417813
+    ],
+    "targetPosition": [
+      7.74748489956605
+    ],
+    "targetVelocity": [
+      -0.1917653082802211
+    ],
+    "targetAcceleration": [
+      -0.5821487045233162
+    ],
+    "maxVelocity": [
+      7.860285062777848
+    ],
+    "maxAcceleration": [
+      7.0949588871461735
+    ],
+    "maxJerk": [
+      7.357046454073888
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.8705295051912465
+    ],
+    "currentVelocity": [
+      1.6561964826472737
+    ],
+    "currentAcceleration": [
+      -0.5144200256249762
+    ],
+    "targetPosition": [
+      0.7758671362421588
+    ],
+    "targetVelocity": [
+      0.4176083948226057
+    ],
+    "targetAcceleration": [
+      5.948090394963881
+    ],
+    "maxVelocity": [
+      2.4585237839295653
+    ],
+    "maxAcceleration": [
+      6.524979896518888
+    ],
+    "maxJerk": [
+      8.450384070287262
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.697654396232318
+    ],
+    "currentVelocity": [
+      -3.673949996129061
+    ],
+    "currentAcceleration": [
+      -2.1615963462443553
+    ],
+    "targetPosition": [
+      8.523587082551739
+    ],
+    "targetVelocity": [
+      2.726792243907745
+    ],
+    "targetAcceleration": [
+      -6.400304685820944
+    ],
+    "maxVelocity": [
+      7.160390559772102
+    ],
+    "maxAcceleration": [
+      7.789196587780035
+    ],
+    "maxJerk": [
+      10.961029413666619
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.572358551368336
+    ],
+    "currentVelocity": [
+      0.18689301924002066
+    ],
+    "currentAcceleration": [
+      -0.3061995575733576
+    ],
+    "targetPosition": [
+      -6.247129306831541
+    ],
+    "targetVelocity": [
+      -3.7313895171585942
+    ],
+    "targetAcceleration": [
+      -6.15295796894824
+    ],
+    "maxVelocity": [
+      6.006724214250968
+    ],
+    "maxAcceleration": [
+      7.335106086663196
+    ],
+    "maxJerk": [
+      5.850599357320624
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.338785977837478
+    ],
+    "currentVelocity": [
+      0.627376408991184
+    ],
+    "currentAcceleration": [
+      1.0076571338998974
+    ],
+    "targetPosition": [
+      3.7654807264991703
+    ],
+    "targetVelocity": [
+      -0.06454140524085261
+    ],
+    "targetAcceleration": [
+      2.1777783063651555
+    ],
+    "maxVelocity": [
+      6.773329189607354
+    ],
+    "maxAcceleration": [
+      9.201290158837692
+    ],
+    "maxJerk": [
+      10.652420993925087
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.39012931356543
+    ],
+    "currentVelocity": [
+      -1.1390544591608949
+    ],
+    "currentAcceleration": [
+      4.580418084075326
+    ],
+    "targetPosition": [
+      -3.2487632723356574
+    ],
+    "targetVelocity": [
+      6.999621611823123
+    ],
+    "targetAcceleration": [
+      2.0435628133004577
+    ],
+    "maxVelocity": [
+      7.996491869812493
+    ],
+    "maxAcceleration": [
+      9.964434789427575
+    ],
+    "maxJerk": [
+      19.542842443097456
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.677271900291409
+    ],
+    "currentVelocity": [
+      0.057610212921210824
+    ],
+    "currentAcceleration": [
+      -3.3307556326691463
+    ],
+    "targetPosition": [
+      -3.831190137110836
+    ],
+    "targetVelocity": [
+      -1.5360110312808075
+    ],
+    "targetAcceleration": [
+      -1.0781665874556232
+    ],
+    "maxVelocity": [
+      7.730666202407676
+    ],
+    "maxAcceleration": [
+      7.586205417447401
+    ],
+    "maxJerk": [
+      18.357913759380178
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.199005429377227
+    ],
+    "currentVelocity": [
+      -0.6771934422409656
+    ],
+    "currentAcceleration": [
+      -4.370901975604033
+    ],
+    "targetPosition": [
+      -6.977474260397485
+    ],
+    "targetVelocity": [
+      1.129026435226363
+    ],
+    "targetAcceleration": [
+      -7.425477386614029
+    ],
+    "maxVelocity": [
+      7.933032585862884
+    ],
+    "maxAcceleration": [
+      9.390656738233282
+    ],
+    "maxJerk": [
+      12.267218339986126
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.1305268986508175
+    ],
+    "currentVelocity": [
+      0.9613492396781425
+    ],
+    "currentAcceleration": [
+      2.4737002204387473
+    ],
+    "targetPosition": [
+      -8.172295503684408
+    ],
+    "targetVelocity": [
+      -0.818805564470577
+    ],
+    "targetAcceleration": [
+      -1.7761658335306167
+    ],
+    "maxVelocity": [
+      2.1849389375314288
+    ],
+    "maxAcceleration": [
+      6.3894920364170655
+    ],
+    "maxJerk": [
+      8.44322978188288
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.362212702859992
+    ],
+    "currentVelocity": [
+      0.31732562377240825
+    ],
+    "currentAcceleration": [
+      4.818496013811685
+    ],
+    "targetPosition": [
+      5.065107785069717
+    ],
+    "targetVelocity": [
+      1.9712213825019171
+    ],
+    "targetAcceleration": [
+      -6.780813436981727
+    ],
+    "maxVelocity": [
+      3.9127260390342915
+    ],
+    "maxAcceleration": [
+      7.0726111522047725
+    ],
+    "maxJerk": [
+      17.492362723827735
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.2839039784170865
+    ],
+    "currentVelocity": [
+      0.6403110623982382
+    ],
+    "currentAcceleration": [
+      -0.7321231309860301
+    ],
+    "targetPosition": [
+      8.53038505927939
+    ],
+    "targetVelocity": [
+      3.0549099387564596
+    ],
+    "targetAcceleration": [
+      1.6939651730099503
+    ],
+    "maxVelocity": [
+      5.715433842610459
+    ],
+    "maxAcceleration": [
+      3.980611326404214
+    ],
+    "maxJerk": [
+      6.4214796225807635
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.324213611462669
+    ],
+    "currentVelocity": [
+      -3.4516594071462556
+    ],
+    "currentAcceleration": [
+      -4.038428110904098
+    ],
+    "targetPosition": [
+      -8.98270324050065
+    ],
+    "targetVelocity": [
+      1.1853496636740743
+    ],
+    "targetAcceleration": [
+      -8.074634477878137
+    ],
+    "maxVelocity": [
+      5.124552187953306
+    ],
+    "maxAcceleration": [
+      8.352553109007161
+    ],
+    "maxJerk": [
+      17.37477187944407
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.2052799577609727
+    ],
+    "currentVelocity": [
+      2.186570480854301
+    ],
+    "currentAcceleration": [
+      5.660423209120935
+    ],
+    "targetPosition": [
+      -6.571473340960072
+    ],
+    "targetVelocity": [
+      2.0680708997911834
+    ],
+    "targetAcceleration": [
+      0.9629681580276239
+    ],
+    "maxVelocity": [
+      5.890169862116379
+    ],
+    "maxAcceleration": [
+      5.812310653155947
+    ],
+    "maxJerk": [
+      14.10449184967372
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.43363228685865884
+    ],
+    "currentVelocity": [
+      2.499006152518866
+    ],
+    "currentAcceleration": [
+      -1.580735955340148
+    ],
+    "targetPosition": [
+      9.37719580357522
+    ],
+    "targetVelocity": [
+      -2.9569713915327513
+    ],
+    "targetAcceleration": [
+      -0.8910336642253309
+    ],
+    "maxVelocity": [
+      3.9859048926210394
+    ],
+    "maxAcceleration": [
+      5.695197974649565
+    ],
+    "maxJerk": [
+      11.640339877450739
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.973103962035804
+    ],
+    "currentVelocity": [
+      6.178500278963764
+    ],
+    "currentAcceleration": [
+      1.8401448335014141
+    ],
+    "targetPosition": [
+      -6.328205458104423
+    ],
+    "targetVelocity": [
+      -0.9875734972146324
+    ],
+    "targetAcceleration": [
+      0.1625800860774813
+    ],
+    "maxVelocity": [
+      7.017092937257944
+    ],
+    "maxAcceleration": [
+      4.813144142943907
+    ],
+    "maxJerk": [
+      17.10931077796188
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.9257898484681348
+    ],
+    "currentVelocity": [
+      0.5582229934918681
+    ],
+    "currentAcceleration": [
+      -0.8216431448782666
+    ],
+    "targetPosition": [
+      -8.75331069390196
+    ],
+    "targetVelocity": [
+      -3.0157726345522406
+    ],
+    "targetAcceleration": [
+      -0.41201260805591877
+    ],
+    "maxVelocity": [
+      5.1727220856592036
+    ],
+    "maxAcceleration": [
+      3.088324461550913
+    ],
+    "maxJerk": [
+      11.546553918636718
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.270477789122281
+    ],
+    "currentVelocity": [
+      -4.737571778368971
+    ],
+    "currentAcceleration": [
+      5.61581249615688
+    ],
+    "targetPosition": [
+      -0.06463338190895662
+    ],
+    "targetVelocity": [
+      -4.053835358985876
+    ],
+    "targetAcceleration": [
+      1.0545462118556008
+    ],
+    "maxVelocity": [
+      4.875048062646603
+    ],
+    "maxAcceleration": [
+      5.709598613796323
+    ],
+    "maxJerk": [
+      14.748459798453316
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.4743421683370315
+    ],
+    "currentVelocity": [
+      1.961209291339352
+    ],
+    "currentAcceleration": [
+      -1.6814459242769935
+    ],
+    "targetPosition": [
+      -4.657950738013541
+    ],
+    "targetVelocity": [
+      -1.9129358343746738
+    ],
+    "targetAcceleration": [
+      -1.6807878313740343
+    ],
+    "maxVelocity": [
+      5.855029148406555
+    ],
+    "maxAcceleration": [
+      3.2549856920720743
+    ],
+    "maxJerk": [
+      13.206563398512301
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.435392904888117
+    ],
+    "currentVelocity": [
+      -3.120005916830907
+    ],
+    "currentAcceleration": [
+      6.342320372774724
+    ],
+    "targetPosition": [
+      -0.45696623805022796
+    ],
+    "targetVelocity": [
+      3.162248306181958
+    ],
+    "targetAcceleration": [
+      -0.8401908528184672
+    ],
+    "maxVelocity": [
+      7.7964867747360245
+    ],
+    "maxAcceleration": [
+      6.376679194974004
+    ],
+    "maxJerk": [
+      10.831126371972262
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.350096116784478
+    ],
+    "currentVelocity": [
+      -3.5295153397019163
+    ],
+    "currentAcceleration": [
+      5.4524485187748315
+    ],
+    "targetPosition": [
+      9.054259020693593
+    ],
+    "targetVelocity": [
+      3.2093445912901153
+    ],
+    "targetAcceleration": [
+      -4.51597347427223
+    ],
+    "maxVelocity": [
+      7.166034462830149
+    ],
+    "maxAcceleration": [
+      8.213179272608286
+    ],
+    "maxJerk": [
+      5.19800009906018
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.7765855017181718
+    ],
+    "currentVelocity": [
+      3.970954888060043
+    ],
+    "currentAcceleration": [
+      -3.804454994742351
+    ],
+    "targetPosition": [
+      -8.621939732953717
+    ],
+    "targetVelocity": [
+      -1.20323784787717
+    ],
+    "targetAcceleration": [
+      2.1541951167896283
+    ],
+    "maxVelocity": [
+      5.206201184601727
+    ],
+    "maxAcceleration": [
+      6.615995498186603
+    ],
+    "maxJerk": [
+      18.540903572849572
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.82502904811492
+    ],
+    "currentVelocity": [
+      1.9369785623570452
+    ],
+    "currentAcceleration": [
+      1.2270836748169724
+    ],
+    "targetPosition": [
+      9.765339718970012
+    ],
+    "targetVelocity": [
+      -2.3609860397450313
+    ],
+    "targetAcceleration": [
+      -0.6783282108328397
+    ],
+    "maxVelocity": [
+      2.943215057354192
+    ],
+    "maxAcceleration": [
+      7.628818902492403
+    ],
+    "maxJerk": [
+      12.444066377843233
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.4379858272209205
+    ],
+    "currentVelocity": [
+      -0.3150868826356674
+    ],
+    "currentAcceleration": [
+      -1.0752875484988387
+    ],
+    "targetPosition": [
+      1.7290635838847397
+    ],
+    "targetVelocity": [
+      1.2267566110874264
+    ],
+    "targetAcceleration": [
+      5.83223714824695
+    ],
+    "maxVelocity": [
+      2.001972175201721
+    ],
+    "maxAcceleration": [
+      5.9697288982439325
+    ],
+    "maxJerk": [
+      17.32217665760769
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.3324739258768705
+    ],
+    "currentVelocity": [
+      -2.595515757886168
+    ],
+    "currentAcceleration": [
+      4.050882822530733
+    ],
+    "targetPosition": [
+      4.789624918161522
+    ],
+    "targetVelocity": [
+      -4.005886423274442
+    ],
+    "targetAcceleration": [
+      -3.720262581957586
+    ],
+    "maxVelocity": [
+      4.357261048485048
+    ],
+    "maxAcceleration": [
+      8.216093889295687
+    ],
+    "maxJerk": [
+      9.650779289816878
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.922479745649847
+    ],
+    "currentVelocity": [
+      0.48879729741783606
+    ],
+    "currentAcceleration": [
+      -0.05858196927055559
+    ],
+    "targetPosition": [
+      -1.1353675277566957
+    ],
+    "targetVelocity": [
+      -0.3054291216958642
+    ],
+    "targetAcceleration": [
+      -5.6111949074889536
+    ],
+    "maxVelocity": [
+      7.209535968401056
+    ],
+    "maxAcceleration": [
+      9.507897610837901
+    ],
+    "maxJerk": [
+      9.363709879517193
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.127254144583546
+    ],
+    "currentVelocity": [
+      -0.7559999832146227
+    ],
+    "currentAcceleration": [
+      6.483983942030596
+    ],
+    "targetPosition": [
+      -1.8000172538627073
+    ],
+    "targetVelocity": [
+      1.020411724332166
+    ],
+    "targetAcceleration": [
+      4.571075067793707
+    ],
+    "maxVelocity": [
+      2.4776567281880064
+    ],
+    "maxAcceleration": [
+      7.468861361261267
+    ],
+    "maxJerk": [
+      8.855684884377384
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.024736717528843
+    ],
+    "currentVelocity": [
+      0.9592534566182191
+    ],
+    "currentAcceleration": [
+      0.09329077824835075
+    ],
+    "targetPosition": [
+      8.053675574625355
+    ],
+    "targetVelocity": [
+      -6.2843955732693
+    ],
+    "targetAcceleration": [
+      -3.479630430118009
+    ],
+    "maxVelocity": [
+      7.33744869714209
+    ],
+    "maxAcceleration": [
+      4.751037636292958
+    ],
+    "maxJerk": [
+      8.746404683407821
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+    {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.929020109346629
+    ],
+    "currentVelocity": [
+      3.904741109343907
+    ],
+    "currentAcceleration": [
+      1.0827080090548264
+    ],
+    "targetPosition": [
+      -1.4620462188399141
+    ],
+    "targetVelocity": [
+      0.9603468503966699
+    ],
+    "targetAcceleration": [
+      -0.676379521648447
+    ],
+    "maxVelocity": [
+      4.092582786286295
+    ],
+    "maxAcceleration": [
+      4.193414380622032
+    ],
+    "maxJerk": [
+      8.439075729927787
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.507923481393986
+    ],
+    "currentVelocity": [
+      -2.400514744080207
+    ],
+    "currentAcceleration": [
+      1.9856217902824618
+    ],
+    "targetPosition": [
+      -5.763398796867632
+    ],
+    "targetVelocity": [
+      0.5789863145653253
+    ],
+    "targetAcceleration": [
+      -4.207017729190458
+    ],
+    "maxVelocity": [
+      3.7812375541855863
+    ],
+    "maxAcceleration": [
+      6.788303404150403
+    ],
+    "maxJerk": [
+      10.724379650396422
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.9830984180738476
+    ],
+    "currentVelocity": [
+      -3.1434216991097177
+    ],
+    "currentAcceleration": [
+      -0.4496908976025846
+    ],
+    "targetPosition": [
+      -4.209327420856104
+    ],
+    "targetVelocity": [
+      1.409077112797239
+    ],
+    "targetAcceleration": [
+      -2.4574609939903596
+    ],
+    "maxVelocity": [
+      5.545128738234714
+    ],
+    "maxAcceleration": [
+      8.978060941112993
+    ],
+    "maxJerk": [
+      11.26949167028507
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.653066120838343
+    ],
+    "currentVelocity": [
+      1.854514931783298
+    ],
+    "currentAcceleration": [
+      4.141693364731379
+    ],
+    "targetPosition": [
+      3.300454522260468
+    ],
+    "targetVelocity": [
+      -1.9627764390677809
+    ],
+    "targetAcceleration": [
+      -4.27686775314462
+    ],
+    "maxVelocity": [
+      3.1007238974966156
+    ],
+    "maxAcceleration": [
+      5.407313130272458
+    ],
+    "maxJerk": [
+      13.47169918776571
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.237980387352458
+    ],
+    "currentVelocity": [
+      3.527629994845988
+    ],
+    "currentAcceleration": [
+      2.3863722085536683
+    ],
+    "targetPosition": [
+      -9.394926903066734
+    ],
+    "targetVelocity": [
+      -1.633462817634074
+    ],
+    "targetAcceleration": [
+      -2.488289109483916
+    ],
+    "maxVelocity": [
+      7.802918166168109
+    ],
+    "maxAcceleration": [
+      5.779515033828643
+    ],
+    "maxJerk": [
+      8.681990404512183
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.2377721351303936
+    ],
+    "currentVelocity": [
+      1.4595898960618623
+    ],
+    "currentAcceleration": [
+      -0.3805741104124696
+    ],
+    "targetPosition": [
+      -5.696717706138568
+    ],
+    "targetVelocity": [
+      2.380475063970522
+    ],
+    "targetAcceleration": [
+      -2.765434873432894
+    ],
+    "maxVelocity": [
+      2.9810562226009463
+    ],
+    "maxAcceleration": [
+      6.771844787530694
+    ],
+    "maxJerk": [
+      17.848297072721948
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.451329793142035
+    ],
+    "currentVelocity": [
+      3.2474220060779864
+    ],
+    "currentAcceleration": [
+      -1.7147755525663353
+    ],
+    "targetPosition": [
+      -7.753277241260264
+    ],
+    "targetVelocity": [
+      0.08442314798747486
+    ],
+    "targetAcceleration": [
+      -7.268297211780087
+    ],
+    "maxVelocity": [
+      4.186003417659544
+    ],
+    "maxAcceleration": [
+      9.572450788698784
+    ],
+    "maxJerk": [
+      10.931230866837044
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.219895824602462
+    ],
+    "currentVelocity": [
+      1.595140063754616
+    ],
+    "currentAcceleration": [
+      -5.541310135066427
+    ],
+    "targetPosition": [
+      -8.58731591288932
+    ],
+    "targetVelocity": [
+      1.488316868469461
+    ],
+    "targetAcceleration": [
+      -1.3528271279429926
+    ],
+    "maxVelocity": [
+      2.1221829213913526
+    ],
+    "maxAcceleration": [
+      8.857096036994438
+    ],
+    "maxJerk": [
+      14.348562071383594
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.6069650225212566
+    ],
+    "currentVelocity": [
+      -0.24680562897057357
+    ],
+    "currentAcceleration": [
+      6.91502550505265
+    ],
+    "targetPosition": [
+      1.0943190086959564
+    ],
+    "targetVelocity": [
+      -2.4453620335512003
+    ],
+    "targetAcceleration": [
+      5.533498200268502
+    ],
+    "maxVelocity": [
+      5.5263073279099695
+    ],
+    "maxAcceleration": [
+      8.763579300113486
+    ],
+    "maxJerk": [
+      9.53618354095868
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.9335826262310345
+    ],
+    "currentVelocity": [
+      -0.08833322854466186
+    ],
+    "currentAcceleration": [
+      -0.3949730855309559
+    ],
+    "targetPosition": [
+      -4.257229567285423
+    ],
+    "targetVelocity": [
+      3.447823322230011
+    ],
+    "targetAcceleration": [
+      1.6357140588877188
+    ],
+    "maxVelocity": [
+      5.545590115378186
+    ],
+    "maxAcceleration": [
+      4.836643486523883
+    ],
+    "maxJerk": [
+      11.301793686030132
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.12255628836934207
+    ],
+    "currentVelocity": [
+      4.359532814805794
+    ],
+    "currentAcceleration": [
+      1.6259470677999621
+    ],
+    "targetPosition": [
+      -1.6506405914745237
+    ],
+    "targetVelocity": [
+      2.467238982646636
+    ],
+    "targetAcceleration": [
+      -1.9482728140972767
+    ],
+    "maxVelocity": [
+      5.5979811375824795
+    ],
+    "maxAcceleration": [
+      3.087405109551235
+    ],
+    "maxJerk": [
+      14.214992784725517
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.3954291951989184
+    ],
+    "currentVelocity": [
+      -0.4442286991143356
+    ],
+    "currentAcceleration": [
+      -4.018021045627429
+    ],
+    "targetPosition": [
+      2.9642397940156826
+    ],
+    "targetVelocity": [
+      0.15651404367546773
+    ],
+    "targetAcceleration": [
+      6.000578245183127
+    ],
+    "maxVelocity": [
+      2.8828715199114674
+    ],
+    "maxAcceleration": [
+      7.704673498559036
+    ],
+    "maxJerk": [
+      18.525088302430085
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.5547624887686826
+    ],
+    "currentVelocity": [
+      0.7792753146847504
+    ],
+    "currentAcceleration": [
+      -5.775303690686352
+    ],
+    "targetPosition": [
+      7.3220509010437915
+    ],
+    "targetVelocity": [
+      0.6728007006015142
+    ],
+    "targetAcceleration": [
+      -0.3668766599228057
+    ],
+    "maxVelocity": [
+      2.661900959277683
+    ],
+    "maxAcceleration": [
+      9.651093649769091
+    ],
+    "maxJerk": [
+      9.56210858268511
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.9991169238514725
+    ],
+    "currentVelocity": [
+      -5.196398127785409
+    ],
+    "currentAcceleration": [
+      -1.8918282819850338
+    ],
+    "targetPosition": [
+      9.714461164220761
+    ],
+    "targetVelocity": [
+      4.158737236536241
+    ],
+    "targetAcceleration": [
+      2.7468394185338143
+    ],
+    "maxVelocity": [
+      5.698577590491152
+    ],
+    "maxAcceleration": [
+      3.6873928839352548
+    ],
+    "maxJerk": [
+      18.27565780926476
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.503921781240132
+    ],
+    "currentVelocity": [
+      0.4011799946428276
+    ],
+    "currentAcceleration": [
+      -3.0343360390868175
+    ],
+    "targetPosition": [
+      -2.7315551190791076
+    ],
+    "targetVelocity": [
+      1.092166759905727
+    ],
+    "targetAcceleration": [
+      1.9967059316248945
+    ],
+    "maxVelocity": [
+      2.841122521616396
+    ],
+    "maxAcceleration": [
+      3.4166360775564795
+    ],
+    "maxJerk": [
+      13.35281106205517
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.664755934329875
+    ],
+    "currentVelocity": [
+      1.1566533637806309
+    ],
+    "currentAcceleration": [
+      0.3744921471728553
+    ],
+    "targetPosition": [
+      5.981408334133835
+    ],
+    "targetVelocity": [
+      3.8491365459907927
+    ],
+    "targetAcceleration": [
+      -4.047282765221784
+    ],
+    "maxVelocity": [
+      5.669411192942465
+    ],
+    "maxAcceleration": [
+      5.024459569559247
+    ],
+    "maxJerk": [
+      5.4671315540826875
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.2305172579567927
+    ],
+    "currentVelocity": [
+      2.979959699399277
+    ],
+    "currentAcceleration": [
+      2.2774509417673467
+    ],
+    "targetPosition": [
+      -4.114320900838903
+    ],
+    "targetVelocity": [
+      -4.638403656143724
+    ],
+    "targetAcceleration": [
+      -3.372866131598203
+    ],
+    "maxVelocity": [
+      6.498241391379294
+    ],
+    "maxAcceleration": [
+      5.069875060019046
+    ],
+    "maxJerk": [
+      14.11819174661981
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.354024983922264
+    ],
+    "currentVelocity": [
+      3.192032521011053
+    ],
+    "currentAcceleration": [
+      -1.2417994163916024
+    ],
+    "targetPosition": [
+      -2.018704683567705
+    ],
+    "targetVelocity": [
+      -0.23145822398696403
+    ],
+    "targetAcceleration": [
+      -3.0267768322226623
+    ],
+    "maxVelocity": [
+      6.458577704048587
+    ],
+    "maxAcceleration": [
+      3.3611881432229294
+    ],
+    "maxJerk": [
+      13.251736179460236
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7112140659487434
+    ],
+    "currentVelocity": [
+      3.5886843509523256
+    ],
+    "currentAcceleration": [
+      2.6975436621188345
+    ],
+    "targetPosition": [
+      -3.6518974046728285
+    ],
+    "targetVelocity": [
+      0.994177363527001
+    ],
+    "targetAcceleration": [
+      0.7170573932801516
+    ],
+    "maxVelocity": [
+      4.117398337761165
+    ],
+    "maxAcceleration": [
+      3.828502652586781
+    ],
+    "maxJerk": [
+      12.635950177895571
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.6417496674648895
+    ],
+    "currentVelocity": [
+      -1.6344351030032231
+    ],
+    "currentAcceleration": [
+      1.940220279522086
+    ],
+    "targetPosition": [
+      -2.477038910210072
+    ],
+    "targetVelocity": [
+      0.1388224159753242
+    ],
+    "targetAcceleration": [
+      -2.935946863492721
+    ],
+    "maxVelocity": [
+      2.16031284605104
+    ],
+    "maxAcceleration": [
+      3.715888853643237
+    ],
+    "maxJerk": [
+      7.596504749328107
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.584948615454655
+    ],
+    "currentVelocity": [
+      2.958618482226246
+    ],
+    "currentAcceleration": [
+      -1.1338639683138334
+    ],
+    "targetPosition": [
+      -9.491607589308398
+    ],
+    "targetVelocity": [
+      4.7033915691963255
+    ],
+    "targetAcceleration": [
+      -2.4705656860368785
+    ],
+    "maxVelocity": [
+      7.401633721759659
+    ],
+    "maxAcceleration": [
+      4.205828420122676
+    ],
+    "maxJerk": [
+      19.980048981345554
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.432848480330862
+    ],
+    "currentVelocity": [
+      -0.8973357128493327
+    ],
+    "currentAcceleration": [
+      -3.2192435581591594
+    ],
+    "targetPosition": [
+      -8.574216100140726
+    ],
+    "targetVelocity": [
+      2.4998412233886445
+    ],
+    "targetAcceleration": [
+      7.0846150067746
+    ],
+    "maxVelocity": [
+      2.6669218696079167
+    ],
+    "maxAcceleration": [
+      8.775098089779789
+    ],
+    "maxJerk": [
+      8.217770656111613
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.0564017813399236
+    ],
+    "currentVelocity": [
+      1.837769648296935
+    ],
+    "currentAcceleration": [
+      -1.377511699837068
+    ],
+    "targetPosition": [
+      -2.2199205642032105
+    ],
+    "targetVelocity": [
+      -3.093077659442959
+    ],
+    "targetAcceleration": [
+      -1.619797471694028
+    ],
+    "maxVelocity": [
+      4.6865400030409
+    ],
+    "maxAcceleration": [
+      4.158691004145345
+    ],
+    "maxJerk": [
+      16.820755795527667
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.197608183129159
+    ],
+    "currentVelocity": [
+      0.5233332047362769
+    ],
+    "currentAcceleration": [
+      -1.9510305301256716
+    ],
+    "targetPosition": [
+      -2.02443849887199
+    ],
+    "targetVelocity": [
+      2.5178607261809667
+    ],
+    "targetAcceleration": [
+      0.6683326458705316
+    ],
+    "maxVelocity": [
+      3.527907394523397
+    ],
+    "maxAcceleration": [
+      4.402418134328212
+    ],
+    "maxJerk": [
+      12.011046039223675
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.304803114098981
+    ],
+    "currentVelocity": [
+      6.180388194982897
+    ],
+    "currentAcceleration": [
+      -0.9980431181878737
+    ],
+    "targetPosition": [
+      -6.577955085376774
+    ],
+    "targetVelocity": [
+      -5.720722437042111
+    ],
+    "targetAcceleration": [
+      -2.01610049856267
+    ],
+    "maxVelocity": [
+      6.848950924926078
+    ],
+    "maxAcceleration": [
+      7.191199321834259
+    ],
+    "maxJerk": [
+      15.58814005580558
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.3764914167632387
+    ],
+    "currentVelocity": [
+      2.739153733529572
+    ],
+    "currentAcceleration": [
+      -4.009579286951374
+    ],
+    "targetPosition": [
+      -6.434892291255602
+    ],
+    "targetVelocity": [
+      -2.6206661754656135
+    ],
+    "targetAcceleration": [
+      -7.313064593708103
+    ],
+    "maxVelocity": [
+      4.644379209946438
+    ],
+    "maxAcceleration": [
+      7.360099520246372
+    ],
+    "maxJerk": [
+      10.611073162401272
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.316963052664249
+    ],
+    "currentVelocity": [
+      -1.351532356640409
+    ],
+    "currentAcceleration": [
+      -0.9494848815829542
+    ],
+    "targetPosition": [
+      -0.6139404923999443
+    ],
+    "targetVelocity": [
+      0.6146163676557954
+    ],
+    "targetAcceleration": [
+      -1.5912375546600748
+    ],
+    "maxVelocity": [
+      2.4216963468130164
+    ],
+    "maxAcceleration": [
+      4.70561895638612
+    ],
+    "maxJerk": [
+      8.013161401142254
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.5603745057604481
+    ],
+    "currentVelocity": [
+      0.6728264540892734
+    ],
+    "currentAcceleration": [
+      2.7651091301930837
+    ],
+    "targetPosition": [
+      5.654579113657679
+    ],
+    "targetVelocity": [
+      -1.4171896387464669
+    ],
+    "targetAcceleration": [
+      6.709219718436932
+    ],
+    "maxVelocity": [
+      5.604210337688729
+    ],
+    "maxAcceleration": [
+      8.351624592027012
+    ],
+    "maxJerk": [
+      10.33412985081885
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.745816651788056
+    ],
+    "currentVelocity": [
+      2.466918440127583
+    ],
+    "currentAcceleration": [
+      3.320933601459389
+    ],
+    "targetPosition": [
+      1.1936478828557373
+    ],
+    "targetVelocity": [
+      0.17376528758940646
+    ],
+    "targetAcceleration": [
+      -0.6026819964035259
+    ],
+    "maxVelocity": [
+      3.4149410496258765
+    ],
+    "maxAcceleration": [
+      3.538463013307542
+    ],
+    "maxJerk": [
+      5.821628423475447
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.186030948667284
+    ],
+    "currentVelocity": [
+      -6.632042707711895
+    ],
+    "currentAcceleration": [
+      3.1685676290054436
+    ],
+    "targetPosition": [
+      -4.0780084645922905
+    ],
+    "targetVelocity": [
+      2.5438241580285688
+    ],
+    "targetAcceleration": [
+      -5.919655518895983
+    ],
+    "maxVelocity": [
+      7.4496863636726705
+    ],
+    "maxAcceleration": [
+      7.15865704003101
+    ],
+    "maxJerk": [
+      19.86819451427108
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.1705255391026252
+    ],
+    "currentVelocity": [
+      0.9762739668332552
+    ],
+    "currentAcceleration": [
+      -1.7536190699463239
+    ],
+    "targetPosition": [
+      -1.4008801985362744
+    ],
+    "targetVelocity": [
+      1.7300658426974422
+    ],
+    "targetAcceleration": [
+      -4.3037697564637565
+    ],
+    "maxVelocity": [
+      5.045901883448598
+    ],
+    "maxAcceleration": [
+      9.644850921294545
+    ],
+    "maxJerk": [
+      14.451199545138538
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.541184129918948
+    ],
+    "currentVelocity": [
+      2.8992206048743565
+    ],
+    "currentAcceleration": [
+      1.551544842824642
+    ],
+    "targetPosition": [
+      -5.291432423888775
+    ],
+    "targetVelocity": [
+      2.385976136075243
+    ],
+    "targetAcceleration": [
+      2.855839255406779
+    ],
+    "maxVelocity": [
+      4.699154210529954
+    ],
+    "maxAcceleration": [
+      3.6039679516934093
+    ],
+    "maxJerk": [
+      18.642794266664215
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.25333328554645
+    ],
+    "currentVelocity": [
+      -3.304942374452933
+    ],
+    "currentAcceleration": [
+      -0.9454122055154
+    ],
+    "targetPosition": [
+      9.841630180411634
+    ],
+    "targetVelocity": [
+      -5.28636425719683
+    ],
+    "targetAcceleration": [
+      1.054799489916865
+    ],
+    "maxVelocity": [
+      6.033671213579659
+    ],
+    "maxAcceleration": [
+      3.488463062926017
+    ],
+    "maxJerk": [
+      16.698496887543524
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.840782386628163
+    ],
+    "currentVelocity": [
+      2.2916217399450023
+    ],
+    "currentAcceleration": [
+      -3.250993701798049
+    ],
+    "targetPosition": [
+      -0.12512733267373477
+    ],
+    "targetVelocity": [
+      -1.927303591931341
+    ],
+    "targetAcceleration": [
+      -5.931787289210614
+    ],
+    "maxVelocity": [
+      4.193704259924357
+    ],
+    "maxAcceleration": [
+      6.144556091168963
+    ],
+    "maxJerk": [
+      17.169666451190672
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.077221261413431
+    ],
+    "currentVelocity": [
+      -1.1473336545548207
+    ],
+    "currentAcceleration": [
+      3.2212185422124735
+    ],
+    "targetPosition": [
+      6.527094700155718
+    ],
+    "targetVelocity": [
+      0.8756646266658574
+    ],
+    "targetAcceleration": [
+      -7.279428101857604
+    ],
+    "maxVelocity": [
+      6.487369283316771
+    ],
+    "maxAcceleration": [
+      7.813910266187983
+    ],
+    "maxJerk": [
+      11.59458614434201
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.639164657833337
+    ],
+    "currentVelocity": [
+      -1.5148071129417255
+    ],
+    "currentAcceleration": [
+      3.411909657606273
+    ],
+    "targetPosition": [
+      3.9421341581984635
+    ],
+    "targetVelocity": [
+      1.008592888891802
+    ],
+    "targetAcceleration": [
+      -3.20113135968805
+    ],
+    "maxVelocity": [
+      4.15327886182484
+    ],
+    "maxAcceleration": [
+      9.863051073196118
+    ],
+    "maxJerk": [
+      17.999116083217785
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.508623682904261
+    ],
+    "currentVelocity": [
+      4.077161737182049
+    ],
+    "currentAcceleration": [
+      -8.256584333306298
+    ],
+    "targetPosition": [
+      -9.969523014770019
+    ],
+    "targetVelocity": [
+      4.374716124923934
+    ],
+    "targetAcceleration": [
+      -4.766344816695533
+    ],
+    "maxVelocity": [
+      6.091504694926403
+    ],
+    "maxAcceleration": [
+      8.313607952599607
+    ],
+    "maxJerk": [
+      12.541751307329124
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.5121089425833993
+    ],
+    "currentVelocity": [
+      0.5021591694171148
+    ],
+    "currentAcceleration": [
+      -0.5294114047952938
+    ],
+    "targetPosition": [
+      5.78198073141804
+    ],
+    "targetVelocity": [
+      4.098591622248986
+    ],
+    "targetAcceleration": [
+      -3.0933156506887673
+    ],
+    "maxVelocity": [
+      4.916035124652368
+    ],
+    "maxAcceleration": [
+      4.433026333622877
+    ],
+    "maxJerk": [
+      19.912581208601914
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.809821435317577
+    ],
+    "currentVelocity": [
+      0.6142742512283839
+    ],
+    "currentAcceleration": [
+      3.4206671834543627
+    ],
+    "targetPosition": [
+      -1.6717550499760563
+    ],
+    "targetVelocity": [
+      4.525673858875578
+    ],
+    "targetAcceleration": [
+      -0.33756321587511184
+    ],
+    "maxVelocity": [
+      7.332314433752327
+    ],
+    "maxAcceleration": [
+      4.666643546125741
+    ],
+    "maxJerk": [
+      5.232893975724179
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.024312535835961
+    ],
+    "currentVelocity": [
+      2.807687832752767
+    ],
+    "currentAcceleration": [
+      1.5078902123200137
+    ],
+    "targetPosition": [
+      -9.785691594306357
+    ],
+    "targetVelocity": [
+      -3.4841615766955965
+    ],
+    "targetAcceleration": [
+      2.494265888888412
+    ],
+    "maxVelocity": [
+      4.728552110330158
+    ],
+    "maxAcceleration": [
+      6.596812729912573
+    ],
+    "maxJerk": [
+      10.468102295197843
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.4886274542950986
+    ],
+    "currentVelocity": [
+      -1.916029144852935
+    ],
+    "currentAcceleration": [
+      -4.022822999080735
+    ],
+    "targetPosition": [
+      1.7868222409813228
+    ],
+    "targetVelocity": [
+      5.030709158412627
+    ],
+    "targetAcceleration": [
+      -5.188102312625901
+    ],
+    "maxVelocity": [
+      7.366292683127821
+    ],
+    "maxAcceleration": [
+      9.633017989902644
+    ],
+    "maxJerk": [
+      9.702122352683245
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.108899843546084
+    ],
+    "currentVelocity": [
+      4.315922924630868
+    ],
+    "currentAcceleration": [
+      -6.91476699105175
+    ],
+    "targetPosition": [
+      -5.744412159380272
+    ],
+    "targetVelocity": [
+      1.9369542128439
+    ],
+    "targetAcceleration": [
+      6.275026856688347
+    ],
+    "maxVelocity": [
+      5.298466413342693
+    ],
+    "maxAcceleration": [
+      8.201546239059624
+    ],
+    "maxJerk": [
+      6.615744128118942
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.634044082551411
+    ],
+    "currentVelocity": [
+      2.4258232294970083
+    ],
+    "currentAcceleration": [
+      0.7657536569057131
+    ],
+    "targetPosition": [
+      -8.52014286019065
+    ],
+    "targetVelocity": [
+      3.2145439339626067
+    ],
+    "targetAcceleration": [
+      -1.695081677990879
+    ],
+    "maxVelocity": [
+      5.985508836705539
+    ],
+    "maxAcceleration": [
+      3.247754504589115
+    ],
+    "maxJerk": [
+      7.089848286338096
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.506002501951315
+    ],
+    "currentVelocity": [
+      0.07004997044888306
+    ],
+    "currentAcceleration": [
+      3.4060764567564803
+    ],
+    "targetPosition": [
+      -1.2544198196816794
+    ],
+    "targetVelocity": [
+      4.600092579749044
+    ],
+    "targetAcceleration": [
+      5.027197905283241
+    ],
+    "maxVelocity": [
+      6.609949198225276
+    ],
+    "maxAcceleration": [
+      5.553471273987462
+    ],
+    "maxJerk": [
+      16.222764293834203
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.16732903304353
+    ],
+    "currentVelocity": [
+      2.375178696835146
+    ],
+    "currentAcceleration": [
+      -1.2659866206705725
+    ],
+    "targetPosition": [
+      0.7706518415502099
+    ],
+    "targetVelocity": [
+      -5.139522733797315
+    ],
+    "targetAcceleration": [
+      -5.8343639867671175
+    ],
+    "maxVelocity": [
+      6.36111911263475
+    ],
+    "maxAcceleration": [
+      8.217624545910532
+    ],
+    "maxJerk": [
+      18.595856048088443
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.636593175302098
+    ],
+    "currentVelocity": [
+      -4.377025882756506
+    ],
+    "currentAcceleration": [
+      -1.8045185964144617
+    ],
+    "targetPosition": [
+      1.8428304966961768
+    ],
+    "targetVelocity": [
+      -1.2496591153075132
+    ],
+    "targetAcceleration": [
+      2.7172005868346503
+    ],
+    "maxVelocity": [
+      5.399379190828587
+    ],
+    "maxAcceleration": [
+      9.649961415970495
+    ],
+    "maxJerk": [
+      9.369828288917745
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.860059725990773
+    ],
+    "currentVelocity": [
+      -5.9632635340033175
+    ],
+    "currentAcceleration": [
+      -1.567335443387786
+    ],
+    "targetPosition": [
+      4.233454032115242
+    ],
+    "targetVelocity": [
+      3.34397681916876
+    ],
+    "targetAcceleration": [
+      3.5205126755764447
+    ],
+    "maxVelocity": [
+      6.16535967622321
+    ],
+    "maxAcceleration": [
+      6.079222726878363
+    ],
+    "maxJerk": [
+      6.551160636942923
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.522587945871919
+    ],
+    "currentVelocity": [
+      -1.9271905218121532
+    ],
+    "currentAcceleration": [
+      3.864074785653041
+    ],
+    "targetPosition": [
+      0.4548845252061575
+    ],
+    "targetVelocity": [
+      -1.082412543212144
+    ],
+    "targetAcceleration": [
+      3.2876085785226463
+    ],
+    "maxVelocity": [
+      2.095057531236492
+    ],
+    "maxAcceleration": [
+      5.781948740631942
+    ],
+    "maxJerk": [
+      15.60467894921793
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.275406971775336
+    ],
+    "currentVelocity": [
+      -1.7466086337938544
+    ],
+    "currentAcceleration": [
+      2.7411020023840322
+    ],
+    "targetPosition": [
+      -2.805320447220925
+    ],
+    "targetVelocity": [
+      0.20492486292837597
+    ],
+    "targetAcceleration": [
+      -4.563377121829327
+    ],
+    "maxVelocity": [
+      2.5689581342359964
+    ],
+    "maxAcceleration": [
+      9.86005630751017
+    ],
+    "maxJerk": [
+      17.954191920291187
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.0341625137168595
+    ],
+    "currentVelocity": [
+      -4.857019816805731
+    ],
+    "currentAcceleration": [
+      0.7716234478508031
+    ],
+    "targetPosition": [
+      0.3034667279746017
+    ],
+    "targetVelocity": [
+      1.3542162838162266
+    ],
+    "targetAcceleration": [
+      0.975318794229922
+    ],
+    "maxVelocity": [
+      5.949351065608807
+    ],
+    "maxAcceleration": [
+      3.2629977481876566
+    ],
+    "maxJerk": [
+      16.12532711445024
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.243561567142438
+    ],
+    "currentVelocity": [
+      0.9148356202852588
+    ],
+    "currentAcceleration": [
+      1.980197111835417
+    ],
+    "targetPosition": [
+      -2.8711695248497087
+    ],
+    "targetVelocity": [
+      -2.3061363870148255
+    ],
+    "targetAcceleration": [
+      -4.412847925423306
+    ],
+    "maxVelocity": [
+      4.848641029234478
+    ],
+    "maxAcceleration": [
+      7.119841661362822
+    ],
+    "maxJerk": [
+      5.699261866590465
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.2712168319437378
+    ],
+    "currentVelocity": [
+      1.3782322310783242
+    ],
+    "currentAcceleration": [
+      -3.5896859813818134
+    ],
+    "targetPosition": [
+      3.450571415504429
+    ],
+    "targetVelocity": [
+      3.3025284804867345
+    ],
+    "targetAcceleration": [
+      -1.989879292405881
+    ],
+    "maxVelocity": [
+      5.324725177002656
+    ],
+    "maxAcceleration": [
+      9.826051357211231
+    ],
+    "maxJerk": [
+      16.247668874227507
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.339136354388433
+    ],
+    "currentVelocity": [
+      -3.4191027804889087
+    ],
+    "currentAcceleration": [
+      0.014982672142765274
+    ],
+    "targetPosition": [
+      -2.6796086881633503
+    ],
+    "targetVelocity": [
+      1.7971551474485583
+    ],
+    "targetAcceleration": [
+      -0.7102343358560708
+    ],
+    "maxVelocity": [
+      4.054436349634485
+    ],
+    "maxAcceleration": [
+      6.899195086886973
+    ],
+    "maxJerk": [
+      13.034558807620318
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.937446747601994
+    ],
+    "currentVelocity": [
+      0.8786926640110133
+    ],
+    "currentAcceleration": [
+      -4.0493347956084635
+    ],
+    "targetPosition": [
+      -7.898112214358903
+    ],
+    "targetVelocity": [
+      2.802885091142593
+    ],
+    "targetAcceleration": [
+      -0.9046184134134023
+    ],
+    "maxVelocity": [
+      4.626233227598027
+    ],
+    "maxAcceleration": [
+      7.890964159932825
+    ],
+    "maxJerk": [
+      12.303808655542118
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.293982135194739
+    ],
+    "currentVelocity": [
+      -1.7706185962172243
+    ],
+    "currentAcceleration": [
+      1.4039834362232875
+    ],
+    "targetPosition": [
+      -6.1492301855819065
+    ],
+    "targetVelocity": [
+      -1.8088807929929729
+    ],
+    "targetAcceleration": [
+      -1.521722043360004
+    ],
+    "maxVelocity": [
+      2.244124970261229
+    ],
+    "maxAcceleration": [
+      3.6176513445396394
+    ],
+    "maxJerk": [
+      18.52231351064917
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.22848275441196
+    ],
+    "currentVelocity": [
+      -1.0087517052861443
+    ],
+    "currentAcceleration": [
+      0.10004635832058373
+    ],
+    "targetPosition": [
+      4.646844342370597
+    ],
+    "targetVelocity": [
+      -2.2479378582567655
+    ],
+    "targetAcceleration": [
+      -1.7002269426900947
+    ],
+    "maxVelocity": [
+      3.7655522342567607
+    ],
+    "maxAcceleration": [
+      5.186743361239062
+    ],
+    "maxJerk": [
+      7.123063153933865
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.9607646063106614
+    ],
+    "currentVelocity": [
+      0.9733806422408202
+    ],
+    "currentAcceleration": [
+      8.50359658521263
+    ],
+    "targetPosition": [
+      -4.413223489697618
+    ],
+    "targetVelocity": [
+      -0.010070910543182876
+    ],
+    "targetAcceleration": [
+      -3.3763646987868725
+    ],
+    "maxVelocity": [
+      5.451496107694455
+    ],
+    "maxAcceleration": [
+      9.839093599616362
+    ],
+    "maxJerk": [
+      8.94856769524017
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.994869270994357
+    ],
+    "currentVelocity": [
+      -3.330965810953876
+    ],
+    "currentAcceleration": [
+      -0.06639447317124425
+    ],
+    "targetPosition": [
+      -4.737087473060393
+    ],
+    "targetVelocity": [
+      -1.6988924423308456
+    ],
+    "targetAcceleration": [
+      -1.6974868274685169
+    ],
+    "maxVelocity": [
+      6.112560907645548
+    ],
+    "maxAcceleration": [
+      4.7826201872449285
+    ],
+    "maxJerk": [
+      16.900977582175962
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.724969661181608
+    ],
+    "currentVelocity": [
+      -0.9112552965053649
+    ],
+    "currentAcceleration": [
+      -2.7070834163541253
+    ],
+    "targetPosition": [
+      -6.611047250635482
+    ],
+    "targetVelocity": [
+      -0.6073952812582335
+    ],
+    "targetAcceleration": [
+      1.5857288850164148
+    ],
+    "maxVelocity": [
+      3.1473036338726943
+    ],
+    "maxAcceleration": [
+      3.795773166129712
+    ],
+    "maxJerk": [
+      14.081285731479946
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.5236976599953671
+    ],
+    "currentVelocity": [
+      -2.5137738208680647
+    ],
+    "currentAcceleration": [
+      2.2957309546468747
+    ],
+    "targetPosition": [
+      -3.373911105234222
+    ],
+    "targetVelocity": [
+      1.345774073183276
+    ],
+    "targetAcceleration": [
+      1.713381641901624
+    ],
+    "maxVelocity": [
+      4.299309188557761
+    ],
+    "maxAcceleration": [
+      3.206320762457914
+    ],
+    "maxJerk": [
+      15.255443242206502
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.8635218196180556
+    ],
+    "currentVelocity": [
+      -0.36470733668227484
+    ],
+    "currentAcceleration": [
+      0.27651411769662637
+    ],
+    "targetPosition": [
+      -9.748755804511646
+    ],
+    "targetVelocity": [
+      -0.8625339593007126
+    ],
+    "targetAcceleration": [
+      3.62912721568574
+    ],
+    "maxVelocity": [
+      2.050504490332232
+    ],
+    "maxAcceleration": [
+      5.40197069429529
+    ],
+    "maxJerk": [
+      14.808378124356814
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.996071734768595
+    ],
+    "currentVelocity": [
+      -2.4391376188575933
+    ],
+    "currentAcceleration": [
+      -3.392400751034759
+    ],
+    "targetPosition": [
+      7.300746872029503
+    ],
+    "targetVelocity": [
+      -5.065438321272154
+    ],
+    "targetAcceleration": [
+      -5.362242019863569
+    ],
+    "maxVelocity": [
+      7.9310564055085075
+    ],
+    "maxAcceleration": [
+      9.159908665801936
+    ],
+    "maxJerk": [
+      18.018953825393947
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.288235189477069
+    ],
+    "currentVelocity": [
+      1.5074734059268162
+    ],
+    "currentAcceleration": [
+      -0.3349086408815758
+    ],
+    "targetPosition": [
+      9.636207062367532
+    ],
+    "targetVelocity": [
+      -3.483531502805617
+    ],
+    "targetAcceleration": [
+      -4.50700509661931
+    ],
+    "maxVelocity": [
+      3.843647975059246
+    ],
+    "maxAcceleration": [
+      9.64264016264914
+    ],
+    "maxJerk": [
+      11.77699771274032
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.800927666353913
+    ],
+    "currentVelocity": [
+      -3.477592249979804
+    ],
+    "currentAcceleration": [
+      -4.562074336012875
+    ],
+    "targetPosition": [
+      1.5689440466879496
+    ],
+    "targetVelocity": [
+      -2.4445327178237832
+    ],
+    "targetAcceleration": [
+      -0.10402561474870531
+    ],
+    "maxVelocity": [
+      6.273966793920986
+    ],
+    "maxAcceleration": [
+      5.512280359397567
+    ],
+    "maxJerk": [
+      11.44659472128303
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.376361974793161
+    ],
+    "currentVelocity": [
+      1.420363514571978
+    ],
+    "currentAcceleration": [
+      2.9985894256081025
+    ],
+    "targetPosition": [
+      -3.2428925960994137
+    ],
+    "targetVelocity": [
+      1.536550702747931
+    ],
+    "targetAcceleration": [
+      1.23791538699205
+    ],
+    "maxVelocity": [
+      4.470012311128027
+    ],
+    "maxAcceleration": [
+      9.511422627107473
+    ],
+    "maxJerk": [
+      6.742841534159803
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.6643741323378833
+    ],
+    "currentVelocity": [
+      -3.0542337136788094
+    ],
+    "currentAcceleration": [
+      -4.853341347441253
+    ],
+    "targetPosition": [
+      -8.471191123240189
+    ],
+    "targetVelocity": [
+      1.052524885153968
+    ],
+    "targetAcceleration": [
+      -4.133020636553736
+    ],
+    "maxVelocity": [
+      4.417861615018507
+    ],
+    "maxAcceleration": [
+      7.600571439325988
+    ],
+    "maxJerk": [
+      16.561542620900703
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.6256874674767374
+    ],
+    "currentVelocity": [
+      0.7266512471812332
+    ],
+    "currentAcceleration": [
+      3.2947551603330583
+    ],
+    "targetPosition": [
+      8.858061369195205
+    ],
+    "targetVelocity": [
+      0.2820300114702299
+    ],
+    "targetAcceleration": [
+      2.11808620349682
+    ],
+    "maxVelocity": [
+      2.5900135125257258
+    ],
+    "maxAcceleration": [
+      7.274054136623417
+    ],
+    "maxJerk": [
+      13.26901636041216
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.4444981893076445
+    ],
+    "currentVelocity": [
+      -4.133871139871626
+    ],
+    "currentAcceleration": [
+      -0.9301318553110818
+    ],
+    "targetPosition": [
+      0.7616832137032503
+    ],
+    "targetVelocity": [
+      -4.2530083376914005
+    ],
+    "targetAcceleration": [
+      -4.535941550434484
+    ],
+    "maxVelocity": [
+      5.056790450774749
+    ],
+    "maxAcceleration": [
+      7.866491930612108
+    ],
+    "maxJerk": [
+      17.788366985719527
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.964171812660547
+    ],
+    "currentVelocity": [
+      1.8033643323831283
+    ],
+    "currentAcceleration": [
+      1.1337163896416893
+    ],
+    "targetPosition": [
+      -1.264803881916631
+    ],
+    "targetVelocity": [
+      -1.3113832292600223
+    ],
+    "targetAcceleration": [
+      2.784910212031024
+    ],
+    "maxVelocity": [
+      3.8893298176354865
+    ],
+    "maxAcceleration": [
+      7.1142655760568605
+    ],
+    "maxJerk": [
+      11.304857350867339
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.174636637864414
+    ],
+    "currentVelocity": [
+      -3.878055274884557
+    ],
+    "currentAcceleration": [
+      0.18000084705784447
+    ],
+    "targetPosition": [
+      -1.0915900771622074
+    ],
+    "targetVelocity": [
+      7.278616403318549
+    ],
+    "targetAcceleration": [
+      1.431149312036602
+    ],
+    "maxVelocity": [
+      7.699590926522945
+    ],
+    "maxAcceleration": [
+      3.357294156565008
+    ],
+    "maxJerk": [
+      14.926787336207816
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.569251762726886
+    ],
+    "currentVelocity": [
+      -5.16540291338049
+    ],
+    "currentAcceleration": [
+      3.2049332920390494
+    ],
+    "targetPosition": [
+      8.102665675871915
+    ],
+    "targetVelocity": [
+      -4.677615152098596
+    ],
+    "targetAcceleration": [
+      -5.611168083734771
+    ],
+    "maxVelocity": [
+      5.939573655173624
+    ],
+    "maxAcceleration": [
+      5.860725935464195
+    ],
+    "maxJerk": [
+      17.906572894163727
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.045622093382018
+    ],
+    "currentVelocity": [
+      -1.1949667967479973
+    ],
+    "currentAcceleration": [
+      -0.06774379589471291
+    ],
+    "targetPosition": [
+      4.612302028744351
+    ],
+    "targetVelocity": [
+      0.19006466645015685
+    ],
+    "targetAcceleration": [
+      -1.4971189894564612
+    ],
+    "maxVelocity": [
+      4.64888840724986
+    ],
+    "maxAcceleration": [
+      3.973110846445198
+    ],
+    "maxJerk": [
+      18.24094304771208
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.707852808789905
+    ],
+    "currentVelocity": [
+      5.058612497706106
+    ],
+    "currentAcceleration": [
+      -2.305524413569189
+    ],
+    "targetPosition": [
+      1.454040736088162
+    ],
+    "targetVelocity": [
+      4.344013923793385
+    ],
+    "targetAcceleration": [
+      -0.22996371403625826
+    ],
+    "maxVelocity": [
+      5.449728026163987
+    ],
+    "maxAcceleration": [
+      3.51268200634774
+    ],
+    "maxJerk": [
+      17.758708564210494
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.463677939253128
+    ],
+    "currentVelocity": [
+      -6.143304579695585
+    ],
+    "currentAcceleration": [
+      6.038882467287324
+    ],
+    "targetPosition": [
+      -3.5109320330510707
+    ],
+    "targetVelocity": [
+      1.9129379303104663
+    ],
+    "targetAcceleration": [
+      6.586959207444205
+    ],
+    "maxVelocity": [
+      6.631493556943489
+    ],
+    "maxAcceleration": [
+      7.518034906335699
+    ],
+    "maxJerk": [
+      17.58724952610826
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.5133002907905
+    ],
+    "currentVelocity": [
+      1.684741340746414
+    ],
+    "currentAcceleration": [
+      -1.3958595593655767
+    ],
+    "targetPosition": [
+      4.628060072986159
+    ],
+    "targetVelocity": [
+      1.1409564294348233
+    ],
+    "targetAcceleration": [
+      -3.9207756367963964
+    ],
+    "maxVelocity": [
+      2.2685193644302464
+    ],
+    "maxAcceleration": [
+      4.993027855510992
+    ],
+    "maxJerk": [
+      13.171620613212076
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.0511011365828224
+    ],
+    "currentVelocity": [
+      0.12154236482658476
+    ],
+    "currentAcceleration": [
+      1.3748895091413065
+    ],
+    "targetPosition": [
+      -0.44053987217915846
+    ],
+    "targetVelocity": [
+      -2.0885092911310865
+    ],
+    "targetAcceleration": [
+      5.844027988766614
+    ],
+    "maxVelocity": [
+      7.151460739089387
+    ],
+    "maxAcceleration": [
+      6.350528735412318
+    ],
+    "maxJerk": [
+      8.509386935836726
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.409759247294872
+    ],
+    "currentVelocity": [
+      2.114059270509399
+    ],
+    "currentAcceleration": [
+      0.42718006355147864
+    ],
+    "targetPosition": [
+      -9.0873192460179
+    ],
+    "targetVelocity": [
+      1.2160336215709568
+    ],
+    "targetAcceleration": [
+      -0.5520998739810188
+    ],
+    "maxVelocity": [
+      4.889484391568334
+    ],
+    "maxAcceleration": [
+      4.129061497378022
+    ],
+    "maxJerk": [
+      15.753141522250877
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.8518434642831316
+    ],
+    "currentVelocity": [
+      -4.770678468268409
+    ],
+    "currentAcceleration": [
+      -1.9881210367500248
+    ],
+    "targetPosition": [
+      -2.008120506946529
+    ],
+    "targetVelocity": [
+      -0.8438956922590766
+    ],
+    "targetAcceleration": [
+      -2.785524087797523
+    ],
+    "maxVelocity": [
+      5.663410584713085
+    ],
+    "maxAcceleration": [
+      3.9069759886018827
+    ],
+    "maxJerk": [
+      15.402903584400345
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.0107696554859977
+    ],
+    "currentVelocity": [
+      4.059275514663953
+    ],
+    "currentAcceleration": [
+      0.4199158599816517
+    ],
+    "targetPosition": [
+      9.702986805445086
+    ],
+    "targetVelocity": [
+      2.84561160961698
+    ],
+    "targetAcceleration": [
+      -1.7564158045458873
+    ],
+    "maxVelocity": [
+      5.552451379220158
+    ],
+    "maxAcceleration": [
+      6.8474002065943775
+    ],
+    "maxJerk": [
+      10.946365990504145
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.492198436823582
+    ],
+    "currentVelocity": [
+      -3.383017249078851
+    ],
+    "currentAcceleration": [
+      1.982773723409104
+    ],
+    "targetPosition": [
+      7.350207999777886
+    ],
+    "targetVelocity": [
+      1.6181886505906622
+    ],
+    "targetAcceleration": [
+      -3.4339230047727285
+    ],
+    "maxVelocity": [
+      3.5888378239754104
+    ],
+    "maxAcceleration": [
+      4.723615668869685
+    ],
+    "maxJerk": [
+      17.834138169073853
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.857258973259949
+    ],
+    "currentVelocity": [
+      -6.904437463724561
+    ],
+    "currentAcceleration": [
+      -4.628660243957492
+    ],
+    "targetPosition": [
+      -6.920827289470168
+    ],
+    "targetVelocity": [
+      4.276497344150066
+    ],
+    "targetAcceleration": [
+      -2.1651240424665303
+    ],
+    "maxVelocity": [
+      7.7884579351356
+    ],
+    "maxAcceleration": [
+      7.992518403351884
+    ],
+    "maxJerk": [
+      12.962512238310598
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.452701058202448
+    ],
+    "currentVelocity": [
+      0.8322876280613993
+    ],
+    "currentAcceleration": [
+      -3.1122028381844586
+    ],
+    "targetPosition": [
+      7.358137718643295
+    ],
+    "targetVelocity": [
+      -3.410496015317414
+    ],
+    "targetAcceleration": [
+      4.901482757267641
+    ],
+    "maxVelocity": [
+      6.636495625258696
+    ],
+    "maxAcceleration": [
+      7.510966807065896
+    ],
+    "maxJerk": [
+      10.815505863551197
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.815628901439052
+    ],
+    "currentVelocity": [
+      2.3464093280914096
+    ],
+    "currentAcceleration": [
+      -4.840507842392476
+    ],
+    "targetPosition": [
+      -5.48650021371113
+    ],
+    "targetVelocity": [
+      1.6841440007140482
+    ],
+    "targetAcceleration": [
+      -1.1467286891543482
+    ],
+    "maxVelocity": [
+      3.380912217358844
+    ],
+    "maxAcceleration": [
+      8.004532847612964
+    ],
+    "maxJerk": [
+      10.971089347289738
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.435415753466533
+    ],
+    "currentVelocity": [
+      2.0691443690263585
+    ],
+    "currentAcceleration": [
+      5.848067601695157
+    ],
+    "targetPosition": [
+      2.62958185174484
+    ],
+    "targetVelocity": [
+      4.644875221271053
+    ],
+    "targetAcceleration": [
+      -4.725609093871728
+    ],
+    "maxVelocity": [
+      7.55062599955665
+    ],
+    "maxAcceleration": [
+      6.736670322636031
+    ],
+    "maxJerk": [
+      7.235850007871131
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.4407955512581019
+    ],
+    "currentVelocity": [
+      1.6044291491241607
+    ],
+    "currentAcceleration": [
+      -3.0996840027399624
+    ],
+    "targetPosition": [
+      6.795836596239447
+    ],
+    "targetVelocity": [
+      -0.7452049350090486
+    ],
+    "targetAcceleration": [
+      1.0469358998875031
+    ],
+    "maxVelocity": [
+      3.1256887780133287
+    ],
+    "maxAcceleration": [
+      3.1334319567835682
+    ],
+    "maxJerk": [
+      9.615870613049474
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.54474690904215
+    ],
+    "currentVelocity": [
+      -1.8856592934758538
+    ],
+    "currentAcceleration": [
+      5.778547399108309
+    ],
+    "targetPosition": [
+      8.153505676181542
+    ],
+    "targetVelocity": [
+      -2.6400179833266737
+    ],
+    "targetAcceleration": [
+      -8.384754611175028
+    ],
+    "maxVelocity": [
+      7.766171551482759
+    ],
+    "maxAcceleration": [
+      9.205937570316106
+    ],
+    "maxJerk": [
+      11.80769216172561
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.748362651924372
+    ],
+    "currentVelocity": [
+      -1.8766801825719681
+    ],
+    "currentAcceleration": [
+      2.2574800007661766
+    ],
+    "targetPosition": [
+      -2.394052929738802
+    ],
+    "targetVelocity": [
+      -0.2277472154234017
+    ],
+    "targetAcceleration": [
+      0.48675467294654506
+    ],
+    "maxVelocity": [
+      2.808234814739261
+    ],
+    "maxAcceleration": [
+      4.1339580976959365
+    ],
+    "maxJerk": [
+      12.347969564574289
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.20763280801322
+    ],
+    "currentVelocity": [
+      -3.6993711223447185
+    ],
+    "currentAcceleration": [
+      -6.7475652739654155
+    ],
+    "targetPosition": [
+      6.999795328041031
+    ],
+    "targetVelocity": [
+      1.7910991113549235
+    ],
+    "targetAcceleration": [
+      -0.3414797594199621
+    ],
+    "maxVelocity": [
+      5.500003875608859
+    ],
+    "maxAcceleration": [
+      7.064931297786413
+    ],
+    "maxJerk": [
+      12.92919356195257
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.139828211695141
+    ],
+    "currentVelocity": [
+      -3.732061492914231
+    ],
+    "currentAcceleration": [
+      3.0107806008838445
+    ],
+    "targetPosition": [
+      7.786190733864903
+    ],
+    "targetVelocity": [
+      5.5115499481813295
+    ],
+    "targetAcceleration": [
+      -6.041211056330624
+    ],
+    "maxVelocity": [
+      6.695656995992865
+    ],
+    "maxAcceleration": [
+      8.846125254627308
+    ],
+    "maxJerk": [
+      18.787210258919004
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.7884751102431435
+    ],
+    "currentVelocity": [
+      -1.6042177005563216
+    ],
+    "currentAcceleration": [
+      0.9765063954562958
+    ],
+    "targetPosition": [
+      -6.819853275428567
+    ],
+    "targetVelocity": [
+      1.8881312833559596
+    ],
+    "targetAcceleration": [
+      0.7596592918608147
+    ],
+    "maxVelocity": [
+      2.9558645010430036
+    ],
+    "maxAcceleration": [
+      5.822948258121386
+    ],
+    "maxJerk": [
+      12.893613126025354
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.314638247080707
+    ],
+    "currentVelocity": [
+      -2.785981188275328
+    ],
+    "currentAcceleration": [
+      3.505149872319617
+    ],
+    "targetPosition": [
+      5.835661339743687
+    ],
+    "targetVelocity": [
+      -0.45284208409156923
+    ],
+    "targetAcceleration": [
+      -3.733541283735099
+    ],
+    "maxVelocity": [
+      3.820046509829586
+    ],
+    "maxAcceleration": [
+      4.5195953389351615
+    ],
+    "maxJerk": [
+      12.584996670438855
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.387405376967434
+    ],
+    "currentVelocity": [
+      -2.2000781679652297
+    ],
+    "currentAcceleration": [
+      -4.504333844922691
+    ],
+    "targetPosition": [
+      -1.4323323228665608
+    ],
+    "targetVelocity": [
+      2.220008674938521
+    ],
+    "targetAcceleration": [
+      7.364164456173061
+    ],
+    "maxVelocity": [
+      6.201594692105816
+    ],
+    "maxAcceleration": [
+      9.4239533968201
+    ],
+    "maxJerk": [
+      12.485368152727702
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.294752579636384
+    ],
+    "currentVelocity": [
+      4.231271674785794
+    ],
+    "currentAcceleration": [
+      -0.1696266157852646
+    ],
+    "targetPosition": [
+      -8.287074134990714
+    ],
+    "targetVelocity": [
+      0.4721186745180761
+    ],
+    "targetAcceleration": [
+      -6.223742570096362
+    ],
+    "maxVelocity": [
+      5.485182536691597
+    ],
+    "maxAcceleration": [
+      6.248091635504291
+    ],
+    "maxJerk": [
+      7.088735923278445
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.192341029821236
+    ],
+    "currentVelocity": [
+      -3.2553222551180743
+    ],
+    "currentAcceleration": [
+      -3.679107067022149
+    ],
+    "targetPosition": [
+      8.273071340883686
+    ],
+    "targetVelocity": [
+      -4.344768678985133
+    ],
+    "targetAcceleration": [
+      2.7574120841059235
+    ],
+    "maxVelocity": [
+      6.137114221577418
+    ],
+    "maxAcceleration": [
+      6.187744085157484
+    ],
+    "maxJerk": [
+      8.010819634348854
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.377379784623354
+    ],
+    "currentVelocity": [
+      6.15860337526273
+    ],
+    "currentAcceleration": [
+      -0.28051030951414724
+    ],
+    "targetPosition": [
+      1.1024610033215012
+    ],
+    "targetVelocity": [
+      -3.6537486299552024
+    ],
+    "targetAcceleration": [
+      -3.8189573733855946
+    ],
+    "maxVelocity": [
+      6.23850738982414
+    ],
+    "maxAcceleration": [
+      5.168752488553106
+    ],
+    "maxJerk": [
+      9.951293837836866
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.791217450097696
+    ],
+    "currentVelocity": [
+      0.6684040654318473
+    ],
+    "currentAcceleration": [
+      -7.229646767117083
+    ],
+    "targetPosition": [
+      1.095386814462767
+    ],
+    "targetVelocity": [
+      -0.6938799914245388
+    ],
+    "targetAcceleration": [
+      -7.670918897656692
+    ],
+    "maxVelocity": [
+      3.689380892199954
+    ],
+    "maxAcceleration": [
+      9.238497381005175
+    ],
+    "maxJerk": [
+      9.883125937470325
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.552411751034196
+    ],
+    "currentVelocity": [
+      0.6949153034525142
+    ],
+    "currentAcceleration": [
+      3.091809128425819
+    ],
+    "targetPosition": [
+      -6.939909977805085
+    ],
+    "targetVelocity": [
+      1.512997627809055
+    ],
+    "targetAcceleration": [
+      -4.14065272800971
+    ],
+    "maxVelocity": [
+      2.4311545331106714
+    ],
+    "maxAcceleration": [
+      5.816944058445262
+    ],
+    "maxJerk": [
+      17.159477872078337
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.236681347451551
+    ],
+    "currentVelocity": [
+      -0.7262198430618894
+    ],
+    "currentAcceleration": [
+      9.04050470359519
+    ],
+    "targetPosition": [
+      -0.799949870561349
+    ],
+    "targetVelocity": [
+      -2.0733404817640126
+    ],
+    "targetAcceleration": [
+      -0.23856709354750372
+    ],
+    "maxVelocity": [
+      2.2811208003608567
+    ],
+    "maxAcceleration": [
+      9.159454779564175
+    ],
+    "maxJerk": [
+      17.274383882351373
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.6370542371517516
+    ],
+    "currentVelocity": [
+      -1.9889505031629762
+    ],
+    "currentAcceleration": [
+      5.64400309751662
+    ],
+    "targetPosition": [
+      6.0845359645451715
+    ],
+    "targetVelocity": [
+      5.503821699953395
+    ],
+    "targetAcceleration": [
+      -2.287272707227215
+    ],
+    "maxVelocity": [
+      6.922206594279988
+    ],
+    "maxAcceleration": [
+      6.902052591193954
+    ],
+    "maxJerk": [
+      10.735626117796883
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.102076296092206
+    ],
+    "currentVelocity": [
+      -2.8980532831612473
+    ],
+    "currentAcceleration": [
+      -6.416645406173599
+    ],
+    "targetPosition": [
+      0.4114858282898055
+    ],
+    "targetVelocity": [
+      2.2754496120870096
+    ],
+    "targetAcceleration": [
+      6.138870439012107
+    ],
+    "maxVelocity": [
+      4.429901399626681
+    ],
+    "maxAcceleration": [
+      8.330252135187315
+    ],
+    "maxJerk": [
+      18.405188023940386
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.2362655331251986
+    ],
+    "currentVelocity": [
+      3.7158212965605104
+    ],
+    "currentAcceleration": [
+      -7.081006337327738
+    ],
+    "targetPosition": [
+      0.14060098219372996
+    ],
+    "targetVelocity": [
+      -1.3414898475777237
+    ],
+    "targetAcceleration": [
+      -2.9291170104851503
+    ],
+    "maxVelocity": [
+      4.270695980711636
+    ],
+    "maxAcceleration": [
+      7.235658429590759
+    ],
+    "maxJerk": [
+      18.208915384033368
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.619450110105854
+    ],
+    "currentVelocity": [
+      -6.573917125819958
+    ],
+    "currentAcceleration": [
+      3.7477213995345284
+    ],
+    "targetPosition": [
+      -9.937161825106337
+    ],
+    "targetVelocity": [
+      3.54388530999055
+    ],
+    "targetAcceleration": [
+      -5.554478120223662
+    ],
+    "maxVelocity": [
+      7.490482933288691
+    ],
+    "maxAcceleration": [
+      6.275059384844486
+    ],
+    "maxJerk": [
+      14.276808060376519
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.05999856909381407
+    ],
+    "currentVelocity": [
+      1.04025018515574
+    ],
+    "currentAcceleration": [
+      -0.18972285358887309
+    ],
+    "targetPosition": [
+      2.2009628515932196
+    ],
+    "targetVelocity": [
+      -1.0956052560881442
+    ],
+    "targetAcceleration": [
+      0.3873014365304446
+    ],
+    "maxVelocity": [
+      2.672688356281883
+    ],
+    "maxAcceleration": [
+      5.436403037597799
+    ],
+    "maxJerk": [
+      11.425586770757693
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.349988022084824
+    ],
+    "currentVelocity": [
+      -2.869209591085025
+    ],
+    "currentAcceleration": [
+      6.80716528115805
+    ],
+    "targetPosition": [
+      8.087321026294717
+    ],
+    "targetVelocity": [
+      1.2688507962890023
+    ],
+    "targetAcceleration": [
+      3.243349062801834
+    ],
+    "maxVelocity": [
+      4.681794913098629
+    ],
+    "maxAcceleration": [
+      7.7133168157424405
+    ],
+    "maxJerk": [
+      8.771183449728754
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.374897535212484
+    ],
+    "currentVelocity": [
+      -1.3514141918943081
+    ],
+    "currentAcceleration": [
+      4.630971777958624
+    ],
+    "targetPosition": [
+      -4.502675529379607
+    ],
+    "targetVelocity": [
+      1.3481951143363888
+    ],
+    "targetAcceleration": [
+      -3.8305351000302386
+    ],
+    "maxVelocity": [
+      5.057266911836639
+    ],
+    "maxAcceleration": [
+      5.832268001525724
+    ],
+    "maxJerk": [
+      9.155784291719645
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.357256273820411
+    ],
+    "currentVelocity": [
+      4.326916566079682
+    ],
+    "currentAcceleration": [
+      -3.2690394402716145
+    ],
+    "targetPosition": [
+      -8.883904972099767
+    ],
+    "targetVelocity": [
+      2.4725842721671594
+    ],
+    "targetAcceleration": [
+      -0.2512458257132981
+    ],
+    "maxVelocity": [
+      5.028040598853334
+    ],
+    "maxAcceleration": [
+      3.9926547306540954
+    ],
+    "maxJerk": [
+      8.077018686276489
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.258266403756708
+    ],
+    "currentVelocity": [
+      -5.122240186813725
+    ],
+    "currentAcceleration": [
+      3.6806584703854988
+    ],
+    "targetPosition": [
+      2.34083097635464
+    ],
+    "targetVelocity": [
+      3.8546034104716593
+    ],
+    "targetAcceleration": [
+      2.6091598119383335
+    ],
+    "maxVelocity": [
+      5.974756444722475
+    ],
+    "maxAcceleration": [
+      4.01264999861761
+    ],
+    "maxJerk": [
+      7.310991242160894
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.029456907604203
+    ],
+    "currentVelocity": [
+      0.020066320676320526
+    ],
+    "currentAcceleration": [
+      -1.322952688124742
+    ],
+    "targetPosition": [
+      8.315809453364466
+    ],
+    "targetVelocity": [
+      -0.9136296237310639
+    ],
+    "targetAcceleration": [
+      -0.019006988869676444
+    ],
+    "maxVelocity": [
+      2.1662170194173824
+    ],
+    "maxAcceleration": [
+      3.199020271771831
+    ],
+    "maxJerk": [
+      19.92482565766754
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7005613455675004
+    ],
+    "currentVelocity": [
+      1.1090665405687896
+    ],
+    "currentAcceleration": [
+      -6.428516920720116
+    ],
+    "targetPosition": [
+      6.3599221564276185
+    ],
+    "targetVelocity": [
+      1.8270175191798974
+    ],
+    "targetAcceleration": [
+      3.539563277586721
+    ],
+    "maxVelocity": [
+      2.7007533408266178
+    ],
+    "maxAcceleration": [
+      6.530940584402487
+    ],
+    "maxJerk": [
+      7.660754370998177
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.3333049441844036
+    ],
+    "currentVelocity": [
+      5.343715372884086
+    ],
+    "currentAcceleration": [
+      0.5695991266248335
+    ],
+    "targetPosition": [
+      3.1934349632186816
+    ],
+    "targetVelocity": [
+      6.156749649232221
+    ],
+    "targetAcceleration": [
+      3.3902943476117287
+    ],
+    "maxVelocity": [
+      7.217612793916249
+    ],
+    "maxAcceleration": [
+      7.749124206061143
+    ],
+    "maxJerk": [
+      14.817961395195603
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.344458617415853
+    ],
+    "currentVelocity": [
+      6.493032156109782
+    ],
+    "currentAcceleration": [
+      1.3870264574746614
+    ],
+    "targetPosition": [
+      0.386276608298882
+    ],
+    "targetVelocity": [
+      -0.6794559952103398
+    ],
+    "targetAcceleration": [
+      -0.6836462803291359
+    ],
+    "maxVelocity": [
+      7.482191732202542
+    ],
+    "maxAcceleration": [
+      4.315966768187428
+    ],
+    "maxJerk": [
+      16.478106931005442
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.822522597763516
+    ],
+    "currentVelocity": [
+      -1.3533914478573812
+    ],
+    "currentAcceleration": [
+      1.2506888649405994
+    ],
+    "targetPosition": [
+      -3.425972886892403
+    ],
+    "targetVelocity": [
+      0.2944973769483923
+    ],
+    "targetAcceleration": [
+      -1.2853176524843115
+    ],
+    "maxVelocity": [
+      2.0779557407091978
+    ],
+    "maxAcceleration": [
+      3.551670845018494
+    ],
+    "maxJerk": [
+      18.699053410429634
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.6363239758368344
+    ],
+    "currentVelocity": [
+      -1.5530293357453848
+    ],
+    "currentAcceleration": [
+      -3.795145013417865
+    ],
+    "targetPosition": [
+      -2.144073246664526
+    ],
+    "targetVelocity": [
+      2.087084577730539
+    ],
+    "targetAcceleration": [
+      -5.187359025350318
+    ],
+    "maxVelocity": [
+      6.719377660644281
+    ],
+    "maxAcceleration": [
+      6.523859930760848
+    ],
+    "maxJerk": [
+      15.350126809465918
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.8879693674908449
+    ],
+    "currentVelocity": [
+      -0.10172230530320991
+    ],
+    "currentAcceleration": [
+      3.5530187044163952
+    ],
+    "targetPosition": [
+      0.42837908429121896
+    ],
+    "targetVelocity": [
+      -0.874075790975672
+    ],
+    "targetAcceleration": [
+      -1.4964097701611152
+    ],
+    "maxVelocity": [
+      5.285004789597668
+    ],
+    "maxAcceleration": [
+      5.637367180998398
+    ],
+    "maxJerk": [
+      5.987455533020754
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.4214310506291365
+    ],
+    "currentVelocity": [
+      3.859768634398682
+    ],
+    "currentAcceleration": [
+      -8.794845816201244
+    ],
+    "targetPosition": [
+      -4.585980621933821
+    ],
+    "targetVelocity": [
+      -5.358930398599921
+    ],
+    "targetAcceleration": [
+      -5.803090325290205
+    ],
+    "maxVelocity": [
+      5.72298388398236
+    ],
+    "maxAcceleration": [
+      9.460502033313212
+    ],
+    "maxJerk": [
+      16.439766563031213
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.833116390978425
+    ],
+    "currentVelocity": [
+      3.3569436370896435
+    ],
+    "currentAcceleration": [
+      -6.643204071376285
+    ],
+    "targetPosition": [
+      2.6204244051421846
+    ],
+    "targetVelocity": [
+      0.2841414175001651
+    ],
+    "targetAcceleration": [
+      2.702684413524868
+    ],
+    "maxVelocity": [
+      3.5191691779737955
+    ],
+    "maxAcceleration": [
+      6.6752272628882094
+    ],
+    "maxJerk": [
+      10.993690714268572
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.7808307639977308
+    ],
+    "currentVelocity": [
+      3.8705232164620504
+    ],
+    "currentAcceleration": [
+      -1.370284360956787
+    ],
+    "targetPosition": [
+      -5.618877656749075
+    ],
+    "targetVelocity": [
+      4.146768891708728
+    ],
+    "targetAcceleration": [
+      -5.705095105499791
+    ],
+    "maxVelocity": [
+      5.730581687720452
+    ],
+    "maxAcceleration": [
+      7.055028079563104
+    ],
+    "maxJerk": [
+      18.51902657684606
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6982596595663715
+    ],
+    "currentVelocity": [
+      4.376127994972306
+    ],
+    "currentAcceleration": [
+      -7.7301105283954215
+    ],
+    "targetPosition": [
+      -4.860051624403814
+    ],
+    "targetVelocity": [
+      5.5712422807535695
+    ],
+    "targetAcceleration": [
+      2.3195144713486684
+    ],
+    "maxVelocity": [
+      5.750247846459006
+    ],
+    "maxAcceleration": [
+      9.606208840909002
+    ],
+    "maxJerk": [
+      5.201879033691941
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.49079117515644555
+    ],
+    "currentVelocity": [
+      -0.15112368141990284
+    ],
+    "currentAcceleration": [
+      -2.3026218447730784
+    ],
+    "targetPosition": [
+      7.883122047213547
+    ],
+    "targetVelocity": [
+      -1.0251322337884572
+    ],
+    "targetAcceleration": [
+      -2.283164200644995
+    ],
+    "maxVelocity": [
+      2.549492621907495
+    ],
+    "maxAcceleration": [
+      3.642659500971392
+    ],
+    "maxJerk": [
+      17.61825207282196
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.931833758303252
+    ],
+    "currentVelocity": [
+      1.2203199038316646
+    ],
+    "currentAcceleration": [
+      -6.181525109230956
+    ],
+    "targetPosition": [
+      8.244905721024448
+    ],
+    "targetVelocity": [
+      1.715188537864936
+    ],
+    "targetAcceleration": [
+      1.763124253763399
+    ],
+    "maxVelocity": [
+      3.7734686630107195
+    ],
+    "maxAcceleration": [
+      8.431513122919569
+    ],
+    "maxJerk": [
+      18.949552028948272
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.4582491075177995
+    ],
+    "currentVelocity": [
+      0.016374171750450195
+    ],
+    "currentAcceleration": [
+      -7.0515755292504485
+    ],
+    "targetPosition": [
+      -4.519440762410145
+    ],
+    "targetVelocity": [
+      1.2905831506929424
+    ],
+    "targetAcceleration": [
+      7.098684275587008
+    ],
+    "maxVelocity": [
+      2.558598231117708
+    ],
+    "maxAcceleration": [
+      7.452436678378129
+    ],
+    "maxJerk": [
+      12.319287273520779
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7679199562498997
+    ],
+    "currentVelocity": [
+      2.0049507527881483
+    ],
+    "currentAcceleration": [
+      -6.58851924014378
+    ],
+    "targetPosition": [
+      6.188211810693737
+    ],
+    "targetVelocity": [
+      1.3878645068359985
+    ],
+    "targetAcceleration": [
+      6.996514483447363
+    ],
+    "maxVelocity": [
+      3.089053401491027
+    ],
+    "maxAcceleration": [
+      9.100167345616736
+    ],
+    "maxJerk": [
+      5.94376505211987
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.631338031076016
+    ],
+    "currentVelocity": [
+      -0.27231502288263876
+    ],
+    "currentAcceleration": [
+      -0.24830399977881434
+    ],
+    "targetPosition": [
+      -6.292899817041615
+    ],
+    "targetVelocity": [
+      -4.71101603649672
+    ],
+    "targetAcceleration": [
+      -4.2300223440698375
+    ],
+    "maxVelocity": [
+      6.610928388145485
+    ],
+    "maxAcceleration": [
+      7.187893646384436
+    ],
+    "maxJerk": [
+      6.838749351969844
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.157200547794775
+    ],
+    "currentVelocity": [
+      -4.12346071881055
+    ],
+    "currentAcceleration": [
+      -1.9072757973244192
+    ],
+    "targetPosition": [
+      2.7754419951638276
+    ],
+    "targetVelocity": [
+      0.8884745983098785
+    ],
+    "targetAcceleration": [
+      5.174723710533685
+    ],
+    "maxVelocity": [
+      6.07015129687273
+    ],
+    "maxAcceleration": [
+      6.500586721294685
+    ],
+    "maxJerk": [
+      10.872680185426187
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.41856943910368827
+    ],
+    "currentVelocity": [
+      0.2858184275791733
+    ],
+    "currentAcceleration": [
+      3.0771478294645966
+    ],
+    "targetPosition": [
+      1.4150205066433141
+    ],
+    "targetVelocity": [
+      -0.0019342645371538403
+    ],
+    "targetAcceleration": [
+      -0.1711034239524416
+    ],
+    "maxVelocity": [
+      3.6982532067698988
+    ],
+    "maxAcceleration": [
+      8.990228839393552
+    ],
+    "maxJerk": [
+      10.034585638153022
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.466484258822458
+    ],
+    "currentVelocity": [
+      -4.546926512635971
+    ],
+    "currentAcceleration": [
+      8.988941976515251
+    ],
+    "targetPosition": [
+      -3.6527449014926887
+    ],
+    "targetVelocity": [
+      -3.112810626635774
+    ],
+    "targetAcceleration": [
+      1.0220308681296846
+    ],
+    "maxVelocity": [
+      5.543019700620506
+    ],
+    "maxAcceleration": [
+      9.361643149652027
+    ],
+    "maxJerk": [
+      19.42374411013133
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.970133902866072
+    ],
+    "currentVelocity": [
+      1.0139610291368109
+    ],
+    "currentAcceleration": [
+      -1.973100656640619
+    ],
+    "targetPosition": [
+      -6.9124303974045205
+    ],
+    "targetVelocity": [
+      0.75824730190695
+    ],
+    "targetAcceleration": [
+      -1.8253855773303382
+    ],
+    "maxVelocity": [
+      2.4200164505179274
+    ],
+    "maxAcceleration": [
+      3.115406215050892
+    ],
+    "maxJerk": [
+      14.736754791425454
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.9779580151153588
+    ],
+    "currentVelocity": [
+      -3.17693863120165
+    ],
+    "currentAcceleration": [
+      -0.39342825221779076
+    ],
+    "targetPosition": [
+      -3.27366924911082
+    ],
+    "targetVelocity": [
+      4.744828199248025
+    ],
+    "targetAcceleration": [
+      -1.150867627513521
+    ],
+    "maxVelocity": [
+      5.601291387109156
+    ],
+    "maxAcceleration": [
+      3.2209185361345867
+    ],
+    "maxJerk": [
+      10.45694819496043
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.238725279241043
+    ],
+    "currentVelocity": [
+      -2.799768364305351
+    ],
+    "currentAcceleration": [
+      1.1924651416439254
+    ],
+    "targetPosition": [
+      -5.24002287566717
+    ],
+    "targetVelocity": [
+      0.9081528932611915
+    ],
+    "targetAcceleration": [
+      -1.9002718356675332
+    ],
+    "maxVelocity": [
+      3.2973707382191035
+    ],
+    "maxAcceleration": [
+      3.6398821962330183
+    ],
+    "maxJerk": [
+      17.674606501025536
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.299246639607148
+    ],
+    "currentVelocity": [
+      -2.1719328803687286
+    ],
+    "currentAcceleration": [
+      4.7948962742548495
+    ],
+    "targetPosition": [
+      -2.6777246035093505
+    ],
+    "targetVelocity": [
+      0.7300602292510141
+    ],
+    "targetAcceleration": [
+      4.5940172878709085
+    ],
+    "maxVelocity": [
+      3.086590749714782
+    ],
+    "maxAcceleration": [
+      6.8916098658351
+    ],
+    "maxJerk": [
+      16.761555704247773
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6582824675336703
+    ],
+    "currentVelocity": [
+      1.0637675442971695
+    ],
+    "currentAcceleration": [
+      -5.8897679711491815
+    ],
+    "targetPosition": [
+      -1.5911077118536952
+    ],
+    "targetVelocity": [
+      1.4069524226708268
+    ],
+    "targetAcceleration": [
+      -5.306328799081829
+    ],
+    "maxVelocity": [
+      3.613635166119984
+    ],
+    "maxAcceleration": [
+      5.976707450699641
+    ],
+    "maxJerk": [
+      11.711184282766318
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.3293909129332455
+    ],
+    "currentVelocity": [
+      4.8524037593439795
+    ],
+    "currentAcceleration": [
+      1.256703661881085
+    ],
+    "targetPosition": [
+      -6.402405093843915
+    ],
+    "targetVelocity": [
+      5.241703601601114
+    ],
+    "targetAcceleration": [
+      5.928312798411058
+    ],
+    "maxVelocity": [
+      6.684539092623342
+    ],
+    "maxAcceleration": [
+      6.934357080659753
+    ],
+    "maxJerk": [
+      18.759427595540156
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.254948400933703
+    ],
+    "currentVelocity": [
+      -0.4919331587774547
+    ],
+    "currentAcceleration": [
+      1.494665072599414
+    ],
+    "targetPosition": [
+      -4.411481171185705
+    ],
+    "targetVelocity": [
+      -0.897481247098836
+    ],
+    "targetAcceleration": [
+      -0.48211722857501993
+    ],
+    "maxVelocity": [
+      4.342723760372327
+    ],
+    "maxAcceleration": [
+      3.251147039246069
+    ],
+    "maxJerk": [
+      6.848826366108138
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.05176253058605
+    ],
+    "currentVelocity": [
+      4.5933150520854635
+    ],
+    "currentAcceleration": [
+      3.492163312156131
+    ],
+    "targetPosition": [
+      -6.032420461962904
+    ],
+    "targetVelocity": [
+      -0.9117295879503509
+    ],
+    "targetAcceleration": [
+      4.4287717751894915
+    ],
+    "maxVelocity": [
+      5.347432179860158
+    ],
+    "maxAcceleration": [
+      5.24922250198651
+    ],
+    "maxJerk": [
+      13.156270376246175
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.591671670663949
+    ],
+    "currentVelocity": [
+      5.326667468226235
+    ],
+    "currentAcceleration": [
+      1.429443086704966
+    ],
+    "targetPosition": [
+      0.3489757650694756
+    ],
+    "targetVelocity": [
+      -3.5654586249318276
+    ],
+    "targetAcceleration": [
+      -7.377375673555463
+    ],
+    "maxVelocity": [
+      5.543243353406885
+    ],
+    "maxAcceleration": [
+      8.956100342940204
+    ],
+    "maxJerk": [
+      8.295155754188333
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.2980203729351345
+    ],
+    "currentVelocity": [
+      2.457781364166439
+    ],
+    "currentAcceleration": [
+      1.9878282415954693
+    ],
+    "targetPosition": [
+      6.736242329326817
+    ],
+    "targetVelocity": [
+      -0.595853546084308
+    ],
+    "targetAcceleration": [
+      -3.784431031867092
+    ],
+    "maxVelocity": [
+      3.4113360783039406
+    ],
+    "maxAcceleration": [
+      6.57265893927954
+    ],
+    "maxJerk": [
+      11.239037995921969
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.90250962427818
+    ],
+    "currentVelocity": [
+      0.31035919128233447
+    ],
+    "currentAcceleration": [
+      2.4090412298396053
+    ],
+    "targetPosition": [
+      -9.305784128508911
+    ],
+    "targetVelocity": [
+      1.3089376010024578
+    ],
+    "targetAcceleration": [
+      -2.60833578761114
+    ],
+    "maxVelocity": [
+      3.2942934903776626
+    ],
+    "maxAcceleration": [
+      7.113972387794453
+    ],
+    "maxJerk": [
+      5.520400068705047
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.952581876905466
+    ],
+    "currentVelocity": [
+      -0.5883412369015706
+    ],
+    "currentAcceleration": [
+      -2.076443166574826
+    ],
+    "targetPosition": [
+      -3.7129602029151805
+    ],
+    "targetVelocity": [
+      -1.6010837392701402
+    ],
+    "targetAcceleration": [
+      2.28789091123093
+    ],
+    "maxVelocity": [
+      3.7029554371235296
+    ],
+    "maxAcceleration": [
+      9.713545638923733
+    ],
+    "maxJerk": [
+      7.087546156337526
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.3467788793808744
+    ],
+    "currentVelocity": [
+      -1.4422436615956358
+    ],
+    "currentAcceleration": [
+      0.950103061648234
+    ],
+    "targetPosition": [
+      -7.234833000710321
+    ],
+    "targetVelocity": [
+      -0.6624026845956172
+    ],
+    "targetAcceleration": [
+      0.7107140911869236
+    ],
+    "maxVelocity": [
+      3.139108204186023
+    ],
+    "maxAcceleration": [
+      3.613678746404626
+    ],
+    "maxJerk": [
+      6.315052327350919
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.314741250567732
+    ],
+    "currentVelocity": [
+      4.090085349663361
+    ],
+    "currentAcceleration": [
+      -4.2782967298607515
+    ],
+    "targetPosition": [
+      2.9614104255553286
+    ],
+    "targetVelocity": [
+      -4.040432095182624
+    ],
+    "targetAcceleration": [
+      -0.9475363165761155
+    ],
+    "maxVelocity": [
+      4.332929181550816
+    ],
+    "maxAcceleration": [
+      4.9410450743939
+    ],
+    "maxJerk": [
+      5.821685063535332
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.40807007598885114
+    ],
+    "currentVelocity": [
+      -0.29731726924210555
+    ],
+    "currentAcceleration": [
+      2.16307619270359
+    ],
+    "targetPosition": [
+      4.448127637804973
+    ],
+    "targetVelocity": [
+      0.5698377044963534
+    ],
+    "targetAcceleration": [
+      -5.572834380685377
+    ],
+    "maxVelocity": [
+      4.613958644258687
+    ],
+    "maxAcceleration": [
+      8.082345496810419
+    ],
+    "maxJerk": [
+      18.84519638901661
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.706216924648313
+    ],
+    "currentVelocity": [
+      -0.30378655355383977
+    ],
+    "currentAcceleration": [
+      4.24249197777292
+    ],
+    "targetPosition": [
+      1.047032893717752
+    ],
+    "targetVelocity": [
+      3.2852253004745844
+    ],
+    "targetAcceleration": [
+      1.9831673271455852
+    ],
+    "maxVelocity": [
+      3.489603739957893
+    ],
+    "maxAcceleration": [
+      6.954404150515131
+    ],
+    "maxJerk": [
+      16.593161650405918
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.208372713827588
+    ],
+    "currentVelocity": [
+      2.431210730408491
+    ],
+    "currentAcceleration": [
+      7.431806011328144
+    ],
+    "targetPosition": [
+      3.4147183976892492
+    ],
+    "targetVelocity": [
+      -6.4589703483829
+    ],
+    "targetAcceleration": [
+      3.2176004221076333
+    ],
+    "maxVelocity": [
+      7.620095221117216
+    ],
+    "maxAcceleration": [
+      8.505966617862406
+    ],
+    "maxJerk": [
+      14.484658021663117
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.386557505156205
+    ],
+    "currentVelocity": [
+      2.9516463676010014
+    ],
+    "currentAcceleration": [
+      -8.036831899748076
+    ],
+    "targetPosition": [
+      6.440639091650432
+    ],
+    "targetVelocity": [
+      -1.8315879157860016
+    ],
+    "targetAcceleration": [
+      7.1871830002669554
+    ],
+    "maxVelocity": [
+      7.587000099075973
+    ],
+    "maxAcceleration": [
+      9.180436094216418
+    ],
+    "maxJerk": [
+      17.613317358604352
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.519145286588923
+    ],
+    "currentVelocity": [
+      2.326092381648741
+    ],
+    "currentAcceleration": [
+      -5.034330683368704
+    ],
+    "targetPosition": [
+      -0.4920349326676021
+    ],
+    "targetVelocity": [
+      -5.44017528629062
+    ],
+    "targetAcceleration": [
+      -4.506630851884626
+    ],
+    "maxVelocity": [
+      5.743615870642793
+    ],
+    "maxAcceleration": [
+      7.27023170851212
+    ],
+    "maxJerk": [
+      7.246423586489197
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.387331532950263
+    ],
+    "currentVelocity": [
+      -0.7184949340466042
+    ],
+    "currentAcceleration": [
+      0.09401942571787192
+    ],
+    "targetPosition": [
+      7.322378964862196
+    ],
+    "targetVelocity": [
+      -1.197568940817167
+    ],
+    "targetAcceleration": [
+      4.574806848298181
+    ],
+    "maxVelocity": [
+      2.3549852353062004
+    ],
+    "maxAcceleration": [
+      4.613605059633503
+    ],
+    "maxJerk": [
+      17.02175517497227
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.489153240178036
+    ],
+    "currentVelocity": [
+      4.041392545219772
+    ],
+    "currentAcceleration": [
+      1.183960101327095
+    ],
+    "targetPosition": [
+      9.001695271130497
+    ],
+    "targetVelocity": [
+      3.8780611539899272
+    ],
+    "targetAcceleration": [
+      -0.8262592819227015
+    ],
+    "maxVelocity": [
+      5.202244039662126
+    ],
+    "maxAcceleration": [
+      8.206994685283398
+    ],
+    "maxJerk": [
+      6.944591246925085
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.487532671976261
+    ],
+    "currentVelocity": [
+      1.8784507033227618
+    ],
+    "currentAcceleration": [
+      -1.3780512783269945
+    ],
+    "targetPosition": [
+      -6.323617953909326
+    ],
+    "targetVelocity": [
+      1.7053316229776794
+    ],
+    "targetAcceleration": [
+      -3.2737193316094215
+    ],
+    "maxVelocity": [
+      4.4643842888955465
+    ],
+    "maxAcceleration": [
+      5.37920383608983
+    ],
+    "maxJerk": [
+      8.673718246281485
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.756949593770905
+    ],
+    "currentVelocity": [
+      1.2532254769681188
+    ],
+    "currentAcceleration": [
+      -0.7504684736578442
+    ],
+    "targetPosition": [
+      3.3246688811457865
+    ],
+    "targetVelocity": [
+      -2.177021648507832
+    ],
+    "targetAcceleration": [
+      -3.8933712177462967
+    ],
+    "maxVelocity": [
+      2.3271520461037207
+    ],
+    "maxAcceleration": [
+      8.156500675855595
+    ],
+    "maxJerk": [
+      6.014302478226147
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.3117120704822085
+    ],
+    "currentVelocity": [
+      -4.569291037206287
+    ],
+    "currentAcceleration": [
+      3.896264481302648
+    ],
+    "targetPosition": [
+      9.38265045150574
+    ],
+    "targetVelocity": [
+      0.952921079750694
+    ],
+    "targetAcceleration": [
+      2.191655946136672
+    ],
+    "maxVelocity": [
+      5.151249231960336
+    ],
+    "maxAcceleration": [
+      4.504238663047037
+    ],
+    "maxJerk": [
+      15.441436345303478
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.2901470816382936
+    ],
+    "currentVelocity": [
+      -0.1778700314563384
+    ],
+    "currentAcceleration": [
+      8.320425190976888
+    ],
+    "targetPosition": [
+      9.465304954998569
+    ],
+    "targetVelocity": [
+      4.40745915924041
+    ],
+    "targetAcceleration": [
+      -2.0205798514328963
+    ],
+    "maxVelocity": [
+      6.9436684745370965
+    ],
+    "maxAcceleration": [
+      9.505909488218052
+    ],
+    "maxJerk": [
+      9.848087274887945
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.06475102437237
+    ],
+    "currentVelocity": [
+      -0.9013140083543609
+    ],
+    "currentAcceleration": [
+      0.4313903510886634
+    ],
+    "targetPosition": [
+      -3.8497291682888264
+    ],
+    "targetVelocity": [
+      -3.9267400198597766
+    ],
+    "targetAcceleration": [
+      -1.2890328633702577
+    ],
+    "maxVelocity": [
+      7.9647959967877675
+    ],
+    "maxAcceleration": [
+      7.504696249121661
+    ],
+    "maxJerk": [
+      9.276578870998579
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.163211342869113
+    ],
+    "currentVelocity": [
+      -4.5050414289136445
+    ],
+    "currentAcceleration": [
+      4.3371117544722795
+    ],
+    "targetPosition": [
+      -8.809250862534295
+    ],
+    "targetVelocity": [
+      -3.2863931683405765
+    ],
+    "targetAcceleration": [
+      -5.269928659240038
+    ],
+    "maxVelocity": [
+      6.797648846593393
+    ],
+    "maxAcceleration": [
+      7.751103315915967
+    ],
+    "maxJerk": [
+      9.517711845833166
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.967368097771004
+    ],
+    "currentVelocity": [
+      -0.12040384464290543
+    ],
+    "currentAcceleration": [
+      1.508499107727042
+    ],
+    "targetPosition": [
+      -9.932581801166132
+    ],
+    "targetVelocity": [
+      3.176763653750422
+    ],
+    "targetAcceleration": [
+      -4.718698629536773
+    ],
+    "maxVelocity": [
+      5.957712476329114
+    ],
+    "maxAcceleration": [
+      9.687247198336479
+    ],
+    "maxJerk": [
+      19.695664435552246
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.681490183673358
+    ],
+    "currentVelocity": [
+      -0.7739001303771387
+    ],
+    "currentAcceleration": [
+      -2.2374444536501104
+    ],
+    "targetPosition": [
+      -9.915560648908333
+    ],
+    "targetVelocity": [
+      -1.613336327420524
+    ],
+    "targetAcceleration": [
+      1.8505652793985208
+    ],
+    "maxVelocity": [
+      6.205852857087345
+    ],
+    "maxAcceleration": [
+      4.450686866434201
+    ],
+    "maxJerk": [
+      16.756143466875677
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.2536219062585339
+    ],
+    "currentVelocity": [
+      4.423204013818447
+    ],
+    "currentAcceleration": [
+      3.706728440274956
+    ],
+    "targetPosition": [
+      0.41775511255019104
+    ],
+    "targetVelocity": [
+      2.773716680419419
+    ],
+    "targetAcceleration": [
+      -1.3354788466978724
+    ],
+    "maxVelocity": [
+      5.345174176402427
+    ],
+    "maxAcceleration": [
+      4.961459761690673
+    ],
+    "maxJerk": [
+      14.607252012468454
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.25991237807338763
+    ],
+    "currentVelocity": [
+      1.3083151177196002
+    ],
+    "currentAcceleration": [
+      -7.254999370320129
+    ],
+    "targetPosition": [
+      6.5651300050441925
+    ],
+    "targetVelocity": [
+      1.4689556726903645
+    ],
+    "targetAcceleration": [
+      -4.860260795597822
+    ],
+    "maxVelocity": [
+      3.6033517116426785
+    ],
+    "maxAcceleration": [
+      9.389864268152195
+    ],
+    "maxJerk": [
+      13.916538504631516
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.840432618029633
+    ],
+    "currentVelocity": [
+      -2.5559205664036937
+    ],
+    "currentAcceleration": [
+      -3.3559357038048314
+    ],
+    "targetPosition": [
+      -6.4822778563715255
+    ],
+    "targetVelocity": [
+      -2.536142762044909
+    ],
+    "targetAcceleration": [
+      0.43318440752388643
+    ],
+    "maxVelocity": [
+      4.968248750891055
+    ],
+    "maxAcceleration": [
+      6.882411255929194
+    ],
+    "maxJerk": [
+      12.378331428793457
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.125111607694659
+    ],
+    "currentVelocity": [
+      5.31135505961041
+    ],
+    "currentAcceleration": [
+      -0.540761042368517
+    ],
+    "targetPosition": [
+      -4.811089647842353
+    ],
+    "targetVelocity": [
+      5.072801616902909
+    ],
+    "targetAcceleration": [
+      0.7509366069397081
+    ],
+    "maxVelocity": [
+      7.337112237818491
+    ],
+    "maxAcceleration": [
+      3.5275721986259456
+    ],
+    "maxJerk": [
+      11.19506351834631
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.867626812567089
+    ],
+    "currentVelocity": [
+      -2.1125809369763284
+    ],
+    "currentAcceleration": [
+      1.4768901656441376
+    ],
+    "targetPosition": [
+      -1.619461133076726
+    ],
+    "targetVelocity": [
+      -0.9945897812268525
+    ],
+    "targetAcceleration": [
+      2.0917370658736205
+    ],
+    "maxVelocity": [
+      6.081402652286133
+    ],
+    "maxAcceleration": [
+      3.466147182877407
+    ],
+    "maxJerk": [
+      6.86328177502421
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.345979195124885
+    ],
+    "currentVelocity": [
+      4.138860801685862
+    ],
+    "currentAcceleration": [
+      -8.632630478256122
+    ],
+    "targetPosition": [
+      4.185855946387694
+    ],
+    "targetVelocity": [
+      2.5276592829506015
+    ],
+    "targetAcceleration": [
+      5.326001096222553
+    ],
+    "maxVelocity": [
+      5.6251185275305655
+    ],
+    "maxAcceleration": [
+      9.098371491672335
+    ],
+    "maxJerk": [
+      17.081066320683853
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.5692943052283486
+    ],
+    "currentVelocity": [
+      0.5518403731756858
+    ],
+    "currentAcceleration": [
+      4.1609391261969035
+    ],
+    "targetPosition": [
+      6.991698997509708
+    ],
+    "targetVelocity": [
+      -1.1367856898799777
+    ],
+    "targetAcceleration": [
+      -2.6895265716577548
+    ],
+    "maxVelocity": [
+      2.1726956815924323
+    ],
+    "maxAcceleration": [
+      7.378704130092449
+    ],
+    "maxJerk": [
+      12.709061923627747
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.915912337546664
+    ],
+    "currentVelocity": [
+      1.1060756573210417
+    ],
+    "currentAcceleration": [
+      -3.1879388778808204
+    ],
+    "targetPosition": [
+      7.6303235902595254
+    ],
+    "targetVelocity": [
+      -5.616233239708396
+    ],
+    "targetAcceleration": [
+      -4.0187957146321365
+    ],
+    "maxVelocity": [
+      6.00785035850145
+    ],
+    "maxAcceleration": [
+      4.442537847303778
+    ],
+    "maxJerk": [
+      8.620802883338543
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7686831166380141
+    ],
+    "currentVelocity": [
+      0.8798471526406937
+    ],
+    "currentAcceleration": [
+      1.4189691536468398
+    ],
+    "targetPosition": [
+      -0.4266469274621869
+    ],
+    "targetVelocity": [
+      -3.7658726974204346
+    ],
+    "targetAcceleration": [
+      -0.43263064763293535
+    ],
+    "maxVelocity": [
+      5.432415341739439
+    ],
+    "maxAcceleration": [
+      9.249287711025698
+    ],
+    "maxJerk": [
+      6.432005633736742
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.187317276854491
+    ],
+    "currentVelocity": [
+      -1.6586957469763428
+    ],
+    "currentAcceleration": [
+      6.907190653168781
+    ],
+    "targetPosition": [
+      6.209430986298795
+    ],
+    "targetVelocity": [
+      2.5405031307905004
+    ],
+    "targetAcceleration": [
+      0.8945234924170702
+    ],
+    "maxVelocity": [
+      4.542736944053193
+    ],
+    "maxAcceleration": [
+      7.995346168172958
+    ],
+    "maxJerk": [
+      18.664667684698543
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.847581441139756
+    ],
+    "currentVelocity": [
+      -1.139455700934609
+    ],
+    "currentAcceleration": [
+      5.7831457741463215
+    ],
+    "targetPosition": [
+      -6.653345981937376
+    ],
+    "targetVelocity": [
+      2.003264726692354
+    ],
+    "targetAcceleration": [
+      2.9132792114485397
+    ],
+    "maxVelocity": [
+      5.592247791378865
+    ],
+    "maxAcceleration": [
+      5.984197867808112
+    ],
+    "maxJerk": [
+      13.404810858756937
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.288488986683577
+    ],
+    "currentVelocity": [
+      -5.968828640218207
+    ],
+    "currentAcceleration": [
+      -2.8498171758594006
+    ],
+    "targetPosition": [
+      -3.2732335626076132
+    ],
+    "targetVelocity": [
+      -1.3409079184941577
+    ],
+    "targetAcceleration": [
+      -2.0883427807523676
+    ],
+    "maxVelocity": [
+      7.236544680618898
+    ],
+    "maxAcceleration": [
+      9.219557131767644
+    ],
+    "maxJerk": [
+      6.42353287928156
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.25726060691656905
+    ],
+    "currentVelocity": [
+      0.6275213826158339
+    ],
+    "currentAcceleration": [
+      3.1075484213253626
+    ],
+    "targetPosition": [
+      -2.5087350687208527
+    ],
+    "targetVelocity": [
+      6.3354942494812985
+    ],
+    "targetAcceleration": [
+      -3.2613366802579193
+    ],
+    "maxVelocity": [
+      7.717332811928415
+    ],
+    "maxAcceleration": [
+      6.593504860544068
+    ],
+    "maxJerk": [
+      6.690911887807914
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.6308272260719825
+    ],
+    "currentVelocity": [
+      4.301729943441961
+    ],
+    "currentAcceleration": [
+      4.856813778029809
+    ],
+    "targetPosition": [
+      8.088677834538554
+    ],
+    "targetVelocity": [
+      4.820565858139219
+    ],
+    "targetAcceleration": [
+      4.459778061111442
+    ],
+    "maxVelocity": [
+      6.9180329306280655
+    ],
+    "maxAcceleration": [
+      7.268417470379851
+    ],
+    "maxJerk": [
+      7.804555279280925
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.361782819350355
+    ],
+    "currentVelocity": [
+      1.9134785284043394
+    ],
+    "currentAcceleration": [
+      4.274268878352823
+    ],
+    "targetPosition": [
+      -5.209003745707834
+    ],
+    "targetVelocity": [
+      -5.914676304743932
+    ],
+    "targetAcceleration": [
+      -8.435316374250611
+    ],
+    "maxVelocity": [
+      6.679095463393652
+    ],
+    "maxAcceleration": [
+      9.503349173229854
+    ],
+    "maxJerk": [
+      12.177423641081873
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.10776043727667
+    ],
+    "currentVelocity": [
+      -4.485735397621276
+    ],
+    "currentAcceleration": [
+      -3.793350131271242
+    ],
+    "targetPosition": [
+      0.7913207415057837
+    ],
+    "targetVelocity": [
+      -0.6194362776684716
+    ],
+    "targetAcceleration": [
+      8.024101010532931
+    ],
+    "maxVelocity": [
+      4.94546404079167
+    ],
+    "maxAcceleration": [
+      8.452920425092199
+    ],
+    "maxJerk": [
+      17.212727612564436
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.047211293723832
+    ],
+    "currentVelocity": [
+      -2.7389717560508364
+    ],
+    "currentAcceleration": [
+      0.8050573704480648
+    ],
+    "targetPosition": [
+      4.92259392172258
+    ],
+    "targetVelocity": [
+      1.378485810868602
+    ],
+    "targetAcceleration": [
+      -1.968557663893594
+    ],
+    "maxVelocity": [
+      4.936278347676466
+    ],
+    "maxAcceleration": [
+      5.0833906332028835
+    ],
+    "maxJerk": [
+      5.299810595838011
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.121196924472557
+    ],
+    "currentVelocity": [
+      -3.8763272535452424
+    ],
+    "currentAcceleration": [
+      3.380412309497066
+    ],
+    "targetPosition": [
+      -8.655293950825868
+    ],
+    "targetVelocity": [
+      -2.3144246960368315
+    ],
+    "targetAcceleration": [
+      1.184952289064623
+    ],
+    "maxVelocity": [
+      6.554800043043047
+    ],
+    "maxAcceleration": [
+      4.762812678680239
+    ],
+    "maxJerk": [
+      11.818947760057046
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.097196447751806
+    ],
+    "currentVelocity": [
+      0.7652063571717083
+    ],
+    "currentAcceleration": [
+      -1.1232934087427622
+    ],
+    "targetPosition": [
+      -9.657301049979148
+    ],
+    "targetVelocity": [
+      -5.040113132894423
+    ],
+    "targetAcceleration": [
+      0.3078035718952794
+    ],
+    "maxVelocity": [
+      5.167641229013177
+    ],
+    "maxAcceleration": [
+      3.9669922039324783
+    ],
+    "maxJerk": [
+      9.900991294050602
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.352746208700733
+    ],
+    "currentVelocity": [
+      -1.4112281014598471
+    ],
+    "currentAcceleration": [
+      -4.153149378400304
+    ],
+    "targetPosition": [
+      3.5355676184624905
+    ],
+    "targetVelocity": [
+      -0.08955777135147125
+    ],
+    "targetAcceleration": [
+      0.5654698239640901
+    ],
+    "maxVelocity": [
+      3.542791766782665
+    ],
+    "maxAcceleration": [
+      8.372051634417875
+    ],
+    "maxJerk": [
+      12.705185104512577
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.511990501124712
+    ],
+    "currentVelocity": [
+      -0.001813110294206055
+    ],
+    "currentAcceleration": [
+      1.4377028892379418
+    ],
+    "targetPosition": [
+      8.052842353566206
+    ],
+    "targetVelocity": [
+      -2.7799853735041844
+    ],
+    "targetAcceleration": [
+      -4.476509308613032
+    ],
+    "maxVelocity": [
+      3.6212266286443446
+    ],
+    "maxAcceleration": [
+      6.2873902275958
+    ],
+    "maxJerk": [
+      18.296238175897685
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.223985837374833
+    ],
+    "currentVelocity": [
+      -2.8967948408939086
+    ],
+    "currentAcceleration": [
+      6.660670265063771
+    ],
+    "targetPosition": [
+      5.790424897345703
+    ],
+    "targetVelocity": [
+      -3.1428218523262803
+    ],
+    "targetAcceleration": [
+      -6.266966392275733
+    ],
+    "maxVelocity": [
+      5.892267728566168
+    ],
+    "maxAcceleration": [
+      6.695186158986732
+    ],
+    "maxJerk": [
+      18.13929294401437
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.952037984347728
+    ],
+    "currentVelocity": [
+      1.6841053692218395
+    ],
+    "currentAcceleration": [
+      -7.302934689898976
+    ],
+    "targetPosition": [
+      -4.715976117162914
+    ],
+    "targetVelocity": [
+      3.867194494160538
+    ],
+    "targetAcceleration": [
+      -3.9715532276594
+    ],
+    "maxVelocity": [
+      4.553271439208466
+    ],
+    "maxAcceleration": [
+      7.471352308345121
+    ],
+    "maxJerk": [
+      16.122616438433017
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.400573234378472
+    ],
+    "currentVelocity": [
+      -5.36780977575231
+    ],
+    "currentAcceleration": [
+      0.8827567500322981
+    ],
+    "targetPosition": [
+      -2.3516337224514805
+    ],
+    "targetVelocity": [
+      -3.2648416498578205
+    ],
+    "targetAcceleration": [
+      1.9735476180121685
+    ],
+    "maxVelocity": [
+      6.1652315118663426
+    ],
+    "maxAcceleration": [
+      3.28146020897249
+    ],
+    "maxJerk": [
+      12.17509326959128
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.564886812081292
+    ],
+    "currentVelocity": [
+      -3.055706952713079
+    ],
+    "currentAcceleration": [
+      4.423155628993497
+    ],
+    "targetPosition": [
+      -5.281246143967682
+    ],
+    "targetVelocity": [
+      -3.8154573636718565
+    ],
+    "targetAcceleration": [
+      4.14520305127461
+    ],
+    "maxVelocity": [
+      7.368528602257695
+    ],
+    "maxAcceleration": [
+      6.502139029396446
+    ],
+    "maxJerk": [
+      14.493167936142775
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.820645142424102
+    ],
+    "currentVelocity": [
+      0.6366010821685393
+    ],
+    "currentAcceleration": [
+      -4.9734541758196364
+    ],
+    "targetPosition": [
+      -1.7699714730204015
+    ],
+    "targetVelocity": [
+      -6.846737083345866
+    ],
+    "targetAcceleration": [
+      -4.147429551358954
+    ],
+    "maxVelocity": [
+      7.512737078471229
+    ],
+    "maxAcceleration": [
+      7.112482463378789
+    ],
+    "maxJerk": [
+      16.165736348153672
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.305765538132526
+    ],
+    "currentVelocity": [
+      -4.591281729494709
+    ],
+    "currentAcceleration": [
+      1.7049675873675358
+    ],
+    "targetPosition": [
+      -4.905975038344312
+    ],
+    "targetVelocity": [
+      -1.052159248050204
+    ],
+    "targetAcceleration": [
+      3.9081770315822784
+    ],
+    "maxVelocity": [
+      7.576153556389089
+    ],
+    "maxAcceleration": [
+      8.009655680886528
+    ],
+    "maxJerk": [
+      6.153475183435451
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.818918368513216
+    ],
+    "currentVelocity": [
+      -0.783671499452514
+    ],
+    "currentAcceleration": [
+      -0.9993940083075294
+    ],
+    "targetPosition": [
+      9.99965999014674
+    ],
+    "targetVelocity": [
+      1.8538280585791451
+    ],
+    "targetAcceleration": [
+      -0.47886812894644937
+    ],
+    "maxVelocity": [
+      3.18452425595076
+    ],
+    "maxAcceleration": [
+      5.430456435245991
+    ],
+    "maxJerk": [
+      13.54702275237811
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.2002293475282
+    ],
+    "currentVelocity": [
+      -0.3699586804139985
+    ],
+    "currentAcceleration": [
+      -5.7879844568097765
+    ],
+    "targetPosition": [
+      -2.545046347872111
+    ],
+    "targetVelocity": [
+      -3.424880893261196
+    ],
+    "targetAcceleration": [
+      -1.6285731792777014
+    ],
+    "maxVelocity": [
+      6.267504955989715
+    ],
+    "maxAcceleration": [
+      5.959536745404886
+    ],
+    "maxJerk": [
+      7.973462910872861
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.784387629682069
+    ],
+    "currentVelocity": [
+      -1.8741364470172917
+    ],
+    "currentAcceleration": [
+      -1.5230684306143347
+    ],
+    "targetPosition": [
+      -2.2756891044959193
+    ],
+    "targetVelocity": [
+      -0.8361042633154172
+    ],
+    "targetAcceleration": [
+      -3.3795588678771225
+    ],
+    "maxVelocity": [
+      7.4664414667277965
+    ],
+    "maxAcceleration": [
+      5.934225702089384
+    ],
+    "maxJerk": [
+      12.187631487147634
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.536227368720887
+    ],
+    "currentVelocity": [
+      0.09386959477670942
+    ],
+    "currentAcceleration": [
+      2.6163148011542674
+    ],
+    "targetPosition": [
+      -7.0409159480274734
+    ],
+    "targetVelocity": [
+      -1.882876350626778
+    ],
+    "targetAcceleration": [
+      1.133532335244034
+    ],
+    "maxVelocity": [
+      2.0563400659569098
+    ],
+    "maxAcceleration": [
+      9.676263804127203
+    ],
+    "maxJerk": [
+      5.00546958209046
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.523625976443672
+    ],
+    "currentVelocity": [
+      -1.9344308007623456
+    ],
+    "currentAcceleration": [
+      0.06254491215808855
+    ],
+    "targetPosition": [
+      -4.050851902894664
+    ],
+    "targetVelocity": [
+      1.416530750280364
+    ],
+    "targetAcceleration": [
+      6.007298686395137
+    ],
+    "maxVelocity": [
+      5.261153115071566
+    ],
+    "maxAcceleration": [
+      6.4028216453446944
+    ],
+    "maxJerk": [
+      14.435046020287828
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.625384595938803
+    ],
+    "currentVelocity": [
+      -2.190521555158874
+    ],
+    "currentAcceleration": [
+      -2.4355907472789236
+    ],
+    "targetPosition": [
+      -2.2665565121480302
+    ],
+    "targetVelocity": [
+      -2.1561573925406288
+    ],
+    "targetAcceleration": [
+      5.299209136123759
+    ],
+    "maxVelocity": [
+      3.4271321295239554
+    ],
+    "maxAcceleration": [
+      8.157377367179073
+    ],
+    "maxJerk": [
+      12.332425692322886
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.887581538338651
+    ],
+    "currentVelocity": [
+      0.7024933265051052
+    ],
+    "currentAcceleration": [
+      -6.692622898534389
+    ],
+    "targetPosition": [
+      -8.215503113529303
+    ],
+    "targetVelocity": [
+      -1.6727565827734063
+    ],
+    "targetAcceleration": [
+      1.154641296268303
+    ],
+    "maxVelocity": [
+      2.060540264061155
+    ],
+    "maxAcceleration": [
+      7.499766380583442
+    ],
+    "maxJerk": [
+      12.395143924047897
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.087515011387865
+    ],
+    "currentVelocity": [
+      2.0680437787014014
+    ],
+    "currentAcceleration": [
+      4.249495213790361
+    ],
+    "targetPosition": [
+      -3.7624384379353693
+    ],
+    "targetVelocity": [
+      0.6075825338520424
+    ],
+    "targetAcceleration": [
+      -2.7376008944437666
+    ],
+    "maxVelocity": [
+      3.7622465785237154
+    ],
+    "maxAcceleration": [
+      9.811592448752668
+    ],
+    "maxJerk": [
+      10.112299430591882
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.326572644953361
+    ],
+    "currentVelocity": [
+      3.000512878665619
+    ],
+    "currentAcceleration": [
+      0.8546867905389863
+    ],
+    "targetPosition": [
+      6.503397856095621
+    ],
+    "targetVelocity": [
+      6.573820653668042
+    ],
+    "targetAcceleration": [
+      5.499245178087911
+    ],
+    "maxVelocity": [
+      6.643340298954463
+    ],
+    "maxAcceleration": [
+      8.321619842010367
+    ],
+    "maxJerk": [
+      17.867545033519075
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.738595319269894
+    ],
+    "currentVelocity": [
+      -3.440987971836817
+    ],
+    "currentAcceleration": [
+      7.695643467481894
+    ],
+    "targetPosition": [
+      -6.270966718968609
+    ],
+    "targetVelocity": [
+      0.4652685196174282
+    ],
+    "targetAcceleration": [
+      0.6652304337636696
+    ],
+    "maxVelocity": [
+      4.162021939352568
+    ],
+    "maxAcceleration": [
+      9.552261981261939
+    ],
+    "maxJerk": [
+      15.445244199226288
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.8733900726681796
+    ],
+    "currentVelocity": [
+      -1.139156698307473
+    ],
+    "currentAcceleration": [
+      0.058812331439393795
+    ],
+    "targetPosition": [
+      8.053235979260023
+    ],
+    "targetVelocity": [
+      -2.6700868754595017
+    ],
+    "targetAcceleration": [
+      -0.23696129938599242
+    ],
+    "maxVelocity": [
+      4.956590182639353
+    ],
+    "maxAcceleration": [
+      5.93801063175642
+    ],
+    "maxJerk": [
+      16.255176262251364
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.9030251855869391
+    ],
+    "currentVelocity": [
+      2.1044813647944034
+    ],
+    "currentAcceleration": [
+      1.7679017689687564
+    ],
+    "targetPosition": [
+      4.3786820997390326
+    ],
+    "targetVelocity": [
+      -1.9988850200178514
+    ],
+    "targetAcceleration": [
+      1.427471758925793
+    ],
+    "maxVelocity": [
+      5.0885781776945995
+    ],
+    "maxAcceleration": [
+      7.259083831297802
+    ],
+    "maxJerk": [
+      14.4342423312083
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7261762167616066
+    ],
+    "currentVelocity": [
+      -2.235354639441743
+    ],
+    "currentAcceleration": [
+      -0.920305327434062
+    ],
+    "targetPosition": [
+      8.367764507988479
+    ],
+    "targetVelocity": [
+      3.352792275556375
+    ],
+    "targetAcceleration": [
+      5.066817938860554
+    ],
+    "maxVelocity": [
+      5.83782319391203
+    ],
+    "maxAcceleration": [
+      7.425510041389419
+    ],
+    "maxJerk": [
+      17.54973703198512
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.749748209273982
+    ],
+    "currentVelocity": [
+      2.2604102757754925
+    ],
+    "currentAcceleration": [
+      -0.06264521278369273
+    ],
+    "targetPosition": [
+      7.215360180492368
+    ],
+    "targetVelocity": [
+      0.4885035590359985
+    ],
+    "targetAcceleration": [
+      -3.9700825573609873
+    ],
+    "maxVelocity": [
+      4.13155491150116
+    ],
+    "maxAcceleration": [
+      5.205695313763964
+    ],
+    "maxJerk": [
+      17.909936376906856
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.2068452689025015
+    ],
+    "currentVelocity": [
+      2.183179640794017
+    ],
+    "currentAcceleration": [
+      -3.834550821691666
+    ],
+    "targetPosition": [
+      0.10940563589673324
+    ],
+    "targetVelocity": [
+      2.411602746462166
+    ],
+    "targetAcceleration": [
+      -3.609470237976151
+    ],
+    "maxVelocity": [
+      4.431526794297769
+    ],
+    "maxAcceleration": [
+      6.165186977650808
+    ],
+    "maxJerk": [
+      17.970205056032725
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.158471205467848
+    ],
+    "currentVelocity": [
+      2.5566794218033007
+    ],
+    "currentAcceleration": [
+      -3.3923478195113237
+    ],
+    "targetPosition": [
+      -7.492850007712444
+    ],
+    "targetVelocity": [
+      0.3577344662992017
+    ],
+    "targetAcceleration": [
+      -3.4814280545387595
+    ],
+    "maxVelocity": [
+      7.545250027875417
+    ],
+    "maxAcceleration": [
+      5.963619231912489
+    ],
+    "maxJerk": [
+      13.73230272149713
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.384464683718457
+    ],
+    "currentVelocity": [
+      -3.6347758634005545
+    ],
+    "currentAcceleration": [
+      -0.6514488746741369
+    ],
+    "targetPosition": [
+      -9.134239729246747
+    ],
+    "targetVelocity": [
+      2.068169708331375
+    ],
+    "targetAcceleration": [
+      0.7735180882190029
+    ],
+    "maxVelocity": [
+      7.081945767828319
+    ],
+    "maxAcceleration": [
+      6.095507032974746
+    ],
+    "maxJerk": [
+      12.256914579125288
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.331177366861782
+    ],
+    "currentVelocity": [
+      1.8782006972229617
+    ],
+    "currentAcceleration": [
+      1.6994296112165808
+    ],
+    "targetPosition": [
+      -5.973500864362382
+    ],
+    "targetVelocity": [
+      1.020133021159781
+    ],
+    "targetAcceleration": [
+      3.3892766792070583
+    ],
+    "maxVelocity": [
+      3.1757787259866497
+    ],
+    "maxAcceleration": [
+      7.563835800202113
+    ],
+    "maxJerk": [
+      13.28166111199379
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.760698495940872
+    ],
+    "currentVelocity": [
+      2.7227006526437822
+    ],
+    "currentAcceleration": [
+      -2.302290776142434
+    ],
+    "targetPosition": [
+      -0.8452856739407739
+    ],
+    "targetVelocity": [
+      1.9919993213704634
+    ],
+    "targetAcceleration": [
+      -1.50069475154839
+    ],
+    "maxVelocity": [
+      2.896650679600338
+    ],
+    "maxAcceleration": [
+      3.7009652289848263
+    ],
+    "maxJerk": [
+      6.622444041446123
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.352041899833072
+    ],
+    "currentVelocity": [
+      3.3208039380220153
+    ],
+    "currentAcceleration": [
+      -0.29701532678123366
+    ],
+    "targetPosition": [
+      2.402948168991621
+    ],
+    "targetVelocity": [
+      -4.556466678719206
+    ],
+    "targetAcceleration": [
+      -0.7853951179446614
+    ],
+    "maxVelocity": [
+      7.361340717371389
+    ],
+    "maxAcceleration": [
+      4.1459962092336236
+    ],
+    "maxJerk": [
+      5.856617191082329
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.5540343406622625
+    ],
+    "currentVelocity": [
+      0.6907178966056442
+    ],
+    "currentAcceleration": [
+      -2.479144198666782
+    ],
+    "targetPosition": [
+      9.654671519470998
+    ],
+    "targetVelocity": [
+      -5.120620393367474
+    ],
+    "targetAcceleration": [
+      -2.2039794951573386
+    ],
+    "maxVelocity": [
+      6.366124236165616
+    ],
+    "maxAcceleration": [
+      3.314992114263857
+    ],
+    "maxJerk": [
+      10.699654744146182
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.483000085680412
+    ],
+    "currentVelocity": [
+      -1.0246430362298187
+    ],
+    "currentAcceleration": [
+      4.789368481407401
+    ],
+    "targetPosition": [
+      4.512414131588887
+    ],
+    "targetVelocity": [
+      -1.0624899379525605
+    ],
+    "targetAcceleration": [
+      0.9152818852578006
+    ],
+    "maxVelocity": [
+      2.957380724053243
+    ],
+    "maxAcceleration": [
+      5.015142958627688
+    ],
+    "maxJerk": [
+      18.016651663557226
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.391649458913783
+    ],
+    "currentVelocity": [
+      -3.8027957009872058
+    ],
+    "currentAcceleration": [
+      -1.7403897824289913
+    ],
+    "targetPosition": [
+      -9.90552084881529
+    ],
+    "targetVelocity": [
+      4.696044388265617
+    ],
+    "targetAcceleration": [
+      -1.4078708267872808
+    ],
+    "maxVelocity": [
+      5.306466210992627
+    ],
+    "maxAcceleration": [
+      4.839679483123369
+    ],
+    "maxJerk": [
+      12.468295177217165
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.043997976284291
+    ],
+    "currentVelocity": [
+      4.203102142468347
+    ],
+    "currentAcceleration": [
+      -7.5731564155194935
+    ],
+    "targetPosition": [
+      2.180542931532635
+    ],
+    "targetVelocity": [
+      0.7533451948323551
+    ],
+    "targetAcceleration": [
+      -3.062377290411333
+    ],
+    "maxVelocity": [
+      5.673862750953238
+    ],
+    "maxAcceleration": [
+      7.690790287976114
+    ],
+    "maxJerk": [
+      9.283347918811646
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.847543730595804
+    ],
+    "currentVelocity": [
+      -2.976062089417134
+    ],
+    "currentAcceleration": [
+      4.949311675662969
+    ],
+    "targetPosition": [
+      -6.625467224921426
+    ],
+    "targetVelocity": [
+      -1.3461318361845311
+    ],
+    "targetAcceleration": [
+      6.971211822289257
+    ],
+    "maxVelocity": [
+      3.064580160898874
+    ],
+    "maxAcceleration": [
+      8.19453571479033
+    ],
+    "maxJerk": [
+      19.707223450192934
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.4310582955015221
+    ],
+    "currentVelocity": [
+      3.284067079047986
+    ],
+    "currentAcceleration": [
+      2.5141305307029693
+    ],
+    "targetPosition": [
+      0.8935061168043106
+    ],
+    "targetVelocity": [
+      2.0584496622007546
+    ],
+    "targetAcceleration": [
+      2.8319883027017587
+    ],
+    "maxVelocity": [
+      3.928632195978753
+    ],
+    "maxAcceleration": [
+      4.599143248375768
+    ],
+    "maxJerk": [
+      13.188036860385823
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.311254162001836
+    ],
+    "currentVelocity": [
+      5.153293607024771
+    ],
+    "currentAcceleration": [
+      -2.1821140322810457
+    ],
+    "targetPosition": [
+      -9.880975899300303
+    ],
+    "targetVelocity": [
+      -0.09830419548456604
+    ],
+    "targetAcceleration": [
+      4.058262416177383
+    ],
+    "maxVelocity": [
+      5.254325413418587
+    ],
+    "maxAcceleration": [
+      6.4822019518929075
+    ],
+    "maxJerk": [
+      6.7542349125386165
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.604587425131726
+    ],
+    "currentVelocity": [
+      -3.7039816113370687
+    ],
+    "currentAcceleration": [
+      2.2995747266331374
+    ],
+    "targetPosition": [
+      1.8755451134139953
+    ],
+    "targetVelocity": [
+      2.4444490070333753
+    ],
+    "targetAcceleration": [
+      0.03122783282380137
+    ],
+    "maxVelocity": [
+      7.453997289709186
+    ],
+    "maxAcceleration": [
+      5.779989634255607
+    ],
+    "maxJerk": [
+      12.784279034348891
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.325389471631041
+    ],
+    "currentVelocity": [
+      4.782221664284195
+    ],
+    "currentAcceleration": [
+      1.4501416810839878
+    ],
+    "targetPosition": [
+      1.4107981283239148
+    ],
+    "targetVelocity": [
+      3.3869908566532905
+    ],
+    "targetAcceleration": [
+      7.89831846135117
+    ],
+    "maxVelocity": [
+      5.280532729186157
+    ],
+    "maxAcceleration": [
+      8.536393293756326
+    ],
+    "maxJerk": [
+      8.07140662774362
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.397136060285388
+    ],
+    "currentVelocity": [
+      0.3467960917417816
+    ],
+    "currentAcceleration": [
+      5.15991893734061
+    ],
+    "targetPosition": [
+      4.496826717507057
+    ],
+    "targetVelocity": [
+      -0.9516913509647296
+    ],
+    "targetAcceleration": [
+      5.190999774620822
+    ],
+    "maxVelocity": [
+      5.596241965927254
+    ],
+    "maxAcceleration": [
+      8.182005047259253
+    ],
+    "maxJerk": [
+      7.221753947344809
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.026527677741344
+    ],
+    "currentVelocity": [
+      0.6216799932408623
+    ],
+    "currentAcceleration": [
+      -2.357245459947751
+    ],
+    "targetPosition": [
+      -1.38962461215886
+    ],
+    "targetVelocity": [
+      -1.990975716087342
+    ],
+    "targetAcceleration": [
+      -1.45193828731382
+    ],
+    "maxVelocity": [
+      6.5265916150775976
+    ],
+    "maxAcceleration": [
+      5.691558692853793
+    ],
+    "maxJerk": [
+      9.04343421098344
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.123424215746228
+    ],
+    "currentVelocity": [
+      -1.0537941325455273
+    ],
+    "currentAcceleration": [
+      0.8503398237763982
+    ],
+    "targetPosition": [
+      -4.672118362867823
+    ],
+    "targetVelocity": [
+      0.6589199759517594
+    ],
+    "targetAcceleration": [
+      2.150054859734471
+    ],
+    "maxVelocity": [
+      6.377077365420193
+    ],
+    "maxAcceleration": [
+      5.279945502397174
+    ],
+    "maxJerk": [
+      5.597064203244703
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.195520794749932
+    ],
+    "currentVelocity": [
+      -3.8228778293242534
+    ],
+    "currentAcceleration": [
+      -5.958462048157928
+    ],
+    "targetPosition": [
+      -0.13796410613246657
+    ],
+    "targetVelocity": [
+      0.10377356962116924
+    ],
+    "targetAcceleration": [
+      -0.7000923579166001
+    ],
+    "maxVelocity": [
+      5.518057233525729
+    ],
+    "maxAcceleration": [
+      6.2618643699247
+    ],
+    "maxJerk": [
+      17.619889459711104
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.585142184332426
+    ],
+    "currentVelocity": [
+      -2.1703171709481577
+    ],
+    "currentAcceleration": [
+      -5.228498620910837
+    ],
+    "targetPosition": [
+      -4.198872055506795
+    ],
+    "targetVelocity": [
+      -6.125296296646161
+    ],
+    "targetAcceleration": [
+      -0.1910001404967483
+    ],
+    "maxVelocity": [
+      6.404768917099248
+    ],
+    "maxAcceleration": [
+      6.857373327495544
+    ],
+    "maxJerk": [
+      5.504661825759587
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.775876131501196
+    ],
+    "currentVelocity": [
+      0.7736528026879763
+    ],
+    "currentAcceleration": [
+      4.057872059265326
+    ],
+    "targetPosition": [
+      -0.7970409663525686
+    ],
+    "targetVelocity": [
+      -0.6018925237522199
+    ],
+    "targetAcceleration": [
+      -2.6808393520613203
+    ],
+    "maxVelocity": [
+      2.43144669961444
+    ],
+    "maxAcceleration": [
+      6.196265456055797
+    ],
+    "maxJerk": [
+      7.255213352077127
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.87979234495576
+    ],
+    "currentVelocity": [
+      3.2708767769352827
+    ],
+    "currentAcceleration": [
+      -3.10695582070326
+    ],
+    "targetPosition": [
+      7.081947171982243
+    ],
+    "targetVelocity": [
+      -1.8273555177101068
+    ],
+    "targetAcceleration": [
+      0.6945014717515967
+    ],
+    "maxVelocity": [
+      3.5062840557553088
+    ],
+    "maxAcceleration": [
+      8.59216956441487
+    ],
+    "maxJerk": [
+      6.93556860144439
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.932843457657537
+    ],
+    "currentVelocity": [
+      3.69439514777737
+    ],
+    "currentAcceleration": [
+      -1.0377728615291755
+    ],
+    "targetPosition": [
+      -6.8400700546853965
+    ],
+    "targetVelocity": [
+      -2.236515896532822
+    ],
+    "targetAcceleration": [
+      -6.401779814883357
+    ],
+    "maxVelocity": [
+      5.178535780612202
+    ],
+    "maxAcceleration": [
+      7.407671134532023
+    ],
+    "maxJerk": [
+      18.12048684113738
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.41888623712801376
+    ],
+    "currentVelocity": [
+      5.371191839952913
+    ],
+    "currentAcceleration": [
+      0.9162542501693931
+    ],
+    "targetPosition": [
+      -8.02574686737345
+    ],
+    "targetVelocity": [
+      3.679375183497654
+    ],
+    "targetAcceleration": [
+      -1.315614857930195
+    ],
+    "maxVelocity": [
+      5.476428012730444
+    ],
+    "maxAcceleration": [
+      4.4556438854878015
+    ],
+    "maxJerk": [
+      16.949334450206177
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.813742804815288
+    ],
+    "currentVelocity": [
+      1.0671000802309933
+    ],
+    "currentAcceleration": [
+      4.796476716338687
+    ],
+    "targetPosition": [
+      -9.113944119115324
+    ],
+    "targetVelocity": [
+      -0.06743543740706759
+    ],
+    "targetAcceleration": [
+      -1.3213306922764687
+    ],
+    "maxVelocity": [
+      6.961167945545151
+    ],
+    "maxAcceleration": [
+      7.7979701972791835
+    ],
+    "maxJerk": [
+      14.294444170836861
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.5324084040539265
+    ],
+    "currentVelocity": [
+      -2.0515431675364972
+    ],
+    "currentAcceleration": [
+      0.36759270035655334
+    ],
+    "targetPosition": [
+      1.4310237394394143
+    ],
+    "targetVelocity": [
+      -3.7357536132596256
+    ],
+    "targetAcceleration": [
+      1.6364324159035109
+    ],
+    "maxVelocity": [
+      6.899314556692361
+    ],
+    "maxAcceleration": [
+      5.01435184652612
+    ],
+    "maxJerk": [
+      13.861980702619054
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.252404701219813
+    ],
+    "currentVelocity": [
+      -0.88157117859057
+    ],
+    "currentAcceleration": [
+      -1.157832685931095
+    ],
+    "targetPosition": [
+      1.626411518931313
+    ],
+    "targetVelocity": [
+      -0.9515002184864358
+    ],
+    "targetAcceleration": [
+      5.105449060070126
+    ],
+    "maxVelocity": [
+      2.076059895082103
+    ],
+    "maxAcceleration": [
+      7.732158296566065
+    ],
+    "maxJerk": [
+      13.88016003231795
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.30180912531347
+    ],
+    "currentVelocity": [
+      -5.090679411482351
+    ],
+    "currentAcceleration": [
+      -4.7869573316247775
+    ],
+    "targetPosition": [
+      -2.5236262663095754
+    ],
+    "targetVelocity": [
+      1.0513102088903628
+    ],
+    "targetAcceleration": [
+      6.212941951826062
+    ],
+    "maxVelocity": [
+      6.612710900103732
+    ],
+    "maxAcceleration": [
+      8.807088057975113
+    ],
+    "maxJerk": [
+      17.393449124416605
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.053510174099454
+    ],
+    "currentVelocity": [
+      -1.7521972897620526
+    ],
+    "currentAcceleration": [
+      -5.802311654545523
+    ],
+    "targetPosition": [
+      -6.255162108958521
+    ],
+    "targetVelocity": [
+      0.15181124744330354
+    ],
+    "targetAcceleration": [
+      -6.100003825534419
+    ],
+    "maxVelocity": [
+      3.0623585545107828
+    ],
+    "maxAcceleration": [
+      8.40471078417206
+    ],
+    "maxJerk": [
+      13.863439581713044
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.8568227504513235
+    ],
+    "currentVelocity": [
+      -0.34898657377650366
+    ],
+    "currentAcceleration": [
+      -0.9510597936921776
+    ],
+    "targetPosition": [
+      -0.27923146001228183
+    ],
+    "targetVelocity": [
+      -1.394706760587824
+    ],
+    "targetAcceleration": [
+      -0.9685076666680863
+    ],
+    "maxVelocity": [
+      6.637410639083026
+    ],
+    "maxAcceleration": [
+      4.3609177187426695
+    ],
+    "maxJerk": [
+      19.7624052852021
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.192650129367241
+    ],
+    "currentVelocity": [
+      1.0351109455424536
+    ],
+    "currentAcceleration": [
+      -3.7496191818880127
+    ],
+    "targetPosition": [
+      -2.096961998537921
+    ],
+    "targetVelocity": [
+      -2.9178017540015775
+    ],
+    "targetAcceleration": [
+      -0.3802102214699641
+    ],
+    "maxVelocity": [
+      7.023306910684934
+    ],
+    "maxAcceleration": [
+      7.749206058628144
+    ],
+    "maxJerk": [
+      12.300527853113444
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.4853222003181976
+    ],
+    "currentVelocity": [
+      4.287582144139398
+    ],
+    "currentAcceleration": [
+      2.890834233240624
+    ],
+    "targetPosition": [
+      4.159431836077982
+    ],
+    "targetVelocity": [
+      -3.245476856638255
+    ],
+    "targetAcceleration": [
+      -4.188954827436413
+    ],
+    "maxVelocity": [
+      7.050019176149968
+    ],
+    "maxAcceleration": [
+      7.966390215248457
+    ],
+    "maxJerk": [
+      10.475873053248403
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.3459912141636767
+    ],
+    "currentVelocity": [
+      2.5943689565437786
+    ],
+    "currentAcceleration": [
+      -5.341317569829734
+    ],
+    "targetPosition": [
+      1.837634889280789
+    ],
+    "targetVelocity": [
+      3.262348796728853
+    ],
+    "targetAcceleration": [
+      3.801494505895837
+    ],
+    "maxVelocity": [
+      6.480573980147856
+    ],
+    "maxAcceleration": [
+      7.388523877151499
+    ],
+    "maxJerk": [
+      12.56290852297401
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.8027995187236119
+    ],
+    "currentVelocity": [
+      -0.9477591807362149
+    ],
+    "currentAcceleration": [
+      -5.545474349452963
+    ],
+    "targetPosition": [
+      5.81569663944769
+    ],
+    "targetVelocity": [
+      -0.8052169658791177
+    ],
+    "targetAcceleration": [
+      0.6149200771689749
+    ],
+    "maxVelocity": [
+      4.283911544051186
+    ],
+    "maxAcceleration": [
+      8.27415856945783
+    ],
+    "maxJerk": [
+      9.746723536784087
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.7017014373721029
+    ],
+    "currentVelocity": [
+      2.801895620983343
+    ],
+    "currentAcceleration": [
+      2.804044803979664
+    ],
+    "targetPosition": [
+      6.483510358245745
+    ],
+    "targetVelocity": [
+      -0.24391961484845748
+    ],
+    "targetAcceleration": [
+      -2.571070154459161
+    ],
+    "maxVelocity": [
+      4.326177877727245
+    ],
+    "maxAcceleration": [
+      3.027269108555076
+    ],
+    "maxJerk": [
+      14.274025882892367
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.058527487401417
+    ],
+    "currentVelocity": [
+      0.5079779775756128
+    ],
+    "currentAcceleration": [
+      -4.584863072436794
+    ],
+    "targetPosition": [
+      5.952908176720824
+    ],
+    "targetVelocity": [
+      -1.3245363421780167
+    ],
+    "targetAcceleration": [
+      0.839328963251389
+    ],
+    "maxVelocity": [
+      3.6371338226727303
+    ],
+    "maxAcceleration": [
+      6.221400850565077
+    ],
+    "maxJerk": [
+      13.097380427996233
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.844742036074405
+    ],
+    "currentVelocity": [
+      -3.39840545731231
+    ],
+    "currentAcceleration": [
+      -3.1174435429478446
+    ],
+    "targetPosition": [
+      9.408396990619593
+    ],
+    "targetVelocity": [
+      1.4354570189295677
+    ],
+    "targetAcceleration": [
+      -0.5219367236146648
+    ],
+    "maxVelocity": [
+      4.879784925182409
+    ],
+    "maxAcceleration": [
+      4.332860449614217
+    ],
+    "maxJerk": [
+      5.463903272707434
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.681868918252457
+    ],
+    "currentVelocity": [
+      -3.0653821257971448
+    ],
+    "currentAcceleration": [
+      0.029053188030883526
+    ],
+    "targetPosition": [
+      0.05580241401185049
+    ],
+    "targetVelocity": [
+      -4.877449770951266
+    ],
+    "targetAcceleration": [
+      3.829264268454473
+    ],
+    "maxVelocity": [
+      6.9626915254669814
+    ],
+    "maxAcceleration": [
+      7.6569428537802935
+    ],
+    "maxJerk": [
+      10.95831314589193
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.3911183463076533
+    ],
+    "currentVelocity": [
+      -5.691440124966777
+    ],
+    "currentAcceleration": [
+      2.885699925621421
+    ],
+    "targetPosition": [
+      -2.99519556682013
+    ],
+    "targetVelocity": [
+      -1.5506129178816241
+    ],
+    "targetAcceleration": [
+      -0.12384657940499899
+    ],
+    "maxVelocity": [
+      6.0116373148831554
+    ],
+    "maxAcceleration": [
+      4.648149362580815
+    ],
+    "maxJerk": [
+      17.954840835726344
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.932933242277587
+    ],
+    "currentVelocity": [
+      -1.2842465955008704
+    ],
+    "currentAcceleration": [
+      -2.3894263331926338
+    ],
+    "targetPosition": [
+      -2.37955556297492
+    ],
+    "targetVelocity": [
+      -0.28673422114022884
+    ],
+    "targetAcceleration": [
+      -6.0908434865060554
+    ],
+    "maxVelocity": [
+      3.3973242675255575
+    ],
+    "maxAcceleration": [
+      8.52671433084581
+    ],
+    "maxJerk": [
+      17.289467723688844
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.4015919953926392
+    ],
+    "currentVelocity": [
+      -0.36302621204359875
+    ],
+    "currentAcceleration": [
+      6.202558655643525
+    ],
+    "targetPosition": [
+      -4.759512162176238
+    ],
+    "targetVelocity": [
+      -1.4086037630142345
+    ],
+    "targetAcceleration": [
+      5.737607900052916
+    ],
+    "maxVelocity": [
+      2.5276718689612108
+    ],
+    "maxAcceleration": [
+      8.168475628421769
+    ],
+    "maxJerk": [
+      16.651699939980688
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.04576803164061
+    ],
+    "currentVelocity": [
+      3.1335043387462127
+    ],
+    "currentAcceleration": [
+      -1.0412126858729822
+    ],
+    "targetPosition": [
+      9.77909535270069
+    ],
+    "targetVelocity": [
+      -1.05010114488636
+    ],
+    "targetAcceleration": [
+      8.407759197816226
+    ],
+    "maxVelocity": [
+      3.8467952197565207
+    ],
+    "maxAcceleration": [
+      8.46753436390707
+    ],
+    "maxJerk": [
+      17.876272885689197
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.811311821189152
+    ],
+    "currentVelocity": [
+      -7.028760064440143
+    ],
+    "currentAcceleration": [
+      3.526927695509114
+    ],
+    "targetPosition": [
+      7.931541220810836
+    ],
+    "targetVelocity": [
+      -3.28825908583868
+    ],
+    "targetAcceleration": [
+      -0.5738264975232905
+    ],
+    "maxVelocity": [
+      7.422618278025976
+    ],
+    "maxAcceleration": [
+      5.597464889671782
+    ],
+    "maxJerk": [
+      12.609375683367851
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.4570931322787537
+    ],
+    "currentVelocity": [
+      3.4121325595305514
+    ],
+    "currentAcceleration": [
+      1.0842836510096419
+    ],
+    "targetPosition": [
+      -1.0352703294337537
+    ],
+    "targetVelocity": [
+      2.658412786970006
+    ],
+    "targetAcceleration": [
+      -4.344835682850511
+    ],
+    "maxVelocity": [
+      7.624455142527278
+    ],
+    "maxAcceleration": [
+      8.44977714034199
+    ],
+    "maxJerk": [
+      18.184286136075578
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.756617937440662
+    ],
+    "currentVelocity": [
+      -0.1450832838213847
+    ],
+    "currentAcceleration": [
+      3.5032614276535394
+    ],
+    "targetPosition": [
+      -6.710512705154066
+    ],
+    "targetVelocity": [
+      -3.373657837483451
+    ],
+    "targetAcceleration": [
+      -2.7750724471012824
+    ],
+    "maxVelocity": [
+      7.449594743043875
+    ],
+    "maxAcceleration": [
+      6.473901694661425
+    ],
+    "maxJerk": [
+      10.483875703619937
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.5631925331219669
+    ],
+    "currentVelocity": [
+      3.1572773738254254
+    ],
+    "currentAcceleration": [
+      -1.3379376510410657
+    ],
+    "targetPosition": [
+      -5.149089298427507
+    ],
+    "targetVelocity": [
+      3.178274461547029
+    ],
+    "targetAcceleration": [
+      3.7100076152523283
+    ],
+    "maxVelocity": [
+      5.90693573160464
+    ],
+    "maxAcceleration": [
+      6.798237902224118
+    ],
+    "maxJerk": [
+      13.276028658010523
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.88719566178518
+    ],
+    "currentVelocity": [
+      -0.1428487762479973
+    ],
+    "currentAcceleration": [
+      -3.0448814461475298
+    ],
+    "targetPosition": [
+      6.716008741412281
+    ],
+    "targetVelocity": [
+      -5.117556505785304
+    ],
+    "targetAcceleration": [
+      -0.35882463065158543
+    ],
+    "maxVelocity": [
+      6.811340116082185
+    ],
+    "maxAcceleration": [
+      5.667548710133804
+    ],
+    "maxJerk": [
+      9.339910423526595
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.127139905090836
+    ],
+    "currentVelocity": [
+      6.34999143161497
+    ],
+    "currentAcceleration": [
+      -3.578750731118699
+    ],
+    "targetPosition": [
+      4.454922149836666
+    ],
+    "targetVelocity": [
+      -6.4830002819047
+    ],
+    "targetAcceleration": [
+      -1.5844013002606951
+    ],
+    "maxVelocity": [
+      6.603982984576414
+    ],
+    "maxAcceleration": [
+      6.010353815602437
+    ],
+    "maxJerk": [
+      5.794092827164228
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.027000351556424
+    ],
+    "currentVelocity": [
+      -0.01736916082988449
+    ],
+    "currentAcceleration": [
+      -0.06441804013342622
+    ],
+    "targetPosition": [
+      -9.76751916836761
+    ],
+    "targetVelocity": [
+      -0.8827517660399467
+    ],
+    "targetAcceleration": [
+      -0.4329479794911091
+    ],
+    "maxVelocity": [
+      2.0366636163392937
+    ],
+    "maxAcceleration": [
+      7.319721208929775
+    ],
+    "maxJerk": [
+      17.60414826627696
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.434843200117372
+    ],
+    "currentVelocity": [
+      -6.010097654481785
+    ],
+    "currentAcceleration": [
+      -1.6522099200185973
+    ],
+    "targetPosition": [
+      9.30158689141334
+    ],
+    "targetVelocity": [
+      3.432513978456977
+    ],
+    "targetAcceleration": [
+      5.518653632253791
+    ],
+    "maxVelocity": [
+      7.029291282916453
+    ],
+    "maxAcceleration": [
+      6.612840750122961
+    ],
+    "maxJerk": [
+      13.434850443351822
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.314190344435419
+    ],
+    "currentVelocity": [
+      -2.9805080457824995
+    ],
+    "currentAcceleration": [
+      -1.7398522927017004
+    ],
+    "targetPosition": [
+      3.4550854408135923
+    ],
+    "targetVelocity": [
+      -5.029238951153515
+    ],
+    "targetAcceleration": [
+      1.529926972033985
+    ],
+    "maxVelocity": [
+      5.213292780692216
+    ],
+    "maxAcceleration": [
+      3.211484986504114
+    ],
+    "maxJerk": [
+      13.756667681913273
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.3339658362750288
+    ],
+    "currentVelocity": [
+      0.9242252967098841
+    ],
+    "currentAcceleration": [
+      -1.6359697220902651
+    ],
+    "targetPosition": [
+      7.20110927624323
+    ],
+    "targetVelocity": [
+      -5.801760056924144
+    ],
+    "targetAcceleration": [
+      -1.8527836313730175
+    ],
+    "maxVelocity": [
+      7.2598206107106185
+    ],
+    "maxAcceleration": [
+      3.4226684112851453
+    ],
+    "maxJerk": [
+      18.015977091026777
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.7423784029336
+    ],
+    "currentVelocity": [
+      1.9467308883041383
+    ],
+    "currentAcceleration": [
+      -2.9336240357258108
+    ],
+    "targetPosition": [
+      -8.075192969149255
+    ],
+    "targetVelocity": [
+      -0.2920582417781308
+    ],
+    "targetAcceleration": [
+      -4.485307049988131
+    ],
+    "maxVelocity": [
+      4.762592252075013
+    ],
+    "maxAcceleration": [
+      4.838622261864802
+    ],
+    "maxJerk": [
+      13.315601780520037
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.9923330792168041
+    ],
+    "currentVelocity": [
+      -7.059762443893399
+    ],
+    "currentAcceleration": [
+      1.8595868215892524
+    ],
+    "targetPosition": [
+      0.7071927386598169
+    ],
+    "targetVelocity": [
+      4.419278022326601
+    ],
+    "targetAcceleration": [
+      -1.4802283423322558
+    ],
+    "maxVelocity": [
+      7.89577914969194
+    ],
+    "maxAcceleration": [
+      3.094785380686426
+    ],
+    "maxJerk": [
+      17.983596744359815
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.362263029745515
+    ],
+    "currentVelocity": [
+      -7.155019900849825
+    ],
+    "currentAcceleration": [
+      0.7895078997881679
+    ],
+    "targetPosition": [
+      4.536801030342929
+    ],
+    "targetVelocity": [
+      4.4125441019886384
+    ],
+    "targetAcceleration": [
+      -4.313872014819774
+    ],
+    "maxVelocity": [
+      7.781127071751639
+    ],
+    "maxAcceleration": [
+      8.893321184226554
+    ],
+    "maxJerk": [
+      8.398826175892044
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.9620251934235995
+    ],
+    "currentVelocity": [
+      -3.1798640977622603
+    ],
+    "currentAcceleration": [
+      0.33630803798991504
+    ],
+    "targetPosition": [
+      -5.269419041425718
+    ],
+    "targetVelocity": [
+      6.435060968022815
+    ],
+    "targetAcceleration": [
+      1.445241221428951
+    ],
+    "maxVelocity": [
+      7.013905074576006
+    ],
+    "maxAcceleration": [
+      5.557678147318651
+    ],
+    "maxJerk": [
+      13.675890784634815
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.9568390742847548
+    ],
+    "currentVelocity": [
+      1.4796533473245943
+    ],
+    "currentAcceleration": [
+      1.7529380389903642
+    ],
+    "targetPosition": [
+      -9.397310877372004
+    ],
+    "targetVelocity": [
+      -0.19917601868482038
+    ],
+    "targetAcceleration": [
+      4.782028337902678
+    ],
+    "maxVelocity": [
+      2.1699301773596464
+    ],
+    "maxAcceleration": [
+      5.851384857870765
+    ],
+    "maxJerk": [
+      19.206041288699318
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.030480052908601
+    ],
+    "currentVelocity": [
+      -1.6568182774259244
+    ],
+    "currentAcceleration": [
+      -2.4030527426815773
+    ],
+    "targetPosition": [
+      6.701108789651098
+    ],
+    "targetVelocity": [
+      1.337500199986171
+    ],
+    "targetAcceleration": [
+      7.132980979284969
+    ],
+    "maxVelocity": [
+      3.6498145367153256
+    ],
+    "maxAcceleration": [
+      8.032382558805509
+    ],
+    "maxJerk": [
+      14.072290614329823
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.9161254643523566
+    ],
+    "currentVelocity": [
+      2.159188243246799
+    ],
+    "currentAcceleration": [
+      -7.785949944447147
+    ],
+    "targetPosition": [
+      -5.979717220703371
+    ],
+    "targetVelocity": [
+      3.0287593835335525
+    ],
+    "targetAcceleration": [
+      5.515983758811915
+    ],
+    "maxVelocity": [
+      5.92848776726095
+    ],
+    "maxAcceleration": [
+      7.98432313851572
+    ],
+    "maxJerk": [
+      16.699309306350955
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.394717158764456
+    ],
+    "currentVelocity": [
+      4.495688581902536
+    ],
+    "currentAcceleration": [
+      -7.133486830101253
+    ],
+    "targetPosition": [
+      8.201867447587702
+    ],
+    "targetVelocity": [
+      -4.574317007715169
+    ],
+    "targetAcceleration": [
+      -7.38126979474055
+    ],
+    "maxVelocity": [
+      6.2043466462390935
+    ],
+    "maxAcceleration": [
+      8.323731477280056
+    ],
+    "maxJerk": [
+      8.698661881974086
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.613031073355799
+    ],
+    "currentVelocity": [
+      3.653026756886767
+    ],
+    "currentAcceleration": [
+      -1.1087985710244075
+    ],
+    "targetPosition": [
+      -6.004970493409525
+    ],
+    "targetVelocity": [
+      -1.619223140783959
+    ],
+    "targetAcceleration": [
+      -0.32499818625068766
+    ],
+    "maxVelocity": [
+      4.294639368713777
+    ],
+    "maxAcceleration": [
+      5.138201572613218
+    ],
+    "maxJerk": [
+      13.520756515583923
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.044024278748056034
+    ],
+    "currentVelocity": [
+      -4.290500746451088
+    ],
+    "currentAcceleration": [
+      0.5671050451080495
+    ],
+    "targetPosition": [
+      -0.5164383534350705
+    ],
+    "targetVelocity": [
+      -0.5459265798876354
+    ],
+    "targetAcceleration": [
+      -3.3386300055246307
+    ],
+    "maxVelocity": [
+      6.054863151432904
+    ],
+    "maxAcceleration": [
+      4.317125841082806
+    ],
+    "maxJerk": [
+      15.538875226826736
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.712608037450742
+    ],
+    "currentVelocity": [
+      -0.21931514565449906
+    ],
+    "currentAcceleration": [
+      -0.7011885865177883
+    ],
+    "targetPosition": [
+      -8.598594286202921
+    ],
+    "targetVelocity": [
+      4.133820929471537
+    ],
+    "targetAcceleration": [
+      -5.165164114519671
+    ],
+    "maxVelocity": [
+      5.8089923793875125
+    ],
+    "maxAcceleration": [
+      6.616603823190527
+    ],
+    "maxJerk": [
+      10.589802748260713
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.4843655240910998
+    ],
+    "currentVelocity": [
+      -2.138945918895536
+    ],
+    "currentAcceleration": [
+      -4.068574814460833
+    ],
+    "targetPosition": [
+      -7.333432852085949
+    ],
+    "targetVelocity": [
+      -0.8163742768264863
+    ],
+    "targetAcceleration": [
+      -6.211921147918802
+    ],
+    "maxVelocity": [
+      4.519759413998534
+    ],
+    "maxAcceleration": [
+      7.230824608094078
+    ],
+    "maxJerk": [
+      7.128145560496161
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.716485016011468
+    ],
+    "currentVelocity": [
+      1.0719529522913218
+    ],
+    "currentAcceleration": [
+      -3.1282225969831954
+    ],
+    "targetPosition": [
+      3.3333522131689364
+    ],
+    "targetVelocity": [
+      -2.7547154487093715
+    ],
+    "targetAcceleration": [
+      1.6278255298100923
+    ],
+    "maxVelocity": [
+      4.356432432753302
+    ],
+    "maxAcceleration": [
+      8.141471336115114
+    ],
+    "maxJerk": [
+      15.058374669296832
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.614544953389565
+    ],
+    "currentVelocity": [
+      2.1718913534970503
+    ],
+    "currentAcceleration": [
+      -8.385407292626567
+    ],
+    "targetPosition": [
+      0.8721696495149089
+    ],
+    "targetVelocity": [
+      -0.6857794936058403
+    ],
+    "targetAcceleration": [
+      -1.95164621734967
+    ],
+    "maxVelocity": [
+      2.4213732520204396
+    ],
+    "maxAcceleration": [
+      8.61550082476048
+    ],
+    "maxJerk": [
+      9.121489522058866
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.412960642361043
+    ],
+    "currentVelocity": [
+      0.2867873683356148
+    ],
+    "currentAcceleration": [
+      -4.26357749092481
+    ],
+    "targetPosition": [
+      -8.521571876714846
+    ],
+    "targetVelocity": [
+      -3.1253548248280922
+    ],
+    "targetAcceleration": [
+      4.522014032656395
+    ],
+    "maxVelocity": [
+      5.020784497305681
+    ],
+    "maxAcceleration": [
+      7.715433216954779
+    ],
+    "maxJerk": [
+      15.258928379184024
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.345792446822564
+    ],
+    "currentVelocity": [
+      -1.689850018863893
+    ],
+    "currentAcceleration": [
+      6.765625187015759
+    ],
+    "targetPosition": [
+      -6.255909362553799
+    ],
+    "targetVelocity": [
+      3.8750379930053604
+    ],
+    "targetAcceleration": [
+      5.506599201221674
+    ],
+    "maxVelocity": [
+      4.409653343481597
+    ],
+    "maxAcceleration": [
+      6.866401433787891
+    ],
+    "maxJerk": [
+      19.572898103635907
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.9517511909219252
+    ],
+    "currentVelocity": [
+      -3.5612557651290793
+    ],
+    "currentAcceleration": [
+      0.5860543609966227
+    ],
+    "targetPosition": [
+      7.709557148725597
+    ],
+    "targetVelocity": [
+      0.7703986986091707
+    ],
+    "targetAcceleration": [
+      2.6578999000965284
+    ],
+    "maxVelocity": [
+      3.7539313741655516
+    ],
+    "maxAcceleration": [
+      5.718446226648953
+    ],
+    "maxJerk": [
+      17.539308948241604
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.7894779415366404
+    ],
+    "currentVelocity": [
+      3.546459445459798
+    ],
+    "currentAcceleration": [
+      -0.5046631079322204
+    ],
+    "targetPosition": [
+      6.654616475187137
+    ],
+    "targetVelocity": [
+      3.113304426671388
+    ],
+    "targetAcceleration": [
+      1.4060632500887307
+    ],
+    "maxVelocity": [
+      3.836372446897117
+    ],
+    "maxAcceleration": [
+      5.854987693630511
+    ],
+    "maxJerk": [
+      12.938145003618981
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.181368075099329
+    ],
+    "currentVelocity": [
+      -2.9574592456473545
+    ],
+    "currentAcceleration": [
+      -3.1859298132769096
+    ],
+    "targetPosition": [
+      4.33912176553725
+    ],
+    "targetVelocity": [
+      -3.4960557102267527
+    ],
+    "targetAcceleration": [
+      2.690741851883973
+    ],
+    "maxVelocity": [
+      6.906568898243754
+    ],
+    "maxAcceleration": [
+      6.03998201162054
+    ],
+    "maxJerk": [
+      19.24431038873444
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.676701677031639
+    ],
+    "currentVelocity": [
+      5.43186396496259
+    ],
+    "currentAcceleration": [
+      -4.06652018774791
+    ],
+    "targetPosition": [
+      -3.3294066645644005
+    ],
+    "targetVelocity": [
+      2.694686211747106
+    ],
+    "targetAcceleration": [
+      3.1791721607292125
+    ],
+    "maxVelocity": [
+      7.459587536426671
+    ],
+    "maxAcceleration": [
+      4.530257907200381
+    ],
+    "maxJerk": [
+      19.405791054104306
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.55096398991647
+    ],
+    "currentVelocity": [
+      -1.219606962124708
+    ],
+    "currentAcceleration": [
+      0.52518342749695
+    ],
+    "targetPosition": [
+      6.3171641938099725
+    ],
+    "targetVelocity": [
+      1.7942630151832386
+    ],
+    "targetAcceleration": [
+      -2.0646718285705083
+    ],
+    "maxVelocity": [
+      5.078492719900998
+    ],
+    "maxAcceleration": [
+      3.252650306675331
+    ],
+    "maxJerk": [
+      6.726977596268153
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.474318909727103
+    ],
+    "currentVelocity": [
+      -4.762147604231559
+    ],
+    "currentAcceleration": [
+      2.091821469587945
+    ],
+    "targetPosition": [
+      -9.693545932664735
+    ],
+    "targetVelocity": [
+      -4.496603021115806
+    ],
+    "targetAcceleration": [
+      -5.643489764282187
+    ],
+    "maxVelocity": [
+      5.5778208257428075
+    ],
+    "maxAcceleration": [
+      6.729127623053953
+    ],
+    "maxJerk": [
+      19.24772672458629
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.578549760870867
+    ],
+    "currentVelocity": [
+      0.030423681646175815
+    ],
+    "currentAcceleration": [
+      -3.061281878358175
+    ],
+    "targetPosition": [
+      -1.2942442657938695
+    ],
+    "targetVelocity": [
+      -3.5863800374761725
+    ],
+    "targetAcceleration": [
+      -2.2819114804474543
+    ],
+    "maxVelocity": [
+      5.425742142995448
+    ],
+    "maxAcceleration": [
+      4.642953367509136
+    ],
+    "maxJerk": [
+      19.017006113501573
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0415898580170193
+    ],
+    "currentVelocity": [
+      0.2732124607335349
+    ],
+    "currentAcceleration": [
+      -2.116362155878675
+    ],
+    "targetPosition": [
+      -5.143994943243273
+    ],
+    "targetVelocity": [
+      1.4885803065617607
+    ],
+    "targetAcceleration": [
+      2.3801078427409976
+    ],
+    "maxVelocity": [
+      3.206381017716893
+    ],
+    "maxAcceleration": [
+      5.238836996100373
+    ],
+    "maxJerk": [
+      18.433010685336818
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.9224740095683774
+    ],
+    "currentVelocity": [
+      -0.3370511140247183
+    ],
+    "currentAcceleration": [
+      -9.544745594141768
+    ],
+    "targetPosition": [
+      7.480421360239312
+    ],
+    "targetVelocity": [
+      -0.23162866742035249
+    ],
+    "targetAcceleration": [
+      -7.736227307658458
+    ],
+    "maxVelocity": [
+      5.206891459303165
+    ],
+    "maxAcceleration": [
+      9.89399573139588
+    ],
+    "maxJerk": [
+      9.744576427484251
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.16009692085472
+    ],
+    "currentVelocity": [
+      3.2310711813850665
+    ],
+    "currentAcceleration": [
+      -0.9164781170429781
+    ],
+    "targetPosition": [
+      3.7367822503687425
+    ],
+    "targetVelocity": [
+      0.6183878388143245
+    ],
+    "targetAcceleration": [
+      0.8940701834801215
+    ],
+    "maxVelocity": [
+      3.7748979464754746
+    ],
+    "maxAcceleration": [
+      3.094665544393591
+    ],
+    "maxJerk": [
+      16.2660278784819
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.084484674980175
+    ],
+    "currentVelocity": [
+      2.658690239033847
+    ],
+    "currentAcceleration": [
+      5.758884488146952
+    ],
+    "targetPosition": [
+      -8.169478654197103
+    ],
+    "targetVelocity": [
+      -2.428180592629538
+    ],
+    "targetAcceleration": [
+      -5.674679870732825
+    ],
+    "maxVelocity": [
+      5.308075553362557
+    ],
+    "maxAcceleration": [
+      8.149952979624045
+    ],
+    "maxJerk": [
+      13.54357138079914
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.036465607404969
+    ],
+    "currentVelocity": [
+      5.519149167478302
+    ],
+    "currentAcceleration": [
+      0.9223937405577978
+    ],
+    "targetPosition": [
+      9.10919093395814
+    ],
+    "targetVelocity": [
+      -5.467534932649547
+    ],
+    "targetAcceleration": [
+      1.5965533046832565
+    ],
+    "maxVelocity": [
+      6.096590158828798
+    ],
+    "maxAcceleration": [
+      4.872374700905674
+    ],
+    "maxJerk": [
+      10.814825587204803
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.619657336717747
+    ],
+    "currentVelocity": [
+      -0.896703185374375
+    ],
+    "currentAcceleration": [
+      -1.5793331825376349
+    ],
+    "targetPosition": [
+      -9.416153469165085
+    ],
+    "targetVelocity": [
+      -1.5050768412130475
+    ],
+    "targetAcceleration": [
+      -4.305015884098197
+    ],
+    "maxVelocity": [
+      4.31767714499744
+    ],
+    "maxAcceleration": [
+      4.401389827229952
+    ],
+    "maxJerk": [
+      8.299765045121262
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.339698295839515
+    ],
+    "currentVelocity": [
+      4.9829995623963805
+    ],
+    "currentAcceleration": [
+      -5.200468444641872
+    ],
+    "targetPosition": [
+      1.172198186517246
+    ],
+    "targetVelocity": [
+      -1.7288954215414343
+    ],
+    "targetAcceleration": [
+      0.0039511359032582405
+    ],
+    "maxVelocity": [
+      6.000949800742288
+    ],
+    "maxAcceleration": [
+      5.645271061609362
+    ],
+    "maxJerk": [
+      14.196317465811731
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.532427911455077
+    ],
+    "currentVelocity": [
+      0.5964006480193005
+    ],
+    "currentAcceleration": [
+      -2.587016177714557
+    ],
+    "targetPosition": [
+      -4.3658909793602785
+    ],
+    "targetVelocity": [
+      -0.5707078671036332
+    ],
+    "targetAcceleration": [
+      -2.585787901156312
+    ],
+    "maxVelocity": [
+      2.2562919780659243
+    ],
+    "maxAcceleration": [
+      5.080086646118406
+    ],
+    "maxJerk": [
+      8.527861142271107
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.65946799412497
+    ],
+    "currentVelocity": [
+      6.256832608110373
+    ],
+    "currentAcceleration": [
+      -4.091203190075344
+    ],
+    "targetPosition": [
+      -3.806207638157333
+    ],
+    "targetVelocity": [
+      4.938259391581448
+    ],
+    "targetAcceleration": [
+      -3.136855047325298
+    ],
+    "maxVelocity": [
+      6.5137098050320565
+    ],
+    "maxAcceleration": [
+      7.2435068840029215
+    ],
+    "maxJerk": [
+      13.827688650213911
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.886944223753014
+    ],
+    "currentVelocity": [
+      -1.8936190198853442
+    ],
+    "currentAcceleration": [
+      -4.552654327020984
+    ],
+    "targetPosition": [
+      4.385634046147672
+    ],
+    "targetVelocity": [
+      -0.9004955313294212
+    ],
+    "targetAcceleration": [
+      1.1734795821124386
+    ],
+    "maxVelocity": [
+      4.677162014973595
+    ],
+    "maxAcceleration": [
+      4.620693774972608
+    ],
+    "maxJerk": [
+      15.688293450928562
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.028691769237610742
+    ],
+    "currentVelocity": [
+      -2.2357548120255064
+    ],
+    "currentAcceleration": [
+      3.224897269073142
+    ],
+    "targetPosition": [
+      3.3880080199377716
+    ],
+    "targetVelocity": [
+      -1.6284040851486001
+    ],
+    "targetAcceleration": [
+      2.6989929602204485
+    ],
+    "maxVelocity": [
+      2.6613989446830213
+    ],
+    "maxAcceleration": [
+      3.286143153226094
+    ],
+    "maxJerk": [
+      6.746483207420917
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.419506670857027
+    ],
+    "currentVelocity": [
+      0.6063386959203259
+    ],
+    "currentAcceleration": [
+      -2.273300963515477
+    ],
+    "targetPosition": [
+      -1.0442175126264068
+    ],
+    "targetVelocity": [
+      -2.047649798985484
+    ],
+    "targetAcceleration": [
+      -0.7841051150657683
+    ],
+    "maxVelocity": [
+      5.8528271216633065
+    ],
+    "maxAcceleration": [
+      3.0493423521128853
+    ],
+    "maxJerk": [
+      13.882872555354512
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.1819769860172986
+    ],
+    "currentVelocity": [
+      -0.08504348310746224
+    ],
+    "currentAcceleration": [
+      -2.2212615156121123
+    ],
+    "targetPosition": [
+      -0.029725821609867253
+    ],
+    "targetVelocity": [
+      0.6666645040383754
+    ],
+    "targetAcceleration": [
+      2.5143686094453788
+    ],
+    "maxVelocity": [
+      4.202729793852429
+    ],
+    "maxAcceleration": [
+      4.079772823364605
+    ],
+    "maxJerk": [
+      8.507033822521864
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.361580033977486
+    ],
+    "currentVelocity": [
+      5.3568780157545834
+    ],
+    "currentAcceleration": [
+      -1.1855745519719336
+    ],
+    "targetPosition": [
+      -9.152648467227289
+    ],
+    "targetVelocity": [
+      -5.869824258408267
+    ],
+    "targetAcceleration": [
+      -0.5270754530922277
+    ],
+    "maxVelocity": [
+      7.43925050059463
+    ],
+    "maxAcceleration": [
+      3.0162058167183314
+    ],
+    "maxJerk": [
+      6.5033851579188395
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.03454075212735219
+    ],
+    "currentVelocity": [
+      1.0223508412587976
+    ],
+    "currentAcceleration": [
+      1.838021423102079
+    ],
+    "targetPosition": [
+      -5.952751198578719
+    ],
+    "targetVelocity": [
+      1.5986764478167985
+    ],
+    "targetAcceleration": [
+      -0.22065458289252327
+    ],
+    "maxVelocity": [
+      2.3149366297928813
+    ],
+    "maxAcceleration": [
+      3.9866397217663323
+    ],
+    "maxJerk": [
+      5.4400127876415185
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.924565594033691
+    ],
+    "currentVelocity": [
+      -1.2433427539519029
+    ],
+    "currentAcceleration": [
+      0.7718852836611951
+    ],
+    "targetPosition": [
+      -7.150722911221116
+    ],
+    "targetVelocity": [
+      -2.357205233969357
+    ],
+    "targetAcceleration": [
+      -0.0748105548731619
+    ],
+    "maxVelocity": [
+      6.0101430971430965
+    ],
+    "maxAcceleration": [
+      9.64305057122813
+    ],
+    "maxJerk": [
+      12.270414822279704
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.5963637478092245
+    ],
+    "currentVelocity": [
+      2.0138292101175144
+    ],
+    "currentAcceleration": [
+      -3.680285223322521
+    ],
+    "targetPosition": [
+      -1.6419546499267632
+    ],
+    "targetVelocity": [
+      0.6324000511745846
+    ],
+    "targetAcceleration": [
+      2.3599032711489922
+    ],
+    "maxVelocity": [
+      3.997927721509058
+    ],
+    "maxAcceleration": [
+      8.541024730052557
+    ],
+    "maxJerk": [
+      17.60170130800944
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.741266628412202
+    ],
+    "currentVelocity": [
+      -0.47156703321858284
+    ],
+    "currentAcceleration": [
+      -3.515584774638392
+    ],
+    "targetPosition": [
+      9.86467317239212
+    ],
+    "targetVelocity": [
+      -0.5914886962150909
+    ],
+    "targetAcceleration": [
+      -0.5538169499144807
+    ],
+    "maxVelocity": [
+      4.963449279467
+    ],
+    "maxAcceleration": [
+      8.635843631101462
+    ],
+    "maxJerk": [
+      8.000648988848052
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.59063114159817
+    ],
+    "currentVelocity": [
+      1.5300361379368317
+    ],
+    "currentAcceleration": [
+      -1.062434014610968
+    ],
+    "targetPosition": [
+      5.612215705782209
+    ],
+    "targetVelocity": [
+      -2.9497645480677908
+    ],
+    "targetAcceleration": [
+      -4.367614463854661
+    ],
+    "maxVelocity": [
+      4.365361332070236
+    ],
+    "maxAcceleration": [
+      6.606350150982469
+    ],
+    "maxJerk": [
+      13.586951214167925
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.1217169693658047
+    ],
+    "currentVelocity": [
+      -2.1032581661147765
+    ],
+    "currentAcceleration": [
+      5.690011415565559
+    ],
+    "targetPosition": [
+      -8.433866855487032
+    ],
+    "targetVelocity": [
+      0.6363855932749964
+    ],
+    "targetAcceleration": [
+      4.859685631161863
+    ],
+    "maxVelocity": [
+      3.125681138691757
+    ],
+    "maxAcceleration": [
+      9.13967644767651
+    ],
+    "maxJerk": [
+      16.80615165626609
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.249176692676477
+    ],
+    "currentVelocity": [
+      -1.8862146488137737
+    ],
+    "currentAcceleration": [
+      0.8842845634284826
+    ],
+    "targetPosition": [
+      6.365772404318953
+    ],
+    "targetVelocity": [
+      4.635977041481945
+    ],
+    "targetAcceleration": [
+      -1.8196227498879027
+    ],
+    "maxVelocity": [
+      5.339502714189442
+    ],
+    "maxAcceleration": [
+      7.354221953941983
+    ],
+    "maxJerk": [
+      8.881559045616985
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.2127511100642305
+    ],
+    "currentVelocity": [
+      -5.073375170167296
+    ],
+    "currentAcceleration": [
+      5.5652042330118
+    ],
+    "targetPosition": [
+      7.4247067319987465
+    ],
+    "targetVelocity": [
+      3.7021691944322974
+    ],
+    "targetAcceleration": [
+      0.8531754046312061
+    ],
+    "maxVelocity": [
+      5.573270896797778
+    ],
+    "maxAcceleration": [
+      6.642121663157491
+    ],
+    "maxJerk": [
+      18.400260975089225
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.10592438871694
+    ],
+    "currentVelocity": [
+      1.7702688918916074
+    ],
+    "currentAcceleration": [
+      6.32884023178433
+    ],
+    "targetPosition": [
+      -8.072743820928022
+    ],
+    "targetVelocity": [
+      5.2346114192037
+    ],
+    "targetAcceleration": [
+      -7.55599073432211
+    ],
+    "maxVelocity": [
+      7.477864026145973
+    ],
+    "maxAcceleration": [
+      9.333927036787419
+    ],
+    "maxJerk": [
+      15.495918551833006
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.73167659522662
+    ],
+    "currentVelocity": [
+      3.1724188295433375
+    ],
+    "currentAcceleration": [
+      -0.4180504844462094
+    ],
+    "targetPosition": [
+      9.066405659521156
+    ],
+    "targetVelocity": [
+      3.227921428461155
+    ],
+    "targetAcceleration": [
+      -4.1394518026772085
+    ],
+    "maxVelocity": [
+      6.146544639131228
+    ],
+    "maxAcceleration": [
+      4.5101134668567004
+    ],
+    "maxJerk": [
+      18.726492805425877
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.4477404977953263
+    ],
+    "currentVelocity": [
+      -1.5219376481974018
+    ],
+    "currentAcceleration": [
+      1.4484815060405105
+    ],
+    "targetPosition": [
+      5.016291305451565
+    ],
+    "targetVelocity": [
+      -0.18496880121439663
+    ],
+    "targetAcceleration": [
+      -1.1867414962405651
+    ],
+    "maxVelocity": [
+      5.832659908611031
+    ],
+    "maxAcceleration": [
+      3.706654818627651
+    ],
+    "maxJerk": [
+      14.898907355722262
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.48550628776529
+    ],
+    "currentVelocity": [
+      2.3688757004177035
+    ],
+    "currentAcceleration": [
+      3.2122471880688206
+    ],
+    "targetPosition": [
+      -1.8909768600674184
+    ],
+    "targetVelocity": [
+      -5.215853268462556
+    ],
+    "targetAcceleration": [
+      0.6003725294045132
+    ],
+    "maxVelocity": [
+      6.055651433250887
+    ],
+    "maxAcceleration": [
+      3.5126716828436875
+    ],
+    "maxJerk": [
+      16.599720436328987
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.0703437314059734
+    ],
+    "currentVelocity": [
+      0.45807229840161945
+    ],
+    "currentAcceleration": [
+      0.06080245757722036
+    ],
+    "targetPosition": [
+      0.5151875420309278
+    ],
+    "targetVelocity": [
+      -1.7223649211569767
+    ],
+    "targetAcceleration": [
+      4.106452077021142
+    ],
+    "maxVelocity": [
+      4.714731586012264
+    ],
+    "maxAcceleration": [
+      6.316953799925383
+    ],
+    "maxJerk": [
+      7.267801102540326
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.1108378874262854
+    ],
+    "currentVelocity": [
+      -1.1756933136448362
+    ],
+    "currentAcceleration": [
+      -0.6712603148758078
+    ],
+    "targetPosition": [
+      7.181947820037809
+    ],
+    "targetVelocity": [
+      2.355521717671296
+    ],
+    "targetAcceleration": [
+      -1.2087722285996563
+    ],
+    "maxVelocity": [
+      3.1621266369933005
+    ],
+    "maxAcceleration": [
+      3.162082809643221
+    ],
+    "maxJerk": [
+      10.19962758164883
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.96311505104841
+    ],
+    "currentVelocity": [
+      -0.06002652725802626
+    ],
+    "currentAcceleration": [
+      -2.1216350978714833
+    ],
+    "targetPosition": [
+      9.087262420526269
+    ],
+    "targetVelocity": [
+      -4.9368920847393625
+    ],
+    "targetAcceleration": [
+      2.315839368549486
+    ],
+    "maxVelocity": [
+      6.133978809722678
+    ],
+    "maxAcceleration": [
+      3.34527474207925
+    ],
+    "maxJerk": [
+      14.797822490924137
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.070222576738175
+    ],
+    "currentVelocity": [
+      1.3114236056529345
+    ],
+    "currentAcceleration": [
+      6.537426322600666
+    ],
+    "targetPosition": [
+      2.3500058474285446
+    ],
+    "targetVelocity": [
+      0.3339525883586445
+    ],
+    "targetAcceleration": [
+      -5.84656780985304
+    ],
+    "maxVelocity": [
+      5.4760684139229605
+    ],
+    "maxAcceleration": [
+      8.184823703865483
+    ],
+    "maxJerk": [
+      12.98775300561795
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.2799995936961572
+    ],
+    "currentVelocity": [
+      1.8150717047317126
+    ],
+    "currentAcceleration": [
+      1.5202315139649158
+    ],
+    "targetPosition": [
+      5.027190758128501
+    ],
+    "targetVelocity": [
+      0.6014417481220624
+    ],
+    "targetAcceleration": [
+      -2.17742998036798
+    ],
+    "maxVelocity": [
+      5.790354225599106
+    ],
+    "maxAcceleration": [
+      4.117731654696746
+    ],
+    "maxJerk": [
+      6.876225107428599
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.999641068060797
+    ],
+    "currentVelocity": [
+      -2.823195753987326
+    ],
+    "currentAcceleration": [
+      1.918028363104444
+    ],
+    "targetPosition": [
+      6.424782071232901
+    ],
+    "targetVelocity": [
+      1.4402612718546672
+    ],
+    "targetAcceleration": [
+      3.283126223708866
+    ],
+    "maxVelocity": [
+      4.080035907309012
+    ],
+    "maxAcceleration": [
+      3.303388287033906
+    ],
+    "maxJerk": [
+      11.493770529781479
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6018298949362215
+    ],
+    "currentVelocity": [
+      2.953797299734771
+    ],
+    "currentAcceleration": [
+      5.598805672600619
+    ],
+    "targetPosition": [
+      -9.878583615542523
+    ],
+    "targetVelocity": [
+      -1.640856353582942
+    ],
+    "targetAcceleration": [
+      -0.979478587161279
+    ],
+    "maxVelocity": [
+      5.60146706834533
+    ],
+    "maxAcceleration": [
+      8.028229328907791
+    ],
+    "maxJerk": [
+      13.971064805985245
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.164448323278097
+    ],
+    "currentVelocity": [
+      -2.6867018331084607
+    ],
+    "currentAcceleration": [
+      3.361121867899925
+    ],
+    "targetPosition": [
+      2.905489570329463
+    ],
+    "targetVelocity": [
+      -2.5989984350539155
+    ],
+    "targetAcceleration": [
+      4.386037229258578
+    ],
+    "maxVelocity": [
+      4.280157636927057
+    ],
+    "maxAcceleration": [
+      8.352570175198355
+    ],
+    "maxJerk": [
+      15.039117726647252
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7661248009573924
+    ],
+    "currentVelocity": [
+      -3.4827277853207894
+    ],
+    "currentAcceleration": [
+      -0.2928509911278141
+    ],
+    "targetPosition": [
+      8.83519229308557
+    ],
+    "targetVelocity": [
+      -3.2273029756388523
+    ],
+    "targetAcceleration": [
+      0.44744628735388225
+    ],
+    "maxVelocity": [
+      5.030032934607942
+    ],
+    "maxAcceleration": [
+      4.312240599727881
+    ],
+    "maxJerk": [
+      8.822078405643712
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.740868458668947
+    ],
+    "currentVelocity": [
+      3.007513807174197
+    ],
+    "currentAcceleration": [
+      -1.475011178742661
+    ],
+    "targetPosition": [
+      0.49425178635604183
+    ],
+    "targetVelocity": [
+      -4.757589402858187
+    ],
+    "targetAcceleration": [
+      4.5863822947263415
+    ],
+    "maxVelocity": [
+      5.3609967719883755
+    ],
+    "maxAcceleration": [
+      6.575897952821707
+    ],
+    "maxJerk": [
+      19.0039303710831
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.529110241665247
+    ],
+    "currentVelocity": [
+      -3.684737894051021
+    ],
+    "currentAcceleration": [
+      4.9052953306817155
+    ],
+    "targetPosition": [
+      -1.8646004408320458
+    ],
+    "targetVelocity": [
+      -4.434396140606924
+    ],
+    "targetAcceleration": [
+      -1.0658818663442187
+    ],
+    "maxVelocity": [
+      5.675816553439219
+    ],
+    "maxAcceleration": [
+      7.273213142591715
+    ],
+    "maxJerk": [
+      15.468188853888805
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.478156743118632
+    ],
+    "currentVelocity": [
+      2.972352257106592
+    ],
+    "currentAcceleration": [
+      -5.801186716108585
+    ],
+    "targetPosition": [
+      -5.361360004501286
+    ],
+    "targetVelocity": [
+      2.852731889817181
+    ],
+    "targetAcceleration": [
+      -4.399305897542869
+    ],
+    "maxVelocity": [
+      7.587874809525585
+    ],
+    "maxAcceleration": [
+      6.155784266496902
+    ],
+    "maxJerk": [
+      9.65460821073645
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.347766040569102
+    ],
+    "currentVelocity": [
+      3.790250866522924
+    ],
+    "currentAcceleration": [
+      1.5927799927784445
+    ],
+    "targetPosition": [
+      -5.02254638354434
+    ],
+    "targetVelocity": [
+      -1.001195384023597
+    ],
+    "targetAcceleration": [
+      -3.7110404172289657
+    ],
+    "maxVelocity": [
+      5.578833657910416
+    ],
+    "maxAcceleration": [
+      6.250657360970708
+    ],
+    "maxJerk": [
+      18.81285989534674
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.944493806669
+    ],
+    "currentVelocity": [
+      -5.451071484022613
+    ],
+    "currentAcceleration": [
+      -1.303368377463971
+    ],
+    "targetPosition": [
+      -3.218081390909351
+    ],
+    "targetVelocity": [
+      0.9580176700357574
+    ],
+    "targetAcceleration": [
+      -0.9687005921035317
+    ],
+    "maxVelocity": [
+      7.7844043970102375
+    ],
+    "maxAcceleration": [
+      3.254175326726346
+    ],
+    "maxJerk": [
+      13.069000504102984
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.7126991689025033
+    ],
+    "currentVelocity": [
+      3.5954512468391524
+    ],
+    "currentAcceleration": [
+      -1.9711972712735397
+    ],
+    "targetPosition": [
+      1.5052843577873674
+    ],
+    "targetVelocity": [
+      0.24266044986377544
+    ],
+    "targetAcceleration": [
+      -6.346649007736974
+    ],
+    "maxVelocity": [
+      4.544617715278633
+    ],
+    "maxAcceleration": [
+      8.019709544619525
+    ],
+    "maxJerk": [
+      17.263231355444326
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.188133717024435
+    ],
+    "currentVelocity": [
+      -1.5755407656163447
+    ],
+    "currentAcceleration": [
+      -4.29905836623821
+    ],
+    "targetPosition": [
+      -6.704758929865406
+    ],
+    "targetVelocity": [
+      1.5015802262676425
+    ],
+    "targetAcceleration": [
+      2.8569890948815715
+    ],
+    "maxVelocity": [
+      5.19390561113714
+    ],
+    "maxAcceleration": [
+      5.465070440501265
+    ],
+    "maxJerk": [
+      16.19472542451551
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.200118791609675
+    ],
+    "currentVelocity": [
+      2.5741146143692824
+    ],
+    "currentAcceleration": [
+      -2.591516875430922
+    ],
+    "targetPosition": [
+      7.026407764427255
+    ],
+    "targetVelocity": [
+      -3.805272984653736
+    ],
+    "targetAcceleration": [
+      4.763012273075024
+    ],
+    "maxVelocity": [
+      7.839168879715089
+    ],
+    "maxAcceleration": [
+      6.173398981318357
+    ],
+    "maxJerk": [
+      17.452915726283834
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.26348783168702
+    ],
+    "currentVelocity": [
+      0.4335181029155737
+    ],
+    "currentAcceleration": [
+      0.33125080272003515
+    ],
+    "targetPosition": [
+      1.3756219732483999
+    ],
+    "targetVelocity": [
+      -2.7128340142597027
+    ],
+    "targetAcceleration": [
+      -2.454331915515891
+    ],
+    "maxVelocity": [
+      3.3292059344215863
+    ],
+    "maxAcceleration": [
+      3.8396177179282827
+    ],
+    "maxJerk": [
+      10.644419611792014
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.5484846337589531
+    ],
+    "currentVelocity": [
+      -3.9055146409212607
+    ],
+    "currentAcceleration": [
+      3.85195496465571
+    ],
+    "targetPosition": [
+      -9.89065312508715
+    ],
+    "targetVelocity": [
+      6.43202260966343
+    ],
+    "targetAcceleration": [
+      -5.360666329316392
+    ],
+    "maxVelocity": [
+      7.368939717441596
+    ],
+    "maxAcceleration": [
+      5.489843606236783
+    ],
+    "maxJerk": [
+      16.945031688676348
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.698690439920228
+    ],
+    "currentVelocity": [
+      1.001970544187448
+    ],
+    "currentAcceleration": [
+      -3.3038194877168365
+    ],
+    "targetPosition": [
+      8.483603351389817
+    ],
+    "targetVelocity": [
+      -3.4303235999073145
+    ],
+    "targetAcceleration": [
+      2.104907761273755
+    ],
+    "maxVelocity": [
+      5.194291215461113
+    ],
+    "maxAcceleration": [
+      3.8830798064212475
+    ],
+    "maxJerk": [
+      15.291478513711033
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.988921328923661
+    ],
+    "currentVelocity": [
+      -2.0272652009906396
+    ],
+    "currentAcceleration": [
+      3.6670439072226007
+    ],
+    "targetPosition": [
+      -8.425040055983668
+    ],
+    "targetVelocity": [
+      -2.3192659302181227
+    ],
+    "targetAcceleration": [
+      1.6998408704820047
+    ],
+    "maxVelocity": [
+      4.7383222389995
+    ],
+    "maxAcceleration": [
+      9.557761636722677
+    ],
+    "maxJerk": [
+      11.667472310648911
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.649224159897434
+    ],
+    "currentVelocity": [
+      4.947066685960637
+    ],
+    "currentAcceleration": [
+      -4.195234411983613
+    ],
+    "targetPosition": [
+      -5.9371895191809205
+    ],
+    "targetVelocity": [
+      6.185304834659274
+    ],
+    "targetAcceleration": [
+      -1.1132530616874217
+    ],
+    "maxVelocity": [
+      7.40873603361463
+    ],
+    "maxAcceleration": [
+      8.109838392870637
+    ],
+    "maxJerk": [
+      18.21949952083861
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.2242897613788015
+    ],
+    "currentVelocity": [
+      -1.9280675106420584
+    ],
+    "currentAcceleration": [
+      2.8170031439754863
+    ],
+    "targetPosition": [
+      -8.738558429993207
+    ],
+    "targetVelocity": [
+      0.5493528420614506
+    ],
+    "targetAcceleration": [
+      -3.5195213317038734
+    ],
+    "maxVelocity": [
+      2.004092196433316
+    ],
+    "maxAcceleration": [
+      4.601681951458907
+    ],
+    "maxJerk": [
+      18.47337622780851
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.476564620091578
+    ],
+    "currentVelocity": [
+      3.8248122195001404
+    ],
+    "currentAcceleration": [
+      -0.5429996886546911
+    ],
+    "targetPosition": [
+      0.8984698804226277
+    ],
+    "targetVelocity": [
+      3.909181293734811
+    ],
+    "targetAcceleration": [
+      1.5551667909832023
+    ],
+    "maxVelocity": [
+      6.382348599616522
+    ],
+    "maxAcceleration": [
+      3.121475293537112
+    ],
+    "maxJerk": [
+      13.4031013260281
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.6138445111074535
+    ],
+    "currentVelocity": [
+      3.6947519595601808
+    ],
+    "currentAcceleration": [
+      -2.157615133971189
+    ],
+    "targetPosition": [
+      6.049421510212948
+    ],
+    "targetVelocity": [
+      7.210199336538857
+    ],
+    "targetAcceleration": [
+      2.219706057049499
+    ],
+    "maxVelocity": [
+      7.296796847858914
+    ],
+    "maxAcceleration": [
+      3.1966465447543353
+    ],
+    "maxJerk": [
+      7.870506761782006
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.321022613688449
+    ],
+    "currentVelocity": [
+      -1.4900223692830608
+    ],
+    "currentAcceleration": [
+      0.5550920146585918
+    ],
+    "targetPosition": [
+      -7.011273038875691
+    ],
+    "targetVelocity": [
+      1.5281797035970044
+    ],
+    "targetAcceleration": [
+      -4.963460703820193
+    ],
+    "maxVelocity": [
+      7.284808206253487
+    ],
+    "maxAcceleration": [
+      7.908063175193706
+    ],
+    "maxJerk": [
+      16.013281646981277
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6614879352125627
+    ],
+    "currentVelocity": [
+      0.3184735283360771
+    ],
+    "currentAcceleration": [
+      4.485333692593267
+    ],
+    "targetPosition": [
+      1.432766781389926
+    ],
+    "targetVelocity": [
+      0.9380704503065131
+    ],
+    "targetAcceleration": [
+      1.2348595862756806
+    ],
+    "maxVelocity": [
+      3.4033679984524254
+    ],
+    "maxAcceleration": [
+      6.912093133516857
+    ],
+    "maxJerk": [
+      11.59049044684104
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.203006239630305
+    ],
+    "currentVelocity": [
+      1.9338146307284028
+    ],
+    "currentAcceleration": [
+      -2.298676607413152
+    ],
+    "targetPosition": [
+      -0.9955804659524521
+    ],
+    "targetVelocity": [
+      -1.1996654963356286
+    ],
+    "targetAcceleration": [
+      4.294681598997764
+    ],
+    "maxVelocity": [
+      2.7417661566128384
+    ],
+    "maxAcceleration": [
+      8.997350910477602
+    ],
+    "maxJerk": [
+      15.67733288631174
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.764174151627614
+    ],
+    "currentVelocity": [
+      1.5472795635770433
+    ],
+    "currentAcceleration": [
+      -4.227820375080984
+    ],
+    "targetPosition": [
+      7.009685765347967
+    ],
+    "targetVelocity": [
+      -2.126812651409077
+    ],
+    "targetAcceleration": [
+      2.9910469302311204
+    ],
+    "maxVelocity": [
+      3.11515472695861
+    ],
+    "maxAcceleration": [
+      7.73362907573851
+    ],
+    "maxJerk": [
+      8.03544255778216
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.221037470187955
+    ],
+    "currentVelocity": [
+      -3.5640648026007478
+    ],
+    "currentAcceleration": [
+      -0.5571209817747409
+    ],
+    "targetPosition": [
+      -1.9899005193073656
+    ],
+    "targetVelocity": [
+      -3.9834043000607235
+    ],
+    "targetAcceleration": [
+      -4.948750118395609
+    ],
+    "maxVelocity": [
+      6.125219663511198
+    ],
+    "maxAcceleration": [
+      6.986514391518595
+    ],
+    "maxJerk": [
+      19.051579421474006
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.454475820220072
+    ],
+    "currentVelocity": [
+      1.6511229699462087
+    ],
+    "currentAcceleration": [
+      3.319167162038868
+    ],
+    "targetPosition": [
+      -0.8419368571848995
+    ],
+    "targetVelocity": [
+      2.338602385767264
+    ],
+    "targetAcceleration": [
+      -0.18867597133549907
+    ],
+    "maxVelocity": [
+      2.546713517874065
+    ],
+    "maxAcceleration": [
+      8.285251500143236
+    ],
+    "maxJerk": [
+      14.777238602302281
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.3974044502696525
+    ],
+    "currentVelocity": [
+      0.669666239566383
+    ],
+    "currentAcceleration": [
+      -5.019300387672736
+    ],
+    "targetPosition": [
+      8.247627133735012
+    ],
+    "targetVelocity": [
+      -1.4223205249695794
+    ],
+    "targetAcceleration": [
+      -3.1012043675096566
+    ],
+    "maxVelocity": [
+      2.0756821388572595
+    ],
+    "maxAcceleration": [
+      7.999900710333513
+    ],
+    "maxJerk": [
+      17.46824490025507
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.40872078048184
+    ],
+    "currentVelocity": [
+      -1.5209632718948995
+    ],
+    "currentAcceleration": [
+      -2.8636827721567517
+    ],
+    "targetPosition": [
+      4.815213490858312
+    ],
+    "targetVelocity": [
+      2.2394493428135585
+    ],
+    "targetAcceleration": [
+      1.3981913721154111
+    ],
+    "maxVelocity": [
+      6.4218503170859735
+    ],
+    "maxAcceleration": [
+      6.124175471844947
+    ],
+    "maxJerk": [
+      9.334987466298806
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.200055012205328
+    ],
+    "currentVelocity": [
+      2.5158602244774846
+    ],
+    "currentAcceleration": [
+      1.5987445268559268
+    ],
+    "targetPosition": [
+      -7.68977498314765
+    ],
+    "targetVelocity": [
+      -3.6614860862214145
+    ],
+    "targetAcceleration": [
+      3.5643486892332685
+    ],
+    "maxVelocity": [
+      6.728968789844276
+    ],
+    "maxAcceleration": [
+      4.44762457511689
+    ],
+    "maxJerk": [
+      9.384807428765528
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.0489310465415596
+    ],
+    "currentVelocity": [
+      -0.03805285055374519
+    ],
+    "currentAcceleration": [
+      -5.551125608275054
+    ],
+    "targetPosition": [
+      1.310867294108796
+    ],
+    "targetVelocity": [
+      -0.7103476899882644
+    ],
+    "targetAcceleration": [
+      -4.042652579275014
+    ],
+    "maxVelocity": [
+      5.282195190615351
+    ],
+    "maxAcceleration": [
+      6.755061410644766
+    ],
+    "maxJerk": [
+      10.523846845431317
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.131041306254865
+    ],
+    "currentVelocity": [
+      2.2794994261229555
+    ],
+    "currentAcceleration": [
+      2.982451094493368
+    ],
+    "targetPosition": [
+      3.82622389727044
+    ],
+    "targetVelocity": [
+      2.5233669055197177
+    ],
+    "targetAcceleration": [
+      -2.4578308470670476
+    ],
+    "maxVelocity": [
+      3.363890546198269
+    ],
+    "maxAcceleration": [
+      3.55989023629017
+    ],
+    "maxJerk": [
+      13.159465270610394
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.090740416463156
+    ],
+    "currentVelocity": [
+      -0.595750681606289
+    ],
+    "currentAcceleration": [
+      -1.8835045818305334
+    ],
+    "targetPosition": [
+      6.321830057015269
+    ],
+    "targetVelocity": [
+      0.7100843592651489
+    ],
+    "targetAcceleration": [
+      4.345013963849198
+    ],
+    "maxVelocity": [
+      2.811245471136874
+    ],
+    "maxAcceleration": [
+      5.467595558706417
+    ],
+    "maxJerk": [
+      5.592699084670565
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.968400950739378
+    ],
+    "currentVelocity": [
+      -4.65256454884554
+    ],
+    "currentAcceleration": [
+      -5.564388840222257
+    ],
+    "targetPosition": [
+      -6.419770866479886
+    ],
+    "targetVelocity": [
+      -4.40756501837119
+    ],
+    "targetAcceleration": [
+      -4.0530256485204745
+    ],
+    "maxVelocity": [
+      7.259708402023428
+    ],
+    "maxAcceleration": [
+      7.226535267888332
+    ],
+    "maxJerk": [
+      13.808088940160571
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.2667054939443645
+    ],
+    "currentVelocity": [
+      7.085305091045588
+    ],
+    "currentAcceleration": [
+      -7.131141121755369
+    ],
+    "targetPosition": [
+      -3.2185605399331347
+    ],
+    "targetVelocity": [
+      -5.779084867644367
+    ],
+    "targetAcceleration": [
+      -8.33696038570135
+    ],
+    "maxVelocity": [
+      7.629856369680039
+    ],
+    "maxAcceleration": [
+      8.65602596697708
+    ],
+    "maxJerk": [
+      6.338190988014053
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.698220300748188
+    ],
+    "currentVelocity": [
+      -1.6360713978188937
+    ],
+    "currentAcceleration": [
+      -4.48201454368299
+    ],
+    "targetPosition": [
+      -7.527734994201333
+    ],
+    "targetVelocity": [
+      -1.395049339492962
+    ],
+    "targetAcceleration": [
+      -2.5901734687229787
+    ],
+    "maxVelocity": [
+      5.706643189067178
+    ],
+    "maxAcceleration": [
+      4.980901907379286
+    ],
+    "maxJerk": [
+      12.381745104790483
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.1295749739468182
+    ],
+    "currentVelocity": [
+      -2.476454344287921
+    ],
+    "currentAcceleration": [
+      -1.5064114274051787
+    ],
+    "targetPosition": [
+      8.239986472260256
+    ],
+    "targetVelocity": [
+      -0.6184872777703854
+    ],
+    "targetAcceleration": [
+      -0.4726334450363625
+    ],
+    "maxVelocity": [
+      3.326629369175829
+    ],
+    "maxAcceleration": [
+      8.023390799712487
+    ],
+    "maxJerk": [
+      10.483428641116152
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.005281520066383
+    ],
+    "currentVelocity": [
+      1.0976259084106794
+    ],
+    "currentAcceleration": [
+      0.19713235545783547
+    ],
+    "targetPosition": [
+      -2.8007540757429954
+    ],
+    "targetVelocity": [
+      -1.7368680781462362
+    ],
+    "targetAcceleration": [
+      -1.186503511042483
+    ],
+    "maxVelocity": [
+      3.6922205464334907
+    ],
+    "maxAcceleration": [
+      6.532432072029254
+    ],
+    "maxJerk": [
+      10.891726185089972
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.12500380595662897
+    ],
+    "currentVelocity": [
+      5.036806932609178
+    ],
+    "currentAcceleration": [
+      -5.35910871178357
+    ],
+    "targetPosition": [
+      -8.866502233412213
+    ],
+    "targetVelocity": [
+      3.1835778708822406
+    ],
+    "targetAcceleration": [
+      3.446297893458265
+    ],
+    "maxVelocity": [
+      7.057656921840691
+    ],
+    "maxAcceleration": [
+      5.6879422768756775
+    ],
+    "maxJerk": [
+      11.338475431473789
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.787945782698852
+    ],
+    "currentVelocity": [
+      4.235459132140696
+    ],
+    "currentAcceleration": [
+      -1.8421155210335232
+    ],
+    "targetPosition": [
+      5.363984423480122
+    ],
+    "targetVelocity": [
+      -0.3185097902148577
+    ],
+    "targetAcceleration": [
+      0.28140584338265384
+    ],
+    "maxVelocity": [
+      5.643766086897396
+    ],
+    "maxAcceleration": [
+      4.260486472731323
+    ],
+    "maxJerk": [
+      17.85954209877137
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.12271178387686
+    ],
+    "currentVelocity": [
+      3.673877683751172
+    ],
+    "currentAcceleration": [
+      5.297766158644292
+    ],
+    "targetPosition": [
+      -5.2171672816371135
+    ],
+    "targetVelocity": [
+      4.479513596162622
+    ],
+    "targetAcceleration": [
+      -2.9204302782317426
+    ],
+    "maxVelocity": [
+      5.122661360405422
+    ],
+    "maxAcceleration": [
+      5.475793110826011
+    ],
+    "maxJerk": [
+      19.044197835081672
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.4866836324623858
+    ],
+    "currentVelocity": [
+      -1.3540971748772486
+    ],
+    "currentAcceleration": [
+      -0.6411243326841247
+    ],
+    "targetPosition": [
+      -7.986954532500297
+    ],
+    "targetVelocity": [
+      2.5431625589520888
+    ],
+    "targetAcceleration": [
+      -3.283939503800859
+    ],
+    "maxVelocity": [
+      5.2921030225107115
+    ],
+    "maxAcceleration": [
+      4.045488745961733
+    ],
+    "maxJerk": [
+      10.570661244398876
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.297538687565019
+    ],
+    "currentVelocity": [
+      1.631390071812767
+    ],
+    "currentAcceleration": [
+      -2.439699541297084
+    ],
+    "targetPosition": [
+      8.467862785375196
+    ],
+    "targetVelocity": [
+      5.92647024275378
+    ],
+    "targetAcceleration": [
+      -1.1710323980260702
+    ],
+    "maxVelocity": [
+      7.824894651311183
+    ],
+    "maxAcceleration": [
+      3.2803792967954384
+    ],
+    "maxJerk": [
+      14.506973640585331
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6927012034200981
+    ],
+    "currentVelocity": [
+      -2.4047981935678937
+    ],
+    "currentAcceleration": [
+      -6.2038003126792525
+    ],
+    "targetPosition": [
+      -6.944374797135497
+    ],
+    "targetVelocity": [
+      4.516212688753463
+    ],
+    "targetAcceleration": [
+      -1.0832009211666325
+    ],
+    "maxVelocity": [
+      7.41266772967179
+    ],
+    "maxAcceleration": [
+      6.847164837520294
+    ],
+    "maxJerk": [
+      5.21477347639761
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.6328819310862404
+    ],
+    "currentVelocity": [
+      -4.224292542262056
+    ],
+    "currentAcceleration": [
+      3.89414195671449
+    ],
+    "targetPosition": [
+      7.161618325522021
+    ],
+    "targetVelocity": [
+      1.84500782857641
+    ],
+    "targetAcceleration": [
+      4.332655266719367
+    ],
+    "maxVelocity": [
+      5.0508034572971745
+    ],
+    "maxAcceleration": [
+      4.941319961471498
+    ],
+    "maxJerk": [
+      8.207408213757173
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.784628859327492
+    ],
+    "currentVelocity": [
+      4.142391904667721
+    ],
+    "currentAcceleration": [
+      -0.4068264001317097
+    ],
+    "targetPosition": [
+      9.348078798188716
+    ],
+    "targetVelocity": [
+      5.954529827053219
+    ],
+    "targetAcceleration": [
+      -0.6193072002689188
+    ],
+    "maxVelocity": [
+      7.331441762667038
+    ],
+    "maxAcceleration": [
+      8.811385323626451
+    ],
+    "maxJerk": [
+      19.47383301122646
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.114096892510389
+    ],
+    "currentVelocity": [
+      -0.7943591245504296
+    ],
+    "currentAcceleration": [
+      4.3529898081871226
+    ],
+    "targetPosition": [
+      5.763989963728681
+    ],
+    "targetVelocity": [
+      -5.274178012196674
+    ],
+    "targetAcceleration": [
+      4.7934780677965305
+    ],
+    "maxVelocity": [
+      7.433267899306868
+    ],
+    "maxAcceleration": [
+      7.59994387356575
+    ],
+    "maxJerk": [
+      10.56568467815401
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.3621644083341806
+    ],
+    "currentVelocity": [
+      4.0238788170605835
+    ],
+    "currentAcceleration": [
+      1.8684829445259865
+    ],
+    "targetPosition": [
+      3.0589230663317046
+    ],
+    "targetVelocity": [
+      -2.390048156898186
+    ],
+    "targetAcceleration": [
+      -3.4082995305829735
+    ],
+    "maxVelocity": [
+      7.660457146178403
+    ],
+    "maxAcceleration": [
+      7.605103738970817
+    ],
+    "maxJerk": [
+      11.457697916679706
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.95398007787834
+    ],
+    "currentVelocity": [
+      0.39554609031881993
+    ],
+    "currentAcceleration": [
+      3.593638926467338
+    ],
+    "targetPosition": [
+      6.276699066157768
+    ],
+    "targetVelocity": [
+      0.3936176037758714
+    ],
+    "targetAcceleration": [
+      3.6522289180208594
+    ],
+    "maxVelocity": [
+      2.7436140510653955
+    ],
+    "maxAcceleration": [
+      3.87411159066803
+    ],
+    "maxJerk": [
+      12.281045205684887
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.43841333860199
+    ],
+    "currentVelocity": [
+      -2.2262269874088174
+    ],
+    "currentAcceleration": [
+      3.398746998792748
+    ],
+    "targetPosition": [
+      6.606594678008442
+    ],
+    "targetVelocity": [
+      -3.570353099100774
+    ],
+    "targetAcceleration": [
+      -1.6657227114169952
+    ],
+    "maxVelocity": [
+      7.227525909292251
+    ],
+    "maxAcceleration": [
+      7.641355689181112
+    ],
+    "maxJerk": [
+      10.122932449350824
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.848145482832422
+    ],
+    "currentVelocity": [
+      -2.1890338941274905
+    ],
+    "currentAcceleration": [
+      1.2763083241864832
+    ],
+    "targetPosition": [
+      5.436089658269045
+    ],
+    "targetVelocity": [
+      -0.8006940969350187
+    ],
+    "targetAcceleration": [
+      4.548044524053447
+    ],
+    "maxVelocity": [
+      2.7710689094880046
+    ],
+    "maxAcceleration": [
+      5.20927857601956
+    ],
+    "maxJerk": [
+      12.654842133972295
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.794793517535915
+    ],
+    "currentVelocity": [
+      -0.7034683454858941
+    ],
+    "currentAcceleration": [
+      3.849842418685264
+    ],
+    "targetPosition": [
+      7.213963312197006
+    ],
+    "targetVelocity": [
+      -0.5108767513483201
+    ],
+    "targetAcceleration": [
+      3.790418816707313
+    ],
+    "maxVelocity": [
+      4.782654449790507
+    ],
+    "maxAcceleration": [
+      6.056789659821397
+    ],
+    "maxJerk": [
+      9.007068990794515
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.8033136423055893
+    ],
+    "currentVelocity": [
+      0.6729061306363961
+    ],
+    "currentAcceleration": [
+      1.699900069458974
+    ],
+    "targetPosition": [
+      6.648844327604692
+    ],
+    "targetVelocity": [
+      0.4648277620188854
+    ],
+    "targetAcceleration": [
+      -0.49070959197669595
+    ],
+    "maxVelocity": [
+      3.5159530314223097
+    ],
+    "maxAcceleration": [
+      5.11822872357457
+    ],
+    "maxJerk": [
+      9.297184469326362
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.9415301568453476
+    ],
+    "currentVelocity": [
+      6.375107026375663
+    ],
+    "currentAcceleration": [
+      0.8634614664766236
+    ],
+    "targetPosition": [
+      5.956343231896561
+    ],
+    "targetVelocity": [
+      2.3387566712200814
+    ],
+    "targetAcceleration": [
+      2.250958480924349
+    ],
+    "maxVelocity": [
+      7.638011796911349
+    ],
+    "maxAcceleration": [
+      5.319198460954683
+    ],
+    "maxJerk": [
+      15.978115047803069
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.8631618832615775
+    ],
+    "currentVelocity": [
+      5.026816962916573
+    ],
+    "currentAcceleration": [
+      -1.742927595491592
+    ],
+    "targetPosition": [
+      3.962675182745576
+    ],
+    "targetVelocity": [
+      -1.748413230432024
+    ],
+    "targetAcceleration": [
+      -5.485438732924267
+    ],
+    "maxVelocity": [
+      5.991076303462357
+    ],
+    "maxAcceleration": [
+      9.913954897441554
+    ],
+    "maxJerk": [
+      14.883701050626815
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.319235507767269
+    ],
+    "currentVelocity": [
+      -1.2438069126872735
+    ],
+    "currentAcceleration": [
+      5.381450341178295
+    ],
+    "targetPosition": [
+      -6.417037843182425
+    ],
+    "targetVelocity": [
+      0.8353115006695195
+    ],
+    "targetAcceleration": [
+      -3.3891881950161737
+    ],
+    "maxVelocity": [
+      2.117893477572766
+    ],
+    "maxAcceleration": [
+      7.824458342010437
+    ],
+    "maxJerk": [
+      13.178821891956453
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.8504242730542231
+    ],
+    "currentVelocity": [
+      -4.9890411030592
+    ],
+    "currentAcceleration": [
+      3.4706935492871827
+    ],
+    "targetPosition": [
+      -4.703878456808046
+    ],
+    "targetVelocity": [
+      0.7902654077897626
+    ],
+    "targetAcceleration": [
+      0.2763096069795523
+    ],
+    "maxVelocity": [
+      6.369908476898676
+    ],
+    "maxAcceleration": [
+      4.538936093736617
+    ],
+    "maxJerk": [
+      16.78384611026668
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.439400148139693
+    ],
+    "currentVelocity": [
+      0.7662639784148193
+    ],
+    "currentAcceleration": [
+      2.1945987764940087
+    ],
+    "targetPosition": [
+      0.4726098775756391
+    ],
+    "targetVelocity": [
+      -0.8902311700352021
+    ],
+    "targetAcceleration": [
+      2.6492388557039144
+    ],
+    "maxVelocity": [
+      2.6275392713464445
+    ],
+    "maxAcceleration": [
+      6.05863249883818
+    ],
+    "maxJerk": [
+      15.530706519072217
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.377307637989716
+    ],
+    "currentVelocity": [
+      2.206733179715439
+    ],
+    "currentAcceleration": [
+      -5.9771124298762075
+    ],
+    "targetPosition": [
+      8.586975305956138
+    ],
+    "targetVelocity": [
+      0.30931121823330887
+    ],
+    "targetAcceleration": [
+      -5.0346903729594965
+    ],
+    "maxVelocity": [
+      5.035588242724057
+    ],
+    "maxAcceleration": [
+      6.959429003416854
+    ],
+    "maxJerk": [
+      10.16321503124741
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.765672144948745
+    ],
+    "currentVelocity": [
+      -6.856767000135595
+    ],
+    "currentAcceleration": [
+      6.310707052512878
+    ],
+    "targetPosition": [
+      2.552929864898024
+    ],
+    "targetVelocity": [
+      -1.982372950108668
+    ],
+    "targetAcceleration": [
+      7.228888908859844
+    ],
+    "maxVelocity": [
+      7.577085092732169
+    ],
+    "maxAcceleration": [
+      9.585659319995923
+    ],
+    "maxJerk": [
+      6.296332583120348
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.483893668399006
+    ],
+    "currentVelocity": [
+      3.6893215829814308
+    ],
+    "currentAcceleration": [
+      0.43353931490604225
+    ],
+    "targetPosition": [
+      -4.316138865244636
+    ],
+    "targetVelocity": [
+      -3.2887336519452046
+    ],
+    "targetAcceleration": [
+      -2.0614251247076307
+    ],
+    "maxVelocity": [
+      5.141727560585605
+    ],
+    "maxAcceleration": [
+      5.165881304181086
+    ],
+    "maxJerk": [
+      13.444426661463423
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.550985729040228
+    ],
+    "currentVelocity": [
+      0.5903062970213337
+    ],
+    "currentAcceleration": [
+      -1.2534756068429713
+    ],
+    "targetPosition": [
+      1.0948979438474087
+    ],
+    "targetVelocity": [
+      5.692480523177123
+    ],
+    "targetAcceleration": [
+      1.024952284100304
+    ],
+    "maxVelocity": [
+      7.925022032068391
+    ],
+    "maxAcceleration": [
+      3.5837029122010726
+    ],
+    "maxJerk": [
+      12.061308941839275
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7349339776613224
+    ],
+    "currentVelocity": [
+      -6.806865372641945
+    ],
+    "currentAcceleration": [
+      -3.2089281446827034
+    ],
+    "targetPosition": [
+      -6.517168619741565
+    ],
+    "targetVelocity": [
+      0.9010365529986988
+    ],
+    "targetAcceleration": [
+      -0.8455795561691906
+    ],
+    "maxVelocity": [
+      7.598104878596139
+    ],
+    "maxAcceleration": [
+      4.501085286993149
+    ],
+    "maxJerk": [
+      18.910202906314197
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.494396123680733
+    ],
+    "currentVelocity": [
+      -1.426050494910207
+    ],
+    "currentAcceleration": [
+      -1.6897681854855513
+    ],
+    "targetPosition": [
+      2.0295215159333413
+    ],
+    "targetVelocity": [
+      -4.537200231787854
+    ],
+    "targetAcceleration": [
+      -4.476817584836236
+    ],
+    "maxVelocity": [
+      5.324236571959322
+    ],
+    "maxAcceleration": [
+      9.920782267123087
+    ],
+    "maxJerk": [
+      16.180038276190345
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.6262693720287906
+    ],
+    "currentVelocity": [
+      -1.6367407967636582
+    ],
+    "currentAcceleration": [
+      -5.1677404017852755
+    ],
+    "targetPosition": [
+      -6.756871154749984
+    ],
+    "targetVelocity": [
+      0.4288443689715793
+    ],
+    "targetAcceleration": [
+      4.889173879305559
+    ],
+    "maxVelocity": [
+      6.05293681931834
+    ],
+    "maxAcceleration": [
+      7.44265254964652
+    ],
+    "maxJerk": [
+      10.055933244120832
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.861918420586088
+    ],
+    "currentVelocity": [
+      -5.451285433296647
+    ],
+    "currentAcceleration": [
+      -1.7070079215775285
+    ],
+    "targetPosition": [
+      2.5132029039272137
+    ],
+    "targetVelocity": [
+      -5.693375983395
+    ],
+    "targetAcceleration": [
+      -3.334679401273193
+    ],
+    "maxVelocity": [
+      6.373066097514802
+    ],
+    "maxAcceleration": [
+      4.603850544648661
+    ],
+    "maxJerk": [
+      12.576185083540288
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.222827587633315
+    ],
+    "currentVelocity": [
+      -4.6426767080619165
+    ],
+    "currentAcceleration": [
+      -3.402465779926186
+    ],
+    "targetPosition": [
+      6.1445790425182985
+    ],
+    "targetVelocity": [
+      -4.281887878052862
+    ],
+    "targetAcceleration": [
+      -3.127097161322952
+    ],
+    "maxVelocity": [
+      6.930234879452255
+    ],
+    "maxAcceleration": [
+      4.134114493809646
+    ],
+    "maxJerk": [
+      12.247097347619608
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.572333385887513
+    ],
+    "currentVelocity": [
+      -4.260773894328913
+    ],
+    "currentAcceleration": [
+      -1.9596771462027194
+    ],
+    "targetPosition": [
+      -5.08406797207585
+    ],
+    "targetVelocity": [
+      1.790485593794008
+    ],
+    "targetAcceleration": [
+      4.358502668402489
+    ],
+    "maxVelocity": [
+      4.490565360937264
+    ],
+    "maxAcceleration": [
+      8.99410022384142
+    ],
+    "maxJerk": [
+      15.73824580581447
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.372121081207271
+    ],
+    "currentVelocity": [
+      -0.08536008513637405
+    ],
+    "currentAcceleration": [
+      -3.2337900605385776
+    ],
+    "targetPosition": [
+      -0.07495948683142295
+    ],
+    "targetVelocity": [
+      1.80167667857219
+    ],
+    "targetAcceleration": [
+      -5.167450980783378
+    ],
+    "maxVelocity": [
+      6.460935300552294
+    ],
+    "maxAcceleration": [
+      6.771478244588277
+    ],
+    "maxJerk": [
+      11.390319759169774
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.106229883145776
+    ],
+    "currentVelocity": [
+      -1.4371723763237858
+    ],
+    "currentAcceleration": [
+      -2.6059976851868596
+    ],
+    "targetPosition": [
+      -0.05206571395206083
+    ],
+    "targetVelocity": [
+      -0.7574283999745108
+    ],
+    "targetAcceleration": [
+      0.5964640086288666
+    ],
+    "maxVelocity": [
+      3.130369862374363
+    ],
+    "maxAcceleration": [
+      4.704052422132425
+    ],
+    "maxJerk": [
+      17.34815709423802
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.459867868575742
+    ],
+    "currentVelocity": [
+      0.11905870974838617
+    ],
+    "currentAcceleration": [
+      -3.329449364882134
+    ],
+    "targetPosition": [
+      -2.697751348332174
+    ],
+    "targetVelocity": [
+      2.730138716502914
+    ],
+    "targetAcceleration": [
+      -3.2861370423080447
+    ],
+    "maxVelocity": [
+      7.447444896636487
+    ],
+    "maxAcceleration": [
+      6.17570275355429
+    ],
+    "maxJerk": [
+      15.387151030164066
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.254834439009539
+    ],
+    "currentVelocity": [
+      4.091816440081209
+    ],
+    "currentAcceleration": [
+      5.680634040567375
+    ],
+    "targetPosition": [
+      2.4983949003222623
+    ],
+    "targetVelocity": [
+      0.5883183153682907
+    ],
+    "targetAcceleration": [
+      -3.583784566614517
+    ],
+    "maxVelocity": [
+      6.1010184748540945
+    ],
+    "maxAcceleration": [
+      7.12879128636933
+    ],
+    "maxJerk": [
+      9.753164758493117
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.496205260838029
+    ],
+    "currentVelocity": [
+      1.4513992853692952
+    ],
+    "currentAcceleration": [
+      2.9794904209979522
+    ],
+    "targetPosition": [
+      -9.888226691810416
+    ],
+    "targetVelocity": [
+      0.5399225112229442
+    ],
+    "targetAcceleration": [
+      -4.465623147498878
+    ],
+    "maxVelocity": [
+      2.4673578017814686
+    ],
+    "maxAcceleration": [
+      7.548688321360932
+    ],
+    "maxJerk": [
+      7.777138726211219
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.354619655888903
+    ],
+    "currentVelocity": [
+      1.0849482901432017
+    ],
+    "currentAcceleration": [
+      -0.3965130469939666
+    ],
+    "targetPosition": [
+      -9.16450026939302
+    ],
+    "targetVelocity": [
+      -0.8202394676144498
+    ],
+    "targetAcceleration": [
+      2.324191333460954
+    ],
+    "maxVelocity": [
+      3.3519212331061095
+    ],
+    "maxAcceleration": [
+      9.990817694093483
+    ],
+    "maxJerk": [
+      19.560726176444902
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.484370511806084
+    ],
+    "currentVelocity": [
+      2.5765586966506078
+    ],
+    "currentAcceleration": [
+      -5.514718044615856
+    ],
+    "targetPosition": [
+      -0.6471148030940057
+    ],
+    "targetVelocity": [
+      0.8709108222248654
+    ],
+    "targetAcceleration": [
+      -1.7562057891900213
+    ],
+    "maxVelocity": [
+      4.015887794134961
+    ],
+    "maxAcceleration": [
+      5.9549812323885405
+    ],
+    "maxJerk": [
+      8.406615523774702
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.755030371607783
+    ],
+    "currentVelocity": [
+      -4.389153360960606
+    ],
+    "currentAcceleration": [
+      3.9634266078135756
+    ],
+    "targetPosition": [
+      8.914464581067534
+    ],
+    "targetVelocity": [
+      -3.772987969738357
+    ],
+    "targetAcceleration": [
+      0.20271435074083577
+    ],
+    "maxVelocity": [
+      5.108942371365233
+    ],
+    "maxAcceleration": [
+      8.379614220291064
+    ],
+    "maxJerk": [
+      14.53266575662337
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.1043380818406217
+    ],
+    "currentVelocity": [
+      -3.9623527156466958
+    ],
+    "currentAcceleration": [
+      -1.0054260499891177
+    ],
+    "targetPosition": [
+      -0.48958333264446985
+    ],
+    "targetVelocity": [
+      -3.627210772912451
+    ],
+    "targetAcceleration": [
+      -3.942081899179038
+    ],
+    "maxVelocity": [
+      5.74614761074742
+    ],
+    "maxAcceleration": [
+      5.032191052508673
+    ],
+    "maxJerk": [
+      16.41102133441295
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.451910224895329
+    ],
+    "currentVelocity": [
+      -0.7023770662447721
+    ],
+    "currentAcceleration": [
+      -3.5183349923771283
+    ],
+    "targetPosition": [
+      -3.6996701538696115
+    ],
+    "targetVelocity": [
+      0.20355337738769919
+    ],
+    "targetAcceleration": [
+      5.913187056611648
+    ],
+    "maxVelocity": [
+      2.8640522176307
+    ],
+    "maxAcceleration": [
+      9.109074123870574
+    ],
+    "maxJerk": [
+      13.91269073561425
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.382042675073475
+    ],
+    "currentVelocity": [
+      -2.395076620815016
+    ],
+    "currentAcceleration": [
+      0.09832212884064173
+    ],
+    "targetPosition": [
+      -5.025666461749809
+    ],
+    "targetVelocity": [
+      -2.1632486365314123
+    ],
+    "targetAcceleration": [
+      3.8645790319477404
+    ],
+    "maxVelocity": [
+      2.7460106677787914
+    ],
+    "maxAcceleration": [
+      6.277706573784292
+    ],
+    "maxJerk": [
+      13.054468548003962
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.660716065931382
+    ],
+    "currentVelocity": [
+      1.1660302660505906
+    ],
+    "currentAcceleration": [
+      1.22131114053889
+    ],
+    "targetPosition": [
+      5.202400576559496
+    ],
+    "targetVelocity": [
+      -2.690907959403714
+    ],
+    "targetAcceleration": [
+      2.6196693699975775
+    ],
+    "maxVelocity": [
+      4.237129013311716
+    ],
+    "maxAcceleration": [
+      5.47814135099267
+    ],
+    "maxJerk": [
+      8.719544203392248
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.858514606731152
+    ],
+    "currentVelocity": [
+      4.474801859419558
+    ],
+    "currentAcceleration": [
+      1.4478582074657367
+    ],
+    "targetPosition": [
+      -5.3031527562417775
+    ],
+    "targetVelocity": [
+      5.591054193312549
+    ],
+    "targetAcceleration": [
+      0.9341406267749126
+    ],
+    "maxVelocity": [
+      7.148860528001173
+    ],
+    "maxAcceleration": [
+      3.849875765797019
+    ],
+    "maxJerk": [
+      12.976179226374734
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.715658407084332
+    ],
+    "currentVelocity": [
+      -3.297099204312086
+    ],
+    "currentAcceleration": [
+      1.5853097216295975
+    ],
+    "targetPosition": [
+      -9.372733490254728
+    ],
+    "targetVelocity": [
+      -1.965295913679313
+    ],
+    "targetAcceleration": [
+      -3.775930835518192
+    ],
+    "maxVelocity": [
+      3.4524424401096807
+    ],
+    "maxAcceleration": [
+      8.113702819855758
+    ],
+    "maxJerk": [
+      5.379562559190084
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.557891330040128
+    ],
+    "currentVelocity": [
+      2.816007769798989
+    ],
+    "currentAcceleration": [
+      -8.036541946907196
+    ],
+    "targetPosition": [
+      -4.6853804001527894
+    ],
+    "targetVelocity": [
+      0.36287290780001413
+    ],
+    "targetAcceleration": [
+      -7.980509365429299
+    ],
+    "maxVelocity": [
+      3.872680783607481
+    ],
+    "maxAcceleration": [
+      8.20337427922498
+    ],
+    "maxJerk": [
+      12.799519771828482
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6392529328226288
+    ],
+    "currentVelocity": [
+      1.7815820404450315
+    ],
+    "currentAcceleration": [
+      -1.0718018419376403
+    ],
+    "targetPosition": [
+      -4.048923767049026
+    ],
+    "targetVelocity": [
+      1.79662009671104
+    ],
+    "targetAcceleration": [
+      3.0830138112639984
+    ],
+    "maxVelocity": [
+      3.284610621171682
+    ],
+    "maxAcceleration": [
+      6.847971235638245
+    ],
+    "maxJerk": [
+      9.797635195503094
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.828909620916264
+    ],
+    "currentVelocity": [
+      -4.309580282806381
+    ],
+    "currentAcceleration": [
+      3.034833213682652
+    ],
+    "targetPosition": [
+      5.851684853470211
+    ],
+    "targetVelocity": [
+      4.536711122429575
+    ],
+    "targetAcceleration": [
+      2.1371925833602576
+    ],
+    "maxVelocity": [
+      7.395580558188912
+    ],
+    "maxAcceleration": [
+      6.156500375700239
+    ],
+    "maxJerk": [
+      7.720723646919712
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.462068563592489
+    ],
+    "currentVelocity": [
+      -1.3612223434192785
+    ],
+    "currentAcceleration": [
+      -0.14510787748842136
+    ],
+    "targetPosition": [
+      -1.8383252286345542
+    ],
+    "targetVelocity": [
+      -2.5576473161098927
+    ],
+    "targetAcceleration": [
+      0.24329003349528344
+    ],
+    "maxVelocity": [
+      2.9243413915956524
+    ],
+    "maxAcceleration": [
+      3.419360920619883
+    ],
+    "maxJerk": [
+      8.18238118223754
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.113215793721843
+    ],
+    "currentVelocity": [
+      2.644413661552252
+    ],
+    "currentAcceleration": [
+      0.8256395298870496
+    ],
+    "targetPosition": [
+      8.461266603027077
+    ],
+    "targetVelocity": [
+      2.4002483006308406
+    ],
+    "targetAcceleration": [
+      -4.193261286936808
+    ],
+    "maxVelocity": [
+      3.8347379435735647
+    ],
+    "maxAcceleration": [
+      4.960950612979924
+    ],
+    "maxJerk": [
+      11.896215447791523
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.076291948684073
+    ],
+    "currentVelocity": [
+      -1.5870563467995966
+    ],
+    "currentAcceleration": [
+      -2.157111251185797
+    ],
+    "targetPosition": [
+      9.684533257579304
+    ],
+    "targetVelocity": [
+      2.169103169308288
+    ],
+    "targetAcceleration": [
+      -0.35122598722663856
+    ],
+    "maxVelocity": [
+      2.257412761396303
+    ],
+    "maxAcceleration": [
+      3.2855146976525194
+    ],
+    "maxJerk": [
+      12.07751566145002
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.056249354475778
+    ],
+    "currentVelocity": [
+      5.39435358823495
+    ],
+    "currentAcceleration": [
+      0.9622805385717434
+    ],
+    "targetPosition": [
+      0.17390730419563738
+    ],
+    "targetVelocity": [
+      2.3672220253224276
+    ],
+    "targetAcceleration": [
+      5.392034434048769
+    ],
+    "maxVelocity": [
+      6.879772665728233
+    ],
+    "maxAcceleration": [
+      9.241604847996504
+    ],
+    "maxJerk": [
+      18.653110923024457
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.0279744735390253
+    ],
+    "currentVelocity": [
+      -1.142194107846091
+    ],
+    "currentAcceleration": [
+      -4.466545285100694
+    ],
+    "targetPosition": [
+      -9.495062101435717
+    ],
+    "targetVelocity": [
+      -6.183228352778545
+    ],
+    "targetAcceleration": [
+      -1.8031733732571498
+    ],
+    "maxVelocity": [
+      6.703614742467054
+    ],
+    "maxAcceleration": [
+      6.091801242799837
+    ],
+    "maxJerk": [
+      7.660654816453404
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.915786338065796
+    ],
+    "currentVelocity": [
+      2.2969201481858335
+    ],
+    "currentAcceleration": [
+      -1.743625188795165
+    ],
+    "targetPosition": [
+      4.048785112933327
+    ],
+    "targetVelocity": [
+      0.6311568804231031
+    ],
+    "targetAcceleration": [
+      -3.418566557067217
+    ],
+    "maxVelocity": [
+      2.338221876392674
+    ],
+    "maxAcceleration": [
+      5.694554149248484
+    ],
+    "maxJerk": [
+      18.29983323236462
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.271189363718854
+    ],
+    "currentVelocity": [
+      1.3538843433581826
+    ],
+    "currentAcceleration": [
+      -3.6949049878296654
+    ],
+    "targetPosition": [
+      3.4936150243586095
+    ],
+    "targetVelocity": [
+      5.437368301471693
+    ],
+    "targetAcceleration": [
+      0.7470662679856526
+    ],
+    "maxVelocity": [
+      6.324960918972845
+    ],
+    "maxAcceleration": [
+      7.731663988020922
+    ],
+    "maxJerk": [
+      5.581232358764735
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.56871421080951
+    ],
+    "currentVelocity": [
+      3.026813199788145
+    ],
+    "currentAcceleration": [
+      -0.7024548135829907
+    ],
+    "targetPosition": [
+      0.7275853654483662
+    ],
+    "targetVelocity": [
+      -6.256895160174331
+    ],
+    "targetAcceleration": [
+      1.1584586232794543
+    ],
+    "maxVelocity": [
+      6.399147230618259
+    ],
+    "maxAcceleration": [
+      9.188009723049756
+    ],
+    "maxJerk": [
+      8.502993128360142
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.087243002116704
+    ],
+    "currentVelocity": [
+      -1.173310335564902
+    ],
+    "currentAcceleration": [
+      4.121348205908301
+    ],
+    "targetPosition": [
+      9.943767834578747
+    ],
+    "targetVelocity": [
+      -1.4613384234249303
+    ],
+    "targetAcceleration": [
+      4.388200469594844
+    ],
+    "maxVelocity": [
+      6.480040673728929
+    ],
+    "maxAcceleration": [
+      5.077703345679341
+    ],
+    "maxJerk": [
+      13.211040342644642
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.7109700244790202
+    ],
+    "currentVelocity": [
+      -1.9450861712616916
+    ],
+    "currentAcceleration": [
+      1.8309475376426327
+    ],
+    "targetPosition": [
+      -3.0347275418832993
+    ],
+    "targetVelocity": [
+      -1.3436837183305115
+    ],
+    "targetAcceleration": [
+      -3.1700217828229698
+    ],
+    "maxVelocity": [
+      3.53261564773905
+    ],
+    "maxAcceleration": [
+      5.318109099145518
+    ],
+    "maxJerk": [
+      11.240844105005763
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.249276377910304
+    ],
+    "currentVelocity": [
+      0.09889600475202265
+    ],
+    "currentAcceleration": [
+      -1.380952324305527
+    ],
+    "targetPosition": [
+      -3.0789385293111344
+    ],
+    "targetVelocity": [
+      -2.232848801970847
+    ],
+    "targetAcceleration": [
+      0.7409626150948538
+    ],
+    "maxVelocity": [
+      7.440823699526502
+    ],
+    "maxAcceleration": [
+      3.898978331391242
+    ],
+    "maxJerk": [
+      5.1542648235503705
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.870727083164354
+    ],
+    "currentVelocity": [
+      3.751619211865175
+    ],
+    "currentAcceleration": [
+      4.35466732012573
+    ],
+    "targetPosition": [
+      6.210935762550196
+    ],
+    "targetVelocity": [
+      1.6752577389073666
+    ],
+    "targetAcceleration": [
+      -1.512224384721824
+    ],
+    "maxVelocity": [
+      7.883149616709036
+    ],
+    "maxAcceleration": [
+      7.23107199997149
+    ],
+    "maxJerk": [
+      14.215959109586368
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.2498042593064902
+    ],
+    "currentVelocity": [
+      2.9336105487895177
+    ],
+    "currentAcceleration": [
+      2.4235510720964903
+    ],
+    "targetPosition": [
+      9.076920523915067
+    ],
+    "targetVelocity": [
+      -0.0184517150711887
+    ],
+    "targetAcceleration": [
+      4.032968207320499
+    ],
+    "maxVelocity": [
+      3.268174582878877
+    ],
+    "maxAcceleration": [
+      8.581605450545512
+    ],
+    "maxJerk": [
+      14.502238542811526
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.6748761846860436
+    ],
+    "currentVelocity": [
+      2.9895384405916126
+    ],
+    "currentAcceleration": [
+      3.979789911195505
+    ],
+    "targetPosition": [
+      3.1794697041373805
+    ],
+    "targetVelocity": [
+      -3.2018598218100407
+    ],
+    "targetAcceleration": [
+      -1.6837747762917594
+    ],
+    "maxVelocity": [
+      5.669755373593285
+    ],
+    "maxAcceleration": [
+      8.081434967473369
+    ],
+    "maxJerk": [
+      5.85150013950976
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.884290407141563
+    ],
+    "currentVelocity": [
+      -0.7225106218558768
+    ],
+    "currentAcceleration": [
+      3.2349317046649935
+    ],
+    "targetPosition": [
+      -9.547543676682375
+    ],
+    "targetVelocity": [
+      -0.13155152188091357
+    ],
+    "targetAcceleration": [
+      0.17822518376065055
+    ],
+    "maxVelocity": [
+      2.5178532539632754
+    ],
+    "maxAcceleration": [
+      3.5083531141201023
+    ],
+    "maxJerk": [
+      10.449500401776692
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.49902858408971085
+    ],
+    "currentVelocity": [
+      -1.894526119875405
+    ],
+    "currentAcceleration": [
+      4.698115331607749
+    ],
+    "targetPosition": [
+      1.5605347667210516
+    ],
+    "targetVelocity": [
+      -1.8920723963134565
+    ],
+    "targetAcceleration": [
+      4.096442621834923
+    ],
+    "maxVelocity": [
+      4.598464939495545
+    ],
+    "maxAcceleration": [
+      5.332428107462363
+    ],
+    "maxJerk": [
+      19.1899913490315
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.11859093153467
+    ],
+    "currentVelocity": [
+      -3.391329707664946
+    ],
+    "currentAcceleration": [
+      -0.6417338502863683
+    ],
+    "targetPosition": [
+      -2.998842289090831
+    ],
+    "targetVelocity": [
+      1.0299099418776758
+    ],
+    "targetAcceleration": [
+      2.577671148031742
+    ],
+    "maxVelocity": [
+      3.7163624497844725
+    ],
+    "maxAcceleration": [
+      3.742932528308887
+    ],
+    "maxJerk": [
+      7.863854295594988
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.510885621186489
+    ],
+    "currentVelocity": [
+      -2.253923082358426
+    ],
+    "currentAcceleration": [
+      4.235436289516123
+    ],
+    "targetPosition": [
+      2.9939071685132284
+    ],
+    "targetVelocity": [
+      -3.453829263230928
+    ],
+    "targetAcceleration": [
+      -2.0827832949900267
+    ],
+    "maxVelocity": [
+      7.059007087471478
+    ],
+    "maxAcceleration": [
+      4.839176736689641
+    ],
+    "maxJerk": [
+      16.04599781821088
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.220581645816032
+    ],
+    "currentVelocity": [
+      -6.378445985656157
+    ],
+    "currentAcceleration": [
+      1.7629457525455212
+    ],
+    "targetPosition": [
+      -4.528579072392176
+    ],
+    "targetVelocity": [
+      -6.104030101064666
+    ],
+    "targetAcceleration": [
+      4.483794449085375
+    ],
+    "maxVelocity": [
+      7.628105540075202
+    ],
+    "maxAcceleration": [
+      5.866543659324336
+    ],
+    "maxJerk": [
+      10.375274384883994
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7086344748791387
+    ],
+    "currentVelocity": [
+      -2.0602935073276645
+    ],
+    "currentAcceleration": [
+      -4.172751639507067
+    ],
+    "targetPosition": [
+      0.5871743285449345
+    ],
+    "targetVelocity": [
+      -0.06547046872460527
+    ],
+    "targetAcceleration": [
+      -2.617625921567724
+    ],
+    "maxVelocity": [
+      4.378428321313246
+    ],
+    "maxAcceleration": [
+      5.787307602714021
+    ],
+    "maxJerk": [
+      14.807882017584165
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.2278769476675357
+    ],
+    "currentVelocity": [
+      -3.9371351876800658
+    ],
+    "currentAcceleration": [
+      0.2788240667591717
+    ],
+    "targetPosition": [
+      -3.7757656679821654
+    ],
+    "targetVelocity": [
+      -1.1768498216973455
+    ],
+    "targetAcceleration": [
+      3.995017142262763
+    ],
+    "maxVelocity": [
+      5.130810685804196
+    ],
+    "maxAcceleration": [
+      4.549827627242439
+    ],
+    "maxJerk": [
+      12.63770664851048
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.318510480180915
+    ],
+    "currentVelocity": [
+      3.604506524409085
+    ],
+    "currentAcceleration": [
+      -3.9689041671465843
+    ],
+    "targetPosition": [
+      6.3281313045239145
+    ],
+    "targetVelocity": [
+      0.8775665430893671
+    ],
+    "targetAcceleration": [
+      3.2572866169576624
+    ],
+    "maxVelocity": [
+      4.479306039125139
+    ],
+    "maxAcceleration": [
+      4.42947615999749
+    ],
+    "maxJerk": [
+      12.641023958375104
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.623232930728694
+    ],
+    "currentVelocity": [
+      -4.164986297604697
+    ],
+    "currentAcceleration": [
+      -0.15729280504259702
+    ],
+    "targetPosition": [
+      -5.570748525986096
+    ],
+    "targetVelocity": [
+      -5.02250269683251
+    ],
+    "targetAcceleration": [
+      0.13050142782109742
+    ],
+    "maxVelocity": [
+      6.577109684113431
+    ],
+    "maxAcceleration": [
+      7.30827897571555
+    ],
+    "maxJerk": [
+      16.8633631380745
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.53700902288668
+    ],
+    "currentVelocity": [
+      0.8527125601850964
+    ],
+    "currentAcceleration": [
+      -2.445076664931225
+    ],
+    "targetPosition": [
+      -3.6410569581945023
+    ],
+    "targetVelocity": [
+      1.0479665124356385
+    ],
+    "targetAcceleration": [
+      5.927840188345523
+    ],
+    "maxVelocity": [
+      3.1277779553440874
+    ],
+    "maxAcceleration": [
+      7.6237114466225036
+    ],
+    "maxJerk": [
+      10.867409322339512
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.332257867809819
+    ],
+    "currentVelocity": [
+      2.5908449473289124
+    ],
+    "currentAcceleration": [
+      -5.610073995031472
+    ],
+    "targetPosition": [
+      6.4958269161457665
+    ],
+    "targetVelocity": [
+      -0.6581200352537633
+    ],
+    "targetAcceleration": [
+      -4.046191887169935
+    ],
+    "maxVelocity": [
+      2.821373225596154
+    ],
+    "maxAcceleration": [
+      5.865622176080391
+    ],
+    "maxJerk": [
+      9.85582243039765
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.541088738358912
+    ],
+    "currentVelocity": [
+      -0.19461783518321152
+    ],
+    "currentAcceleration": [
+      5.110189227650565
+    ],
+    "targetPosition": [
+      9.306593321560218
+    ],
+    "targetVelocity": [
+      4.676924488197573
+    ],
+    "targetAcceleration": [
+      1.186272618536643
+    ],
+    "maxVelocity": [
+      6.0103333237720715
+    ],
+    "maxAcceleration": [
+      9.786197825771477
+    ],
+    "maxJerk": [
+      7.135933041631638
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.394964589908277
+    ],
+    "currentVelocity": [
+      0.32605774071056715
+    ],
+    "currentAcceleration": [
+      1.8878762093762238
+    ],
+    "targetPosition": [
+      -7.330109001542747
+    ],
+    "targetVelocity": [
+      -3.3782973530331244
+    ],
+    "targetAcceleration": [
+      0.14210203202331462
+    ],
+    "maxVelocity": [
+      7.313071801283714
+    ],
+    "maxAcceleration": [
+      3.9514767357973475
+    ],
+    "maxJerk": [
+      9.672801785650439
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.389915609008096
+    ],
+    "currentVelocity": [
+      -2.6913839648520748
+    ],
+    "currentAcceleration": [
+      -2.017727569382762
+    ],
+    "targetPosition": [
+      -5.098190314253466
+    ],
+    "targetVelocity": [
+      -0.17978253885972295
+    ],
+    "targetAcceleration": [
+      -4.944866122210591
+    ],
+    "maxVelocity": [
+      2.9710807184567263
+    ],
+    "maxAcceleration": [
+      5.224063534818021
+    ],
+    "maxJerk": [
+      9.893914371247746
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.8734158751420846
+    ],
+    "currentVelocity": [
+      2.356789685740737
+    ],
+    "currentAcceleration": [
+      -3.638759872337814
+    ],
+    "targetPosition": [
+      -7.352136968618015
+    ],
+    "targetVelocity": [
+      -4.907540140759027
+    ],
+    "targetAcceleration": [
+      7.477065152681284
+    ],
+    "maxVelocity": [
+      7.34759231048733
+    ],
+    "maxAcceleration": [
+      9.777526865132316
+    ],
+    "maxJerk": [
+      19.249108982250128
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6131388535521758
+    ],
+    "currentVelocity": [
+      -3.7767599524861044
+    ],
+    "currentAcceleration": [
+      -4.85397394594895
+    ],
+    "targetPosition": [
+      5.241345341835244
+    ],
+    "targetVelocity": [
+      -1.6992107905580678
+    ],
+    "targetAcceleration": [
+      4.51236792085629
+    ],
+    "maxVelocity": [
+      7.111313213993746
+    ],
+    "maxAcceleration": [
+      5.464024584837611
+    ],
+    "maxJerk": [
+      10.476523815103336
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.0212763127276965
+    ],
+    "currentVelocity": [
+      -1.429465258044001
+    ],
+    "currentAcceleration": [
+      -0.13004392383856
+    ],
+    "targetPosition": [
+      5.8146081896085295
+    ],
+    "targetVelocity": [
+      2.917513519535693
+    ],
+    "targetAcceleration": [
+      4.323329845168978
+    ],
+    "maxVelocity": [
+      3.191143692725081
+    ],
+    "maxAcceleration": [
+      8.313752965464461
+    ],
+    "maxJerk": [
+      11.283436247588192
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7525915247311605
+    ],
+    "currentVelocity": [
+      1.1100827309096957
+    ],
+    "currentAcceleration": [
+      5.120589144554539
+    ],
+    "targetPosition": [
+      -5.424049273929173
+    ],
+    "targetVelocity": [
+      -1.735119070045653
+    ],
+    "targetAcceleration": [
+      -4.123853628288654
+    ],
+    "maxVelocity": [
+      5.220006069680202
+    ],
+    "maxAcceleration": [
+      6.119047915801565
+    ],
+    "maxJerk": [
+      15.65343428505484
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.5832746204919275
+    ],
+    "currentVelocity": [
+      -2.3430002077159218
+    ],
+    "currentAcceleration": [
+      -0.13594244945728828
+    ],
+    "targetPosition": [
+      -7.468618700111492
+    ],
+    "targetVelocity": [
+      1.2288210805066635
+    ],
+    "targetAcceleration": [
+      0.019277618475176617
+    ],
+    "maxVelocity": [
+      5.001258946102398
+    ],
+    "maxAcceleration": [
+      6.724209474960712
+    ],
+    "maxJerk": [
+      17.655558663141726
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0039012678670147
+    ],
+    "currentVelocity": [
+      -6.605822653890568
+    ],
+    "currentAcceleration": [
+      0.03987529292660774
+    ],
+    "targetPosition": [
+      6.158214152165616
+    ],
+    "targetVelocity": [
+      6.328086500467745
+    ],
+    "targetAcceleration": [
+      4.662664993137753
+    ],
+    "maxVelocity": [
+      7.270117182103067
+    ],
+    "maxAcceleration": [
+      5.125231416699938
+    ],
+    "maxJerk": [
+      14.610811502019484
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.9004072753349739
+    ],
+    "currentVelocity": [
+      3.839704678857087
+    ],
+    "currentAcceleration": [
+      0.8583871506938712
+    ],
+    "targetPosition": [
+      -6.72399115123657
+    ],
+    "targetVelocity": [
+      -1.2234222898164386
+    ],
+    "targetAcceleration": [
+      -3.9280785244336567
+    ],
+    "maxVelocity": [
+      7.738611594534447
+    ],
+    "maxAcceleration": [
+      5.101441671919986
+    ],
+    "maxJerk": [
+      19.373536558375058
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.095186724006865
+    ],
+    "currentVelocity": [
+      -3.462226552919107
+    ],
+    "currentAcceleration": [
+      3.6493598501301046
+    ],
+    "targetPosition": [
+      -0.6535889141310118
+    ],
+    "targetVelocity": [
+      -2.045603925823233
+    ],
+    "targetAcceleration": [
+      -2.9145968877234094
+    ],
+    "maxVelocity": [
+      4.68828790514062
+    ],
+    "maxAcceleration": [
+      6.199435175283132
+    ],
+    "maxJerk": [
+      16.303251501408553
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.037129094691272
+    ],
+    "currentVelocity": [
+      -0.10859338570378707
+    ],
+    "currentAcceleration": [
+      3.029751463951901
+    ],
+    "targetPosition": [
+      6.656086381037131
+    ],
+    "targetVelocity": [
+      -2.564918640926284
+    ],
+    "targetAcceleration": [
+      -2.05533171996881
+    ],
+    "maxVelocity": [
+      4.461026599525701
+    ],
+    "maxAcceleration": [
+      5.7155460162580125
+    ],
+    "maxJerk": [
+      9.859042026925518
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.699842406370703
+    ],
+    "currentVelocity": [
+      -0.3192413485683083
+    ],
+    "currentAcceleration": [
+      -4.056821193914471
+    ],
+    "targetPosition": [
+      7.68528506211673
+    ],
+    "targetVelocity": [
+      0.8026201618198012
+    ],
+    "targetAcceleration": [
+      -0.8172872465828043
+    ],
+    "maxVelocity": [
+      7.547079633582543
+    ],
+    "maxAcceleration": [
+      5.519611985079858
+    ],
+    "maxJerk": [
+      14.71417259458754
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.670353373944176
+    ],
+    "currentVelocity": [
+      1.4642439119321553
+    ],
+    "currentAcceleration": [
+      -4.446923154942745
+    ],
+    "targetPosition": [
+      9.412124145314355
+    ],
+    "targetVelocity": [
+      0.3606426616697993
+    ],
+    "targetAcceleration": [
+      4.145621444144561
+    ],
+    "maxVelocity": [
+      5.899111846018985
+    ],
+    "maxAcceleration": [
+      5.833484234500732
+    ],
+    "maxJerk": [
+      16.541455804665787
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.992895419839215
+    ],
+    "currentVelocity": [
+      -2.7331140594953123
+    ],
+    "currentAcceleration": [
+      2.746512483635035
+    ],
+    "targetPosition": [
+      9.366298605703061
+    ],
+    "targetVelocity": [
+      2.594726053241243
+    ],
+    "targetAcceleration": [
+      -5.018549145402582
+    ],
+    "maxVelocity": [
+      4.959552330577263
+    ],
+    "maxAcceleration": [
+      6.110627273772863
+    ],
+    "maxJerk": [
+      11.680869037209993
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.370073188494473
+    ],
+    "currentVelocity": [
+      -1.6600439623146674
+    ],
+    "currentAcceleration": [
+      -3.510457491481384
+    ],
+    "targetPosition": [
+      5.135219356190152
+    ],
+    "targetVelocity": [
+      -0.7284238984624873
+    ],
+    "targetAcceleration": [
+      3.7545312403824607
+    ],
+    "maxVelocity": [
+      2.3116813618898018
+    ],
+    "maxAcceleration": [
+      6.935791610220084
+    ],
+    "maxJerk": [
+      14.573270781704007
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.4623116410250514
+    ],
+    "currentVelocity": [
+      -5.320395043341709
+    ],
+    "currentAcceleration": [
+      -3.920079799160118
+    ],
+    "targetPosition": [
+      -5.218553676208655
+    ],
+    "targetVelocity": [
+      -4.104800953917585
+    ],
+    "targetAcceleration": [
+      4.3204322472631045
+    ],
+    "maxVelocity": [
+      7.9290821752751945
+    ],
+    "maxAcceleration": [
+      9.53343383266405
+    ],
+    "maxJerk": [
+      7.200452024803322
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.7259876151309648
+    ],
+    "currentVelocity": [
+      2.8042599446026664
+    ],
+    "currentAcceleration": [
+      -3.072267914630693
+    ],
+    "targetPosition": [
+      -5.573255053164803
+    ],
+    "targetVelocity": [
+      1.311702295843018
+    ],
+    "targetAcceleration": [
+      -1.6039117028202594
+    ],
+    "maxVelocity": [
+      3.141038191840419
+    ],
+    "maxAcceleration": [
+      4.196668211093646
+    ],
+    "maxJerk": [
+      17.418539975316115
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.367075116003814
+    ],
+    "currentVelocity": [
+      0.0972212144688065
+    ],
+    "currentAcceleration": [
+      3.989257399977955
+    ],
+    "targetPosition": [
+      -0.10485656827907164
+    ],
+    "targetVelocity": [
+      -1.1382226060955571
+    ],
+    "targetAcceleration": [
+      -4.108627667392987
+    ],
+    "maxVelocity": [
+      4.213388650199613
+    ],
+    "maxAcceleration": [
+      4.59561210811372
+    ],
+    "maxJerk": [
+      15.259659873881454
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.842062903868321
+    ],
+    "currentVelocity": [
+      -0.05219124718483581
+    ],
+    "currentAcceleration": [
+      -0.28682273279653536
+    ],
+    "targetPosition": [
+      8.189789371305803
+    ],
+    "targetVelocity": [
+      3.602627215874425
+    ],
+    "targetAcceleration": [
+      0.616533037047744
+    ],
+    "maxVelocity": [
+      5.5923471194538665
+    ],
+    "maxAcceleration": [
+      5.615615038892384
+    ],
+    "maxJerk": [
+      7.884823000213963
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.5843077214543255
+    ],
+    "currentVelocity": [
+      -4.013466877174865
+    ],
+    "currentAcceleration": [
+      -2.560819096956986
+    ],
+    "targetPosition": [
+      3.745595127490615
+    ],
+    "targetVelocity": [
+      -3.3697486545409148
+    ],
+    "targetAcceleration": [
+      -0.233188912664819
+    ],
+    "maxVelocity": [
+      6.56000708524101
+    ],
+    "maxAcceleration": [
+      3.2466943157737704
+    ],
+    "maxJerk": [
+      16.187741524348617
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.8078284801227564
+    ],
+    "currentVelocity": [
+      0.14977615546308343
+    ],
+    "currentAcceleration": [
+      6.7059539269323665
+    ],
+    "targetPosition": [
+      2.7065178544705972
+    ],
+    "targetVelocity": [
+      4.514957737421456
+    ],
+    "targetAcceleration": [
+      4.381762749198357
+    ],
+    "maxVelocity": [
+      4.880717348981346
+    ],
+    "maxAcceleration": [
+      7.809062498848332
+    ],
+    "maxJerk": [
+      12.844759951792309
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.3685681647006227
+    ],
+    "currentVelocity": [
+      1.7631918751939466
+    ],
+    "currentAcceleration": [
+      -0.1325351745798482
+    ],
+    "targetPosition": [
+      7.489892443284965
+    ],
+    "targetVelocity": [
+      2.5650792844658907
+    ],
+    "targetAcceleration": [
+      2.9106182525371977
+    ],
+    "maxVelocity": [
+      2.6706507701351763
+    ],
+    "maxAcceleration": [
+      5.378910037851645
+    ],
+    "maxJerk": [
+      19.600495658454207
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.1864313259765886
+    ],
+    "currentVelocity": [
+      5.370589526390592
+    ],
+    "currentAcceleration": [
+      -3.1258508134456116
+    ],
+    "targetPosition": [
+      -9.975872271186475
+    ],
+    "targetVelocity": [
+      -5.044684061526049
+    ],
+    "targetAcceleration": [
+      5.011437492745489
+    ],
+    "maxVelocity": [
+      6.413562387107293
+    ],
+    "maxAcceleration": [
+      5.225669159262579
+    ],
+    "maxJerk": [
+      17.449471846241636
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.696794080378702
+    ],
+    "currentVelocity": [
+      1.3145035169498707
+    ],
+    "currentAcceleration": [
+      -6.990455452469378
+    ],
+    "targetPosition": [
+      -3.0174902924731484
+    ],
+    "targetVelocity": [
+      2.767189785421632
+    ],
+    "targetAcceleration": [
+      2.5876502370440377
+    ],
+    "maxVelocity": [
+      3.3743988414187065
+    ],
+    "maxAcceleration": [
+      7.826592077324733
+    ],
+    "maxJerk": [
+      7.572745611497157
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.2912483102790837
+    ],
+    "currentVelocity": [
+      5.554178358632097
+    ],
+    "currentAcceleration": [
+      -1.1100036409424545
+    ],
+    "targetPosition": [
+      2.310764740902652
+    ],
+    "targetVelocity": [
+      3.54264958963617
+    ],
+    "targetAcceleration": [
+      -0.7701080867965446
+    ],
+    "maxVelocity": [
+      7.083308763717065
+    ],
+    "maxAcceleration": [
+      6.210626667202394
+    ],
+    "maxJerk": [
+      5.082156786778596
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.338076702800301
+    ],
+    "currentVelocity": [
+      -0.6009320118531085
+    ],
+    "currentAcceleration": [
+      2.4298650141060314
+    ],
+    "targetPosition": [
+      -1.4409261244236475
+    ],
+    "targetVelocity": [
+      -2.273026815192709
+    ],
+    "targetAcceleration": [
+      -4.791380698675571
+    ],
+    "maxVelocity": [
+      2.3399339127637333
+    ],
+    "maxAcceleration": [
+      7.027462855043922
+    ],
+    "maxJerk": [
+      5.4106582021905245
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.515049259029514
+    ],
+    "currentVelocity": [
+      -2.5977252761564733
+    ],
+    "currentAcceleration": [
+      5.535232605326543
+    ],
+    "targetPosition": [
+      -0.4682282336937327
+    ],
+    "targetVelocity": [
+      -1.132986165296419
+    ],
+    "targetAcceleration": [
+      -2.2693564579435614
+    ],
+    "maxVelocity": [
+      3.649109710491366
+    ],
+    "maxAcceleration": [
+      6.074256946293048
+    ],
+    "maxJerk": [
+      6.606428230276637
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.974608385051459
+    ],
+    "currentVelocity": [
+      1.2358274857874925
+    ],
+    "currentAcceleration": [
+      5.6512033818232466
+    ],
+    "targetPosition": [
+      5.181329122647959
+    ],
+    "targetVelocity": [
+      -4.600810990555091
+    ],
+    "targetAcceleration": [
+      1.0459950967540932
+    ],
+    "maxVelocity": [
+      6.964515750484855
+    ],
+    "maxAcceleration": [
+      5.754796549946186
+    ],
+    "maxJerk": [
+      15.548074212786718
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.538446852897475
+    ],
+    "currentVelocity": [
+      3.6579673216591946
+    ],
+    "currentAcceleration": [
+      0.40114780861865684
+    ],
+    "targetPosition": [
+      6.602206556292014
+    ],
+    "targetVelocity": [
+      2.734953112141752
+    ],
+    "targetAcceleration": [
+      -1.7069612350838383
+    ],
+    "maxVelocity": [
+      5.075366708264566
+    ],
+    "maxAcceleration": [
+      3.5816953140354517
+    ],
+    "maxJerk": [
+      13.45507032612162
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.994309801467623
+    ],
+    "currentVelocity": [
+      -4.926834526130557
+    ],
+    "currentAcceleration": [
+      -3.299896443850062
+    ],
+    "targetPosition": [
+      2.3288187106631835
+    ],
+    "targetVelocity": [
+      -2.3941012719150576
+    ],
+    "targetAcceleration": [
+      -2.9397747282145508
+    ],
+    "maxVelocity": [
+      7.716323772742639
+    ],
+    "maxAcceleration": [
+      9.436315577650028
+    ],
+    "maxJerk": [
+      7.203120616865739
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.881907297312992
+    ],
+    "currentVelocity": [
+      -1.7966540265111304
+    ],
+    "currentAcceleration": [
+      -5.889417923751657
+    ],
+    "targetPosition": [
+      -4.332936479769913
+    ],
+    "targetVelocity": [
+      -1.0440946227171697
+    ],
+    "targetAcceleration": [
+      4.692613156004281
+    ],
+    "maxVelocity": [
+      6.4429864096178395
+    ],
+    "maxAcceleration": [
+      9.279138745004028
+    ],
+    "maxJerk": [
+      12.201965618834414
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.932055868620669
+    ],
+    "currentVelocity": [
+      2.0018334350156595
+    ],
+    "currentAcceleration": [
+      4.370293847583801
+    ],
+    "targetPosition": [
+      0.025000922130972825
+    ],
+    "targetVelocity": [
+      1.2044270666650876
+    ],
+    "targetAcceleration": [
+      1.418842826015318
+    ],
+    "maxVelocity": [
+      5.124091420799875
+    ],
+    "maxAcceleration": [
+      5.300955947540091
+    ],
+    "maxJerk": [
+      16.22071546987781
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.297389666521667
+    ],
+    "currentVelocity": [
+      3.2806025564361363
+    ],
+    "currentAcceleration": [
+      3.9990109958399227
+    ],
+    "targetPosition": [
+      -6.912038787242352
+    ],
+    "targetVelocity": [
+      0.36070090939149857
+    ],
+    "targetAcceleration": [
+      -7.688125788202231
+    ],
+    "maxVelocity": [
+      6.643462607615325
+    ],
+    "maxAcceleration": [
+      7.935097473950009
+    ],
+    "maxJerk": [
+      14.660832649991779
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.736628978691663
+    ],
+    "currentVelocity": [
+      -5.489506795025897
+    ],
+    "currentAcceleration": [
+      -2.5576157630920324
+    ],
+    "targetPosition": [
+      -2.253276303821412
+    ],
+    "targetVelocity": [
+      -2.7923633699698325
+    ],
+    "targetAcceleration": [
+      3.104720268557104
+    ],
+    "maxVelocity": [
+      6.842155760307085
+    ],
+    "maxAcceleration": [
+      6.6987992062902
+    ],
+    "maxJerk": [
+      16.22954543485355
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6747364052733733
+    ],
+    "currentVelocity": [
+      -4.31098403007508
+    ],
+    "currentAcceleration": [
+      -0.9954171161536274
+    ],
+    "targetPosition": [
+      -5.331795182312559
+    ],
+    "targetVelocity": [
+      3.5725865787093047
+    ],
+    "targetAcceleration": [
+      -2.9964300431692856
+    ],
+    "maxVelocity": [
+      7.609478741008574
+    ],
+    "maxAcceleration": [
+      3.6532016933716895
+    ],
+    "maxJerk": [
+      11.689366290299407
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.82892125247205
+    ],
+    "currentVelocity": [
+      0.6102282542718891
+    ],
+    "currentAcceleration": [
+      -2.9690833026370758
+    ],
+    "targetPosition": [
+      7.713477481537353
+    ],
+    "targetVelocity": [
+      1.1789660101104635
+    ],
+    "targetAcceleration": [
+      8.393363933896332
+    ],
+    "maxVelocity": [
+      4.502793768186446
+    ],
+    "maxAcceleration": [
+      9.702625626887276
+    ],
+    "maxJerk": [
+      7.51923176741775
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.657537685183339
+    ],
+    "currentVelocity": [
+      -4.646154113319505
+    ],
+    "currentAcceleration": [
+      -6.220792614092992
+    ],
+    "targetPosition": [
+      0.46602561847757684
+    ],
+    "targetVelocity": [
+      3.2477156816744257
+    ],
+    "targetAcceleration": [
+      -2.6542095499795577
+    ],
+    "maxVelocity": [
+      6.8108384078721675
+    ],
+    "maxAcceleration": [
+      9.01688642321035
+    ],
+    "maxJerk": [
+      15.077156907060425
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.5394993806854025
+    ],
+    "currentVelocity": [
+      -4.10572872339934
+    ],
+    "currentAcceleration": [
+      0.06675859281791219
+    ],
+    "targetPosition": [
+      -0.6726105530222188
+    ],
+    "targetVelocity": [
+      -3.105237533825055
+    ],
+    "targetAcceleration": [
+      6.287739128836252
+    ],
+    "maxVelocity": [
+      7.6038114151427765
+    ],
+    "maxAcceleration": [
+      8.150556347506456
+    ],
+    "maxJerk": [
+      11.51501915441425
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.962446218719503
+    ],
+    "currentVelocity": [
+      -4.716063278226446
+    ],
+    "currentAcceleration": [
+      4.380141511191056
+    ],
+    "targetPosition": [
+      -2.0332412600476735
+    ],
+    "targetVelocity": [
+      -4.363852906445024
+    ],
+    "targetAcceleration": [
+      -1.6250509561714814
+    ],
+    "maxVelocity": [
+      6.397115293374942
+    ],
+    "maxAcceleration": [
+      6.821947550916324
+    ],
+    "maxJerk": [
+      19.311908647070048
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.175893086690636
+    ],
+    "currentVelocity": [
+      -1.6099638018396418
+    ],
+    "currentAcceleration": [
+      3.1222394373580658
+    ],
+    "targetPosition": [
+      6.733117177709971
+    ],
+    "targetVelocity": [
+      -0.7671915731860133
+    ],
+    "targetAcceleration": [
+      1.026289595299982
+    ],
+    "maxVelocity": [
+      2.5333949880886406
+    ],
+    "maxAcceleration": [
+      4.169818980351039
+    ],
+    "maxJerk": [
+      6.993350901765378
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.969680289543675
+    ],
+    "currentVelocity": [
+      -5.029427492798337
+    ],
+    "currentAcceleration": [
+      0.7287933159057935
+    ],
+    "targetPosition": [
+      1.977795501781701
+    ],
+    "targetVelocity": [
+      -2.590262199705955
+    ],
+    "targetAcceleration": [
+      -2.138955696738348
+    ],
+    "maxVelocity": [
+      5.045171375512804
+    ],
+    "maxAcceleration": [
+      6.817347963971042
+    ],
+    "maxJerk": [
+      5.938811735060515
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.673450237924403
+    ],
+    "currentVelocity": [
+      3.646299855863008
+    ],
+    "currentAcceleration": [
+      -1.1914452693723199
+    ],
+    "targetPosition": [
+      2.160236683581223
+    ],
+    "targetVelocity": [
+      2.574261772013436
+    ],
+    "targetAcceleration": [
+      -0.054699819802359606
+    ],
+    "maxVelocity": [
+      5.443399232285731
+    ],
+    "maxAcceleration": [
+      3.5854651169803597
+    ],
+    "maxJerk": [
+      17.37447523829288
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.750290266377135
+    ],
+    "currentVelocity": [
+      1.6483071528198812
+    ],
+    "currentAcceleration": [
+      7.29455064797143
+    ],
+    "targetPosition": [
+      -0.6121282567525341
+    ],
+    "targetVelocity": [
+      1.4413128323415973
+    ],
+    "targetAcceleration": [
+      -2.435007404447913
+    ],
+    "maxVelocity": [
+      5.559384449493223
+    ],
+    "maxAcceleration": [
+      8.041451592860197
+    ],
+    "maxJerk": [
+      6.836503507047436
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.8672623909199135
+    ],
+    "currentVelocity": [
+      2.719365468476806
+    ],
+    "currentAcceleration": [
+      -4.007116078512119
+    ],
+    "targetPosition": [
+      -5.616269789007244
+    ],
+    "targetVelocity": [
+      -0.6217070294030482
+    ],
+    "targetAcceleration": [
+      -0.8555779634123835
+    ],
+    "maxVelocity": [
+      2.7389934018787625
+    ],
+    "maxAcceleration": [
+      4.427416421724451
+    ],
+    "maxJerk": [
+      16.098787277711686
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.875278075038199
+    ],
+    "currentVelocity": [
+      -0.2140747556490279
+    ],
+    "currentAcceleration": [
+      3.8359474613399698
+    ],
+    "targetPosition": [
+      -2.740838430343975
+    ],
+    "targetVelocity": [
+      0.6693779526605752
+    ],
+    "targetAcceleration": [
+      5.699237487327084
+    ],
+    "maxVelocity": [
+      7.138024375917705
+    ],
+    "maxAcceleration": [
+      7.0437249038199
+    ],
+    "maxJerk": [
+      6.425602864465576
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.13341066040438676
+    ],
+    "currentVelocity": [
+      2.199648348175182
+    ],
+    "currentAcceleration": [
+      -0.8230789694350382
+    ],
+    "targetPosition": [
+      -5.631284604298747
+    ],
+    "targetVelocity": [
+      -2.270058241429987
+    ],
+    "targetAcceleration": [
+      -1.0357667001192659
+    ],
+    "maxVelocity": [
+      2.5192053515845902
+    ],
+    "maxAcceleration": [
+      4.283633820830814
+    ],
+    "maxJerk": [
+      12.794568699063685
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.254421997314848
+    ],
+    "currentVelocity": [
+      -2.762252007739294
+    ],
+    "currentAcceleration": [
+      -3.7776763168184995
+    ],
+    "targetPosition": [
+      8.020380445527746
+    ],
+    "targetVelocity": [
+      1.6235282321733928
+    ],
+    "targetAcceleration": [
+      4.975920825002301
+    ],
+    "maxVelocity": [
+      4.110956158917748
+    ],
+    "maxAcceleration": [
+      7.0955535379629255
+    ],
+    "maxJerk": [
+      5.542282886162427
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.3227648902618174
+    ],
+    "currentVelocity": [
+      1.7938248496090008
+    ],
+    "currentAcceleration": [
+      0.13827961586748128
+    ],
+    "targetPosition": [
+      7.601848725049798
+    ],
+    "targetVelocity": [
+      2.7334333837573226
+    ],
+    "targetAcceleration": [
+      0.5222254380800608
+    ],
+    "maxVelocity": [
+      4.316467255748571
+    ],
+    "maxAcceleration": [
+      5.415750942471044
+    ],
+    "maxJerk": [
+      12.715434142819174
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.8864767073272333
+    ],
+    "currentVelocity": [
+      2.9895319153901774
+    ],
+    "currentAcceleration": [
+      -0.547116773092085
+    ],
+    "targetPosition": [
+      -7.291174790536063
+    ],
+    "targetVelocity": [
+      -0.7494903952919203
+    ],
+    "targetAcceleration": [
+      -1.1078894950392777
+    ],
+    "maxVelocity": [
+      3.1453711868802445
+    ],
+    "maxAcceleration": [
+      3.6074220810831483
+    ],
+    "maxJerk": [
+      15.286749513671902
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.726866837396631
+    ],
+    "currentVelocity": [
+      0.8599312678929678
+    ],
+    "currentAcceleration": [
+      -0.6596182453427901
+    ],
+    "targetPosition": [
+      -0.9674365872472244
+    ],
+    "targetVelocity": [
+      -2.5867946244264206
+    ],
+    "targetAcceleration": [
+      2.6924276226247015
+    ],
+    "maxVelocity": [
+      4.457582714749856
+    ],
+    "maxAcceleration": [
+      3.366921632063562
+    ],
+    "maxJerk": [
+      10.661192810519903
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.85197575303512
+    ],
+    "currentVelocity": [
+      2.80113040083989
+    ],
+    "currentAcceleration": [
+      2.3598179411199696
+    ],
+    "targetPosition": [
+      -9.704562496259397
+    ],
+    "targetVelocity": [
+      -6.2976037369116495
+    ],
+    "targetAcceleration": [
+      -3.1388929202513483
+    ],
+    "maxVelocity": [
+      7.841207697344677
+    ],
+    "maxAcceleration": [
+      3.3746080435422967
+    ],
+    "maxJerk": [
+      19.72695125553379
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.254870315140554
+    ],
+    "currentVelocity": [
+      0.20151932023501873
+    ],
+    "currentAcceleration": [
+      -3.7831449091123246
+    ],
+    "targetPosition": [
+      -2.3260449147273787
+    ],
+    "targetVelocity": [
+      -1.805394512722847
+    ],
+    "targetAcceleration": [
+      0.3700783122685678
+    ],
+    "maxVelocity": [
+      2.515469620171869
+    ],
+    "maxAcceleration": [
+      7.766753613953947
+    ],
+    "maxJerk": [
+      17.412598492125507
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.823343920412668
+    ],
+    "currentVelocity": [
+      1.177331960893576
+    ],
+    "currentAcceleration": [
+      -6.6831834252737545
+    ],
+    "targetPosition": [
+      -7.757931644215786
+    ],
+    "targetVelocity": [
+      -1.6858780696836
+    ],
+    "targetAcceleration": [
+      0.6888097698041431
+    ],
+    "maxVelocity": [
+      3.813807750166614
+    ],
+    "maxAcceleration": [
+      8.48866499724772
+    ],
+    "maxJerk": [
+      7.889951516363031
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.165688403626719
+    ],
+    "currentVelocity": [
+      -1.6346496507835906
+    ],
+    "currentAcceleration": [
+      -3.7902571417811646
+    ],
+    "targetPosition": [
+      4.946851161345798
+    ],
+    "targetVelocity": [
+      -4.024303544551007
+    ],
+    "targetAcceleration": [
+      0.9887536894112312
+    ],
+    "maxVelocity": [
+      4.656953893307926
+    ],
+    "maxAcceleration": [
+      5.738144327131519
+    ],
+    "maxJerk": [
+      10.790302466285109
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.2151526268730137
+    ],
+    "currentVelocity": [
+      -0.4185797662456041
+    ],
+    "currentAcceleration": [
+      -2.274152538407544
+    ],
+    "targetPosition": [
+      -9.428525721795204
+    ],
+    "targetVelocity": [
+      3.3619883009048497
+    ],
+    "targetAcceleration": [
+      -2.0188466017880584
+    ],
+    "maxVelocity": [
+      4.189691995148285
+    ],
+    "maxAcceleration": [
+      3.5339965432797062
+    ],
+    "maxJerk": [
+      15.127385308068266
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.096095111311257
+    ],
+    "currentVelocity": [
+      5.783079243036423
+    ],
+    "currentAcceleration": [
+      3.3441116991798623
+    ],
+    "targetPosition": [
+      -9.150664522869507
+    ],
+    "targetVelocity": [
+      7.231470359236302
+    ],
+    "targetAcceleration": [
+      8.205675544570783
+    ],
+    "maxVelocity": [
+      7.67907751698159
+    ],
+    "maxAcceleration": [
+      8.232634445401535
+    ],
+    "maxJerk": [
+      12.23934140362799
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.241292544935051
+    ],
+    "currentVelocity": [
+      0.7499522662064169
+    ],
+    "currentAcceleration": [
+      -0.8300464300550701
+    ],
+    "targetPosition": [
+      8.043226320899038
+    ],
+    "targetVelocity": [
+      -3.2668965691365806
+    ],
+    "targetAcceleration": [
+      2.2954473729886296
+    ],
+    "maxVelocity": [
+      3.7734315038269117
+    ],
+    "maxAcceleration": [
+      7.9494012439757515
+    ],
+    "maxJerk": [
+      13.321178440070941
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.819438782853194
+    ],
+    "currentVelocity": [
+      -7.229494705241403
+    ],
+    "currentAcceleration": [
+      0.6031063417359039
+    ],
+    "targetPosition": [
+      -4.269417222287258
+    ],
+    "targetVelocity": [
+      -4.103874968872308
+    ],
+    "targetAcceleration": [
+      1.1281281808975505
+    ],
+    "maxVelocity": [
+      7.385413747734528
+    ],
+    "maxAcceleration": [
+      4.637528366135568
+    ],
+    "maxJerk": [
+      19.1721412327824
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.5399405852442793
+    ],
+    "currentVelocity": [
+      -0.8508920910329354
+    ],
+    "currentAcceleration": [
+      -2.6282237964451065
+    ],
+    "targetPosition": [
+      -4.7815271808532
+    ],
+    "targetVelocity": [
+      0.12419967181514213
+    ],
+    "targetAcceleration": [
+      -2.5410387581032965
+    ],
+    "maxVelocity": [
+      4.236341648105414
+    ],
+    "maxAcceleration": [
+      5.024809612205046
+    ],
+    "maxJerk": [
+      9.424051897652511
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.38353814839369
+    ],
+    "currentVelocity": [
+      -2.077469603695845
+    ],
+    "currentAcceleration": [
+      -3.773803443544086
+    ],
+    "targetPosition": [
+      7.9104668113239
+    ],
+    "targetVelocity": [
+      3.685457003003326
+    ],
+    "targetAcceleration": [
+      0.33873606513293986
+    ],
+    "maxVelocity": [
+      4.894899741521216
+    ],
+    "maxAcceleration": [
+      5.627910084603961
+    ],
+    "maxJerk": [
+      11.778432598728028
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.425556688612433
+    ],
+    "currentVelocity": [
+      3.8077886188096333
+    ],
+    "currentAcceleration": [
+      -2.0265105638827796
+    ],
+    "targetPosition": [
+      -3.7841145468697075
+    ],
+    "targetVelocity": [
+      3.6920372224206197
+    ],
+    "targetAcceleration": [
+      5.3958550170354425
+    ],
+    "maxVelocity": [
+      6.073367469630876
+    ],
+    "maxAcceleration": [
+      6.2801278590935645
+    ],
+    "maxJerk": [
+      5.522423450695512
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.796307395113249
+    ],
+    "currentVelocity": [
+      -3.713422083909675
+    ],
+    "currentAcceleration": [
+      -5.852710311617855
+    ],
+    "targetPosition": [
+      1.3776789141616526
+    ],
+    "targetVelocity": [
+      4.829833341506968
+    ],
+    "targetAcceleration": [
+      -1.738658320912573
+    ],
+    "maxVelocity": [
+      5.690794535342929
+    ],
+    "maxAcceleration": [
+      9.217439170804713
+    ],
+    "maxJerk": [
+      13.604753115198218
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.30137285709105655
+    ],
+    "currentVelocity": [
+      1.5464906882439582
+    ],
+    "currentAcceleration": [
+      -1.6458142429147404
+    ],
+    "targetPosition": [
+      3.6428160892691572
+    ],
+    "targetVelocity": [
+      0.08833446529958788
+    ],
+    "targetAcceleration": [
+      3.866601659649035
+    ],
+    "maxVelocity": [
+      6.976810440311626
+    ],
+    "maxAcceleration": [
+      7.839589660494479
+    ],
+    "maxJerk": [
+      7.160613841505233
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.2794797908674553
+    ],
+    "currentVelocity": [
+      1.6656371047498197
+    ],
+    "currentAcceleration": [
+      -2.0900393251268685
+    ],
+    "targetPosition": [
+      -1.9132961585219732
+    ],
+    "targetVelocity": [
+      4.415554922866393
+    ],
+    "targetAcceleration": [
+      5.542225269910982
+    ],
+    "maxVelocity": [
+      5.511198700205597
+    ],
+    "maxAcceleration": [
+      6.645320622601852
+    ],
+    "maxJerk": [
+      19.18417993892173
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.6378201649024184
+    ],
+    "currentVelocity": [
+      -0.7479422784868812
+    ],
+    "currentAcceleration": [
+      -1.8745161593294792
+    ],
+    "targetPosition": [
+      0.5426397157440288
+    ],
+    "targetVelocity": [
+      1.0357210256289413
+    ],
+    "targetAcceleration": [
+      -4.033566706017243
+    ],
+    "maxVelocity": [
+      4.298571169468573
+    ],
+    "maxAcceleration": [
+      7.571805224898197
+    ],
+    "maxJerk": [
+      9.671686237678168
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.3442582963567311
+    ],
+    "currentVelocity": [
+      0.7870142923818237
+    ],
+    "currentAcceleration": [
+      0.5405291874344096
+    ],
+    "targetPosition": [
+      2.148873737656933
+    ],
+    "targetVelocity": [
+      -3.203860187736063
+    ],
+    "targetAcceleration": [
+      -2.3595854728633765
+    ],
+    "maxVelocity": [
+      6.028421723856935
+    ],
+    "maxAcceleration": [
+      5.2682771550974525
+    ],
+    "maxJerk": [
+      16.437169286523115
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.691145195697011
+    ],
+    "currentVelocity": [
+      -0.3597486892216417
+    ],
+    "currentAcceleration": [
+      -4.261094144278385
+    ],
+    "targetPosition": [
+      -3.5789893479631925
+    ],
+    "targetVelocity": [
+      0.1754738097757773
+    ],
+    "targetAcceleration": [
+      0.9054533989886151
+    ],
+    "maxVelocity": [
+      2.6842631771495484
+    ],
+    "maxAcceleration": [
+      6.625295475643663
+    ],
+    "maxJerk": [
+      13.559447201044003
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.7655558468455244
+    ],
+    "currentVelocity": [
+      -3.90046890148757
+    ],
+    "currentAcceleration": [
+      1.9344349413494748
+    ],
+    "targetPosition": [
+      6.4136877633852905
+    ],
+    "targetVelocity": [
+      3.0799109520714367
+    ],
+    "targetAcceleration": [
+      3.2205801976028243
+    ],
+    "maxVelocity": [
+      4.623304094381003
+    ],
+    "maxAcceleration": [
+      3.2365911200907287
+    ],
+    "maxJerk": [
+      11.314691747720701
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.1540356385145767
+    ],
+    "currentVelocity": [
+      0.006838020413920454
+    ],
+    "currentAcceleration": [
+      4.253306006128814
+    ],
+    "targetPosition": [
+      -6.921043742489794
+    ],
+    "targetVelocity": [
+      -2.6294235855903025
+    ],
+    "targetAcceleration": [
+      -4.909041676639938
+    ],
+    "maxVelocity": [
+      2.762281168172827
+    ],
+    "maxAcceleration": [
+      5.864108099856632
+    ],
+    "maxJerk": [
+      7.467125318020511
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.30637157157325845
+    ],
+    "currentVelocity": [
+      4.735468789467219
+    ],
+    "currentAcceleration": [
+      -0.24376381185871665
+    ],
+    "targetPosition": [
+      -8.06263941679897
+    ],
+    "targetVelocity": [
+      -6.501580048524874
+    ],
+    "targetAcceleration": [
+      1.77129445546091
+    ],
+    "maxVelocity": [
+      7.944975728522739
+    ],
+    "maxAcceleration": [
+      7.950401979284087
+    ],
+    "maxJerk": [
+      17.352656823499828
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.949514083374861
+    ],
+    "currentVelocity": [
+      0.31888887336922256
+    ],
+    "currentAcceleration": [
+      3.281121467770351
+    ],
+    "targetPosition": [
+      -4.421667181522553
+    ],
+    "targetVelocity": [
+      -2.401399070475368
+    ],
+    "targetAcceleration": [
+      -0.6307923106523328
+    ],
+    "maxVelocity": [
+      6.181126946334139
+    ],
+    "maxAcceleration": [
+      7.628082008128279
+    ],
+    "maxJerk": [
+      9.444572145708559
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.9942803124353174
+    ],
+    "currentVelocity": [
+      -3.834466122003592
+    ],
+    "currentAcceleration": [
+      6.149703072692151
+    ],
+    "targetPosition": [
+      4.8802684362272934
+    ],
+    "targetVelocity": [
+      -2.7955643085712625
+    ],
+    "targetAcceleration": [
+      -5.094095539731286
+    ],
+    "maxVelocity": [
+      4.3078081280009
+    ],
+    "maxAcceleration": [
+      6.5609564113131595
+    ],
+    "maxJerk": [
+      15.846737196222678
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.6109350884739655
+    ],
+    "currentVelocity": [
+      3.6646680742903808
+    ],
+    "currentAcceleration": [
+      5.105871939839972
+    ],
+    "targetPosition": [
+      7.799159250024587
+    ],
+    "targetVelocity": [
+      -2.6295396591180284
+    ],
+    "targetAcceleration": [
+      3.5774643752011155
+    ],
+    "maxVelocity": [
+      6.344657057402365
+    ],
+    "maxAcceleration": [
+      8.894996640928396
+    ],
+    "maxJerk": [
+      18.93284660054142
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.881177775637568
+    ],
+    "currentVelocity": [
+      -0.10345465309854163
+    ],
+    "currentAcceleration": [
+      4.444768818966249
+    ],
+    "targetPosition": [
+      5.185842765088296
+    ],
+    "targetVelocity": [
+      -2.0885829616425955
+    ],
+    "targetAcceleration": [
+      -8.27935625540757
+    ],
+    "maxVelocity": [
+      3.2716129707568538
+    ],
+    "maxAcceleration": [
+      8.656550101084834
+    ],
+    "maxJerk": [
+      9.412556476444337
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.373539962150325
+    ],
+    "currentVelocity": [
+      4.0340454989285295
+    ],
+    "currentAcceleration": [
+      6.764797295895144
+    ],
+    "targetPosition": [
+      -0.667935025518398
+    ],
+    "targetVelocity": [
+      -4.100346530371642
+    ],
+    "targetAcceleration": [
+      -5.205766507259039
+    ],
+    "maxVelocity": [
+      6.957265338206952
+    ],
+    "maxAcceleration": [
+      7.608730859993574
+    ],
+    "maxJerk": [
+      17.54103865982524
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.0385977322229945
+    ],
+    "currentVelocity": [
+      -0.7159400487487027
+    ],
+    "currentAcceleration": [
+      -3.132615986867198
+    ],
+    "targetPosition": [
+      -0.478227074784785
+    ],
+    "targetVelocity": [
+      -1.7965136488084208
+    ],
+    "targetAcceleration": [
+      -0.579975128431677
+    ],
+    "maxVelocity": [
+      5.057703119572972
+    ],
+    "maxAcceleration": [
+      5.836961964246015
+    ],
+    "maxJerk": [
+      15.160860866786951
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.9219229140648135
+    ],
+    "currentVelocity": [
+      -1.2009253549514405
+    ],
+    "currentAcceleration": [
+      0.6255646449875858
+    ],
+    "targetPosition": [
+      9.403458085607312
+    ],
+    "targetVelocity": [
+      1.1788323484796144
+    ],
+    "targetAcceleration": [
+      -1.0537213914207832
+    ],
+    "maxVelocity": [
+      3.421788796665639
+    ],
+    "maxAcceleration": [
+      5.215200612226602
+    ],
+    "maxJerk": [
+      5.969104724887667
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.818975387823418
+    ],
+    "currentVelocity": [
+      1.2052345391977908
+    ],
+    "currentAcceleration": [
+      3.807560486355179
+    ],
+    "targetPosition": [
+      7.866653392872468
+    ],
+    "targetVelocity": [
+      -0.15503959203818996
+    ],
+    "targetAcceleration": [
+      3.9783126923388163
+    ],
+    "maxVelocity": [
+      2.6735132722898785
+    ],
+    "maxAcceleration": [
+      4.1439633670893485
+    ],
+    "maxJerk": [
+      7.7684065114682905
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.6907435817216587
+    ],
+    "currentVelocity": [
+      -1.1610139572553728
+    ],
+    "currentAcceleration": [
+      -0.44649918979870584
+    ],
+    "targetPosition": [
+      1.7497473002622659
+    ],
+    "targetVelocity": [
+      -2.572017825648817
+    ],
+    "targetAcceleration": [
+      -3.4321414594227972
+    ],
+    "maxVelocity": [
+      2.6153574349674678
+    ],
+    "maxAcceleration": [
+      8.197770472387894
+    ],
+    "maxJerk": [
+      16.050737353781194
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.4515023835677603
+    ],
+    "currentVelocity": [
+      -4.323938625849911
+    ],
+    "currentAcceleration": [
+      -2.7817175782443764
+    ],
+    "targetPosition": [
+      7.606528177187197
+    ],
+    "targetVelocity": [
+      -0.07755220255847828
+    ],
+    "targetAcceleration": [
+      -1.5749140796768897
+    ],
+    "maxVelocity": [
+      6.0216491983926765
+    ],
+    "maxAcceleration": [
+      6.969485534191113
+    ],
+    "maxJerk": [
+      15.792209305003112
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.863400779176084
+    ],
+    "currentVelocity": [
+      3.88554300016221
+    ],
+    "currentAcceleration": [
+      1.1210927814438394
+    ],
+    "targetPosition": [
+      -5.46025468544832
+    ],
+    "targetVelocity": [
+      4.406907834040199
+    ],
+    "targetAcceleration": [
+      0.7576586697029013
+    ],
+    "maxVelocity": [
+      7.441682626034696
+    ],
+    "maxAcceleration": [
+      3.3638356292405964
+    ],
+    "maxJerk": [
+      16.89724974597707
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.7302394838933255
+    ],
+    "currentVelocity": [
+      3.5750533065448113
+    ],
+    "currentAcceleration": [
+      0.3261132941124121
+    ],
+    "targetPosition": [
+      3.710376779998768
+    ],
+    "targetVelocity": [
+      6.154479546005646
+    ],
+    "targetAcceleration": [
+      0.948573860544002
+    ],
+    "maxVelocity": [
+      6.511385701672831
+    ],
+    "maxAcceleration": [
+      6.454756459330685
+    ],
+    "maxJerk": [
+      10.096115534182493
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.021342981659857
+    ],
+    "currentVelocity": [
+      4.957507658530081
+    ],
+    "currentAcceleration": [
+      2.7748908591317214
+    ],
+    "targetPosition": [
+      -4.532021240247232
+    ],
+    "targetVelocity": [
+      -1.9100616594919781
+    ],
+    "targetAcceleration": [
+      -0.6259890849504597
+    ],
+    "maxVelocity": [
+      5.296855900443997
+    ],
+    "maxAcceleration": [
+      4.240114422821547
+    ],
+    "maxJerk": [
+      19.732764672605775
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.47246348708451436
+    ],
+    "currentVelocity": [
+      2.8553796166366867
+    ],
+    "currentAcceleration": [
+      -3.134761561988977
+    ],
+    "targetPosition": [
+      2.097885207890922
+    ],
+    "targetVelocity": [
+      -1.3038846765496261
+    ],
+    "targetAcceleration": [
+      6.1549523212722015
+    ],
+    "maxVelocity": [
+      5.646171664615095
+    ],
+    "maxAcceleration": [
+      6.573592458771001
+    ],
+    "maxJerk": [
+      13.983527988771195
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.110630977489873
+    ],
+    "currentVelocity": [
+      2.465337926960033
+    ],
+    "currentAcceleration": [
+      -3.6975712095192437
+    ],
+    "targetPosition": [
+      -3.616372632442686
+    ],
+    "targetVelocity": [
+      6.149359167444632
+    ],
+    "targetAcceleration": [
+      2.2515034347843983
+    ],
+    "maxVelocity": [
+      6.475018698339535
+    ],
+    "maxAcceleration": [
+      6.731116210891727
+    ],
+    "maxJerk": [
+      7.853250492639618
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.808259857660012
+    ],
+    "currentVelocity": [
+      0.02237638028325417
+    ],
+    "currentAcceleration": [
+      -1.532920356208348
+    ],
+    "targetPosition": [
+      6.08050276465281
+    ],
+    "targetVelocity": [
+      -2.297218535301501
+    ],
+    "targetAcceleration": [
+      6.833299137950453
+    ],
+    "maxVelocity": [
+      4.54899405208935
+    ],
+    "maxAcceleration": [
+      7.621633761315277
+    ],
+    "maxJerk": [
+      15.838155580264583
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.611490842905049
+    ],
+    "currentVelocity": [
+      -2.5776288239697145
+    ],
+    "currentAcceleration": [
+      -1.4753522518600928
+    ],
+    "targetPosition": [
+      0.3557522775422477
+    ],
+    "targetVelocity": [
+      -6.131917715079428
+    ],
+    "targetAcceleration": [
+      3.071239619608205
+    ],
+    "maxVelocity": [
+      7.293490381004317
+    ],
+    "maxAcceleration": [
+      9.701892014859405
+    ],
+    "maxJerk": [
+      12.193077012384242
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.0517079666977267
+    ],
+    "currentVelocity": [
+      -4.790196266533079
+    ],
+    "currentAcceleration": [
+      2.494071272160965
+    ],
+    "targetPosition": [
+      3.364444775747547
+    ],
+    "targetVelocity": [
+      -0.9757760894236043
+    ],
+    "targetAcceleration": [
+      2.7710559116512394
+    ],
+    "maxVelocity": [
+      5.74597044028577
+    ],
+    "maxAcceleration": [
+      5.315531716086791
+    ],
+    "maxJerk": [
+      12.793158774781393
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.70388124494016
+    ],
+    "currentVelocity": [
+      6.628672970731189
+    ],
+    "currentAcceleration": [
+      0.8117903015206549
+    ],
+    "targetPosition": [
+      -2.923175531463369
+    ],
+    "targetVelocity": [
+      -4.164321016706627
+    ],
+    "targetAcceleration": [
+      -1.660542045757559
+    ],
+    "maxVelocity": [
+      7.016001405468615
+    ],
+    "maxAcceleration": [
+      5.5699666355291795
+    ],
+    "maxJerk": [
+      13.564945402427359
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.020498945562821
+    ],
+    "currentVelocity": [
+      -4.286536517227626
+    ],
+    "currentAcceleration": [
+      5.93072089476181
+    ],
+    "targetPosition": [
+      7.439093350719844
+    ],
+    "targetVelocity": [
+      -3.8282311733066896
+    ],
+    "targetAcceleration": [
+      1.2774032830896882
+    ],
+    "maxVelocity": [
+      4.683748592389383
+    ],
+    "maxAcceleration": [
+      9.096116468060051
+    ],
+    "maxJerk": [
+      6.470773627455385
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.395218188964003
+    ],
+    "currentVelocity": [
+      -1.2919942498887351
+    ],
+    "currentAcceleration": [
+      -0.3979910781098486
+    ],
+    "targetPosition": [
+      -1.8695442244970213
+    ],
+    "targetVelocity": [
+      1.6087755927297902
+    ],
+    "targetAcceleration": [
+      1.3612256546591568
+    ],
+    "maxVelocity": [
+      2.6675196502761365
+    ],
+    "maxAcceleration": [
+      3.781777353168476
+    ],
+    "maxJerk": [
+      7.5292886045203415
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.44451524368311
+    ],
+    "currentVelocity": [
+      -2.264263961113027
+    ],
+    "currentAcceleration": [
+      2.4993604247200008
+    ],
+    "targetPosition": [
+      8.177800785240954
+    ],
+    "targetVelocity": [
+      -0.4959551199444052
+    ],
+    "targetAcceleration": [
+      2.873725309600344
+    ],
+    "maxVelocity": [
+      2.26859542609506
+    ],
+    "maxAcceleration": [
+      6.243328426475802
+    ],
+    "maxJerk": [
+      17.926129790513734
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.602125275097945
+    ],
+    "currentVelocity": [
+      -2.154239274048686
+    ],
+    "currentAcceleration": [
+      2.129767949296811
+    ],
+    "targetPosition": [
+      2.1681194189722657
+    ],
+    "targetVelocity": [
+      -1.2238248450100295
+    ],
+    "targetAcceleration": [
+      1.4339991016619447
+    ],
+    "maxVelocity": [
+      5.2171626978195915
+    ],
+    "maxAcceleration": [
+      3.431123011235263
+    ],
+    "maxJerk": [
+      18.156491923298233
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7385724633112307
+    ],
+    "currentVelocity": [
+      1.5810612984944843
+    ],
+    "currentAcceleration": [
+      -5.588026430084444
+    ],
+    "targetPosition": [
+      6.832420167378334
+    ],
+    "targetVelocity": [
+      -3.397546265625196
+    ],
+    "targetAcceleration": [
+      -4.395047186137457
+    ],
+    "maxVelocity": [
+      4.368543341297937
+    ],
+    "maxAcceleration": [
+      7.298838699184452
+    ],
+    "maxJerk": [
+      18.212642174156137
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.210015206195013
+    ],
+    "currentVelocity": [
+      -1.6653418592637388
+    ],
+    "currentAcceleration": [
+      0.3676669823772496
+    ],
+    "targetPosition": [
+      1.8412927021802226
+    ],
+    "targetVelocity": [
+      0.008948231297461362
+    ],
+    "targetAcceleration": [
+      -4.181167804501049
+    ],
+    "maxVelocity": [
+      2.896247246321188
+    ],
+    "maxAcceleration": [
+      8.357631357698498
+    ],
+    "maxJerk": [
+      15.673352657593417
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.457423838941093
+    ],
+    "currentVelocity": [
+      3.187515072302366
+    ],
+    "currentAcceleration": [
+      -1.858227110147066
+    ],
+    "targetPosition": [
+      8.656239765773194
+    ],
+    "targetVelocity": [
+      -3.48245425796783
+    ],
+    "targetAcceleration": [
+      4.4502653277048
+    ],
+    "maxVelocity": [
+      4.044924238106037
+    ],
+    "maxAcceleration": [
+      9.72222857738658
+    ],
+    "maxJerk": [
+      17.694004710164492
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.6180496164965952
+    ],
+    "currentVelocity": [
+      -2.143519197006169
+    ],
+    "currentAcceleration": [
+      -0.6377961044427014
+    ],
+    "targetPosition": [
+      -6.318567629165084
+    ],
+    "targetVelocity": [
+      -6.187908604728309
+    ],
+    "targetAcceleration": [
+      -0.252492924066146
+    ],
+    "maxVelocity": [
+      6.523666333740735
+    ],
+    "maxAcceleration": [
+      3.6893141741964866
+    ],
+    "maxJerk": [
+      13.216432993284357
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.84759046438398
+    ],
+    "currentVelocity": [
+      0.654346531527815
+    ],
+    "currentAcceleration": [
+      -3.2851105183759843
+    ],
+    "targetPosition": [
+      -9.104669412355781
+    ],
+    "targetVelocity": [
+      2.5627785885516596
+    ],
+    "targetAcceleration": [
+      5.199065106195395
+    ],
+    "maxVelocity": [
+      3.479277943039375
+    ],
+    "maxAcceleration": [
+      8.842055093443253
+    ],
+    "maxJerk": [
+      8.592215941141543
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.9764795855969961
+    ],
+    "currentVelocity": [
+      -2.266195656286683
+    ],
+    "currentAcceleration": [
+      0.8276975676856608
+    ],
+    "targetPosition": [
+      -1.3472375287723182
+    ],
+    "targetVelocity": [
+      0.4580127109914667
+    ],
+    "targetAcceleration": [
+      -2.231236723693971
+    ],
+    "maxVelocity": [
+      5.948138092358812
+    ],
+    "maxAcceleration": [
+      6.097504410407384
+    ],
+    "maxJerk": [
+      6.589804376715652
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.432893060798717
+    ],
+    "currentVelocity": [
+      2.745481818848197
+    ],
+    "currentAcceleration": [
+      3.7092152981533086
+    ],
+    "targetPosition": [
+      -2.7682614927419635
+    ],
+    "targetVelocity": [
+      -4.023395657492818
+    ],
+    "targetAcceleration": [
+      1.8782744048387947
+    ],
+    "maxVelocity": [
+      7.062415184616259
+    ],
+    "maxAcceleration": [
+      6.23816538134653
+    ],
+    "maxJerk": [
+      13.228212745686786
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.517228640075757
+    ],
+    "currentVelocity": [
+      1.3754645400637031
+    ],
+    "currentAcceleration": [
+      3.9206325517068583
+    ],
+    "targetPosition": [
+      -5.538797604151262
+    ],
+    "targetVelocity": [
+      0.9247991508234534
+    ],
+    "targetAcceleration": [
+      3.410786890399307
+    ],
+    "maxVelocity": [
+      7.333119521797238
+    ],
+    "maxAcceleration": [
+      4.68437727639619
+    ],
+    "maxJerk": [
+      12.705094193402008
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.530628974256083
+    ],
+    "currentVelocity": [
+      2.166932597232708
+    ],
+    "currentAcceleration": [
+      1.3420044982288175
+    ],
+    "targetPosition": [
+      -6.574266159305022
+    ],
+    "targetVelocity": [
+      -0.7477836886512179
+    ],
+    "targetAcceleration": [
+      1.805912488204279
+    ],
+    "maxVelocity": [
+      2.6510446560868486
+    ],
+    "maxAcceleration": [
+      3.6178974698337143
+    ],
+    "maxJerk": [
+      5.683551521851617
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.250302444485913
+    ],
+    "currentVelocity": [
+      -1.1805850184852362
+    ],
+    "currentAcceleration": [
+      -4.577282725382893
+    ],
+    "targetPosition": [
+      9.450453619614542
+    ],
+    "targetVelocity": [
+      -0.3851323636463384
+    ],
+    "targetAcceleration": [
+      -4.049281893142579
+    ],
+    "maxVelocity": [
+      7.788973734221611
+    ],
+    "maxAcceleration": [
+      7.122577236917479
+    ],
+    "maxJerk": [
+      18.497110158385134
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.11059155851937064
+    ],
+    "currentVelocity": [
+      0.4603053517981479
+    ],
+    "currentAcceleration": [
+      -2.11257627552631
+    ],
+    "targetPosition": [
+      -9.66150467661199
+    ],
+    "targetVelocity": [
+      -0.7434595991721507
+    ],
+    "targetAcceleration": [
+      -4.20966746715265
+    ],
+    "maxVelocity": [
+      4.976198183172428
+    ],
+    "maxAcceleration": [
+      7.156756797179963
+    ],
+    "maxJerk": [
+      5.912477068563551
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.4582188446891937
+    ],
+    "currentVelocity": [
+      -2.306123434914369
+    ],
+    "currentAcceleration": [
+      2.700525364619158
+    ],
+    "targetPosition": [
+      -3.9333229742999816
+    ],
+    "targetVelocity": [
+      -5.166982513677829
+    ],
+    "targetAcceleration": [
+      0.26662862903243223
+    ],
+    "maxVelocity": [
+      5.598667848729633
+    ],
+    "maxAcceleration": [
+      4.744762329822726
+    ],
+    "maxJerk": [
+      14.897389632280207
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.1612850600183258
+    ],
+    "currentVelocity": [
+      4.7313510603529405
+    ],
+    "currentAcceleration": [
+      0.8923243428324019
+    ],
+    "targetPosition": [
+      -3.4604576455039453
+    ],
+    "targetVelocity": [
+      -1.8520184989498603
+    ],
+    "targetAcceleration": [
+      -1.9432440384392713
+    ],
+    "maxVelocity": [
+      6.202600614171642
+    ],
+    "maxAcceleration": [
+      7.200854445475399
+    ],
+    "maxJerk": [
+      18.371845219639457
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.995539698902668
+    ],
+    "currentVelocity": [
+      -2.828053671282636
+    ],
+    "currentAcceleration": [
+      -2.9496901647618916
+    ],
+    "targetPosition": [
+      -3.6026104513903405
+    ],
+    "targetVelocity": [
+      4.179534415556121
+    ],
+    "targetAcceleration": [
+      3.2574664734102186
+    ],
+    "maxVelocity": [
+      6.217288886269992
+    ],
+    "maxAcceleration": [
+      4.940912504738202
+    ],
+    "maxJerk": [
+      14.488358806620562
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.667593420505633
+    ],
+    "currentVelocity": [
+      -3.144992789486383
+    ],
+    "currentAcceleration": [
+      1.284230230450076
+    ],
+    "targetPosition": [
+      3.6779702696837298
+    ],
+    "targetVelocity": [
+      4.849873304951089
+    ],
+    "targetAcceleration": [
+      6.38009823024484
+    ],
+    "maxVelocity": [
+      6.48977095822047
+    ],
+    "maxAcceleration": [
+      7.602742159254232
+    ],
+    "maxJerk": [
+      16.625852999803833
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.266303681271042
+    ],
+    "currentVelocity": [
+      -1.7741686724852705
+    ],
+    "currentAcceleration": [
+      6.9392540920159504
+    ],
+    "targetPosition": [
+      -2.8712246219207804
+    ],
+    "targetVelocity": [
+      -3.250631912753528
+    ],
+    "targetAcceleration": [
+      -0.7815312973981516
+    ],
+    "maxVelocity": [
+      7.281005604268896
+    ],
+    "maxAcceleration": [
+      6.960759935736013
+    ],
+    "maxJerk": [
+      13.177431325909113
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.5796977605691147
+    ],
+    "currentVelocity": [
+      -2.577906756451494
+    ],
+    "currentAcceleration": [
+      -3.5578046376697583
+    ],
+    "targetPosition": [
+      -7.942482769463284
+    ],
+    "targetVelocity": [
+      -0.9109347789303524
+    ],
+    "targetAcceleration": [
+      4.805022086074865
+    ],
+    "maxVelocity": [
+      3.654639927627888
+    ],
+    "maxAcceleration": [
+      7.057588002568015
+    ],
+    "maxJerk": [
+      12.247613353280748
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.21810098785069165
+    ],
+    "currentVelocity": [
+      1.426049372136191
+    ],
+    "currentAcceleration": [
+      -3.8236633257865633
+    ],
+    "targetPosition": [
+      6.361788062048014
+    ],
+    "targetVelocity": [
+      1.6800401899037656
+    ],
+    "targetAcceleration": [
+      2.962933471487041
+    ],
+    "maxVelocity": [
+      2.332178076751518
+    ],
+    "maxAcceleration": [
+      6.698406808978733
+    ],
+    "maxJerk": [
+      5.552941572661957
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6670920874282498
+    ],
+    "currentVelocity": [
+      -2.7009496702837215
+    ],
+    "currentAcceleration": [
+      -6.800228892937563
+    ],
+    "targetPosition": [
+      -9.023439693038743
+    ],
+    "targetVelocity": [
+      0.4358239773125083
+    ],
+    "targetAcceleration": [
+      -1.063982257139724
+    ],
+    "maxVelocity": [
+      5.762394374707206
+    ],
+    "maxAcceleration": [
+      9.962119816589734
+    ],
+    "maxJerk": [
+      8.666170644065717
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.537406766663331
+    ],
+    "currentVelocity": [
+      5.110437445208172
+    ],
+    "currentAcceleration": [
+      -0.7586760126080048
+    ],
+    "targetPosition": [
+      -4.998029999291502
+    ],
+    "targetVelocity": [
+      -0.44170177929768784
+    ],
+    "targetAcceleration": [
+      -0.3661296235834639
+    ],
+    "maxVelocity": [
+      5.721643584596782
+    ],
+    "maxAcceleration": [
+      8.300963047273438
+    ],
+    "maxJerk": [
+      14.883021255180953
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.772930947910161
+    ],
+    "currentVelocity": [
+      -6.73956229390204
+    ],
+    "currentAcceleration": [
+      -3.368454674742458
+    ],
+    "targetPosition": [
+      0.31340310923970804
+    ],
+    "targetVelocity": [
+      4.482440242498256
+    ],
+    "targetAcceleration": [
+      -0.729850435202839
+    ],
+    "maxVelocity": [
+      7.742918734532009
+    ],
+    "maxAcceleration": [
+      3.4121767395442437
+    ],
+    "maxJerk": [
+      11.41562294509881
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.1244621494401912
+    ],
+    "currentVelocity": [
+      -5.378249168158146
+    ],
+    "currentAcceleration": [
+      3.7510273982425497
+    ],
+    "targetPosition": [
+      0.9497223573200504
+    ],
+    "targetVelocity": [
+      1.629996054069423
+    ],
+    "targetAcceleration": [
+      7.266088553891588
+    ],
+    "maxVelocity": [
+      7.056109193829519
+    ],
+    "maxAcceleration": [
+      7.475298431706675
+    ],
+    "maxJerk": [
+      12.429757652592425
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6374025062564623
+    ],
+    "currentVelocity": [
+      6.741906464388916
+    ],
+    "currentAcceleration": [
+      0.04765902235101249
+    ],
+    "targetPosition": [
+      2.217700144176318
+    ],
+    "targetVelocity": [
+      5.601395155147499
+    ],
+    "targetAcceleration": [
+      2.3425282636763622
+    ],
+    "maxVelocity": [
+      7.150061909000841
+    ],
+    "maxAcceleration": [
+      3.209074427745408
+    ],
+    "maxJerk": [
+      6.264728733855698
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6609622739315579
+    ],
+    "currentVelocity": [
+      -1.8878651572035698
+    ],
+    "currentAcceleration": [
+      -1.3553226843962847
+    ],
+    "targetPosition": [
+      4.579516028204747
+    ],
+    "targetVelocity": [
+      0.3991076097296684
+    ],
+    "targetAcceleration": [
+      -0.42537538599152436
+    ],
+    "maxVelocity": [
+      5.386707291964557
+    ],
+    "maxAcceleration": [
+      3.514533325883782
+    ],
+    "maxJerk": [
+      18.935554129824016
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.8504725986141892
+    ],
+    "currentVelocity": [
+      -3.3581412468122362
+    ],
+    "currentAcceleration": [
+      -4.016509437178693
+    ],
+    "targetPosition": [
+      8.645959433383293
+    ],
+    "targetVelocity": [
+      -2.3512840709549403
+    ],
+    "targetAcceleration": [
+      1.464107602535055
+    ],
+    "maxVelocity": [
+      4.752628089751395
+    ],
+    "maxAcceleration": [
+      7.639835412289941
+    ],
+    "maxJerk": [
+      18.24274530564187
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.897364257539984
+    ],
+    "currentVelocity": [
+      3.087390489515778
+    ],
+    "currentAcceleration": [
+      1.149729036288135
+    ],
+    "targetPosition": [
+      0.06732411161634211
+    ],
+    "targetVelocity": [
+      -1.1363052124389084
+    ],
+    "targetAcceleration": [
+      -2.9005961164395977
+    ],
+    "maxVelocity": [
+      4.988956507944495
+    ],
+    "maxAcceleration": [
+      3.695817480309893
+    ],
+    "maxJerk": [
+      12.619604148937139
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.8658878396892487
+    ],
+    "currentVelocity": [
+      3.333053090316012
+    ],
+    "currentAcceleration": [
+      -5.382248698508271
+    ],
+    "targetPosition": [
+      -6.868856419826315
+    ],
+    "targetVelocity": [
+      0.4249207829097008
+    ],
+    "targetAcceleration": [
+      0.6463828666566638
+    ],
+    "maxVelocity": [
+      4.171112236236237
+    ],
+    "maxAcceleration": [
+      6.318290980159297
+    ],
+    "maxJerk": [
+      16.846779863386036
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.998714533621259
+    ],
+    "currentVelocity": [
+      5.913227050363011
+    ],
+    "currentAcceleration": [
+      -2.6270640746012077
+    ],
+    "targetPosition": [
+      -8.371676735810702
+    ],
+    "targetVelocity": [
+      -4.560309636308428
+    ],
+    "targetAcceleration": [
+      0.2363268612282141
+    ],
+    "maxVelocity": [
+      7.725040014160744
+    ],
+    "maxAcceleration": [
+      6.805883398407273
+    ],
+    "maxJerk": [
+      14.458153297820488
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.308317506897726
+    ],
+    "currentVelocity": [
+      -3.7593474226249413
+    ],
+    "currentAcceleration": [
+      -3.0444086921805624
+    ],
+    "targetPosition": [
+      9.558184355382416
+    ],
+    "targetVelocity": [
+      -3.3734909569190488
+    ],
+    "targetAcceleration": [
+      -0.08844271916026969
+    ],
+    "maxVelocity": [
+      6.237498624161938
+    ],
+    "maxAcceleration": [
+      3.8635027473977623
+    ],
+    "maxJerk": [
+      17.487029637508897
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.178514770882051
+    ],
+    "currentVelocity": [
+      0.38041661452314024
+    ],
+    "currentAcceleration": [
+      -0.5621753173822088
+    ],
+    "targetPosition": [
+      -2.8951048124057044
+    ],
+    "targetVelocity": [
+      4.360815558555989
+    ],
+    "targetAcceleration": [
+      3.9485799731776896
+    ],
+    "maxVelocity": [
+      4.656119522301261
+    ],
+    "maxAcceleration": [
+      3.9725827647848964
+    ],
+    "maxJerk": [
+      17.743717998559397
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.625909402294923
+    ],
+    "currentVelocity": [
+      0.0022150112523542376
+    ],
+    "currentAcceleration": [
+      -5.528552642764304
+    ],
+    "targetPosition": [
+      -8.4989746792448
+    ],
+    "targetVelocity": [
+      -5.437010368257929
+    ],
+    "targetAcceleration": [
+      -0.43792676170028955
+    ],
+    "maxVelocity": [
+      7.112399954100547
+    ],
+    "maxAcceleration": [
+      9.99680128140906
+    ],
+    "maxJerk": [
+      6.701493665246544
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.733671527374456
+    ],
+    "currentVelocity": [
+      4.263240816977891
+    ],
+    "currentAcceleration": [
+      1.9406213789437894
+    ],
+    "targetPosition": [
+      6.064516347716516
+    ],
+    "targetVelocity": [
+      -3.087663812599852
+    ],
+    "targetAcceleration": [
+      -4.390167550485664
+    ],
+    "maxVelocity": [
+      4.70930931976209
+    ],
+    "maxAcceleration": [
+      7.403266747593235
+    ],
+    "maxJerk": [
+      6.636186968312593
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.528813110454564
+    ],
+    "currentVelocity": [
+      -0.36448585508543374
+    ],
+    "currentAcceleration": [
+      -0.2749025574977231
+    ],
+    "targetPosition": [
+      7.485235092974396
+    ],
+    "targetVelocity": [
+      -0.9739158524167246
+    ],
+    "targetAcceleration": [
+      2.93835668658353
+    ],
+    "maxVelocity": [
+      4.405582689406944
+    ],
+    "maxAcceleration": [
+      3.6159867536983716
+    ],
+    "maxJerk": [
+      5.631874292824553
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.8785472640386374
+    ],
+    "currentVelocity": [
+      1.8577269593993053
+    ],
+    "currentAcceleration": [
+      -5.244263873924806
+    ],
+    "targetPosition": [
+      -8.275875232913144
+    ],
+    "targetVelocity": [
+      -0.6902311180408982
+    ],
+    "targetAcceleration": [
+      2.3883097224206535
+    ],
+    "maxVelocity": [
+      4.27862018913255
+    ],
+    "maxAcceleration": [
+      6.39621247007418
+    ],
+    "maxJerk": [
+      5.0371805610616285
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.302260605551906
+    ],
+    "currentVelocity": [
+      -2.032194469512085
+    ],
+    "currentAcceleration": [
+      0.17817712773277083
+    ],
+    "targetPosition": [
+      6.016367841019907
+    ],
+    "targetVelocity": [
+      -4.7325101337195505
+    ],
+    "targetAcceleration": [
+      -0.31103097236805777
+    ],
+    "maxVelocity": [
+      6.545997554839276
+    ],
+    "maxAcceleration": [
+      4.790071618153601
+    ],
+    "maxJerk": [
+      18.073499273599996
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.369123854659787
+    ],
+    "currentVelocity": [
+      -0.7146340292766169
+    ],
+    "currentAcceleration": [
+      -6.138022042677967
+    ],
+    "targetPosition": [
+      3.4626645359111308
+    ],
+    "targetVelocity": [
+      1.0823728185882322
+    ],
+    "targetAcceleration": [
+      0.8291665617044632
+    ],
+    "maxVelocity": [
+      5.0146056918418696
+    ],
+    "maxAcceleration": [
+      8.933010084404886
+    ],
+    "maxJerk": [
+      5.207979654096993
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.7151508452271429
+    ],
+    "currentVelocity": [
+      -1.4381986923283057
+    ],
+    "currentAcceleration": [
+      6.621299904531571
+    ],
+    "targetPosition": [
+      -5.322230376140828
+    ],
+    "targetVelocity": [
+      2.3595366075925757
+    ],
+    "targetAcceleration": [
+      0.5281716208067833
+    ],
+    "maxVelocity": [
+      6.498886874108807
+    ],
+    "maxAcceleration": [
+      7.457094885077441
+    ],
+    "maxJerk": [
+      16.651858677618137
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.668907962299041
+    ],
+    "currentVelocity": [
+      -1.4438214066802697
+    ],
+    "currentAcceleration": [
+      0.39307722073137974
+    ],
+    "targetPosition": [
+      -8.944005858647625
+    ],
+    "targetVelocity": [
+      -2.5310701769359802
+    ],
+    "targetAcceleration": [
+      0.5354150114408913
+    ],
+    "maxVelocity": [
+      4.590990791954862
+    ],
+    "maxAcceleration": [
+      3.86163965374668
+    ],
+    "maxJerk": [
+      19.183050191310546
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.930027732631546
+    ],
+    "currentVelocity": [
+      7.16195609180734
+    ],
+    "currentAcceleration": [
+      -6.406295547133221
+    ],
+    "targetPosition": [
+      9.485775827653914
+    ],
+    "targetVelocity": [
+      -5.719289298879714
+    ],
+    "targetAcceleration": [
+      3.847405562151179
+    ],
+    "maxVelocity": [
+      7.902722862776734
+    ],
+    "maxAcceleration": [
+      9.53863764877825
+    ],
+    "maxJerk": [
+      14.056392635337021
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.75377734642127
+    ],
+    "currentVelocity": [
+      -1.5292472866984799
+    ],
+    "currentAcceleration": [
+      -3.730852002188783
+    ],
+    "targetPosition": [
+      7.723894156062883
+    ],
+    "targetVelocity": [
+      1.0352786310414013
+    ],
+    "targetAcceleration": [
+      -4.293716951397981
+    ],
+    "maxVelocity": [
+      4.0158530685181635
+    ],
+    "maxAcceleration": [
+      7.8801236361003
+    ],
+    "maxJerk": [
+      18.719054039578438
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.963307475718045
+    ],
+    "currentVelocity": [
+      -5.552876941406703
+    ],
+    "currentAcceleration": [
+      0.29314795653646986
+    ],
+    "targetPosition": [
+      -5.669795353085531
+    ],
+    "targetVelocity": [
+      6.166772555602829
+    ],
+    "targetAcceleration": [
+      -0.46237566125306984
+    ],
+    "maxVelocity": [
+      7.078871461051206
+    ],
+    "maxAcceleration": [
+      4.700413191095686
+    ],
+    "maxJerk": [
+      10.31575960076317
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.84930290517615
+    ],
+    "currentVelocity": [
+      0.39296127092834343
+    ],
+    "currentAcceleration": [
+      -5.30924342769314
+    ],
+    "targetPosition": [
+      -9.11153732197831
+    ],
+    "targetVelocity": [
+      1.873130847318686
+    ],
+    "targetAcceleration": [
+      -7.93126428797836
+    ],
+    "maxVelocity": [
+      5.50526444724731
+    ],
+    "maxAcceleration": [
+      8.54400423454232
+    ],
+    "maxJerk": [
+      17.155322668392458
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.512036802882932
+    ],
+    "currentVelocity": [
+      1.9951596564895215
+    ],
+    "currentAcceleration": [
+      8.421027054208006
+    ],
+    "targetPosition": [
+      -5.20411343108953
+    ],
+    "targetVelocity": [
+      6.015941191870212
+    ],
+    "targetAcceleration": [
+      4.116291724246516
+    ],
+    "maxVelocity": [
+      7.837617621205943
+    ],
+    "maxAcceleration": [
+      8.676759015912525
+    ],
+    "maxJerk": [
+      18.76724652333462
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.907568320087215
+    ],
+    "currentVelocity": [
+      -1.4595072416279233
+    ],
+    "currentAcceleration": [
+      4.8251026288875005
+    ],
+    "targetPosition": [
+      0.2233316422976639
+    ],
+    "targetVelocity": [
+      5.688751111843771
+    ],
+    "targetAcceleration": [
+      -0.9878696209140729
+    ],
+    "maxVelocity": [
+      5.887364820508821
+    ],
+    "maxAcceleration": [
+      6.3516181614390534
+    ],
+    "maxJerk": [
+      9.888903573202644
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.821087176101205
+    ],
+    "currentVelocity": [
+      0.5845035607924114
+    ],
+    "currentAcceleration": [
+      -5.626506046029087
+    ],
+    "targetPosition": [
+      4.419771624264454
+    ],
+    "targetVelocity": [
+      -0.13218918822668613
+    ],
+    "targetAcceleration": [
+      -2.30709669218142
+    ],
+    "maxVelocity": [
+      6.084093059072415
+    ],
+    "maxAcceleration": [
+      9.772543526948162
+    ],
+    "maxJerk": [
+      8.029132515053021
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.161671718178077
+    ],
+    "currentVelocity": [
+      -1.4130210925807045
+    ],
+    "currentAcceleration": [
+      0.4789584670508287
+    ],
+    "targetPosition": [
+      2.824210808762457
+    ],
+    "targetVelocity": [
+      -1.5033845408153708
+    ],
+    "targetAcceleration": [
+      2.931173156163056
+    ],
+    "maxVelocity": [
+      4.26755272275528
+    ],
+    "maxAcceleration": [
+      3.7846197869568092
+    ],
+    "maxJerk": [
+      5.01317711069086
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.2684069499294175
+    ],
+    "currentVelocity": [
+      4.612207758965441
+    ],
+    "currentAcceleration": [
+      2.4103693269759523
+    ],
+    "targetPosition": [
+      -1.2379025817686902
+    ],
+    "targetVelocity": [
+      3.770769766781875
+    ],
+    "targetAcceleration": [
+      2.2810005552611248
+    ],
+    "maxVelocity": [
+      5.096206365256197
+    ],
+    "maxAcceleration": [
+      4.814976163441442
+    ],
+    "maxJerk": [
+      16.100797401058827
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.874878644226813
+    ],
+    "currentVelocity": [
+      -1.505974458020391
+    ],
+    "currentAcceleration": [
+      2.2619275408876023
+    ],
+    "targetPosition": [
+      -7.018622616639654
+    ],
+    "targetVelocity": [
+      -1.967947747581932
+    ],
+    "targetAcceleration": [
+      0.15664630751776887
+    ],
+    "maxVelocity": [
+      3.6364419921103304
+    ],
+    "maxAcceleration": [
+      3.508251956653596
+    ],
+    "maxJerk": [
+      19.7434446831669
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.4017129318380945
+    ],
+    "currentVelocity": [
+      3.2382062813076153
+    ],
+    "currentAcceleration": [
+      1.2992128472695814
+    ],
+    "targetPosition": [
+      8.02993296049279
+    ],
+    "targetVelocity": [
+      0.3658100931400625
+    ],
+    "targetAcceleration": [
+      5.616245142708559
+    ],
+    "maxVelocity": [
+      5.652627975603023
+    ],
+    "maxAcceleration": [
+      8.951543179810919
+    ],
+    "maxJerk": [
+      14.837078129904139
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.294207273912845
+    ],
+    "currentVelocity": [
+      3.983286991217158
+    ],
+    "currentAcceleration": [
+      -8.914684729053883
+    ],
+    "targetPosition": [
+      -4.803681666683628
+    ],
+    "targetVelocity": [
+      -1.6714867922944618
+    ],
+    "targetAcceleration": [
+      7.726167071079523
+    ],
+    "maxVelocity": [
+      5.154761733493343
+    ],
+    "maxAcceleration": [
+      9.429816459773232
+    ],
+    "maxJerk": [
+      17.425924328085934
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.702841668247723
+    ],
+    "currentVelocity": [
+      4.31617396967701
+    ],
+    "currentAcceleration": [
+      -3.98065310813168
+    ],
+    "targetPosition": [
+      8.017031680851257
+    ],
+    "targetVelocity": [
+      1.8966793821216719
+    ],
+    "targetAcceleration": [
+      -2.812725309621125
+    ],
+    "maxVelocity": [
+      7.287188520351883
+    ],
+    "maxAcceleration": [
+      6.473638300937145
+    ],
+    "maxJerk": [
+      18.019456172330777
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.162256369879753
+    ],
+    "currentVelocity": [
+      -2.803129618036234
+    ],
+    "currentAcceleration": [
+      -1.3185438284895905
+    ],
+    "targetPosition": [
+      -6.820287097728588
+    ],
+    "targetVelocity": [
+      0.3149010152829459
+    ],
+    "targetAcceleration": [
+      -1.8466759755621156
+    ],
+    "maxVelocity": [
+      2.9452749007233527
+    ],
+    "maxAcceleration": [
+      3.1302181552114883
+    ],
+    "maxJerk": [
+      13.629699617212443
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.625350612485722
+    ],
+    "currentVelocity": [
+      -7.285058446338797
+    ],
+    "currentAcceleration": [
+      -0.2246324352034197
+    ],
+    "targetPosition": [
+      -0.9358036001961665
+    ],
+    "targetVelocity": [
+      -6.042395485081944
+    ],
+    "targetAcceleration": [
+      0.8587077521541646
+    ],
+    "maxVelocity": [
+      7.638860865069
+    ],
+    "maxAcceleration": [
+      4.412102584319401
+    ],
+    "maxJerk": [
+      14.498834940636707
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.269347470412576
+    ],
+    "currentVelocity": [
+      -0.707988365795148
+    ],
+    "currentAcceleration": [
+      0.14519082634483382
+    ],
+    "targetPosition": [
+      -3.0443734920492993
+    ],
+    "targetVelocity": [
+      -2.0196653491047813
+    ],
+    "targetAcceleration": [
+      -7.26464312350609
+    ],
+    "maxVelocity": [
+      2.0550114731960996
+    ],
+    "maxAcceleration": [
+      8.164124890699458
+    ],
+    "maxJerk": [
+      8.356087237048897
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.495804956997327
+    ],
+    "currentVelocity": [
+      -4.807666846643167
+    ],
+    "currentAcceleration": [
+      4.667120590628043
+    ],
+    "targetPosition": [
+      -2.303509265303867
+    ],
+    "targetVelocity": [
+      6.295905669625611
+    ],
+    "targetAcceleration": [
+      2.038680129449368
+    ],
+    "maxVelocity": [
+      7.957238998610752
+    ],
+    "maxAcceleration": [
+      5.082349273314694
+    ],
+    "maxJerk": [
+      12.814128910708641
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.1690971302535331
+    ],
+    "currentVelocity": [
+      2.7562719066242916
+    ],
+    "currentAcceleration": [
+      0.21535352945497443
+    ],
+    "targetPosition": [
+      -7.2067879186563495
+    ],
+    "targetVelocity": [
+      -1.1161245752087978
+    ],
+    "targetAcceleration": [
+      3.1413102070973897
+    ],
+    "maxVelocity": [
+      2.9723168852692976
+    ],
+    "maxAcceleration": [
+      3.2471993409400177
+    ],
+    "maxJerk": [
+      16.971866748617682
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.323068501398429
+    ],
+    "currentVelocity": [
+      -0.016745716334090943
+    ],
+    "currentAcceleration": [
+      2.848455345775334
+    ],
+    "targetPosition": [
+      -8.538841534153637
+    ],
+    "targetVelocity": [
+      5.18543882860775
+    ],
+    "targetAcceleration": [
+      -0.8353884992427805
+    ],
+    "maxVelocity": [
+      6.869660270743199
+    ],
+    "maxAcceleration": [
+      5.904875205386186
+    ],
+    "maxJerk": [
+      5.106394876411636
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.0348101900959534
+    ],
+    "currentVelocity": [
+      -0.17585311606462106
+    ],
+    "currentAcceleration": [
+      -4.9757455669329715
+    ],
+    "targetPosition": [
+      -1.1609256457840438
+    ],
+    "targetVelocity": [
+      2.7048670267735258
+    ],
+    "targetAcceleration": [
+      3.8877122162798887
+    ],
+    "maxVelocity": [
+      5.141309411538579
+    ],
+    "maxAcceleration": [
+      5.162482627499191
+    ],
+    "maxJerk": [
+      7.076348514357896
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.67980138535167
+    ],
+    "currentVelocity": [
+      -0.23065675206101055
+    ],
+    "currentAcceleration": [
+      -3.4149190052474996
+    ],
+    "targetPosition": [
+      -0.26143790474199236
+    ],
+    "targetVelocity": [
+      0.3169837160496871
+    ],
+    "targetAcceleration": [
+      -1.1808621356638733
+    ],
+    "maxVelocity": [
+      3.1216097416003667
+    ],
+    "maxAcceleration": [
+      4.326091521813314
+    ],
+    "maxJerk": [
+      15.255434418696831
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.055390596235521
+    ],
+    "currentVelocity": [
+      0.013151827293713225
+    ],
+    "currentAcceleration": [
+      -3.660238647724584
+    ],
+    "targetPosition": [
+      -5.791400911058952
+    ],
+    "targetVelocity": [
+      5.536250053298962
+    ],
+    "targetAcceleration": [
+      6.513150038178292
+    ],
+    "maxVelocity": [
+      7.027915002427489
+    ],
+    "maxAcceleration": [
+      6.59498789451033
+    ],
+    "maxJerk": [
+      17.914569884677814
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.2692143223895442
+    ],
+    "currentVelocity": [
+      -2.8017639705351693
+    ],
+    "currentAcceleration": [
+      2.2855953931208943
+    ],
+    "targetPosition": [
+      3.516031314269693
+    ],
+    "targetVelocity": [
+      2.93662873316598
+    ],
+    "targetAcceleration": [
+      0.07939064668859164
+    ],
+    "maxVelocity": [
+      4.8375178017497005
+    ],
+    "maxAcceleration": [
+      3.0357808025997888
+    ],
+    "maxJerk": [
+      6.589951014500713
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.036142224187039
+    ],
+    "currentVelocity": [
+      -3.2161384089988783
+    ],
+    "currentAcceleration": [
+      -2.7345157214088003
+    ],
+    "targetPosition": [
+      7.230962254731477
+    ],
+    "targetVelocity": [
+      7.703860659967355
+    ],
+    "targetAcceleration": [
+      -0.3748489930387242
+    ],
+    "maxVelocity": [
+      7.949170876345783
+    ],
+    "maxAcceleration": [
+      6.871161297711098
+    ],
+    "maxJerk": [
+      14.455156564959172
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.0457508149449914
+    ],
+    "currentVelocity": [
+      4.539961774547873
+    ],
+    "currentAcceleration": [
+      -0.1573667686016007
+    ],
+    "targetPosition": [
+      -4.310364388115979
+    ],
+    "targetVelocity": [
+      5.14695110284892
+    ],
+    "targetAcceleration": [
+      -4.474735968839419
+    ],
+    "maxVelocity": [
+      6.392090346496241
+    ],
+    "maxAcceleration": [
+      5.481630884027824
+    ],
+    "maxJerk": [
+      17.793407940971825
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.571143134335287
+    ],
+    "currentVelocity": [
+      -3.7661787946473293
+    ],
+    "currentAcceleration": [
+      -5.723218192080389
+    ],
+    "targetPosition": [
+      -1.9238581073495915
+    ],
+    "targetVelocity": [
+      -1.0850907590739292
+    ],
+    "targetAcceleration": [
+      -1.848657160665999
+    ],
+    "maxVelocity": [
+      5.606483130042674
+    ],
+    "maxAcceleration": [
+      6.798735114449274
+    ],
+    "maxJerk": [
+      18.546985816019536
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.737648009772421
+    ],
+    "currentVelocity": [
+      -4.376295392377588
+    ],
+    "currentAcceleration": [
+      -1.7892182359902353
+    ],
+    "targetPosition": [
+      -2.857748954397401
+    ],
+    "targetVelocity": [
+      0.7535645738548427
+    ],
+    "targetAcceleration": [
+      -2.0257819618261568
+    ],
+    "maxVelocity": [
+      6.8412683176261755
+    ],
+    "maxAcceleration": [
+      6.177820257380259
+    ],
+    "maxJerk": [
+      17.914154615155045
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.7353838440283038
+    ],
+    "currentVelocity": [
+      0.1417827927141051
+    ],
+    "currentAcceleration": [
+      0.8386305495670028
+    ],
+    "targetPosition": [
+      2.454384809973451
+    ],
+    "targetVelocity": [
+      4.26743481461767
+    ],
+    "targetAcceleration": [
+      -4.209449287449246
+    ],
+    "maxVelocity": [
+      5.369486978732781
+    ],
+    "maxAcceleration": [
+      4.236734378591781
+    ],
+    "maxJerk": [
+      15.916222485228275
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.7878793070691295
+    ],
+    "currentVelocity": [
+      -5.436412860525689
+    ],
+    "currentAcceleration": [
+      4.802092370572966
+    ],
+    "targetPosition": [
+      -0.9928792371155168
+    ],
+    "targetVelocity": [
+      1.1263887429818418
+    ],
+    "targetAcceleration": [
+      -2.8275553366702715
+    ],
+    "maxVelocity": [
+      6.835938473118682
+    ],
+    "maxAcceleration": [
+      7.793159333050236
+    ],
+    "maxJerk": [
+      7.492526881899307
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.119196038782697
+    ],
+    "currentVelocity": [
+      1.1219943091733695
+    ],
+    "currentAcceleration": [
+      2.520958213642885
+    ],
+    "targetPosition": [
+      -9.254854036358719
+    ],
+    "targetVelocity": [
+      -1.435664002253916
+    ],
+    "targetAcceleration": [
+      -4.386500990174505
+    ],
+    "maxVelocity": [
+      2.0951755827662106
+    ],
+    "maxAcceleration": [
+      5.347954135818029
+    ],
+    "maxJerk": [
+      9.29973951014053
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.1782294026333524
+    ],
+    "currentVelocity": [
+      6.628388112305412
+    ],
+    "currentAcceleration": [
+      4.221465718839735
+    ],
+    "targetPosition": [
+      1.3396360974784258
+    ],
+    "targetVelocity": [
+      -0.2737397562222741
+    ],
+    "targetAcceleration": [
+      4.5268450589772495
+    ],
+    "maxVelocity": [
+      7.545000079598319
+    ],
+    "maxAcceleration": [
+      5.773542091759401
+    ],
+    "maxJerk": [
+      12.450151740911195
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.118514172030864
+    ],
+    "currentVelocity": [
+      0.30904836456771
+    ],
+    "currentAcceleration": [
+      0.4970952332787002
+    ],
+    "targetPosition": [
+      -0.661234550996701
+    ],
+    "targetVelocity": [
+      -3.1938768587133013
+    ],
+    "targetAcceleration": [
+      0.9974787687662188
+    ],
+    "maxVelocity": [
+      5.986167754390191
+    ],
+    "maxAcceleration": [
+      3.7866276886323567
+    ],
+    "maxJerk": [
+      5.229828503370049
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.252660086840567
+    ],
+    "currentVelocity": [
+      1.2153991617227486
+    ],
+    "currentAcceleration": [
+      0.8095702180527837
+    ],
+    "targetPosition": [
+      6.722495184724167
+    ],
+    "targetVelocity": [
+      4.494501625397456
+    ],
+    "targetAcceleration": [
+      -4.75967666479081
+    ],
+    "maxVelocity": [
+      6.371366282449156
+    ],
+    "maxAcceleration": [
+      7.376293439715026
+    ],
+    "maxJerk": [
+      7.737648751750009
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.970618137491147
+    ],
+    "currentVelocity": [
+      -0.80068498814006
+    ],
+    "currentAcceleration": [
+      -0.3516133002521693
+    ],
+    "targetPosition": [
+      4.3266695592819016
+    ],
+    "targetVelocity": [
+      -1.7941367560097168
+    ],
+    "targetAcceleration": [
+      5.970038292557316
+    ],
+    "maxVelocity": [
+      3.2506268837777696
+    ],
+    "maxAcceleration": [
+      6.439291613915675
+    ],
+    "maxJerk": [
+      14.468362809709426
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.83383055352912
+    ],
+    "currentVelocity": [
+      5.406716878805282
+    ],
+    "currentAcceleration": [
+      3.432324267341433
+    ],
+    "targetPosition": [
+      -4.662082943573072
+    ],
+    "targetVelocity": [
+      -4.711573300967251
+    ],
+    "targetAcceleration": [
+      2.3179469329207985
+    ],
+    "maxVelocity": [
+      6.234644427920902
+    ],
+    "maxAcceleration": [
+      4.703774518591907
+    ],
+    "maxJerk": [
+      11.701636541633523
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.894145963252136
+    ],
+    "currentVelocity": [
+      -4.906768984802205
+    ],
+    "currentAcceleration": [
+      -1.3502196722397528
+    ],
+    "targetPosition": [
+      -6.7010706317827
+    ],
+    "targetVelocity": [
+      -5.45310045294094
+    ],
+    "targetAcceleration": [
+      -2.04260507446259
+    ],
+    "maxVelocity": [
+      6.315561298220491
+    ],
+    "maxAcceleration": [
+      9.648911168306732
+    ],
+    "maxJerk": [
+      8.205596347098476
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.622454145591856
+    ],
+    "currentVelocity": [
+      1.9547683488438015
+    ],
+    "currentAcceleration": [
+      3.942221498492028
+    ],
+    "targetPosition": [
+      -2.485787126564974
+    ],
+    "targetVelocity": [
+      0.7193528616101785
+    ],
+    "targetAcceleration": [
+      4.1906956555970005
+    ],
+    "maxVelocity": [
+      5.508425692922952
+    ],
+    "maxAcceleration": [
+      7.135911428543606
+    ],
+    "maxJerk": [
+      12.816935544609393
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.0201812657433846
+    ],
+    "currentVelocity": [
+      -1.1457159454274106
+    ],
+    "currentAcceleration": [
+      1.7824940754400975
+    ],
+    "targetPosition": [
+      8.254790065861076
+    ],
+    "targetVelocity": [
+      -1.2310964605914387
+    ],
+    "targetAcceleration": [
+      -3.2848994051222586
+    ],
+    "maxVelocity": [
+      3.6080735959123538
+    ],
+    "maxAcceleration": [
+      5.932240332346677
+    ],
+    "maxJerk": [
+      13.43683879624574
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.5775360285906457
+    ],
+    "currentVelocity": [
+      -0.4484699547794664
+    ],
+    "currentAcceleration": [
+      3.5415293940836383
+    ],
+    "targetPosition": [
+      8.248558968231478
+    ],
+    "targetVelocity": [
+      2.786705901063282
+    ],
+    "targetAcceleration": [
+      0.6451124953532226
+    ],
+    "maxVelocity": [
+      4.683782392276698
+    ],
+    "maxAcceleration": [
+      4.419248672424218
+    ],
+    "maxJerk": [
+      9.573084643799293
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.9113725373737083
+    ],
+    "currentVelocity": [
+      -0.06543759148424444
+    ],
+    "currentAcceleration": [
+      4.025693136002542
+    ],
+    "targetPosition": [
+      -9.764974221742662
+    ],
+    "targetVelocity": [
+      0.30273256445068375
+    ],
+    "targetAcceleration": [
+      1.3352384974126386
+    ],
+    "maxVelocity": [
+      2.498363604976962
+    ],
+    "maxAcceleration": [
+      4.134452423188031
+    ],
+    "maxJerk": [
+      6.7771964066383905
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.8491597813938334
+    ],
+    "currentVelocity": [
+      1.2062049364397103
+    ],
+    "currentAcceleration": [
+      -6.23007297194563
+    ],
+    "targetPosition": [
+      6.294477431126452
+    ],
+    "targetVelocity": [
+      -0.9865570791957312
+    ],
+    "targetAcceleration": [
+      -2.6497883672415306
+    ],
+    "maxVelocity": [
+      6.777733066087104
+    ],
+    "maxAcceleration": [
+      7.3297355909828115
+    ],
+    "maxJerk": [
+      6.306195479305702
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.502757024920168
+    ],
+    "currentVelocity": [
+      -2.227326454982874
+    ],
+    "currentAcceleration": [
+      -1.9188711283739637
+    ],
+    "targetPosition": [
+      -8.967613069544143
+    ],
+    "targetVelocity": [
+      3.367871157515448
+    ],
+    "targetAcceleration": [
+      1.8141972057087141
+    ],
+    "maxVelocity": [
+      4.906747733072186
+    ],
+    "maxAcceleration": [
+      5.631875020731749
+    ],
+    "maxJerk": [
+      16.55096815970414
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.34697161900629
+    ],
+    "currentVelocity": [
+      -2.7817098412157355
+    ],
+    "currentAcceleration": [
+      -1.8723976939454927
+    ],
+    "targetPosition": [
+      -8.010956912283199
+    ],
+    "targetVelocity": [
+      -2.7420209449830653
+    ],
+    "targetAcceleration": [
+      -3.1140881385125976
+    ],
+    "maxVelocity": [
+      7.387556835278664
+    ],
+    "maxAcceleration": [
+      3.645472582763697
+    ],
+    "maxJerk": [
+      8.19313944335859
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.683559347762367
+    ],
+    "currentVelocity": [
+      0.9805739617255176
+    ],
+    "currentAcceleration": [
+      4.381632559364142
+    ],
+    "targetPosition": [
+      -7.776795259634404
+    ],
+    "targetVelocity": [
+      -0.2118765639840996
+    ],
+    "targetAcceleration": [
+      4.8728176856994985
+    ],
+    "maxVelocity": [
+      6.186248462379922
+    ],
+    "maxAcceleration": [
+      7.874337897089088
+    ],
+    "maxJerk": [
+      15.773398069878231
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.805098785942693
+    ],
+    "currentVelocity": [
+      5.456618952656186
+    ],
+    "currentAcceleration": [
+      -1.103109450457004
+    ],
+    "targetPosition": [
+      -4.56953242518561
+    ],
+    "targetVelocity": [
+      0.009370688097527058
+    ],
+    "targetAcceleration": [
+      -6.434532476464964
+    ],
+    "maxVelocity": [
+      5.705067915342651
+    ],
+    "maxAcceleration": [
+      7.552537384865239
+    ],
+    "maxJerk": [
+      12.96704494229117
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.5904476410093178
+    ],
+    "currentVelocity": [
+      3.3679852410833995
+    ],
+    "currentAcceleration": [
+      2.083955275652105
+    ],
+    "targetPosition": [
+      -3.715428785838471
+    ],
+    "targetVelocity": [
+      -5.106594991353036
+    ],
+    "targetAcceleration": [
+      3.6069760435093094
+    ],
+    "maxVelocity": [
+      7.5916114079165915
+    ],
+    "maxAcceleration": [
+      7.286638983009285
+    ],
+    "maxJerk": [
+      10.078960116322731
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.11054580216466192
+    ],
+    "currentVelocity": [
+      -1.2889429255352747
+    ],
+    "currentAcceleration": [
+      3.8557366703020968
+    ],
+    "targetPosition": [
+      -8.68854789684301
+    ],
+    "targetVelocity": [
+      -6.188769510677631
+    ],
+    "targetAcceleration": [
+      -4.988266476047946
+    ],
+    "maxVelocity": [
+      6.290385085064366
+    ],
+    "maxAcceleration": [
+      5.687200098181254
+    ],
+    "maxJerk": [
+      6.547479954896184
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.051478526642068
+    ],
+    "currentVelocity": [
+      -6.3681002254069154
+    ],
+    "currentAcceleration": [
+      0.39408798402479306
+    ],
+    "targetPosition": [
+      -0.04097400314064714
+    ],
+    "targetVelocity": [
+      -1.9599319644010489
+    ],
+    "targetAcceleration": [
+      8.079045641426909
+    ],
+    "maxVelocity": [
+      6.752321891320681
+    ],
+    "maxAcceleration": [
+      9.69999910890045
+    ],
+    "maxJerk": [
+      10.498329248266447
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.01583704814755
+    ],
+    "currentVelocity": [
+      -1.7850416352660634
+    ],
+    "currentAcceleration": [
+      1.8258614618713178
+    ],
+    "targetPosition": [
+      5.101813297660275
+    ],
+    "targetVelocity": [
+      -1.6902573765584672
+    ],
+    "targetAcceleration": [
+      -0.5340706898501786
+    ],
+    "maxVelocity": [
+      3.1380156033001065
+    ],
+    "maxAcceleration": [
+      3.3712370624170767
+    ],
+    "maxJerk": [
+      14.51705797597517
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.158132143885634
+    ],
+    "currentVelocity": [
+      2.515343895864965
+    ],
+    "currentAcceleration": [
+      3.226020474067734
+    ],
+    "targetPosition": [
+      6.1862978950382335
+    ],
+    "targetVelocity": [
+      2.1770018613654223
+    ],
+    "targetAcceleration": [
+      -0.5866471355166358
+    ],
+    "maxVelocity": [
+      3.185772073930618
+    ],
+    "maxAcceleration": [
+      3.3971445504525417
+    ],
+    "maxJerk": [
+      8.660035933327595
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.032100008778839
+    ],
+    "currentVelocity": [
+      -5.053745417625203
+    ],
+    "currentAcceleration": [
+      -2.6871459064541736
+    ],
+    "targetPosition": [
+      0.3091879788511669
+    ],
+    "targetVelocity": [
+      1.6014091885743893
+    ],
+    "targetAcceleration": [
+      -3.3915217080630002
+    ],
+    "maxVelocity": [
+      6.440627280655312
+    ],
+    "maxAcceleration": [
+      4.968237007745693
+    ],
+    "maxJerk": [
+      9.891401090529632
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.976089138697429
+    ],
+    "currentVelocity": [
+      -2.9177064770373433
+    ],
+    "currentAcceleration": [
+      0.4517817969646103
+    ],
+    "targetPosition": [
+      9.114540560956101
+    ],
+    "targetVelocity": [
+      -5.006512335529678
+    ],
+    "targetAcceleration": [
+      3.167603767052409
+    ],
+    "maxVelocity": [
+      6.631333311946919
+    ],
+    "maxAcceleration": [
+      7.9594210896189495
+    ],
+    "maxJerk": [
+      17.581496542712713
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.529780879581548
+    ],
+    "currentVelocity": [
+      1.881444995748982
+    ],
+    "currentAcceleration": [
+      -1.9391628032594523
+    ],
+    "targetPosition": [
+      0.5620231216000544
+    ],
+    "targetVelocity": [
+      0.7963747445105795
+    ],
+    "targetAcceleration": [
+      2.839218193326226
+    ],
+    "maxVelocity": [
+      3.9885890488806117
+    ],
+    "maxAcceleration": [
+      7.362682659688576
+    ],
+    "maxJerk": [
+      12.204269662111665
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.319263099808442
+    ],
+    "currentVelocity": [
+      -2.0585934758269824
+    ],
+    "currentAcceleration": [
+      4.409341253583233
+    ],
+    "targetPosition": [
+      6.5826529924380495
+    ],
+    "targetVelocity": [
+      -0.6183177138105105
+    ],
+    "targetAcceleration": [
+      0.008840819640392183
+    ],
+    "maxVelocity": [
+      6.2794671879786375
+    ],
+    "maxAcceleration": [
+      4.7727060457959345
+    ],
+    "maxJerk": [
+      12.733607495057129
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.371622559645344
+    ],
+    "currentVelocity": [
+      -5.932646574240833
+    ],
+    "currentAcceleration": [
+      3.049559623728121
+    ],
+    "targetPosition": [
+      -0.24802352871226674
+    ],
+    "targetVelocity": [
+      -5.0298542734512335
+    ],
+    "targetAcceleration": [
+      0.4533304506056144
+    ],
+    "maxVelocity": [
+      7.563630657444314
+    ],
+    "maxAcceleration": [
+      4.289595577681751
+    ],
+    "maxJerk": [
+      17.692695951772613
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.899530085453343
+    ],
+    "currentVelocity": [
+      -2.1258573721987064
+    ],
+    "currentAcceleration": [
+      -1.2999795757263741
+    ],
+    "targetPosition": [
+      0.7921833900102513
+    ],
+    "targetVelocity": [
+      -1.6078623408216814
+    ],
+    "targetAcceleration": [
+      3.345219230323476
+    ],
+    "maxVelocity": [
+      4.795300540002806
+    ],
+    "maxAcceleration": [
+      3.8480727693170182
+    ],
+    "maxJerk": [
+      7.246570930180753
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.683756328151448
+    ],
+    "currentVelocity": [
+      2.458783945002427
+    ],
+    "currentAcceleration": [
+      5.43105820985906
+    ],
+    "targetPosition": [
+      -8.661438450544562
+    ],
+    "targetVelocity": [
+      1.7146894242276565
+    ],
+    "targetAcceleration": [
+      -4.9751106429756025
+    ],
+    "maxVelocity": [
+      3.608195399824454
+    ],
+    "maxAcceleration": [
+      9.142532804802364
+    ],
+    "maxJerk": [
+      19.798485872668973
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.327975392082768
+    ],
+    "currentVelocity": [
+      1.789158413244854
+    ],
+    "currentAcceleration": [
+      -5.0987988761253815
+    ],
+    "targetPosition": [
+      -7.982404455832752
+    ],
+    "targetVelocity": [
+      -0.08132238838602746
+    ],
+    "targetAcceleration": [
+      -6.785333419021631
+    ],
+    "maxVelocity": [
+      6.4941070712191316
+    ],
+    "maxAcceleration": [
+      6.866110313300539
+    ],
+    "maxJerk": [
+      12.435484458042984
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.66121380223052
+    ],
+    "currentVelocity": [
+      7.71976800238651
+    ],
+    "currentAcceleration": [
+      0.8067958916456845
+    ],
+    "targetPosition": [
+      -2.7315932511690066
+    ],
+    "targetVelocity": [
+      6.323572099880123
+    ],
+    "targetAcceleration": [
+      1.1742525862336413
+    ],
+    "maxVelocity": [
+      7.9560390130881595
+    ],
+    "maxAcceleration": [
+      6.338434822462112
+    ],
+    "maxJerk": [
+      12.707020599212374
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.8788712780207213
+    ],
+    "currentVelocity": [
+      -2.3825476637272325
+    ],
+    "currentAcceleration": [
+      6.877750314121938
+    ],
+    "targetPosition": [
+      -2.4222887042251102
+    ],
+    "targetVelocity": [
+      -1.7708728074772782
+    ],
+    "targetAcceleration": [
+      4.717638294537455
+    ],
+    "maxVelocity": [
+      5.450977739615543
+    ],
+    "maxAcceleration": [
+      6.980563514450473
+    ],
+    "maxJerk": [
+      16.897010331601827
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.4370102213327911
+    ],
+    "currentVelocity": [
+      -2.1593585495939154
+    ],
+    "currentAcceleration": [
+      -1.489549926686498
+    ],
+    "targetPosition": [
+      -0.5869198649242335
+    ],
+    "targetVelocity": [
+      -6.83447282030836
+    ],
+    "targetAcceleration": [
+      -3.173109235992218
+    ],
+    "maxVelocity": [
+      6.993955036292222
+    ],
+    "maxAcceleration": [
+      4.7915486552965465
+    ],
+    "maxJerk": [
+      7.363156075940484
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.45667822056101
+    ],
+    "currentVelocity": [
+      1.5588119236566493
+    ],
+    "currentAcceleration": [
+      4.196910003327964
+    ],
+    "targetPosition": [
+      9.976941781053846
+    ],
+    "targetVelocity": [
+      -0.3047888937473049
+    ],
+    "targetAcceleration": [
+      0.9554477359376454
+    ],
+    "maxVelocity": [
+      6.819232217839363
+    ],
+    "maxAcceleration": [
+      6.013730736031127
+    ],
+    "maxJerk": [
+      8.196087346567136
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.025809911070802
+    ],
+    "currentVelocity": [
+      -2.553246483736223
+    ],
+    "currentAcceleration": [
+      -2.6283258977768087
+    ],
+    "targetPosition": [
+      -6.063502319970045
+    ],
+    "targetVelocity": [
+      1.43260519393211
+    ],
+    "targetAcceleration": [
+      -1.849657415274324
+    ],
+    "maxVelocity": [
+      4.463825573307435
+    ],
+    "maxAcceleration": [
+      9.98748017161454
+    ],
+    "maxJerk": [
+      13.70429817145817
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.3525321923086615
+    ],
+    "currentVelocity": [
+      0.060729019339280654
+    ],
+    "currentAcceleration": [
+      7.339713993554305
+    ],
+    "targetPosition": [
+      1.140783983816922
+    ],
+    "targetVelocity": [
+      -1.8948000705337673
+    ],
+    "targetAcceleration": [
+      -7.149053701292212
+    ],
+    "maxVelocity": [
+      4.100959829610609
+    ],
+    "maxAcceleration": [
+      8.569353461203328
+    ],
+    "maxJerk": [
+      12.275512288932724
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.653137607375967
+    ],
+    "currentVelocity": [
+      -5.669863642868141
+    ],
+    "currentAcceleration": [
+      -0.008464395306633676
+    ],
+    "targetPosition": [
+      5.327100256274841
+    ],
+    "targetVelocity": [
+      -0.0753801688231519
+    ],
+    "targetAcceleration": [
+      -0.5026774346036569
+    ],
+    "maxVelocity": [
+      6.510492020166656
+    ],
+    "maxAcceleration": [
+      4.325627507146527
+    ],
+    "maxJerk": [
+      16.510337699674714
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.173393697309994
+    ],
+    "currentVelocity": [
+      1.6840944200742367
+    ],
+    "currentAcceleration": [
+      -4.80268529152186
+    ],
+    "targetPosition": [
+      3.6430928601765302
+    ],
+    "targetVelocity": [
+      -1.8235286283825425
+    ],
+    "targetAcceleration": [
+      2.1116741889939075
+    ],
+    "maxVelocity": [
+      4.192147966527049
+    ],
+    "maxAcceleration": [
+      6.88116612182853
+    ],
+    "maxJerk": [
+      5.63870528395849
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.667696542994129
+    ],
+    "currentVelocity": [
+      -1.4137721495358262
+    ],
+    "currentAcceleration": [
+      -0.6521691925033481
+    ],
+    "targetPosition": [
+      -0.2847252705982619
+    ],
+    "targetVelocity": [
+      -4.233944222301635
+    ],
+    "targetAcceleration": [
+      4.023007085723439
+    ],
+    "maxVelocity": [
+      5.7881368952736025
+    ],
+    "maxAcceleration": [
+      6.084740201518436
+    ],
+    "maxJerk": [
+      8.640090589859994
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.820848764149972
+    ],
+    "currentVelocity": [
+      1.2084416627287542
+    ],
+    "currentAcceleration": [
+      -1.833158499338282
+    ],
+    "targetPosition": [
+      -8.637444211291307
+    ],
+    "targetVelocity": [
+      -2.928765433783423
+    ],
+    "targetAcceleration": [
+      -0.06462717299551546
+    ],
+    "maxVelocity": [
+      4.596555890065882
+    ],
+    "maxAcceleration": [
+      6.609687867188269
+    ],
+    "maxJerk": [
+      16.787535191534108
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.015176754733652
+    ],
+    "currentVelocity": [
+      0.5319395400492981
+    ],
+    "currentAcceleration": [
+      -0.8100421407411025
+    ],
+    "targetPosition": [
+      0.166232561106197
+    ],
+    "targetVelocity": [
+      1.7711879061076283
+    ],
+    "targetAcceleration": [
+      5.3171724495643184
+    ],
+    "maxVelocity": [
+      3.594264543546431
+    ],
+    "maxAcceleration": [
+      7.516148099471592
+    ],
+    "maxJerk": [
+      12.29696592716861
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.402682917486432
+    ],
+    "currentVelocity": [
+      -4.262328250209032
+    ],
+    "currentAcceleration": [
+      3.3248426598106278
+    ],
+    "targetPosition": [
+      4.829563758246312
+    ],
+    "targetVelocity": [
+      -1.1669773701276016
+    ],
+    "targetAcceleration": [
+      0.5903410924771189
+    ],
+    "maxVelocity": [
+      6.346027071605756
+    ],
+    "maxAcceleration": [
+      6.082803535878455
+    ],
+    "maxJerk": [
+      12.066186760261594
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.006717590322118
+    ],
+    "currentVelocity": [
+      3.0305108483958545
+    ],
+    "currentAcceleration": [
+      -3.199210025817874
+    ],
+    "targetPosition": [
+      2.053256108809565
+    ],
+    "targetVelocity": [
+      -5.976706524735667
+    ],
+    "targetAcceleration": [
+      0.9498015254818295
+    ],
+    "maxVelocity": [
+      7.900190816854327
+    ],
+    "maxAcceleration": [
+      9.275751752349823
+    ],
+    "maxJerk": [
+      6.340465333396647
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.822962437587606
+    ],
+    "currentVelocity": [
+      -0.35433322721421545
+    ],
+    "currentAcceleration": [
+      9.155461268639504
+    ],
+    "targetPosition": [
+      -6.26460331619894
+    ],
+    "targetVelocity": [
+      -1.889697714854543
+    ],
+    "targetAcceleration": [
+      2.354259576711069
+    ],
+    "maxVelocity": [
+      2.6658705016215554
+    ],
+    "maxAcceleration": [
+      9.37042926517731
+    ],
+    "maxJerk": [
+      14.59697078070016
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.701329158281048
+    ],
+    "currentVelocity": [
+      4.226865855545654
+    ],
+    "currentAcceleration": [
+      2.3868787753317164
+    ],
+    "targetPosition": [
+      0.9897497984055086
+    ],
+    "targetVelocity": [
+      4.800471453436796
+    ],
+    "targetAcceleration": [
+      0.7055376815486047
+    ],
+    "maxVelocity": [
+      6.320502912087381
+    ],
+    "maxAcceleration": [
+      5.64628671405187
+    ],
+    "maxJerk": [
+      19.43338261196005
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.747304175059089
+    ],
+    "currentVelocity": [
+      -4.672512809009879
+    ],
+    "currentAcceleration": [
+      1.5066481165854526
+    ],
+    "targetPosition": [
+      -1.5815901799439729
+    ],
+    "targetVelocity": [
+      -1.7371550931634445
+    ],
+    "targetAcceleration": [
+      7.266345303031951
+    ],
+    "maxVelocity": [
+      7.01971265428798
+    ],
+    "maxAcceleration": [
+      8.779412609327295
+    ],
+    "maxJerk": [
+      11.438676339744116
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.623278204369656
+    ],
+    "currentVelocity": [
+      -4.149546826655592
+    ],
+    "currentAcceleration": [
+      -2.5664782867513223
+    ],
+    "targetPosition": [
+      -1.9299809432371653
+    ],
+    "targetVelocity": [
+      -4.842165410307372
+    ],
+    "targetAcceleration": [
+      -4.317255552297913
+    ],
+    "maxVelocity": [
+      5.008297386949421
+    ],
+    "maxAcceleration": [
+      6.2746102733324705
+    ],
+    "maxJerk": [
+      17.092818745339976
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.608580472569807
+    ],
+    "currentVelocity": [
+      -0.06168848240778679
+    ],
+    "currentAcceleration": [
+      3.609091806595492
+    ],
+    "targetPosition": [
+      -2.739217986757774
+    ],
+    "targetVelocity": [
+      -2.729973726177934
+    ],
+    "targetAcceleration": [
+      3.85982191914772
+    ],
+    "maxVelocity": [
+      6.940188688080077
+    ],
+    "maxAcceleration": [
+      8.741471745527914
+    ],
+    "maxJerk": [
+      10.537528217327182
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.061944100641972
+    ],
+    "currentVelocity": [
+      1.2768450098366921
+    ],
+    "currentAcceleration": [
+      2.9170383374537856
+    ],
+    "targetPosition": [
+      7.386124369224724
+    ],
+    "targetVelocity": [
+      -1.9591702776942936
+    ],
+    "targetAcceleration": [
+      1.9123413433792358
+    ],
+    "maxVelocity": [
+      6.399328933204393
+    ],
+    "maxAcceleration": [
+      9.700196913150114
+    ],
+    "maxJerk": [
+      12.92372638701224
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.444268063374372
+    ],
+    "currentVelocity": [
+      -0.05221847573021776
+    ],
+    "currentAcceleration": [
+      -3.2155983223900524
+    ],
+    "targetPosition": [
+      2.5773914452630144
+    ],
+    "targetVelocity": [
+      0.9196748941798978
+    ],
+    "targetAcceleration": [
+      5.793951409204507
+    ],
+    "maxVelocity": [
+      2.1968943538786183
+    ],
+    "maxAcceleration": [
+      9.26722470693483
+    ],
+    "maxJerk": [
+      15.42300093680807
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.001421458180882
+    ],
+    "currentVelocity": [
+      -1.4667506388036173
+    ],
+    "currentAcceleration": [
+      -2.8998279213155493
+    ],
+    "targetPosition": [
+      2.1827400548604796
+    ],
+    "targetVelocity": [
+      3.3749542820591714
+    ],
+    "targetAcceleration": [
+      8.181156104906451
+    ],
+    "maxVelocity": [
+      7.6138277255366535
+    ],
+    "maxAcceleration": [
+      8.216885906427455
+    ],
+    "maxJerk": [
+      7.255707219483327
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.06117291640356
+    ],
+    "currentVelocity": [
+      -2.2551595720644615
+    ],
+    "currentAcceleration": [
+      -1.8988147011931868
+    ],
+    "targetPosition": [
+      -8.877724137353074
+    ],
+    "targetVelocity": [
+      -4.173257215664973
+    ],
+    "targetAcceleration": [
+      5.348292079586036
+    ],
+    "maxVelocity": [
+      7.754056097465836
+    ],
+    "maxAcceleration": [
+      6.63778861986804
+    ],
+    "maxJerk": [
+      12.955078164436115
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.199278635638167
+    ],
+    "currentVelocity": [
+      -7.1836485823850165
+    ],
+    "currentAcceleration": [
+      1.7611412655387433
+    ],
+    "targetPosition": [
+      -2.2750125860448662
+    ],
+    "targetVelocity": [
+      -0.02001353670243855
+    ],
+    "targetAcceleration": [
+      7.0328024242072384
+    ],
+    "maxVelocity": [
+      7.943374107655194
+    ],
+    "maxAcceleration": [
+      8.928236901143045
+    ],
+    "maxJerk": [
+      13.78514791489402
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.189252355334159
+    ],
+    "currentVelocity": [
+      -3.414563854063484
+    ],
+    "currentAcceleration": [
+      6.677251977673935
+    ],
+    "targetPosition": [
+      -5.1494055494963575
+    ],
+    "targetVelocity": [
+      -0.3699360749440195
+    ],
+    "targetAcceleration": [
+      6.181353965703623
+    ],
+    "maxVelocity": [
+      3.826869198218711
+    ],
+    "maxAcceleration": [
+      6.968643864572918
+    ],
+    "maxJerk": [
+      10.791225889032214
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.59458106713442
+    ],
+    "currentVelocity": [
+      -0.2089746000657975
+    ],
+    "currentAcceleration": [
+      -2.9812509973386447
+    ],
+    "targetPosition": [
+      -5.990013815917557
+    ],
+    "targetVelocity": [
+      3.1559927592621175
+    ],
+    "targetAcceleration": [
+      0.11671395234506043
+    ],
+    "maxVelocity": [
+      5.032034521695008
+    ],
+    "maxAcceleration": [
+      3.3640674296378976
+    ],
+    "maxJerk": [
+      5.526298298365083
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.379431184583229
+    ],
+    "currentVelocity": [
+      2.351767522956851
+    ],
+    "currentAcceleration": [
+      0.6843819748486246
+    ],
+    "targetPosition": [
+      -5.433787290893861
+    ],
+    "targetVelocity": [
+      4.334883523587162
+    ],
+    "targetAcceleration": [
+      1.444759464412313
+    ],
+    "maxVelocity": [
+      4.939823699590133
+    ],
+    "maxAcceleration": [
+      3.6047463035791876
+    ],
+    "maxJerk": [
+      6.777118769671558
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.134655488431388
+    ],
+    "currentVelocity": [
+      -1.2671713369007005
+    ],
+    "currentAcceleration": [
+      5.612923821215495
+    ],
+    "targetPosition": [
+      -3.291562993336745
+    ],
+    "targetVelocity": [
+      -1.9504566202288354
+    ],
+    "targetAcceleration": [
+      4.594883624264745
+    ],
+    "maxVelocity": [
+      3.7821889584816937
+    ],
+    "maxAcceleration": [
+      5.686461195156737
+    ],
+    "maxJerk": [
+      18.778034179263116
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.815222303204535
+    ],
+    "currentVelocity": [
+      4.037929856997011
+    ],
+    "currentAcceleration": [
+      -2.8718689399121615
+    ],
+    "targetPosition": [
+      5.866034551065589
+    ],
+    "targetVelocity": [
+      3.528426449660137
+    ],
+    "targetAcceleration": [
+      -1.2459249130753483
+    ],
+    "maxVelocity": [
+      5.630774771412564
+    ],
+    "maxAcceleration": [
+      5.903741832238552
+    ],
+    "maxJerk": [
+      14.366386600735263
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.272897115573933
+    ],
+    "currentVelocity": [
+      1.0942459905790134
+    ],
+    "currentAcceleration": [
+      2.1299249821936055
+    ],
+    "targetPosition": [
+      -7.0859511855959
+    ],
+    "targetVelocity": [
+      -5.377314614153985
+    ],
+    "targetAcceleration": [
+      3.6592456178464534
+    ],
+    "maxVelocity": [
+      7.975819136091966
+    ],
+    "maxAcceleration": [
+      5.990180949755144
+    ],
+    "maxJerk": [
+      14.756364921854072
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.992868303407132
+    ],
+    "currentVelocity": [
+      -0.6379275161479723
+    ],
+    "currentAcceleration": [
+      0.17667364389676443
+    ],
+    "targetPosition": [
+      4.379758719034765
+    ],
+    "targetVelocity": [
+      0.42716864360999374
+    ],
+    "targetAcceleration": [
+      7.557058560626819
+    ],
+    "maxVelocity": [
+      2.255233364062379
+    ],
+    "maxAcceleration": [
+      8.275898234403652
+    ],
+    "maxJerk": [
+      13.937879716361053
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.344313044539817
+    ],
+    "currentVelocity": [
+      -0.9496326598985132
+    ],
+    "currentAcceleration": [
+      2.520131356959136
+    ],
+    "targetPosition": [
+      -2.05511876410589
+    ],
+    "targetVelocity": [
+      -1.844740679826147
+    ],
+    "targetAcceleration": [
+      -1.3452095270122477
+    ],
+    "maxVelocity": [
+      2.720643967055392
+    ],
+    "maxAcceleration": [
+      3.945062856031183
+    ],
+    "maxJerk": [
+      6.223042323871912
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.336756687906947
+    ],
+    "currentVelocity": [
+      -2.2562603730440207
+    ],
+    "currentAcceleration": [
+      -0.9826875202439833
+    ],
+    "targetPosition": [
+      -9.464733170483226
+    ],
+    "targetVelocity": [
+      0.46627309574591846
+    ],
+    "targetAcceleration": [
+      2.8826700534011103
+    ],
+    "maxVelocity": [
+      2.3879423005177998
+    ],
+    "maxAcceleration": [
+      6.900491462534754
+    ],
+    "maxJerk": [
+      5.478603669598401
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.844917353669715
+    ],
+    "currentVelocity": [
+      0.6112496109864645
+    ],
+    "currentAcceleration": [
+      0.3869918209189076
+    ],
+    "targetPosition": [
+      9.331487875743186
+    ],
+    "targetVelocity": [
+      -2.1937445906991715
+    ],
+    "targetAcceleration": [
+      0.6978610040178519
+    ],
+    "maxVelocity": [
+      2.827005547010449
+    ],
+    "maxAcceleration": [
+      3.68271549596571
+    ],
+    "maxJerk": [
+      7.3594155868183915
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.561187893980744
+    ],
+    "currentVelocity": [
+      -3.4483690833240663
+    ],
+    "currentAcceleration": [
+      5.850623054954701
+    ],
+    "targetPosition": [
+      -5.46707168340993
+    ],
+    "targetVelocity": [
+      2.50664232756744
+    ],
+    "targetAcceleration": [
+      -3.566875049227402
+    ],
+    "maxVelocity": [
+      6.802037635413403
+    ],
+    "maxAcceleration": [
+      7.038100465523289
+    ],
+    "maxJerk": [
+      13.027162385365234
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.3997609551616375
+    ],
+    "currentVelocity": [
+      0.7971957683255386
+    ],
+    "currentAcceleration": [
+      2.2998217542908765
+    ],
+    "targetPosition": [
+      7.4703627688423495
+    ],
+    "targetVelocity": [
+      1.2555197625103247
+    ],
+    "targetAcceleration": [
+      -2.367960242650047
+    ],
+    "maxVelocity": [
+      2.012849516053434
+    ],
+    "maxAcceleration": [
+      7.6346016591465915
+    ],
+    "maxJerk": [
+      16.746327364142346
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.350928281356145
+    ],
+    "currentVelocity": [
+      0.5304596597440625
+    ],
+    "currentAcceleration": [
+      2.5639227913600147
+    ],
+    "targetPosition": [
+      7.366032402950701
+    ],
+    "targetVelocity": [
+      -0.5126461238476487
+    ],
+    "targetAcceleration": [
+      0.6888460439470192
+    ],
+    "maxVelocity": [
+      7.4926471097085585
+    ],
+    "maxAcceleration": [
+      4.491152359079183
+    ],
+    "maxJerk": [
+      8.831969612138039
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.9181025397961982
+    ],
+    "currentVelocity": [
+      0.7137919231212781
+    ],
+    "currentAcceleration": [
+      -3.562052044657424
+    ],
+    "targetPosition": [
+      2.553669756451434
+    ],
+    "targetVelocity": [
+      -2.177253450705916
+    ],
+    "targetAcceleration": [
+      -3.617593816276668
+    ],
+    "maxVelocity": [
+      3.1326469534403563
+    ],
+    "maxAcceleration": [
+      5.527009026627663
+    ],
+    "maxJerk": [
+      7.128615258491649
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.747613655176368
+    ],
+    "currentVelocity": [
+      -5.090782819293864
+    ],
+    "currentAcceleration": [
+      -2.072926179554865
+    ],
+    "targetPosition": [
+      -9.384044773526242
+    ],
+    "targetVelocity": [
+      1.749375924760142
+    ],
+    "targetAcceleration": [
+      -4.261016153860848
+    ],
+    "maxVelocity": [
+      6.026736202153119
+    ],
+    "maxAcceleration": [
+      7.098009884477952
+    ],
+    "maxJerk": [
+      11.122683118265009
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.00889770062613
+    ],
+    "currentVelocity": [
+      -0.388449901101269
+    ],
+    "currentAcceleration": [
+      -7.915133818222226
+    ],
+    "targetPosition": [
+      -1.4886150092391155
+    ],
+    "targetVelocity": [
+      0.7464601975611673
+    ],
+    "targetAcceleration": [
+      -4.005375615656398
+    ],
+    "maxVelocity": [
+      2.0874361045413607
+    ],
+    "maxAcceleration": [
+      9.756790579555958
+    ],
+    "maxJerk": [
+      19.926567520875608
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.217853134225862
+    ],
+    "currentVelocity": [
+      2.222305704462896
+    ],
+    "currentAcceleration": [
+      -7.120802550818348
+    ],
+    "targetPosition": [
+      -1.2030461153478367
+    ],
+    "targetVelocity": [
+      -1.282936431374927
+    ],
+    "targetAcceleration": [
+      -0.4034761504065951
+    ],
+    "maxVelocity": [
+      3.1813706856047985
+    ],
+    "maxAcceleration": [
+      9.430077466780318
+    ],
+    "maxJerk": [
+      10.924119110950237
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.304426436763968
+    ],
+    "currentVelocity": [
+      -3.742679828030728
+    ],
+    "currentAcceleration": [
+      -3.710726147400525
+    ],
+    "targetPosition": [
+      -9.770872771303825
+    ],
+    "targetVelocity": [
+      1.3778612076592403
+    ],
+    "targetAcceleration": [
+      3.7435148921412127
+    ],
+    "maxVelocity": [
+      7.1990696067422615
+    ],
+    "maxAcceleration": [
+      7.80303143447676
+    ],
+    "maxJerk": [
+      10.523785720111988
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.948499905784516
+    ],
+    "currentVelocity": [
+      1.334854966783654
+    ],
+    "currentAcceleration": [
+      3.9480285648266857
+    ],
+    "targetPosition": [
+      6.227490866481443
+    ],
+    "targetVelocity": [
+      -7.1455642699546456
+    ],
+    "targetAcceleration": [
+      3.5030605182845047
+    ],
+    "maxVelocity": [
+      7.61670287785606
+    ],
+    "maxAcceleration": [
+      9.156425774153925
+    ],
+    "maxJerk": [
+      14.594639862226321
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.176750765178948
+    ],
+    "currentVelocity": [
+      -0.1787429002658989
+    ],
+    "currentAcceleration": [
+      -1.1550046612437601
+    ],
+    "targetPosition": [
+      -8.158938703981342
+    ],
+    "targetVelocity": [
+      0.6356356190721582
+    ],
+    "targetAcceleration": [
+      -1.9643041076665146
+    ],
+    "maxVelocity": [
+      3.319587607547184
+    ],
+    "maxAcceleration": [
+      4.453193908972477
+    ],
+    "maxJerk": [
+      5.399708179002721
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.05872857122986
+    ],
+    "currentVelocity": [
+      3.2193794931882778
+    ],
+    "currentAcceleration": [
+      0.8691193538056314
+    ],
+    "targetPosition": [
+      6.756445926898632
+    ],
+    "targetVelocity": [
+      -1.4223382013585542
+    ],
+    "targetAcceleration": [
+      -4.776214068305281
+    ],
+    "maxVelocity": [
+      4.962374664994808
+    ],
+    "maxAcceleration": [
+      9.199581016277966
+    ],
+    "maxJerk": [
+      9.024433140416761
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.845589791629223
+    ],
+    "currentVelocity": [
+      2.0158188151927074
+    ],
+    "currentAcceleration": [
+      -1.5717064651408341
+    ],
+    "targetPosition": [
+      6.5144969981965914
+    ],
+    "targetVelocity": [
+      -2.1853156898614796
+    ],
+    "targetAcceleration": [
+      1.7153707550263189
+    ],
+    "maxVelocity": [
+      2.523710581822071
+    ],
+    "maxAcceleration": [
+      5.348599397686316
+    ],
+    "maxJerk": [
+      14.407268890976908
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.810949820744769
+    ],
+    "currentVelocity": [
+      -1.5650341650713946
+    ],
+    "currentAcceleration": [
+      1.3160332470923022
+    ],
+    "targetPosition": [
+      -0.9677634099945802
+    ],
+    "targetVelocity": [
+      -0.9023462239787161
+    ],
+    "targetAcceleration": [
+      -4.15629255637805
+    ],
+    "maxVelocity": [
+      6.024741654380429
+    ],
+    "maxAcceleration": [
+      4.316879357292441
+    ],
+    "maxJerk": [
+      18.64062570712966
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.127940089416917
+    ],
+    "currentVelocity": [
+      4.015192302635922
+    ],
+    "currentAcceleration": [
+      -6.705629737871329
+    ],
+    "targetPosition": [
+      8.257884491541986
+    ],
+    "targetVelocity": [
+      1.7855094865189596
+    ],
+    "targetAcceleration": [
+      -7.348454113345083
+    ],
+    "maxVelocity": [
+      4.165488577414397
+    ],
+    "maxAcceleration": [
+      8.309315830014487
+    ],
+    "maxJerk": [
+      18.715969145288835
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.820868335916167
+    ],
+    "currentVelocity": [
+      -1.1285443588589312
+    ],
+    "currentAcceleration": [
+      0.6959525524550845
+    ],
+    "targetPosition": [
+      -6.504195488283213
+    ],
+    "targetVelocity": [
+      2.347157529935779
+    ],
+    "targetAcceleration": [
+      2.5793850397351514
+    ],
+    "maxVelocity": [
+      3.5462289396249203
+    ],
+    "maxAcceleration": [
+      4.148922170590109
+    ],
+    "maxJerk": [
+      7.546793515328758
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.612220082239492
+    ],
+    "currentVelocity": [
+      2.748402700242141
+    ],
+    "currentAcceleration": [
+      0.8065431123730704
+    ],
+    "targetPosition": [
+      -1.8654573552675924
+    ],
+    "targetVelocity": [
+      -2.117776668514461
+    ],
+    "targetAcceleration": [
+      -6.100743850310112
+    ],
+    "maxVelocity": [
+      3.601656291391203
+    ],
+    "maxAcceleration": [
+      6.890671405505292
+    ],
+    "maxJerk": [
+      11.727126484709494
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.4061626674306265
+    ],
+    "currentVelocity": [
+      0.45501654045107154
+    ],
+    "currentAcceleration": [
+      -4.84454776522874
+    ],
+    "targetPosition": [
+      -3.421586597586847
+    ],
+    "targetVelocity": [
+      -1.2419753930744504
+    ],
+    "targetAcceleration": [
+      3.6593512881981995
+    ],
+    "maxVelocity": [
+      3.100267675372584
+    ],
+    "maxAcceleration": [
+      5.571103497578425
+    ],
+    "maxJerk": [
+      11.58706709064488
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.9060687755911712
+    ],
+    "currentVelocity": [
+      -1.9263966109305553
+    ],
+    "currentAcceleration": [
+      0.61326416830186
+    ],
+    "targetPosition": [
+      -8.795410085805116
+    ],
+    "targetVelocity": [
+      3.3153164287726717
+    ],
+    "targetAcceleration": [
+      -0.045208697636152984
+    ],
+    "maxVelocity": [
+      3.837867126607591
+    ],
+    "maxAcceleration": [
+      3.412329243773373
+    ],
+    "maxJerk": [
+      5.4683741084494155
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.1967069832275463
+    ],
+    "currentVelocity": [
+      0.8960061333919542
+    ],
+    "currentAcceleration": [
+      -2.907002903044446
+    ],
+    "targetPosition": [
+      2.2681820193788145
+    ],
+    "targetVelocity": [
+      4.653516771474168
+    ],
+    "targetAcceleration": [
+      2.4415351603622355
+    ],
+    "maxVelocity": [
+      7.01897981680548
+    ],
+    "maxAcceleration": [
+      6.175350060473315
+    ],
+    "maxJerk": [
+      16.016793200745912
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.21509934884757875
+    ],
+    "currentVelocity": [
+      0.0687840524132799
+    ],
+    "currentAcceleration": [
+      -1.7128263744059309
+    ],
+    "targetPosition": [
+      5.32222829450407
+    ],
+    "targetVelocity": [
+      4.21411828329506
+    ],
+    "targetAcceleration": [
+      -1.6806047261276182
+    ],
+    "maxVelocity": [
+      4.8423235441885675
+    ],
+    "maxAcceleration": [
+      7.631241143850084
+    ],
+    "maxJerk": [
+      6.855582515479114
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.257335337800919
+    ],
+    "currentVelocity": [
+      -3.9351313737224065
+    ],
+    "currentAcceleration": [
+      -2.104732220826637
+    ],
+    "targetPosition": [
+      -8.602280509011758
+    ],
+    "targetVelocity": [
+      1.4364938233520892
+    ],
+    "targetAcceleration": [
+      1.3237263173100704
+    ],
+    "maxVelocity": [
+      5.647170229597985
+    ],
+    "maxAcceleration": [
+      5.37090567266806
+    ],
+    "maxJerk": [
+      13.354094857845208
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.526177088530396
+    ],
+    "currentVelocity": [
+      1.4627995337220003
+    ],
+    "currentAcceleration": [
+      -4.8534264067280315
+    ],
+    "targetPosition": [
+      -2.369376631177797
+    ],
+    "targetVelocity": [
+      -0.12145644923276322
+    ],
+    "targetAcceleration": [
+      5.223429695896451
+    ],
+    "maxVelocity": [
+      3.3592986987283924
+    ],
+    "maxAcceleration": [
+      7.752893338551749
+    ],
+    "maxJerk": [
+      11.269821456130199
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.9411420707643394
+    ],
+    "currentVelocity": [
+      1.0222331827592326
+    ],
+    "currentAcceleration": [
+      2.9432187682446855
+    ],
+    "targetPosition": [
+      -0.40347958160551656
+    ],
+    "targetVelocity": [
+      4.41479754563071
+    ],
+    "targetAcceleration": [
+      0.3719664451823439
+    ],
+    "maxVelocity": [
+      4.453796056490641
+    ],
+    "maxAcceleration": [
+      6.270727582090464
+    ],
+    "maxJerk": [
+      15.19273864108072
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.2730353706279054
+    ],
+    "currentVelocity": [
+      3.7714482105340483
+    ],
+    "currentAcceleration": [
+      6.360921797011127
+    ],
+    "targetPosition": [
+      -7.133655596081594
+    ],
+    "targetVelocity": [
+      4.537185849478016
+    ],
+    "targetAcceleration": [
+      5.889350561868106
+    ],
+    "maxVelocity": [
+      5.46225769141137
+    ],
+    "maxAcceleration": [
+      9.174138249461425
+    ],
+    "maxJerk": [
+      14.589697808560912
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.054600597108013
+    ],
+    "currentVelocity": [
+      -0.2205781321606639
+    ],
+    "currentAcceleration": [
+      -3.89563792514282
+    ],
+    "targetPosition": [
+      2.7157635298017517
+    ],
+    "targetVelocity": [
+      1.332855594706349
+    ],
+    "targetAcceleration": [
+      -4.414199340180923
+    ],
+    "maxVelocity": [
+      3.353583092405136
+    ],
+    "maxAcceleration": [
+      5.610283245031883
+    ],
+    "maxJerk": [
+      10.596630931964166
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.52077174288184
+    ],
+    "currentVelocity": [
+      2.2804494445189354
+    ],
+    "currentAcceleration": [
+      4.848124674494683
+    ],
+    "targetPosition": [
+      6.467305055097036
+    ],
+    "targetVelocity": [
+      -0.12126765989525268
+    ],
+    "targetAcceleration": [
+      -1.3159224105206242
+    ],
+    "maxVelocity": [
+      3.916920534300557
+    ],
+    "maxAcceleration": [
+      4.971847415524952
+    ],
+    "maxJerk": [
+      17.779575522550466
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.3576851501524434
+    ],
+    "currentVelocity": [
+      4.498316868145745
+    ],
+    "currentAcceleration": [
+      -4.840858593149695
+    ],
+    "targetPosition": [
+      -7.459116397464558
+    ],
+    "targetVelocity": [
+      -4.405760776440176
+    ],
+    "targetAcceleration": [
+      2.781176360723032
+    ],
+    "maxVelocity": [
+      5.9107179501547655
+    ],
+    "maxAcceleration": [
+      6.186530758064347
+    ],
+    "maxJerk": [
+      6.865216861530736
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.8977555704359101
+    ],
+    "currentVelocity": [
+      3.4765960215578042
+    ],
+    "currentAcceleration": [
+      3.862257918428263
+    ],
+    "targetPosition": [
+      -2.0915531658430293
+    ],
+    "targetVelocity": [
+      4.648357092722974
+    ],
+    "targetAcceleration": [
+      -0.449873017373676
+    ],
+    "maxVelocity": [
+      6.540475688679414
+    ],
+    "maxAcceleration": [
+      6.810204800143273
+    ],
+    "maxJerk": [
+      9.451724887519013
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.538991300150201
+    ],
+    "currentVelocity": [
+      0.6532074981430114
+    ],
+    "currentAcceleration": [
+      -1.4159829655159657
+    ],
+    "targetPosition": [
+      9.32207055215778
+    ],
+    "targetVelocity": [
+      1.5742150234789865
+    ],
+    "targetAcceleration": [
+      -1.2490433356861494
+    ],
+    "maxVelocity": [
+      4.674176335412957
+    ],
+    "maxAcceleration": [
+      3.3047097294685686
+    ],
+    "maxJerk": [
+      10.586108425894487
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.522975758957475
+    ],
+    "currentVelocity": [
+      2.3526265661637202
+    ],
+    "currentAcceleration": [
+      1.1098555781840425
+    ],
+    "targetPosition": [
+      3.4190922723934474
+    ],
+    "targetVelocity": [
+      3.6304518407836692
+    ],
+    "targetAcceleration": [
+      4.743729376102181
+    ],
+    "maxVelocity": [
+      5.029386244727519
+    ],
+    "maxAcceleration": [
+      4.999965300332839
+    ],
+    "maxJerk": [
+      15.467653340465734
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.635149445498671
+    ],
+    "currentVelocity": [
+      1.178226111844845
+    ],
+    "currentAcceleration": [
+      6.6129718276818545
+    ],
+    "targetPosition": [
+      2.5070607772651083
+    ],
+    "targetVelocity": [
+      -2.1207635078690954
+    ],
+    "targetAcceleration": [
+      2.3619976972135257
+    ],
+    "maxVelocity": [
+      4.056894918634005
+    ],
+    "maxAcceleration": [
+      7.135412612231055
+    ],
+    "maxJerk": [
+      15.193280394541485
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.901860316229923
+    ],
+    "currentVelocity": [
+      -0.8742991709640546
+    ],
+    "currentAcceleration": [
+      5.447251515132109
+    ],
+    "targetPosition": [
+      4.647476712406709
+    ],
+    "targetVelocity": [
+      -0.8913952371932106
+    ],
+    "targetAcceleration": [
+      6.892001236882312
+    ],
+    "maxVelocity": [
+      3.1736223781311725
+    ],
+    "maxAcceleration": [
+      9.096982189745638
+    ],
+    "maxJerk": [
+      15.522450392690248
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.998460024146432
+    ],
+    "currentVelocity": [
+      -1.7674124195951455
+    ],
+    "currentAcceleration": [
+      0.9896488079317525
+    ],
+    "targetPosition": [
+      -4.486458224886145
+    ],
+    "targetVelocity": [
+      -0.7055589856622024
+    ],
+    "targetAcceleration": [
+      6.688373008935153
+    ],
+    "maxVelocity": [
+      7.740419459143178
+    ],
+    "maxAcceleration": [
+      7.703037280820414
+    ],
+    "maxJerk": [
+      6.460229629634188
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.5150522701889964
+    ],
+    "currentVelocity": [
+      -2.2765022945576856
+    ],
+    "currentAcceleration": [
+      0.528444753867273
+    ],
+    "targetPosition": [
+      -1.209466012368722
+    ],
+    "targetVelocity": [
+      -1.156844864067909
+    ],
+    "targetAcceleration": [
+      2.0302787859003235
+    ],
+    "maxVelocity": [
+      2.3043061904050486
+    ],
+    "maxAcceleration": [
+      7.303945735074048
+    ],
+    "maxJerk": [
+      10.99026060920684
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.755723697827123
+    ],
+    "currentVelocity": [
+      0.6085892396760384
+    ],
+    "currentAcceleration": [
+      -8.572009593860443
+    ],
+    "targetPosition": [
+      3.507695933825964
+    ],
+    "targetVelocity": [
+      5.493011111946726
+    ],
+    "targetAcceleration": [
+      4.622832491845818
+    ],
+    "maxVelocity": [
+      6.425936394100531
+    ],
+    "maxAcceleration": [
+      9.790047993472971
+    ],
+    "maxJerk": [
+      16.41722010959179
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.078088735893303
+    ],
+    "currentVelocity": [
+      -6.488159417807945
+    ],
+    "currentAcceleration": [
+      -1.6446539738520247
+    ],
+    "targetPosition": [
+      -1.4294009987156624
+    ],
+    "targetVelocity": [
+      0.30523780114772947
+    ],
+    "targetAcceleration": [
+      -5.608890780052828
+    ],
+    "maxVelocity": [
+      6.781449747392815
+    ],
+    "maxAcceleration": [
+      7.581133706542707
+    ],
+    "maxJerk": [
+      15.077579701488553
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.639852198384027
+    ],
+    "currentVelocity": [
+      4.050551275094007
+    ],
+    "currentAcceleration": [
+      -3.172556379986154
+    ],
+    "targetPosition": [
+      9.46880697295699
+    ],
+    "targetVelocity": [
+      0.04838678606105162
+    ],
+    "targetAcceleration": [
+      -3.4604890409090987
+    ],
+    "maxVelocity": [
+      4.0699567575888
+    ],
+    "maxAcceleration": [
+      3.7371397156787562
+    ],
+    "maxJerk": [
+      7.335571606967019
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.5316178717249507
+    ],
+    "currentVelocity": [
+      -1.9243078809119158
+    ],
+    "currentAcceleration": [
+      6.664157021938479
+    ],
+    "targetPosition": [
+      7.780766417523235
+    ],
+    "targetVelocity": [
+      2.6059051367774053
+    ],
+    "targetAcceleration": [
+      3.659981087458968
+    ],
+    "maxVelocity": [
+      3.0507945270381533
+    ],
+    "maxAcceleration": [
+      7.168565595456956
+    ],
+    "maxJerk": [
+      18.007174082762678
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.003927571344256364
+    ],
+    "currentVelocity": [
+      -1.2024489402617005
+    ],
+    "currentAcceleration": [
+      -1.2213284898251988
+    ],
+    "targetPosition": [
+      -1.171921327118806
+    ],
+    "targetVelocity": [
+      -2.194526137186788
+    ],
+    "targetAcceleration": [
+      -0.6464851461061407
+    ],
+    "maxVelocity": [
+      3.611576970505661
+    ],
+    "maxAcceleration": [
+      9.9707361759746
+    ],
+    "maxJerk": [
+      13.683608442800285
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.741701117976552
+    ],
+    "currentVelocity": [
+      -1.9625245562238152
+    ],
+    "currentAcceleration": [
+      2.179609735857788
+    ],
+    "targetPosition": [
+      8.037528853737946
+    ],
+    "targetVelocity": [
+      5.634168789407823
+    ],
+    "targetAcceleration": [
+      6.798235463574743
+    ],
+    "maxVelocity": [
+      5.716762001265966
+    ],
+    "maxAcceleration": [
+      9.511789031995834
+    ],
+    "maxJerk": [
+      8.621633218039943
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.375963492643367
+    ],
+    "currentVelocity": [
+      -0.34663469581140927
+    ],
+    "currentAcceleration": [
+      5.114957848278518
+    ],
+    "targetPosition": [
+      -7.918814027526988
+    ],
+    "targetVelocity": [
+      -4.067021348928618
+    ],
+    "targetAcceleration": [
+      -4.29532279137779
+    ],
+    "maxVelocity": [
+      6.678227922660642
+    ],
+    "maxAcceleration": [
+      5.845881116715587
+    ],
+    "maxJerk": [
+      9.693759605496076
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.1274957466692292
+    ],
+    "currentVelocity": [
+      2.624262903124592
+    ],
+    "currentAcceleration": [
+      -8.240912923043961
+    ],
+    "targetPosition": [
+      0.20991474591609993
+    ],
+    "targetVelocity": [
+      -0.3509301259546822
+    ],
+    "targetAcceleration": [
+      3.367208313649096
+    ],
+    "maxVelocity": [
+      3.006469297709306
+    ],
+    "maxAcceleration": [
+      8.506966808657635
+    ],
+    "maxJerk": [
+      18.344395336017758
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.06020331539829371
+    ],
+    "currentVelocity": [
+      -1.3256214340386518
+    ],
+    "currentAcceleration": [
+      -6.197216139018049
+    ],
+    "targetPosition": [
+      -1.4281378553674386
+    ],
+    "targetVelocity": [
+      -0.09383310291098645
+    ],
+    "targetAcceleration": [
+      0.05943129021804072
+    ],
+    "maxVelocity": [
+      2.877432258835546
+    ],
+    "maxAcceleration": [
+      6.3362194318658425
+    ],
+    "maxJerk": [
+      13.77536636154001
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.482152222523661
+    ],
+    "currentVelocity": [
+      -2.928838655995561
+    ],
+    "currentAcceleration": [
+      -8.4794394301876
+    ],
+    "targetPosition": [
+      0.828262344571268
+    ],
+    "targetVelocity": [
+      4.896602903840301
+    ],
+    "targetAcceleration": [
+      -5.235064784913992
+    ],
+    "maxVelocity": [
+      6.94615521421376
+    ],
+    "maxAcceleration": [
+      9.608042496827345
+    ],
+    "maxJerk": [
+      15.499824809761751
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.001056287684603
+    ],
+    "currentVelocity": [
+      -4.421800736651285
+    ],
+    "currentAcceleration": [
+      -2.488403396284701
+    ],
+    "targetPosition": [
+      -5.907478690206618
+    ],
+    "targetVelocity": [
+      2.731170351676198
+    ],
+    "targetAcceleration": [
+      -2.0946883582220988
+    ],
+    "maxVelocity": [
+      5.375039788351309
+    ],
+    "maxAcceleration": [
+      8.409635760205555
+    ],
+    "maxJerk": [
+      8.03125006192146
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.0374653600687065
+    ],
+    "currentVelocity": [
+      -0.8712868041044233
+    ],
+    "currentAcceleration": [
+      1.361830790402144
+    ],
+    "targetPosition": [
+      -3.5292654587716736
+    ],
+    "targetVelocity": [
+      0.8004922180532987
+    ],
+    "targetAcceleration": [
+      -3.6339628599792566
+    ],
+    "maxVelocity": [
+      2.118468213846765
+    ],
+    "maxAcceleration": [
+      5.70350219405335
+    ],
+    "maxJerk": [
+      13.072333295803517
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.508999366595283
+    ],
+    "currentVelocity": [
+      4.1553212070809185
+    ],
+    "currentAcceleration": [
+      -7.212459136994245
+    ],
+    "targetPosition": [
+      5.186771611644119
+    ],
+    "targetVelocity": [
+      1.8515203639570919
+    ],
+    "targetAcceleration": [
+      -5.009380629640548
+    ],
+    "maxVelocity": [
+      4.597154132103412
+    ],
+    "maxAcceleration": [
+      7.961656088052054
+    ],
+    "maxJerk": [
+      17.87905049433271
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.5505781492643145
+    ],
+    "currentVelocity": [
+      1.151453011449294
+    ],
+    "currentAcceleration": [
+      -0.8967743918012103
+    ],
+    "targetPosition": [
+      -6.960648538702994
+    ],
+    "targetVelocity": [
+      1.9193017630942686
+    ],
+    "targetAcceleration": [
+      4.3171089058092615
+    ],
+    "maxVelocity": [
+      2.493567164600403
+    ],
+    "maxAcceleration": [
+      4.410097810153104
+    ],
+    "maxJerk": [
+      5.819877223948264
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.191901129728636
+    ],
+    "currentVelocity": [
+      1.7137679010012077
+    ],
+    "currentAcceleration": [
+      4.347413750803529
+    ],
+    "targetPosition": [
+      5.833081616877614
+    ],
+    "targetVelocity": [
+      2.970578180286024
+    ],
+    "targetAcceleration": [
+      0.17195406754719045
+    ],
+    "maxVelocity": [
+      4.585429117186314
+    ],
+    "maxAcceleration": [
+      7.388223884713728
+    ],
+    "maxJerk": [
+      13.611455621536937
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.841053072644792
+    ],
+    "currentVelocity": [
+      -1.048880543209135
+    ],
+    "currentAcceleration": [
+      -2.5349387476924568
+    ],
+    "targetPosition": [
+      3.8175356550096176
+    ],
+    "targetVelocity": [
+      -3.7170198048753607
+    ],
+    "targetAcceleration": [
+      -2.5585280529970547
+    ],
+    "maxVelocity": [
+      6.951816777169923
+    ],
+    "maxAcceleration": [
+      8.361488387779659
+    ],
+    "maxJerk": [
+      7.6949402600150405
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.7010036389533365
+    ],
+    "currentVelocity": [
+      -2.816995943534226
+    ],
+    "currentAcceleration": [
+      4.259138277351768
+    ],
+    "targetPosition": [
+      -3.2149455452227134
+    ],
+    "targetVelocity": [
+      0.4210366790007205
+    ],
+    "targetAcceleration": [
+      -2.4071906886780807
+    ],
+    "maxVelocity": [
+      5.217472334657538
+    ],
+    "maxAcceleration": [
+      8.813125213839577
+    ],
+    "maxJerk": [
+      10.627461816583889
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7968217796509869
+    ],
+    "currentVelocity": [
+      -3.3388639903077113
+    ],
+    "currentAcceleration": [
+      1.9202987641562483
+    ],
+    "targetPosition": [
+      0.926541274358442
+    ],
+    "targetVelocity": [
+      1.1277140797267098
+    ],
+    "targetAcceleration": [
+      -2.7078751310168796
+    ],
+    "maxVelocity": [
+      5.986958143170494
+    ],
+    "maxAcceleration": [
+      4.651204710312866
+    ],
+    "maxJerk": [
+      6.231095506246997
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.408876311065988
+    ],
+    "currentVelocity": [
+      -3.527586317611186
+    ],
+    "currentAcceleration": [
+      0.12706628788520513
+    ],
+    "targetPosition": [
+      4.529273760178654
+    ],
+    "targetVelocity": [
+      -2.3537097530944386
+    ],
+    "targetAcceleration": [
+      -0.31512334593129765
+    ],
+    "maxVelocity": [
+      3.86834825703684
+    ],
+    "maxAcceleration": [
+      3.2266897650935817
+    ],
+    "maxJerk": [
+      9.945832476961854
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.122747585590297
+    ],
+    "currentVelocity": [
+      -2.9833219132315696
+    ],
+    "currentAcceleration": [
+      1.5271973381386728
+    ],
+    "targetPosition": [
+      4.921543805630195
+    ],
+    "targetVelocity": [
+      -3.185204264498508
+    ],
+    "targetAcceleration": [
+      -4.888872906496951
+    ],
+    "maxVelocity": [
+      7.319471913184212
+    ],
+    "maxAcceleration": [
+      6.960305181370448
+    ],
+    "maxJerk": [
+      12.25165724086887
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.193993643367952
+    ],
+    "currentVelocity": [
+      -6.3697564731112335
+    ],
+    "currentAcceleration": [
+      3.895978924955818
+    ],
+    "targetPosition": [
+      6.100002248029163
+    ],
+    "targetVelocity": [
+      -5.110441953941062
+    ],
+    "targetAcceleration": [
+      3.209672449744126
+    ],
+    "maxVelocity": [
+      7.625278043220319
+    ],
+    "maxAcceleration": [
+      8.419154481729155
+    ],
+    "maxJerk": [
+      10.53183436641751
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.73553930055187
+    ],
+    "currentVelocity": [
+      -4.908174966856115
+    ],
+    "currentAcceleration": [
+      -0.1321729543664083
+    ],
+    "targetPosition": [
+      8.708206306424845
+    ],
+    "targetVelocity": [
+      -0.5346128811297532
+    ],
+    "targetAcceleration": [
+      0.5020667015196034
+    ],
+    "maxVelocity": [
+      7.602467894839269
+    ],
+    "maxAcceleration": [
+      3.9972745700556738
+    ],
+    "maxJerk": [
+      11.483802462501147
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.543455333775439
+    ],
+    "currentVelocity": [
+      2.987211300336231
+    ],
+    "currentAcceleration": [
+      -0.021283945367908785
+    ],
+    "targetPosition": [
+      -2.6525832299345087
+    ],
+    "targetVelocity": [
+      -6.039990247994464
+    ],
+    "targetAcceleration": [
+      -4.612017953576386
+    ],
+    "maxVelocity": [
+      7.278697347577314
+    ],
+    "maxAcceleration": [
+      5.212931837798757
+    ],
+    "maxJerk": [
+      9.31899248204516
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.2904354289964708
+    ],
+    "currentVelocity": [
+      -0.869518352729211
+    ],
+    "currentAcceleration": [
+      -2.9214419828614595
+    ],
+    "targetPosition": [
+      1.2004155272903017
+    ],
+    "targetVelocity": [
+      0.8927157683736926
+    ],
+    "targetAcceleration": [
+      0.9331683367778147
+    ],
+    "maxVelocity": [
+      2.230702318821044
+    ],
+    "maxAcceleration": [
+      6.972577286256593
+    ],
+    "maxJerk": [
+      15.878716748699466
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.8393704292033117
+    ],
+    "currentVelocity": [
+      2.649610602696961
+    ],
+    "currentAcceleration": [
+      -0.1602902558277952
+    ],
+    "targetPosition": [
+      0.4090770679821816
+    ],
+    "targetVelocity": [
+      -2.489503393091196
+    ],
+    "targetAcceleration": [
+      -2.416074983517071
+    ],
+    "maxVelocity": [
+      4.31735080832128
+    ],
+    "maxAcceleration": [
+      3.108561756733801
+    ],
+    "maxJerk": [
+      6.844052428398646
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.974649035190218
+    ],
+    "currentVelocity": [
+      -1.0911205664748633
+    ],
+    "currentAcceleration": [
+      -1.6956913924179993
+    ],
+    "targetPosition": [
+      2.8984007253764155
+    ],
+    "targetVelocity": [
+      -0.08942358997365529
+    ],
+    "targetAcceleration": [
+      0.3637497489609265
+    ],
+    "maxVelocity": [
+      2.133254184142668
+    ],
+    "maxAcceleration": [
+      3.6389452585749114
+    ],
+    "maxJerk": [
+      16.939488706550186
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.487437290463905
+    ],
+    "currentVelocity": [
+      -6.812217430033552
+    ],
+    "currentAcceleration": [
+      -1.5715794645006103
+    ],
+    "targetPosition": [
+      -6.060612955628237
+    ],
+    "targetVelocity": [
+      -5.886233786771971
+    ],
+    "targetAcceleration": [
+      -0.08307522267037193
+    ],
+    "maxVelocity": [
+      7.50378580192919
+    ],
+    "maxAcceleration": [
+      3.637712875438141
+    ],
+    "maxJerk": [
+      18.646601836102505
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.436857403675439
+    ],
+    "currentVelocity": [
+      6.5675082136676455
+    ],
+    "currentAcceleration": [
+      -6.746827241678059
+    ],
+    "targetPosition": [
+      5.513281208943388
+    ],
+    "targetVelocity": [
+      2.4723924478506323
+    ],
+    "targetAcceleration": [
+      -4.911383929790294
+    ],
+    "maxVelocity": [
+      7.047176591815507
+    ],
+    "maxAcceleration": [
+      6.752428140752309
+    ],
+    "maxJerk": [
+      9.925745769188154
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.477744338434089
+    ],
+    "currentVelocity": [
+      2.7741938867398606
+    ],
+    "currentAcceleration": [
+      4.66675693149963
+    ],
+    "targetPosition": [
+      -9.240021029880399
+    ],
+    "targetVelocity": [
+      -4.05957149995747
+    ],
+    "targetAcceleration": [
+      2.364618881158406
+    ],
+    "maxVelocity": [
+      7.959383276589236
+    ],
+    "maxAcceleration": [
+      5.673042685165556
+    ],
+    "maxJerk": [
+      6.543600089723345
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.526702465697554
+    ],
+    "currentVelocity": [
+      -5.824609523412894
+    ],
+    "currentAcceleration": [
+      9.045091819797241
+    ],
+    "targetPosition": [
+      -3.4960791526602293
+    ],
+    "targetVelocity": [
+      -6.805299625402047
+    ],
+    "targetAcceleration": [
+      -1.5305712924373553
+    ],
+    "maxVelocity": [
+      7.55571585606618
+    ],
+    "maxAcceleration": [
+      9.14755447010443
+    ],
+    "maxJerk": [
+      5.116968522045797
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.2574150620538127
+    ],
+    "currentVelocity": [
+      -2.9766355959836357
+    ],
+    "currentAcceleration": [
+      1.757702116706386
+    ],
+    "targetPosition": [
+      -7.33059654811175
+    ],
+    "targetVelocity": [
+      3.78328716899712
+    ],
+    "targetAcceleration": [
+      2.9349623105894924
+    ],
+    "maxVelocity": [
+      5.131069208886197
+    ],
+    "maxAcceleration": [
+      3.9454385000188097
+    ],
+    "maxJerk": [
+      12.311847254879234
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.040549665528935
+    ],
+    "currentVelocity": [
+      -1.9584395454307781
+    ],
+    "currentAcceleration": [
+      0.38714008545656187
+    ],
+    "targetPosition": [
+      -1.9323287088302692
+    ],
+    "targetVelocity": [
+      3.304861262775616
+    ],
+    "targetAcceleration": [
+      -1.4476476158913019
+    ],
+    "maxVelocity": [
+      6.124613600403344
+    ],
+    "maxAcceleration": [
+      3.7016987877270746
+    ],
+    "maxJerk": [
+      13.542664534233179
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.3689401676400834
+    ],
+    "currentVelocity": [
+      -0.673318922075345
+    ],
+    "currentAcceleration": [
+      -2.601343903543098
+    ],
+    "targetPosition": [
+      -5.725229376769045
+    ],
+    "targetVelocity": [
+      -0.4540074414120605
+    ],
+    "targetAcceleration": [
+      -4.6360426292707375
+    ],
+    "maxVelocity": [
+      3.9675969640434907
+    ],
+    "maxAcceleration": [
+      9.970768724871174
+    ],
+    "maxJerk": [
+      16.445357442157377
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.190656118016815
+    ],
+    "currentVelocity": [
+      7.097179194309559
+    ],
+    "currentAcceleration": [
+      -5.610591795887961
+    ],
+    "targetPosition": [
+      -2.541434695634754
+    ],
+    "targetVelocity": [
+      2.842638563169542
+    ],
+    "targetAcceleration": [
+      6.402956125047737
+    ],
+    "maxVelocity": [
+      7.630978180309189
+    ],
+    "maxAcceleration": [
+      6.816698575559364
+    ],
+    "maxJerk": [
+      19.714054522839753
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.185535703150402
+    ],
+    "currentVelocity": [
+      0.16407145510240317
+    ],
+    "currentAcceleration": [
+      3.901114541102932
+    ],
+    "targetPosition": [
+      6.019565194835781
+    ],
+    "targetVelocity": [
+      2.6685671628423107
+    ],
+    "targetAcceleration": [
+      -0.5521632026274257
+    ],
+    "maxVelocity": [
+      3.1642897272891117
+    ],
+    "maxAcceleration": [
+      4.043625683908162
+    ],
+    "maxJerk": [
+      13.847603429212242
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.790334233846355
+    ],
+    "currentVelocity": [
+      -0.741778789241522
+    ],
+    "currentAcceleration": [
+      1.9827218778097864
+    ],
+    "targetPosition": [
+      -3.1762403670713812
+    ],
+    "targetVelocity": [
+      -0.8899681435433164
+    ],
+    "targetAcceleration": [
+      -5.156351569286618
+    ],
+    "maxVelocity": [
+      2.8735803048474775
+    ],
+    "maxAcceleration": [
+      5.916359130904958
+    ],
+    "maxJerk": [
+      11.485084986306205
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.329396446291017
+    ],
+    "currentVelocity": [
+      4.063609122035922
+    ],
+    "currentAcceleration": [
+      -5.626813640985633
+    ],
+    "targetPosition": [
+      4.16345999071261
+    ],
+    "targetVelocity": [
+      4.09879075722829
+    ],
+    "targetAcceleration": [
+      -5.107980707454255
+    ],
+    "maxVelocity": [
+      5.2951556993880065
+    ],
+    "maxAcceleration": [
+      6.258615313312006
+    ],
+    "maxJerk": [
+      14.601056312775418
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.4319437055284165
+    ],
+    "currentVelocity": [
+      1.5477268856743738
+    ],
+    "currentAcceleration": [
+      3.739152162709617
+    ],
+    "targetPosition": [
+      8.869051887389261
+    ],
+    "targetVelocity": [
+      -4.476473691458639
+    ],
+    "targetAcceleration": [
+      0.22168212700103496
+    ],
+    "maxVelocity": [
+      7.985112416986569
+    ],
+    "maxAcceleration": [
+      9.28619147038515
+    ],
+    "maxJerk": [
+      12.180190662469144
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.757041115002263
+    ],
+    "currentVelocity": [
+      5.08842063304859
+    ],
+    "currentAcceleration": [
+      -8.04043096496242
+    ],
+    "targetPosition": [
+      9.96508213157189
+    ],
+    "targetVelocity": [
+      4.77354894190248
+    ],
+    "targetAcceleration": [
+      7.103560138073949
+    ],
+    "maxVelocity": [
+      7.213823278013117
+    ],
+    "maxAcceleration": [
+      9.919189634129037
+    ],
+    "maxJerk": [
+      17.742453932926956
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.96563332193677
+    ],
+    "currentVelocity": [
+      -1.5848170049481056
+    ],
+    "currentAcceleration": [
+      2.091342279990947
+    ],
+    "targetPosition": [
+      -5.602610539454802
+    ],
+    "targetVelocity": [
+      5.010533924545334
+    ],
+    "targetAcceleration": [
+      2.462681695264642
+    ],
+    "maxVelocity": [
+      5.188320091399354
+    ],
+    "maxAcceleration": [
+      6.001229825280049
+    ],
+    "maxJerk": [
+      15.87938894197682
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.9488159102051341
+    ],
+    "currentVelocity": [
+      -0.298315315234285
+    ],
+    "currentAcceleration": [
+      -3.2954780536941577
+    ],
+    "targetPosition": [
+      -8.21511064958623
+    ],
+    "targetVelocity": [
+      1.5356946255191355
+    ],
+    "targetAcceleration": [
+      1.3573311532551133
+    ],
+    "maxVelocity": [
+      4.196068336026728
+    ],
+    "maxAcceleration": [
+      3.699671820829685
+    ],
+    "maxJerk": [
+      6.530669812107893
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.458001642931025
+    ],
+    "currentVelocity": [
+      -1.1137768573259854
+    ],
+    "currentAcceleration": [
+      -4.136976895649853
+    ],
+    "targetPosition": [
+      -8.791819903537876
+    ],
+    "targetVelocity": [
+      -1.071227138739748
+    ],
+    "targetAcceleration": [
+      1.3880265458789065
+    ],
+    "maxVelocity": [
+      3.440158536263593
+    ],
+    "maxAcceleration": [
+      6.458068014768768
+    ],
+    "maxJerk": [
+      9.523989006264566
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.6255079589689565
+    ],
+    "currentVelocity": [
+      3.5278950707427192
+    ],
+    "currentAcceleration": [
+      -1.731715561102737
+    ],
+    "targetPosition": [
+      -7.149988920697645
+    ],
+    "targetVelocity": [
+      -0.4864626563531118
+    ],
+    "targetAcceleration": [
+      2.9158304254870533
+    ],
+    "maxVelocity": [
+      5.411417149405686
+    ],
+    "maxAcceleration": [
+      5.964205203713096
+    ],
+    "maxJerk": [
+      5.4554315740198875
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.4473294379379436
+    ],
+    "currentVelocity": [
+      1.3886073659898956
+    ],
+    "currentAcceleration": [
+      -0.4403086490571022
+    ],
+    "targetPosition": [
+      7.770951017148896
+    ],
+    "targetVelocity": [
+      2.181203200237208
+    ],
+    "targetAcceleration": [
+      -5.432154662602316
+    ],
+    "maxVelocity": [
+      6.412334441006955
+    ],
+    "maxAcceleration": [
+      5.794648886397326
+    ],
+    "maxJerk": [
+      6.637314290090703
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.8202695263294064
+    ],
+    "currentVelocity": [
+      1.434233002323925
+    ],
+    "currentAcceleration": [
+      -1.0385297544884455
+    ],
+    "targetPosition": [
+      -3.3515812746576206
+    ],
+    "targetVelocity": [
+      -4.6359974735611225
+    ],
+    "targetAcceleration": [
+      -3.9790494223503727
+    ],
+    "maxVelocity": [
+      5.627509403809221
+    ],
+    "maxAcceleration": [
+      6.265132369111206
+    ],
+    "maxJerk": [
+      17.218569641360922
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.809698475453843
+    ],
+    "currentVelocity": [
+      1.3562872051588872
+    ],
+    "currentAcceleration": [
+      7.766445833882463
+    ],
+    "targetPosition": [
+      3.8923257572951275
+    ],
+    "targetVelocity": [
+      0.720918383162136
+    ],
+    "targetAcceleration": [
+      -2.5303507112938135
+    ],
+    "maxVelocity": [
+      4.078637291489613
+    ],
+    "maxAcceleration": [
+      7.935252890948313
+    ],
+    "maxJerk": [
+      18.04913013424523
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.902515947099952
+    ],
+    "currentVelocity": [
+      2.800309945616572
+    ],
+    "currentAcceleration": [
+      -0.32093522794789786
+    ],
+    "targetPosition": [
+      9.852976325429069
+    ],
+    "targetVelocity": [
+      -2.706635214915014
+    ],
+    "targetAcceleration": [
+      -2.6826069639025616
+    ],
+    "maxVelocity": [
+      3.2108851453808773
+    ],
+    "maxAcceleration": [
+      3.2849574746754664
+    ],
+    "maxJerk": [
+      6.635648783964207
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.050295893636478
+    ],
+    "currentVelocity": [
+      -4.0646485714265825
+    ],
+    "currentAcceleration": [
+      3.5864955568640378
+    ],
+    "targetPosition": [
+      3.1776716168999144
+    ],
+    "targetVelocity": [
+      -2.08060667021097
+    ],
+    "targetAcceleration": [
+      -1.5354384828446488
+    ],
+    "maxVelocity": [
+      4.630852099609032
+    ],
+    "maxAcceleration": [
+      4.070386471564126
+    ],
+    "maxJerk": [
+      17.464820157105358
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.833537564385409
+    ],
+    "currentVelocity": [
+      0.4396093690557823
+    ],
+    "currentAcceleration": [
+      -1.6706504012774994
+    ],
+    "targetPosition": [
+      -8.962203612573234
+    ],
+    "targetVelocity": [
+      -2.8454176724417106
+    ],
+    "targetAcceleration": [
+      3.8634602748271636
+    ],
+    "maxVelocity": [
+      6.2520676523205605
+    ],
+    "maxAcceleration": [
+      5.992080048810916
+    ],
+    "maxJerk": [
+      5.045263936845178
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.732780825306271
+    ],
+    "currentVelocity": [
+      5.6015683482504395
+    ],
+    "currentAcceleration": [
+      -0.06304532367588411
+    ],
+    "targetPosition": [
+      8.070566953341537
+    ],
+    "targetVelocity": [
+      -4.5324119454128216
+    ],
+    "targetAcceleration": [
+      -2.0618889129936644
+    ],
+    "maxVelocity": [
+      6.43190610869184
+    ],
+    "maxAcceleration": [
+      3.383971786349779
+    ],
+    "maxJerk": [
+      15.63506674783334
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.682700425442106
+    ],
+    "currentVelocity": [
+      -2.4203042552012644
+    ],
+    "currentAcceleration": [
+      -2.558677423347753
+    ],
+    "targetPosition": [
+      3.4454669169431984
+    ],
+    "targetVelocity": [
+      3.216191849214143
+    ],
+    "targetAcceleration": [
+      1.373396969843256
+    ],
+    "maxVelocity": [
+      7.198499820623468
+    ],
+    "maxAcceleration": [
+      6.187000961580949
+    ],
+    "maxJerk": [
+      11.591053757801797
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.747221178601352
+    ],
+    "currentVelocity": [
+      -1.7471334530809557
+    ],
+    "currentAcceleration": [
+      2.8746495088092114
+    ],
+    "targetPosition": [
+      0.19935046454480698
+    ],
+    "targetVelocity": [
+      -3.919300106106066
+    ],
+    "targetAcceleration": [
+      -0.8664323457413028
+    ],
+    "maxVelocity": [
+      6.785764070560706
+    ],
+    "maxAcceleration": [
+      6.394701504932035
+    ],
+    "maxJerk": [
+      11.769149117953528
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.026510740380356
+    ],
+    "currentVelocity": [
+      -1.4130536494007635
+    ],
+    "currentAcceleration": [
+      -6.532967372816393
+    ],
+    "targetPosition": [
+      3.6370945109274206
+    ],
+    "targetVelocity": [
+      1.9466258022223908
+    ],
+    "targetAcceleration": [
+      7.333187531893621
+    ],
+    "maxVelocity": [
+      4.604185542315487
+    ],
+    "maxAcceleration": [
+      9.287379296976777
+    ],
+    "maxJerk": [
+      15.435753404358525
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.564366660148847
+    ],
+    "currentVelocity": [
+      -1.6490089981443536
+    ],
+    "currentAcceleration": [
+      -0.3669583056192667
+    ],
+    "targetPosition": [
+      8.326030343318202
+    ],
+    "targetVelocity": [
+      -0.5640360721167124
+    ],
+    "targetAcceleration": [
+      1.6099538084992013
+    ],
+    "maxVelocity": [
+      5.3092926737815676
+    ],
+    "maxAcceleration": [
+      3.3811705590626144
+    ],
+    "maxJerk": [
+      6.110729697751251
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.952927912355962
+    ],
+    "currentVelocity": [
+      2.4187191524043516
+    ],
+    "currentAcceleration": [
+      -2.6605713611664887
+    ],
+    "targetPosition": [
+      -2.041290410420837
+    ],
+    "targetVelocity": [
+      4.767059760145472
+    ],
+    "targetAcceleration": [
+      3.4538867166373883
+    ],
+    "maxVelocity": [
+      6.65772146257515
+    ],
+    "maxAcceleration": [
+      4.64014316013456
+    ],
+    "maxJerk": [
+      12.749709452215338
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.320264867972595
+    ],
+    "currentVelocity": [
+      -2.626788234842616
+    ],
+    "currentAcceleration": [
+      0.5353204303723711
+    ],
+    "targetPosition": [
+      5.36697292434755
+    ],
+    "targetVelocity": [
+      -0.40995525902296137
+    ],
+    "targetAcceleration": [
+      0.30618332802323955
+    ],
+    "maxVelocity": [
+      5.172968083602447
+    ],
+    "maxAcceleration": [
+      8.918696736857889
+    ],
+    "maxJerk": [
+      18.295689152364744
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.39343379194347
+    ],
+    "currentVelocity": [
+      0.2863924390687229
+    ],
+    "currentAcceleration": [
+      -3.40949880795244
+    ],
+    "targetPosition": [
+      9.664672628441178
+    ],
+    "targetVelocity": [
+      -2.899107014369033
+    ],
+    "targetAcceleration": [
+      0.32878062090776705
+    ],
+    "maxVelocity": [
+      3.7679930504984744
+    ],
+    "maxAcceleration": [
+      3.918166124432518
+    ],
+    "maxJerk": [
+      14.655730119551738
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.2219237413903912
+    ],
+    "currentVelocity": [
+      -3.4343919499492626
+    ],
+    "currentAcceleration": [
+      -5.69574785201246
+    ],
+    "targetPosition": [
+      1.523170107031678
+    ],
+    "targetVelocity": [
+      -0.42451949457497307
+    ],
+    "targetAcceleration": [
+      -0.27937664435173204
+    ],
+    "maxVelocity": [
+      4.430936347782379
+    ],
+    "maxAcceleration": [
+      7.349805091021329
+    ],
+    "maxJerk": [
+      19.80984854871428
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.5030638904795524
+    ],
+    "currentVelocity": [
+      4.553228961768265
+    ],
+    "currentAcceleration": [
+      -5.009042692835832
+    ],
+    "targetPosition": [
+      -5.633972387571724
+    ],
+    "targetVelocity": [
+      1.662711495403066
+    ],
+    "targetAcceleration": [
+      4.780501151543173
+    ],
+    "maxVelocity": [
+      5.41969382874919
+    ],
+    "maxAcceleration": [
+      6.534003099186811
+    ],
+    "maxJerk": [
+      19.99352970603167
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.0069322956786095
+    ],
+    "currentVelocity": [
+      -2.5668835665346963
+    ],
+    "currentAcceleration": [
+      6.58449830859163
+    ],
+    "targetPosition": [
+      9.007513831861004
+    ],
+    "targetVelocity": [
+      -2.4504399337149794
+    ],
+    "targetAcceleration": [
+      -4.216709011678282
+    ],
+    "maxVelocity": [
+      3.5381588231511785
+    ],
+    "maxAcceleration": [
+      8.416592956397903
+    ],
+    "maxJerk": [
+      5.312513556053127
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.4881544094399484
+    ],
+    "currentVelocity": [
+      2.4566383631584667
+    ],
+    "currentAcceleration": [
+      6.8054313781869595
+    ],
+    "targetPosition": [
+      3.350379401552315
+    ],
+    "targetVelocity": [
+      -1.5747782768943805
+    ],
+    "targetAcceleration": [
+      -4.536297266898021
+    ],
+    "maxVelocity": [
+      7.73428489486535
+    ],
+    "maxAcceleration": [
+      8.307441576050657
+    ],
+    "maxJerk": [
+      16.686902446400595
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.779937258752799
+    ],
+    "currentVelocity": [
+      0.9044460048880714
+    ],
+    "currentAcceleration": [
+      7.299048976539493
+    ],
+    "targetPosition": [
+      5.126918232940287
+    ],
+    "targetVelocity": [
+      -2.703129383966432
+    ],
+    "targetAcceleration": [
+      1.5056710746068331
+    ],
+    "maxVelocity": [
+      6.552047768923938
+    ],
+    "maxAcceleration": [
+      7.913571561195458
+    ],
+    "maxJerk": [
+      12.52728867925768
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.499103358637205
+    ],
+    "currentVelocity": [
+      1.9296436385549294
+    ],
+    "currentAcceleration": [
+      1.297119157194592
+    ],
+    "targetPosition": [
+      5.360956590047497
+    ],
+    "targetVelocity": [
+      -3.4709602701221067
+    ],
+    "targetAcceleration": [
+      -3.310814757076871
+    ],
+    "maxVelocity": [
+      3.50833771123097
+    ],
+    "maxAcceleration": [
+      5.874209040149816
+    ],
+    "maxJerk": [
+      12.947265780638942
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.909264094058912
+    ],
+    "currentVelocity": [
+      -1.0407712194511758
+    ],
+    "currentAcceleration": [
+      -0.2825609950154431
+    ],
+    "targetPosition": [
+      9.829283399042243
+    ],
+    "targetVelocity": [
+      7.268002255701104
+    ],
+    "targetAcceleration": [
+      -2.3830406730369003
+    ],
+    "maxVelocity": [
+      7.668308368423425
+    ],
+    "maxAcceleration": [
+      3.8205321627913094
+    ],
+    "maxJerk": [
+      18.88824005108657
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.915383610426762
+    ],
+    "currentVelocity": [
+      0.3307393467639397
+    ],
+    "currentAcceleration": [
+      0.0686657976457834
+    ],
+    "targetPosition": [
+      -7.744245823209582
+    ],
+    "targetVelocity": [
+      -0.21913767368370918
+    ],
+    "targetAcceleration": [
+      0.23722261368227393
+    ],
+    "maxVelocity": [
+      2.543939778235445
+    ],
+    "maxAcceleration": [
+      4.958215677563135
+    ],
+    "maxJerk": [
+      16.416017585338828
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.909952792592479
+    ],
+    "currentVelocity": [
+      -4.918992101215309
+    ],
+    "currentAcceleration": [
+      -1.4126159006174506
+    ],
+    "targetPosition": [
+      -2.364973653471023
+    ],
+    "targetVelocity": [
+      -1.164173265121354
+    ],
+    "targetAcceleration": [
+      2.8222063467141476
+    ],
+    "maxVelocity": [
+      7.992865571573543
+    ],
+    "maxAcceleration": [
+      4.614660095705546
+    ],
+    "maxJerk": [
+      10.127633252746579
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.7149043007093212
+    ],
+    "currentVelocity": [
+      -7.837382419389272
+    ],
+    "currentAcceleration": [
+      2.0541349423634783
+    ],
+    "targetPosition": [
+      0.9453431880355385
+    ],
+    "targetVelocity": [
+      3.392551361328305
+    ],
+    "targetAcceleration": [
+      -2.2432545952234784
+    ],
+    "maxVelocity": [
+      7.94570682863406
+    ],
+    "maxAcceleration": [
+      5.79886191621047
+    ],
+    "maxJerk": [
+      17.369564761554603
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.8541950711909134
+    ],
+    "currentVelocity": [
+      -1.8703740170324132
+    ],
+    "currentAcceleration": [
+      4.933908576214446
+    ],
+    "targetPosition": [
+      0.2820628777907679
+    ],
+    "targetVelocity": [
+      -0.1997649500379448
+    ],
+    "targetAcceleration": [
+      0.9165411694486236
+    ],
+    "maxVelocity": [
+      4.192069185500291
+    ],
+    "maxAcceleration": [
+      6.716236713255517
+    ],
+    "maxJerk": [
+      7.573661833810148
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.43054091337879
+    ],
+    "currentVelocity": [
+      -2.306324870431629
+    ],
+    "currentAcceleration": [
+      -1.6198234138473007
+    ],
+    "targetPosition": [
+      1.5475375575076136
+    ],
+    "targetVelocity": [
+      1.700372816196868
+    ],
+    "targetAcceleration": [
+      -6.942393763892719
+    ],
+    "maxVelocity": [
+      3.5507525552567802
+    ],
+    "maxAcceleration": [
+      9.144125919202027
+    ],
+    "maxJerk": [
+      17.013806459774464
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.1850535417646704
+    ],
+    "currentVelocity": [
+      2.6473315147974086
+    ],
+    "currentAcceleration": [
+      -0.6190782820255487
+    ],
+    "targetPosition": [
+      9.850481760035162
+    ],
+    "targetVelocity": [
+      -4.674428509716651
+    ],
+    "targetAcceleration": [
+      -5.072742500460528
+    ],
+    "maxVelocity": [
+      5.566328504559627
+    ],
+    "maxAcceleration": [
+      5.076733257412415
+    ],
+    "maxJerk": [
+      11.488700615308174
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.039023976305339
+    ],
+    "currentVelocity": [
+      0.06143093257601695
+    ],
+    "currentAcceleration": [
+      -4.300724388328241
+    ],
+    "targetPosition": [
+      1.5465146490636634
+    ],
+    "targetVelocity": [
+      0.2660050022555196
+    ],
+    "targetAcceleration": [
+      7.333271261140466
+    ],
+    "maxVelocity": [
+      3.698936553728008
+    ],
+    "maxAcceleration": [
+      8.908184038960206
+    ],
+    "maxJerk": [
+      8.375048442086714
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.595320920174928
+    ],
+    "currentVelocity": [
+      0.8578066204970458
+    ],
+    "currentAcceleration": [
+      1.6599164979453231
+    ],
+    "targetPosition": [
+      4.452742837779764
+    ],
+    "targetVelocity": [
+      -0.46116860884305666
+    ],
+    "targetAcceleration": [
+      0.35361632949489685
+    ],
+    "maxVelocity": [
+      4.610230512431057
+    ],
+    "maxAcceleration": [
+      6.205461436614957
+    ],
+    "maxJerk": [
+      18.106450552197103
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6297716564321743
+    ],
+    "currentVelocity": [
+      5.365883359142174
+    ],
+    "currentAcceleration": [
+      4.28294397712652
+    ],
+    "targetPosition": [
+      1.7227962961238141
+    ],
+    "targetVelocity": [
+      4.730302100312791
+    ],
+    "targetAcceleration": [
+      6.776029877463564
+    ],
+    "maxVelocity": [
+      7.4442498849789125
+    ],
+    "maxAcceleration": [
+      8.648603123836605
+    ],
+    "maxJerk": [
+      12.450499050996424
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.798387219695302
+    ],
+    "currentVelocity": [
+      -3.7986218525884357
+    ],
+    "currentAcceleration": [
+      6.405765856877433
+    ],
+    "targetPosition": [
+      5.099763511282831
+    ],
+    "targetVelocity": [
+      6.175586035126672
+    ],
+    "targetAcceleration": [
+      -3.888766918427571
+    ],
+    "maxVelocity": [
+      7.08070720546395
+    ],
+    "maxAcceleration": [
+      7.3016334651422445
+    ],
+    "maxJerk": [
+      9.571766964962983
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.8112115702005713
+    ],
+    "currentVelocity": [
+      -4.83351592366865
+    ],
+    "currentAcceleration": [
+      3.70410730007287
+    ],
+    "targetPosition": [
+      4.8480158023512825
+    ],
+    "targetVelocity": [
+      3.4259983078303105
+    ],
+    "targetAcceleration": [
+      3.7535631705878387
+    ],
+    "maxVelocity": [
+      5.816316976106759
+    ],
+    "maxAcceleration": [
+      6.29242019728861
+    ],
+    "maxJerk": [
+      17.255601574545764
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.9596408304686346
+    ],
+    "currentVelocity": [
+      0.5414179496494942
+    ],
+    "currentAcceleration": [
+      -2.0326080250025447
+    ],
+    "targetPosition": [
+      -7.485324989907789
+    ],
+    "targetVelocity": [
+      -1.5677444957154005
+    ],
+    "targetAcceleration": [
+      5.854622862530974
+    ],
+    "maxVelocity": [
+      4.739457643004199
+    ],
+    "maxAcceleration": [
+      6.015112288129455
+    ],
+    "maxJerk": [
+      17.140254745289617
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.428152527647761
+    ],
+    "currentVelocity": [
+      3.9603638406311967
+    ],
+    "currentAcceleration": [
+      0.41907119767948897
+    ],
+    "targetPosition": [
+      -1.9105590884932706
+    ],
+    "targetVelocity": [
+      -3.2785411293017233
+    ],
+    "targetAcceleration": [
+      3.6947819019022705
+    ],
+    "maxVelocity": [
+      4.1020971913375694
+    ],
+    "maxAcceleration": [
+      3.7886726157963184
+    ],
+    "maxJerk": [
+      10.50840810386943
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.771573753903802
+    ],
+    "currentVelocity": [
+      -0.1740875012798817
+    ],
+    "currentAcceleration": [
+      2.757940654880488
+    ],
+    "targetPosition": [
+      9.721133073147644
+    ],
+    "targetVelocity": [
+      -6.367904156563162
+    ],
+    "targetAcceleration": [
+      -0.08218538869443126
+    ],
+    "maxVelocity": [
+      6.620187486463343
+    ],
+    "maxAcceleration": [
+      7.62433045011793
+    ],
+    "maxJerk": [
+      16.592891943777417
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.5944127463285485
+    ],
+    "currentVelocity": [
+      0.4322696952554326
+    ],
+    "currentAcceleration": [
+      0.9916174294726003
+    ],
+    "targetPosition": [
+      -0.0748185019212162
+    ],
+    "targetVelocity": [
+      3.8177718143243684
+    ],
+    "targetAcceleration": [
+      4.235059405868772
+    ],
+    "maxVelocity": [
+      6.975194915615356
+    ],
+    "maxAcceleration": [
+      7.938902461780901
+    ],
+    "maxJerk": [
+      10.940028348345013
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.6179577647107095
+    ],
+    "currentVelocity": [
+      -0.55390522739836
+    ],
+    "currentAcceleration": [
+      -3.2565988979042677
+    ],
+    "targetPosition": [
+      1.0430483052522561
+    ],
+    "targetVelocity": [
+      -0.12834992803435963
+    ],
+    "targetAcceleration": [
+      4.144501656529978
+    ],
+    "maxVelocity": [
+      6.6353893766667085
+    ],
+    "maxAcceleration": [
+      7.8060962801917215
+    ],
+    "maxJerk": [
+      17.622084821085352
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.5771387408121793
+    ],
+    "currentVelocity": [
+      -2.5934225760362635
+    ],
+    "currentAcceleration": [
+      1.9669877471704833
+    ],
+    "targetPosition": [
+      3.5378412032692133
+    ],
+    "targetVelocity": [
+      -3.012073524989833
+    ],
+    "targetAcceleration": [
+      1.333266053879548
+    ],
+    "maxVelocity": [
+      4.468091450605964
+    ],
+    "maxAcceleration": [
+      7.236111911637169
+    ],
+    "maxJerk": [
+      19.079244665481262
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.201346270031516
+    ],
+    "currentVelocity": [
+      -1.4084699685202364
+    ],
+    "currentAcceleration": [
+      7.98987686651266
+    ],
+    "targetPosition": [
+      4.591759436209733
+    ],
+    "targetVelocity": [
+      2.0324085637890548
+    ],
+    "targetAcceleration": [
+      7.773550605247273
+    ],
+    "maxVelocity": [
+      2.923162787644314
+    ],
+    "maxAcceleration": [
+      8.278362674764736
+    ],
+    "maxJerk": [
+      17.6578789656541
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.649286098531173
+    ],
+    "currentVelocity": [
+      4.74235268468563
+    ],
+    "currentAcceleration": [
+      2.018418974128303
+    ],
+    "targetPosition": [
+      3.3773523157554397
+    ],
+    "targetVelocity": [
+      -3.6269015521095613
+    ],
+    "targetAcceleration": [
+      -1.2430819555195791
+    ],
+    "maxVelocity": [
+      5.7534486726219844
+    ],
+    "maxAcceleration": [
+      7.3011930598111165
+    ],
+    "maxJerk": [
+      10.483850694948682
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.026592632718435
+    ],
+    "currentVelocity": [
+      0.6002717142748235
+    ],
+    "currentAcceleration": [
+      -3.460070543829607
+    ],
+    "targetPosition": [
+      -5.949156802975288
+    ],
+    "targetVelocity": [
+      -1.0668402252268594
+    ],
+    "targetAcceleration": [
+      -3.7430268505710473
+    ],
+    "maxVelocity": [
+      2.4838074038519835
+    ],
+    "maxAcceleration": [
+      5.246109260219976
+    ],
+    "maxJerk": [
+      6.7166732904103235
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.1711088511673005
+    ],
+    "currentVelocity": [
+      0.039015430601129
+    ],
+    "currentAcceleration": [
+      7.520585216945451
+    ],
+    "targetPosition": [
+      9.463907841406737
+    ],
+    "targetVelocity": [
+      3.4976768717946527
+    ],
+    "targetAcceleration": [
+      1.5992543626294609
+    ],
+    "maxVelocity": [
+      4.956658577305127
+    ],
+    "maxAcceleration": [
+      9.01196826928812
+    ],
+    "maxJerk": [
+      17.677712514463643
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.0169545396445852
+    ],
+    "currentVelocity": [
+      2.1067029081631787
+    ],
+    "currentAcceleration": [
+      -4.267936332766594
+    ],
+    "targetPosition": [
+      2.9734259413290687
+    ],
+    "targetVelocity": [
+      1.8115728897231094
+    ],
+    "targetAcceleration": [
+      5.100037500244731
+    ],
+    "maxVelocity": [
+      4.481091264580375
+    ],
+    "maxAcceleration": [
+      9.586865046836134
+    ],
+    "maxJerk": [
+      11.63696661647933
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.69690599261126
+    ],
+    "currentVelocity": [
+      -3.022425854284905
+    ],
+    "currentAcceleration": [
+      -1.3406610017922476
+    ],
+    "targetPosition": [
+      6.618687307196545
+    ],
+    "targetVelocity": [
+      0.09439570050458457
+    ],
+    "targetAcceleration": [
+      -0.5392109055311978
+    ],
+    "maxVelocity": [
+      4.269287394119607
+    ],
+    "maxAcceleration": [
+      3.6015743961756312
+    ],
+    "maxJerk": [
+      17.769475361378824
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.292634644330809
+    ],
+    "currentVelocity": [
+      3.4102454158735362
+    ],
+    "currentAcceleration": [
+      0.32630662753132
+    ],
+    "targetPosition": [
+      -6.15504091057272
+    ],
+    "targetVelocity": [
+      -2.895714739730863
+    ],
+    "targetAcceleration": [
+      3.3363328579766023
+    ],
+    "maxVelocity": [
+      7.562713889227748
+    ],
+    "maxAcceleration": [
+      8.610157548975529
+    ],
+    "maxJerk": [
+      15.644054478255605
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.629517717450642
+    ],
+    "currentVelocity": [
+      3.2748718774447942
+    ],
+    "currentAcceleration": [
+      -1.4069207090519331
+    ],
+    "targetPosition": [
+      1.808453605508987
+    ],
+    "targetVelocity": [
+      4.20531836113638
+    ],
+    "targetAcceleration": [
+      -0.6799665765993508
+    ],
+    "maxVelocity": [
+      4.301240032263241
+    ],
+    "maxAcceleration": [
+      6.928564138623992
+    ],
+    "maxJerk": [
+      18.25297558624795
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.0342377735417365
+    ],
+    "currentVelocity": [
+      -1.9502709045909572
+    ],
+    "currentAcceleration": [
+      -2.5375382033270713
+    ],
+    "targetPosition": [
+      4.948530372005248
+    ],
+    "targetVelocity": [
+      -2.960490226683234
+    ],
+    "targetAcceleration": [
+      -4.811359147375982
+    ],
+    "maxVelocity": [
+      3.057258005880402
+    ],
+    "maxAcceleration": [
+      8.850055333947164
+    ],
+    "maxJerk": [
+      15.911808522548585
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.3366097032676905
+    ],
+    "currentVelocity": [
+      3.87673020495299
+    ],
+    "currentAcceleration": [
+      -3.3809495322037177
+    ],
+    "targetPosition": [
+      3.725672836105593
+    ],
+    "targetVelocity": [
+      1.916166276260837
+    ],
+    "targetAcceleration": [
+      3.244899249297534
+    ],
+    "maxVelocity": [
+      7.0658335326158195
+    ],
+    "maxAcceleration": [
+      8.933332637536012
+    ],
+    "maxJerk": [
+      18.566910222209117
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.852318966500556
+    ],
+    "currentVelocity": [
+      1.985020788125408
+    ],
+    "currentAcceleration": [
+      1.8651449247443432
+    ],
+    "targetPosition": [
+      4.102239629703956
+    ],
+    "targetVelocity": [
+      1.8287520189870792
+    ],
+    "targetAcceleration": [
+      0.6899836713057725
+    ],
+    "maxVelocity": [
+      3.7035376899940022
+    ],
+    "maxAcceleration": [
+      4.881642323551764
+    ],
+    "maxJerk": [
+      16.465571125818187
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.245209804247225
+    ],
+    "currentVelocity": [
+      0.7561608120681025
+    ],
+    "currentAcceleration": [
+      4.011779109137017
+    ],
+    "targetPosition": [
+      -8.018466872667044
+    ],
+    "targetVelocity": [
+      -1.9850087454502123
+    ],
+    "targetAcceleration": [
+      -4.609653879990344
+    ],
+    "maxVelocity": [
+      3.238401016901188
+    ],
+    "maxAcceleration": [
+      5.252337610767433
+    ],
+    "maxJerk": [
+      8.526248005997143
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.020965205432562
+    ],
+    "currentVelocity": [
+      0.9725787882066044
+    ],
+    "currentAcceleration": [
+      3.196488179499026
+    ],
+    "targetPosition": [
+      -0.9110608028772322
+    ],
+    "targetVelocity": [
+      2.427411765447739
+    ],
+    "targetAcceleration": [
+      0.7907424466462727
+    ],
+    "maxVelocity": [
+      6.311310500169342
+    ],
+    "maxAcceleration": [
+      4.343075849757364
+    ],
+    "maxJerk": [
+      16.69529176509715
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.311621684399832
+    ],
+    "currentVelocity": [
+      2.3248315135066155
+    ],
+    "currentAcceleration": [
+      -3.9145780513979442
+    ],
+    "targetPosition": [
+      -4.176029275907441
+    ],
+    "targetVelocity": [
+      3.8848784937658944
+    ],
+    "targetAcceleration": [
+      5.113516670269014
+    ],
+    "maxVelocity": [
+      4.331225640566233
+    ],
+    "maxAcceleration": [
+      6.754591498454371
+    ],
+    "maxJerk": [
+      11.73673141984034
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.977460801212617
+    ],
+    "currentVelocity": [
+      0.18600478648015883
+    ],
+    "currentAcceleration": [
+      3.181050861860996
+    ],
+    "targetPosition": [
+      -7.661841661951241
+    ],
+    "targetVelocity": [
+      1.739543581503081
+    ],
+    "targetAcceleration": [
+      -0.04802332603140691
+    ],
+    "maxVelocity": [
+      3.0476628784204443
+    ],
+    "maxAcceleration": [
+      9.036807543718584
+    ],
+    "maxJerk": [
+      11.370353351159944
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6552783924485936
+    ],
+    "currentVelocity": [
+      -0.1309737680494334
+    ],
+    "currentAcceleration": [
+      -4.589673225685813
+    ],
+    "targetPosition": [
+      -6.457811128073998
+    ],
+    "targetVelocity": [
+      0.7039367059557913
+    ],
+    "targetAcceleration": [
+      -0.3054393097083441
+    ],
+    "maxVelocity": [
+      2.9745601775371733
+    ],
+    "maxAcceleration": [
+      5.553782067056143
+    ],
+    "maxJerk": [
+      9.088823004258881
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.904065551180604
+    ],
+    "currentVelocity": [
+      -2.479509398825482
+    ],
+    "currentAcceleration": [
+      -0.8887099011666035
+    ],
+    "targetPosition": [
+      -2.091336510651505
+    ],
+    "targetVelocity": [
+      -1.0568283163364836
+    ],
+    "targetAcceleration": [
+      3.1645305872424005
+    ],
+    "maxVelocity": [
+      4.510956663716154
+    ],
+    "maxAcceleration": [
+      4.757414753918617
+    ],
+    "maxJerk": [
+      5.1369290920035
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.4694877940704867
+    ],
+    "currentVelocity": [
+      -2.1091042054408384
+    ],
+    "currentAcceleration": [
+      -0.893534062451983
+    ],
+    "targetPosition": [
+      0.6758671140283425
+    ],
+    "targetVelocity": [
+      -0.8510283312925349
+    ],
+    "targetAcceleration": [
+      4.226549495319971
+    ],
+    "maxVelocity": [
+      2.7363150443665254
+    ],
+    "maxAcceleration": [
+      5.707192018690635
+    ],
+    "maxJerk": [
+      19.484710069302572
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.7005077913747098
+    ],
+    "currentVelocity": [
+      0.04960869055578243
+    ],
+    "currentAcceleration": [
+      -4.032922621113085
+    ],
+    "targetPosition": [
+      7.173547150709727
+    ],
+    "targetVelocity": [
+      -1.2116910565927583
+    ],
+    "targetAcceleration": [
+      0.16074086487390993
+    ],
+    "maxVelocity": [
+      3.041998774276921
+    ],
+    "maxAcceleration": [
+      4.975391126444973
+    ],
+    "maxJerk": [
+      19.218561808067495
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.6328482339052748
+    ],
+    "currentVelocity": [
+      -1.3297569462715915
+    ],
+    "currentAcceleration": [
+      5.614724608558919
+    ],
+    "targetPosition": [
+      -8.933754353806533
+    ],
+    "targetVelocity": [
+      2.2868518617694757
+    ],
+    "targetAcceleration": [
+      6.975112738299466
+    ],
+    "maxVelocity": [
+      6.863973871934089
+    ],
+    "maxAcceleration": [
+      7.82127552722011
+    ],
+    "maxJerk": [
+      10.632315090831717
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.3729323663697546
+    ],
+    "currentVelocity": [
+      1.6759542150470703
+    ],
+    "currentAcceleration": [
+      0.8648645872509944
+    ],
+    "targetPosition": [
+      6.748078146505161
+    ],
+    "targetVelocity": [
+      0.7360812176803564
+    ],
+    "targetAcceleration": [
+      0.11230840008912057
+    ],
+    "maxVelocity": [
+      3.701393124593283
+    ],
+    "maxAcceleration": [
+      6.911822314082665
+    ],
+    "maxJerk": [
+      17.058173875907862
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.956174138141396
+    ],
+    "currentVelocity": [
+      -3.0993494891404256
+    ],
+    "currentAcceleration": [
+      -0.6995658477525488
+    ],
+    "targetPosition": [
+      8.189686822035718
+    ],
+    "targetVelocity": [
+      0.9437114624771672
+    ],
+    "targetAcceleration": [
+      -4.654737292493321
+    ],
+    "maxVelocity": [
+      4.023999312283291
+    ],
+    "maxAcceleration": [
+      6.030922047135796
+    ],
+    "maxJerk": [
+      8.323956777325513
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.28760841086039
+    ],
+    "currentVelocity": [
+      3.179265517513195
+    ],
+    "currentAcceleration": [
+      3.900399069276671
+    ],
+    "targetPosition": [
+      -3.1848691911957
+    ],
+    "targetVelocity": [
+      -1.5081117793045995
+    ],
+    "targetAcceleration": [
+      -1.348580144611212
+    ],
+    "maxVelocity": [
+      4.6627599508618225
+    ],
+    "maxAcceleration": [
+      6.944048544477503
+    ],
+    "maxJerk": [
+      7.131238393093009
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.5066302354069165
+    ],
+    "currentVelocity": [
+      1.7262786146651363
+    ],
+    "currentAcceleration": [
+      2.546426385815167
+    ],
+    "targetPosition": [
+      9.955541773883464
+    ],
+    "targetVelocity": [
+      0.24845300129585102
+    ],
+    "targetAcceleration": [
+      -1.9944149137173692
+    ],
+    "maxVelocity": [
+      4.525841552020394
+    ],
+    "maxAcceleration": [
+      9.04593851243476
+    ],
+    "maxJerk": [
+      14.908956020239803
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.444808677725639
+    ],
+    "currentVelocity": [
+      0.15584917818767074
+    ],
+    "currentAcceleration": [
+      -1.7786560638034574
+    ],
+    "targetPosition": [
+      8.564148423582253
+    ],
+    "targetVelocity": [
+      -0.9657696503212903
+    ],
+    "targetAcceleration": [
+      -1.7735829087735642
+    ],
+    "maxVelocity": [
+      2.1621440226736053
+    ],
+    "maxAcceleration": [
+      4.06214645740598
+    ],
+    "maxJerk": [
+      14.815873798912216
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.325134461538241
+    ],
+    "currentVelocity": [
+      -0.4978501601446941
+    ],
+    "currentAcceleration": [
+      4.9343338999195385
+    ],
+    "targetPosition": [
+      -0.4416851915385518
+    ],
+    "targetVelocity": [
+      2.241642827335042
+    ],
+    "targetAcceleration": [
+      -2.0034545946949653
+    ],
+    "maxVelocity": [
+      3.4123313047332244
+    ],
+    "maxAcceleration": [
+      5.698849625382115
+    ],
+    "maxJerk": [
+      13.47552274274214
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.45475896592332
+    ],
+    "currentVelocity": [
+      2.5199884472840957
+    ],
+    "currentAcceleration": [
+      0.1372816947203246
+    ],
+    "targetPosition": [
+      7.406124451947157
+    ],
+    "targetVelocity": [
+      1.094380146339509
+    ],
+    "targetAcceleration": [
+      1.341674472452083
+    ],
+    "maxVelocity": [
+      2.6744282412371003
+    ],
+    "maxAcceleration": [
+      7.57140150763706
+    ],
+    "maxJerk": [
+      16.68921144877384
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.1588521740769977
+    ],
+    "currentVelocity": [
+      -0.8095154420210078
+    ],
+    "currentAcceleration": [
+      -3.473595354844354
+    ],
+    "targetPosition": [
+      -9.294306686525681
+    ],
+    "targetVelocity": [
+      1.167610441898399
+    ],
+    "targetAcceleration": [
+      4.579408813174064
+    ],
+    "maxVelocity": [
+      2.102747740739786
+    ],
+    "maxAcceleration": [
+      5.864437019615549
+    ],
+    "maxJerk": [
+      11.877053644566402
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.249956324768704
+    ],
+    "currentVelocity": [
+      -1.9465608235448877
+    ],
+    "currentAcceleration": [
+      -2.6214118706273957
+    ],
+    "targetPosition": [
+      -9.588909937794089
+    ],
+    "targetVelocity": [
+      1.0199475916509355
+    ],
+    "targetAcceleration": [
+      -1.6511004892269012
+    ],
+    "maxVelocity": [
+      3.883374239307103
+    ],
+    "maxAcceleration": [
+      3.432371453721913
+    ],
+    "maxJerk": [
+      19.717123776152075
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.576946858871851
+    ],
+    "currentVelocity": [
+      3.3916794538216752
+    ],
+    "currentAcceleration": [
+      2.16661680723937
+    ],
+    "targetPosition": [
+      -4.298102324657906
+    ],
+    "targetVelocity": [
+      -1.1876232765355175
+    ],
+    "targetAcceleration": [
+      0.5129577117069548
+    ],
+    "maxVelocity": [
+      6.556781557120335
+    ],
+    "maxAcceleration": [
+      8.182690921194844
+    ],
+    "maxJerk": [
+      8.90549468041334
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.490642710144281
+    ],
+    "currentVelocity": [
+      -5.842698662432203
+    ],
+    "currentAcceleration": [
+      4.0449284110664
+    ],
+    "targetPosition": [
+      7.142430377967344
+    ],
+    "targetVelocity": [
+      -0.553579132075031
+    ],
+    "targetAcceleration": [
+      0.3509412356188184
+    ],
+    "maxVelocity": [
+      6.260646549821863
+    ],
+    "maxAcceleration": [
+      6.592195542701721
+    ],
+    "maxJerk": [
+      14.79946608335356
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.408093417861746
+    ],
+    "currentVelocity": [
+      -2.489643895298437
+    ],
+    "currentAcceleration": [
+      -0.3178195174946268
+    ],
+    "targetPosition": [
+      9.890348934930639
+    ],
+    "targetVelocity": [
+      -3.854328131170635
+    ],
+    "targetAcceleration": [
+      -5.645913212803529
+    ],
+    "maxVelocity": [
+      6.2771615743880105
+    ],
+    "maxAcceleration": [
+      5.839328517745357
+    ],
+    "maxJerk": [
+      19.448615985883155
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.50689072548634
+    ],
+    "currentVelocity": [
+      0.5270538383325061
+    ],
+    "currentAcceleration": [
+      3.6956065418515838
+    ],
+    "targetPosition": [
+      8.246324716235044
+    ],
+    "targetVelocity": [
+      1.0057807094760802
+    ],
+    "targetAcceleration": [
+      1.9077726647657869
+    ],
+    "maxVelocity": [
+      2.2718402512475953
+    ],
+    "maxAcceleration": [
+      3.7357413511951885
+    ],
+    "maxJerk": [
+      5.539821564622219
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.270606375221306
+    ],
+    "currentVelocity": [
+      0.9622951482179447
+    ],
+    "currentAcceleration": [
+      3.1968703541888974
+    ],
+    "targetPosition": [
+      7.223724337814808
+    ],
+    "targetVelocity": [
+      -1.7896654164102415
+    ],
+    "targetAcceleration": [
+      0.7709990888366729
+    ],
+    "maxVelocity": [
+      3.3314994982887383
+    ],
+    "maxAcceleration": [
+      6.460893366537242
+    ],
+    "maxJerk": [
+      6.264758351244503
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.670667093697979
+    ],
+    "currentVelocity": [
+      -0.24336476507762939
+    ],
+    "currentAcceleration": [
+      -3.012960009867646
+    ],
+    "targetPosition": [
+      1.1220667962387054
+    ],
+    "targetVelocity": [
+      -0.643563442216867
+    ],
+    "targetAcceleration": [
+      -4.128938528881824
+    ],
+    "maxVelocity": [
+      5.44472655945329
+    ],
+    "maxAcceleration": [
+      9.579725274853715
+    ],
+    "maxJerk": [
+      11.138914920150716
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.346838537447205
+    ],
+    "currentVelocity": [
+      1.9955037403577012
+    ],
+    "currentAcceleration": [
+      -0.7086148294342518
+    ],
+    "targetPosition": [
+      -3.144098777652453
+    ],
+    "targetVelocity": [
+      -1.9454340290448882
+    ],
+    "targetAcceleration": [
+      0.8715777975833348
+    ],
+    "maxVelocity": [
+      3.4300446497079373
+    ],
+    "maxAcceleration": [
+      7.078750629002324
+    ],
+    "maxJerk": [
+      5.240200833468292
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.801964648972717
+    ],
+    "currentVelocity": [
+      -1.6853024507357777
+    ],
+    "currentAcceleration": [
+      5.880912368492675
+    ],
+    "targetPosition": [
+      -5.491145714585571
+    ],
+    "targetVelocity": [
+      -2.974478306119961
+    ],
+    "targetAcceleration": [
+      2.6869625979529097
+    ],
+    "maxVelocity": [
+      7.0422464324166105
+    ],
+    "maxAcceleration": [
+      8.93646040969493
+    ],
+    "maxJerk": [
+      15.489536999554149
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.990371859714362
+    ],
+    "currentVelocity": [
+      -1.9225941103392614
+    ],
+    "currentAcceleration": [
+      4.592048795398
+    ],
+    "targetPosition": [
+      9.184976492092623
+    ],
+    "targetVelocity": [
+      -7.584118137467144
+    ],
+    "targetAcceleration": [
+      2.455176611149052
+    ],
+    "maxVelocity": [
+      7.886872584615654
+    ],
+    "maxAcceleration": [
+      4.987991684193936
+    ],
+    "maxJerk": [
+      13.72457288236691
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.098926578200736
+    ],
+    "currentVelocity": [
+      -3.720682458708576
+    ],
+    "currentAcceleration": [
+      6.196383733917425
+    ],
+    "targetPosition": [
+      -0.6962918101663895
+    ],
+    "targetVelocity": [
+      3.743527661078942
+    ],
+    "targetAcceleration": [
+      -2.922195172913793
+    ],
+    "maxVelocity": [
+      7.026233338885677
+    ],
+    "maxAcceleration": [
+      6.974679006560199
+    ],
+    "maxJerk": [
+      6.300864214005818
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.163195706617515
+    ],
+    "currentVelocity": [
+      1.7019087968166815
+    ],
+    "currentAcceleration": [
+      -3.757474022991947
+    ],
+    "targetPosition": [
+      9.010652758826737
+    ],
+    "targetVelocity": [
+      -3.2818774753027804
+    ],
+    "targetAcceleration": [
+      -0.9582174491800619
+    ],
+    "maxVelocity": [
+      5.346707477488692
+    ],
+    "maxAcceleration": [
+      4.634650410056487
+    ],
+    "maxJerk": [
+      13.314066243119434
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.48554638140747
+    ],
+    "currentVelocity": [
+      4.935420711310972
+    ],
+    "currentAcceleration": [
+      -3.356804275135879
+    ],
+    "targetPosition": [
+      -9.366832720074393
+    ],
+    "targetVelocity": [
+      -1.8780596813222203
+    ],
+    "targetAcceleration": [
+      -1.3011967253699144
+    ],
+    "maxVelocity": [
+      6.427644588815378
+    ],
+    "maxAcceleration": [
+      3.3966327653966712
+    ],
+    "maxJerk": [
+      14.506724665978517
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.377140564774221
+    ],
+    "currentVelocity": [
+      -2.9728403328336377
+    ],
+    "currentAcceleration": [
+      7.020750462323811
+    ],
+    "targetPosition": [
+      3.054258422465521
+    ],
+    "targetVelocity": [
+      -2.706047591546625
+    ],
+    "targetAcceleration": [
+      1.263705313594679
+    ],
+    "maxVelocity": [
+      6.925095528258865
+    ],
+    "maxAcceleration": [
+      8.629936563372215
+    ],
+    "maxJerk": [
+      12.527741686405658
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.496261655345265
+    ],
+    "currentVelocity": [
+      -0.10833478698620214
+    ],
+    "currentAcceleration": [
+      3.571259188551151
+    ],
+    "targetPosition": [
+      -5.030135613328746
+    ],
+    "targetVelocity": [
+      1.647456341902335
+    ],
+    "targetAcceleration": [
+      2.6535426048538397
+    ],
+    "maxVelocity": [
+      2.721468173901986
+    ],
+    "maxAcceleration": [
+      7.102723647184861
+    ],
+    "maxJerk": [
+      15.20970251052233
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.236460367042492
+    ],
+    "currentVelocity": [
+      -2.6925273502836395
+    ],
+    "currentAcceleration": [
+      -2.842918462947611
+    ],
+    "targetPosition": [
+      1.2065245522459183
+    ],
+    "targetVelocity": [
+      -0.08495638660078964
+    ],
+    "targetAcceleration": [
+      -1.1952931680293517
+    ],
+    "maxVelocity": [
+      5.345253765158922
+    ],
+    "maxAcceleration": [
+      3.752011902498942
+    ],
+    "maxJerk": [
+      18.9409209732491
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.052355398930047
+    ],
+    "currentVelocity": [
+      -1.0472463460481434
+    ],
+    "currentAcceleration": [
+      -6.287591218601652
+    ],
+    "targetPosition": [
+      -3.000154370487138
+    ],
+    "targetVelocity": [
+      4.244557133912784
+    ],
+    "targetAcceleration": [
+      -2.715795826180636
+    ],
+    "maxVelocity": [
+      5.758899250031695
+    ],
+    "maxAcceleration": [
+      7.088903220105583
+    ],
+    "maxJerk": [
+      15.51278088826269
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.5645135766056324
+    ],
+    "currentVelocity": [
+      -5.733179759825664
+    ],
+    "currentAcceleration": [
+      2.2102167752572246
+    ],
+    "targetPosition": [
+      4.802665498859707
+    ],
+    "targetVelocity": [
+      -1.8555513297738147
+    ],
+    "targetAcceleration": [
+      3.818279304485321
+    ],
+    "maxVelocity": [
+      7.328628784971947
+    ],
+    "maxAcceleration": [
+      5.2428418322332835
+    ],
+    "maxJerk": [
+      16.606109269245437
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.327808933229754
+    ],
+    "currentVelocity": [
+      0.9449214216274715
+    ],
+    "currentAcceleration": [
+      -3.54342923020719
+    ],
+    "targetPosition": [
+      3.41506490411442
+    ],
+    "targetVelocity": [
+      -0.808220662153303
+    ],
+    "targetAcceleration": [
+      -1.0975672351680732
+    ],
+    "maxVelocity": [
+      2.052827970031132
+    ],
+    "maxAcceleration": [
+      9.862140421824618
+    ],
+    "maxJerk": [
+      7.950951780392696
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.1876810370993418
+    ],
+    "currentVelocity": [
+      2.2827155408351816
+    ],
+    "currentAcceleration": [
+      -1.477901299495766
+    ],
+    "targetPosition": [
+      -5.432243222872826
+    ],
+    "targetVelocity": [
+      1.1575454770626532
+    ],
+    "targetAcceleration": [
+      2.600110467423759
+    ],
+    "maxVelocity": [
+      2.4461147142780675
+    ],
+    "maxAcceleration": [
+      8.849357496599053
+    ],
+    "maxJerk": [
+      6.825133175914155
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.7962525238871425
+    ],
+    "currentVelocity": [
+      -0.3646250884560889
+    ],
+    "currentAcceleration": [
+      -0.32270631269578587
+    ],
+    "targetPosition": [
+      -8.282420431141047
+    ],
+    "targetVelocity": [
+      2.8854781958932314
+    ],
+    "targetAcceleration": [
+      -2.026765433154808
+    ],
+    "maxVelocity": [
+      4.592452841402554
+    ],
+    "maxAcceleration": [
+      3.412433715784003
+    ],
+    "maxJerk": [
+      18.452846381252762
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.396413510627251
+    ],
+    "currentVelocity": [
+      3.36509021095626
+    ],
+    "currentAcceleration": [
+      -1.7870622130032254
+    ],
+    "targetPosition": [
+      6.793700066248615
+    ],
+    "targetVelocity": [
+      0.9843884206029534
+    ],
+    "targetAcceleration": [
+      1.8074274374972372
+    ],
+    "maxVelocity": [
+      3.552705590525564
+    ],
+    "maxAcceleration": [
+      6.5112943325307935
+    ],
+    "maxJerk": [
+      5.426665554124929
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.34192973189338
+    ],
+    "currentVelocity": [
+      2.9934534498758163
+    ],
+    "currentAcceleration": [
+      -1.275359522629378
+    ],
+    "targetPosition": [
+      1.6995274827734193
+    ],
+    "targetVelocity": [
+      1.3547996256588943
+    ],
+    "targetAcceleration": [
+      -3.7207981938590677
+    ],
+    "maxVelocity": [
+      4.779216398897328
+    ],
+    "maxAcceleration": [
+      9.423585231705967
+    ],
+    "maxJerk": [
+      11.528116093511535
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.986140857870097
+    ],
+    "currentVelocity": [
+      -4.231764764895262
+    ],
+    "currentAcceleration": [
+      2.5236179936940193
+    ],
+    "targetPosition": [
+      9.80864073728959
+    ],
+    "targetVelocity": [
+      5.170546307972568
+    ],
+    "targetAcceleration": [
+      0.2687419072243582
+    ],
+    "maxVelocity": [
+      5.6571269058667735
+    ],
+    "maxAcceleration": [
+      4.513919739159464
+    ],
+    "maxJerk": [
+      8.28323215901821
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.420202235883629
+    ],
+    "currentVelocity": [
+      1.7798521598208046
+    ],
+    "currentAcceleration": [
+      -1.1957216832468962
+    ],
+    "targetPosition": [
+      -1.4532928553084652
+    ],
+    "targetVelocity": [
+      -2.4485665139213095
+    ],
+    "targetAcceleration": [
+      -7.812844267472423
+    ],
+    "maxVelocity": [
+      4.266228006444741
+    ],
+    "maxAcceleration": [
+      8.330849073086533
+    ],
+    "maxJerk": [
+      15.49340827750776
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.1012448021751435
+    ],
+    "currentVelocity": [
+      1.8649816523104832
+    ],
+    "currentAcceleration": [
+      2.6367626192918125
+    ],
+    "targetPosition": [
+      0.8714371637572143
+    ],
+    "targetVelocity": [
+      3.1971993819252393
+    ],
+    "targetAcceleration": [
+      -0.30219545908125367
+    ],
+    "maxVelocity": [
+      5.156677579756531
+    ],
+    "maxAcceleration": [
+      3.775436344042869
+    ],
+    "maxJerk": [
+      14.50647259580096
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.120006357200566
+    ],
+    "currentVelocity": [
+      5.265894362161843
+    ],
+    "currentAcceleration": [
+      -4.222868965195145
+    ],
+    "targetPosition": [
+      -7.696002254143279
+    ],
+    "targetVelocity": [
+      -3.4481777263471804
+    ],
+    "targetAcceleration": [
+      -0.7995022802058713
+    ],
+    "maxVelocity": [
+      6.136613057955271
+    ],
+    "maxAcceleration": [
+      6.965345891336364
+    ],
+    "maxJerk": [
+      7.580055713099333
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.186595074749505
+    ],
+    "currentVelocity": [
+      5.549185724597791
+    ],
+    "currentAcceleration": [
+      0.14023555569415702
+    ],
+    "targetPosition": [
+      -5.688724243804025
+    ],
+    "targetVelocity": [
+      -0.6190504848309066
+    ],
+    "targetAcceleration": [
+      -3.484149540963655
+    ],
+    "maxVelocity": [
+      5.97725208212597
+    ],
+    "maxAcceleration": [
+      5.359264234547993
+    ],
+    "maxJerk": [
+      12.157771063253069
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.39724364540979096
+    ],
+    "currentVelocity": [
+      4.780788826156067
+    ],
+    "currentAcceleration": [
+      -6.235670583738379
+    ],
+    "targetPosition": [
+      -9.638858016947097
+    ],
+    "targetVelocity": [
+      -3.813026382298687
+    ],
+    "targetAcceleration": [
+      -5.0534480560630906
+    ],
+    "maxVelocity": [
+      6.067371331710762
+    ],
+    "maxAcceleration": [
+      9.44369064623061
+    ],
+    "maxJerk": [
+      14.296928328008153
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.041905130329795
+    ],
+    "currentVelocity": [
+      -3.714243726210292
+    ],
+    "currentAcceleration": [
+      0.271716250535178
+    ],
+    "targetPosition": [
+      -3.2250252891368802
+    ],
+    "targetVelocity": [
+      -3.5964939343657245
+    ],
+    "targetAcceleration": [
+      0.6378077631855348
+    ],
+    "maxVelocity": [
+      6.354986546933606
+    ],
+    "maxAcceleration": [
+      8.642606841704167
+    ],
+    "maxJerk": [
+      11.123131761502183
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.3272389288521644
+    ],
+    "currentVelocity": [
+      2.2011304265290548
+    ],
+    "currentAcceleration": [
+      -4.751129594617142
+    ],
+    "targetPosition": [
+      -7.117601354645943
+    ],
+    "targetVelocity": [
+      -1.8880367160410823
+    ],
+    "targetAcceleration": [
+      2.252791276368181
+    ],
+    "maxVelocity": [
+      2.6217106093935882
+    ],
+    "maxAcceleration": [
+      5.350199980102174
+    ],
+    "maxJerk": [
+      19.955474040846187
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.784263020064671
+    ],
+    "currentVelocity": [
+      -1.6857574322673685
+    ],
+    "currentAcceleration": [
+      3.279289730913156
+    ],
+    "targetPosition": [
+      7.3344071278996275
+    ],
+    "targetVelocity": [
+      -0.8258291141067924
+    ],
+    "targetAcceleration": [
+      1.5354746302193671
+    ],
+    "maxVelocity": [
+      2.0564958316313535
+    ],
+    "maxAcceleration": [
+      8.21967632904315
+    ],
+    "maxJerk": [
+      19.063607146640585
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.078884031121785
+    ],
+    "currentVelocity": [
+      1.0453476505909083
+    ],
+    "currentAcceleration": [
+      4.55131748140608
+    ],
+    "targetPosition": [
+      -5.780731947792073
+    ],
+    "targetVelocity": [
+      -0.8669784148656325
+    ],
+    "targetAcceleration": [
+      -3.771834344519904
+    ],
+    "maxVelocity": [
+      2.206383338284795
+    ],
+    "maxAcceleration": [
+      5.03104528681679
+    ],
+    "maxJerk": [
+      9.407722890459326
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.6670266075114135
+    ],
+    "currentVelocity": [
+      -5.781867148894801
+    ],
+    "currentAcceleration": [
+      0.96411284394937
+    ],
+    "targetPosition": [
+      -0.6789309743060574
+    ],
+    "targetVelocity": [
+      5.895009654658807
+    ],
+    "targetAcceleration": [
+      2.5778756030199794
+    ],
+    "maxVelocity": [
+      6.613034416411589
+    ],
+    "maxAcceleration": [
+      3.2645138279646035
+    ],
+    "maxJerk": [
+      16.186024023082524
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.408410218808221
+    ],
+    "currentVelocity": [
+      2.011305266900612
+    ],
+    "currentAcceleration": [
+      0.14567551457936556
+    ],
+    "targetPosition": [
+      6.390154109355464
+    ],
+    "targetVelocity": [
+      2.2969692876067835
+    ],
+    "targetAcceleration": [
+      -4.043526123713397
+    ],
+    "maxVelocity": [
+      5.216451215636
+    ],
+    "maxAcceleration": [
+      7.873802549967208
+    ],
+    "maxJerk": [
+      12.244173320183085
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.017677912302879
+    ],
+    "currentVelocity": [
+      0.40156387843294095
+    ],
+    "currentAcceleration": [
+      -1.6039048790402433
+    ],
+    "targetPosition": [
+      -2.2238687565789057
+    ],
+    "targetVelocity": [
+      -1.6737502306786385
+    ],
+    "targetAcceleration": [
+      -2.144652211743268
+    ],
+    "maxVelocity": [
+      4.473417619854522
+    ],
+    "maxAcceleration": [
+      6.8797132048007725
+    ],
+    "maxJerk": [
+      18.271567083190394
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.10601304929263478
+    ],
+    "currentVelocity": [
+      -4.0618136241509735
+    ],
+    "currentAcceleration": [
+      5.458580080590859
+    ],
+    "targetPosition": [
+      7.990904483632281
+    ],
+    "targetVelocity": [
+      2.1857759125490475
+    ],
+    "targetAcceleration": [
+      -0.5572954143187792
+    ],
+    "maxVelocity": [
+      5.2616447848012555
+    ],
+    "maxAcceleration": [
+      6.912223051991115
+    ],
+    "maxJerk": [
+      15.780784628871395
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6175595853767071
+    ],
+    "currentVelocity": [
+      4.8815075281828095
+    ],
+    "currentAcceleration": [
+      -0.5743357668524012
+    ],
+    "targetPosition": [
+      0.9494429212510411
+    ],
+    "targetVelocity": [
+      5.028936723865086
+    ],
+    "targetAcceleration": [
+      -2.4341500805437755
+    ],
+    "maxVelocity": [
+      7.038019546623775
+    ],
+    "maxAcceleration": [
+      3.192896641600069
+    ],
+    "maxJerk": [
+      10.932391324924696
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.7104466744186233
+    ],
+    "currentVelocity": [
+      0.5004224622199356
+    ],
+    "currentAcceleration": [
+      4.653534779643101
+    ],
+    "targetPosition": [
+      8.248349281804344
+    ],
+    "targetVelocity": [
+      1.0628036451104368
+    ],
+    "targetAcceleration": [
+      -3.490528153986995
+    ],
+    "maxVelocity": [
+      2.1622356969334593
+    ],
+    "maxAcceleration": [
+      6.036364874097101
+    ],
+    "maxJerk": [
+      12.399786591023235
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.7458395679138645
+    ],
+    "currentVelocity": [
+      0.41296381532892124
+    ],
+    "currentAcceleration": [
+      -2.2114227582018975
+    ],
+    "targetPosition": [
+      -0.971608354759681
+    ],
+    "targetVelocity": [
+      0.1501536241790955
+    ],
+    "targetAcceleration": [
+      -0.07685910936463447
+    ],
+    "maxVelocity": [
+      4.676784743654949
+    ],
+    "maxAcceleration": [
+      4.717243107321133
+    ],
+    "maxJerk": [
+      6.39173766084978
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.219934596736514
+    ],
+    "currentVelocity": [
+      -0.1877284850360521
+    ],
+    "currentAcceleration": [
+      -0.35652857039570485
+    ],
+    "targetPosition": [
+      3.048186355414124
+    ],
+    "targetVelocity": [
+      1.1356281234072707
+    ],
+    "targetAcceleration": [
+      -4.037018763753875
+    ],
+    "maxVelocity": [
+      5.572185211055636
+    ],
+    "maxAcceleration": [
+      8.973561024900325
+    ],
+    "maxJerk": [
+      8.042691308245793
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.222038423424214
+    ],
+    "currentVelocity": [
+      -4.864148215773747
+    ],
+    "currentAcceleration": [
+      3.125140137286955
+    ],
+    "targetPosition": [
+      8.266112055690094
+    ],
+    "targetVelocity": [
+      5.419253465985115
+    ],
+    "targetAcceleration": [
+      6.511122231242238
+    ],
+    "maxVelocity": [
+      6.626903660303224
+    ],
+    "maxAcceleration": [
+      9.320631209663759
+    ],
+    "maxJerk": [
+      14.2170502793415
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.95668001035245
+    ],
+    "currentVelocity": [
+      -1.2403151390698914
+    ],
+    "currentAcceleration": [
+      4.941784904173778
+    ],
+    "targetPosition": [
+      -2.894778358455441
+    ],
+    "targetVelocity": [
+      -0.4266888629420418
+    ],
+    "targetAcceleration": [
+      6.078938321837947
+    ],
+    "maxVelocity": [
+      5.979012761045472
+    ],
+    "maxAcceleration": [
+      6.695140232117298
+    ],
+    "maxJerk": [
+      6.919497705866445
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.1163974725155015
+    ],
+    "currentVelocity": [
+      2.310901905190824
+    ],
+    "currentAcceleration": [
+      -1.6699054962619906
+    ],
+    "targetPosition": [
+      3.661620721916192
+    ],
+    "targetVelocity": [
+      0.15914060748523795
+    ],
+    "targetAcceleration": [
+      2.9136823187706664
+    ],
+    "maxVelocity": [
+      3.1392253754320407
+    ],
+    "maxAcceleration": [
+      4.995359824253997
+    ],
+    "maxJerk": [
+      9.559609531015877
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.7661988065471448
+    ],
+    "currentVelocity": [
+      0.6204366843482259
+    ],
+    "currentAcceleration": [
+      1.6214186274866158
+    ],
+    "targetPosition": [
+      -5.8481672413463315
+    ],
+    "targetVelocity": [
+      -0.3572728242691454
+    ],
+    "targetAcceleration": [
+      -6.524518974887336
+    ],
+    "maxVelocity": [
+      7.943449478243071
+    ],
+    "maxAcceleration": [
+      9.434568215029637
+    ],
+    "maxJerk": [
+      15.35890283182451
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.0506760309366587
+    ],
+    "currentVelocity": [
+      1.3657860326632552
+    ],
+    "currentAcceleration": [
+      -2.553375215588194
+    ],
+    "targetPosition": [
+      -7.238735158949043
+    ],
+    "targetVelocity": [
+      -3.6117753886082027
+    ],
+    "targetAcceleration": [
+      -3.032845410540844
+    ],
+    "maxVelocity": [
+      7.011037266403216
+    ],
+    "maxAcceleration": [
+      3.51163253901899
+    ],
+    "maxJerk": [
+      6.9069249662077254
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.828713306334989
+    ],
+    "currentVelocity": [
+      -0.07934530356403346
+    ],
+    "currentAcceleration": [
+      -1.477880073008147
+    ],
+    "targetPosition": [
+      -5.774327159769241
+    ],
+    "targetVelocity": [
+      -3.609552197174395
+    ],
+    "targetAcceleration": [
+      -1.4837172512554138
+    ],
+    "maxVelocity": [
+      4.779292988528905
+    ],
+    "maxAcceleration": [
+      4.147419160786834
+    ],
+    "maxJerk": [
+      12.021619074189244
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.746498555450838
+    ],
+    "currentVelocity": [
+      -1.9273860366665327
+    ],
+    "currentAcceleration": [
+      1.3862058475809018
+    ],
+    "targetPosition": [
+      0.005692568452902336
+    ],
+    "targetVelocity": [
+      -4.096980857281747
+    ],
+    "targetAcceleration": [
+      -0.3895344128471301
+    ],
+    "maxVelocity": [
+      5.1393746739437915
+    ],
+    "maxAcceleration": [
+      4.438977611585572
+    ],
+    "maxJerk": [
+      5.627567705381018
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.889764295474992
+    ],
+    "currentVelocity": [
+      -2.883192614008116
+    ],
+    "currentAcceleration": [
+      4.140758542276107
+    ],
+    "targetPosition": [
+      2.0102226859960464
+    ],
+    "targetVelocity": [
+      -0.7644274956923462
+    ],
+    "targetAcceleration": [
+      4.394157904990513
+    ],
+    "maxVelocity": [
+      3.005586593590568
+    ],
+    "maxAcceleration": [
+      4.400410209070547
+    ],
+    "maxJerk": [
+      13.541319329385221
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.327829894610922
+    ],
+    "currentVelocity": [
+      1.9044272376178908
+    ],
+    "currentAcceleration": [
+      0.7302573109979242
+    ],
+    "targetPosition": [
+      0.6840322355515394
+    ],
+    "targetVelocity": [
+      -0.42223832395053407
+    ],
+    "targetAcceleration": [
+      2.704612507385024
+    ],
+    "maxVelocity": [
+      4.241572406705638
+    ],
+    "maxAcceleration": [
+      3.0962686501831067
+    ],
+    "maxJerk": [
+      17.30247368959689
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.908906050433355
+    ],
+    "currentVelocity": [
+      -1.3377446014704852
+    ],
+    "currentAcceleration": [
+      6.581167849327619
+    ],
+    "targetPosition": [
+      -4.941623276055431
+    ],
+    "targetVelocity": [
+      2.8264179623208774
+    ],
+    "targetAcceleration": [
+      -2.788506188376855
+    ],
+    "maxVelocity": [
+      3.417850917093607
+    ],
+    "maxAcceleration": [
+      6.7455658819873285
+    ],
+    "maxJerk": [
+      10.391853825439636
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.388028077970446
+    ],
+    "currentVelocity": [
+      -3.804563614632422
+    ],
+    "currentAcceleration": [
+      -1.6314432249371893
+    ],
+    "targetPosition": [
+      -3.8093437768375598
+    ],
+    "targetVelocity": [
+      -2.9920777710409148
+    ],
+    "targetAcceleration": [
+      -1.6591407651001626
+    ],
+    "maxVelocity": [
+      4.589673082525493
+    ],
+    "maxAcceleration": [
+      3.0232416266446647
+    ],
+    "maxJerk": [
+      5.937134407296248
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.680601451291476
+    ],
+    "currentVelocity": [
+      -0.326446865348307
+    ],
+    "currentAcceleration": [
+      -6.952553086228219
+    ],
+    "targetPosition": [
+      4.012708452328964
+    ],
+    "targetVelocity": [
+      -0.7194123172590121
+    ],
+    "targetAcceleration": [
+      -2.940253302056874
+    ],
+    "maxVelocity": [
+      2.3248369179864374
+    ],
+    "maxAcceleration": [
+      7.278457055341811
+    ],
+    "maxJerk": [
+      15.066326110505209
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.902791695580454
+    ],
+    "currentVelocity": [
+      -0.13501456977779913
+    ],
+    "currentAcceleration": [
+      0.22410591691708426
+    ],
+    "targetPosition": [
+      3.2228379741378816
+    ],
+    "targetVelocity": [
+      5.908759900482758
+    ],
+    "targetAcceleration": [
+      -2.4931781962477313
+    ],
+    "maxVelocity": [
+      6.99327039876303
+    ],
+    "maxAcceleration": [
+      9.187220662738225
+    ],
+    "maxJerk": [
+      18.665778892016295
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.073274311128655
+    ],
+    "currentVelocity": [
+      -1.4205873185953806
+    ],
+    "currentAcceleration": [
+      -1.5832008373417334
+    ],
+    "targetPosition": [
+      5.954192388014723
+    ],
+    "targetVelocity": [
+      5.2054912307720596
+    ],
+    "targetAcceleration": [
+      -0.1341054580180039
+    ],
+    "maxVelocity": [
+      6.7057339067164
+    ],
+    "maxAcceleration": [
+      4.173440487301077
+    ],
+    "maxJerk": [
+      19.490803849790915
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.119423795244858
+    ],
+    "currentVelocity": [
+      3.964909332195793
+    ],
+    "currentAcceleration": [
+      -4.380774821083612
+    ],
+    "targetPosition": [
+      -4.446251784719591
+    ],
+    "targetVelocity": [
+      -4.919116227439552
+    ],
+    "targetAcceleration": [
+      -0.5432251677636621
+    ],
+    "maxVelocity": [
+      7.014239631641065
+    ],
+    "maxAcceleration": [
+      5.49804197993782
+    ],
+    "maxJerk": [
+      17.269596102404723
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.60604589267503
+    ],
+    "currentVelocity": [
+      3.399722974596169
+    ],
+    "currentAcceleration": [
+      3.7302118731283898
+    ],
+    "targetPosition": [
+      -1.0772624012794978
+    ],
+    "targetVelocity": [
+      6.219988289259811
+    ],
+    "targetAcceleration": [
+      5.9411876083866435
+    ],
+    "maxVelocity": [
+      6.275471102621668
+    ],
+    "maxAcceleration": [
+      6.3024654043348605
+    ],
+    "maxJerk": [
+      18.012851014467806
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.2924709806416956
+    ],
+    "currentVelocity": [
+      -3.60344592847312
+    ],
+    "currentAcceleration": [
+      4.62432777641752
+    ],
+    "targetPosition": [
+      -3.968042350518102
+    ],
+    "targetVelocity": [
+      4.367863614697336
+    ],
+    "targetAcceleration": [
+      -2.1517959252395453
+    ],
+    "maxVelocity": [
+      5.757361186416089
+    ],
+    "maxAcceleration": [
+      8.776606576081472
+    ],
+    "maxJerk": [
+      7.698800423544131
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.191771916142212
+    ],
+    "currentVelocity": [
+      -1.6187044915036521
+    ],
+    "currentAcceleration": [
+      -0.7231859253949735
+    ],
+    "targetPosition": [
+      1.474840711534311
+    ],
+    "targetVelocity": [
+      0.44049853001098294
+    ],
+    "targetAcceleration": [
+      1.182299358014152
+    ],
+    "maxVelocity": [
+      2.837103619786243
+    ],
+    "maxAcceleration": [
+      3.737717790242928
+    ],
+    "maxJerk": [
+      17.366035274540224
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.064046179755362
+    ],
+    "currentVelocity": [
+      -0.9310078057007054
+    ],
+    "currentAcceleration": [
+      3.2362981105565147
+    ],
+    "targetPosition": [
+      -4.850609623633737
+    ],
+    "targetVelocity": [
+      -1.8186445218666565
+    ],
+    "targetAcceleration": [
+      -7.546305787840142
+    ],
+    "maxVelocity": [
+      7.050461317839003
+    ],
+    "maxAcceleration": [
+      9.546893724400242
+    ],
+    "maxJerk": [
+      7.520383864112677
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.338162252293122
+    ],
+    "currentVelocity": [
+      -0.37646246422981733
+    ],
+    "currentAcceleration": [
+      -5.576200933090676
+    ],
+    "targetPosition": [
+      -7.8233220772658925
+    ],
+    "targetVelocity": [
+      1.4466065649823174
+    ],
+    "targetAcceleration": [
+      -5.712339363341751
+    ],
+    "maxVelocity": [
+      2.5158804754602575
+    ],
+    "maxAcceleration": [
+      5.966928693747255
+    ],
+    "maxJerk": [
+      16.786525509683504
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.13099852170811488
+    ],
+    "currentVelocity": [
+      -2.163695711717503
+    ],
+    "currentAcceleration": [
+      3.8150747371265448
+    ],
+    "targetPosition": [
+      8.59151983059212
+    ],
+    "targetVelocity": [
+      1.5333890038998979
+    ],
+    "targetAcceleration": [
+      -0.8283863159523177
+    ],
+    "maxVelocity": [
+      2.4914491325331847
+    ],
+    "maxAcceleration": [
+      5.044892504998539
+    ],
+    "maxJerk": [
+      14.692219910339572
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.128656744207521
+    ],
+    "currentVelocity": [
+      -3.4743429815918567
+    ],
+    "currentAcceleration": [
+      1.784294248027857
+    ],
+    "targetPosition": [
+      -1.5316155076164826
+    ],
+    "targetVelocity": [
+      -2.7568578956324403
+    ],
+    "targetAcceleration": [
+      1.8377733299922
+    ],
+    "maxVelocity": [
+      6.940094251970572
+    ],
+    "maxAcceleration": [
+      5.254657711857989
+    ],
+    "maxJerk": [
+      10.137085113867329
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.719616575821764
+    ],
+    "currentVelocity": [
+      2.578098000349442
+    ],
+    "currentAcceleration": [
+      1.5696339205835077
+    ],
+    "targetPosition": [
+      4.83088504392374
+    ],
+    "targetVelocity": [
+      2.727392470305814
+    ],
+    "targetAcceleration": [
+      0.6830737075181235
+    ],
+    "maxVelocity": [
+      5.847189182413574
+    ],
+    "maxAcceleration": [
+      3.433500256320243
+    ],
+    "maxJerk": [
+      13.829758371741598
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.592486019603093
+    ],
+    "currentVelocity": [
+      5.131794711870285
+    ],
+    "currentAcceleration": [
+      -3.7904348783888544
+    ],
+    "targetPosition": [
+      9.365373241471843
+    ],
+    "targetVelocity": [
+      1.9162630973249541
+    ],
+    "targetAcceleration": [
+      6.70741195253008
+    ],
+    "maxVelocity": [
+      6.487811619431785
+    ],
+    "maxAcceleration": [
+      8.006122001756918
+    ],
+    "maxJerk": [
+      8.567090094917777
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.49060155096579194
+    ],
+    "currentVelocity": [
+      3.616876927681192
+    ],
+    "currentAcceleration": [
+      -6.568224087403149
+    ],
+    "targetPosition": [
+      -5.770942538025143
+    ],
+    "targetVelocity": [
+      3.5430397493859154
+    ],
+    "targetAcceleration": [
+      6.098132600889263
+    ],
+    "maxVelocity": [
+      6.804344042134339
+    ],
+    "maxAcceleration": [
+      8.471637401136135
+    ],
+    "maxJerk": [
+      7.6941034130558235
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.074615747365591
+    ],
+    "currentVelocity": [
+      0.7714073544877387
+    ],
+    "currentAcceleration": [
+      -4.807556760896524
+    ],
+    "targetPosition": [
+      -4.365859648850567
+    ],
+    "targetVelocity": [
+      3.1859416780227763
+    ],
+    "targetAcceleration": [
+      -1.835322141202218
+    ],
+    "maxVelocity": [
+      4.906270388599714
+    ],
+    "maxAcceleration": [
+      5.099447491938692
+    ],
+    "maxJerk": [
+      14.971235799235863
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6831486699311586
+    ],
+    "currentVelocity": [
+      -4.874038834085363
+    ],
+    "currentAcceleration": [
+      6.4429761239975125
+    ],
+    "targetPosition": [
+      8.245390619552026
+    ],
+    "targetVelocity": [
+      -5.562297202111808
+    ],
+    "targetAcceleration": [
+      1.0516589928032012
+    ],
+    "maxVelocity": [
+      6.879644635439361
+    ],
+    "maxAcceleration": [
+      6.445049273039912
+    ],
+    "maxJerk": [
+      7.847171736387739
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.118105850869112
+    ],
+    "currentVelocity": [
+      0.761339781451019
+    ],
+    "currentAcceleration": [
+      -0.707831485035177
+    ],
+    "targetPosition": [
+      8.025072040526858
+    ],
+    "targetVelocity": [
+      3.6511606734589517
+    ],
+    "targetAcceleration": [
+      3.5289760171313276
+    ],
+    "maxVelocity": [
+      5.156395677105408
+    ],
+    "maxAcceleration": [
+      8.41997489631496
+    ],
+    "maxJerk": [
+      18.66744069610469
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.649638996674614
+    ],
+    "currentVelocity": [
+      -1.1148555114253895
+    ],
+    "currentAcceleration": [
+      -5.311449927237129
+    ],
+    "targetPosition": [
+      -0.758946716915748
+    ],
+    "targetVelocity": [
+      0.4930574133673984
+    ],
+    "targetAcceleration": [
+      -2.8373525656567633
+    ],
+    "maxVelocity": [
+      4.398248659208392
+    ],
+    "maxAcceleration": [
+      6.281548284044271
+    ],
+    "maxJerk": [
+      8.470963490069439
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.121098915331416
+    ],
+    "currentVelocity": [
+      4.050338553079783
+    ],
+    "currentAcceleration": [
+      3.0931056522164386
+    ],
+    "targetPosition": [
+      1.0119073030024346
+    ],
+    "targetVelocity": [
+      4.374146135971936
+    ],
+    "targetAcceleration": [
+      5.096561492933789
+    ],
+    "maxVelocity": [
+      4.728830392781212
+    ],
+    "maxAcceleration": [
+      5.284014310737723
+    ],
+    "maxJerk": [
+      16.148549354055326
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.738347956161693
+    ],
+    "currentVelocity": [
+      -0.2831306296217049
+    ],
+    "currentAcceleration": [
+      2.785135426931328
+    ],
+    "targetPosition": [
+      5.545673269292559
+    ],
+    "targetVelocity": [
+      1.5159389869809372
+    ],
+    "targetAcceleration": [
+      -0.5257999078154478
+    ],
+    "maxVelocity": [
+      7.651878103313284
+    ],
+    "maxAcceleration": [
+      4.605062924753956
+    ],
+    "maxJerk": [
+      16.901572645863325
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.603807855335448
+    ],
+    "currentVelocity": [
+      -2.1864124276203487
+    ],
+    "currentAcceleration": [
+      -4.376719292252814
+    ],
+    "targetPosition": [
+      2.1902521136330666
+    ],
+    "targetVelocity": [
+      -2.5558782603097505
+    ],
+    "targetAcceleration": [
+      -3.5077496598475606
+    ],
+    "maxVelocity": [
+      3.937932656658573
+    ],
+    "maxAcceleration": [
+      5.569124298188158
+    ],
+    "maxJerk": [
+      16.130832069221977
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.32254842732139
+    ],
+    "currentVelocity": [
+      -3.48889393971596
+    ],
+    "currentAcceleration": [
+      -4.198365021618536
+    ],
+    "targetPosition": [
+      -6.67455654629925
+    ],
+    "targetVelocity": [
+      -1.2997320650146413
+    ],
+    "targetAcceleration": [
+      4.019876111645358
+    ],
+    "maxVelocity": [
+      5.614625374001509
+    ],
+    "maxAcceleration": [
+      5.92654776028893
+    ],
+    "maxJerk": [
+      14.921574380632848
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.491187797467838
+    ],
+    "currentVelocity": [
+      0.7196311576756522
+    ],
+    "currentAcceleration": [
+      -1.5079085137944968
+    ],
+    "targetPosition": [
+      -9.47243596516963
+    ],
+    "targetVelocity": [
+      0.8057396452847865
+    ],
+    "targetAcceleration": [
+      0.48558968351330156
+    ],
+    "maxVelocity": [
+      2.7275713470071654
+    ],
+    "maxAcceleration": [
+      3.565887468764528
+    ],
+    "maxJerk": [
+      14.42139729475621
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.559855559917263
+    ],
+    "currentVelocity": [
+      -5.618260706275335
+    ],
+    "currentAcceleration": [
+      1.4060337170158483
+    ],
+    "targetPosition": [
+      -1.7005670075309727
+    ],
+    "targetVelocity": [
+      -4.6889612742933995
+    ],
+    "targetAcceleration": [
+      2.5558956153328856
+    ],
+    "maxVelocity": [
+      5.917667943748667
+    ],
+    "maxAcceleration": [
+      3.861019411689118
+    ],
+    "maxJerk": [
+      19.46402910535308
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.818819875781198
+    ],
+    "currentVelocity": [
+      0.39415290899093947
+    ],
+    "currentAcceleration": [
+      -6.938843590346927
+    ],
+    "targetPosition": [
+      0.7867194180097172
+    ],
+    "targetVelocity": [
+      -1.7305386401514449
+    ],
+    "targetAcceleration": [
+      2.106171184937672
+    ],
+    "maxVelocity": [
+      3.0399759030119657
+    ],
+    "maxAcceleration": [
+      7.701678519466926
+    ],
+    "maxJerk": [
+      11.216985111051839
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.3064608522093106
+    ],
+    "currentVelocity": [
+      2.8199712877383005
+    ],
+    "currentAcceleration": [
+      -2.2355104443344302
+    ],
+    "targetPosition": [
+      1.6099143404743224
+    ],
+    "targetVelocity": [
+      -3.6823847121965922
+    ],
+    "targetAcceleration": [
+      0.8842184585068003
+    ],
+    "maxVelocity": [
+      4.567645627164183
+    ],
+    "maxAcceleration": [
+      7.552168252143539
+    ],
+    "maxJerk": [
+      16.49065541210508
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.329382397895699
+    ],
+    "currentVelocity": [
+      3.7033081533212755
+    ],
+    "currentAcceleration": [
+      -2.4438244549348553
+    ],
+    "targetPosition": [
+      1.0134808904125858
+    ],
+    "targetVelocity": [
+      4.253570162699122
+    ],
+    "targetAcceleration": [
+      1.2546930996758068
+    ],
+    "maxVelocity": [
+      6.450416034277502
+    ],
+    "maxAcceleration": [
+      4.248663023076616
+    ],
+    "maxJerk": [
+      18.465616254957695
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true
+    ]
+  }
+]
\ No newline at end of file
diff --git a/tests/otg/data/successful_trajectories_multi_dof.json b/tests/otg/data/successful_trajectories_multi_dof.json
new file mode 100644
index 0000000..97ea1fc
--- /dev/null
+++ b/tests/otg/data/successful_trajectories_multi_dof.json
@@ -0,0 +1,25652 @@
+[
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.339698295839515,
+      3.311254162001836
+    ],
+    "currentVelocity": [
+      4.9829995623963805,
+      5.153293607024771
+    ],
+    "currentAcceleration": [
+      -5.200468444641872,
+      -2.1821140322810457
+    ],
+    "targetPosition": [
+      1.172198186517246,
+      -9.880975899300303
+    ],
+    "targetVelocity": [
+      -1.7288954215414343,
+      -0.09830419548456604
+    ],
+    "targetAcceleration": [
+      0.0039511359032582405,
+      4.058262416177383
+    ],
+    "maxVelocity": [
+      6.000949800742288,
+      5.254325413418587
+    ],
+    "maxAcceleration": [
+      5.645271061609362,
+      6.4822019518929075
+    ],
+    "maxJerk": [
+      14.196317465811731,
+      6.7542349125386165
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.3151148125945813,
+      -9.181368075099329
+    ],
+    "currentVelocity": [
+      -1.4303351116458025,
+      -2.9574592456473545
+    ],
+    "currentAcceleration": [
+      -4.875088399877218,
+      -3.1859298132769096
+    ],
+    "targetPosition": [
+      8.776480668890343,
+      4.33912176553725
+    ],
+    "targetVelocity": [
+      2.140504825261136,
+      -3.4960557102267527
+    ],
+    "targetAcceleration": [
+      -4.836053622217638,
+      2.690741851883973
+    ],
+    "maxVelocity": [
+      3.106063582423765,
+      6.906568898243754
+    ],
+    "maxAcceleration": [
+      5.902483473408733,
+      6.03998201162054
+    ],
+    "maxJerk": [
+      17.82104355182762,
+      19.24431038873444
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.1217169693658047,
+      -0.5882420588765402
+    ],
+    "currentVelocity": [
+      -2.1032581661147765,
+      0.4049180020933374
+    ],
+    "currentAcceleration": [
+      5.690011415565559,
+      -1.7532361179224472
+    ],
+    "targetPosition": [
+      -8.433866855487032,
+      8.406083774713924
+    ],
+    "targetVelocity": [
+      0.6363855932749964,
+      -1.4910214499061814
+    ],
+    "targetAcceleration": [
+      4.859685631161863,
+      4.3505126654788615
+    ],
+    "maxVelocity": [
+      3.125681138691757,
+      2.8421299653625836
+    ],
+    "maxAcceleration": [
+      9.13967644767651,
+      8.415296410322393
+    ],
+    "maxJerk": [
+      16.80615165626609,
+      18.22410410828938
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.339136354388433,
+      -9.487437290463905
+    ],
+    "currentVelocity": [
+      -3.4191027804889087,
+      -6.812217430033552
+    ],
+    "currentAcceleration": [
+      0.014982672142765274,
+      -1.5715794645006103
+    ],
+    "targetPosition": [
+      -2.6796086881633503,
+      -6.060612955628237
+    ],
+    "targetVelocity": [
+      1.7971551474485583,
+      -5.886233786771971
+    ],
+    "targetAcceleration": [
+      -0.7102343358560708,
+      -0.08307522267037193
+    ],
+    "maxVelocity": [
+      4.054436349634485,
+      7.50378580192919
+    ],
+    "maxAcceleration": [
+      6.899195086886973,
+      3.637712875438141
+    ],
+    "maxJerk": [
+      13.034558807620318,
+      18.646601836102505
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.327808933229754,
+      5.5505781492643145
+    ],
+    "currentVelocity": [
+      0.9449214216274715,
+      1.151453011449294
+    ],
+    "currentAcceleration": [
+      -3.54342923020719,
+      -0.8967743918012103
+    ],
+    "targetPosition": [
+      3.41506490411442,
+      -6.960648538702994
+    ],
+    "targetVelocity": [
+      -0.808220662153303,
+      1.9193017630942686
+    ],
+    "targetAcceleration": [
+      -1.0975672351680732,
+      4.3171089058092615
+    ],
+    "maxVelocity": [
+      2.052827970031132,
+      2.493567164600403
+    ],
+    "maxAcceleration": [
+      9.862140421824618,
+      4.410097810153104
+    ],
+    "maxJerk": [
+      7.950951780392696,
+      5.819877223948264
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.1108378874262854,
+      -5.434843200117372
+    ],
+    "currentVelocity": [
+      -1.1756933136448362,
+      -6.010097654481785
+    ],
+    "currentAcceleration": [
+      -0.6712603148758078,
+      -1.6522099200185973
+    ],
+    "targetPosition": [
+      7.181947820037809,
+      9.30158689141334
+    ],
+    "targetVelocity": [
+      2.355521717671296,
+      3.432513978456977
+    ],
+    "targetAcceleration": [
+      -1.2087722285996563,
+      5.518653632253791
+    ],
+    "maxVelocity": [
+      3.1621266369933005,
+      7.029291282916453
+    ],
+    "maxAcceleration": [
+      3.162082809643221,
+      6.612840750122961
+    ],
+    "maxJerk": [
+      10.19962758164883,
+      13.434850443351822
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.963307475718045,
+      -1.877212863729195
+    ],
+    "currentVelocity": [
+      -5.552876941406703,
+      -3.5518925063673836
+    ],
+    "currentAcceleration": [
+      0.29314795653646986,
+      -2.6479118549776715
+    ],
+    "targetPosition": [
+      -5.669795353085531,
+      -6.688111987712412
+    ],
+    "targetVelocity": [
+      6.166772555602829,
+      -0.4819723273699399
+    ],
+    "targetAcceleration": [
+      -0.46237566125306984,
+      -2.999944939330743
+    ],
+    "maxVelocity": [
+      7.078871461051206,
+      5.071046389328823
+    ],
+    "maxAcceleration": [
+      4.700413191095686,
+      7.019287464405994
+    ],
+    "maxJerk": [
+      10.31575960076317,
+      18.58417425743327
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.8504242730542231,
+      6.649087426675152
+    ],
+    "currentVelocity": [
+      -4.9890411030592,
+      -1.7196585619659843
+    ],
+    "currentAcceleration": [
+      3.4706935492871827,
+      -3.6835022695742996
+    ],
+    "targetPosition": [
+      -4.703878456808046,
+      -4.632519332535045
+    ],
+    "targetVelocity": [
+      0.7902654077897626,
+      1.9218188748830034
+    ],
+    "targetAcceleration": [
+      0.2763096069795523,
+      5.820923498653984
+    ],
+    "maxVelocity": [
+      6.369908476898676,
+      2.36187254995664
+    ],
+    "maxAcceleration": [
+      4.538936093736617,
+      8.000641420127906
+    ],
+    "maxJerk": [
+      16.78384611026668,
+      13.235404890387207
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.271598791185758,
+      0.32894841663523344
+    ],
+    "currentVelocity": [
+      -4.075770864267978,
+      2.7559707031484066
+    ],
+    "currentAcceleration": [
+      -4.490416169065114,
+      2.0520055267597144
+    ],
+    "targetPosition": [
+      -6.8223225529378,
+      5.190986630678548
+    ],
+    "targetVelocity": [
+      2.9573202778040226,
+      0.16828842585109882
+    ],
+    "targetAcceleration": [
+      -1.8474978117217953,
+      0.9155005235789435
+    ],
+    "maxVelocity": [
+      6.384702017319565,
+      4.759752572531788
+    ],
+    "maxAcceleration": [
+      5.2469106627447335,
+      4.049258523739931
+    ],
+    "maxJerk": [
+      15.158331807194456,
+      11.220218776411764
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.747613655176368,
+      -0.2315835037770917
+    ],
+    "currentVelocity": [
+      -5.090782819293864,
+      -1.9123390142238827
+    ],
+    "currentAcceleration": [
+      -2.072926179554865,
+      -4.145560144373316
+    ],
+    "targetPosition": [
+      -9.384044773526242,
+      -9.928297319294613
+    ],
+    "targetVelocity": [
+      1.749375924760142,
+      2.665579969397811
+    ],
+    "targetAcceleration": [
+      -4.261016153860848,
+      -1.9084422854721055
+    ],
+    "maxVelocity": [
+      6.026736202153119,
+      6.81837964231393
+    ],
+    "maxAcceleration": [
+      7.098009884477952,
+      4.750665952079222
+    ],
+    "maxJerk": [
+      11.122683118265009,
+      14.458324610197982
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.887581538338651,
+      -9.603807855335448
+    ],
+    "currentVelocity": [
+      0.7024933265051052,
+      -2.1864124276203487
+    ],
+    "currentAcceleration": [
+      -6.692622898534389,
+      -4.376719292252814
+    ],
+    "targetPosition": [
+      -8.215503113529303,
+      2.1902521136330666
+    ],
+    "targetVelocity": [
+      -1.6727565827734063,
+      -2.5558782603097505
+    ],
+    "targetAcceleration": [
+      1.154641296268303,
+      -3.5077496598475606
+    ],
+    "maxVelocity": [
+      2.060540264061155,
+      3.937932656658573
+    ],
+    "maxAcceleration": [
+      7.499766380583442,
+      5.569124298188158
+    ],
+    "maxJerk": [
+      12.395143924047897,
+      16.130832069221977
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.815384734774664,
+      6.208401275354635
+    ],
+    "currentVelocity": [
+      2.6996733119094154,
+      -0.48329951843415486
+    ],
+    "currentAcceleration": [
+      2.583235929851707,
+      6.928510333627411
+    ],
+    "targetPosition": [
+      3.7324420325663805,
+      1.7165667284839614
+    ],
+    "targetVelocity": [
+      0.7956506830300789,
+      0.9236979917468138
+    ],
+    "targetAcceleration": [
+      -1.4175529382718226,
+      2.4137319215946675
+    ],
+    "maxVelocity": [
+      3.4451731475346703,
+      2.8777410723988286
+    ],
+    "maxAcceleration": [
+      6.295362676184448,
+      9.05414593273057
+    ],
+    "maxJerk": [
+      10.598658321860349,
+      8.160430333934482
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.8024811705678392,
+      6.904065551180604
+    ],
+    "currentVelocity": [
+      0.3700302217734919,
+      -2.479509398825482
+    ],
+    "currentAcceleration": [
+      0.07564653502324248,
+      -0.8887099011666035
+    ],
+    "targetPosition": [
+      -6.717322515711901,
+      -2.091336510651505
+    ],
+    "targetVelocity": [
+      -0.4788371602233692,
+      -1.0568283163364836
+    ],
+    "targetAcceleration": [
+      -2.8391848897697987,
+      3.1645305872424005
+    ],
+    "maxVelocity": [
+      6.281922566917556,
+      4.510956663716154
+    ],
+    "maxAcceleration": [
+      4.125184024965528,
+      4.757414753918617
+    ],
+    "maxJerk": [
+      19.925238653787574,
+      5.1369290920035
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.494396123680733,
+      -4.9942803124353174
+    ],
+    "currentVelocity": [
+      -1.426050494910207,
+      -3.834466122003592
+    ],
+    "currentAcceleration": [
+      -1.6897681854855513,
+      6.149703072692151
+    ],
+    "targetPosition": [
+      2.0295215159333413,
+      4.8802684362272934
+    ],
+    "targetVelocity": [
+      -4.537200231787854,
+      -2.7955643085712625
+    ],
+    "targetAcceleration": [
+      -4.476817584836236,
+      -5.094095539731286
+    ],
+    "maxVelocity": [
+      5.324236571959322,
+      4.3078081280009
+    ],
+    "maxAcceleration": [
+      9.920782267123087,
+      6.5609564113131595
+    ],
+    "maxJerk": [
+      16.180038276190345,
+      15.846737196222678
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.158471205467848,
+      7.85197575303512
+    ],
+    "currentVelocity": [
+      2.5566794218033007,
+      2.80113040083989
+    ],
+    "currentAcceleration": [
+      -3.3923478195113237,
+      2.3598179411199696
+    ],
+    "targetPosition": [
+      -7.492850007712444,
+      -9.704562496259397
+    ],
+    "targetVelocity": [
+      0.3577344662992017,
+      -6.2976037369116495
+    ],
+    "targetAcceleration": [
+      -3.4814280545387595,
+      -3.1388929202513483
+    ],
+    "maxVelocity": [
+      7.545250027875417,
+      7.841207697344677
+    ],
+    "maxAcceleration": [
+      5.963619231912489,
+      3.3746080435422967
+    ],
+    "maxJerk": [
+      13.73230272149713,
+      19.72695125553379
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.182633224453667,
+      -6.489769426314844
+    ],
+    "currentVelocity": [
+      0.60007718560664,
+      1.8167895616084073
+    ],
+    "currentAcceleration": [
+      3.111930999063582,
+      -8.824982079018081
+    ],
+    "targetPosition": [
+      -4.736698164049955,
+      -5.230004770645207
+    ],
+    "targetVelocity": [
+      1.4782117138688955,
+      0.9506747179736528
+    ],
+    "targetAcceleration": [
+      2.405374156009824,
+      8.603926272123768
+    ],
+    "maxVelocity": [
+      5.216877996763265,
+      3.0917996761405804
+    ],
+    "maxAcceleration": [
+      3.2339368841736587,
+      9.561238068090066
+    ],
+    "maxJerk": [
+      19.86931231245945,
+      13.423293134548992
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.809821435317577,
+      -4.024312535835961
+    ],
+    "currentVelocity": [
+      0.6142742512283839,
+      2.807687832752767
+    ],
+    "currentAcceleration": [
+      3.4206671834543627,
+      1.5078902123200137
+    ],
+    "targetPosition": [
+      -1.6717550499760563,
+      -9.785691594306357
+    ],
+    "targetVelocity": [
+      4.525673858875578,
+      -3.4841615766955965
+    ],
+    "targetAcceleration": [
+      -0.33756321587511184,
+      2.494265888888412
+    ],
+    "maxVelocity": [
+      7.332314433752327,
+      4.728552110330158
+    ],
+    "maxAcceleration": [
+      4.666643546125741,
+      6.596812729912573
+    ],
+    "maxJerk": [
+      5.232893975724179,
+      10.468102295197843
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.1782294026333524,
+      5.171466517174686
+    ],
+    "currentVelocity": [
+      6.628388112305412,
+      0.45940226623023594
+    ],
+    "currentAcceleration": [
+      4.221465718839735,
+      -7.6185706240953746
+    ],
+    "targetPosition": [
+      1.3396360974784258,
+      -7.698235698267604
+    ],
+    "targetVelocity": [
+      -0.2737397562222741,
+      -1.9244240825270946
+    ],
+    "targetAcceleration": [
+      4.5268450589772495,
+      2.523213127246084
+    ],
+    "maxVelocity": [
+      7.545000079598319,
+      5.282555703083902
+    ],
+    "maxAcceleration": [
+      5.773542091759401,
+      8.175397863099679
+    ],
+    "maxJerk": [
+      12.450151740911195,
+      7.632569873047119
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.87938406075782,
+      8.614544953389565
+    ],
+    "currentVelocity": [
+      -1.8544922936161323,
+      2.1718913534970503
+    ],
+    "currentAcceleration": [
+      3.598891584578545,
+      -8.385407292626567
+    ],
+    "targetPosition": [
+      3.870790946467748,
+      0.8721696495149089
+    ],
+    "targetVelocity": [
+      2.4076410848862446,
+      -0.6857794936058403
+    ],
+    "targetAcceleration": [
+      1.6914887395490017,
+      -1.95164621734967
+    ],
+    "maxVelocity": [
+      4.144031550813094,
+      2.4213732520204396
+    ],
+    "maxAcceleration": [
+      3.85958510439962,
+      8.61550082476048
+    ],
+    "maxJerk": [
+      14.533102999112282,
+      9.121489522058866
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.0517079666977267,
+      -7.344313044539817
+    ],
+    "currentVelocity": [
+      -4.790196266533079,
+      -0.9496326598985132
+    ],
+    "currentAcceleration": [
+      2.494071272160965,
+      2.520131356959136
+    ],
+    "targetPosition": [
+      3.364444775747547,
+      -2.05511876410589
+    ],
+    "targetVelocity": [
+      -0.9757760894236043,
+      -1.844740679826147
+    ],
+    "targetAcceleration": [
+      2.7710559116512394,
+      -1.3452095270122477
+    ],
+    "maxVelocity": [
+      5.74597044028577,
+      2.720643967055392
+    ],
+    "maxAcceleration": [
+      5.315531716086791,
+      3.945062856031183
+    ],
+    "maxJerk": [
+      12.793158774781393,
+      6.223042323871912
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.424756804731999,
+      4.612220082239492
+    ],
+    "currentVelocity": [
+      0.03952087482412425,
+      2.748402700242141
+    ],
+    "currentAcceleration": [
+      -2.5495065952175096,
+      0.8065431123730704
+    ],
+    "targetPosition": [
+      6.933692391795827,
+      -1.8654573552675924
+    ],
+    "targetVelocity": [
+      -0.9000886326684818,
+      -2.117776668514461
+    ],
+    "targetAcceleration": [
+      -1.2468046076833335,
+      -6.100743850310112
+    ],
+    "maxVelocity": [
+      3.1326559149682307,
+      3.601656291391203
+    ],
+    "maxAcceleration": [
+      4.771046615446632,
+      6.890671405505292
+    ],
+    "maxJerk": [
+      10.621948299319001,
+      11.727126484709494
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.3662874364292019,
+      -6.329382397895699
+    ],
+    "currentVelocity": [
+      4.436644402391878,
+      3.7033081533212755
+    ],
+    "currentAcceleration": [
+      -7.8914622817263345,
+      -2.4438244549348553
+    ],
+    "targetPosition": [
+      -1.7609322597095378,
+      1.0134808904125858
+    ],
+    "targetVelocity": [
+      5.087698639007502,
+      4.253570162699122
+    ],
+    "targetAcceleration": [
+      -0.7480503242806193,
+      1.2546930996758068
+    ],
+    "maxVelocity": [
+      6.032661517542061,
+      6.450416034277502
+    ],
+    "maxAcceleration": [
+      8.537454254761784,
+      4.248663023076616
+    ],
+    "maxJerk": [
+      11.60056605736258,
+      18.465616254957695
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.904327496321461,
+      1.5121089425833993
+    ],
+    "currentVelocity": [
+      3.5433679635028863,
+      0.5021591694171148
+    ],
+    "currentAcceleration": [
+      -3.602037129220674,
+      -0.5294114047952938
+    ],
+    "targetPosition": [
+      9.613676188960515,
+      5.78198073141804
+    ],
+    "targetVelocity": [
+      -0.6704850389635091,
+      4.098591622248986
+    ],
+    "targetAcceleration": [
+      -1.217116144403514,
+      -3.0933156506887673
+    ],
+    "maxVelocity": [
+      5.347955752195112,
+      4.916035124652368
+    ],
+    "maxAcceleration": [
+      5.397975849420245,
+      4.433026333622877
+    ],
+    "maxJerk": [
+      12.392337715658487,
+      19.912581208601914
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.00889770062613,
+      -9.950629915574169
+    ],
+    "currentVelocity": [
+      -0.388449901101269,
+      2.8343553341821863
+    ],
+    "currentAcceleration": [
+      -7.915133818222226,
+      -0.6810888435479105
+    ],
+    "targetPosition": [
+      -1.4886150092391155,
+      -5.462942622132165
+    ],
+    "targetVelocity": [
+      0.7464601975611673,
+      -0.8642225958673473
+    ],
+    "targetAcceleration": [
+      -4.005375615656398,
+      -7.471863592838734
+    ],
+    "maxVelocity": [
+      2.0874361045413607,
+      3.4726640084502067
+    ],
+    "maxAcceleration": [
+      9.756790579555958,
+      7.916326861916948
+    ],
+    "maxJerk": [
+      19.926567520875608,
+      7.358555549042412
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.7095829814112076,
+      -0.9257898484681348
+    ],
+    "currentVelocity": [
+      -4.132450920281402,
+      0.5582229934918681
+    ],
+    "currentAcceleration": [
+      1.8838209310232106,
+      -0.8216431448782666
+    ],
+    "targetPosition": [
+      1.7390131483404758,
+      -8.75331069390196
+    ],
+    "targetVelocity": [
+      1.8823334649115129,
+      -3.0157726345522406
+    ],
+    "targetAcceleration": [
+      0.4591813687810795,
+      -0.41201260805591877
+    ],
+    "maxVelocity": [
+      6.573956174188821,
+      5.1727220856592036
+    ],
+    "maxAcceleration": [
+      7.880983244740566,
+      3.088324461550913
+    ],
+    "maxJerk": [
+      12.422321347549563,
+      11.546553918636718
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.0094058637454175,
+      -6.801418360618953
+    ],
+    "currentVelocity": [
+      -2.9545558429519554,
+      0.26569654946258137
+    ],
+    "currentAcceleration": [
+      -2.8320462145259846,
+      -4.276919282659111
+    ],
+    "targetPosition": [
+      -1.862950640899001,
+      0.8168839229352223
+    ],
+    "targetVelocity": [
+      2.982426859847518,
+      5.0752125102292664
+    ],
+    "targetAcceleration": [
+      4.679778152332437,
+      -2.5346129324446887
+    ],
+    "maxVelocity": [
+      4.723539541818123,
+      5.729753087317854
+    ],
+    "maxAcceleration": [
+      9.704774259990353,
+      9.200263449863252
+    ],
+    "maxJerk": [
+      7.287076702891749,
+      9.233864100490585
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.127139905090836,
+      3.6516494879477097
+    ],
+    "currentVelocity": [
+      6.34999143161497,
+      1.8458842748391446
+    ],
+    "currentAcceleration": [
+      -3.578750731118699,
+      -2.5869892805334
+    ],
+    "targetPosition": [
+      4.454922149836666,
+      -4.483775928593998
+    ],
+    "targetVelocity": [
+      -6.4830002819047,
+      -2.238903545519854
+    ],
+    "targetAcceleration": [
+      -1.5844013002606951,
+      -8.068135422937093
+    ],
+    "maxVelocity": [
+      6.603982984576414,
+      2.348096758303948
+    ],
+    "maxAcceleration": [
+      6.010353815602437,
+      8.670363284946207
+    ],
+    "maxJerk": [
+      5.794092827164228,
+      14.152646772344047
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.689170123733102,
+      -7.104675265441371
+    ],
+    "currentVelocity": [
+      2.139718809945072,
+      -2.6107550970846605
+    ],
+    "currentAcceleration": [
+      3.8712590543266368,
+      4.509234498811809
+    ],
+    "targetPosition": [
+      7.771975217342323,
+      1.9038183889525495
+    ],
+    "targetVelocity": [
+      5.117544857095183,
+      -3.0969556820695967
+    ],
+    "targetAcceleration": [
+      -0.9763124620976589,
+      -0.4438231583775636
+    ],
+    "maxVelocity": [
+      5.59799675505095,
+      7.053612787875815
+    ],
+    "maxAcceleration": [
+      6.928361959985065,
+      6.561593642596504
+    ],
+    "maxJerk": [
+      5.712800495047806,
+      10.21856744156889
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.543455333775439,
+      -3.4479601761668306
+    ],
+    "currentVelocity": [
+      2.987211300336231,
+      -2.5722385247817243
+    ],
+    "currentAcceleration": [
+      -0.021283945367908785,
+      0.042305854621441874
+    ],
+    "targetPosition": [
+      -2.6525832299345087,
+      0.07345971939480478
+    ],
+    "targetVelocity": [
+      -6.039990247994464,
+      -1.6101276358074814
+    ],
+    "targetAcceleration": [
+      -4.612017953576386,
+      0.036196268490902295
+    ],
+    "maxVelocity": [
+      7.278697347577314,
+      2.8355611534095795
+    ],
+    "maxAcceleration": [
+      5.212931837798757,
+      3.460151677166814
+    ],
+    "maxJerk": [
+      9.31899248204516,
+      5.647568920947183
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.03668089293532972,
+      0.858514606731152
+    ],
+    "currentVelocity": [
+      -1.0970385756223378,
+      4.474801859419558
+    ],
+    "currentAcceleration": [
+      -0.8317277816334085,
+      1.4478582074657367
+    ],
+    "targetPosition": [
+      -6.774830154124327,
+      -5.3031527562417775
+    ],
+    "targetVelocity": [
+      1.661112675649301,
+      5.591054193312549
+    ],
+    "targetAcceleration": [
+      0.7676271945531798,
+      0.9341406267749126
+    ],
+    "maxVelocity": [
+      4.160511031619346,
+      7.148860528001173
+    ],
+    "maxAcceleration": [
+      8.181553850525884,
+      3.849875765797019
+    ],
+    "maxJerk": [
+      12.766050839761505,
+      12.976179226374734
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.7534119224077411,
+      -6.059765926885651
+    ],
+    "currentVelocity": [
+      3.66319963954955,
+      2.462033655950016
+    ],
+    "currentAcceleration": [
+      -1.7013709453553307,
+      0.457006511415198
+    ],
+    "targetPosition": [
+      -7.776600862492426,
+      -0.44746876808271274
+    ],
+    "targetVelocity": [
+      1.0161960299609651,
+      -1.1913570946379615
+    ],
+    "targetAcceleration": [
+      6.634995756671783,
+      2.8872577014338408
+    ],
+    "maxVelocity": [
+      4.461813883886826,
+      2.9228868039953566
+    ],
+    "maxAcceleration": [
+      7.308047997883488,
+      3.95309490721358
+    ],
+    "maxJerk": [
+      16.945899456197726,
+      13.886037351044555
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.8991569946193145,
+      6.818975387823418
+    ],
+    "currentVelocity": [
+      2.4203338011052065,
+      1.2052345391977908
+    ],
+    "currentAcceleration": [
+      2.088479613526626,
+      3.807560486355179
+    ],
+    "targetPosition": [
+      1.0689598110574963,
+      7.866653392872468
+    ],
+    "targetVelocity": [
+      -0.43997087862197004,
+      -0.15503959203818996
+    ],
+    "targetAcceleration": [
+      -3.3706280971669584,
+      3.9783126923388163
+    ],
+    "maxVelocity": [
+      4.195493012117612,
+      2.6735132722898785
+    ],
+    "maxAcceleration": [
+      3.8571714787727926,
+      4.1439633670893485
+    ],
+    "maxJerk": [
+      6.929379220042099,
+      7.7684065114682905
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.755723697827123,
+      7.738347956161693
+    ],
+    "currentVelocity": [
+      0.6085892396760384,
+      -0.2831306296217049
+    ],
+    "currentAcceleration": [
+      -8.572009593860443,
+      2.785135426931328
+    ],
+    "targetPosition": [
+      3.507695933825964,
+      5.545673269292559
+    ],
+    "targetVelocity": [
+      5.493011111946726,
+      1.5159389869809372
+    ],
+    "targetAcceleration": [
+      4.622832491845818,
+      -0.5257999078154478
+    ],
+    "maxVelocity": [
+      6.425936394100531,
+      7.651878103313284
+    ],
+    "maxAcceleration": [
+      9.790047993472971,
+      4.605062924753956
+    ],
+    "maxJerk": [
+      16.41722010959179,
+      16.901572645863325
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.233520588295219,
+      -4.377379784623354
+    ],
+    "currentVelocity": [
+      -1.2446286499584565,
+      6.15860337526273
+    ],
+    "currentAcceleration": [
+      -0.024419444403472657,
+      -0.28051030951414724
+    ],
+    "targetPosition": [
+      1.5536431636519197,
+      1.1024610033215012
+    ],
+    "targetVelocity": [
+      -3.0780166253418404,
+      -3.6537486299552024
+    ],
+    "targetAcceleration": [
+      -3.1761500585338847,
+      -3.8189573733855946
+    ],
+    "maxVelocity": [
+      4.026953396923467,
+      6.23850738982414
+    ],
+    "maxAcceleration": [
+      3.3389963388378967,
+      5.168752488553106
+    ],
+    "maxJerk": [
+      17.34844598059142,
+      9.951293837836866
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.118105850869112,
+      -4.591822635039939
+    ],
+    "currentVelocity": [
+      0.761339781451019,
+      1.1223631534219942
+    ],
+    "currentAcceleration": [
+      -0.707831485035177,
+      2.4926141280709766
+    ],
+    "targetPosition": [
+      8.025072040526858,
+      -2.9920477569415604
+    ],
+    "targetVelocity": [
+      3.6511606734589517,
+      1.905000222294169
+    ],
+    "targetAcceleration": [
+      3.5289760171313276,
+      2.5699593733073938
+    ],
+    "maxVelocity": [
+      5.156395677105408,
+      5.368281618715594
+    ],
+    "maxAcceleration": [
+      8.41997489631496,
+      4.624208650604588
+    ],
+    "maxJerk": [
+      18.66744069610469,
+      15.712657746344677
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.348434556187438,
+      2.0107696554859977
+    ],
+    "currentVelocity": [
+      -1.489220179228016,
+      4.059275514663953
+    ],
+    "currentAcceleration": [
+      0.916939635853284,
+      0.4199158599816517
+    ],
+    "targetPosition": [
+      5.408031364366741,
+      9.702986805445086
+    ],
+    "targetVelocity": [
+      5.1627096229729785,
+      2.84561160961698
+    ],
+    "targetAcceleration": [
+      -2.617735432332341,
+      -1.7564158045458873
+    ],
+    "maxVelocity": [
+      5.570740593907353,
+      5.552451379220158
+    ],
+    "maxAcceleration": [
+      9.183554447768355,
+      6.8474002065943775
+    ],
+    "maxJerk": [
+      16.300095103480498,
+      10.946365990504145
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.171062428926161,
+      -6.5843077214543255
+    ],
+    "currentVelocity": [
+      -2.54883832526486,
+      -4.013466877174865
+    ],
+    "currentAcceleration": [
+      4.223655688686115,
+      -2.560819096956986
+    ],
+    "targetPosition": [
+      -4.999470061165288,
+      3.745595127490615
+    ],
+    "targetVelocity": [
+      -0.8638345345905325,
+      -3.3697486545409148
+    ],
+    "targetAcceleration": [
+      0.31919550747458825,
+      -0.233188912664819
+    ],
+    "maxVelocity": [
+      2.651743285693673,
+      6.56000708524101
+    ],
+    "maxAcceleration": [
+      5.018071835467671,
+      3.2466943157737704
+    ],
+    "maxJerk": [
+      13.072806559066033,
+      16.187741524348617
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.714509713412069,
+      -8.217853134225862
+    ],
+    "currentVelocity": [
+      3.3824455837772858,
+      2.222305704462896
+    ],
+    "currentAcceleration": [
+      -6.91938991077363,
+      -7.120802550818348
+    ],
+    "targetPosition": [
+      -7.622839976321596,
+      -1.2030461153478367
+    ],
+    "targetVelocity": [
+      5.304099435522551,
+      -1.282936431374927
+    ],
+    "targetAcceleration": [
+      -0.32358900698865956,
+      -0.4034761504065951
+    ],
+    "maxVelocity": [
+      6.36608282596849,
+      3.1813706856047985
+    ],
+    "maxAcceleration": [
+      7.311801782325062,
+      9.430077466780318
+    ],
+    "maxJerk": [
+      8.169966685129355,
+      10.924119110950237
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.3366097032676905,
+      3.998460024146432
+    ],
+    "currentVelocity": [
+      3.87673020495299,
+      -1.7674124195951455
+    ],
+    "currentAcceleration": [
+      -3.3809495322037177,
+      0.9896488079317525
+    ],
+    "targetPosition": [
+      3.725672836105593,
+      -4.486458224886145
+    ],
+    "targetVelocity": [
+      1.916166276260837,
+      -0.7055589856622024
+    ],
+    "targetAcceleration": [
+      3.244899249297534,
+      6.688373008935153
+    ],
+    "maxVelocity": [
+      7.0658335326158195,
+      7.740419459143178
+    ],
+    "maxAcceleration": [
+      8.933332637536012,
+      7.703037280820414
+    ],
+    "maxJerk": [
+      18.566910222209117,
+      6.460229629634188
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.016143777495752,
+      2.1274957466692292
+    ],
+    "currentVelocity": [
+      3.8611750097024817,
+      2.624262903124592
+    ],
+    "currentAcceleration": [
+      -0.48917921772589956,
+      -8.240912923043961
+    ],
+    "targetPosition": [
+      8.08629304061466,
+      0.20991474591609993
+    ],
+    "targetVelocity": [
+      4.134460760476463,
+      -0.3509301259546822
+    ],
+    "targetAcceleration": [
+      3.779582678070412,
+      3.367208313649096
+    ],
+    "maxVelocity": [
+      4.996171002942129,
+      3.006469297709306
+    ],
+    "maxAcceleration": [
+      8.796446386055424,
+      8.506966808657635
+    ],
+    "maxJerk": [
+      19.133407609522873,
+      18.344395336017758
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.2574150620538127,
+      -1.48539005047658
+    ],
+    "currentVelocity": [
+      -2.9766355959836357,
+      1.3219089848708792
+    ],
+    "currentAcceleration": [
+      1.757702116706386,
+      -0.3911096153981264
+    ],
+    "targetPosition": [
+      -7.33059654811175,
+      8.137521185474547
+    ],
+    "targetVelocity": [
+      3.78328716899712,
+      2.281690428641301
+    ],
+    "targetAcceleration": [
+      2.9349623105894924,
+      -1.3889858386519487
+    ],
+    "maxVelocity": [
+      5.131069208886197,
+      3.8924310382667815
+    ],
+    "maxAcceleration": [
+      3.9454385000188097,
+      4.63265766887638
+    ],
+    "maxJerk": [
+      12.311847254879234,
+      16.34570942034997
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.6202597912719607,
+      -7.362212702859992
+    ],
+    "currentVelocity": [
+      -2.1009428366412237,
+      0.31732562377240825
+    ],
+    "currentAcceleration": [
+      2.96390736270574,
+      4.818496013811685
+    ],
+    "targetPosition": [
+      -0.4732981960295142,
+      5.065107785069717
+    ],
+    "targetVelocity": [
+      -1.4296649246465427,
+      1.9712213825019171
+    ],
+    "targetAcceleration": [
+      1.9560003336018488,
+      -6.780813436981727
+    ],
+    "maxVelocity": [
+      2.948805061870778,
+      3.9127260390342915
+    ],
+    "maxAcceleration": [
+      5.192681658508404,
+      7.0726111522047725
+    ],
+    "maxJerk": [
+      14.116584455414069,
+      17.492362723827735
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.3343887468231497,
+      0.8114403184603187
+    ],
+    "currentVelocity": [
+      -1.1579431278979913,
+      -2.6479061668959782
+    ],
+    "currentAcceleration": [
+      3.5099786244591193,
+      2.553033503134122
+    ],
+    "targetPosition": [
+      8.613932538655614,
+      -1.5518487065417155
+    ],
+    "targetVelocity": [
+      -1.768366320566162,
+      -1.483628824376738
+    ],
+    "targetAcceleration": [
+      1.6032979809385637,
+      0.25446256783745014
+    ],
+    "maxVelocity": [
+      5.228926508214162,
+      5.797676792001423
+    ],
+    "maxAcceleration": [
+      6.774268522618836,
+      8.819908413292765
+    ],
+    "maxJerk": [
+      7.980235500445183,
+      11.396780831569007
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.221037470187955,
+      -5.073776666504877
+    ],
+    "currentVelocity": [
+      -3.5640648026007478,
+      5.239953771585489
+    ],
+    "currentAcceleration": [
+      -0.5571209817747409,
+      2.530486914624856
+    ],
+    "targetPosition": [
+      -1.9899005193073656,
+      -7.0135599838824465
+    ],
+    "targetVelocity": [
+      -3.9834043000607235,
+      4.230550592980723
+    ],
+    "targetAcceleration": [
+      -4.948750118395609,
+      3.5140086787143345
+    ],
+    "maxVelocity": [
+      6.125219663511198,
+      7.766836507550726
+    ],
+    "maxAcceleration": [
+      6.986514391518595,
+      3.942063662150464
+    ],
+    "maxJerk": [
+      19.051579421474006,
+      18.904387207772753
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.319879656592548,
+      4.526702465697554
+    ],
+    "currentVelocity": [
+      -1.8105529370392652,
+      -5.824609523412894
+    ],
+    "currentAcceleration": [
+      4.70775726891151,
+      9.045091819797241
+    ],
+    "targetPosition": [
+      -0.5681973501430164,
+      -3.4960791526602293
+    ],
+    "targetVelocity": [
+      -3.8356997294637583,
+      -6.805299625402047
+    ],
+    "targetAcceleration": [
+      0.5639554913651192,
+      -1.5305712924373553
+    ],
+    "maxVelocity": [
+      7.402129198404133,
+      7.55571585606618
+    ],
+    "maxAcceleration": [
+      7.371334565167319,
+      9.14755447010443
+    ],
+    "maxJerk": [
+      18.05091087321956,
+      5.116968522045797
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.164448323278097,
+      -9.755762932872846
+    ],
+    "currentVelocity": [
+      -2.6867018331084607,
+      3.899204480278697
+    ],
+    "currentAcceleration": [
+      3.361121867899925,
+      -2.225903980230393
+    ],
+    "targetPosition": [
+      2.905489570329463,
+      -4.629415826885275
+    ],
+    "targetVelocity": [
+      -2.5989984350539155,
+      0.971482083563135
+    ],
+    "targetAcceleration": [
+      4.386037229258578,
+      -0.14216167156626947
+    ],
+    "maxVelocity": [
+      4.280157636927057,
+      3.9348571669822148
+    ],
+    "maxAcceleration": [
+      8.352570175198355,
+      3.5183297837570713
+    ],
+    "maxJerk": [
+      15.039117726647252,
+      13.751465262754449
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.7344362456350773,
+      -4.3997609551616375
+    ],
+    "currentVelocity": [
+      4.348654257882651,
+      0.7971957683255386
+    ],
+    "currentAcceleration": [
+      1.9428130173090903,
+      2.2998217542908765
+    ],
+    "targetPosition": [
+      3.3687120408221833,
+      7.4703627688423495
+    ],
+    "targetVelocity": [
+      -0.047377965741373984,
+      1.2555197625103247
+    ],
+    "targetAcceleration": [
+      3.0431117131392096,
+      -2.367960242650047
+    ],
+    "maxVelocity": [
+      4.5929721508426615,
+      2.012849516053434
+    ],
+    "maxAcceleration": [
+      8.378109292111938,
+      7.6346016591465915
+    ],
+    "maxJerk": [
+      18.08863568929123,
+      16.746327364142346
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.1163974725155015,
+      -7.125111607694659
+    ],
+    "currentVelocity": [
+      2.310901905190824,
+      5.31135505961041
+    ],
+    "currentAcceleration": [
+      -1.6699054962619906,
+      -0.540761042368517
+    ],
+    "targetPosition": [
+      3.661620721916192,
+      -4.811089647842353
+    ],
+    "targetVelocity": [
+      0.15914060748523795,
+      5.072801616902909
+    ],
+    "targetAcceleration": [
+      2.9136823187706664,
+      0.7509366069397081
+    ],
+    "maxVelocity": [
+      3.1392253754320407,
+      7.337112237818491
+    ],
+    "maxAcceleration": [
+      4.995359824253997,
+      3.5275721986259456
+    ],
+    "maxJerk": [
+      9.559609531015877,
+      11.19506351834631
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6614879352125627,
+      -2.7109700244790202
+    ],
+    "currentVelocity": [
+      0.3184735283360771,
+      -1.9450861712616916
+    ],
+    "currentAcceleration": [
+      4.485333692593267,
+      1.8309475376426327
+    ],
+    "targetPosition": [
+      1.432766781389926,
+      -3.0347275418832993
+    ],
+    "targetVelocity": [
+      0.9380704503065131,
+      -1.3436837183305115
+    ],
+    "targetAcceleration": [
+      1.2348595862756806,
+      -3.1700217828229698
+    ],
+    "maxVelocity": [
+      3.4033679984524254,
+      3.53261564773905
+    ],
+    "maxAcceleration": [
+      6.912093133516857,
+      5.318109099145518
+    ],
+    "maxJerk": [
+      11.59049044684104,
+      11.240844105005763
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.077221261413431,
+      7.670667093697979
+    ],
+    "currentVelocity": [
+      -1.1473336545548207,
+      -0.24336476507762939
+    ],
+    "currentAcceleration": [
+      3.2212185422124735,
+      -3.012960009867646
+    ],
+    "targetPosition": [
+      6.527094700155718,
+      1.1220667962387054
+    ],
+    "targetVelocity": [
+      0.8756646266658574,
+      -0.643563442216867
+    ],
+    "targetAcceleration": [
+      -7.279428101857604,
+      -4.128938528881824
+    ],
+    "maxVelocity": [
+      6.487369283316771,
+      5.44472655945329
+    ],
+    "maxAcceleration": [
+      7.813910266187983,
+      9.579725274853715
+    ],
+    "maxJerk": [
+      11.59458614434201,
+      11.138914920150716
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.0212763127276965,
+      9.813965652075225
+    ],
+    "currentVelocity": [
+      -1.429465258044001,
+      -3.0658784075329946
+    ],
+    "currentAcceleration": [
+      -0.13004392383856,
+      3.632830916480291
+    ],
+    "targetPosition": [
+      5.8146081896085295,
+      -8.319663908610735
+    ],
+    "targetVelocity": [
+      2.917513519535693,
+      2.291436330458021
+    ],
+    "targetAcceleration": [
+      4.323329845168978,
+      -7.0870978784940775
+    ],
+    "maxVelocity": [
+      3.191143692725081,
+      7.088532386447206
+    ],
+    "maxAcceleration": [
+      8.313752965464461,
+      9.72616538230937
+    ],
+    "maxJerk": [
+      11.283436247588192,
+      14.050984777609841
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.001756027262974,
+      -9.813806156022274
+    ],
+    "currentVelocity": [
+      2.1356070262719813,
+      -0.021971619203639214
+    ],
+    "currentAcceleration": [
+      0.21648646808063532,
+      6.18164565795791
+    ],
+    "targetPosition": [
+      8.813542661042291,
+      8.606167432634393
+    ],
+    "targetVelocity": [
+      -3.458589225251854,
+      0.26716333324883124
+    ],
+    "targetAcceleration": [
+      -0.9977984776646762,
+      3.47929617654731
+    ],
+    "maxVelocity": [
+      4.317220142957623,
+      6.91229896306007
+    ],
+    "maxAcceleration": [
+      3.1973497067366474,
+      6.290113807863079
+    ],
+    "maxJerk": [
+      16.099166257063352,
+      16.135038254270867
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.738516571317401,
+      2.05176253058605
+    ],
+    "currentVelocity": [
+      1.4261509386616167,
+      4.5933150520854635
+    ],
+    "currentAcceleration": [
+      -3.4357625594494854,
+      3.492163312156131
+    ],
+    "targetPosition": [
+      -8.078128883703643,
+      -6.032420461962904
+    ],
+    "targetVelocity": [
+      1.0607774165176354,
+      -0.9117295879503509
+    ],
+    "targetAcceleration": [
+      -0.3469839211184871,
+      4.4287717751894915
+    ],
+    "maxVelocity": [
+      2.623371355804438,
+      5.347432179860158
+    ],
+    "maxAcceleration": [
+      4.639180525322342,
+      5.24922250198651
+    ],
+    "maxJerk": [
+      12.603947136185816,
+      13.156270376246175
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.503547445161528,
+      8.350096116784478
+    ],
+    "currentVelocity": [
+      2.8916997480473663,
+      -3.5295153397019163
+    ],
+    "currentAcceleration": [
+      1.1508767736848577,
+      5.4524485187748315
+    ],
+    "targetPosition": [
+      2.843641748161499,
+      9.054259020693593
+    ],
+    "targetVelocity": [
+      -2.036046299115231,
+      3.2093445912901153
+    ],
+    "targetAcceleration": [
+      -5.5175293925157805,
+      -4.51597347427223
+    ],
+    "maxVelocity": [
+      6.062462176929649,
+      7.166034462830149
+    ],
+    "maxAcceleration": [
+      6.387096079019634,
+      8.213179272608286
+    ],
+    "maxJerk": [
+      8.984227350098433,
+      5.19800009906018
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.043997976284291,
+      8.75377734642127
+    ],
+    "currentVelocity": [
+      4.203102142468347,
+      -1.5292472866984799
+    ],
+    "currentAcceleration": [
+      -7.5731564155194935,
+      -3.730852002188783
+    ],
+    "targetPosition": [
+      2.180542931532635,
+      7.723894156062883
+    ],
+    "targetVelocity": [
+      0.7533451948323551,
+      1.0352786310414013
+    ],
+    "targetAcceleration": [
+      -3.062377290411333,
+      -4.293716951397981
+    ],
+    "maxVelocity": [
+      5.673862750953238,
+      4.0158530685181635
+    ],
+    "maxAcceleration": [
+      7.690790287976114,
+      7.8801236361003
+    ],
+    "maxJerk": [
+      9.283347918811646,
+      18.719054039578438
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.2487212800423606,
+      4.0730201348198865
+    ],
+    "currentVelocity": [
+      -2.095519671484536,
+      3.5468196803960783
+    ],
+    "currentAcceleration": [
+      0.2887227869848088,
+      -3.072663650731063
+    ],
+    "targetPosition": [
+      -3.230442486606835,
+      7.284124614037456
+    ],
+    "targetVelocity": [
+      -5.179291751215883,
+      -3.171888149947334
+    ],
+    "targetAcceleration": [
+      6.885459535561445,
+      4.044374554962667
+    ],
+    "maxVelocity": [
+      7.719578066257892,
+      3.947829526028764
+    ],
+    "maxAcceleration": [
+      7.475838309070099,
+      4.491037488477156
+    ],
+    "maxJerk": [
+      19.104618365863196,
+      19.000979848076778
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.195520794749932,
+      9.122747585590297
+    ],
+    "currentVelocity": [
+      -3.8228778293242534,
+      -2.9833219132315696
+    ],
+    "currentAcceleration": [
+      -5.958462048157928,
+      1.5271973381386728
+    ],
+    "targetPosition": [
+      -0.13796410613246657,
+      4.921543805630195
+    ],
+    "targetVelocity": [
+      0.10377356962116924,
+      -3.185204264498508
+    ],
+    "targetAcceleration": [
+      -0.7000923579166001,
+      -4.888872906496951
+    ],
+    "maxVelocity": [
+      5.518057233525729,
+      7.319471913184212
+    ],
+    "maxAcceleration": [
+      6.2618643699247,
+      6.960305181370448
+    ],
+    "maxJerk": [
+      17.619889459711104,
+      12.25165724086887
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.522975758957475,
+      -9.371345198866589
+    ],
+    "currentVelocity": [
+      2.3526265661637202,
+      0.5262959905995022
+    ],
+    "currentAcceleration": [
+      1.1098555781840425,
+      4.447911994654833
+    ],
+    "targetPosition": [
+      3.4190922723934474,
+      -8.762121960567729
+    ],
+    "targetVelocity": [
+      3.6304518407836692,
+      -2.4649047581138954
+    ],
+    "targetAcceleration": [
+      4.743729376102181,
+      -2.3163155446167756
+    ],
+    "maxVelocity": [
+      5.029386244727519,
+      6.393028224620358
+    ],
+    "maxAcceleration": [
+      4.999965300332839,
+      5.950737920602965
+    ],
+    "maxJerk": [
+      15.467653340465734,
+      12.908267760231048
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.632159416992085,
+      -5.451910224895329
+    ],
+    "currentVelocity": [
+      -2.3932512006635256,
+      -0.7023770662447721
+    ],
+    "currentAcceleration": [
+      3.3582513084287733,
+      -3.5183349923771283
+    ],
+    "targetPosition": [
+      9.461204109804655,
+      -3.6996701538696115
+    ],
+    "targetVelocity": [
+      3.461688991704656,
+      0.20355337738769919
+    ],
+    "targetAcceleration": [
+      -2.538481969810654,
+      5.913187056611648
+    ],
+    "maxVelocity": [
+      5.429041726330287,
+      2.8640522176307
+    ],
+    "maxAcceleration": [
+      4.273358884715426,
+      9.109074123870574
+    ],
+    "maxJerk": [
+      8.210928039081995,
+      13.91269073561425
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.002449124881922,
+      7.59387353511169
+    ],
+    "currentVelocity": [
+      -4.035676852484208,
+      0.6448356004364646
+    ],
+    "currentAcceleration": [
+      -5.122549607957124,
+      0.14984224880894104
+    ],
+    "targetPosition": [
+      2.029659132538848,
+      -1.1818973180884544
+    ],
+    "targetVelocity": [
+      -3.29513484278709,
+      3.3281206313559855
+    ],
+    "targetAcceleration": [
+      4.162021828090099,
+      5.24471715060135
+    ],
+    "maxVelocity": [
+      5.232752122470632,
+      3.6003034605500224
+    ],
+    "maxAcceleration": [
+      6.266388125760603,
+      9.63150828057319
+    ],
+    "maxJerk": [
+      13.053847004009276,
+      6.0206115228872505
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.6180496164965952,
+      2.2944994563352594
+    ],
+    "currentVelocity": [
+      -2.143519197006169,
+      -2.458708285023529
+    ],
+    "currentAcceleration": [
+      -0.6377961044427014,
+      -3.7769279998343226
+    ],
+    "targetPosition": [
+      -6.318567629165084,
+      -6.7359635422721365
+    ],
+    "targetVelocity": [
+      -6.187908604728309,
+      0.36524495679242364
+    ],
+    "targetAcceleration": [
+      -0.252492924066146,
+      -4.879037663064994
+    ],
+    "maxVelocity": [
+      6.523666333740735,
+      3.7033255667614
+    ],
+    "maxAcceleration": [
+      3.6893141741964866,
+      8.59556314435911
+    ],
+    "maxJerk": [
+      13.216432993284357,
+      10.68907843801523
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.69690599261126,
+      -5.932055868620669
+    ],
+    "currentVelocity": [
+      -3.022425854284905,
+      2.0018334350156595
+    ],
+    "currentAcceleration": [
+      -1.3406610017922476,
+      4.370293847583801
+    ],
+    "targetPosition": [
+      6.618687307196545,
+      0.025000922130972825
+    ],
+    "targetVelocity": [
+      0.09439570050458457,
+      1.2044270666650876
+    ],
+    "targetAcceleration": [
+      -0.5392109055311978,
+      1.418842826015318
+    ],
+    "maxVelocity": [
+      4.269287394119607,
+      5.124091420799875
+    ],
+    "maxAcceleration": [
+      3.6015743961756312,
+      5.300955947540091
+    ],
+    "maxJerk": [
+      17.769475361378824,
+      16.22071546987781
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.819142878618936,
+      -1.222589481264663
+    ],
+    "currentVelocity": [
+      -1.3868263985408893,
+      -4.1752750107559855
+    ],
+    "currentAcceleration": [
+      -3.0488131470699136,
+      1.7735255080288628
+    ],
+    "targetPosition": [
+      -0.07839499816282469,
+      4.141286085548092
+    ],
+    "targetVelocity": [
+      -0.36158666584473,
+      -1.5269096425052346
+    ],
+    "targetAcceleration": [
+      -1.9157379595038484,
+      -2.3537808191385334
+    ],
+    "maxVelocity": [
+      3.8543470105587248,
+      7.088621217893617
+    ],
+    "maxAcceleration": [
+      5.636218444740115,
+      8.848522758216355
+    ],
+    "maxJerk": [
+      7.889070210286783,
+      6.7076532849157555
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.12255628836934207,
+      -7.219895824602462
+    ],
+    "currentVelocity": [
+      4.359532814805794,
+      1.595140063754616
+    ],
+    "currentAcceleration": [
+      1.6259470677999621,
+      -5.541310135066427
+    ],
+    "targetPosition": [
+      -1.6506405914745237,
+      -8.58731591288932
+    ],
+    "targetVelocity": [
+      2.467238982646636,
+      1.488316868469461
+    ],
+    "targetAcceleration": [
+      -1.9482728140972767,
+      -1.3528271279429926
+    ],
+    "maxVelocity": [
+      5.5979811375824795,
+      2.1221829213913526
+    ],
+    "maxAcceleration": [
+      3.087405109551235,
+      8.857096036994438
+    ],
+    "maxJerk": [
+      14.214992784725517,
+      14.348562071383594
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.42975955505144725,
+      5.7880758274397355
+    ],
+    "currentVelocity": [
+      1.2424739290810183,
+      -3.0706733142316915
+    ],
+    "currentAcceleration": [
+      -0.10627042548190158,
+      -4.9615534975193505
+    ],
+    "targetPosition": [
+      0.001002197956463391,
+      0.6976165970378112
+    ],
+    "targetVelocity": [
+      2.2640728138154693,
+      -4.889183053464729
+    ],
+    "targetAcceleration": [
+      -0.4184778340122226,
+      -2.4348253993970577
+    ],
+    "maxVelocity": [
+      3.1697806754497164,
+      4.965159358080063
+    ],
+    "maxAcceleration": [
+      3.8676401050488973,
+      7.974410695681795
+    ],
+    "maxJerk": [
+      13.835116070087096,
+      12.025716394445457
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.025809911070802,
+      -4.187091823171993
+    ],
+    "currentVelocity": [
+      -2.553246483736223,
+      1.1151382214386398
+    ],
+    "currentAcceleration": [
+      -2.6283258977768087,
+      4.898214850881252
+    ],
+    "targetPosition": [
+      -6.063502319970045,
+      -5.337161615850265
+    ],
+    "targetVelocity": [
+      1.43260519393211,
+      -1.1789563194258297
+    ],
+    "targetAcceleration": [
+      -1.849657415274324,
+      1.2284465240924343
+    ],
+    "maxVelocity": [
+      4.463825573307435,
+      4.352964369315609
+    ],
+    "maxAcceleration": [
+      9.98748017161454,
+      6.90716871095212
+    ],
+    "maxJerk": [
+      13.70429817145817,
+      17.280044546962436
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.4673319101053437,
+      -8.058527487401417
+    ],
+    "currentVelocity": [
+      4.667700437640027,
+      0.5079779775756128
+    ],
+    "currentAcceleration": [
+      -5.330187931114482,
+      -4.584863072436794
+    ],
+    "targetPosition": [
+      7.2009135762033125,
+      5.952908176720824
+    ],
+    "targetVelocity": [
+      6.22158551219578,
+      -1.3245363421780167
+    ],
+    "targetAcceleration": [
+      2.4956608346681524,
+      0.839328963251389
+    ],
+    "maxVelocity": [
+      6.7574904088955865,
+      3.6371338226727303
+    ],
+    "maxAcceleration": [
+      7.530870730208255,
+      6.221400850565077
+    ],
+    "maxJerk": [
+      16.546466502126478,
+      13.097380427996233
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.6120181203187567,
+      -9.732780825306271
+    ],
+    "currentVelocity": [
+      -5.550570289647071,
+      5.6015683482504395
+    ],
+    "currentAcceleration": [
+      4.641056446573167,
+      -0.06304532367588411
+    ],
+    "targetPosition": [
+      0.9784501866504556,
+      8.070566953341537
+    ],
+    "targetVelocity": [
+      2.1006793505845147,
+      -4.5324119454128216
+    ],
+    "targetAcceleration": [
+      -2.0762093671265403,
+      -2.0618889129936644
+    ],
+    "maxVelocity": [
+      6.949275091636712,
+      6.43190610869184
+    ],
+    "maxAcceleration": [
+      5.6595315283170535,
+      3.383971786349779
+    ],
+    "maxJerk": [
+      15.878475919656884,
+      15.63506674783334
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.3501513457807643,
+      -1.0674657029080503
+    ],
+    "currentVelocity": [
+      1.443936602337896,
+      3.5806544224473056
+    ],
+    "currentAcceleration": [
+      2.3262180825224057,
+      -8.37698399059665
+    ],
+    "targetPosition": [
+      4.629741830328808,
+      -6.180450796448871
+    ],
+    "targetVelocity": [
+      0.7053659450953229,
+      7.5990880277602395
+    ],
+    "targetAcceleration": [
+      -1.9030182030592475,
+      1.6090547187120183
+    ],
+    "maxVelocity": [
+      3.2397642715018735,
+      7.826506404195022
+    ],
+    "maxAcceleration": [
+      3.0762693683253213,
+      9.143213457345336
+    ],
+    "maxJerk": [
+      13.908379444304906,
+      17.48444098969039
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.8744523464670007,
+      9.131620825777542
+    ],
+    "currentVelocity": [
+      5.116924263745067,
+      4.6944923360523685
+    ],
+    "currentAcceleration": [
+      0.6467441851794287,
+      -1.6707207365058627
+    ],
+    "targetPosition": [
+      -8.427205620371037,
+      -6.325542306118042
+    ],
+    "targetVelocity": [
+      -0.2678360929224848,
+      4.607726017829529
+    ],
+    "targetAcceleration": [
+      -1.9380939333510907,
+      4.71753897177309
+    ],
+    "maxVelocity": [
+      5.976320665244002,
+      6.917322559101095
+    ],
+    "maxAcceleration": [
+      3.7544292544653293,
+      7.189122375244702
+    ],
+    "maxJerk": [
+      17.995339588253618,
+      9.961084053580525
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.175893086690636,
+      0.43363228685865884
+    ],
+    "currentVelocity": [
+      -1.6099638018396418,
+      2.499006152518866
+    ],
+    "currentAcceleration": [
+      3.1222394373580658,
+      -1.580735955340148
+    ],
+    "targetPosition": [
+      6.733117177709971,
+      9.37719580357522
+    ],
+    "targetVelocity": [
+      -0.7671915731860133,
+      -2.9569713915327513
+    ],
+    "targetAcceleration": [
+      1.026289595299982,
+      -0.8910336642253309
+    ],
+    "maxVelocity": [
+      2.5333949880886406,
+      3.9859048926210394
+    ],
+    "maxAcceleration": [
+      4.169818980351039,
+      5.695197974649565
+    ],
+    "maxJerk": [
+      6.993350901765378,
+      11.640339877450739
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.035337057758547,
+      0.9766406926423272
+    ],
+    "currentVelocity": [
+      -0.3649360461473652,
+      0.5003380496414209
+    ],
+    "currentAcceleration": [
+      -3.6107420840239595,
+      -5.67092245425503
+    ],
+    "targetPosition": [
+      -5.794367600329924,
+      -0.06410998813898416
+    ],
+    "targetVelocity": [
+      2.598674322788901,
+      4.07690891679899
+    ],
+    "targetAcceleration": [
+      1.9491430438641428,
+      3.791737017516853
+    ],
+    "maxVelocity": [
+      3.7273694767870658,
+      6.733888652712304
+    ],
+    "maxAcceleration": [
+      3.8307439535948804,
+      9.672042477591091
+    ],
+    "maxJerk": [
+      8.108418370204811,
+      18.900552391763622
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.929020109346629,
+      -4.3447525018226685
+    ],
+    "currentVelocity": [
+      3.904741109343907,
+      -5.809566695559364
+    ],
+    "currentAcceleration": [
+      1.0827080090548264,
+      -1.746332443001417
+    ],
+    "targetPosition": [
+      -1.4620462188399141,
+      -6.876719261152811
+    ],
+    "targetVelocity": [
+      0.9603468503966699,
+      0.4689648343973012
+    ],
+    "targetAcceleration": [
+      -0.676379521648447,
+      -0.5619292172057397
+    ],
+    "maxVelocity": [
+      4.092582786286295,
+      6.466361255544058
+    ],
+    "maxAcceleration": [
+      4.193414380622032,
+      3.4308000709987305
+    ],
+    "maxJerk": [
+      8.439075729927787,
+      7.400515400099126
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.0169545396445852,
+      4.964171812660547
+    ],
+    "currentVelocity": [
+      2.1067029081631787,
+      1.8033643323831283
+    ],
+    "currentAcceleration": [
+      -4.267936332766594,
+      1.1337163896416893
+    ],
+    "targetPosition": [
+      2.9734259413290687,
+      -1.264803881916631
+    ],
+    "targetVelocity": [
+      1.8115728897231094,
+      -1.3113832292600223
+    ],
+    "targetAcceleration": [
+      5.100037500244731,
+      2.784910212031024
+    ],
+    "maxVelocity": [
+      4.481091264580375,
+      3.8893298176354865
+    ],
+    "maxAcceleration": [
+      9.586865046836134,
+      7.1142655760568605
+    ],
+    "maxJerk": [
+      11.63696661647933,
+      11.304857350867339
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.677271900291409,
+      -1.6506824619148297
+    ],
+    "currentVelocity": [
+      0.057610212921210824,
+      -1.927863630772534
+    ],
+    "currentAcceleration": [
+      -3.3307556326691463,
+      3.1655919360221763
+    ],
+    "targetPosition": [
+      -3.831190137110836,
+      -6.241997403847179
+    ],
+    "targetVelocity": [
+      -1.5360110312808075,
+      -2.3800640473780117
+    ],
+    "targetAcceleration": [
+      -1.0781665874556232,
+      1.1053196929427047
+    ],
+    "maxVelocity": [
+      7.730666202407676,
+      3.9583225408158254
+    ],
+    "maxAcceleration": [
+      7.586205417447401,
+      6.4897913308591235
+    ],
+    "maxJerk": [
+      18.357913759380178,
+      9.272205718119189
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.73553930055187,
+      -3.808902697619148
+    ],
+    "currentVelocity": [
+      -4.908174966856115,
+      -3.366709141258747
+    ],
+    "currentAcceleration": [
+      -0.1321729543664083,
+      -4.0159646504312185
+    ],
+    "targetPosition": [
+      8.708206306424845,
+      -6.661902615675787
+    ],
+    "targetVelocity": [
+      -0.5346128811297532,
+      -5.665010613157333
+    ],
+    "targetAcceleration": [
+      0.5020667015196034,
+      0.022623868931580304
+    ],
+    "maxVelocity": [
+      7.602467894839269,
+      6.760779919729308
+    ],
+    "maxAcceleration": [
+      3.9972745700556738,
+      4.470401823235115
+    ],
+    "maxJerk": [
+      11.483802462501147,
+      18.937254634087886
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.490642710144281,
+      9.269347470412576
+    ],
+    "currentVelocity": [
+      -5.842698662432203,
+      -0.707988365795148
+    ],
+    "currentAcceleration": [
+      4.0449284110664,
+      0.14519082634483382
+    ],
+    "targetPosition": [
+      7.142430377967344,
+      -3.0443734920492993
+    ],
+    "targetVelocity": [
+      -0.553579132075031,
+      -2.0196653491047813
+    ],
+    "targetAcceleration": [
+      0.3509412356188184,
+      -7.26464312350609
+    ],
+    "maxVelocity": [
+      6.260646549821863,
+      2.0550114731960996
+    ],
+    "maxAcceleration": [
+      6.592195542701721,
+      8.164124890699458
+    ],
+    "maxJerk": [
+      14.79946608335356,
+      8.356087237048897
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.030480052908601,
+      -6.5944127463285485
+    ],
+    "currentVelocity": [
+      -1.6568182774259244,
+      0.4322696952554326
+    ],
+    "currentAcceleration": [
+      -2.4030527426815773,
+      0.9916174294726003
+    ],
+    "targetPosition": [
+      6.701108789651098,
+      -0.0748185019212162
+    ],
+    "targetVelocity": [
+      1.337500199986171,
+      3.8177718143243684
+    ],
+    "targetAcceleration": [
+      7.132980979284969,
+      4.235059405868772
+    ],
+    "maxVelocity": [
+      3.6498145367153256,
+      6.975194915615356
+    ],
+    "maxAcceleration": [
+      8.032382558805509,
+      7.938902461780901
+    ],
+    "maxJerk": [
+      14.072290614329823,
+      10.940028348345013
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.214940357437589,
+      6.25333328554645
+    ],
+    "currentVelocity": [
+      4.631924301722208,
+      -3.304942374452933
+    ],
+    "currentAcceleration": [
+      1.0263458599887372,
+      -0.9454122055154
+    ],
+    "targetPosition": [
+      -1.183752697700335,
+      9.841630180411634
+    ],
+    "targetVelocity": [
+      -0.33708655153085765,
+      -5.28636425719683
+    ],
+    "targetAcceleration": [
+      1.3498376179286957,
+      1.054799489916865
+    ],
+    "maxVelocity": [
+      7.8875907779416465,
+      6.033671213579659
+    ],
+    "maxAcceleration": [
+      4.390254608327181,
+      3.488463062926017
+    ],
+    "maxJerk": [
+      10.925892333159522,
+      16.698496887543524
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.682700425442106,
+      -3.220581645816032
+    ],
+    "currentVelocity": [
+      -2.4203042552012644,
+      -6.378445985656157
+    ],
+    "currentAcceleration": [
+      -2.558677423347753,
+      1.7629457525455212
+    ],
+    "targetPosition": [
+      3.4454669169431984,
+      -4.528579072392176
+    ],
+    "targetVelocity": [
+      3.216191849214143,
+      -6.104030101064666
+    ],
+    "targetAcceleration": [
+      1.373396969843256,
+      4.483794449085375
+    ],
+    "maxVelocity": [
+      7.198499820623468,
+      7.628105540075202
+    ],
+    "maxAcceleration": [
+      6.187000961580949,
+      5.866543659324336
+    ],
+    "maxJerk": [
+      11.591053757801797,
+      10.375274384883994
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.3801879316540955,
+      -9.314638247080707
+    ],
+    "currentVelocity": [
+      -5.012713743803273,
+      -2.785981188275328
+    ],
+    "currentAcceleration": [
+      0.9953952680596556,
+      3.505149872319617
+    ],
+    "targetPosition": [
+      7.323322024307423,
+      5.835661339743687
+    ],
+    "targetVelocity": [
+      -4.820990246523079,
+      -0.45284208409156923
+    ],
+    "targetAcceleration": [
+      1.1260447542072063,
+      -3.733541283735099
+    ],
+    "maxVelocity": [
+      7.947320597538097,
+      3.820046509829586
+    ],
+    "maxAcceleration": [
+      4.287242922607535,
+      4.5195953389351615
+    ],
+    "maxJerk": [
+      11.563480394956441,
+      12.584996670438855
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.0786392346988176,
+      -3.252404701219813
+    ],
+    "currentVelocity": [
+      1.2721688066315728,
+      -0.88157117859057
+    ],
+    "currentAcceleration": [
+      -3.4774493019555432,
+      -1.157832685931095
+    ],
+    "targetPosition": [
+      -3.914863205839345,
+      1.626411518931313
+    ],
+    "targetVelocity": [
+      -2.9109314460575786,
+      -0.9515002184864358
+    ],
+    "targetAcceleration": [
+      0.4925614468599857,
+      5.105449060070126
+    ],
+    "maxVelocity": [
+      5.6663704921530496,
+      2.076059895082103
+    ],
+    "maxAcceleration": [
+      9.073604134841036,
+      7.732158296566065
+    ],
+    "maxJerk": [
+      18.288873112663225,
+      13.88016003231795
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.096095111311257,
+      5.371622559645344
+    ],
+    "currentVelocity": [
+      5.783079243036423,
+      -5.932646574240833
+    ],
+    "currentAcceleration": [
+      3.3441116991798623,
+      3.049559623728121
+    ],
+    "targetPosition": [
+      -9.150664522869507,
+      -0.24802352871226674
+    ],
+    "targetVelocity": [
+      7.231470359236302,
+      -5.0298542734512335
+    ],
+    "targetAcceleration": [
+      8.205675544570783,
+      0.4533304506056144
+    ],
+    "maxVelocity": [
+      7.67907751698159,
+      7.563630657444314
+    ],
+    "maxAcceleration": [
+      8.232634445401535,
+      4.289595577681751
+    ],
+    "maxJerk": [
+      12.23934140362799,
+      17.692695951772613
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.4031168012434456,
+      5.501765432108405
+    ],
+    "currentVelocity": [
+      -1.1475274117010343,
+      6.344924740650627
+    ],
+    "currentAcceleration": [
+      1.0714428447403037,
+      -5.287192078683961
+    ],
+    "targetPosition": [
+      8.067564878132366,
+      3.6045983510464943
+    ],
+    "targetVelocity": [
+      -1.2032542319208908,
+      -2.6921954797229413
+    ],
+    "targetAcceleration": [
+      -7.392933581112979,
+      -0.22171396263999288
+    ],
+    "maxVelocity": [
+      4.831619837493182,
+      6.50269910189071
+    ],
+    "maxAcceleration": [
+      9.662344785153167,
+      7.220834087804628
+    ],
+    "maxJerk": [
+      18.54890244508003,
+      15.265328096050562
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.061944100641972,
+      -9.452597020181745
+    ],
+    "currentVelocity": [
+      1.2768450098366921,
+      -5.856504398262631
+    ],
+    "currentAcceleration": [
+      2.9170383374537856,
+      -0.4360433674191877
+    ],
+    "targetPosition": [
+      7.386124369224724,
+      5.128236948754299
+    ],
+    "targetVelocity": [
+      -1.9591702776942936,
+      -0.3478464462353017
+    ],
+    "targetAcceleration": [
+      1.9123413433792358,
+      -0.002494160197723083
+    ],
+    "maxVelocity": [
+      6.399328933204393,
+      6.481095300650178
+    ],
+    "maxAcceleration": [
+      9.700196913150114,
+      4.212334494342655
+    ],
+    "maxJerk": [
+      12.92372638701224,
+      15.55715703262873
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.3576851501524434,
+      -0.2761788817823252
+    ],
+    "currentVelocity": [
+      4.498316868145745,
+      0.34739446015509623
+    ],
+    "currentAcceleration": [
+      -4.840858593149695,
+      0.9880983377859809
+    ],
+    "targetPosition": [
+      -7.459116397464558,
+      6.016217371815593
+    ],
+    "targetVelocity": [
+      -4.405760776440176,
+      -0.4158061861304472
+    ],
+    "targetAcceleration": [
+      2.781176360723032,
+      0.07521292759544362
+    ],
+    "maxVelocity": [
+      5.9107179501547655,
+      2.199261363691747
+    ],
+    "maxAcceleration": [
+      6.186530758064347,
+      3.6655326429170345
+    ],
+    "maxJerk": [
+      6.865216861530736,
+      10.099015132596739
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.271882227780626,
+      6.132147773228986
+    ],
+    "currentVelocity": [
+      -2.578378927888033,
+      0.4342187840674194
+    ],
+    "currentAcceleration": [
+      -2.5120385547729214,
+      1.0055478341366308
+    ],
+    "targetPosition": [
+      -4.327978935003247,
+      -6.128132963376949
+    ],
+    "targetVelocity": [
+      -0.3816238993020793,
+      3.8814636208733804
+    ],
+    "targetAcceleration": [
+      2.590393800726863,
+      2.0733114578020615
+    ],
+    "maxVelocity": [
+      7.9657155601388165,
+      7.056836203764187
+    ],
+    "maxAcceleration": [
+      8.389164979625024,
+      4.293560907543204
+    ],
+    "maxJerk": [
+      7.390739079534593,
+      11.995560831600713
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.939849520762019,
+      4.394717158764456
+    ],
+    "currentVelocity": [
+      2.0536855928749747,
+      4.495688581902536
+    ],
+    "currentAcceleration": [
+      -0.6619103340965373,
+      -7.133486830101253
+    ],
+    "targetPosition": [
+      8.86394903298563,
+      8.201867447587702
+    ],
+    "targetVelocity": [
+      -1.5437317685491507,
+      -4.574317007715169
+    ],
+    "targetAcceleration": [
+      0.9018385496034522,
+      -7.38126979474055
+    ],
+    "maxVelocity": [
+      5.593517564307069,
+      6.2043466462390935
+    ],
+    "maxAcceleration": [
+      3.511122402558443,
+      8.323731477280056
+    ],
+    "maxJerk": [
+      8.956810031429825,
+      8.698661881974086
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.95668001035245,
+      -3.4154730762232717
+    ],
+    "currentVelocity": [
+      -1.2403151390698914,
+      -1.5988198403771314
+    ],
+    "currentAcceleration": [
+      4.941784904173778,
+      1.3006741932162118
+    ],
+    "targetPosition": [
+      -2.894778358455441,
+      -0.6175508514458876
+    ],
+    "targetVelocity": [
+      -0.4266888629420418,
+      1.7479494357552552
+    ],
+    "targetAcceleration": [
+      6.078938321837947,
+      0.1617435119739632
+    ],
+    "maxVelocity": [
+      5.979012761045472,
+      2.8521911887670974
+    ],
+    "maxAcceleration": [
+      6.695140232117298,
+      8.070897663827939
+    ],
+    "maxJerk": [
+      6.919497705866445,
+      6.347789398804024
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.396413510627251,
+      -3.0561390036856784
+    ],
+    "currentVelocity": [
+      3.36509021095626,
+      2.561233953938655
+    ],
+    "currentAcceleration": [
+      -1.7870622130032254,
+      5.794270595230307
+    ],
+    "targetPosition": [
+      6.793700066248615,
+      1.0651560097231325
+    ],
+    "targetVelocity": [
+      0.9843884206029534,
+      1.1242622360105123
+    ],
+    "targetAcceleration": [
+      1.8074274374972372,
+      -5.731572435101741
+    ],
+    "maxVelocity": [
+      3.552705590525564,
+      5.38903350915716
+    ],
+    "maxAcceleration": [
+      6.5112943325307935,
+      7.919839026169463
+    ],
+    "maxJerk": [
+      5.426665554124929,
+      15.501522531053558
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.254834439009539,
+      0.0428521414445413
+    ],
+    "currentVelocity": [
+      4.091816440081209,
+      5.126192262001746
+    ],
+    "currentAcceleration": [
+      5.680634040567375,
+      -4.995768901714416
+    ],
+    "targetPosition": [
+      2.4983949003222623,
+      -4.483913053238567
+    ],
+    "targetVelocity": [
+      0.5883183153682907,
+      -2.614054949423065
+    ],
+    "targetAcceleration": [
+      -3.583784566614517,
+      -0.8523927014178412
+    ],
+    "maxVelocity": [
+      6.1010184748540945,
+      7.4019008561936666
+    ],
+    "maxAcceleration": [
+      7.12879128636933,
+      9.91233011967789
+    ],
+    "maxJerk": [
+      9.753164758493117,
+      16.509785183924954
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.946342100096512,
+      9.032776094975816
+    ],
+    "currentVelocity": [
+      1.2512427974195663,
+      -1.6554539861577462
+    ],
+    "currentAcceleration": [
+      -1.25500863992155,
+      -3.548676326101619
+    ],
+    "targetPosition": [
+      0.17623722408823284,
+      -0.5991674803292764
+    ],
+    "targetVelocity": [
+      2.641322763432669,
+      2.107058327452573
+    ],
+    "targetAcceleration": [
+      2.6042685323550163,
+      -2.9701641614017777
+    ],
+    "maxVelocity": [
+      7.607511235359407,
+      6.3318403220609225
+    ],
+    "maxAcceleration": [
+      4.34696880698154,
+      4.468961297230791
+    ],
+    "maxJerk": [
+      7.765029554736945,
+      8.347356387272452
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.592823500766711,
+      -5.994500344620739
+    ],
+    "currentVelocity": [
+      -4.099147351209801,
+      -0.15486362946567622
+    ],
+    "currentAcceleration": [
+      -1.0485743716622604,
+      -3.245345957737817
+    ],
+    "targetPosition": [
+      8.925786536147633,
+      6.130190056761457
+    ],
+    "targetVelocity": [
+      1.2048698589592757,
+      -0.3147277564912927
+    ],
+    "targetAcceleration": [
+      -1.8970541422863612,
+      -3.0606286997839676
+    ],
+    "maxVelocity": [
+      6.723203503624577,
+      2.4193678499611675
+    ],
+    "maxAcceleration": [
+      8.80022090961439,
+      3.94731606285167
+    ],
+    "maxJerk": [
+      7.314003515769291,
+      8.25944126608691
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.8568227504513235,
+      6.194587701055617
+    ],
+    "currentVelocity": [
+      -0.34898657377650366,
+      -0.7126118934373646
+    ],
+    "currentAcceleration": [
+      -0.9510597936921776,
+      -1.863654002878976
+    ],
+    "targetPosition": [
+      -0.27923146001228183,
+      -0.6553193347421526
+    ],
+    "targetVelocity": [
+      -1.394706760587824,
+      -0.13056321809790994
+    ],
+    "targetAcceleration": [
+      -0.9685076666680863,
+      -2.1170332734611867
+    ],
+    "maxVelocity": [
+      6.637410639083026,
+      2.654576407555255
+    ],
+    "maxAcceleration": [
+      4.3609177187426695,
+      5.182346973250556
+    ],
+    "maxJerk": [
+      19.7624052852021,
+      19.026320230116376
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.160055209221912,
+      -3.696817597593613
+    ],
+    "currentVelocity": [
+      -3.0523980666331534,
+      -1.2633880063247453
+    ],
+    "currentAcceleration": [
+      0.03317355483663054,
+      4.618862849257308
+    ],
+    "targetPosition": [
+      -1.0174273209531766,
+      4.715795918126215
+    ],
+    "targetVelocity": [
+      4.020330146743763,
+      -0.4990546632559947
+    ],
+    "targetAcceleration": [
+      -1.8433100487058596,
+      -1.4498275736434945
+    ],
+    "maxVelocity": [
+      4.396548170268666,
+      3.0911086280202587
+    ],
+    "maxAcceleration": [
+      5.103123679664612,
+      8.404480081448662
+    ],
+    "maxJerk": [
+      5.732656877677727,
+      11.202638573501483
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.6346971414472975,
+      -7.938184495220053
+    ],
+    "currentVelocity": [
+      -3.430346588924345,
+      -2.4159130331875174
+    ],
+    "currentAcceleration": [
+      7.693628930009323,
+      0.8148850126364993
+    ],
+    "targetPosition": [
+      -1.4185634335590418,
+      6.616040023975319
+    ],
+    "targetVelocity": [
+      -4.194304681601796,
+      -0.49885900217222545
+    ],
+    "targetAcceleration": [
+      -2.286059294485928,
+      1.2800148803157523
+    ],
+    "maxVelocity": [
+      7.668255682377555,
+      7.211713147412144
+    ],
+    "maxAcceleration": [
+      8.125829166297446,
+      3.6100929036728875
+    ],
+    "maxJerk": [
+      19.586659376314522,
+      5.945675847102084
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.851918445105678,
+      -7.699842406370703
+    ],
+    "currentVelocity": [
+      3.864319865433708,
+      -0.3192413485683083
+    ],
+    "currentAcceleration": [
+      3.4212396318695237,
+      -4.056821193914471
+    ],
+    "targetPosition": [
+      -9.489674627582097,
+      7.68528506211673
+    ],
+    "targetVelocity": [
+      -3.781584406883991,
+      0.8026201618198012
+    ],
+    "targetAcceleration": [
+      0.009271647737081778,
+      -0.8172872465828043
+    ],
+    "maxVelocity": [
+      7.86274196772164,
+      7.547079633582543
+    ],
+    "maxAcceleration": [
+      6.096680330733337,
+      5.519611985079858
+    ],
+    "maxJerk": [
+      17.09325315846535,
+      14.71417259458754
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.772551754701921,
+      4.673450237924403
+    ],
+    "currentVelocity": [
+      -2.6073588657020186,
+      3.646299855863008
+    ],
+    "currentAcceleration": [
+      -2.455880348229546,
+      -1.1914452693723199
+    ],
+    "targetPosition": [
+      7.1096934558953535,
+      2.160236683581223
+    ],
+    "targetVelocity": [
+      -3.649761120542981,
+      2.574261772013436
+    ],
+    "targetAcceleration": [
+      -0.24322276978146062,
+      -0.054699819802359606
+    ],
+    "maxVelocity": [
+      6.114834304744772,
+      5.443399232285731
+    ],
+    "maxAcceleration": [
+      3.0451275934930084,
+      3.5854651169803597
+    ],
+    "maxJerk": [
+      15.91876438290569,
+      17.37447523829288
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.294752579636384,
+      9.612365644638814
+    ],
+    "currentVelocity": [
+      4.231271674785794,
+      -0.1466888909421291
+    ],
+    "currentAcceleration": [
+      -0.1696266157852646,
+      -6.373266512256636
+    ],
+    "targetPosition": [
+      -8.287074134990714,
+      -9.066983957811885
+    ],
+    "targetVelocity": [
+      0.4721186745180761,
+      -0.6033496187635783
+    ],
+    "targetAcceleration": [
+      -6.223742570096362,
+      4.288333129705244
+    ],
+    "maxVelocity": [
+      5.485182536691597,
+      2.9532889106341433
+    ],
+    "maxAcceleration": [
+      6.248091635504291,
+      9.5023624966354
+    ],
+    "maxJerk": [
+      7.088735923278445,
+      13.706211487591577
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.821249343122087,
+      7.790334233846355
+    ],
+    "currentVelocity": [
+      -0.8588036346830119,
+      -0.741778789241522
+    ],
+    "currentAcceleration": [
+      -2.2034670485103085,
+      1.9827218778097864
+    ],
+    "targetPosition": [
+      0.9398550260341647,
+      -3.1762403670713812
+    ],
+    "targetVelocity": [
+      -0.8316162168863954,
+      -0.8899681435433164
+    ],
+    "targetAcceleration": [
+      4.313041554069789,
+      -5.156351569286618
+    ],
+    "maxVelocity": [
+      5.895759288177307,
+      2.8735803048474775
+    ],
+    "maxAcceleration": [
+      9.416968992771181,
+      5.916359130904958
+    ],
+    "maxJerk": [
+      10.943551698461633,
+      11.485084986306205
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.956174138141396,
+      0.5778272169201841
+    ],
+    "currentVelocity": [
+      -3.0993494891404256,
+      -2.18195210818383
+    ],
+    "currentAcceleration": [
+      -0.6995658477525488,
+      3.765907656111338
+    ],
+    "targetPosition": [
+      8.189686822035718,
+      -9.678010489123741
+    ],
+    "targetVelocity": [
+      0.9437114624771672,
+      -0.16615143075283356
+    ],
+    "targetAcceleration": [
+      -4.654737292493321,
+      -1.2173445675625927
+    ],
+    "maxVelocity": [
+      4.023999312283291,
+      5.481245819956939
+    ],
+    "maxAcceleration": [
+      6.030922047135796,
+      4.589082464567124
+    ],
+    "maxJerk": [
+      8.323956777325513,
+      5.497281170590699
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.89475167518135,
+      2.5066302354069165
+    ],
+    "currentVelocity": [
+      1.8090119542616527,
+      1.7262786146651363
+    ],
+    "currentAcceleration": [
+      5.62494747417813,
+      2.546426385815167
+    ],
+    "targetPosition": [
+      7.74748489956605,
+      9.955541773883464
+    ],
+    "targetVelocity": [
+      -0.1917653082802211,
+      0.24845300129585102
+    ],
+    "targetAcceleration": [
+      -0.5821487045233162,
+      -1.9944149137173692
+    ],
+    "maxVelocity": [
+      7.860285062777848,
+      4.525841552020394
+    ],
+    "maxAcceleration": [
+      7.0949588871461735,
+      9.04593851243476
+    ],
+    "maxJerk": [
+      7.357046454073888,
+      14.908956020239803
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.7005077913747098,
+      -5.374897535212484
+    ],
+    "currentVelocity": [
+      0.04960869055578243,
+      -1.3514141918943081
+    ],
+    "currentAcceleration": [
+      -4.032922621113085,
+      4.630971777958624
+    ],
+    "targetPosition": [
+      7.173547150709727,
+      -4.502675529379607
+    ],
+    "targetVelocity": [
+      -1.2116910565927583,
+      1.3481951143363888
+    ],
+    "targetAcceleration": [
+      0.16074086487390993,
+      -3.8305351000302386
+    ],
+    "maxVelocity": [
+      3.041998774276921,
+      5.057266911836639
+    ],
+    "maxAcceleration": [
+      4.975391126444973,
+      5.832268001525724
+    ],
+    "maxJerk": [
+      19.218561808067495,
+      9.155784291719645
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.681490183673358,
+      8.631338031076016
+    ],
+    "currentVelocity": [
+      -0.7739001303771387,
+      -0.27231502288263876
+    ],
+    "currentAcceleration": [
+      -2.2374444536501104,
+      -0.24830399977881434
+    ],
+    "targetPosition": [
+      -9.915560648908333,
+      -6.292899817041615
+    ],
+    "targetVelocity": [
+      -1.613336327420524,
+      -4.71101603649672
+    ],
+    "targetAcceleration": [
+      1.8505652793985208,
+      -4.2300223440698375
+    ],
+    "maxVelocity": [
+      6.205852857087345,
+      6.610928388145485
+    ],
+    "maxAcceleration": [
+      4.450686866434201,
+      7.187893646384436
+    ],
+    "maxJerk": [
+      16.756143466875677,
+      6.838749351969844
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.032100008778839,
+      5.223176438939788
+    ],
+    "currentVelocity": [
+      -5.053745417625203,
+      2.463625767187808
+    ],
+    "currentAcceleration": [
+      -2.6871459064541736,
+      -4.147075997421599
+    ],
+    "targetPosition": [
+      0.3091879788511669,
+      0.36882145017912293
+    ],
+    "targetVelocity": [
+      1.6014091885743893,
+      -2.5259723488467487
+    ],
+    "targetAcceleration": [
+      -3.3915217080630002,
+      -6.637668459218165
+    ],
+    "maxVelocity": [
+      6.440627280655312,
+      3.6039193055526644
+    ],
+    "maxAcceleration": [
+      4.968237007745693,
+      6.816917672499283
+    ],
+    "maxJerk": [
+      9.891401090529632,
+      18.243406088073954
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.236681347451551,
+      -7.619231182786558
+    ],
+    "currentVelocity": [
+      -0.7262198430618894,
+      4.015276689602237
+    ],
+    "currentAcceleration": [
+      9.04050470359519,
+      -1.5615331527856209
+    ],
+    "targetPosition": [
+      -0.799949870561349,
+      -1.8276812324738891
+    ],
+    "targetVelocity": [
+      -2.0733404817640126,
+      1.4895659200183617
+    ],
+    "targetAcceleration": [
+      -0.23856709354750372,
+      -0.3678111128148922
+    ],
+    "maxVelocity": [
+      2.2811208003608567,
+      4.898618204952948
+    ],
+    "maxAcceleration": [
+      9.159454779564175,
+      5.0988995380718745
+    ],
+    "maxJerk": [
+      17.274383882351373,
+      13.639733839915602
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.908566255669811,
+      -8.238725279241043
+    ],
+    "currentVelocity": [
+      2.1009059343851844,
+      -2.799768364305351
+    ],
+    "currentAcceleration": [
+      -4.200022999412029,
+      1.1924651416439254
+    ],
+    "targetPosition": [
+      3.726741029954974,
+      -5.24002287566717
+    ],
+    "targetVelocity": [
+      -0.37566570523465526,
+      0.9081528932611915
+    ],
+    "targetAcceleration": [
+      -0.32978984875820494,
+      -1.9002718356675332
+    ],
+    "maxVelocity": [
+      2.7533268575276324,
+      3.2973707382191035
+    ],
+    "maxAcceleration": [
+      9.762889403417391,
+      3.6398821962330183
+    ],
+    "maxJerk": [
+      9.342530702973148,
+      17.674606501025536
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.990413994512091,
+      -4.123424215746228
+    ],
+    "currentVelocity": [
+      0.5435292137799248,
+      -1.0537941325455273
+    ],
+    "currentAcceleration": [
+      0.8711597621886527,
+      0.8503398237763982
+    ],
+    "targetPosition": [
+      0.02208860684299907,
+      -4.672118362867823
+    ],
+    "targetVelocity": [
+      -1.6138784796131045,
+      0.6589199759517594
+    ],
+    "targetAcceleration": [
+      -1.3150971978003563,
+      2.150054859734471
+    ],
+    "maxVelocity": [
+      2.0733679404665395,
+      6.377077365420193
+    ],
+    "maxAcceleration": [
+      3.4478692639286703,
+      5.279945502397174
+    ],
+    "maxJerk": [
+      15.621962188392123,
+      5.597064203244703
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7661248009573924,
+      0.0957984906826308
+    ],
+    "currentVelocity": [
+      -3.4827277853207894,
+      -4.191109908185699
+    ],
+    "currentAcceleration": [
+      -0.2928509911278141,
+      -1.4191115581667795
+    ],
+    "targetPosition": [
+      8.83519229308557,
+      -4.777152178165918
+    ],
+    "targetVelocity": [
+      -3.2273029756388523,
+      -3.582697915042175
+    ],
+    "targetAcceleration": [
+      0.44744628735388225,
+      -5.083458334031141
+    ],
+    "maxVelocity": [
+      5.030032934607942,
+      4.6335936012592205
+    ],
+    "maxAcceleration": [
+      4.312240599727881,
+      9.684101270723144
+    ],
+    "maxJerk": [
+      8.822078405643712,
+      14.811958917856579
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6131388535521758,
+      -6.629905118738158
+    ],
+    "currentVelocity": [
+      -3.7767599524861044,
+      1.5452441763511047
+    ],
+    "currentAcceleration": [
+      -4.85397394594895,
+      0.9065629181187909
+    ],
+    "targetPosition": [
+      5.241345341835244,
+      3.0275769651985645
+    ],
+    "targetVelocity": [
+      -1.6992107905580678,
+      -1.1856458934778225
+    ],
+    "targetAcceleration": [
+      4.51236792085629,
+      -2.3253338427889765
+    ],
+    "maxVelocity": [
+      7.111313213993746,
+      7.16467834233061
+    ],
+    "maxAcceleration": [
+      5.464024584837611,
+      4.781357593929197
+    ],
+    "maxJerk": [
+      10.476523815103336,
+      17.584106709651337
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.9596408304686346,
+      -1.1680678039951502
+    ],
+    "currentVelocity": [
+      0.5414179496494942,
+      1.635201843464206
+    ],
+    "currentAcceleration": [
+      -2.0326080250025447,
+      -1.9795253770760324
+    ],
+    "targetPosition": [
+      -7.485324989907789,
+      -7.939727912710981
+    ],
+    "targetVelocity": [
+      -1.5677444957154005,
+      -0.35509905654966545
+    ],
+    "targetAcceleration": [
+      5.854622862530974,
+      4.329467864174124
+    ],
+    "maxVelocity": [
+      4.739457643004199,
+      2.6664410393177973
+    ],
+    "maxAcceleration": [
+      6.015112288129455,
+      5.024590628131189
+    ],
+    "maxJerk": [
+      17.140254745289617,
+      19.091283893316195
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.2498042593064902,
+      7.161671718178077
+    ],
+    "currentVelocity": [
+      2.9336105487895177,
+      -1.4130210925807045
+    ],
+    "currentAcceleration": [
+      2.4235510720964903,
+      0.4789584670508287
+    ],
+    "targetPosition": [
+      9.076920523915067,
+      2.824210808762457
+    ],
+    "targetVelocity": [
+      -0.0184517150711887,
+      -1.5033845408153708
+    ],
+    "targetAcceleration": [
+      4.032968207320499,
+      2.931173156163056
+    ],
+    "maxVelocity": [
+      3.268174582878877,
+      4.26755272275528
+    ],
+    "maxAcceleration": [
+      8.581605450545512,
+      3.7846197869568092
+    ],
+    "maxJerk": [
+      14.502238542811526,
+      5.01317711069086
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.696794080378702,
+      0.5030638904795524
+    ],
+    "currentVelocity": [
+      1.3145035169498707,
+      4.553228961768265
+    ],
+    "currentAcceleration": [
+      -6.990455452469378,
+      -5.009042692835832
+    ],
+    "targetPosition": [
+      -3.0174902924731484,
+      -5.633972387571724
+    ],
+    "targetVelocity": [
+      2.767189785421632,
+      1.662711495403066
+    ],
+    "targetAcceleration": [
+      2.5876502370440377,
+      4.780501151543173
+    ],
+    "maxVelocity": [
+      3.3743988414187065,
+      5.41969382874919
+    ],
+    "maxAcceleration": [
+      7.826592077324733,
+      6.534003099186811
+    ],
+    "maxJerk": [
+      7.572745611497157,
+      19.99352970603167
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.50689072548634,
+      -0.49079117515644555
+    ],
+    "currentVelocity": [
+      0.5270538383325061,
+      -0.15112368141990284
+    ],
+    "currentAcceleration": [
+      3.6956065418515838,
+      -2.3026218447730784
+    ],
+    "targetPosition": [
+      8.246324716235044,
+      7.883122047213547
+    ],
+    "targetVelocity": [
+      1.0057807094760802,
+      -1.0251322337884572
+    ],
+    "targetAcceleration": [
+      1.9077726647657869,
+      -2.283164200644995
+    ],
+    "maxVelocity": [
+      2.2718402512475953,
+      2.549492621907495
+    ],
+    "maxAcceleration": [
+      3.7357413511951885,
+      3.642659500971392
+    ],
+    "maxJerk": [
+      5.539821564622219,
+      17.61825207282196
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.200512778856988,
+      0.028691769237610742
+    ],
+    "currentVelocity": [
+      -0.45618332881481116,
+      -2.2357548120255064
+    ],
+    "currentAcceleration": [
+      -7.015294109006877,
+      3.224897269073142
+    ],
+    "targetPosition": [
+      2.3643041997289522,
+      3.3880080199377716
+    ],
+    "targetVelocity": [
+      2.9611289548687036,
+      -1.6284040851486001
+    ],
+    "targetAcceleration": [
+      -6.089580831329684,
+      2.6989929602204485
+    ],
+    "maxVelocity": [
+      5.5423467739583625,
+      2.6613989446830213
+    ],
+    "maxAcceleration": [
+      8.923860012678775,
+      3.286143153226094
+    ],
+    "maxJerk": [
+      7.64738528125276,
+      6.746483207420917
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.149185957021373,
+      -8.308317506897726
+    ],
+    "currentVelocity": [
+      -1.3599825263855385,
+      -3.7593474226249413
+    ],
+    "currentAcceleration": [
+      -2.913806438751787,
+      -3.0444086921805624
+    ],
+    "targetPosition": [
+      -5.065344011767625,
+      9.558184355382416
+    ],
+    "targetVelocity": [
+      2.0149938425539045,
+      -3.3734909569190488
+    ],
+    "targetAcceleration": [
+      -3.4587612325858004,
+      -0.08844271916026969
+    ],
+    "maxVelocity": [
+      2.5342631505159696,
+      6.237498624161938
+    ],
+    "maxAcceleration": [
+      3.6349062830283985,
+      3.8635027473977623
+    ],
+    "maxJerk": [
+      17.80487293171196,
+      17.487029637508897
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.96563332193677,
+      -3.056249354475778
+    ],
+    "currentVelocity": [
+      -1.5848170049481056,
+      5.39435358823495
+    ],
+    "currentAcceleration": [
+      2.091342279990947,
+      0.9622805385717434
+    ],
+    "targetPosition": [
+      -5.602610539454802,
+      0.17390730419563738
+    ],
+    "targetVelocity": [
+      5.010533924545334,
+      2.3672220253224276
+    ],
+    "targetAcceleration": [
+      2.462681695264642,
+      5.392034434048769
+    ],
+    "maxVelocity": [
+      5.188320091399354,
+      6.879772665728233
+    ],
+    "maxAcceleration": [
+      6.001229825280049,
+      9.241604847996504
+    ],
+    "maxJerk": [
+      15.87938894197682,
+      18.653110923024457
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.857258973259949,
+      7.006929330504764
+    ],
+    "currentVelocity": [
+      -6.904437463724561,
+      -4.055602788258898
+    ],
+    "currentAcceleration": [
+      -4.628660243957492,
+      7.690626320907246
+    ],
+    "targetPosition": [
+      -6.920827289470168,
+      -3.2427554020254394
+    ],
+    "targetVelocity": [
+      4.276497344150066,
+      -5.817242372887431
+    ],
+    "targetAcceleration": [
+      -2.1651240424665303,
+      5.370482669620769
+    ],
+    "maxVelocity": [
+      7.7884579351356,
+      7.457096863822846
+    ],
+    "maxAcceleration": [
+      7.992518403351884,
+      8.812396943620026
+    ],
+    "maxJerk": [
+      12.962512238310598,
+      16.012331744007398
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.103590984273708,
+      5.478393030620461
+    ],
+    "currentVelocity": [
+      -5.858599198677482,
+      1.4658358154356925
+    ],
+    "currentAcceleration": [
+      -3.6864996327113007,
+      -0.2792606810306193
+    ],
+    "targetPosition": [
+      -2.6565258928776148,
+      -9.616712630962652
+    ],
+    "targetVelocity": [
+      -4.394414078799445,
+      1.263224511902549
+    ],
+    "targetAcceleration": [
+      5.1474888267408545,
+      -5.354654358838767
+    ],
+    "maxVelocity": [
+      7.872699440633665,
+      6.663615687389459
+    ],
+    "maxAcceleration": [
+      9.585609079246499,
+      8.73423696224831
+    ],
+    "maxJerk": [
+      12.956466655719463,
+      15.838495999715066
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7525915247311605,
+      -0.8202695263294064
+    ],
+    "currentVelocity": [
+      1.1100827309096957,
+      1.434233002323925
+    ],
+    "currentAcceleration": [
+      5.120589144554539,
+      -1.0385297544884455
+    ],
+    "targetPosition": [
+      -5.424049273929173,
+      -3.3515812746576206
+    ],
+    "targetVelocity": [
+      -1.735119070045653,
+      -4.6359974735611225
+    ],
+    "targetAcceleration": [
+      -4.123853628288654,
+      -3.9790494223503727
+    ],
+    "maxVelocity": [
+      5.220006069680202,
+      5.627509403809221
+    ],
+    "maxAcceleration": [
+      6.119047915801565,
+      6.265132369111206
+    ],
+    "maxJerk": [
+      15.65343428505484,
+      17.218569641360922
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.9607646063106614,
+      -9.459797629555815
+    ],
+    "currentVelocity": [
+      0.9733806422408202,
+      1.7175174773741286
+    ],
+    "currentAcceleration": [
+      8.50359658521263,
+      5.897341255965674
+    ],
+    "targetPosition": [
+      -4.413223489697618,
+      7.721052762916653
+    ],
+    "targetVelocity": [
+      -0.010070910543182876,
+      -1.0095204877519222
+    ],
+    "targetAcceleration": [
+      -3.3763646987868725,
+      -5.446500497269399
+    ],
+    "maxVelocity": [
+      5.451496107694455,
+      3.1363466924411627
+    ],
+    "maxAcceleration": [
+      9.839093599616362,
+      7.424282035350755
+    ],
+    "maxJerk": [
+      8.94856769524017,
+      16.828392976951186
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.5064253955123075,
+      0.921796057102199
+    ],
+    "currentVelocity": [
+      0.01819389864391141,
+      3.426734249939239
+    ],
+    "currentAcceleration": [
+      -3.273402015788749,
+      -1.4280819210240763
+    ],
+    "targetPosition": [
+      -5.673510225777944,
+      -0.8691790951238083
+    ],
+    "targetVelocity": [
+      -0.45964569588041515,
+      -1.5306852293644653
+    ],
+    "targetAcceleration": [
+      -4.3289659330293535,
+      -4.003843137980002
+    ],
+    "maxVelocity": [
+      3.46168194921916,
+      3.951413187337959
+    ],
+    "maxAcceleration": [
+      6.475459493235958,
+      7.60280461651158
+    ],
+    "maxJerk": [
+      11.90800457020524,
+      6.7414994594884625
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.184794927869043,
+      -3.774539832740267
+    ],
+    "currentVelocity": [
+      1.3101924419731592,
+      -1.5662721189483895
+    ],
+    "currentAcceleration": [
+      -2.525859325529046,
+      -7.112450712167883
+    ],
+    "targetPosition": [
+      -4.743965161057799,
+      4.005077565301388
+    ],
+    "targetVelocity": [
+      1.4485976275804457,
+      4.280318750429992
+    ],
+    "targetAcceleration": [
+      -0.9133760530524735,
+      2.319127750313738
+    ],
+    "maxVelocity": [
+      5.909116510120188,
+      6.243295653958268
+    ],
+    "maxAcceleration": [
+      3.044929229331602,
+      9.7238793462084
+    ],
+    "maxJerk": [
+      11.363834358802613,
+      14.697276167746248
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.0964077718747482,
+      -1.4627076810609285
+    ],
+    "currentVelocity": [
+      3.5002958997646987,
+      0.14555698363102954
+    ],
+    "currentAcceleration": [
+      0.02457667417937781,
+      -1.6312109780391268
+    ],
+    "targetPosition": [
+      5.628881733303457,
+      9.129407999782696
+    ],
+    "targetVelocity": [
+      2.215954866926265,
+      -0.7473937721849002
+    ],
+    "targetAcceleration": [
+      4.401949539882635,
+      -4.169607865716884
+    ],
+    "maxVelocity": [
+      4.038908602980053,
+      2.4398199983217026
+    ],
+    "maxAcceleration": [
+      7.2071919544863245,
+      4.421283491421928
+    ],
+    "maxJerk": [
+      19.085252409109017,
+      12.848126083724317
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.7220646094838656,
+      -7.2068452689025015
+    ],
+    "currentVelocity": [
+      -0.9747276724092304,
+      2.183179640794017
+    ],
+    "currentAcceleration": [
+      -3.4120007387531053,
+      -3.834550821691666
+    ],
+    "targetPosition": [
+      9.415720564092645,
+      0.10940563589673324
+    ],
+    "targetVelocity": [
+      0.1998764297980351,
+      2.411602746462166
+    ],
+    "targetAcceleration": [
+      -2.1806122364219553,
+      -3.609470237976151
+    ],
+    "maxVelocity": [
+      2.0364527399439663,
+      4.431526794297769
+    ],
+    "maxAcceleration": [
+      4.258456064279086,
+      6.165186977650808
+    ],
+    "maxJerk": [
+      8.478120980165723,
+      17.970205056032725
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.808259857660012,
+      1.402225542124187
+    ],
+    "currentVelocity": [
+      0.02237638028325417,
+      -4.590335013683294
+    ],
+    "currentAcceleration": [
+      -1.532920356208348,
+      0.5261179903479585
+    ],
+    "targetPosition": [
+      6.08050276465281,
+      3.3400463157464895
+    ],
+    "targetVelocity": [
+      -2.297218535301501,
+      3.2690642786704007
+    ],
+    "targetAcceleration": [
+      6.833299137950453,
+      -1.5581244663240237
+    ],
+    "maxVelocity": [
+      4.54899405208935,
+      7.938965895574125
+    ],
+    "maxAcceleration": [
+      7.621633761315277,
+      3.819165390932999
+    ],
+    "maxJerk": [
+      15.838155580264583,
+      14.778884079000008
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.863725656307446,
+      3.352041899833072
+    ],
+    "currentVelocity": [
+      3.541423407005862,
+      3.3208039380220153
+    ],
+    "currentAcceleration": [
+      -5.820150317421675,
+      -0.29701532678123366
+    ],
+    "targetPosition": [
+      -1.1173832772554846,
+      2.402948168991621
+    ],
+    "targetVelocity": [
+      6.267693769834825,
+      -4.556466678719206
+    ],
+    "targetAcceleration": [
+      5.16157642946503,
+      -0.7853951179446614
+    ],
+    "maxVelocity": [
+      7.839093042713545,
+      7.361340717371389
+    ],
+    "maxAcceleration": [
+      6.785912039982459,
+      4.1459962092336236
+    ],
+    "maxJerk": [
+      10.224369967607712,
+      5.856617191082329
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.9520626645028472,
+      3.3118295178406036
+    ],
+    "currentVelocity": [
+      0.781899698700756,
+      -2.541662900148709
+    ],
+    "currentAcceleration": [
+      1.2848047441551937,
+      3.015604885425703
+    ],
+    "targetPosition": [
+      -3.8801742368108556,
+      8.476093936256198
+    ],
+    "targetVelocity": [
+      -2.3690705426653196,
+      6.103647418989794
+    ],
+    "targetAcceleration": [
+      -0.28215185921725716,
+      -5.347007524256732
+    ],
+    "maxVelocity": [
+      3.3623209797694535,
+      7.792254904539996
+    ],
+    "maxAcceleration": [
+      7.211175023201937,
+      7.593077286332854
+    ],
+    "maxJerk": [
+      7.678526150496438,
+      11.517120026773632
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.834424832441189,
+      -5.073174970950056
+    ],
+    "currentVelocity": [
+      1.8959635636465952,
+      0.9441722168508178
+    ],
+    "currentAcceleration": [
+      3.495086873323573,
+      -4.577858528056095
+    ],
+    "targetPosition": [
+      3.6097753850639833,
+      6.129434662577971
+    ],
+    "targetVelocity": [
+      -4.049643108087749,
+      -1.0636177192571128
+    ],
+    "targetAcceleration": [
+      -3.8560984777262397,
+      5.2717258646784195
+    ],
+    "maxVelocity": [
+      5.71912513826008,
+      3.308717602912608
+    ],
+    "maxAcceleration": [
+      5.458773049266459,
+      8.427628542577372
+    ],
+    "maxJerk": [
+      5.717527735274484,
+      11.265897403113803
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.683559347762367,
+      3.184816388458895
+    ],
+    "currentVelocity": [
+      0.9805739617255176,
+      -1.0548308475479198
+    ],
+    "currentAcceleration": [
+      4.381632559364142,
+      -2.0428829263283372
+    ],
+    "targetPosition": [
+      -7.776795259634404,
+      -3.4908131807532445
+    ],
+    "targetVelocity": [
+      -0.2118765639840996,
+      5.2420535799854955
+    ],
+    "targetAcceleration": [
+      4.8728176856994985,
+      -2.77232002193001
+    ],
+    "maxVelocity": [
+      6.186248462379922,
+      5.849878963209753
+    ],
+    "maxAcceleration": [
+      7.874337897089088,
+      3.2303413428607377
+    ],
+    "maxJerk": [
+      15.773398069878231,
+      17.015788450383965
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.08501510745564,
+      -6.800927666353913
+    ],
+    "currentVelocity": [
+      0.38605598978414335,
+      -3.477592249979804
+    ],
+    "currentAcceleration": [
+      2.5142872268547176,
+      -4.562074336012875
+    ],
+    "targetPosition": [
+      -3.3917472646870213,
+      1.5689440466879496
+    ],
+    "targetVelocity": [
+      0.8904316894927509,
+      -2.4445327178237832
+    ],
+    "targetAcceleration": [
+      1.0713580283378326,
+      -0.10402561474870531
+    ],
+    "maxVelocity": [
+      2.3816201423500543,
+      6.273966793920986
+    ],
+    "maxAcceleration": [
+      3.5027396515909395,
+      5.512280359397567
+    ],
+    "maxJerk": [
+      10.129946911670292,
+      11.44659472128303
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.17822845239246,
+      -6.530628974256083
+    ],
+    "currentVelocity": [
+      -4.556934780830629,
+      2.166932597232708
+    ],
+    "currentAcceleration": [
+      2.554866170657621,
+      1.3420044982288175
+    ],
+    "targetPosition": [
+      -5.795852427930761,
+      -6.574266159305022
+    ],
+    "targetVelocity": [
+      3.807018250710108,
+      -0.7477836886512179
+    ],
+    "targetAcceleration": [
+      -1.2591520878405613,
+      1.805912488204279
+    ],
+    "maxVelocity": [
+      4.836948909162221,
+      2.6510446560868486
+    ],
+    "maxAcceleration": [
+      3.9484185172104658,
+      3.6178974698337143
+    ],
+    "maxJerk": [
+      8.696374242294604,
+      5.683551521851617
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.8907544688264597,
+      -2.5476749288446587
+    ],
+    "currentVelocity": [
+      0.36905604185629315,
+      -4.48156348877842
+    ],
+    "currentAcceleration": [
+      4.334156472257466,
+      2.4085223001130593
+    ],
+    "targetPosition": [
+      7.023941228529953,
+      7.571373583553882
+    ],
+    "targetVelocity": [
+      0.7079625348565362,
+      -4.855591782000856
+    ],
+    "targetAcceleration": [
+      -4.931636581098514,
+      1.0477222071807955
+    ],
+    "maxVelocity": [
+      2.5380110128851516,
+      7.795472587471678
+    ],
+    "maxAcceleration": [
+      5.67845055689306,
+      7.294358440607164
+    ],
+    "maxJerk": [
+      18.587543579319455,
+      15.425985127025672
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6101574933576401,
+      9.361580033977486
+    ],
+    "currentVelocity": [
+      -0.9452221280718902,
+      5.3568780157545834
+    ],
+    "currentAcceleration": [
+      -1.4681479008901066,
+      -1.1855745519719336
+    ],
+    "targetPosition": [
+      9.27743391535444,
+      -9.152648467227289
+    ],
+    "targetVelocity": [
+      5.076825662383273,
+      -5.869824258408267
+    ],
+    "targetAcceleration": [
+      3.2775442329185545,
+      -0.5270754530922277
+    ],
+    "maxVelocity": [
+      7.013791230370117,
+      7.43925050059463
+    ],
+    "maxAcceleration": [
+      6.001136337937842,
+      3.0162058167183314
+    ],
+    "maxJerk": [
+      8.842529799897374,
+      6.5033851579188395
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7034138034607516,
+      5.801897347386333
+    ],
+    "currentVelocity": [
+      -2.029677451280847,
+      -0.25334963386481046
+    ],
+    "currentAcceleration": [
+      3.4112787933769626,
+      3.8072414832996193
+    ],
+    "targetPosition": [
+      -2.34814543785562,
+      -0.717905184047245
+    ],
+    "targetVelocity": [
+      -4.665979589198242,
+      0.3280804980101042
+    ],
+    "targetAcceleration": [
+      2.776714599121937,
+      -4.084270112431626
+    ],
+    "maxVelocity": [
+      7.214986518423469,
+      6.215398061919336
+    ],
+    "maxAcceleration": [
+      7.918636448342016,
+      5.068506597475488
+    ],
+    "maxJerk": [
+      17.324802953620463,
+      16.50739432341026
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.680601451291476,
+      3.446025742227949
+    ],
+    "currentVelocity": [
+      -0.326446865348307,
+      -3.5943360106825772
+    ],
+    "currentAcceleration": [
+      -6.952553086228219,
+      4.035332808918664
+    ],
+    "targetPosition": [
+      4.012708452328964,
+      2.6157899384131404
+    ],
+    "targetVelocity": [
+      -0.7194123172590121,
+      4.053086618627005
+    ],
+    "targetAcceleration": [
+      -2.940253302056874,
+      -2.370821644348588
+    ],
+    "maxVelocity": [
+      2.3248369179864374,
+      6.824570022608158
+    ],
+    "maxAcceleration": [
+      7.278457055341811,
+      9.432212335258457
+    ],
+    "maxJerk": [
+      15.066326110505209,
+      10.199505787346864
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.841053072644792,
+      -9.015176754733652
+    ],
+    "currentVelocity": [
+      -1.048880543209135,
+      0.5319395400492981
+    ],
+    "currentAcceleration": [
+      -2.5349387476924568,
+      -0.8100421407411025
+    ],
+    "targetPosition": [
+      3.8175356550096176,
+      0.166232561106197
+    ],
+    "targetVelocity": [
+      -3.7170198048753607,
+      1.7711879061076283
+    ],
+    "targetAcceleration": [
+      -2.5585280529970547,
+      5.3171724495643184
+    ],
+    "maxVelocity": [
+      6.951816777169923,
+      3.594264543546431
+    ],
+    "maxAcceleration": [
+      8.361488387779659,
+      7.516148099471592
+    ],
+    "maxJerk": [
+      7.6949402600150405,
+      12.29696592716861
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.29553552296877,
+      -5.3322197351479295
+    ],
+    "currentVelocity": [
+      -0.6638404096300721,
+      5.391705640794572
+    ],
+    "currentAcceleration": [
+      -6.647613689005271,
+      5.785914545340674
+    ],
+    "targetPosition": [
+      8.995689401251198,
+      1.2282060593337576
+    ],
+    "targetVelocity": [
+      -0.7808259535198121,
+      -5.057154045746023
+    ],
+    "targetAcceleration": [
+      4.5836463450757154,
+      -1.2603941718648537
+    ],
+    "maxVelocity": [
+      4.3043908057321705,
+      6.898958753149656
+    ],
+    "maxAcceleration": [
+      6.732455523259318,
+      6.816959664985692
+    ],
+    "maxJerk": [
+      17.308759341394513,
+      15.6267675380961
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.3442582963567311,
+      1.8391471649251407
+    ],
+    "currentVelocity": [
+      0.7870142923818237,
+      -2.00012348994698
+    ],
+    "currentAcceleration": [
+      0.5405291874344096,
+      -2.6910723186005634
+    ],
+    "targetPosition": [
+      2.148873737656933,
+      -4.589106251351169
+    ],
+    "targetVelocity": [
+      -3.203860187736063,
+      4.87041587353197
+    ],
+    "targetAcceleration": [
+      -2.3595854728633765,
+      -0.13086851381126952
+    ],
+    "maxVelocity": [
+      6.028421723856935,
+      7.275364795372541
+    ],
+    "maxAcceleration": [
+      5.2682771550974525,
+      4.485950804466425
+    ],
+    "maxJerk": [
+      16.437169286523115,
+      10.070497738232888
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.325641485391788,
+      5.797758283948159
+    ],
+    "currentVelocity": [
+      -5.641627932134126,
+      -2.2889270846926264
+    ],
+    "currentAcceleration": [
+      3.795288084461659,
+      -7.245188988351876
+    ],
+    "targetPosition": [
+      4.124408266702327,
+      5.9176006810803266
+    ],
+    "targetVelocity": [
+      -5.246710563317169,
+      1.8299265418497965
+    ],
+    "targetAcceleration": [
+      0.4445159958567215,
+      -7.787532242543209
+    ],
+    "maxVelocity": [
+      6.578073510197693,
+      7.43213630657035
+    ],
+    "maxAcceleration": [
+      4.0100616320847005,
+      9.018644086125526
+    ],
+    "maxJerk": [
+      7.01711655717679,
+      11.675986386821638
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.159881133942401,
+      6.412960642361043
+    ],
+    "currentVelocity": [
+      0.4778299062683322,
+      0.2867873683356148
+    ],
+    "currentAcceleration": [
+      -3.400920920504091,
+      -4.26357749092481
+    ],
+    "targetPosition": [
+      5.856821641780368,
+      -8.521571876714846
+    ],
+    "targetVelocity": [
+      -1.4630638803782847,
+      -3.1253548248280922
+    ],
+    "targetAcceleration": [
+      1.1729827046953218,
+      4.522014032656395
+    ],
+    "maxVelocity": [
+      2.6456297186506195,
+      5.020784497305681
+    ],
+    "maxAcceleration": [
+      4.217714240524083,
+      7.715433216954779
+    ],
+    "maxJerk": [
+      13.194006683574235,
+      15.258928379184024
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.203006239630305,
+      -2.764174151627614
+    ],
+    "currentVelocity": [
+      1.9338146307284028,
+      1.5472795635770433
+    ],
+    "currentAcceleration": [
+      -2.298676607413152,
+      -4.227820375080984
+    ],
+    "targetPosition": [
+      -0.9955804659524521,
+      7.009685765347967
+    ],
+    "targetVelocity": [
+      -1.1996654963356286,
+      -2.126812651409077
+    ],
+    "targetAcceleration": [
+      4.294681598997764,
+      2.9910469302311204
+    ],
+    "maxVelocity": [
+      2.7417661566128384,
+      3.11515472695861
+    ],
+    "maxAcceleration": [
+      8.997350910477602,
+      7.73362907573851
+    ],
+    "maxJerk": [
+      15.67733288631174,
+      8.03544255778216
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.123850393112514,
+      -9.199005429377227
+    ],
+    "currentVelocity": [
+      1.065217452385955,
+      -0.6771934422409656
+    ],
+    "currentAcceleration": [
+      -3.3274091742091887,
+      -4.370901975604033
+    ],
+    "targetPosition": [
+      -8.865237768837384,
+      -6.977474260397485
+    ],
+    "targetVelocity": [
+      2.577782480479015,
+      1.129026435226363
+    ],
+    "targetAcceleration": [
+      -0.30461579530420124,
+      -7.425477386614029
+    ],
+    "maxVelocity": [
+      6.900177863713034,
+      7.933032585862884
+    ],
+    "maxAcceleration": [
+      6.840179510457849,
+      9.390656738233282
+    ],
+    "maxJerk": [
+      6.854618134300827,
+      12.267218339986126
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0415898580170193,
+      0.745816651788056
+    ],
+    "currentVelocity": [
+      0.2732124607335349,
+      2.466918440127583
+    ],
+    "currentAcceleration": [
+      -2.116362155878675,
+      3.320933601459389
+    ],
+    "targetPosition": [
+      -5.143994943243273,
+      1.1936478828557373
+    ],
+    "targetVelocity": [
+      1.4885803065617607,
+      0.17376528758940646
+    ],
+    "targetAcceleration": [
+      2.3801078427409976,
+      -0.6026819964035259
+    ],
+    "maxVelocity": [
+      3.206381017716893,
+      3.4149410496258765
+    ],
+    "maxAcceleration": [
+      5.238836996100373,
+      3.538463013307542
+    ],
+    "maxJerk": [
+      18.433010685336818,
+      5.821628423475447
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.108899843546084,
+      -0.49060155096579194
+    ],
+    "currentVelocity": [
+      4.315922924630868,
+      3.616876927681192
+    ],
+    "currentAcceleration": [
+      -6.91476699105175,
+      -6.568224087403149
+    ],
+    "targetPosition": [
+      -5.744412159380272,
+      -5.770942538025143
+    ],
+    "targetVelocity": [
+      1.9369542128439,
+      3.5430397493859154
+    ],
+    "targetAcceleration": [
+      6.275026856688347,
+      6.098132600889263
+    ],
+    "maxVelocity": [
+      5.298466413342693,
+      6.804344042134339
+    ],
+    "maxAcceleration": [
+      8.201546239059624,
+      8.471637401136135
+    ],
+    "maxJerk": [
+      6.615744128118942,
+      7.6941034130558235
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.349988022084824,
+      -6.036465607404969
+    ],
+    "currentVelocity": [
+      -2.869209591085025,
+      5.519149167478302
+    ],
+    "currentAcceleration": [
+      6.80716528115805,
+      0.9223937405577978
+    ],
+    "targetPosition": [
+      8.087321026294717,
+      9.10919093395814
+    ],
+    "targetVelocity": [
+      1.2688507962890023,
+      -5.467534932649547
+    ],
+    "targetAcceleration": [
+      3.243349062801834,
+      1.5965533046832565
+    ],
+    "maxVelocity": [
+      4.681794913098629,
+      6.096590158828798
+    ],
+    "maxAcceleration": [
+      7.7133168157424405,
+      4.872374700905674
+    ],
+    "maxJerk": [
+      8.771183449728754,
+      10.814825587204803
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.654027124382255,
+      -4.4354227430129995
+    ],
+    "currentVelocity": [
+      3.685784002320645,
+      1.755375487109459
+    ],
+    "currentAcceleration": [
+      5.002440147022684,
+      3.7823623861432507
+    ],
+    "targetPosition": [
+      1.0760871996832222,
+      9.94926235641551
+    ],
+    "targetVelocity": [
+      4.038418712284907,
+      1.5717851687760755
+    ],
+    "targetAcceleration": [
+      -1.418206485897045,
+      3.544395733550771
+    ],
+    "maxVelocity": [
+      5.358358871177813,
+      2.1823133278651414
+    ],
+    "maxAcceleration": [
+      7.299968706300909,
+      5.401918368245252
+    ],
+    "maxJerk": [
+      8.389033808964248,
+      18.766247967698163
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0284185555071996,
+      -2.0489310465415596
+    ],
+    "currentVelocity": [
+      -3.450228220222047,
+      -0.03805285055374519
+    ],
+    "currentAcceleration": [
+      -0.9546738406464428,
+      -5.551125608275054
+    ],
+    "targetPosition": [
+      -2.6877498849746484,
+      1.310867294108796
+    ],
+    "targetVelocity": [
+      0.2432261602514263,
+      -0.7103476899882644
+    ],
+    "targetAcceleration": [
+      5.261827867276008,
+      -4.042652579275014
+    ],
+    "maxVelocity": [
+      7.0899253371470685,
+      5.282195190615351
+    ],
+    "maxAcceleration": [
+      7.202568645478042,
+      6.755061410644766
+    ],
+    "maxJerk": [
+      12.459378664657335,
+      10.523846845431317
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.49578188294163716,
+      0.6159485781770329
+    ],
+    "currentVelocity": [
+      5.397426427851542,
+      -1.5685832817885523
+    ],
+    "currentAcceleration": [
+      -3.996300899943046,
+      -2.3253425752640657
+    ],
+    "targetPosition": [
+      -5.999350448433489,
+      5.998076916035524
+    ],
+    "targetVelocity": [
+      3.6955209759214416,
+      2.559058649702581
+    ],
+    "targetAcceleration": [
+      -6.434794457210197,
+      -1.7678550981266743
+    ],
+    "maxVelocity": [
+      5.720177888511682,
+      3.2974171934323078
+    ],
+    "maxAcceleration": [
+      9.122030413832563,
+      4.277178494260148
+    ],
+    "maxJerk": [
+      19.90852242888552,
+      11.047669126303537
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 2,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7302943966192785,
+      -0.33268112212298107
+    ],
+    "currentVelocity": [
+      -2.089596579454291,
+      -1.2356186066083152
+    ],
+    "currentAcceleration": [
+      7.328545678569718,
+      3.9476216425481514
+    ],
+    "targetPosition": [
+      -4.522728157741474,
+      0.5747611779485347
+    ],
+    "targetVelocity": [
+      -1.1004258055144143,
+      4.703632376990387
+    ],
+    "targetAcceleration": [
+      -7.8200665516807755,
+      -4.0574889293295024
+    ],
+    "maxVelocity": [
+      3.789799184180584,
+      5.719002967030163
+    ],
+    "maxAcceleration": [
+      8.928131297553414,
+      6.488581474805654
+    ],
+    "maxJerk": [
+      17.937116749128478,
+      8.872115347397038
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.10776043727667,
+      -6.604823442017622,
+      -9.623278204369656
+    ],
+    "currentVelocity": [
+      -4.485735397621276,
+      -3.12750164827998,
+      -4.149546826655592
+    ],
+    "currentAcceleration": [
+      -3.793350131271242,
+      -3.1760590150929056,
+      -2.5664782867513223
+    ],
+    "targetPosition": [
+      0.7913207415057837,
+      1.3236510370870551,
+      -1.9299809432371653
+    ],
+    "targetVelocity": [
+      -0.6194362776684716,
+      0.25104507800234277,
+      -4.842165410307372
+    ],
+    "targetAcceleration": [
+      8.024101010532931,
+      -2.2938087926386865,
+      -4.317255552297913
+    ],
+    "maxVelocity": [
+      4.94546404079167,
+      4.637952680866072,
+      5.008297386949421
+    ],
+    "maxAcceleration": [
+      8.452920425092199,
+      3.2346086672426866,
+      6.2746102733324705
+    ],
+    "maxJerk": [
+      17.212727612564436,
+      13.940014303141284,
+      17.092818745339976
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.198466925246152,
+      7.828239677844575,
+      -7.688000013788585
+    ],
+    "currentVelocity": [
+      1.723434853049747,
+      1.2798904140210388,
+      -3.14259691674478
+    ],
+    "currentAcceleration": [
+      -4.613073190920112,
+      -4.178105772378553,
+      -2.9532393170958486
+    ],
+    "targetPosition": [
+      2.5536499392863536,
+      9.396121441270022,
+      3.698530996222276
+    ],
+    "targetVelocity": [
+      -1.7243778333680047,
+      1.7826156354916654,
+      1.9870783128820229
+    ],
+    "targetAcceleration": [
+      -6.228356838516879,
+      -4.394191460902431,
+      -1.9754619949070356
+    ],
+    "maxVelocity": [
+      2.7613428854020943,
+      2.7091297554424107,
+      4.090491578622533
+    ],
+    "maxAcceleration": [
+      8.336692750034238,
+      4.8067303289365135,
+      4.47584848905108
+    ],
+    "maxJerk": [
+      12.727050014068382,
+      10.474093474963198,
+      13.127969599115703
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.810988283263143,
+      -3.8078284801227564,
+      -1.5485244422925817
+    ],
+    "currentVelocity": [
+      3.1344596872711517,
+      0.14977615546308343,
+      2.089885890515961
+    ],
+    "currentAcceleration": [
+      -4.373380912777449,
+      6.7059539269323665,
+      1.4223696212770607
+    ],
+    "targetPosition": [
+      -0.5883219471574535,
+      2.7065178544705972,
+      8.586381836437841
+    ],
+    "targetVelocity": [
+      1.569978877025429,
+      4.514957737421456,
+      -0.5898926571506626
+    ],
+    "targetAcceleration": [
+      2.988510718604452,
+      4.381762749198357,
+      0.47308210839282516
+    ],
+    "maxVelocity": [
+      6.1228673226900145,
+      4.880717348981346,
+      7.927263421768996
+    ],
+    "maxAcceleration": [
+      8.861561791674614,
+      7.809062498848332,
+      5.9283150795171125
+    ],
+    "maxJerk": [
+      18.840931863759963,
+      12.844759951792309,
+      7.457571107344215
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.184836996726494,
+      3.6576654087142693,
+      -4.330624311308928
+    ],
+    "currentVelocity": [
+      -1.1051390630593803,
+      -3.929410333765044,
+      -0.25383129082121547
+    ],
+    "currentAcceleration": [
+      6.362141507452271,
+      2.4238552879720627,
+      -4.3853848660739825
+    ],
+    "targetPosition": [
+      -7.860324751920422,
+      1.8506000485664593,
+      -2.5192345227127415
+    ],
+    "targetVelocity": [
+      -1.25440809299538,
+      2.824574221273215,
+      -3.6606263275489885
+    ],
+    "targetAcceleration": [
+      -5.365732702498235,
+      -4.005767210306743,
+      2.393541437374898
+    ],
+    "maxVelocity": [
+      6.799929552550416,
+      7.028580980480379,
+      4.100056072251624
+    ],
+    "maxAcceleration": [
+      6.935639414397488,
+      4.947650474307437,
+      6.959246017646068
+    ],
+    "maxJerk": [
+      18.3259299857102,
+      10.497955755189347,
+      7.660503824401484
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.6308272260719825,
+      -2.2901470816382936,
+      -4.5848683965776456
+    ],
+    "currentVelocity": [
+      4.301729943441961,
+      -0.1778700314563384,
+      0.09427548110240647
+    ],
+    "currentAcceleration": [
+      4.856813778029809,
+      8.320425190976888,
+      3.5134775443455872
+    ],
+    "targetPosition": [
+      8.088677834538554,
+      9.465304954998569,
+      -4.710797871270723
+    ],
+    "targetVelocity": [
+      4.820565858139219,
+      4.40745915924041,
+      -1.104088323050941
+    ],
+    "targetAcceleration": [
+      4.459778061111442,
+      -2.0205798514328963,
+      -1.726705956386673
+    ],
+    "maxVelocity": [
+      6.9180329306280655,
+      6.9436684745370965,
+      3.351616915114578
+    ],
+    "maxAcceleration": [
+      7.268417470379851,
+      9.505909488218052,
+      8.319559369171667
+    ],
+    "maxJerk": [
+      7.804555279280925,
+      9.848087274887945,
+      13.806042661727979
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.2955081385977909,
+      9.899875372298442,
+      -7.147695868842696
+    ],
+    "currentVelocity": [
+      4.440624430599721,
+      2.366906637297851,
+      2.5648638715588836
+    ],
+    "currentAcceleration": [
+      -2.928875927583263,
+      3.444510807897209,
+      4.43716443312051
+    ],
+    "targetPosition": [
+      -4.944459724520929,
+      -4.732193668521174,
+      -7.627336877651825
+    ],
+    "targetVelocity": [
+      -1.7305473257127373,
+      -3.541345720799201,
+      5.269077217205274
+    ],
+    "targetAcceleration": [
+      -6.7093775068005055,
+      -4.291609281783034,
+      3.377961697698061
+    ],
+    "maxVelocity": [
+      5.864811487348883,
+      6.207437448274585,
+      5.4137083688928955
+    ],
+    "maxAcceleration": [
+      9.453977180637585,
+      4.416768449695677,
+      7.594821529438852
+    ],
+    "maxJerk": [
+      14.233922866877768,
+      15.510367823005216,
+      7.361153860283425
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.683756328151448,
+      -5.045262945189981,
+      -1.6670920874282498
+    ],
+    "currentVelocity": [
+      2.458783945002427,
+      -3.9058249114651398,
+      -2.7009496702837215
+    ],
+    "currentAcceleration": [
+      5.43105820985906,
+      3.2473842164903868,
+      -6.800228892937563
+    ],
+    "targetPosition": [
+      -8.661438450544562,
+      -3.210386717235063,
+      -9.023439693038743
+    ],
+    "targetVelocity": [
+      1.7146894242276565,
+      -4.472164879459379,
+      0.4358239773125083
+    ],
+    "targetAcceleration": [
+      -4.9751106429756025,
+      -4.228609766749671,
+      -1.063982257139724
+    ],
+    "maxVelocity": [
+      3.608195399824454,
+      5.2192003651446175,
+      5.762394374707206
+    ],
+    "maxAcceleration": [
+      9.142532804802364,
+      4.779503104509152,
+      9.962119816589734
+    ],
+    "maxJerk": [
+      19.798485872668973,
+      15.550687101499435,
+      8.666170644065717
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.875278075038199,
+      3.8989479495390977,
+      5.2127511100642305
+    ],
+    "currentVelocity": [
+      -0.2140747556490279,
+      -4.970448680307678,
+      -5.073375170167296
+    ],
+    "currentAcceleration": [
+      3.8359474613399698,
+      0.5991457671943117,
+      5.5652042330118
+    ],
+    "targetPosition": [
+      -2.740838430343975,
+      -0.12333861559240056,
+      7.4247067319987465
+    ],
+    "targetVelocity": [
+      0.6693779526605752,
+      -2.054079966067649,
+      3.7021691944322974
+    ],
+    "targetAcceleration": [
+      5.699237487327084,
+      -3.998242126641337,
+      0.8531754046312061
+    ],
+    "maxVelocity": [
+      7.138024375917705,
+      5.099658747720369,
+      5.573270896797778
+    ],
+    "maxAcceleration": [
+      7.0437249038199,
+      5.661295437317374,
+      6.642121663157491
+    ],
+    "maxJerk": [
+      6.425602864465576,
+      17.884678324140705,
+      18.400260975089225
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.7010036389533365,
+      -1.310980095665462,
+      -6.979497095978329
+    ],
+    "currentVelocity": [
+      -2.816995943534226,
+      -2.5537020685580494,
+      1.896325195562921
+    ],
+    "currentAcceleration": [
+      4.259138277351768,
+      0.7250167001201069,
+      -0.655268633858122
+    ],
+    "targetPosition": [
+      -3.2149455452227134,
+      -4.746008783095359,
+      -8.311610405469779
+    ],
+    "targetVelocity": [
+      0.4210366790007205,
+      0.3261346185169707,
+      0.4132723462303245
+    ],
+    "targetAcceleration": [
+      -2.4071906886780807,
+      0.9560111439770749,
+      -2.6191483949682954
+    ],
+    "maxVelocity": [
+      5.217472334657538,
+      3.851686478167756,
+      2.8019421803900744
+    ],
+    "maxAcceleration": [
+      8.813125213839577,
+      4.889478316373785,
+      6.396056652401995
+    ],
+    "maxJerk": [
+      10.627461816583889,
+      9.224528132250011,
+      7.690586884159296
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.5841676892767,
+      2.591119493521658,
+      -3.8050109315459952
+    ],
+    "currentVelocity": [
+      1.3777474704871802,
+      5.79614458282753,
+      0.7801524151110586
+    ],
+    "currentAcceleration": [
+      -1.6023563597423331,
+      0.5266919730256525,
+      0.7118410469982352
+    ],
+    "targetPosition": [
+      -8.78469214824057,
+      -8.26716709838247,
+      2.3685431774088244
+    ],
+    "targetVelocity": [
+      -0.6765558854256482,
+      -4.595846787233562,
+      4.326956969119127
+    ],
+    "targetAcceleration": [
+      -3.0220633642807386,
+      -1.9664034704660271,
+      1.7700262444037778
+    ],
+    "maxVelocity": [
+      2.3070598878817314,
+      7.551477270907139,
+      5.8612597189953135
+    ],
+    "maxAcceleration": [
+      4.097664396984813,
+      5.011050772783504,
+      7.848211020639641
+    ],
+    "maxJerk": [
+      9.542804843370075,
+      14.766501783531588,
+      18.656424677807408
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.375963492643367,
+      -7.87017824042503,
+      -2.5775360285906457
+    ],
+    "currentVelocity": [
+      -0.34663469581140927,
+      -2.8967637440761003,
+      -0.4484699547794664
+    ],
+    "currentAcceleration": [
+      5.114957848278518,
+      1.8175024220439218,
+      3.5415293940836383
+    ],
+    "targetPosition": [
+      -7.918814027526988,
+      0.97379052450313,
+      8.248558968231478
+    ],
+    "targetVelocity": [
+      -4.067021348928618,
+      1.501566594332819,
+      2.786705901063282
+    ],
+    "targetAcceleration": [
+      -4.29532279137779,
+      -3.0110443925502377,
+      0.6451124953532226
+    ],
+    "maxVelocity": [
+      6.678227922660642,
+      6.159536316566256,
+      4.683782392276698
+    ],
+    "maxAcceleration": [
+      5.845881116715587,
+      4.0410794444373845,
+      4.419248672424218
+    ],
+    "maxJerk": [
+      9.693759605496076,
+      17.851175069591655,
+      9.573084643799293
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.625698185464454,
+      -7.2242897613788015,
+      -2.54474690904215
+    ],
+    "currentVelocity": [
+      -2.0920672362767836,
+      -1.9280675106420584,
+      -1.8856592934758538
+    ],
+    "currentAcceleration": [
+      -0.9802838056009429,
+      2.8170031439754863,
+      5.778547399108309
+    ],
+    "targetPosition": [
+      -9.043695255580273,
+      -8.738558429993207,
+      8.153505676181542
+    ],
+    "targetVelocity": [
+      0.3465158135068842,
+      0.5493528420614506,
+      -2.6400179833266737
+    ],
+    "targetAcceleration": [
+      -3.910910836407986,
+      -3.5195213317038734,
+      -8.384754611175028
+    ],
+    "maxVelocity": [
+      2.201288296394451,
+      2.004092196433316,
+      7.766171551482759
+    ],
+    "maxAcceleration": [
+      3.9819066244240977,
+      4.601681951458907,
+      9.205937570316106
+    ],
+    "maxJerk": [
+      5.267509037308684,
+      18.47337622780851,
+      11.80769216172561
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.311621684399832,
+      7.4379858272209205,
+      -6.213175367041426
+    ],
+    "currentVelocity": [
+      2.3248315135066155,
+      -0.3150868826356674,
+      1.532225160242258
+    ],
+    "currentAcceleration": [
+      -3.9145780513979442,
+      -1.0752875484988387,
+      -0.5020014578543757
+    ],
+    "targetPosition": [
+      -4.176029275907441,
+      1.7290635838847397,
+      -8.387326290791975
+    ],
+    "targetVelocity": [
+      3.8848784937658944,
+      1.2267566110874264,
+      2.9833665330280335
+    ],
+    "targetAcceleration": [
+      5.113516670269014,
+      5.83223714824695,
+      -2.288838570851963
+    ],
+    "maxVelocity": [
+      4.331225640566233,
+      2.001972175201721,
+      3.209824616158884
+    ],
+    "maxAcceleration": [
+      6.754591498454371,
+      5.9697288982439325,
+      5.5790359328112045
+    ],
+    "maxJerk": [
+      11.73673141984034,
+      17.32217665760769,
+      17.604834617119394
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.279120397665309,
+      3.4582188446891937,
+      8.742962886363234
+    ],
+    "currentVelocity": [
+      0.7883913097286364,
+      -2.306123434914369,
+      -2.807084435611441
+    ],
+    "currentAcceleration": [
+      4.151241906259424,
+      2.700525364619158,
+      -5.700684751261463
+    ],
+    "targetPosition": [
+      8.487202577247295,
+      -3.9333229742999816,
+      7.344649891312901
+    ],
+    "targetVelocity": [
+      1.070420473097478,
+      -5.166982513677829,
+      -2.247204432272061
+    ],
+    "targetAcceleration": [
+      0.8481425606247228,
+      0.26662862903243223,
+      1.840515507807707
+    ],
+    "maxVelocity": [
+      2.9745960166666636,
+      5.598667848729633,
+      4.929651223627014
+    ],
+    "maxAcceleration": [
+      6.809976918568285,
+      4.744762329822726,
+      5.903256721645632
+    ],
+    "maxJerk": [
+      13.78513261187451,
+      14.897389632280207,
+      9.7171631636621
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.815628901439052,
+      -2.8635218196180556,
+      -5.802618972921472
+    ],
+    "currentVelocity": [
+      2.3464093280914096,
+      -0.36470733668227484,
+      -0.8143012757858927
+    ],
+    "currentAcceleration": [
+      -4.840507842392476,
+      0.27651411769662637,
+      -3.0411273462060633
+    ],
+    "targetPosition": [
+      -5.48650021371113,
+      -9.748755804511646,
+      -3.9968725404568506
+    ],
+    "targetVelocity": [
+      1.6841440007140482,
+      -0.8625339593007126,
+      -3.339479683847774
+    ],
+    "targetAcceleration": [
+      -1.1467286891543482,
+      3.62912721568574,
+      0.5645149613391789
+    ],
+    "maxVelocity": [
+      3.380912217358844,
+      2.050504490332232,
+      4.367839414039749
+    ],
+    "maxAcceleration": [
+      8.004532847612964,
+      5.40197069429529,
+      5.784868724408131
+    ],
+    "maxJerk": [
+      10.971089347289738,
+      14.808378124356814,
+      13.814643351191194
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0815679962199347,
+      7.472175890109739,
+      -9.561187893980744
+    ],
+    "currentVelocity": [
+      2.696000409652685,
+      -4.486486205515318,
+      -3.4483690833240663
+    ],
+    "currentAcceleration": [
+      -0.681013240201704,
+      -0.7041644958258089,
+      5.850623054954701
+    ],
+    "targetPosition": [
+      -0.6512768666204831,
+      -1.8387066398222078,
+      -5.46707168340993
+    ],
+    "targetVelocity": [
+      -1.9577707007044851,
+      1.7089880854824262,
+      2.50664232756744
+    ],
+    "targetAcceleration": [
+      -6.609824893311996,
+      0.8685745556162927,
+      -3.566875049227402
+    ],
+    "maxVelocity": [
+      5.713544769199567,
+      4.647550104285131,
+      6.802037635413403
+    ],
+    "maxAcceleration": [
+      7.613951525229516,
+      3.6482923499199127,
+      7.038100465523289
+    ],
+    "maxJerk": [
+      16.62155077196728,
+      11.624333693471465,
+      13.027162385365234
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.564366660148847,
+      6.444808677725639,
+      -0.7565985129466171
+    ],
+    "currentVelocity": [
+      -1.6490089981443536,
+      0.15584917818767074,
+      2.1920654029228475
+    ],
+    "currentAcceleration": [
+      -0.3669583056192667,
+      -1.7786560638034574,
+      0.7879897621022334
+    ],
+    "targetPosition": [
+      8.326030343318202,
+      8.564148423582253,
+      1.1910642521741757
+    ],
+    "targetVelocity": [
+      -0.5640360721167124,
+      -0.9657696503212903,
+      2.1506358728305655
+    ],
+    "targetAcceleration": [
+      1.6099538084992013,
+      -1.7735829087735642,
+      5.1201980596678
+    ],
+    "maxVelocity": [
+      5.3092926737815676,
+      2.1621440226736053,
+      3.548248459418873
+    ],
+    "maxAcceleration": [
+      3.3811705590626144,
+      4.06214645740598,
+      8.566360079531107
+    ],
+    "maxJerk": [
+      6.110729697751251,
+      14.815873798912216,
+      9.947588730668212
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.4319437055284165,
+      4.12232949277497,
+      -9.898821502363901
+    ],
+    "currentVelocity": [
+      1.5477268856743738,
+      -1.518732242307658,
+      -1.725729441345492
+    ],
+    "currentAcceleration": [
+      3.739152162709617,
+      6.764218456651288,
+      -1.9905014170372075
+    ],
+    "targetPosition": [
+      8.869051887389261,
+      -1.495654449659039,
+      -9.359932285301893
+    ],
+    "targetVelocity": [
+      -4.476473691458639,
+      -1.0101427602612023,
+      -2.0829999124873755
+    ],
+    "targetAcceleration": [
+      0.22168212700103496,
+      -6.0556322580458,
+      6.774429876722287
+    ],
+    "maxVelocity": [
+      7.985112416986569,
+      2.0751124414866817,
+      6.536055672464679
+    ],
+    "maxAcceleration": [
+      9.28619147038515,
+      6.99277530195979,
+      9.529898657356771
+    ],
+    "maxJerk": [
+      12.180190662469144,
+      19.564340061683687,
+      7.496157946420311
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.103158531975332,
+      2.787945782698852,
+      -8.725375121401521
+    ],
+    "currentVelocity": [
+      -4.519040755510829,
+      4.235459132140696,
+      -2.180481071373261
+    ],
+    "currentAcceleration": [
+      0.29487782721552236,
+      -1.8421155210335232,
+      3.2108986432302977
+    ],
+    "targetPosition": [
+      -0.2557379548225551,
+      5.363984423480122,
+      -4.460772411796476
+    ],
+    "targetVelocity": [
+      1.977949949592535,
+      -0.3185097902148577,
+      2.723863708344328
+    ],
+    "targetAcceleration": [
+      -4.255195739381503,
+      0.28140584338265384,
+      1.4996267153694358
+    ],
+    "maxVelocity": [
+      5.522642661341995,
+      5.643766086897396,
+      3.954336177799603
+    ],
+    "maxAcceleration": [
+      7.78619659093445,
+      4.260486472731323,
+      6.580242659253491
+    ],
+    "maxJerk": [
+      7.205259468562671,
+      17.85954209877137,
+      8.420276362972269
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.10601304929263478,
+      -0.1903343272226401,
+      3.330192161288174
+    ],
+    "currentVelocity": [
+      -4.0618136241509735,
+      -4.267159034699107,
+      -5.256332578303525
+    ],
+    "currentAcceleration": [
+      5.458580080590859,
+      -1.907880503982767,
+      6.348521297509
+    ],
+    "targetPosition": [
+      7.990904483632281,
+      5.155947955681617,
+      5.594467749531491
+    ],
+    "targetVelocity": [
+      2.1857759125490475,
+      -2.1491195758935526,
+      0.4763180304885868
+    ],
+    "targetAcceleration": [
+      -0.5572954143187792,
+      2.2216740147604703,
+      2.4527488028784212
+    ],
+    "maxVelocity": [
+      5.2616447848012555,
+      5.592602518606083,
+      6.006658921698751
+    ],
+    "maxAcceleration": [
+      6.912223051991115,
+      9.111175060356414,
+      8.188790475138198
+    ],
+    "maxJerk": [
+      15.780784628871395,
+      9.667431078828029,
+      18.405142879732
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.538141196640094,
+      -6.791217450097696,
+      -3.121879914605059
+    ],
+    "currentVelocity": [
+      2.0638455516854988,
+      0.6684040654318473,
+      -4.004122480951047
+    ],
+    "currentAcceleration": [
+      -2.8179055865965017,
+      -7.229646767117083,
+      5.456026522806713
+    ],
+    "targetPosition": [
+      -4.194185195217608,
+      1.095386814462767,
+      -4.943723995104532
+    ],
+    "targetVelocity": [
+      0.5584780829926919,
+      -0.6938799914245388,
+      -5.894693870450614
+    ],
+    "targetAcceleration": [
+      -1.210493507172668,
+      -7.670918897656692,
+      -1.0582065315701161
+    ],
+    "maxVelocity": [
+      4.193017591611173,
+      3.689380892199954,
+      6.590588200262892
+    ],
+    "maxAcceleration": [
+      5.847540482920088,
+      9.238497381005175,
+      5.653654954393431
+    ],
+    "maxJerk": [
+      5.848347899106797,
+      9.883125937470325,
+      10.720013045083872
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7422021903327636,
+      -5.747221178601352,
+      -3.6178497469642394
+    ],
+    "currentVelocity": [
+      3.3142615428839886,
+      -1.7471334530809557,
+      -0.9643472386609471
+    ],
+    "currentAcceleration": [
+      -0.7844902561558129,
+      2.8746495088092114,
+      1.669730132957401
+    ],
+    "targetPosition": [
+      -7.213683457139705,
+      0.19935046454480698,
+      -2.111117874756241
+    ],
+    "targetVelocity": [
+      -6.091220916482791,
+      -3.919300106106066,
+      -3.268996678024623
+    ],
+    "targetAcceleration": [
+      -6.2522466155471506,
+      -0.8664323457413028,
+      -0.7182227685639617
+    ],
+    "maxVelocity": [
+      6.256530093359901,
+      6.785764070560706,
+      3.271075171064677
+    ],
+    "maxAcceleration": [
+      8.195012970655618,
+      6.394701504932035,
+      7.402144053937096
+    ],
+    "maxJerk": [
+      18.38781710005226,
+      11.769149117953528,
+      6.432784122844851
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.22805679327999,
+      -7.53700902288668,
+      2.3652277378157684
+    ],
+    "currentVelocity": [
+      3.638449586224465,
+      0.8527125601850964,
+      -0.6259931869761575
+    ],
+    "currentAcceleration": [
+      0.408276960070058,
+      -2.445076664931225,
+      1.753787778819187
+    ],
+    "targetPosition": [
+      -5.881239862983493,
+      -3.6410569581945023,
+      8.20489198294431
+    ],
+    "targetVelocity": [
+      3.286377132769239,
+      1.0479665124356385,
+      2.3147321719554323
+    ],
+    "targetAcceleration": [
+      1.8380414674651373,
+      5.927840188345523,
+      -0.8294286024028446
+    ],
+    "maxVelocity": [
+      4.026453169622959,
+      3.1277779553440874,
+      2.875485640861913
+    ],
+    "maxAcceleration": [
+      6.8296862508626734,
+      7.6237114466225036,
+      3.395715120235148
+    ],
+    "maxJerk": [
+      8.023908940310346,
+      10.867409322339512,
+      16.94647814898973
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.9014644310574687,
+      -1.4623116410250514,
+      2.7349339776613224
+    ],
+    "currentVelocity": [
+      1.9113964710789046,
+      -5.320395043341709,
+      -6.806865372641945
+    ],
+    "currentAcceleration": [
+      8.922642562622595,
+      -3.920079799160118,
+      -3.2089281446827034
+    ],
+    "targetPosition": [
+      -2.489516271571608,
+      -5.218553676208655,
+      -6.517168619741565
+    ],
+    "targetVelocity": [
+      -5.344600003877657,
+      -4.104800953917585,
+      0.9010365529986988
+    ],
+    "targetAcceleration": [
+      -6.04793599110679,
+      4.3204322472631045,
+      -0.8455795561691906
+    ],
+    "maxVelocity": [
+      7.2293716020639165,
+      7.9290821752751945,
+      7.598104878596139
+    ],
+    "maxAcceleration": [
+      9.711783273543748,
+      9.53343383266405,
+      4.501085286993149
+    ],
+    "maxJerk": [
+      7.497665926422558,
+      7.200452024803322,
+      18.910202906314197
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.927000760986216,
+      8.756617937440662,
+      8.474318909727103
+    ],
+    "currentVelocity": [
+      -0.5126912393749272,
+      -0.1450832838213847,
+      -4.762147604231559
+    ],
+    "currentAcceleration": [
+      -2.8864357735652133,
+      3.5032614276535394,
+      2.091821469587945
+    ],
+    "targetPosition": [
+      -2.170681272585533,
+      -6.710512705154066,
+      -9.693545932664735
+    ],
+    "targetVelocity": [
+      2.2405821910949815,
+      -3.373657837483451,
+      -4.496603021115806
+    ],
+    "targetAcceleration": [
+      1.400045494838487,
+      -2.7750724471012824,
+      -5.643489764282187
+    ],
+    "maxVelocity": [
+      7.272980477988892,
+      7.449594743043875,
+      5.5778208257428075
+    ],
+    "maxAcceleration": [
+      4.20891134647316,
+      6.473901694661425,
+      6.729127623053953
+    ],
+    "maxJerk": [
+      17.28230877231886,
+      10.483875703619937,
+      19.24772672458629
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.799927474882576,
+      -1.6982596595663715,
+      -0.1876810370993418
+    ],
+    "currentVelocity": [
+      3.4386845330248894,
+      4.376127994972306,
+      2.2827155408351816
+    ],
+    "currentAcceleration": [
+      3.5422253295719113,
+      -7.7301105283954215,
+      -1.477901299495766
+    ],
+    "targetPosition": [
+      -2.293254585681554,
+      -4.860051624403814,
+      -5.432243222872826
+    ],
+    "targetVelocity": [
+      -1.0656554907665052,
+      5.5712422807535695,
+      1.1575454770626532
+    ],
+    "targetAcceleration": [
+      1.8758914102346722,
+      2.3195144713486684,
+      2.600110467423759
+    ],
+    "maxVelocity": [
+      4.1198884947505645,
+      5.750247846459006,
+      2.4461147142780675
+    ],
+    "maxAcceleration": [
+      9.618897406550767,
+      9.606208840909002,
+      8.849357496599053
+    ],
+    "maxJerk": [
+      11.916396608765687,
+      5.201879033691941,
+      6.825133175914155
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.186421854362972,
+      -1.4214310506291365,
+      -8.520880835876811
+    ],
+    "currentVelocity": [
+      -4.641411843812039,
+      3.859768634398682,
+      4.225625928903786
+    ],
+    "currentAcceleration": [
+      -4.750201345823886,
+      -8.794845816201244,
+      -1.710363495327429
+    ],
+    "targetPosition": [
+      3.8537130289753527,
+      -4.585980621933821,
+      -9.222762805343656
+    ],
+    "targetVelocity": [
+      4.515610893964693,
+      -5.358930398599921,
+      1.7734776810873596
+    ],
+    "targetAcceleration": [
+      -3.2627511980712347,
+      -5.803090325290205,
+      -0.03749002761675113
+    ],
+    "maxVelocity": [
+      7.917410156109657,
+      5.72298388398236,
+      5.1146666101806
+    ],
+    "maxAcceleration": [
+      5.865695379272671,
+      9.460502033313212,
+      3.7879116522658824
+    ],
+    "maxJerk": [
+      7.416814339594776,
+      16.439766563031213,
+      11.451855598986734
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.3227648902618174,
+      -7.463677939253128,
+      1.6069650225212566
+    ],
+    "currentVelocity": [
+      1.7938248496090008,
+      -6.143304579695585,
+      -0.24680562897057357
+    ],
+    "currentAcceleration": [
+      0.13827961586748128,
+      6.038882467287324,
+      6.91502550505265
+    ],
+    "targetPosition": [
+      7.601848725049798,
+      -3.5109320330510707,
+      1.0943190086959564
+    ],
+    "targetVelocity": [
+      2.7334333837573226,
+      1.9129379303104663,
+      -2.4453620335512003
+    ],
+    "targetAcceleration": [
+      0.5222254380800608,
+      6.586959207444205,
+      5.533498200268502
+    ],
+    "maxVelocity": [
+      4.316467255748571,
+      6.631493556943489,
+      5.5263073279099695
+    ],
+    "maxAcceleration": [
+      5.415750942471044,
+      7.518034906335699,
+      8.763579300113486
+    ],
+    "maxJerk": [
+      12.715434142819174,
+      17.58724952610826,
+      9.53618354095868
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.690643200036298,
+      8.806345134071854,
+      3.541184129918948
+    ],
+    "currentVelocity": [
+      1.2336222143872342,
+      0.3823806001078207,
+      2.8992206048743565
+    ],
+    "currentAcceleration": [
+      -1.6831798752045228,
+      1.8663710141225796,
+      1.551544842824642
+    ],
+    "targetPosition": [
+      -0.7616905399239506,
+      5.981462820825584,
+      -5.291432423888775
+    ],
+    "targetVelocity": [
+      1.3711256019352196,
+      -1.1753345430473545,
+      2.385976136075243
+    ],
+    "targetAcceleration": [
+      -0.8620430645086254,
+      2.6156935863959196,
+      2.855839255406779
+    ],
+    "maxVelocity": [
+      2.508156165764929,
+      4.446613621772062,
+      4.699154210529954
+    ],
+    "maxAcceleration": [
+      3.330850425209271,
+      3.06121606471618,
+      3.6039679516934093
+    ],
+    "maxJerk": [
+      8.053517828118686,
+      16.34350419554033,
+      18.642794266664215
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.507313094578695,
+      2.1477159664625862,
+      -3.751077013919155
+    ],
+    "currentVelocity": [
+      -6.344911479502117,
+      0.8555142607626101,
+      -2.987108669426934
+    ],
+    "currentAcceleration": [
+      -0.9333434680647401,
+      -4.0145388647887925,
+      -4.570763964161532
+    ],
+    "targetPosition": [
+      -6.290110635169266,
+      -5.004928172673413,
+      -4.348214766592042
+    ],
+    "targetVelocity": [
+      3.8452737741882927,
+      -0.12151762910664421,
+      -3.83595439277707
+    ],
+    "targetAcceleration": [
+      -1.896457638230479,
+      -0.15752708369267854,
+      4.756648587492791
+    ],
+    "maxVelocity": [
+      7.992064856429298,
+      2.0662070120894285,
+      6.074698764082451
+    ],
+    "maxAcceleration": [
+      3.1272176857213996,
+      4.27160665461333,
+      6.863999676734636
+    ],
+    "maxJerk": [
+      10.528444699088293,
+      9.395969801875678,
+      17.303180211500127
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.863013362677135,
+      6.348121552389031,
+      -1.195676988153231
+    ],
+    "currentVelocity": [
+      0.8518480993361326,
+      -0.29416537806394194,
+      -3.362744980181951
+    ],
+    "currentAcceleration": [
+      -3.7883638212530513,
+      3.6779540754354922,
+      2.8536315474429843
+    ],
+    "targetPosition": [
+      -9.485485112795784,
+      -0.9077753159017234,
+      -0.36699153085470826
+    ],
+    "targetVelocity": [
+      2.23536673693829,
+      1.0638820259219819,
+      -2.900460457562131
+    ],
+    "targetAcceleration": [
+      5.223250978857271,
+      2.7561560708214543,
+      -2.0831479325988607
+    ],
+    "maxVelocity": [
+      5.5199080160120335,
+      3.6841410916428594,
+      6.953876694314575
+    ],
+    "maxAcceleration": [
+      5.7322759166303445,
+      5.821459508857199,
+      3.38556743524612
+    ],
+    "maxJerk": [
+      19.70799534508022,
+      13.542564616295232,
+      17.95744162854546
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.432615596289647,
+      -9.585142184332426,
+      2.192341029821236
+    ],
+    "currentVelocity": [
+      -1.7148245732797744,
+      -2.1703171709481577,
+      -3.2553222551180743
+    ],
+    "currentAcceleration": [
+      -3.844942114451772,
+      -5.228498620910837,
+      -3.679107067022149
+    ],
+    "targetPosition": [
+      0.7954488762357474,
+      -4.198872055506795,
+      8.273071340883686
+    ],
+    "targetVelocity": [
+      -1.8784572763800955,
+      -6.125296296646161,
+      -4.344768678985133
+    ],
+    "targetAcceleration": [
+      -1.3660893695605392,
+      -0.1910001404967483,
+      2.7574120841059235
+    ],
+    "maxVelocity": [
+      3.662811825887754,
+      6.404768917099248,
+      6.137114221577418
+    ],
+    "maxAcceleration": [
+      4.366197009664759,
+      6.857373327495544,
+      6.187744085157484
+    ],
+    "maxJerk": [
+      10.948079902563562,
+      5.504661825759587,
+      8.010819634348854
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.131041306254865,
+      3.877561579174147,
+      6.823343920412668
+    ],
+    "currentVelocity": [
+      2.2794994261229555,
+      4.3441425890079,
+      1.177331960893576
+    ],
+    "currentAcceleration": [
+      2.982451094493368,
+      -2.9821031915467,
+      -6.6831834252737545
+    ],
+    "targetPosition": [
+      3.82622389727044,
+      9.808975163949786,
+      -7.757931644215786
+    ],
+    "targetVelocity": [
+      2.5233669055197177,
+      1.236966878734246,
+      -1.6858780696836
+    ],
+    "targetAcceleration": [
+      -2.4578308470670476,
+      1.8185190112617846,
+      0.6888097698041431
+    ],
+    "maxVelocity": [
+      3.363890546198269,
+      4.414957646434299,
+      3.813807750166614
+    ],
+    "maxAcceleration": [
+      3.55989023629017,
+      4.035576393901956,
+      8.48866499724772
+    ],
+    "maxJerk": [
+      13.159465270610394,
+      17.347839053705194,
+      7.889951516363031
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.871529917171198,
+      -1.9937108897888223,
+      0.2904354289964708
+    ],
+    "currentVelocity": [
+      -3.233692007211606,
+      -5.649952237064803,
+      -0.869518352729211
+    ],
+    "currentAcceleration": [
+      -2.0934689908093,
+      4.372290050833389,
+      -2.9214419828614595
+    ],
+    "targetPosition": [
+      7.371152550346437,
+      5.666738262225836,
+      1.2004155272903017
+    ],
+    "targetVelocity": [
+      -1.5034435584881076,
+      4.589454457375716,
+      0.8927157683736926
+    ],
+    "targetAcceleration": [
+      -1.0079611292306234,
+      4.449967941469668,
+      0.9331683367778147
+    ],
+    "maxVelocity": [
+      4.5165586432184694,
+      5.922492035032882,
+      2.230702318821044
+    ],
+    "maxAcceleration": [
+      6.663634933202164,
+      5.6833257260755925,
+      6.972577286256593
+    ],
+    "maxJerk": [
+      17.146059411623447,
+      12.93167051990691,
+      15.878716748699466
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.2278769476675357,
+      -4.317058365178608,
+      3.0679069507877195
+    ],
+    "currentVelocity": [
+      -3.9371351876800658,
+      3.853991785915686,
+      -1.344591291009778
+    ],
+    "currentAcceleration": [
+      0.2788240667591717,
+      -3.0944744102556867,
+      2.32216091260187
+    ],
+    "targetPosition": [
+      -3.7757656679821654,
+      -0.5743202701188999,
+      4.891678194605582
+    ],
+    "targetVelocity": [
+      -1.1768498216973455,
+      0.9618231034913522,
+      3.631911909974341
+    ],
+    "targetAcceleration": [
+      3.995017142262763,
+      -4.6889072919604775,
+      -2.738237188954575
+    ],
+    "maxVelocity": [
+      5.130810685804196,
+      4.342632724573062,
+      3.9761962071421166
+    ],
+    "maxAcceleration": [
+      4.549827627242439,
+      6.378245860861346,
+      5.317941595732783
+    ],
+    "maxJerk": [
+      12.63770664851048,
+      13.915621866282375,
+      16.27535098162891
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.493447542174906,
+      -9.300193035337081,
+      -6.735174965731776
+    ],
+    "currentVelocity": [
+      -3.688830742575996,
+      -2.964085637730299,
+      2.0531429402872643
+    ],
+    "currentAcceleration": [
+      7.543712738788473,
+      -1.3016187025950003,
+      -2.0862691860183444
+    ],
+    "targetPosition": [
+      1.991350284082575,
+      -8.712294635150863,
+      2.260247899019099
+    ],
+    "targetVelocity": [
+      -0.3219660595028424,
+      6.147696676651877,
+      2.6385869279720735
+    ],
+    "targetAcceleration": [
+      -0.6220554510898051,
+      7.5946740852881955,
+      -0.5067992754157373
+    ],
+    "maxVelocity": [
+      5.001977543811648,
+      6.4172492933813094,
+      2.65066529155371
+    ],
+    "maxAcceleration": [
+      9.45946784289834,
+      9.733057449855833,
+      9.98721978568031
+    ],
+    "maxJerk": [
+      15.504440741547743,
+      11.47945536169704,
+      14.299471087604033
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.6442746063018046,
+      -0.044024278748056034,
+      1.1117316878954888
+    ],
+    "currentVelocity": [
+      -2.12248146857147,
+      -4.290500746451088,
+      5.072266787646439
+    ],
+    "currentAcceleration": [
+      0.7403527414075848,
+      0.5671050451080495,
+      -3.89804030124217
+    ],
+    "targetPosition": [
+      5.235063939250404,
+      -0.5164383534350705,
+      -0.9660468733027052
+    ],
+    "targetVelocity": [
+      2.499704908112342,
+      -0.5459265798876354,
+      4.389346181296893
+    ],
+    "targetAcceleration": [
+      1.9483246812893062,
+      -3.3386300055246307,
+      -2.9157465428960734
+    ],
+    "maxVelocity": [
+      3.7865925490454924,
+      6.054863151432904,
+      6.614161316014996
+    ],
+    "maxAcceleration": [
+      4.387531342030556,
+      4.317125841082806,
+      8.774046115021095
+    ],
+    "maxJerk": [
+      14.131951160762915,
+      15.538875226826736,
+      18.60227281603091
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.570166190307871,
+      3.76966081573614,
+      3.522587945871919
+    ],
+    "currentVelocity": [
+      -1.1964126683414578,
+      1.283426310763478,
+      -1.9271905218121532
+    ],
+    "currentAcceleration": [
+      1.137313898660313,
+      2.468453436928778,
+      3.864074785653041
+    ],
+    "targetPosition": [
+      -3.203342896307344,
+      -4.201063003135534,
+      0.4548845252061575
+    ],
+    "targetVelocity": [
+      -0.9384797308139985,
+      1.6758132854591241,
+      -1.082412543212144
+    ],
+    "targetAcceleration": [
+      -7.4346977047487055,
+      3.2091081492674594,
+      3.2876085785226463
+    ],
+    "maxVelocity": [
+      2.9177490063425378,
+      3.401316093803375,
+      2.095057531236492
+    ],
+    "maxAcceleration": [
+      8.41541212251785,
+      7.641196322407774,
+      5.781948740631942
+    ],
+    "maxJerk": [
+      16.389687083629504,
+      10.986320909794905,
+      15.60467894921793
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.572333385887513,
+      9.933205170089707,
+      4.890176420265995
+    ],
+    "currentVelocity": [
+      -4.260773894328913,
+      0.6402894421095073,
+      -0.964163096104313
+    ],
+    "currentAcceleration": [
+      -1.9596771462027194,
+      -2.6157359827853837,
+      -4.1590738352085665
+    ],
+    "targetPosition": [
+      -5.08406797207585,
+      5.155763800672272,
+      1.6676439941331331
+    ],
+    "targetVelocity": [
+      1.790485593794008,
+      -1.0238071623699447,
+      0.7241418267183883
+    ],
+    "targetAcceleration": [
+      4.358502668402489,
+      2.27507813023018,
+      -3.8896723055600955
+    ],
+    "maxVelocity": [
+      4.490565360937264,
+      3.626906733477873,
+      6.800890019358946
+    ],
+    "maxAcceleration": [
+      8.99410022384142,
+      4.071341882185873,
+      4.452252993342526
+    ],
+    "maxJerk": [
+      15.73824580581447,
+      19.216887661099467,
+      14.141289681115566
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.14342537856196813,
+      7.753227645583969,
+      -7.625384595938803
+    ],
+    "currentVelocity": [
+      -3.6234989626695073,
+      4.877421401710057,
+      -2.190521555158874
+    ],
+    "currentAcceleration": [
+      2.336598082191676,
+      -8.228586009162303,
+      -2.4355907472789236
+    ],
+    "targetPosition": [
+      -0.8863720191675384,
+      1.0771141618547375,
+      -2.2665565121480302
+    ],
+    "targetVelocity": [
+      -4.593707366241659,
+      -5.613608296919911,
+      -2.1561573925406288
+    ],
+    "targetAcceleration": [
+      3.5948532231856056,
+      3.432968327971871,
+      5.299209136123759
+    ],
+    "maxVelocity": [
+      5.524716114413106,
+      7.472627777734006,
+      3.4271321295239554
+    ],
+    "maxAcceleration": [
+      6.013492890666015,
+      9.82642261073242,
+      8.157377367179073
+    ],
+    "maxJerk": [
+      15.938032432896115,
+      16.122478717179604,
+      12.332425692322886
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.382034659860031,
+      -8.842380974599982,
+      0.005584575738692976
+    ],
+    "currentVelocity": [
+      0.007745892983586522,
+      -0.48599416279598096,
+      -0.6449806451131277
+    ],
+    "currentAcceleration": [
+      8.891335286086019,
+      -8.956000282183762,
+      1.2447070908648614
+    ],
+    "targetPosition": [
+      0.7666181418667701,
+      -4.310565821618684,
+      2.687340759034738
+    ],
+    "targetVelocity": [
+      1.1631352566681077,
+      -5.174520173349745,
+      3.367521616926183
+    ],
+    "targetAcceleration": [
+      4.564823052477735,
+      -5.67526749847906,
+      -5.577628723809308
+    ],
+    "maxVelocity": [
+      2.5834479156434047,
+      6.152955017695302,
+      5.107093239255681
+    ],
+    "maxAcceleration": [
+      9.810441081168818,
+      9.279909108157252,
+      5.839596763181921
+    ],
+    "maxJerk": [
+      19.090605427825004,
+      16.40724364702436,
+      11.46123165094609
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.060532935396594,
+      -2.6662317114799894,
+      7.794594690635094
+    ],
+    "currentVelocity": [
+      0.4458023751216169,
+      1.8740851054801002,
+      5.303279329527417
+    ],
+    "currentAcceleration": [
+      -1.3775903019462166,
+      3.2995728024550157,
+      -1.881286518712357
+    ],
+    "targetPosition": [
+      6.808771052229723,
+      2.3963014226693566,
+      2.188402958608812
+    ],
+    "targetVelocity": [
+      2.4079894231438264,
+      -0.34117957427563717,
+      -3.545162640993775
+    ],
+    "targetAcceleration": [
+      1.859876977256456,
+      0.16552832105270632,
+      1.0005035721939608
+    ],
+    "maxVelocity": [
+      3.3551600631496843,
+      4.7374852238720155,
+      6.597518964451018
+    ],
+    "maxAcceleration": [
+      3.4975280655109984,
+      4.036358914561013,
+      3.676876840868098
+    ],
+    "maxJerk": [
+      12.083050375021346,
+      8.71469852812571,
+      14.706498650788147
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.820868335916167,
+      3.4017129318380945,
+      -5.550985729040228
+    ],
+    "currentVelocity": [
+      -1.1285443588589312,
+      3.2382062813076153,
+      0.5903062970213337
+    ],
+    "currentAcceleration": [
+      0.6959525524550845,
+      1.2992128472695814,
+      -1.2534756068429713
+    ],
+    "targetPosition": [
+      -6.504195488283213,
+      8.02993296049279,
+      1.0948979438474087
+    ],
+    "targetVelocity": [
+      2.347157529935779,
+      0.3658100931400625,
+      5.692480523177123
+    ],
+    "targetAcceleration": [
+      2.5793850397351514,
+      5.616245142708559,
+      1.024952284100304
+    ],
+    "maxVelocity": [
+      3.5462289396249203,
+      5.652627975603023,
+      7.925022032068391
+    ],
+    "maxAcceleration": [
+      4.148922170590109,
+      8.951543179810919,
+      3.5837029122010726
+    ],
+    "maxJerk": [
+      7.546793515328758,
+      14.837078129904139,
+      12.061308941839275
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.484214793931489,
+      7.114096892510389,
+      -8.418282596419575
+    ],
+    "currentVelocity": [
+      -1.1644338882919012,
+      -0.7943591245504296,
+      2.473027244356305
+    ],
+    "currentAcceleration": [
+      4.704331813930919,
+      4.3529898081871226,
+      4.036466995932722
+    ],
+    "targetPosition": [
+      9.338185049530686,
+      5.763989963728681,
+      2.396341989834694
+    ],
+    "targetVelocity": [
+      2.8957269622507456,
+      -5.274178012196674,
+      -0.6176374959637956
+    ],
+    "targetAcceleration": [
+      0.6927412350080404,
+      4.7934780677965305,
+      5.527957624964284
+    ],
+    "maxVelocity": [
+      6.909905940431707,
+      7.433267899306868,
+      7.671505057775179
+    ],
+    "maxAcceleration": [
+      4.7729057748561345,
+      7.59994387356575,
+      6.429704785254824
+    ],
+    "maxJerk": [
+      13.837603584367923,
+      10.56568467815401,
+      18.137581659900576
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.6394106444084358,
+      -0.861222344569299,
+      -9.192354201480825
+    ],
+    "currentVelocity": [
+      -0.47153070915391027,
+      -0.9143756049326237,
+      1.2855317420120826
+    ],
+    "currentAcceleration": [
+      2.031162484491725,
+      3.1892198047348783,
+      -4.357683897952078
+    ],
+    "targetPosition": [
+      -2.350151067338901,
+      8.80251480353931,
+      2.4280150281455697
+    ],
+    "targetVelocity": [
+      1.2605020895133268,
+      -1.7096529141978158,
+      -3.5474499044465224
+    ],
+    "targetAcceleration": [
+      -4.25467139215631,
+      -5.43924991326777,
+      -3.884879689490396
+    ],
+    "maxVelocity": [
+      2.7810546770465243,
+      2.4332992640963997,
+      5.780050860918487
+    ],
+    "maxAcceleration": [
+      5.432404480788587,
+      7.377432681903403,
+      4.362891633192847
+    ],
+    "maxJerk": [
+      19.140334950771702,
+      6.790302007251096,
+      6.858845001790431
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.299246639607148,
+      -5.38353814839369,
+      -3.870727083164354
+    ],
+    "currentVelocity": [
+      -2.1719328803687286,
+      -2.077469603695845,
+      3.751619211865175
+    ],
+    "currentAcceleration": [
+      4.7948962742548495,
+      -3.773803443544086,
+      4.35466732012573
+    ],
+    "targetPosition": [
+      -2.6777246035093505,
+      7.9104668113239,
+      6.210935762550196
+    ],
+    "targetVelocity": [
+      0.7300602292510141,
+      3.685457003003326,
+      1.6752577389073666
+    ],
+    "targetAcceleration": [
+      4.5940172878709085,
+      0.33873606513293986,
+      -1.512224384721824
+    ],
+    "maxVelocity": [
+      3.086590749714782,
+      4.894899741521216,
+      7.883149616709036
+    ],
+    "maxAcceleration": [
+      6.8916098658351,
+      5.627910084603961,
+      7.23107199997149
+    ],
+    "maxJerk": [
+      16.761555704247773,
+      11.778432598728028,
+      14.215959109586368
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.734150763906449,
+      0.3324739258768705,
+      4.0670779265241475
+    ],
+    "currentVelocity": [
+      4.038996730121021,
+      -2.595515757886168,
+      2.183684776505726
+    ],
+    "currentAcceleration": [
+      -2.9696197235607453,
+      4.050882822530733,
+      2.4887335041561487
+    ],
+    "targetPosition": [
+      1.4196640880640121,
+      4.789624918161522,
+      -5.393918588138522
+    ],
+    "targetVelocity": [
+      -4.307969816750651,
+      -4.005886423274442,
+      -0.0027353898554300926
+    ],
+    "targetAcceleration": [
+      2.274292664380839,
+      -3.720262581957586,
+      -0.8163852977945663
+    ],
+    "maxVelocity": [
+      7.187791042239562,
+      4.357261048485048,
+      3.8860763715484605
+    ],
+    "maxAcceleration": [
+      5.1293582619742715,
+      8.216093889295687,
+      4.5533021011897095
+    ],
+    "maxJerk": [
+      14.75684512273961,
+      9.650779289816878,
+      7.287716227946234
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.5915537729217597,
+      1.0701529110471455,
+      8.492198436823582
+    ],
+    "currentVelocity": [
+      2.386531014694089,
+      -0.8485041470413135,
+      -3.383017249078851
+    ],
+    "currentAcceleration": [
+      -1.5479075412586063,
+      -0.7589410222572077,
+      1.982773723409104
+    ],
+    "targetPosition": [
+      3.426167872506035,
+      -7.369203451219177,
+      7.350207999777886
+    ],
+    "targetVelocity": [
+      -2.3973545052196554,
+      0.5210737834666008,
+      1.6181886505906622
+    ],
+    "targetAcceleration": [
+      -2.174533628290681,
+      2.841578700602323,
+      -3.4339230047727285
+    ],
+    "maxVelocity": [
+      3.0219641353856077,
+      2.3300328264780075,
+      3.5888378239754104
+    ],
+    "maxAcceleration": [
+      3.6760933365873374,
+      3.8898852828377954,
+      4.723615668869685
+    ],
+    "maxJerk": [
+      7.797916943110419,
+      11.820917532611762,
+      17.834138169073853
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.459867868575742,
+      -2.9161254643523566,
+      9.818918368513216
+    ],
+    "currentVelocity": [
+      0.11905870974838617,
+      2.159188243246799,
+      -0.783671499452514
+    ],
+    "currentAcceleration": [
+      -3.329449364882134,
+      -7.785949944447147,
+      -0.9993940083075294
+    ],
+    "targetPosition": [
+      -2.697751348332174,
+      -5.979717220703371,
+      9.99965999014674
+    ],
+    "targetVelocity": [
+      2.730138716502914,
+      3.0287593835335525,
+      1.8538280585791451
+    ],
+    "targetAcceleration": [
+      -3.2861370423080447,
+      5.515983758811915,
+      -0.47886812894644937
+    ],
+    "maxVelocity": [
+      7.447444896636487,
+      5.92848776726095,
+      3.18452425595076
+    ],
+    "maxAcceleration": [
+      6.17570275355429,
+      7.98432313851572,
+      5.430456435245991
+    ],
+    "maxJerk": [
+      15.387151030164066,
+      16.699309306350955,
+      13.54702275237811
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.346838537447205,
+      -5.547549398768563,
+      -1.7686831166380141
+    ],
+    "currentVelocity": [
+      1.9955037403577012,
+      -0.41863581717454235,
+      0.8798471526406937
+    ],
+    "currentAcceleration": [
+      -0.7086148294342518,
+      -0.30554549878507054,
+      1.4189691536468398
+    ],
+    "targetPosition": [
+      -3.144098777652453,
+      3.721845544646561,
+      -0.4266469274621869
+    ],
+    "targetVelocity": [
+      -1.9454340290448882,
+      1.760245139825475,
+      -3.7658726974204346
+    ],
+    "targetAcceleration": [
+      0.8715777975833348,
+      -2.713788532010863,
+      -0.43263064763293535
+    ],
+    "maxVelocity": [
+      3.4300446497079373,
+      5.509121271023494,
+      5.432415341739439
+    ],
+    "maxAcceleration": [
+      7.078750629002324,
+      3.1441046338844725,
+      9.249287711025698
+    ],
+    "maxJerk": [
+      5.240200833468292,
+      5.489782187725193,
+      6.432005633736742
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.502757024920168,
+      8.386748132071602,
+      9.72057459209445
+    ],
+    "currentVelocity": [
+      -2.227326454982874,
+      -1.9645045604980025,
+      4.951061223243542
+    ],
+    "currentAcceleration": [
+      -1.9188711283739637,
+      -1.1507944880012717,
+      -1.4285291842379344
+    ],
+    "targetPosition": [
+      -8.967613069544143,
+      -0.46329071427454593,
+      -6.764998005367153
+    ],
+    "targetVelocity": [
+      3.367871157515448,
+      0.37887721365935967,
+      -1.8799000230731426
+    ],
+    "targetAcceleration": [
+      1.8141972057087141,
+      -3.757288238178186,
+      4.418808264123482
+    ],
+    "maxVelocity": [
+      4.906747733072186,
+      6.40048901367535,
+      6.073477642219997
+    ],
+    "maxAcceleration": [
+      5.631875020731749,
+      4.213998146155085,
+      5.287545554963075
+    ],
+    "maxJerk": [
+      16.55096815970414,
+      7.71026413234709,
+      18.050781997184785
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.141428921338008,
+      7.506839633744718,
+      -1.076291948684073
+    ],
+    "currentVelocity": [
+      3.3239006929922015,
+      1.6601074289318962,
+      -1.5870563467995966
+    ],
+    "currentAcceleration": [
+      -5.037600036345424,
+      -1.6354785703478143,
+      -2.157111251185797
+    ],
+    "targetPosition": [
+      -5.508481345133507,
+      1.3771293147926578,
+      9.684533257579304
+    ],
+    "targetVelocity": [
+      -0.251070283866496,
+      1.3421244048216074,
+      2.169103169308288
+    ],
+    "targetAcceleration": [
+      6.18977401967595,
+      3.927779277270739,
+      -0.35122598722663856
+    ],
+    "maxVelocity": [
+      4.106227533314197,
+      2.2118398927664242,
+      2.257412761396303
+    ],
+    "maxAcceleration": [
+      7.0928720112617345,
+      5.747421062662461,
+      3.2855146976525194
+    ],
+    "maxJerk": [
+      5.993154983436112,
+      5.9157520456693184,
+      12.07751566145002
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.325134461538241,
+      -0.06020331539829371,
+      -2.697654396232318
+    ],
+    "currentVelocity": [
+      -0.4978501601446941,
+      -1.3256214340386518,
+      -3.673949996129061
+    ],
+    "currentAcceleration": [
+      4.9343338999195385,
+      -6.197216139018049,
+      -2.1615963462443553
+    ],
+    "targetPosition": [
+      -0.4416851915385518,
+      -1.4281378553674386,
+      8.523587082551739
+    ],
+    "targetVelocity": [
+      2.241642827335042,
+      -0.09383310291098645,
+      2.726792243907745
+    ],
+    "targetAcceleration": [
+      -2.0034545946949653,
+      0.05943129021804072,
+      -6.400304685820944
+    ],
+    "maxVelocity": [
+      3.4123313047332244,
+      2.877432258835546,
+      7.160390559772102
+    ],
+    "maxAcceleration": [
+      5.698849625382115,
+      6.3362194318658425,
+      7.789196587780035
+    ],
+    "maxJerk": [
+      13.47552274274214,
+      13.77536636154001,
+      10.961029413666619
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.2912483102790837,
+      8.259024673545749,
+      5.977460801212617
+    ],
+    "currentVelocity": [
+      5.554178358632097,
+      0.6371604437329381,
+      0.18600478648015883
+    ],
+    "currentAcceleration": [
+      -1.1100036409424545,
+      -8.241772655187907,
+      3.181050861860996
+    ],
+    "targetPosition": [
+      2.310764740902652,
+      -2.0381719938164755,
+      -7.661841661951241
+    ],
+    "targetVelocity": [
+      3.54264958963617,
+      -1.9810586264481227,
+      1.739543581503081
+    ],
+    "targetAcceleration": [
+      -0.7701080867965446,
+      -5.203795509464519,
+      -0.04802332603140691
+    ],
+    "maxVelocity": [
+      7.083308763717065,
+      7.363395812026463,
+      3.0476628784204443
+    ],
+    "maxAcceleration": [
+      6.210626667202394,
+      9.419824239713021,
+      9.036807543718584
+    ],
+    "maxJerk": [
+      5.082156786778596,
+      10.204068328794833,
+      11.370353351159944
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.66121380223052,
+      9.597688989985908,
+      9.053399127178984
+    ],
+    "currentVelocity": [
+      7.71976800238651,
+      0.3144364561590183,
+      4.863471883515268
+    ],
+    "currentAcceleration": [
+      0.8067958916456845,
+      -4.759594478775645,
+      -3.104923044119557
+    ],
+    "targetPosition": [
+      -2.7315932511690066,
+      0.5597599928305907,
+      0.35460498045283906
+    ],
+    "targetVelocity": [
+      6.323572099880123,
+      -0.37353255392432905,
+      4.403999612025889
+    ],
+    "targetAcceleration": [
+      1.1742525862336413,
+      -3.511838703354978,
+      3.5269921553079984
+    ],
+    "maxVelocity": [
+      7.9560390130881595,
+      2.2884698461278696,
+      7.797018730338084
+    ],
+    "maxAcceleration": [
+      6.338434822462112,
+      4.874929525797825,
+      3.661843822809355
+    ],
+    "maxJerk": [
+      12.707020599212374,
+      9.174291755325779,
+      17.366253768308464
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.676701677031639,
+      -1.392167872893495,
+      9.408410218808221
+    ],
+    "currentVelocity": [
+      5.43186396496259,
+      -1.3411355464282009,
+      2.011305266900612
+    ],
+    "currentAcceleration": [
+      -4.06652018774791,
+      -1.2328688298643242,
+      0.14567551457936556
+    ],
+    "targetPosition": [
+      -3.3294066645644005,
+      -3.6407240406879975,
+      6.390154109355464
+    ],
+    "targetVelocity": [
+      2.694686211747106,
+      -0.24990789291225646,
+      2.2969692876067835
+    ],
+    "targetAcceleration": [
+      3.1791721607292125,
+      -0.15029681918270432,
+      -4.043526123713397
+    ],
+    "maxVelocity": [
+      7.459587536426671,
+      6.248789410061408,
+      5.216451215636
+    ],
+    "maxAcceleration": [
+      4.530257907200381,
+      3.6115194332307334,
+      7.873802549967208
+    ],
+    "maxJerk": [
+      19.405791054104306,
+      16.359540231302823,
+      12.244173320183085
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.197608183129159,
+      2.9506612659135723,
+      3.119423795244858
+    ],
+    "currentVelocity": [
+      0.5233332047362769,
+      4.463071523937817,
+      3.964909332195793
+    ],
+    "currentAcceleration": [
+      -1.9510305301256716,
+      2.4860719936261813,
+      -4.380774821083612
+    ],
+    "targetPosition": [
+      -2.02443849887199,
+      -4.20490665582401,
+      -4.446251784719591
+    ],
+    "targetVelocity": [
+      2.5178607261809667,
+      0.19005930998904397,
+      -4.919116227439552
+    ],
+    "targetAcceleration": [
+      0.6683326458705316,
+      3.443882405758158,
+      -0.5432251677636621
+    ],
+    "maxVelocity": [
+      3.527907394523397,
+      5.780150901694753,
+      7.014239631641065
+    ],
+    "maxAcceleration": [
+      4.402418134328212,
+      4.900290520927394,
+      5.49804197993782
+    ],
+    "maxJerk": [
+      12.011046039223675,
+      6.143782675373115,
+      17.269596102404723
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.6748761846860436,
+      2.0043659995702363,
+      -7.222821201292449
+    ],
+    "currentVelocity": [
+      2.9895384405916126,
+      -1.4781661997015636,
+      -4.740650784370526
+    ],
+    "currentAcceleration": [
+      3.979789911195505,
+      3.806834710874278,
+      2.077967017964201
+    ],
+    "targetPosition": [
+      3.1794697041373805,
+      1.9357478220012467,
+      1.9967336097073414
+    ],
+    "targetVelocity": [
+      -3.2018598218100407,
+      -6.382972704195527,
+      -5.468929851868068
+    ],
+    "targetAcceleration": [
+      -1.6837747762917594,
+      -0.7921143006742826,
+      3.1938747262573033
+    ],
+    "maxVelocity": [
+      5.669755373593285,
+      7.599385116240962,
+      5.971719443616548
+    ],
+    "maxAcceleration": [
+      8.081434967473369,
+      6.485777924943386,
+      6.424161406287433
+    ],
+    "maxJerk": [
+      5.85150013950976,
+      8.774313831723337,
+      18.03065454667337
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.191901129728636,
+      -0.36332288007323577,
+      -0.6582824675336703
+    ],
+    "currentVelocity": [
+      1.7137679010012077,
+      -1.557616489349976,
+      1.0637675442971695
+    ],
+    "currentAcceleration": [
+      4.347413750803529,
+      -1.52371905672087,
+      -5.8897679711491815
+    ],
+    "targetPosition": [
+      5.833081616877614,
+      8.505416827885114,
+      -1.5911077118536952
+    ],
+    "targetVelocity": [
+      2.970578180286024,
+      0.5715156684251985,
+      1.4069524226708268
+    ],
+    "targetAcceleration": [
+      0.17195406754719045,
+      -1.7852426448471994,
+      -5.306328799081829
+    ],
+    "maxVelocity": [
+      4.585429117186314,
+      2.1909128017996844,
+      3.613635166119984
+    ],
+    "maxAcceleration": [
+      7.388223884713728,
+      5.114020537424063,
+      5.976707450699641
+    ],
+    "maxJerk": [
+      13.611455621536937,
+      14.967681587398847,
+      11.711184282766318
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.796307395113249,
+      -6.360747526596118,
+      7.601830116496583
+    ],
+    "currentVelocity": [
+      -3.713422083909675,
+      3.3316781818446595,
+      0.3762465744406551
+    ],
+    "currentAcceleration": [
+      -5.852710311617855,
+      -0.05494141325930624,
+      5.481530838580667
+    ],
+    "targetPosition": [
+      1.3776789141616526,
+      -7.805614553936826,
+      4.060193923529404
+    ],
+    "targetVelocity": [
+      4.829833341506968,
+      0.915390548384643,
+      0.25050456296611534
+    ],
+    "targetAcceleration": [
+      -1.738658320912573,
+      -2.3919446671916047,
+      -3.1788387442101858
+    ],
+    "maxVelocity": [
+      5.690794535342929,
+      6.133374085327731,
+      2.3180454974398694
+    ],
+    "maxAcceleration": [
+      9.217439170804713,
+      4.309435036128729,
+      8.243077127385561
+    ],
+    "maxJerk": [
+      13.604753115198218,
+      7.982988552149983,
+      13.648656521355544
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.338298181183724,
+      1.1690971302535331,
+      2.649224159897434
+    ],
+    "currentVelocity": [
+      -0.9603101031201358,
+      2.7562719066242916,
+      4.947066685960637
+    ],
+    "currentAcceleration": [
+      0.2877471631652897,
+      0.21535352945497443,
+      -4.195234411983613
+    ],
+    "targetPosition": [
+      0.6465914343948356,
+      -7.2067879186563495,
+      -5.9371895191809205
+    ],
+    "targetVelocity": [
+      -2.1960184630416535,
+      -1.1161245752087978,
+      6.185304834659274
+    ],
+    "targetAcceleration": [
+      -2.008127944140393,
+      3.1413102070973897,
+      -1.1132530616874217
+    ],
+    "maxVelocity": [
+      3.1151860101961297,
+      2.9723168852692976,
+      7.40873603361463
+    ],
+    "maxAcceleration": [
+      4.165871982681261,
+      3.2471993409400177,
+      8.109838392870637
+    ],
+    "maxJerk": [
+      16.553551157676395,
+      16.971866748617682,
+      18.21949952083861
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.476564620091578,
+      2.3170302058901022,
+      9.223985837374833
+    ],
+    "currentVelocity": [
+      3.8248122195001404,
+      -0.5765491259011162,
+      -2.8967948408939086
+    ],
+    "currentAcceleration": [
+      -0.5429996886546911,
+      2.327033748344796,
+      6.660670265063771
+    ],
+    "targetPosition": [
+      0.8984698804226277,
+      -6.326298129535539,
+      5.790424897345703
+    ],
+    "targetVelocity": [
+      3.909181293734811,
+      -7.515689820072432,
+      -3.1428218523262803
+    ],
+    "targetAcceleration": [
+      1.5551667909832023,
+      3.5995892422220557,
+      -6.266966392275733
+    ],
+    "maxVelocity": [
+      6.382348599616522,
+      7.9353091185446285,
+      5.892267728566168
+    ],
+    "maxAcceleration": [
+      3.121475293537112,
+      4.6587776185728025,
+      6.695186158986732
+    ],
+    "maxJerk": [
+      13.4031013260281,
+      17.18237989524826,
+      18.13929294401437
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.139828211695141,
+      7.304426436763968,
+      -8.765702951693958
+    ],
+    "currentVelocity": [
+      -3.732061492914231,
+      -3.742679828030728,
+      2.5787443633548186
+    ],
+    "currentAcceleration": [
+      3.0107806008838445,
+      -3.710726147400525,
+      5.295172227711559
+    ],
+    "targetPosition": [
+      7.786190733864903,
+      -9.770872771303825,
+      -0.47720389535995444
+    ],
+    "targetVelocity": [
+      5.5115499481813295,
+      1.3778612076592403,
+      6.01484860580238
+    ],
+    "targetAcceleration": [
+      -6.041211056330624,
+      3.7435148921412127,
+      6.015901718548697
+    ],
+    "maxVelocity": [
+      6.695656995992865,
+      7.1990696067422615,
+      7.2407595985323265
+    ],
+    "maxAcceleration": [
+      8.846125254627308,
+      7.80303143447676,
+      9.680365384445533
+    ],
+    "maxJerk": [
+      18.787210258919004,
+      10.523785720111988,
+      7.702142693143065
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.3174061613739756,
+      9.801964648972717,
+      -8.813742804815288
+    ],
+    "currentVelocity": [
+      -2.660698288848329,
+      -1.6853024507357777,
+      1.0671000802309933
+    ],
+    "currentAcceleration": [
+      -4.4938778909744945,
+      5.880912368492675,
+      4.796476716338687
+    ],
+    "targetPosition": [
+      -5.410825279579496,
+      -5.491145714585571,
+      -9.113944119115324
+    ],
+    "targetVelocity": [
+      2.5628265479686574,
+      -2.974478306119961,
+      -0.06743543740706759
+    ],
+    "targetAcceleration": [
+      -3.213527191392127,
+      2.6869625979529097,
+      -1.3213306922764687
+    ],
+    "maxVelocity": [
+      3.674558072680102,
+      7.0422464324166105,
+      6.961167945545151
+    ],
+    "maxAcceleration": [
+      4.750072539956035,
+      8.93646040969493,
+      7.7979701972791835
+    ],
+    "maxJerk": [
+      19.782440574814075,
+      15.489536999554149,
+      14.294444170836861
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.909143442780055,
+      -9.736677400163654,
+      4.498300775111071
+    ],
+    "currentVelocity": [
+      7.186286269421111,
+      -2.6916080217671885,
+      2.9973076978413102
+    ],
+    "currentAcceleration": [
+      -1.3261381967296266,
+      -1.175255076979361,
+      0.8226367610388587
+    ],
+    "targetPosition": [
+      2.471715363611967,
+      -4.6261484241816,
+      -3.1309444526413515
+    ],
+    "targetVelocity": [
+      1.2594014064884407,
+      0.3415412190303684,
+      1.404041167241104
+    ],
+    "targetAcceleration": [
+      1.0355566491872406,
+      0.31619426247959126,
+      -2.7410888641075193
+    ],
+    "maxVelocity": [
+      7.8418590778565695,
+      5.023860347288414,
+      3.6096396853955195
+    ],
+    "maxAcceleration": [
+      9.132915449132145,
+      4.278205138894512,
+      4.006202644248583
+    ],
+    "maxJerk": [
+      11.20874043830788,
+      12.946884991705696,
+      5.56828216577053
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.7259876151309648,
+      -2.4570931322787537,
+      5.970133902866072
+    ],
+    "currentVelocity": [
+      2.8042599446026664,
+      3.4121325595305514,
+      1.0139610291368109
+    ],
+    "currentAcceleration": [
+      -3.072267914630693,
+      1.0842836510096419,
+      -1.973100656640619
+    ],
+    "targetPosition": [
+      -5.573255053164803,
+      -1.0352703294337537,
+      -6.9124303974045205
+    ],
+    "targetVelocity": [
+      1.311702295843018,
+      2.658412786970006,
+      0.75824730190695
+    ],
+    "targetAcceleration": [
+      -1.6039117028202594,
+      -4.344835682850511,
+      -1.8253855773303382
+    ],
+    "maxVelocity": [
+      3.141038191840419,
+      7.624455142527278,
+      2.4200164505179274
+    ],
+    "maxAcceleration": [
+      4.196668211093646,
+      8.44977714034199,
+      3.115406215050892
+    ],
+    "maxJerk": [
+      17.418539975316115,
+      18.184286136075578,
+      14.736754791425454
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.6370542371517516,
+      -7.436857403675439,
+      -3.7579065340242686
+    ],
+    "currentVelocity": [
+      -1.9889505031629762,
+      6.5675082136676455,
+      -1.221038394555391
+    ],
+    "currentAcceleration": [
+      5.64400309751662,
+      -6.746827241678059,
+      -7.182386003905659
+    ],
+    "targetPosition": [
+      6.0845359645451715,
+      5.513281208943388,
+      0.049881028762044366
+    ],
+    "targetVelocity": [
+      5.503821699953395,
+      2.4723924478506323,
+      2.308840154099487
+    ],
+    "targetAcceleration": [
+      -2.287272707227215,
+      -4.911383929790294,
+      7.827151030496719
+    ],
+    "maxVelocity": [
+      6.922206594279988,
+      7.047176591815507,
+      6.095020108300087
+    ],
+    "maxAcceleration": [
+      6.902052591193954,
+      6.752428140752309,
+      8.212466000434052
+    ],
+    "maxJerk": [
+      10.735626117796883,
+      9.925745769188154,
+      12.50549165165761
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.0673486793959768,
+      -9.87380790060438,
+      -2.113215793721843
+    ],
+    "currentVelocity": [
+      3.489792157568359,
+      4.913147357458906,
+      2.644413661552252
+    ],
+    "currentAcceleration": [
+      -1.528437059146361,
+      -0.3142448431910214,
+      0.8256395298870496
+    ],
+    "targetPosition": [
+      3.7610689819484797,
+      1.8035388398452916,
+      8.461266603027077
+    ],
+    "targetVelocity": [
+      6.62257313361187,
+      1.6410670839315236,
+      2.4002483006308406
+    ],
+    "targetAcceleration": [
+      -0.19274613917306915,
+      -3.594716191112711,
+      -4.193261286936808
+    ],
+    "maxVelocity": [
+      7.791923589071016,
+      5.8211492467608155,
+      3.8347379435735647
+    ],
+    "maxAcceleration": [
+      8.325149252792336,
+      5.763892245760393,
+      4.960950612979924
+    ],
+    "maxJerk": [
+      14.14911557872816,
+      9.672049426528819,
+      11.896215447791523
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.329396446291017,
+      0.9568390742847548,
+      -0.30637157157325845
+    ],
+    "currentVelocity": [
+      4.063609122035922,
+      1.4796533473245943,
+      4.735468789467219
+    ],
+    "currentAcceleration": [
+      -5.626813640985633,
+      1.7529380389903642,
+      -0.24376381185871665
+    ],
+    "targetPosition": [
+      4.16345999071261,
+      -9.397310877372004,
+      -8.06263941679897
+    ],
+    "targetVelocity": [
+      4.09879075722829,
+      -0.19917601868482038,
+      -6.501580048524874
+    ],
+    "targetAcceleration": [
+      -5.107980707454255,
+      4.782028337902678,
+      1.77129445546091
+    ],
+    "maxVelocity": [
+      5.2951556993880065,
+      2.1699301773596464,
+      7.944975728522739
+    ],
+    "maxAcceleration": [
+      6.258615313312006,
+      5.851384857870765,
+      7.950401979284087
+    ],
+    "maxJerk": [
+      14.601056312775418,
+      19.206041288699318,
+      17.352656823499828
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.21449554783172076,
+      2.056354544349073,
+      3.120006357200566
+    ],
+    "currentVelocity": [
+      6.8461596909965365,
+      -3.507543608106759,
+      5.265894362161843
+    ],
+    "currentAcceleration": [
+      -0.17667723175098082,
+      -4.704905155260897,
+      -4.222868965195145
+    ],
+    "targetPosition": [
+      1.0359681228424318,
+      -2.5014299160614417,
+      -7.696002254143279
+    ],
+    "targetVelocity": [
+      -4.660655324286236,
+      -1.5612463391832359,
+      -3.4481777263471804
+    ],
+    "targetAcceleration": [
+      4.1391961960052,
+      -2.352661387387001,
+      -0.7995022802058713
+    ],
+    "maxVelocity": [
+      7.964344115917669,
+      6.797586848283647,
+      6.136613057955271
+    ],
+    "maxAcceleration": [
+      9.179241386546243,
+      6.784827653799553,
+      6.965345891336364
+    ],
+    "maxJerk": [
+      19.445379616989165,
+      19.29188929933715,
+      7.580055713099333
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.5316178717249507,
+      -8.966671318342893,
+      -8.998714533621259
+    ],
+    "currentVelocity": [
+      -1.9243078809119158,
+      4.865686485272358,
+      5.913227050363011
+    ],
+    "currentAcceleration": [
+      6.664157021938479,
+      -7.221419854188063,
+      -2.6270640746012077
+    ],
+    "targetPosition": [
+      7.780766417523235,
+      -7.19410866276635,
+      -8.371676735810702
+    ],
+    "targetVelocity": [
+      2.6059051367774053,
+      -5.554292544025175,
+      -4.560309636308428
+    ],
+    "targetAcceleration": [
+      3.659981087458968,
+      -0.42266492176961634,
+      0.2363268612282141
+    ],
+    "maxVelocity": [
+      3.0507945270381533,
+      7.748627649250668,
+      7.725040014160744
+    ],
+    "maxAcceleration": [
+      7.168565595456956,
+      9.961962375422024,
+      6.805883398407273
+    ],
+    "maxJerk": [
+      18.007174082762678,
+      16.3221311899839,
+      14.458153297820488
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.351133751345831,
+      -0.7885355787228079,
+      -2.3353084920008023
+    ],
+    "currentVelocity": [
+      2.294139390639284,
+      -5.0769013685124635,
+      -4.178711180270909
+    ],
+    "currentAcceleration": [
+      -2.2482842978304536,
+      -6.3393671084365195,
+      -0.06448810763166835
+    ],
+    "targetPosition": [
+      -8.806876909215884,
+      -6.3474560377469675,
+      -2.696143491319642
+    ],
+    "targetVelocity": [
+      3.2247734053138117,
+      -3.254186145563377,
+      -4.612922127834903
+    ],
+    "targetAcceleration": [
+      4.580522882233415,
+      -2.014042244144176,
+      -2.029479842713592
+    ],
+    "maxVelocity": [
+      3.5398783936018585,
+      7.75898245727236,
+      6.5023746854076006
+    ],
+    "maxAcceleration": [
+      6.4824859467622495,
+      9.309018311542676,
+      4.0155830130844965
+    ],
+    "maxJerk": [
+      16.784786592479193,
+      19.907251286632416,
+      7.741586109572788
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.9415301568453476,
+      -0.44971145878506746,
+      6.376031586563876
+    ],
+    "currentVelocity": [
+      6.375107026375663,
+      0.6487919339079187,
+      -3.619442577105701
+    ],
+    "currentAcceleration": [
+      0.8634614664766236,
+      1.717175902233917,
+      -1.6837222971861143
+    ],
+    "targetPosition": [
+      5.956343231896561,
+      -6.02409056618193,
+      3.6188394628671094
+    ],
+    "targetVelocity": [
+      2.3387566712200814,
+      1.9069775671801574,
+      -2.1827017056964504
+    ],
+    "targetAcceleration": [
+      2.250958480924349,
+      5.423016671406202,
+      -6.463724421126914
+    ],
+    "maxVelocity": [
+      7.638011796911349,
+      2.3301507917934465,
+      6.73869859267785
+    ],
+    "maxAcceleration": [
+      5.319198460954683,
+      7.7597516707492264,
+      8.952483756279388
+    ],
+    "maxJerk": [
+      15.978115047803069,
+      12.405432943367558,
+      12.49371677937948
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.5796977605691147,
+      -2.921175975152348,
+      -0.28948411708703503
+    ],
+    "currentVelocity": [
+      -2.577906756451494,
+      4.781039818710029,
+      -0.20965112740500969
+    ],
+    "currentAcceleration": [
+      -3.5578046376697583,
+      2.8923246902194526,
+      -0.6787013938861186
+    ],
+    "targetPosition": [
+      -7.942482769463284,
+      9.015066495426424,
+      -9.717231632688183
+    ],
+    "targetVelocity": [
+      -0.9109347789303524,
+      -3.4476240936095643,
+      0.3597685630683136
+    ],
+    "targetAcceleration": [
+      4.805022086074865,
+      2.5297537256773577,
+      -0.1793216629000316
+    ],
+    "maxVelocity": [
+      3.654639927627888,
+      5.88831812472797,
+      4.18559114948035
+    ],
+    "maxAcceleration": [
+      7.057588002568015,
+      3.2268353276315427,
+      4.693564757014466
+    ],
+    "maxJerk": [
+      12.247613353280748,
+      17.71691692282047,
+      5.049542120185034
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.8555372403315662,
+      2.784263020064671,
+      5.535723922259342
+    ],
+    "currentVelocity": [
+      -3.0982947362279494,
+      -1.6857574322673685,
+      -4.318324423120752
+    ],
+    "currentAcceleration": [
+      0.9224367050160485,
+      3.279289730913156,
+      0.542354516424326
+    ],
+    "targetPosition": [
+      8.348516899451894,
+      7.3344071278996275,
+      3.7131956209803167
+    ],
+    "targetVelocity": [
+      2.654620888797057,
+      -0.8258291141067924,
+      1.5007315513076191
+    ],
+    "targetAcceleration": [
+      2.1079590756514532,
+      1.5354746302193671,
+      -6.205045586492628
+    ],
+    "maxVelocity": [
+      3.6351640186505927,
+      2.0564958316313535,
+      5.955469219179127
+    ],
+    "maxAcceleration": [
+      3.9295794285069476,
+      8.21967632904315,
+      6.921701617615398
+    ],
+    "maxJerk": [
+      15.435910836590505,
+      19.063607146640585,
+      9.662088861495684
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.986554954754778,
+      7.625958475151386,
+      -9.017304935496778
+    ],
+    "currentVelocity": [
+      6.3621864404300545,
+      -2.0709918474677744,
+      4.096805970990641
+    ],
+    "currentAcceleration": [
+      2.539892876776787,
+      -0.5860476829927359,
+      -5.169578612626479
+    ],
+    "targetPosition": [
+      -0.23565762076764152,
+      1.3703923834000538,
+      -4.51456938728811
+    ],
+    "targetVelocity": [
+      -4.458367155226924,
+      -1.0369421454049552,
+      3.9446817591179286
+    ],
+    "targetAcceleration": [
+      4.926132334361761,
+      0.1554117422317205,
+      -0.8766523150323318
+    ],
+    "maxVelocity": [
+      7.321276578813885,
+      2.7075041969639018,
+      5.678614599092102
+    ],
+    "maxAcceleration": [
+      5.027773753025941,
+      4.389042890964676,
+      6.6552827216164445
+    ],
+    "maxJerk": [
+      7.997847403028089,
+      14.551034705912144,
+      11.127803532273411
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.5904476410093178,
+      5.279882025621969,
+      7.765641326738844
+    ],
+    "currentVelocity": [
+      3.3679852410833995,
+      1.9890558281188255,
+      -3.6869447202506116
+    ],
+    "currentAcceleration": [
+      2.083955275652105,
+      4.124439824951063,
+      2.922554926497562
+    ],
+    "targetPosition": [
+      -3.715428785838471,
+      1.0948018302350064,
+      -6.793693886360943
+    ],
+    "targetVelocity": [
+      -5.106594991353036,
+      -0.3379547145466404,
+      0.146659248152873
+    ],
+    "targetAcceleration": [
+      3.6069760435093094,
+      -0.2809398532119367,
+      -1.7374235231396291
+    ],
+    "maxVelocity": [
+      7.5916114079165915,
+      4.805613288561435,
+      5.144049275911598
+    ],
+    "maxAcceleration": [
+      7.286638983009285,
+      6.295967463155533,
+      3.348257870050679
+    ],
+    "maxJerk": [
+      10.078960116322731,
+      13.029770919870089,
+      5.732242294570205
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.484370511806084,
+      -8.538991300150201,
+      5.491746452745199
+    ],
+    "currentVelocity": [
+      2.5765586966506078,
+      0.6532074981430114,
+      -3.0316610909638144
+    ],
+    "currentAcceleration": [
+      -5.514718044615856,
+      -1.4159829655159657,
+      -1.3655146350563885
+    ],
+    "targetPosition": [
+      -0.6471148030940057,
+      9.32207055215778,
+      6.963674933430816
+    ],
+    "targetVelocity": [
+      0.8709108222248654,
+      1.5742150234789865,
+      0.2425250068765208
+    ],
+    "targetAcceleration": [
+      -1.7562057891900213,
+      -1.2490433356861494,
+      2.566502777499876
+    ],
+    "maxVelocity": [
+      4.015887794134961,
+      4.674176335412957,
+      3.27441816903408
+    ],
+    "maxAcceleration": [
+      5.9549812323885405,
+      3.3047097294685686,
+      3.7889705251383186
+    ],
+    "maxJerk": [
+      8.406615523774702,
+      10.586108425894487,
+      18.09849605939524
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.649286098531173,
+      9.054600597108013,
+      2.4015919953926392
+    ],
+    "currentVelocity": [
+      4.74235268468563,
+      -0.2205781321606639,
+      -0.36302621204359875
+    ],
+    "currentAcceleration": [
+      2.018418974128303,
+      -3.89563792514282,
+      6.202558655643525
+    ],
+    "targetPosition": [
+      3.3773523157554397,
+      2.7157635298017517,
+      -4.759512162176238
+    ],
+    "targetVelocity": [
+      -3.6269015521095613,
+      1.332855594706349,
+      -1.4086037630142345
+    ],
+    "targetAcceleration": [
+      -1.2430819555195791,
+      -4.414199340180923,
+      5.737607900052916
+    ],
+    "maxVelocity": [
+      5.7534486726219844,
+      3.353583092405136,
+      2.5276718689612108
+    ],
+    "maxAcceleration": [
+      7.3011930598111165,
+      5.610283245031883,
+      8.168475628421769
+    ],
+    "maxJerk": [
+      10.483850694948682,
+      10.596630931964166,
+      16.651699939980688
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.338100861929302,
+      7.110927365029166,
+      7.041905130329795
+    ],
+    "currentVelocity": [
+      -0.20524924044078174,
+      -0.5913039996962275,
+      -3.714243726210292
+    ],
+    "currentAcceleration": [
+      -4.007135084810699,
+      3.1057670345791317,
+      0.271716250535178
+    ],
+    "targetPosition": [
+      -2.343251601052545,
+      1.8383502438168904,
+      -3.2250252891368802
+    ],
+    "targetVelocity": [
+      -0.11945643975926412,
+      1.1620730890180697,
+      -3.5964939343657245
+    ],
+    "targetAcceleration": [
+      1.9062788988445858,
+      4.316333875348946,
+      0.6378077631855348
+    ],
+    "maxVelocity": [
+      2.4323683668028466,
+      2.927603278000009,
+      6.354986546933606
+    ],
+    "maxAcceleration": [
+      5.663430444939986,
+      5.2345202516957565,
+      8.642606841704167
+    ],
+    "maxJerk": [
+      12.38647051703502,
+      12.012994520518761,
+      11.123131761502183
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.1596205974463345,
+      7.375605556432642,
+      -3.39343379194347
+    ],
+    "currentVelocity": [
+      -4.742473848131953,
+      2.155348821143239,
+      0.2863924390687229
+    ],
+    "currentAcceleration": [
+      -5.153906362197835,
+      5.301403721321158,
+      -3.40949880795244
+    ],
+    "targetPosition": [
+      3.0837193828181046,
+      0.8177615399937608,
+      9.664672628441178
+    ],
+    "targetVelocity": [
+      -0.0515764148121125,
+      2.3009379894150648,
+      -2.899107014369033
+    ],
+    "targetAcceleration": [
+      -3.6899017003487664,
+      -4.784119365958949,
+      0.32878062090776705
+    ],
+    "maxVelocity": [
+      6.7045876102502575,
+      6.494527935356123,
+      3.7679930504984744
+    ],
+    "maxAcceleration": [
+      7.803710481435836,
+      6.618564059194595,
+      3.918166124432518
+    ],
+    "maxJerk": [
+      11.595301474929503,
+      16.581533330965584,
+      14.655730119551738
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.7055403045221276,
+      -8.952037984347728,
+      -2.8194136045077345
+    ],
+    "currentVelocity": [
+      1.645662234245945,
+      1.6841053692218395,
+      -1.846694509144092
+    ],
+    "currentAcceleration": [
+      -2.279981650633094,
+      -7.302934689898976,
+      -0.3869185224460301
+    ],
+    "targetPosition": [
+      0.27662190483153104,
+      -4.715976117162914,
+      -8.244941194121086
+    ],
+    "targetVelocity": [
+      -0.09886399911133958,
+      3.867194494160538,
+      2.9597729263859396
+    ],
+    "targetAcceleration": [
+      3.032331966250164,
+      -3.9715532276594,
+      3.534619471640143
+    ],
+    "maxVelocity": [
+      2.9806017982293733,
+      4.553271439208466,
+      5.828435192613263
+    ],
+    "maxAcceleration": [
+      3.228046968398344,
+      7.471352308345121,
+      5.547470094306133
+    ],
+    "maxJerk": [
+      17.948151939067763,
+      16.122616438433017,
+      13.938041442228378
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.0564017813399236,
+      -2.95398007787834,
+      5.766504738353442
+    ],
+    "currentVelocity": [
+      1.837769648296935,
+      0.39554609031881993,
+      0.31099382361337957
+    ],
+    "currentAcceleration": [
+      -1.377511699837068,
+      3.593638926467338,
+      7.8458554925413075
+    ],
+    "targetPosition": [
+      -2.2199205642032105,
+      6.276699066157768,
+      6.373127470919002
+    ],
+    "targetVelocity": [
+      -3.093077659442959,
+      0.3936176037758714,
+      -0.4988003041239195
+    ],
+    "targetAcceleration": [
+      -1.619797471694028,
+      3.6522289180208594,
+      0.3823538912686253
+    ],
+    "maxVelocity": [
+      4.6865400030409,
+      2.7436140510653955,
+      2.8107682173932957
+    ],
+    "maxAcceleration": [
+      4.158691004145345,
+      3.87411159066803,
+      8.888620271816837
+    ],
+    "maxJerk": [
+      16.820755795527667,
+      12.281045205684887,
+      19.7318685567081
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.521454405669683,
+      -1.9517511909219252,
+      4.698220300748188
+    ],
+    "currentVelocity": [
+      2.881899912710492,
+      -3.5612557651290793,
+      -1.6360713978188937
+    ],
+    "currentAcceleration": [
+      0.9259604504958912,
+      0.5860543609966227,
+      -4.48201454368299
+    ],
+    "targetPosition": [
+      -7.964368570447283,
+      7.709557148725597,
+      -7.527734994201333
+    ],
+    "targetVelocity": [
+      -0.5458344190722082,
+      0.7703986986091707,
+      -1.395049339492962
+    ],
+    "targetAcceleration": [
+      2.266195489043991,
+      2.6578999000965284,
+      -2.5901734687229787
+    ],
+    "maxVelocity": [
+      6.182019176745432,
+      3.7539313741655516,
+      5.706643189067178
+    ],
+    "maxAcceleration": [
+      6.590102539204004,
+      5.718446226648953,
+      4.980901907379286
+    ],
+    "maxJerk": [
+      5.818857049896644,
+      17.539308948241604,
+      12.381745104790483
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.087515011387865,
+      -5.575061878543179,
+      4.365884338662687
+    ],
+    "currentVelocity": [
+      2.0680437787014014,
+      -1.7342873918085673,
+      2.3833793534478445
+    ],
+    "currentAcceleration": [
+      4.249495213790361,
+      -0.05813867958782071,
+      3.995247087543346
+    ],
+    "targetPosition": [
+      -3.7624384379353693,
+      -0.17449917236211476,
+      -5.416250194273136
+    ],
+    "targetVelocity": [
+      0.6075825338520424,
+      -0.4530371699890723,
+      -1.9369947290631266
+    ],
+    "targetAcceleration": [
+      -2.7376008944437666,
+      2.3128267293139713,
+      5.19117702118008
+    ],
+    "maxVelocity": [
+      3.7622465785237154,
+      2.4918755243371837,
+      2.8300848937985648
+    ],
+    "maxAcceleration": [
+      9.811592448752668,
+      3.044361381035226,
+      7.797861616564402
+    ],
+    "maxJerk": [
+      10.112299430591882,
+      16.81308060765888,
+      19.00068620436227
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.78271080444655,
+      7.419663902452243,
+      -5.631504360935759
+    ],
+    "currentVelocity": [
+      1.2130881518238903,
+      -0.9606615076997298,
+      -5.014986027842985
+    ],
+    "currentAcceleration": [
+      1.0998491756004363,
+      5.775677123840493,
+      1.0222706946251598
+    ],
+    "targetPosition": [
+      4.693620600278873,
+      0.10480296752551688,
+      -7.751603782996104
+    ],
+    "targetVelocity": [
+      1.7274269230372719,
+      -3.299242448114253,
+      -0.27527941330036665
+    ],
+    "targetAcceleration": [
+      -1.6608897595165808,
+      -0.3723908463094894,
+      -4.007995159159863
+    ],
+    "maxVelocity": [
+      5.239971619714017,
+      3.773992007907247,
+      7.860235554418752
+    ],
+    "maxAcceleration": [
+      4.877298848941128,
+      8.479818269977242,
+      5.36870087677969
+    ],
+    "maxJerk": [
+      16.989670266052723,
+      18.46290964734784,
+      18.95951327080166
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.867626812567089,
+      6.73890085049289,
+      5.192650129367241
+    ],
+    "currentVelocity": [
+      -2.1125809369763284,
+      -2.3350933838321604,
+      1.0351109455424536
+    ],
+    "currentAcceleration": [
+      1.4768901656441376,
+      -5.218233782864602,
+      -3.7496191818880127
+    ],
+    "targetPosition": [
+      -1.619461133076726,
+      -5.577636774577539,
+      -2.096961998537921
+    ],
+    "targetVelocity": [
+      -0.9945897812268525,
+      0.4437348820031648,
+      -2.9178017540015775
+    ],
+    "targetAcceleration": [
+      2.0917370658736205,
+      -2.746276877429712,
+      -0.3802102214699641
+    ],
+    "maxVelocity": [
+      6.081402652286133,
+      4.230967268528627,
+      7.023306910684934
+    ],
+    "maxAcceleration": [
+      3.466147182877407,
+      8.115697691564145,
+      7.749206058628144
+    ],
+    "maxJerk": [
+      6.86328177502421,
+      11.879619249939484,
+      12.300527853113444
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.042903057198334,
+      -0.7894779415366404,
+      -8.584948615454655
+    ],
+    "currentVelocity": [
+      5.745484452475534,
+      3.546459445459798,
+      2.958618482226246
+    ],
+    "currentAcceleration": [
+      3.3389797220258144,
+      -0.5046631079322204,
+      -1.1338639683138334
+    ],
+    "targetPosition": [
+      0.2744133068096062,
+      6.654616475187137,
+      -9.491607589308398
+    ],
+    "targetVelocity": [
+      3.219270655627488,
+      3.113304426671388,
+      4.7033915691963255
+    ],
+    "targetAcceleration": [
+      -5.08290502307492,
+      1.4060632500887307,
+      -2.4705656860368785
+    ],
+    "maxVelocity": [
+      6.716995946153082,
+      3.836372446897117,
+      7.401633721759659
+    ],
+    "maxAcceleration": [
+      5.144663682712303,
+      5.854987693630511,
+      4.205828420122676
+    ],
+    "maxJerk": [
+      7.167859978865341,
+      12.938145003618981,
+      19.980048981345554
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.629355724537394,
+      -0.11925772350300434,
+      7.103108790642626
+    ],
+    "currentVelocity": [
+      -2.076819113547958,
+      -0.010419332472216603,
+      -3.276861738506243
+    ],
+    "currentAcceleration": [
+      8.787559296991397,
+      3.5456367661333417,
+      5.288622589075361
+    ],
+    "targetPosition": [
+      1.0029376404304013,
+      1.406309118019042,
+      -8.152144649874156
+    ],
+    "targetVelocity": [
+      -2.240065095350893,
+      2.1661746555395816,
+      3.9468065905806693
+    ],
+    "targetAcceleration": [
+      -8.721915915303283,
+      -5.2820855649891625,
+      -0.3976439209525129
+    ],
+    "maxVelocity": [
+      7.472909187026016,
+      6.505848093002246,
+      6.858306968732586
+    ],
+    "maxAcceleration": [
+      8.992786686776537,
+      6.608326991597689,
+      9.318324081146578
+    ],
+    "maxJerk": [
+      6.799206008849156,
+      16.90213239687518,
+      11.594457536096662
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.914529006436464,
+      -4.342934573038047,
+      -0.1523547752688703
+    ],
+    "currentVelocity": [
+      -1.7871053498294858,
+      1.3975166807651878,
+      4.9686154278488495
+    ],
+    "currentAcceleration": [
+      -0.7401822241218974,
+      -4.934792979737985,
+      1.2167111446364007
+    ],
+    "targetPosition": [
+      -0.009278540624075404,
+      -0.9846021846036841,
+      0.21821279903218027
+    ],
+    "targetVelocity": [
+      2.521548115094462,
+      1.1612659813035329,
+      -2.370125888594937
+    ],
+    "targetAcceleration": [
+      2.714671681164508,
+      -5.398344039083595,
+      4.808690919660691
+    ],
+    "maxVelocity": [
+      3.1498948154191897,
+      4.019486473863271,
+      6.9608971114307145
+    ],
+    "maxAcceleration": [
+      3.196720119877341,
+      7.911180421885964,
+      7.609881472301987
+    ],
+    "maxJerk": [
+      18.97055208344358,
+      17.199187304686475,
+      9.082699711024333
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.719418956384593,
+      6.106229883145776,
+      -4.432848480330862
+    ],
+    "currentVelocity": [
+      -2.3012033008732633,
+      -1.4371723763237858,
+      -0.8973357128493327
+    ],
+    "currentAcceleration": [
+      2.030898025447409,
+      -2.6059976851868596,
+      -3.2192435581591594
+    ],
+    "targetPosition": [
+      -0.9784338723897346,
+      -0.05206571395206083,
+      -8.574216100140726
+    ],
+    "targetVelocity": [
+      -1.4102604045791498,
+      -0.7574283999745108,
+      2.4998412233886445
+    ],
+    "targetAcceleration": [
+      0.5925173932360748,
+      0.5964640086288666,
+      7.0846150067746
+    ],
+    "maxVelocity": [
+      4.084554808547608,
+      3.130369862374363,
+      2.6669218696079167
+    ],
+    "maxAcceleration": [
+      4.333276459279578,
+      4.704052422132425,
+      8.775098089779789
+    ],
+    "maxJerk": [
+      15.729100502102053,
+      17.34815709423802,
+      8.217770656111613
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.90250962427818,
+      -9.819438782853194,
+      5.435392904888117
+    ],
+    "currentVelocity": [
+      0.31035919128233447,
+      -7.229494705241403,
+      -3.120005916830907
+    ],
+    "currentAcceleration": [
+      2.4090412298396053,
+      0.6031063417359039,
+      6.342320372774724
+    ],
+    "targetPosition": [
+      -9.305784128508911,
+      -4.269417222287258,
+      -0.45696623805022796
+    ],
+    "targetVelocity": [
+      1.3089376010024578,
+      -4.103874968872308,
+      3.162248306181958
+    ],
+    "targetAcceleration": [
+      -2.60833578761114,
+      1.1281281808975505,
+      -0.8401908528184672
+    ],
+    "maxVelocity": [
+      3.2942934903776626,
+      7.385413747734528,
+      7.7964867747360245
+    ],
+    "maxAcceleration": [
+      7.113972387794453,
+      4.637528366135568,
+      6.376679194974004
+    ],
+    "maxJerk": [
+      5.520400068705047,
+      19.1721412327824,
+      10.831126371972262
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.947499711071636,
+      -1.8785472640386374,
+      -0.9764795855969961
+    ],
+    "currentVelocity": [
+      0.4239698116150121,
+      1.8577269593993053,
+      -2.266195656286683
+    ],
+    "currentAcceleration": [
+      -3.06652698358488,
+      -5.244263873924806,
+      0.8276975676856608
+    ],
+    "targetPosition": [
+      3.443554286383444,
+      -8.275875232913144,
+      -1.3472375287723182
+    ],
+    "targetVelocity": [
+      1.2946702123708507,
+      -0.6902311180408982,
+      0.4580127109914667
+    ],
+    "targetAcceleration": [
+      4.089345968959617,
+      2.3883097224206535,
+      -2.231236723693971
+    ],
+    "maxVelocity": [
+      2.481687513063851,
+      4.27862018913255,
+      5.948138092358812
+    ],
+    "maxAcceleration": [
+      4.936416586652501,
+      6.39621247007418,
+      6.097504410407384
+    ],
+    "maxJerk": [
+      11.294292516758528,
+      5.0371805610616285,
+      6.589804376715652
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.67457542524151,
+      -4.572358551368336,
+      -1.4881544094399484
+    ],
+    "currentVelocity": [
+      2.7444848897697147,
+      0.18689301924002066,
+      2.4566383631584667
+    ],
+    "currentAcceleration": [
+      8.002040900132249,
+      -0.3061995575733576,
+      6.8054313781869595
+    ],
+    "targetPosition": [
+      -7.53079875129152,
+      -6.247129306831541,
+      3.350379401552315
+    ],
+    "targetVelocity": [
+      3.438871354406106,
+      -3.7313895171585942,
+      -1.5747782768943805
+    ],
+    "targetAcceleration": [
+      -1.3633123725477674,
+      -6.15295796894824,
+      -4.536297266898021
+    ],
+    "maxVelocity": [
+      6.725641778789295,
+      6.006724214250968,
+      7.73428489486535
+    ],
+    "maxAcceleration": [
+      8.77361023401876,
+      7.335106086663196,
+      8.307441576050657
+    ],
+    "maxJerk": [
+      16.607232206820573,
+      5.850599357320624,
+      16.686902446400595
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.06475102437237,
+      -2.8112115702005713,
+      9.06117291640356
+    ],
+    "currentVelocity": [
+      -0.9013140083543609,
+      -4.83351592366865,
+      -2.2551595720644615
+    ],
+    "currentAcceleration": [
+      0.4313903510886634,
+      3.70410730007287,
+      -1.8988147011931868
+    ],
+    "targetPosition": [
+      -3.8497291682888264,
+      4.8480158023512825,
+      -8.877724137353074
+    ],
+    "targetVelocity": [
+      -3.9267400198597766,
+      3.4259983078303105,
+      -4.173257215664973
+    ],
+    "targetAcceleration": [
+      -1.2890328633702577,
+      3.7535631705878387,
+      5.348292079586036
+    ],
+    "maxVelocity": [
+      7.9647959967877675,
+      5.816316976106759,
+      7.754056097465836
+    ],
+    "maxAcceleration": [
+      7.504696249121661,
+      6.29242019728861,
+      6.63778861986804
+    ],
+    "maxJerk": [
+      9.276578870998579,
+      17.255601574545764,
+      12.955078164436115
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.274314139849082,
+      -7.7501172055851235,
+      -1.0634680506963292
+    ],
+    "currentVelocity": [
+      -2.2174219703490983,
+      1.3176755879379787,
+      -4.470656594415888
+    ],
+    "currentAcceleration": [
+      0.6181015469259754,
+      -2.2473130702110318,
+      0.15955260546693406
+    ],
+    "targetPosition": [
+      9.928910671174602,
+      5.844055311972172,
+      8.78152215969785
+    ],
+    "targetVelocity": [
+      3.5933295091729107,
+      2.5993331499178662,
+      -1.1263072079801706
+    ],
+    "targetAcceleration": [
+      -0.2787736056544481,
+      4.4892599696828315,
+      -5.307854309783158
+    ],
+    "maxVelocity": [
+      4.2310492776905,
+      7.892567028311083,
+      7.14159471698346
+    ],
+    "maxAcceleration": [
+      3.605250750225372,
+      6.549927457598188,
+      6.799602681466968
+    ],
+    "maxJerk": [
+      8.1062819589449,
+      10.935045887728414,
+      18.15471240803096
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6228756522666252,
+      1.319235507767269,
+      -5.43054091337879
+    ],
+    "currentVelocity": [
+      4.991179584875985,
+      -1.2438069126872735,
+      -2.306324870431629
+    ],
+    "currentAcceleration": [
+      -5.747036272312577,
+      5.381450341178295,
+      -1.6198234138473007
+    ],
+    "targetPosition": [
+      -9.184212184601625,
+      -6.417037843182425,
+      1.5475375575076136
+    ],
+    "targetVelocity": [
+      -0.5306043501958122,
+      0.8353115006695195,
+      1.700372816196868
+    ],
+    "targetAcceleration": [
+      1.3631532011092347,
+      -3.3891881950161737,
+      -6.942393763892719
+    ],
+    "maxVelocity": [
+      7.452147588531981,
+      2.117893477572766,
+      3.5507525552567802
+    ],
+    "maxAcceleration": [
+      7.6586868457158275,
+      7.824458342010437,
+      9.144125919202027
+    ],
+    "maxJerk": [
+      17.540493380017686,
+      13.178821891956453,
+      17.013806459774464
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.015739974021462544,
+      1.5645135766056324,
+      2.5547624887686826
+    ],
+    "currentVelocity": [
+      -3.321534215979595,
+      -5.733179759825664,
+      0.7792753146847504
+    ],
+    "currentAcceleration": [
+      1.7557061703414636,
+      2.2102167752572246,
+      -5.775303690686352
+    ],
+    "targetPosition": [
+      -5.443658189025744,
+      4.802665498859707,
+      7.3220509010437915
+    ],
+    "targetVelocity": [
+      2.8474982979816756,
+      -1.8555513297738147,
+      0.6728007006015142
+    ],
+    "targetAcceleration": [
+      0.4646614095628694,
+      3.818279304485321,
+      -0.3668766599228057
+    ],
+    "maxVelocity": [
+      5.098400522577871,
+      7.328628784971947,
+      2.661900959277683
+    ],
+    "maxAcceleration": [
+      5.7145691534333745,
+      5.2428418322332835,
+      9.651093649769091
+    ],
+    "maxJerk": [
+      10.095960479500423,
+      16.606109269245437,
+      9.56210858268511
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.828909620916264,
+      -5.320264867972595,
+      2.794793517535915
+    ],
+    "currentVelocity": [
+      -4.309580282806381,
+      -2.626788234842616,
+      -0.7034683454858941
+    ],
+    "currentAcceleration": [
+      3.034833213682652,
+      0.5353204303723711,
+      3.849842418685264
+    ],
+    "targetPosition": [
+      5.851684853470211,
+      5.36697292434755,
+      7.213963312197006
+    ],
+    "targetVelocity": [
+      4.536711122429575,
+      -0.40995525902296137,
+      -0.5108767513483201
+    ],
+    "targetAcceleration": [
+      2.1371925833602576,
+      0.30618332802323955,
+      3.790418816707313
+    ],
+    "maxVelocity": [
+      7.395580558188912,
+      5.172968083602447,
+      4.782654449790507
+    ],
+    "maxAcceleration": [
+      6.156500375700239,
+      8.918696736857889,
+      6.056789659821397
+    ],
+    "maxJerk": [
+      7.720723646919712,
+      18.295689152364744,
+      9.007068990794515
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.798387219695302,
+      0.44890196706406726,
+      -8.986140857870097
+    ],
+    "currentVelocity": [
+      -3.7986218525884357,
+      -4.398412360857957,
+      -4.231764764895262
+    ],
+    "currentAcceleration": [
+      6.405765856877433,
+      4.045558487228986,
+      2.5236179936940193
+    ],
+    "targetPosition": [
+      5.099763511282831,
+      -6.6223076283506614,
+      9.80864073728959
+    ],
+    "targetVelocity": [
+      6.175586035126672,
+      -4.916629936844243,
+      5.170546307972568
+    ],
+    "targetAcceleration": [
+      -3.888766918427571,
+      0.08025344355919373,
+      0.2687419072243582
+    ],
+    "maxVelocity": [
+      7.08070720546395,
+      6.667253001193995,
+      5.6571269058667735
+    ],
+    "maxAcceleration": [
+      7.3016334651422445,
+      5.350380883755314,
+      4.513919739159464
+    ],
+    "maxJerk": [
+      9.571766964962983,
+      19.803996150498357,
+      8.28323215901821
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.982293964364606,
+      -9.642313732026341,
+      1.0572785414300192
+    ],
+    "currentVelocity": [
+      -1.009472787621208,
+      -1.6689956623721538,
+      -0.013722464361489273
+    ],
+    "currentAcceleration": [
+      3.5886710340824086,
+      4.191809902761582,
+      2.6105898039881534
+    ],
+    "targetPosition": [
+      -0.15199692092913963,
+      -5.872662889785223,
+      0.21814239027651006
+    ],
+    "targetVelocity": [
+      -4.272160261355867,
+      1.8778373036795877,
+      -0.30608586632057655
+    ],
+    "targetAcceleration": [
+      3.3149446210376956,
+      -0.9153988604970982,
+      -2.5986868386310666
+    ],
+    "maxVelocity": [
+      4.898881302064586,
+      4.934412277390488,
+      3.562716438019081
+    ],
+    "maxAcceleration": [
+      5.414991283749001,
+      5.674423006679895,
+      5.199456320385025
+    ],
+    "maxJerk": [
+      17.071419146366317,
+      6.36288807677168,
+      6.554683519171375
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.2662859204513417,
+      -8.810949820744769,
+      -3.448315582670805
+    ],
+    "currentVelocity": [
+      1.7653750851467693,
+      -1.5650341650713946,
+      -4.361588842531042
+    ],
+    "currentAcceleration": [
+      -4.846566244205055,
+      1.3160332470923022,
+      4.606287474800858
+    ],
+    "targetPosition": [
+      -6.995453286325799,
+      -0.9677634099945802,
+      -2.777036332508871
+    ],
+    "targetVelocity": [
+      3.74146667026275,
+      -0.9023462239787161,
+      4.43190259289036
+    ],
+    "targetAcceleration": [
+      7.790064051235813,
+      -4.15629255637805,
+      -1.7803982460431045
+    ],
+    "maxVelocity": [
+      6.74994159784788,
+      6.024741654380429,
+      5.034430756505042
+    ],
+    "maxAcceleration": [
+      8.518721025207295,
+      4.316879357292441,
+      5.159808485507526
+    ],
+    "maxJerk": [
+      12.684668302034705,
+      18.64062570712966,
+      9.864598260227528
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.952581876905466,
+      3.715658407084332,
+      -1.7112140659487434
+    ],
+    "currentVelocity": [
+      -0.5883412369015706,
+      -3.297099204312086,
+      3.5886843509523256
+    ],
+    "currentAcceleration": [
+      -2.076443166574826,
+      1.5853097216295975,
+      2.6975436621188345
+    ],
+    "targetPosition": [
+      -3.7129602029151805,
+      -9.372733490254728,
+      -3.6518974046728285
+    ],
+    "targetVelocity": [
+      -1.6010837392701402,
+      -1.965295913679313,
+      0.994177363527001
+    ],
+    "targetAcceleration": [
+      2.28789091123093,
+      -3.775930835518192,
+      0.7170573932801516
+    ],
+    "maxVelocity": [
+      3.7029554371235296,
+      3.4524424401096807,
+      4.117398337761165
+    ],
+    "maxAcceleration": [
+      9.713545638923733,
+      8.113702819855758,
+      3.828502652586781
+    ],
+    "maxJerk": [
+      7.087546156337526,
+      5.379562559190084,
+      12.635950177895571
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.302626245736985,
+      -5.537406766663331,
+      -4.249176692676477
+    ],
+    "currentVelocity": [
+      -3.347978212467694,
+      5.110437445208172,
+      -1.8862146488137737
+    ],
+    "currentAcceleration": [
+      1.327715433451166,
+      -0.7586760126080048,
+      0.8842845634284826
+    ],
+    "targetPosition": [
+      4.805379385404624,
+      -4.998029999291502,
+      6.365772404318953
+    ],
+    "targetVelocity": [
+      -0.28710357550682675,
+      -0.44170177929768784,
+      4.635977041481945
+    ],
+    "targetAcceleration": [
+      0.8131942041706157,
+      -0.3661296235834639,
+      -1.8196227498879027
+    ],
+    "maxVelocity": [
+      4.111064378764669,
+      5.721643584596782,
+      5.339502714189442
+    ],
+    "maxAcceleration": [
+      9.158967364025294,
+      8.300963047273438,
+      7.354221953941983
+    ],
+    "maxJerk": [
+      10.96083364863365,
+      14.883021255180953,
+      8.881559045616985
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.377140564774221,
+      -8.902515947099952,
+      -2.2549535885256455
+    ],
+    "currentVelocity": [
+      -2.9728403328336377,
+      2.800309945616572,
+      -2.5946526084316717
+    ],
+    "currentAcceleration": [
+      7.020750462323811,
+      -0.32093522794789786,
+      0.0506258586659607
+    ],
+    "targetPosition": [
+      3.054258422465521,
+      9.852976325429069,
+      8.857650754399838
+    ],
+    "targetVelocity": [
+      -2.706047591546625,
+      -2.706635214915014,
+      -0.4275959906300786
+    ],
+    "targetAcceleration": [
+      1.263705313594679,
+      -2.6826069639025616,
+      3.777059301730092
+    ],
+    "maxVelocity": [
+      6.925095528258865,
+      3.2108851453808773,
+      3.515206353713203
+    ],
+    "maxAcceleration": [
+      8.629936563372215,
+      3.2849574746754664,
+      4.697773769774792
+    ],
+    "maxJerk": [
+      12.527741686405658,
+      6.635648783964207,
+      7.786728646321764
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.982083213159314,
+      9.107089279138524,
+      -3.4904655766008847
+    ],
+    "currentVelocity": [
+      1.3904596677089889,
+      5.727797524026964,
+      -3.9362508924171142
+    ],
+    "currentAcceleration": [
+      -2.164106839546525,
+      4.236002845392779,
+      -3.323054116329702
+    ],
+    "targetPosition": [
+      -2.8884688105955414,
+      -1.0638291208805573,
+      8.940618795133851
+    ],
+    "targetVelocity": [
+      0.8760407065897824,
+      3.4884240691601276,
+      -1.7904713909156724
+    ],
+    "targetAcceleration": [
+      -2.3730638554210985,
+      8.308127541932043,
+      5.112618875092437
+    ],
+    "maxVelocity": [
+      3.210673041425713,
+      6.876377200747188,
+      7.5936661908618515
+    ],
+    "maxAcceleration": [
+      3.0084481033177846,
+      9.512559506189438,
+      6.09616470526648
+    ],
+    "maxJerk": [
+      16.99784634049704,
+      9.817020364194983,
+      8.321050400720088
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.4397605228574779,
+      6.186030948667284,
+      2.952927912355962
+    ],
+    "currentVelocity": [
+      -1.034318554656673,
+      -6.632042707711895,
+      2.4187191524043516
+    ],
+    "currentAcceleration": [
+      -3.561867851129036,
+      3.1685676290054436,
+      -2.6605713611664887
+    ],
+    "targetPosition": [
+      0.06281144917503134,
+      -4.0780084645922905,
+      -2.041290410420837
+    ],
+    "targetVelocity": [
+      -1.6256303040700297,
+      2.5438241580285688,
+      4.767059760145472
+    ],
+    "targetAcceleration": [
+      5.1840582373102455,
+      -5.919655518895983,
+      3.4538867166373883
+    ],
+    "maxVelocity": [
+      2.499069866753208,
+      7.4496863636726705,
+      6.65772146257515
+    ],
+    "maxAcceleration": [
+      5.437943466516679,
+      7.15865704003101,
+      4.64014316013456
+    ],
+    "maxJerk": [
+      16.827131933631936,
+      19.86819451427108,
+      12.749709452215338
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.902791695580454,
+      -4.517300482400914,
+      8.236740140932994
+    ],
+    "currentVelocity": [
+      -0.13501456977779913,
+      -1.6237338347068997,
+      -4.664026054354633
+    ],
+    "currentAcceleration": [
+      0.22410591691708426,
+      -0.62314293721652,
+      -3.594408157513173
+    ],
+    "targetPosition": [
+      3.2228379741378816,
+      8.043251464702081,
+      -0.004440927073014578
+    ],
+    "targetVelocity": [
+      5.908759900482758,
+      -2.809776899148865,
+      0.46902261326535033
+    ],
+    "targetAcceleration": [
+      -2.4931781962477313,
+      2.97196493856406,
+      1.5597828395516053
+    ],
+    "maxVelocity": [
+      6.99327039876303,
+      6.420732654174643,
+      7.478542299047494
+    ],
+    "maxAcceleration": [
+      9.187220662738225,
+      6.230030480108708,
+      7.421158003526941
+    ],
+    "maxJerk": [
+      18.665778892016295,
+      17.747962680833318,
+      6.445975959879729
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.747304175059089,
+      -0.5304987688024472,
+      -9.361782819350355
+    ],
+    "currentVelocity": [
+      -4.672512809009879,
+      2.7244128909561014,
+      1.9134785284043394
+    ],
+    "currentAcceleration": [
+      1.5066481165854526,
+      -1.0939315446071216,
+      4.274268878352823
+    ],
+    "targetPosition": [
+      -1.5815901799439729,
+      -0.18211092885830027,
+      -5.209003745707834
+    ],
+    "targetVelocity": [
+      -1.7371550931634445,
+      0.852425338847548,
+      -5.914676304743932
+    ],
+    "targetAcceleration": [
+      7.266345303031951,
+      5.4480694299351065,
+      -8.435316374250611
+    ],
+    "maxVelocity": [
+      7.01971265428798,
+      3.8745830110691846,
+      6.679095463393652
+    ],
+    "maxAcceleration": [
+      8.779412609327295,
+      7.7700420354837885,
+      9.503349173229854
+    ],
+    "maxJerk": [
+      11.438676339744116,
+      17.36908658920231,
+      12.177423641081873
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.7302394838933255,
+      -5.541088738358912,
+      -1.8864767073272333
+    ],
+    "currentVelocity": [
+      3.5750533065448113,
+      -0.19461783518321152,
+      2.9895319153901774
+    ],
+    "currentAcceleration": [
+      0.3261132941124121,
+      5.110189227650565,
+      -0.547116773092085
+    ],
+    "targetPosition": [
+      3.710376779998768,
+      9.306593321560218,
+      -7.291174790536063
+    ],
+    "targetVelocity": [
+      6.154479546005646,
+      4.676924488197573,
+      -0.7494903952919203
+    ],
+    "targetAcceleration": [
+      0.948573860544002,
+      1.186272618536643,
+      -1.1078894950392777
+    ],
+    "maxVelocity": [
+      6.511385701672831,
+      6.0103333237720715,
+      3.1453711868802445
+    ],
+    "maxAcceleration": [
+      6.454756459330685,
+      9.786197825771477,
+      3.6074220810831483
+    ],
+    "maxJerk": [
+      10.096115534182493,
+      7.135933041631638,
+      15.286749513671902
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.1540356385145767,
+      -2.460534565262278,
+      -3.11553449708184
+    ],
+    "currentVelocity": [
+      0.006838020413920454,
+      -2.9718261090137608,
+      -1.5242633418338793
+    ],
+    "currentAcceleration": [
+      4.253306006128814,
+      7.608147762774234,
+      4.81503295793285
+    ],
+    "targetPosition": [
+      -6.921043742489794,
+      6.919134781938958,
+      6.513030730313332
+    ],
+    "targetVelocity": [
+      -2.6294235855903025,
+      -5.964789568495416,
+      0.08865410150085529
+    ],
+    "targetAcceleration": [
+      -4.909041676639938,
+      -2.311473069282605,
+      -4.246010508424053
+    ],
+    "maxVelocity": [
+      2.762281168172827,
+      7.202377895044315,
+      2.9482556651254352
+    ],
+    "maxAcceleration": [
+      5.864108099856632,
+      8.066504954442589,
+      5.726424022337353
+    ],
+    "maxJerk": [
+      7.467125318020511,
+      9.391448947163877,
+      7.591314972118245
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.9181025397961982,
+      2.6353456519673024,
+      2.4449740029574425
+    ],
+    "currentVelocity": [
+      0.7137919231212781,
+      -2.6701075561382357,
+      5.377777523724907
+    ],
+    "currentAcceleration": [
+      -3.562052044657424,
+      1.9949134297984328,
+      1.5640235834021494
+    ],
+    "targetPosition": [
+      2.553669756451434,
+      -5.323608457824525,
+      5.232966725489369
+    ],
+    "targetVelocity": [
+      -2.177253450705916,
+      3.3021124177290613,
+      -4.787611128076056
+    ],
+    "targetAcceleration": [
+      -3.617593816276668,
+      2.295175832011446,
+      -3.7444042451132344
+    ],
+    "maxVelocity": [
+      3.1326469534403563,
+      4.021011141370414,
+      6.806588794091626
+    ],
+    "maxAcceleration": [
+      5.527009026627663,
+      4.158444744942704,
+      5.620691135588594
+    ],
+    "maxJerk": [
+      7.128615258491649,
+      11.688282404337949,
+      15.335912936086544
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.602125275097945,
+      -9.28760841086039,
+      -5.833116390978425
+    ],
+    "currentVelocity": [
+      -2.154239274048686,
+      3.179265517513195,
+      3.3569436370896435
+    ],
+    "currentAcceleration": [
+      2.129767949296811,
+      3.900399069276671,
+      -6.643204071376285
+    ],
+    "targetPosition": [
+      2.1681194189722657,
+      -3.1848691911957,
+      2.6204244051421846
+    ],
+    "targetVelocity": [
+      -1.2238248450100295,
+      -1.5081117793045995,
+      0.2841414175001651
+    ],
+    "targetAcceleration": [
+      1.4339991016619447,
+      -1.348580144611212,
+      2.702684413524868
+    ],
+    "maxVelocity": [
+      5.2171626978195915,
+      4.6627599508618225,
+      3.5191691779737955
+    ],
+    "maxAcceleration": [
+      3.431123011235263,
+      6.944048544477503,
+      6.6752272628882094
+    ],
+    "maxJerk": [
+      18.156491923298233,
+      7.131238393093009,
+      10.993690714268572
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.1967069832275463,
+      4.296172588676843,
+      -4.747611524312017
+    ],
+    "currentVelocity": [
+      0.8960061333919542,
+      -1.2170668632682018,
+      4.04955310119626
+    ],
+    "currentAcceleration": [
+      -2.907002903044446,
+      -0.922663922017112,
+      -1.2555239707883938
+    ],
+    "targetPosition": [
+      2.2681820193788145,
+      -3.224903863463531,
+      9.848704326377472
+    ],
+    "targetVelocity": [
+      4.653516771474168,
+      -5.315691589988385,
+      -3.050194942326324
+    ],
+    "targetAcceleration": [
+      2.4415351603622355,
+      2.282887109561632,
+      -3.3912525451521134
+    ],
+    "maxVelocity": [
+      7.01897981680548,
+      5.751174660332188,
+      5.1854932854734805
+    ],
+    "maxAcceleration": [
+      6.175350060473315,
+      3.763231877516739,
+      7.762867223119757
+    ],
+    "maxJerk": [
+      16.016793200745912,
+      9.818175056166057,
+      13.469233735758191
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.576169253200794,
+      -2.84930290517615,
+      -9.82892125247205
+    ],
+    "currentVelocity": [
+      -1.7787522852127986,
+      0.39296127092834343,
+      0.6102282542718891
+    ],
+    "currentAcceleration": [
+      -3.032876682829552,
+      -5.30924342769314,
+      -2.9690833026370758
+    ],
+    "targetPosition": [
+      -6.001484976969911,
+      -9.11153732197831,
+      7.713477481537353
+    ],
+    "targetVelocity": [
+      2.9670627344814813,
+      1.873130847318686,
+      1.1789660101104635
+    ],
+    "targetAcceleration": [
+      3.6072864136351024,
+      -7.93126428797836,
+      8.393363933896332
+    ],
+    "maxVelocity": [
+      4.468792421150821,
+      5.50526444724731,
+      4.502793768186446
+    ],
+    "maxAcceleration": [
+      7.357713549422265,
+      8.54400423454232,
+      9.702625626887276
+    ],
+    "maxJerk": [
+      17.028688541516363,
+      17.155322668392458,
+      7.51923176741775
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.6328819310862404,
+      4.631473326560025,
+      6.316963052664249
+    ],
+    "currentVelocity": [
+      -4.224292542262056,
+      -2.1591497263064774,
+      -1.351532356640409
+    ],
+    "currentAcceleration": [
+      3.89414195671449,
+      -8.329446748349099,
+      -0.9494848815829542
+    ],
+    "targetPosition": [
+      7.161618325522021,
+      5.480995325507163,
+      -0.6139404923999443
+    ],
+    "targetVelocity": [
+      1.84500782857641,
+      4.617452527589658,
+      0.6146163676557954
+    ],
+    "targetAcceleration": [
+      4.332655266719367,
+      6.860377174764647,
+      -1.5912375546600748
+    ],
+    "maxVelocity": [
+      5.0508034572971745,
+      7.7337975035485735,
+      2.4216963468130164
+    ],
+    "maxAcceleration": [
+      4.941319961471498,
+      9.386305687181206,
+      4.70561895638612
+    ],
+    "maxJerk": [
+      8.207408213757173,
+      13.295991043337942,
+      8.013161401142254
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.394546174766571,
+      9.09335481705699,
+      -2.5125162484293178
+    ],
+    "currentVelocity": [
+      -2.1458653413597975,
+      0.9239037092491733,
+      -2.189905250828372
+    ],
+    "currentAcceleration": [
+      -1.1584876031994336,
+      4.140350737989301,
+      -2.4264583181685078
+    ],
+    "targetPosition": [
+      -7.401098354248921,
+      -5.3349521674554286,
+      -6.854866849782077
+    ],
+    "targetVelocity": [
+      1.0495642386494848,
+      0.1358459882772305,
+      -0.4664320020771848
+    ],
+    "targetAcceleration": [
+      2.101550082739804,
+      -1.0786836488637093,
+      -1.3051132368555587
+    ],
+    "maxVelocity": [
+      3.1218573682431736,
+      3.986731101434537,
+      2.9247754074083816
+    ],
+    "maxAcceleration": [
+      6.0320318230868,
+      4.55649850725271,
+      6.231179865079104
+    ],
+    "maxJerk": [
+      19.906927951733504,
+      17.140384650358925,
+      6.750876543021842
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.338076702800301,
+      7.314741250567732,
+      5.861918420586088
+    ],
+    "currentVelocity": [
+      -0.6009320118531085,
+      4.090085349663361,
+      -5.451285433296647
+    ],
+    "currentAcceleration": [
+      2.4298650141060314,
+      -4.2782967298607515,
+      -1.7070079215775285
+    ],
+    "targetPosition": [
+      -1.4409261244236475,
+      2.9614104255553286,
+      2.5132029039272137
+    ],
+    "targetVelocity": [
+      -2.273026815192709,
+      -4.040432095182624,
+      -5.693375983395
+    ],
+    "targetAcceleration": [
+      -4.791380698675571,
+      -0.9475363165761155,
+      -3.334679401273193
+    ],
+    "maxVelocity": [
+      2.3399339127637333,
+      4.332929181550816,
+      6.373066097514802
+    ],
+    "maxAcceleration": [
+      7.027462855043922,
+      4.9410450743939,
+      4.603850544648661
+    ],
+    "maxJerk": [
+      5.4106582021905245,
+      5.821685063535332,
+      12.576185083540288
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.7104466744186233,
+      -8.83383055352912,
+      -0.05999856909381407
+    ],
+    "currentVelocity": [
+      0.5004224622199356,
+      5.406716878805282,
+      1.04025018515574
+    ],
+    "currentAcceleration": [
+      4.653534779643101,
+      3.432324267341433,
+      -0.18972285358887309
+    ],
+    "targetPosition": [
+      8.248349281804344,
+      -4.662082943573072,
+      2.2009628515932196
+    ],
+    "targetVelocity": [
+      1.0628036451104368,
+      -4.711573300967251,
+      -1.0956052560881442
+    ],
+    "targetAcceleration": [
+      -3.490528153986995,
+      2.3179469329207985,
+      0.3873014365304446
+    ],
+    "maxVelocity": [
+      2.1622356969334593,
+      6.234644427920902,
+      2.672688356281883
+    ],
+    "maxAcceleration": [
+      6.036364874097101,
+      4.703774518591907,
+      5.436403037597799
+    ],
+    "maxJerk": [
+      12.399786591023235,
+      11.701636541633523,
+      11.425586770757693
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.6885746886168036,
+      -3.3954291951989184,
+      7.915383610426762
+    ],
+    "currentVelocity": [
+      1.9750712890111846,
+      -0.4442286991143356,
+      0.3307393467639397
+    ],
+    "currentAcceleration": [
+      -0.21570454674755446,
+      -4.018021045627429,
+      0.0686657976457834
+    ],
+    "targetPosition": [
+      -5.626473915950429,
+      2.9642397940156826,
+      -7.744245823209582
+    ],
+    "targetVelocity": [
+      -0.44051456230863106,
+      0.15651404367546773,
+      -0.21913767368370918
+    ],
+    "targetAcceleration": [
+      -1.8773794654428153,
+      6.000578245183127,
+      0.23722261368227393
+    ],
+    "maxVelocity": [
+      3.693745014288143,
+      2.8828715199114674,
+      2.543939778235445
+    ],
+    "maxAcceleration": [
+      8.720511968741059,
+      7.704673498559036,
+      4.958215677563135
+    ],
+    "maxJerk": [
+      18.730152367970803,
+      18.525088302430085,
+      16.416017585338828
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.5484846337589531,
+      -9.040549665528935,
+      7.070222576738175
+    ],
+    "currentVelocity": [
+      -3.9055146409212607,
+      -1.9584395454307781,
+      1.3114236056529345
+    ],
+    "currentAcceleration": [
+      3.85195496465571,
+      0.38714008545656187,
+      6.537426322600666
+    ],
+    "targetPosition": [
+      -9.89065312508715,
+      -1.9323287088302692,
+      2.3500058474285446
+    ],
+    "targetVelocity": [
+      6.43202260966343,
+      3.304861262775616,
+      0.3339525883586445
+    ],
+    "targetAcceleration": [
+      -5.360666329316392,
+      -1.4476476158913019,
+      -5.84656780985304
+    ],
+    "maxVelocity": [
+      7.368939717441596,
+      6.124613600403344,
+      5.4760684139229605
+    ],
+    "maxAcceleration": [
+      5.489843606236783,
+      3.7016987877270746,
+      8.184823703865483
+    ],
+    "maxJerk": [
+      16.945031688676348,
+      13.542664534233179,
+      12.98775300561795
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.880128372154952,
+      -6.564886812081292,
+      -9.881177775637568
+    ],
+    "currentVelocity": [
+      3.473838468360092,
+      -3.055706952713079,
+      -0.10345465309854163
+    ],
+    "currentAcceleration": [
+      0.2849034342709009,
+      4.423155628993497,
+      4.444768818966249
+    ],
+    "targetPosition": [
+      3.048831407789663,
+      -5.281246143967682,
+      5.185842765088296
+    ],
+    "targetVelocity": [
+      3.233792730425008,
+      -3.8154573636718565,
+      -2.0885829616425955
+    ],
+    "targetAcceleration": [
+      -0.5990095995732059,
+      4.14520305127461,
+      -8.27935625540757
+    ],
+    "maxVelocity": [
+      4.395912676627415,
+      7.368528602257695,
+      3.2716129707568538
+    ],
+    "maxAcceleration": [
+      6.9973439182419,
+      6.502139029396446,
+      8.656550101084834
+    ],
+    "maxJerk": [
+      5.069059506163742,
+      14.493167936142775,
+      9.412556476444337
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.1165030846080644,
+      -6.280107807997406,
+      -8.324500886237834
+    ],
+    "currentVelocity": [
+      1.4904302207307683,
+      1.9353362472183262,
+      1.7341231509882293
+    ],
+    "currentAcceleration": [
+      -0.3063629889395969,
+      1.2613440546611354,
+      -4.520846525422841
+    ],
+    "targetPosition": [
+      7.991821750034973,
+      -1.064747528593859,
+      -4.000736192336136
+    ],
+    "targetVelocity": [
+      -2.752108369280863,
+      -2.4337051540460903,
+      2.3903912196037274
+    ],
+    "targetAcceleration": [
+      0.4208054203176639,
+      -0.7184240496528256,
+      1.6931860003817523
+    ],
+    "maxVelocity": [
+      3.3365913115685664,
+      3.422393531991812,
+      3.7281229272053986
+    ],
+    "maxAcceleration": [
+      5.021677292276426,
+      5.490811921569261,
+      8.500926155077284
+    ],
+    "maxJerk": [
+      13.575856745041214,
+      17.107614546983804,
+      13.25904315900449
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.292634644330809,
+      -9.10592438871694,
+      -3.463796977937445
+    ],
+    "currentVelocity": [
+      3.4102454158735362,
+      1.7702688918916074,
+      -3.7227619146659983
+    ],
+    "currentAcceleration": [
+      0.32630662753132,
+      6.32884023178433,
+      -2.854625256076217
+    ],
+    "targetPosition": [
+      -6.15504091057272,
+      -8.072743820928022,
+      -5.815120858805982
+    ],
+    "targetVelocity": [
+      -2.895714739730863,
+      5.2346114192037,
+      -4.147701234815729
+    ],
+    "targetAcceleration": [
+      3.3363328579766023,
+      -7.55599073432211,
+      1.2729920457267712
+    ],
+    "maxVelocity": [
+      7.562713889227748,
+      7.477864026145973,
+      4.5173873636235555
+    ],
+    "maxAcceleration": [
+      8.610157548975529,
+      9.333927036787419,
+      5.234790022138223
+    ],
+    "maxJerk": [
+      15.644054478255605,
+      15.495918551833006,
+      5.8663600451713265
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.1012448021751435,
+      -6.8631618832615775,
+      -4.274828757370422
+    ],
+    "currentVelocity": [
+      1.8649816523104832,
+      5.026816962916573,
+      2.400525442026468
+    ],
+    "currentAcceleration": [
+      2.6367626192918125,
+      -1.742927595491592,
+      -3.021569671087216
+    ],
+    "targetPosition": [
+      0.8714371637572143,
+      3.962675182745576,
+      9.87529131723992
+    ],
+    "targetVelocity": [
+      3.1971993819252393,
+      -1.748413230432024,
+      0.31324539094631554
+    ],
+    "targetAcceleration": [
+      -0.30219545908125367,
+      -5.485438732924267,
+      3.263000373438139
+    ],
+    "maxVelocity": [
+      5.156677579756531,
+      5.991076303462357,
+      5.6084455534367
+    ],
+    "maxAcceleration": [
+      3.775436344042869,
+      9.913954897441554,
+      3.6764578272008492
+    ],
+    "maxJerk": [
+      14.50647259580096,
+      14.883701050626815,
+      12.440617297831409
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.492218247733735,
+      5.063385267395876,
+      9.299749592782234
+    ],
+    "currentVelocity": [
+      -0.6729522536724577,
+      1.038816732251636,
+      -1.3021178107665738
+    ],
+    "currentAcceleration": [
+      2.9576526562556897,
+      1.161118679823005,
+      -0.9007885164883338
+    ],
+    "targetPosition": [
+      1.689870828161519,
+      3.2988493961742105,
+      -1.7534592138738105
+    ],
+    "targetVelocity": [
+      -0.3018062033706692,
+      -4.453903378405528,
+      3.767559670468608
+    ],
+    "targetAcceleration": [
+      -1.6191863087232121,
+      3.4199550292316694,
+      -2.330326187967219
+    ],
+    "maxVelocity": [
+      3.126982833174725,
+      7.930224464690241,
+      4.8121131280317
+    ],
+    "maxAcceleration": [
+      3.2796383933258473,
+      8.0403079970305,
+      4.181348959880297
+    ],
+    "maxJerk": [
+      5.094404605148904,
+      16.976106676217185,
+      5.600743848578404
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.781390943954851,
+      5.847581441139756,
+      -1.5266197210830903
+    ],
+    "currentVelocity": [
+      -3.810655710809957,
+      -1.139455700934609,
+      1.7089727687690095
+    ],
+    "currentAcceleration": [
+      -2.627319334169567,
+      5.7831457741463215,
+      2.2036680677051788
+    ],
+    "targetPosition": [
+      -1.8537404219421312,
+      -6.653345981937376,
+      -9.108907735370577
+    ],
+    "targetVelocity": [
+      4.316549741655266,
+      2.003264726692354,
+      1.5246278572809109
+    ],
+    "targetAcceleration": [
+      -1.8728898132742946,
+      2.9132792114485397,
+      0.6361018847417714
+    ],
+    "maxVelocity": [
+      5.123511881493836,
+      5.592247791378865,
+      5.117774210085229
+    ],
+    "maxAcceleration": [
+      3.6926412155273582,
+      5.984197867808112,
+      8.248994086958575
+    ],
+    "maxJerk": [
+      9.733653278056071,
+      13.404810858756937,
+      10.544629868637545
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7331998741499692,
+      0.9620251934235995,
+      -9.22432081411064
+    ],
+    "currentVelocity": [
+      -4.2234525139230685,
+      -3.1798640977622603,
+      -0.441612831311045
+    ],
+    "currentAcceleration": [
+      -0.3860396258136771,
+      0.33630803798991504,
+      3.469101619427236
+    ],
+    "targetPosition": [
+      3.6096885993574723,
+      -5.269419041425718,
+      -6.171568139163551
+    ],
+    "targetVelocity": [
+      -4.765476229737153,
+      6.435060968022815,
+      -1.3780756092458426
+    ],
+    "targetAcceleration": [
+      -1.684399143883888,
+      1.445241221428951,
+      2.7969471974452578
+    ],
+    "maxVelocity": [
+      5.155319683258487,
+      7.013905074576006,
+      3.4970301324576893
+    ],
+    "maxAcceleration": [
+      4.305484662411649,
+      5.557678147318651,
+      4.00799051612821
+    ],
+    "maxJerk": [
+      19.734457036513643,
+      13.675890784634815,
+      16.48381080694903
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.045622093382018,
+      4.559855559917263,
+      5.567276947205993
+    ],
+    "currentVelocity": [
+      -1.1949667967479973,
+      -5.618260706275335,
+      2.385578724506457
+    ],
+    "currentAcceleration": [
+      -0.06774379589471291,
+      1.4060337170158483,
+      -1.4215202752748732
+    ],
+    "targetPosition": [
+      4.612302028744351,
+      -1.7005670075309727,
+      -3.6344823949798055
+    ],
+    "targetVelocity": [
+      0.19006466645015685,
+      -4.6889612742933995,
+      2.5441848211833746
+    ],
+    "targetAcceleration": [
+      -1.4971189894564612,
+      2.5558956153328856,
+      4.863246181452407
+    ],
+    "maxVelocity": [
+      4.64888840724986,
+      5.917667943748667,
+      3.86086916009214
+    ],
+    "maxAcceleration": [
+      3.973110846445198,
+      3.861019411689118,
+      8.355762052011674
+    ],
+    "maxJerk": [
+      18.24094304771208,
+      19.46402910535308,
+      16.823921561103795
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.2778197188172005,
+      -7.901860316229923,
+      5.121988512900394
+    ],
+    "currentVelocity": [
+      -5.779899092732634,
+      -0.8742991709640546,
+      -0.19287665413327781
+    ],
+    "currentAcceleration": [
+      -3.9691215482347015,
+      5.447251515132109,
+      8.824374850352546
+    ],
+    "targetPosition": [
+      3.7243863327707096,
+      4.647476712406709,
+      6.319997318637419
+    ],
+    "targetVelocity": [
+      4.435125885318447,
+      -0.8913952371932106,
+      0.4243012209800443
+    ],
+    "targetAcceleration": [
+      4.100338757904834,
+      6.892001236882312,
+      6.030567505536567
+    ],
+    "maxVelocity": [
+      7.921932458644337,
+      3.1736223781311725,
+      2.2542662247791796
+    ],
+    "maxAcceleration": [
+      5.5933080701701146,
+      9.096982189745638,
+      9.110314741317575
+    ],
+    "maxJerk": [
+      13.433724118812648,
+      15.522450392690248,
+      17.790836597155355
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.601914114802284,
+      -8.771573753903802,
+      -5.587278547867925
+    ],
+    "currentVelocity": [
+      3.775443621165728,
+      -0.1740875012798817,
+      4.242200438783367
+    ],
+    "currentAcceleration": [
+      -3.8981672103285874,
+      2.757940654880488,
+      -0.7003778876949713
+    ],
+    "targetPosition": [
+      2.8113690833878575,
+      9.721133073147644,
+      -0.1985955319253776
+    ],
+    "targetVelocity": [
+      -6.031871692904235,
+      -6.367904156563162,
+      -1.6425074032162836
+    ],
+    "targetAcceleration": [
+      -0.28537277680601214,
+      -0.08218538869443126,
+      -1.1737057005333593
+    ],
+    "maxVelocity": [
+      7.148801949992425,
+      6.620187486463343,
+      4.663149455011665
+    ],
+    "maxAcceleration": [
+      6.73380077709537,
+      7.62433045011793,
+      5.065461591443578
+    ],
+    "maxJerk": [
+      10.922950470154477,
+      16.592891943777417,
+      12.785009183905466
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.4929235821328355,
+      7.017677912302879,
+      8.379431184583229
+    ],
+    "currentVelocity": [
+      5.7172442754957515,
+      0.40156387843294095,
+      2.351767522956851
+    ],
+    "currentAcceleration": [
+      5.2594916155943405,
+      -1.6039048790402433,
+      0.6843819748486246
+    ],
+    "targetPosition": [
+      4.624251365180683,
+      -2.2238687565789057,
+      -5.433787290893861
+    ],
+    "targetVelocity": [
+      4.965765242739566,
+      -1.6737502306786385,
+      4.334883523587162
+    ],
+    "targetAcceleration": [
+      7.9613484496288365,
+      -2.144652211743268,
+      1.444759464412313
+    ],
+    "maxVelocity": [
+      6.896579006106554,
+      4.473417619854522,
+      4.939823699590133
+    ],
+    "maxAcceleration": [
+      9.749173570844924,
+      6.8797132048007725,
+      3.6047463035791876
+    ],
+    "maxJerk": [
+      16.465479507102046,
+      18.271567083190394,
+      6.777118769671558
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.3974044502696525,
+      9.084484674980175,
+      -7.148088235757182
+    ],
+    "currentVelocity": [
+      0.669666239566383,
+      2.658690239033847,
+      -0.7063817634119633
+    ],
+    "currentAcceleration": [
+      -5.019300387672736,
+      5.758884488146952,
+      -4.237487339575976
+    ],
+    "targetPosition": [
+      8.247627133735012,
+      -8.169478654197103,
+      4.474802463068775
+    ],
+    "targetVelocity": [
+      -1.4223205249695794,
+      -2.428180592629538,
+      1.172272530611202
+    ],
+    "targetAcceleration": [
+      -3.1012043675096566,
+      -5.674679870732825,
+      -1.0327675092150441
+    ],
+    "maxVelocity": [
+      2.0756821388572595,
+      5.308075553362557,
+      2.2150373391160745
+    ],
+    "maxAcceleration": [
+      7.999900710333513,
+      8.149952979624045,
+      4.330096121201491
+    ],
+    "maxJerk": [
+      17.46824490025507,
+      13.54357138079914,
+      14.995055837010298
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.75454940697243,
+      4.7314458192541196,
+      0.49723168996426637
+    ],
+    "currentVelocity": [
+      -1.7319564922138366,
+      -3.046473886750241,
+      3.250038549403155
+    ],
+    "currentAcceleration": [
+      -3.6574768740995687,
+      -2.63325608705372,
+      1.8570739862010726
+    ],
+    "targetPosition": [
+      -9.046578126637923,
+      -0.7384802671738573,
+      -3.231335263222168
+    ],
+    "targetVelocity": [
+      -1.5638392770071725,
+      -3.724196080235247,
+      0.5899185764609864
+    ],
+    "targetAcceleration": [
+      -1.6153081155457283,
+      0.5424138297954695,
+      -1.7017541310771078
+    ],
+    "maxVelocity": [
+      2.64336601887919,
+      4.4488726441608435,
+      4.335588919979802
+    ],
+    "maxAcceleration": [
+      9.09990562959044,
+      4.388553084087321,
+      3.617636910679493
+    ],
+    "maxJerk": [
+      13.866874243115948,
+      6.3980250015122015,
+      19.122114531822625
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.0374653600687065,
+      -1.7840765935628582,
+      2.510885621186489
+    ],
+    "currentVelocity": [
+      -0.8712868041044233,
+      -6.968822651057721,
+      -2.253923082358426
+    ],
+    "currentAcceleration": [
+      1.361830790402144,
+      -2.3049982385674417,
+      4.235436289516123
+    ],
+    "targetPosition": [
+      -3.5292654587716736,
+      7.377517697780473,
+      2.9939071685132284
+    ],
+    "targetVelocity": [
+      0.8004922180532987,
+      6.471948708612654,
+      -3.453829263230928
+    ],
+    "targetAcceleration": [
+      -3.6339628599792566,
+      -5.27823041690245,
+      -2.0827832949900267
+    ],
+    "maxVelocity": [
+      2.118468213846765,
+      7.536741861084488,
+      7.059007087471478
+    ],
+    "maxAcceleration": [
+      5.70350219405335,
+      7.671981220241577,
+      4.839176736689641
+    ],
+    "maxJerk": [
+      13.072333295803517,
+      14.864414848393356,
+      16.04599781821088
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.6831486699311586,
+      9.591671670663949,
+      6.7878793070691295
+    ],
+    "currentVelocity": [
+      -4.874038834085363,
+      5.326667468226235,
+      -5.436412860525689
+    ],
+    "currentAcceleration": [
+      6.4429761239975125,
+      1.429443086704966,
+      4.802092370572966
+    ],
+    "targetPosition": [
+      8.245390619552026,
+      0.3489757650694756,
+      -0.9928792371155168
+    ],
+    "targetVelocity": [
+      -5.562297202111808,
+      -3.5654586249318276,
+      1.1263887429818418
+    ],
+    "targetAcceleration": [
+      1.0516589928032012,
+      -7.377375673555463,
+      -2.8275553366702715
+    ],
+    "maxVelocity": [
+      6.879644635439361,
+      5.543243353406885,
+      6.835938473118682
+    ],
+    "maxAcceleration": [
+      6.445049273039912,
+      8.956100342940204,
+      7.793159333050236
+    ],
+    "maxJerk": [
+      7.847171736387739,
+      8.295155754188333,
+      7.492526881899307
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.21810098785069165,
+      9.608430555538781,
+      8.604390007269267
+    ],
+    "currentVelocity": [
+      1.426049372136191,
+      -0.7005974857007304,
+      0.126084036107466
+    ],
+    "currentAcceleration": [
+      -3.8236633257865633,
+      -2.836169710511254,
+      2.621293285691234
+    ],
+    "targetPosition": [
+      6.361788062048014,
+      -8.177923909559532,
+      2.1553976350952393
+    ],
+    "targetVelocity": [
+      1.6800401899037656,
+      0.9659353940723934,
+      3.0024721119367666
+    ],
+    "targetAcceleration": [
+      2.962933471487041,
+      -0.35698598150559313,
+      -3.4572779892331877
+    ],
+    "maxVelocity": [
+      2.332178076751518,
+      2.537894197486642,
+      4.159280081535483
+    ],
+    "maxAcceleration": [
+      6.698406808978733,
+      4.091510616134878,
+      3.7181006325862374
+    ],
+    "maxJerk": [
+      5.552941572661957,
+      11.533789879130344,
+      8.047373698941197
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.992868303407132,
+      -6.120101035852219,
+      2.5532683147358437
+    ],
+    "currentVelocity": [
+      -0.6379275161479723,
+      2.027492781944343,
+      -0.4501502913361004
+    ],
+    "currentAcceleration": [
+      0.17667364389676443,
+      -1.9265780801389512,
+      -1.747381659978283
+    ],
+    "targetPosition": [
+      4.379758719034765,
+      -9.268717722798215,
+      -8.480960716930534
+    ],
+    "targetVelocity": [
+      0.42716864360999374,
+      -2.5409545337830695,
+      0.326841798196142
+    ],
+    "targetAcceleration": [
+      7.557058560626819,
+      -1.5728227300585127,
+      -0.8216631954421034
+    ],
+    "maxVelocity": [
+      2.255233364062379,
+      2.785275281569453,
+      3.443977736843644
+    ],
+    "maxAcceleration": [
+      8.275898234403652,
+      4.791041213693216,
+      3.9782148169733618
+    ],
+    "maxJerk": [
+      13.937879716361053,
+      6.325146749729001,
+      14.906105312332564
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.7067755332894947,
+      9.254870315140554,
+      3.888782394730562
+    ],
+    "currentVelocity": [
+      1.4458886631629109,
+      0.20151932023501873,
+      -0.9426690882222282
+    ],
+    "currentAcceleration": [
+      -3.914744586036486,
+      -3.7831449091123246,
+      4.094445599732608
+    ],
+    "targetPosition": [
+      9.90338570188603,
+      -2.3260449147273787,
+      2.313862852938648
+    ],
+    "targetVelocity": [
+      0.48670849442450814,
+      -1.805394512722847,
+      0.593502092544965
+    ],
+    "targetAcceleration": [
+      -2.235534258992488,
+      0.3700783122685678,
+      -0.3743486921505017
+    ],
+    "maxVelocity": [
+      2.1080585397888125,
+      2.515469620171869,
+      2.1188983418684852
+    ],
+    "maxAcceleration": [
+      5.462999535765241,
+      7.766753613953947,
+      5.642552746230346
+    ],
+    "maxJerk": [
+      13.759391622869087,
+      17.412598492125507,
+      18.84036164611062
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.4853222003181976,
+      -1.2536219062585339,
+      5.053398799542446
+    ],
+    "currentVelocity": [
+      4.287582144139398,
+      4.423204013818447,
+      3.296518525588729
+    ],
+    "currentAcceleration": [
+      2.890834233240624,
+      3.706728440274956,
+      -4.41559390096147
+    ],
+    "targetPosition": [
+      4.159431836077982,
+      0.41775511255019104,
+      0.9486306860009304
+    ],
+    "targetVelocity": [
+      -3.245476856638255,
+      2.773716680419419,
+      3.835074262719325
+    ],
+    "targetAcceleration": [
+      -4.188954827436413,
+      -1.3354788466978724,
+      1.1282247098479523
+    ],
+    "maxVelocity": [
+      7.050019176149968,
+      5.345174176402427,
+      4.187470039184725
+    ],
+    "maxAcceleration": [
+      7.966390215248457,
+      4.961459761690673,
+      8.122218115381068
+    ],
+    "maxJerk": [
+      10.475873053248403,
+      14.607252012468454,
+      19.821378225541878
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.252660086840567,
+      -0.8788712780207213,
+      -7.424989778768261
+    ],
+    "currentVelocity": [
+      1.2153991617227486,
+      -2.3825476637272325,
+      -5.309539563665892
+    ],
+    "currentAcceleration": [
+      0.8095702180527837,
+      6.877750314121938,
+      0.2308920896304314
+    ],
+    "targetPosition": [
+      6.722495184724167,
+      -2.4222887042251102,
+      -0.44083536563439907
+    ],
+    "targetVelocity": [
+      4.494501625397456,
+      -1.7708728074772782,
+      5.129305454783794
+    ],
+    "targetAcceleration": [
+      -4.75967666479081,
+      4.717638294537455,
+      0.9765919119629518
+    ],
+    "maxVelocity": [
+      6.371366282449156,
+      5.450977739615543,
+      7.354717930318894
+    ],
+    "maxAcceleration": [
+      7.376293439715026,
+      6.980563514450473,
+      3.4378140593141233
+    ],
+    "maxJerk": [
+      7.737648751750009,
+      16.897010331601827,
+      9.42696156247976
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.2799995936961572,
+      5.326572644953361,
+      -0.025668831377359425
+    ],
+    "currentVelocity": [
+      1.8150717047317126,
+      3.000512878665619,
+      2.365035542125021
+    ],
+    "currentAcceleration": [
+      1.5202315139649158,
+      0.8546867905389863,
+      3.8016418078285623
+    ],
+    "targetPosition": [
+      5.027190758128501,
+      6.503397856095621,
+      -5.664054656653046
+    ],
+    "targetVelocity": [
+      0.6014417481220624,
+      6.573820653668042,
+      0.5183479977168819
+    ],
+    "targetAcceleration": [
+      -2.17742998036798,
+      5.499245178087911,
+      3.4905251705025693
+    ],
+    "maxVelocity": [
+      5.790354225599106,
+      6.643340298954463,
+      3.381312214231632
+    ],
+    "maxAcceleration": [
+      4.117731654696746,
+      8.321619842010367,
+      4.975574637026432
+    ],
+    "maxJerk": [
+      6.876225107428599,
+      17.867545033519075,
+      15.536954122326362
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.222827587633315,
+      3.191771916142212,
+      -0.20282675222032687
+    ],
+    "currentVelocity": [
+      -4.6426767080619165,
+      -1.6187044915036521,
+      4.540307693591824
+    ],
+    "currentAcceleration": [
+      -3.402465779926186,
+      -0.7231859253949735,
+      -0.9569945903408703
+    ],
+    "targetPosition": [
+      6.1445790425182985,
+      1.474840711534311,
+      -8.050857564542264
+    ],
+    "targetVelocity": [
+      -4.281887878052862,
+      0.44049853001098294,
+      -3.390525628893966
+    ],
+    "targetAcceleration": [
+      -3.127097161322952,
+      1.182299358014152,
+      -0.6503795010741777
+    ],
+    "maxVelocity": [
+      6.930234879452255,
+      2.837103619786243,
+      4.8430928783143745
+    ],
+    "maxAcceleration": [
+      4.134114493809646,
+      3.737717790242928,
+      4.6617545324690335
+    ],
+    "maxJerk": [
+      12.247097347619608,
+      17.366035274540224,
+      9.870104504548536
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.491187797467838,
+      -2.387331532950263,
+      -2.2052799577609727
+    ],
+    "currentVelocity": [
+      0.7196311576756522,
+      -0.7184949340466042,
+      2.186570480854301
+    ],
+    "currentAcceleration": [
+      -1.5079085137944968,
+      0.09401942571787192,
+      5.660423209120935
+    ],
+    "targetPosition": [
+      -9.47243596516963,
+      7.322378964862196,
+      -6.571473340960072
+    ],
+    "targetVelocity": [
+      0.8057396452847865,
+      -1.197568940817167,
+      2.0680708997911834
+    ],
+    "targetAcceleration": [
+      0.48558968351330156,
+      4.574806848298181,
+      0.9629681580276239
+    ],
+    "maxVelocity": [
+      2.7275713470071654,
+      2.3549852353062004,
+      5.890169862116379
+    ],
+    "maxAcceleration": [
+      3.565887468764528,
+      4.613605059633503,
+      5.812310653155947
+    ],
+    "maxJerk": [
+      14.42139729475621,
+      17.02175517497227,
+      14.10449184967372
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.5236976599953671,
+      -0.40807007598885114,
+      8.22848275441196
+    ],
+    "currentVelocity": [
+      -2.5137738208680647,
+      -0.29731726924210555,
+      -1.0087517052861443
+    ],
+    "currentAcceleration": [
+      2.2957309546468747,
+      2.16307619270359,
+      0.10004635832058373
+    ],
+    "targetPosition": [
+      -3.373911105234222,
+      4.448127637804973,
+      4.646844342370597
+    ],
+    "targetVelocity": [
+      1.345774073183276,
+      0.5698377044963534,
+      -2.2479378582567655
+    ],
+    "targetAcceleration": [
+      1.713381641901624,
+      -5.572834380685377,
+      -1.7002269426900947
+    ],
+    "maxVelocity": [
+      4.299309188557761,
+      4.613958644258687,
+      3.7655522342567607
+    ],
+    "maxAcceleration": [
+      3.206320762457914,
+      8.082345496810419,
+      5.186743361239062
+    ],
+    "maxJerk": [
+      15.255443242206502,
+      18.84519638901661,
+      7.123063153933865
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.787167282531684,
+      -1.2219237413903912,
+      1.842062903868321
+    ],
+    "currentVelocity": [
+      2.4036095465285925,
+      -3.4343919499492626,
+      -0.05219124718483581
+    ],
+    "currentAcceleration": [
+      2.3843818898194655,
+      -5.69574785201246,
+      -0.28682273279653536
+    ],
+    "targetPosition": [
+      4.188183752148763,
+      1.523170107031678,
+      8.189789371305803
+    ],
+    "targetVelocity": [
+      -4.374149597935105,
+      -0.42451949457497307,
+      3.602627215874425
+    ],
+    "targetAcceleration": [
+      2.1707202235146745,
+      -0.27937664435173204,
+      0.616533037047744
+    ],
+    "maxVelocity": [
+      5.129100703870414,
+      4.430936347782379,
+      5.5923471194538665
+    ],
+    "maxAcceleration": [
+      5.780061241935188,
+      7.349805091021329,
+      5.615615038892384
+    ],
+    "maxJerk": [
+      5.25636627849212,
+      19.80984854871428,
+      7.884823000213963
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.84759046438398,
+      -1.775876131501196,
+      -2.7874469482976316
+    ],
+    "currentVelocity": [
+      0.654346531527815,
+      0.7736528026879763,
+      3.494164228297212
+    ],
+    "currentAcceleration": [
+      -3.2851105183759843,
+      4.057872059265326,
+      -3.381384980603935
+    ],
+    "targetPosition": [
+      -9.104669412355781,
+      -0.7970409663525686,
+      -3.997845657579804
+    ],
+    "targetVelocity": [
+      2.5627785885516596,
+      -0.6018925237522199,
+      1.119659259340585
+    ],
+    "targetAcceleration": [
+      5.199065106195395,
+      -2.6808393520613203,
+      0.23923123520540202
+    ],
+    "maxVelocity": [
+      3.479277943039375,
+      2.43144669961444,
+      4.577774723706177
+    ],
+    "maxAcceleration": [
+      8.842055093443253,
+      6.196265456055797,
+      5.3166498015942
+    ],
+    "maxJerk": [
+      8.592215941141543,
+      7.255213352077127,
+      14.491304666192237
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.9432265396594666,
+      -4.864883241875962,
+      3.2213246622168263
+    ],
+    "currentVelocity": [
+      2.299811341507594,
+      1.8792780648269298,
+      1.309426092162533
+    ],
+    "currentAcceleration": [
+      -0.19085600031044692,
+      -5.681205278605111,
+      3.034264987521677
+    ],
+    "targetPosition": [
+      -1.1165434307976856,
+      8.543309635682895,
+      -5.081558148245131
+    ],
+    "targetVelocity": [
+      -5.180128087778378,
+      3.820644905195704,
+      4.494738936350635
+    ],
+    "targetAcceleration": [
+      2.317987369983605,
+      5.737154791951909,
+      -2.784555748516928
+    ],
+    "maxVelocity": [
+      5.737475545943388,
+      7.386793945864521,
+      6.255841070018604
+    ],
+    "maxAcceleration": [
+      6.654170099152704,
+      6.048237247914441,
+      5.3570748488545785
+    ],
+    "maxJerk": [
+      18.57125273808002,
+      12.982428957591356,
+      15.82770683064815
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.186595074749505,
+      -6.681956496314405,
+      -9.663507843329874
+    ],
+    "currentVelocity": [
+      5.549185724597791,
+      1.0111407968237058,
+      2.4850264636246306
+    ],
+    "currentAcceleration": [
+      0.14023555569415702,
+      -2.723867041964284,
+      -0.667458408453852
+    ],
+    "targetPosition": [
+      -5.688724243804025,
+      2.1701780122722596,
+      -6.348311474619541
+    ],
+    "targetVelocity": [
+      -0.6190504848309066,
+      -2.0745253785464217,
+      -0.049544354217352815
+    ],
+    "targetAcceleration": [
+      -3.484149540963655,
+      0.5465658086693699,
+      0.9550544795755336
+    ],
+    "maxVelocity": [
+      5.97725208212597,
+      3.0213839991203644,
+      2.6109285666171314
+    ],
+    "maxAcceleration": [
+      5.359264234547993,
+      6.30663977538406,
+      8.70442631457481
+    ],
+    "maxJerk": [
+      12.157771063253069,
+      16.16421114255691,
+      16.198501379611763
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 3,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.625909402294923,
+      -9.144269956617418,
+      -0.7958441608375839
+    ],
+    "currentVelocity": [
+      0.0022150112523542376,
+      -2.2955196855569304,
+      -1.2643541505945493
+    ],
+    "currentAcceleration": [
+      -5.528552642764304,
+      2.3417603496029336,
+      -4.121488078245095
+    ],
+    "targetPosition": [
+      -8.4989746792448,
+      2.9070518143957784,
+      -0.40908016488033994
+    ],
+    "targetVelocity": [
+      -5.437010368257929,
+      1.2439112701424442,
+      3.3728170459744824
+    ],
+    "targetAcceleration": [
+      -0.43792676170028955,
+      -0.6955882333059686,
+      1.3192254366228653
+    ],
+    "maxVelocity": [
+      7.112399954100547,
+      2.504815302695518,
+      3.4553764258781685
+    ],
+    "maxAcceleration": [
+      9.99680128140906,
+      3.9629144979123176,
+      8.860760916024319
+    ],
+    "maxJerk": [
+      6.701493665246544,
+      13.253962607053577,
+      16.242607472275164
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.211542446902168,
+      2.6643741323378833,
+      4.121196924472557,
+      0.526177088530396
+    ],
+    "currentVelocity": [
+      -4.74324817887951,
+      -3.0542337136788094,
+      -3.8763272535452424,
+      1.4627995337220003
+    ],
+    "currentAcceleration": [
+      2.729838512912826,
+      -4.853341347441253,
+      3.380412309497066,
+      -4.8534264067280315
+    ],
+    "targetPosition": [
+      1.6107948650561088,
+      -8.471191123240189,
+      -8.655293950825868,
+      -2.369376631177797
+    ],
+    "targetVelocity": [
+      -4.536931475101703,
+      1.052524885153968,
+      -2.3144246960368315,
+      -0.12145644923276322
+    ],
+    "targetAcceleration": [
+      -1.8371670821882433,
+      -4.133020636553736,
+      1.184952289064623,
+      5.223429695896451
+    ],
+    "maxVelocity": [
+      7.045554266524292,
+      4.417861615018507,
+      6.554800043043047,
+      3.3592986987283924
+    ],
+    "maxAcceleration": [
+      4.632361928674181,
+      7.600571439325988,
+      4.762812678680239,
+      7.752893338551749
+    ],
+    "maxJerk": [
+      11.97993292291719,
+      16.561542620900703,
+      11.818947760057046,
+      11.269821456130199
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.883085559885391,
+      5.98654613657974,
+      -5.297538687565019,
+      -2.282705776080274
+    ],
+    "currentVelocity": [
+      -1.2924484463494657,
+      6.34870569581397,
+      1.631390071812767,
+      0.871833744776576
+    ],
+    "currentAcceleration": [
+      3.505653454148394,
+      -0.005255438385773914,
+      -2.439699541297084,
+      1.7612073581084342
+    ],
+    "targetPosition": [
+      7.7604590791133035,
+      4.358271329335819,
+      8.467862785375196,
+      3.9791850623459872
+    ],
+    "targetVelocity": [
+      -3.2936522228256306,
+      -5.375706497456665,
+      5.92647024275378,
+      1.8613091369746533
+    ],
+    "targetAcceleration": [
+      4.405839298999181,
+      2.4803072321171946,
+      -1.1710323980260702,
+      -3.931354345631772
+    ],
+    "maxVelocity": [
+      4.62168323640398,
+      6.6637713546185084,
+      7.824894651311183,
+      3.2801537527920086
+    ],
+    "maxAcceleration": [
+      7.569151336863332,
+      4.08050982002943,
+      3.2803792967954384,
+      9.666595811967268
+    ],
+    "maxJerk": [
+      12.543103575861073,
+      6.134354006694142,
+      14.506973640585331,
+      9.833765989105625
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.639852198384027,
+      4.098926578200736,
+      1.9779580151153588,
+      7.5180286492787864
+    ],
+    "currentVelocity": [
+      4.050551275094007,
+      -3.720682458708576,
+      -3.17693863120165,
+      -2.6366907677785667
+    ],
+    "currentAcceleration": [
+      -3.172556379986154,
+      6.196383733917425,
+      -0.39342825221779076,
+      -0.6218217761572418
+    ],
+    "targetPosition": [
+      9.46880697295699,
+      -0.6962918101663895,
+      -3.27366924911082,
+      8.63942023990236
+    ],
+    "targetVelocity": [
+      0.04838678606105162,
+      3.743527661078942,
+      4.744828199248025,
+      -2.5349130344625355
+    ],
+    "targetAcceleration": [
+      -3.4604890409090987,
+      -2.922195172913793,
+      -1.150867627513521,
+      2.2776028547442504
+    ],
+    "maxVelocity": [
+      4.0699567575888,
+      7.026233338885677,
+      5.601291387109156,
+      3.183769317009931
+    ],
+    "maxAcceleration": [
+      3.7371397156787562,
+      6.974679006560199,
+      3.2209185361345867,
+      3.5154867080860273
+    ],
+    "maxJerk": [
+      7.335571606967019,
+      6.300864214005818,
+      10.45694819496043,
+      17.044056540179753
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.031976164058860945,
+      -8.086452969330022,
+      -8.738595319269894,
+      -0.6018298949362215
+    ],
+    "currentVelocity": [
+      -3.8763675395672794,
+      2.8002472822704636,
+      -3.440987971836817,
+      2.953797299734771
+    ],
+    "currentAcceleration": [
+      -0.4428475317540297,
+      -2.8424290669500367,
+      7.695643467481894,
+      5.598805672600619
+    ],
+    "targetPosition": [
+      -7.510892182285578,
+      8.36388505457748,
+      -6.270966718968609,
+      -9.878583615542523
+    ],
+    "targetVelocity": [
+      1.7680589587862983,
+      3.347741495819408,
+      0.4652685196174282,
+      -1.640856353582942
+    ],
+    "targetAcceleration": [
+      -4.370656114135757,
+      -6.248589984920411,
+      0.6652304337636696,
+      -0.979478587161279
+    ],
+    "maxVelocity": [
+      7.0956594856983894,
+      4.9797409564316,
+      4.162021939352568,
+      5.60146706834533
+    ],
+    "maxAcceleration": [
+      6.434554465312916,
+      9.125787276490833,
+      9.552261981261939,
+      8.028229328907791
+    ],
+    "maxJerk": [
+      17.81119108203096,
+      17.269318151258197,
+      15.445244199226288,
+      13.971064805985245
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.928679489603464,
+      2.0401961276997547,
+      -8.959396264408262,
+      8.120746431654403
+    ],
+    "currentVelocity": [
+      -0.6096060800306331,
+      -1.4047186240466534,
+      -6.096407243886405,
+      -2.1293376007166462
+    ],
+    "currentAcceleration": [
+      2.71235836785959,
+      -6.914871220768694,
+      -1.000432953438323,
+      3.5772445833471593
+    ],
+    "targetPosition": [
+      -3.2704821162785036,
+      -6.443624749705201,
+      -3.6742809358813737,
+      -4.14328798163818
+    ],
+    "targetVelocity": [
+      1.9925304087306301,
+      -0.2919923672667917,
+      1.7759530157171248,
+      1.233404367485984
+    ],
+    "targetAcceleration": [
+      -0.8471669454579529,
+      2.4435631220790768,
+      -3.5211328519822773,
+      6.711455509649857
+    ],
+    "maxVelocity": [
+      3.105744533871765,
+      5.887913454123245,
+      6.483778927629654,
+      2.612859572248409
+    ],
+    "maxAcceleration": [
+      4.8210268955841205,
+      9.564689016639893,
+      6.869581949279123,
+      6.875795213938831
+    ],
+    "maxJerk": [
+      13.383598633034811,
+      13.018634811415428,
+      6.207853536934479,
+      18.39949480190237
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.196285066916879,
+      0.8911097600709041,
+      -6.990371859714362,
+      -9.512077002148425
+    ],
+    "currentVelocity": [
+      -0.6507168301604362,
+      1.164592909045206,
+      -1.9225941103392614,
+      -2.2301853985550015
+    ],
+    "currentAcceleration": [
+      -5.400574630753138,
+      3.4180930377025422,
+      4.592048795398,
+      4.482069838975773
+    ],
+    "targetPosition": [
+      -3.040219403238229,
+      5.094195527326624,
+      9.184976492092623,
+      6.065829624549245
+    ],
+    "targetVelocity": [
+      0.8405828749503135,
+      2.901191308516479,
+      -7.584118137467144,
+      -3.5920697876329473
+    ],
+    "targetAcceleration": [
+      2.924423239435802,
+      -6.163007983551527,
+      2.455176611149052,
+      5.554375965743876
+    ],
+    "maxVelocity": [
+      2.126632267351044,
+      4.869611266463959,
+      7.886872584615654,
+      5.6766473845298915
+    ],
+    "maxAcceleration": [
+      6.2822691369151205,
+      8.528979950606647,
+      4.987991684193936,
+      5.997895103894223
+    ],
+    "maxJerk": [
+      15.2697517342439,
+      15.227517109280862,
+      13.72457288236691,
+      9.411696967428924
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.716485016011468,
+      9.701329158281048,
+      0.41856943910368827,
+      -1.4823161639693883
+    ],
+    "currentVelocity": [
+      1.0719529522913218,
+      4.226865855545654,
+      0.2858184275791733,
+      1.4731059106900597
+    ],
+    "currentAcceleration": [
+      -3.1282225969831954,
+      2.3868787753317164,
+      3.0771478294645966,
+      -3.86526262038012
+    ],
+    "targetPosition": [
+      3.3333522131689364,
+      0.9897497984055086,
+      1.4150205066433141,
+      3.842571898279745
+    ],
+    "targetVelocity": [
+      -2.7547154487093715,
+      4.800471453436796,
+      -0.0019342645371538403,
+      2.574226481636142
+    ],
+    "targetAcceleration": [
+      1.6278255298100923,
+      0.7055376815486047,
+      -0.1711034239524416,
+      3.1475531046575167
+    ],
+    "maxVelocity": [
+      4.356432432753302,
+      6.320502912087381,
+      3.6982532067698988,
+      6.401542246172561
+    ],
+    "maxAcceleration": [
+      8.141471336115114,
+      5.64628671405187,
+      8.990228839393552,
+      9.958594786366655
+    ],
+    "maxJerk": [
+      15.058374669296832,
+      19.43338261196005,
+      10.034585638153022,
+      18.06987138556332
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.078088735893303,
+      9.184348566257125,
+      -3.5323845563807232,
+      4.753172498969313
+    ],
+    "currentVelocity": [
+      -6.488159417807945,
+      -3.8330370786960657,
+      -2.479165979969073,
+      1.3289436921627709
+    ],
+    "currentAcceleration": [
+      -1.6446539738520247,
+      4.685199749596462,
+      2.5492677475249748,
+      2.749128893723105
+    ],
+    "targetPosition": [
+      -1.4294009987156624,
+      -5.14152470460747,
+      -7.928929485511242,
+      -6.985420560736959
+    ],
+    "targetVelocity": [
+      0.30523780114772947,
+      -2.1367372639071376,
+      -3.1941072589021924,
+      -1.7155327919103405
+    ],
+    "targetAcceleration": [
+      -5.608890780052828,
+      5.69019975897457,
+      0.9068309320601395,
+      1.755705505965797
+    ],
+    "maxVelocity": [
+      6.781449747392815,
+      4.211733245950682,
+      3.453056325627823,
+      3.2323685753805855
+    ],
+    "maxAcceleration": [
+      7.581133706542707,
+      9.485202934669966,
+      3.012775112059999,
+      4.265591423849664
+    ],
+    "maxJerk": [
+      15.077579701488553,
+      18.069469129757763,
+      11.862648560686537,
+      15.429636007628538
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.45667822056101,
+      -8.030187235155893,
+      -7.668907962299041,
+      1.0914903328877479
+    ],
+    "currentVelocity": [
+      1.5588119236566493,
+      -2.5741392642477385,
+      -1.4438214066802697,
+      1.5875157613146063
+    ],
+    "currentAcceleration": [
+      4.196910003327964,
+      2.549309248432623,
+      0.39307722073137974,
+      -7.017448835998226
+    ],
+    "targetPosition": [
+      9.976941781053846,
+      -5.4646527386109085,
+      -8.944005858647625,
+      -8.968446567761728
+    ],
+    "targetVelocity": [
+      -0.3047888937473049,
+      0.20282912867739622,
+      -2.5310701769359802,
+      -1.6825981816279656
+    ],
+    "targetAcceleration": [
+      0.9554477359376454,
+      2.9753103187109167,
+      0.5354150114408913,
+      -6.813374627858135
+    ],
+    "maxVelocity": [
+      6.819232217839363,
+      2.598080133200069,
+      4.590990791954862,
+      2.277556418397288
+    ],
+    "maxAcceleration": [
+      6.013730736031127,
+      3.0802171660918765,
+      3.86163965374668,
+      8.989991837927011
+    ],
+    "maxJerk": [
+      8.196087346567136,
+      6.6234867257785535,
+      19.183050191310546,
+      19.31607760479441
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0886357363612476,
+      -0.4001560901951269,
+      4.201346270031516,
+      -2.2377721351303936
+    ],
+    "currentVelocity": [
+      1.8848830014454556,
+      2.9175105402869885,
+      -1.4084699685202364,
+      1.4595898960618623
+    ],
+    "currentAcceleration": [
+      -3.394342140561498,
+      4.09975394634874,
+      7.98987686651266,
+      -0.3805741104124696
+    ],
+    "targetPosition": [
+      -1.0137976619158913,
+      -3.600990086782021,
+      4.591759436209733,
+      -5.696717706138568
+    ],
+    "targetVelocity": [
+      2.416458972827246,
+      3.7782360619752016,
+      2.0324085637890548,
+      2.380475063970522
+    ],
+    "targetAcceleration": [
+      -3.3286480850252937,
+      2.647755713508044,
+      7.773550605247273,
+      -2.765434873432894
+    ],
+    "maxVelocity": [
+      2.7428470469921686,
+      4.880879604430854,
+      2.923162787644314,
+      2.9810562226009463
+    ],
+    "maxAcceleration": [
+      5.37408899718792,
+      7.225821222881347,
+      8.278362674764736,
+      6.771844787530694
+    ],
+    "maxJerk": [
+      17.846202583290758,
+      19.691665791573733,
+      17.6578789656541,
+      17.848297072721948
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.05814523525193849,
+      -8.410538925244015,
+      0.7264898004242877,
+      -8.214598282284575
+    ],
+    "currentVelocity": [
+      -0.6591407091811421,
+      5.171800002077639,
+      0.6582328792402583,
+      -0.06984366303047551
+    ],
+    "currentAcceleration": [
+      -3.127676357028382,
+      -1.9922512179112415,
+      -2.2964568243618286,
+      -1.7112454916258288
+    ],
+    "targetPosition": [
+      9.051322859820466,
+      2.4983485325212023,
+      8.893350946914968,
+      0.4711391359453021
+    ],
+    "targetVelocity": [
+      2.852512590639538,
+      7.238294751193267,
+      4.61939039435553,
+      -0.017211904848581483
+    ],
+    "targetAcceleration": [
+      1.4710475658717463,
+      -4.691090213681741,
+      -3.263390713940281,
+      -0.6536325668989713
+    ],
+    "maxVelocity": [
+      7.010583311019447,
+      7.9185231213815666,
+      7.086463724808918,
+      4.268886225707194
+    ],
+    "maxAcceleration": [
+      3.9080035387630367,
+      5.914355586505311,
+      3.87734653238598,
+      6.1100104300996065
+    ],
+    "maxJerk": [
+      11.559725981672784,
+      17.013153892451722,
+      8.867667805170797,
+      16.130910746747055
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.508999366595283,
+      -6.667593420505633,
+      -1.6777997670210318,
+      1.3333049441844036
+    ],
+    "currentVelocity": [
+      4.1553212070809185,
+      -3.144992789486383,
+      2.294546729358882,
+      5.343715372884086
+    ],
+    "currentAcceleration": [
+      -7.212459136994245,
+      1.284230230450076,
+      -1.8637825052289587,
+      0.5695991266248335
+    ],
+    "targetPosition": [
+      5.186771611644119,
+      3.6779702696837298,
+      0.26968490309401183,
+      3.1934349632186816
+    ],
+    "targetVelocity": [
+      1.8515203639570919,
+      4.849873304951089,
+      1.3087383292905592,
+      6.156749649232221
+    ],
+    "targetAcceleration": [
+      -5.009380629640548,
+      6.38009823024484,
+      0.07462103675638776,
+      3.3902943476117287
+    ],
+    "maxVelocity": [
+      4.597154132103412,
+      6.48977095822047,
+      2.882726878252564,
+      7.217612793916249
+    ],
+    "maxAcceleration": [
+      7.961656088052054,
+      7.602742159254232,
+      6.305320239729994,
+      7.749124206061143
+    ],
+    "maxJerk": [
+      17.87905049433271,
+      16.625852999803833,
+      18.307191544713667,
+      14.817961395195603
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.3293909129332455,
+      3.2305172579567927,
+      -7.241292544935051,
+      -4.002100253039367
+    ],
+    "currentVelocity": [
+      4.8524037593439795,
+      2.979959699399277,
+      0.7499522662064169,
+      2.1126064435275556
+    ],
+    "currentAcceleration": [
+      1.256703661881085,
+      2.2774509417673467,
+      -0.8300464300550701,
+      -1.296666224125537
+    ],
+    "targetPosition": [
+      -6.402405093843915,
+      -4.114320900838903,
+      8.043226320899038,
+      2.3235131203453125
+    ],
+    "targetVelocity": [
+      5.241703601601114,
+      -4.638403656143724,
+      -3.2668965691365806,
+      -3.381171797224816
+    ],
+    "targetAcceleration": [
+      5.928312798411058,
+      -3.372866131598203,
+      2.2954473729886296,
+      3.6838936728836877
+    ],
+    "maxVelocity": [
+      6.684539092623342,
+      6.498241391379294,
+      3.7734315038269117,
+      7.275388048477431
+    ],
+    "maxAcceleration": [
+      6.934357080659753,
+      5.069875060019046,
+      7.9494012439757515,
+      5.950472311216959
+    ],
+    "maxJerk": [
+      18.759427595540156,
+      14.11819174661981,
+      13.321178440070941,
+      12.918511710639402
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.608580472569807,
+      -9.208936864381876,
+      7.70388124494016,
+      3.458001642931025
+    ],
+    "currentVelocity": [
+      -0.06168848240778679,
+      2.1069563004960754,
+      6.628672970731189,
+      -1.1137768573259854
+    ],
+    "currentAcceleration": [
+      3.609091806595492,
+      -3.876520181909473,
+      0.8117903015206549,
+      -4.136976895649853
+    ],
+    "targetPosition": [
+      -2.739217986757774,
+      7.843021519381804,
+      -2.923175531463369,
+      -8.791819903537876
+    ],
+    "targetVelocity": [
+      -2.729973726177934,
+      -0.014559156330751222,
+      -4.164321016706627,
+      -1.071227138739748
+    ],
+    "targetAcceleration": [
+      3.85982191914772,
+      1.4695404473467555,
+      -1.660542045757559,
+      1.3880265458789065
+    ],
+    "maxVelocity": [
+      6.940188688080077,
+      3.841398592968419,
+      7.016001405468615,
+      3.440158536263593
+    ],
+    "maxAcceleration": [
+      8.741471745527914,
+      6.714700938985105,
+      5.5699666355291795,
+      6.458068014768768
+    ],
+    "maxJerk": [
+      10.537528217327182,
+      11.545856394985872,
+      13.564945402427359,
+      9.523989006264566
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.3911183463076533,
+      -5.833537564385409,
+      6.868177731258285,
+      3.020965205432562
+    ],
+    "currentVelocity": [
+      -5.691440124966777,
+      0.4396093690557823,
+      -2.857696336715259,
+      0.9725787882066044
+    ],
+    "currentAcceleration": [
+      2.885699925621421,
+      -1.6706504012774994,
+      1.7350483538803343,
+      3.196488179499026
+    ],
+    "targetPosition": [
+      -2.99519556682013,
+      -8.962203612573234,
+      -4.4569143582268005,
+      -0.9110608028772322
+    ],
+    "targetVelocity": [
+      -1.5506129178816241,
+      -2.8454176724417106,
+      1.392514159044679,
+      2.427411765447739
+    ],
+    "targetAcceleration": [
+      -0.12384657940499899,
+      3.8634602748271636,
+      2.14786569257616,
+      0.7907424466462727
+    ],
+    "maxVelocity": [
+      6.0116373148831554,
+      6.2520676523205605,
+      3.869163355300892,
+      6.311310500169342
+    ],
+    "maxAcceleration": [
+      4.648149362580815,
+      5.992080048810916,
+      3.1317244205526458,
+      4.343075849757364
+    ],
+    "maxJerk": [
+      17.954840835726344,
+      5.045263936845178,
+      16.884414235311986,
+      16.69529176509715
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6927012034200981,
+      -6.271189363718854,
+      8.999641068060797,
+      9.411643223148793
+    ],
+    "currentVelocity": [
+      -2.4047981935678937,
+      1.3538843433581826,
+      -2.823195753987326,
+      2.1200318268818528
+    ],
+    "currentAcceleration": [
+      -6.2038003126792525,
+      -3.6949049878296654,
+      1.918028363104444,
+      3.4952069452686034
+    ],
+    "targetPosition": [
+      -6.944374797135497,
+      3.4936150243586095,
+      6.424782071232901,
+      -9.634595906585936
+    ],
+    "targetVelocity": [
+      4.516212688753463,
+      5.437368301471693,
+      1.4402612718546672,
+      -1.36956072842954
+    ],
+    "targetAcceleration": [
+      -1.0832009211666325,
+      0.7470662679856526,
+      3.283126223708866,
+      -4.941191667500332
+    ],
+    "maxVelocity": [
+      7.41266772967179,
+      6.324960918972845,
+      4.080035907309012,
+      3.180652463595421
+    ],
+    "maxAcceleration": [
+      6.847164837520294,
+      7.731663988020922,
+      3.303388287033906,
+      5.429785820138577
+    ],
+    "maxJerk": [
+      5.21477347639761,
+      5.581232358764735,
+      11.493770529781479,
+      14.933796169073306
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.370073188494473,
+      -3.3685681647006227,
+      3.345792446822564,
+      -4.511990501124712
+    ],
+    "currentVelocity": [
+      -1.6600439623146674,
+      1.7631918751939466,
+      -1.689850018863893,
+      -0.001813110294206055
+    ],
+    "currentAcceleration": [
+      -3.510457491481384,
+      -0.1325351745798482,
+      6.765625187015759,
+      1.4377028892379418
+    ],
+    "targetPosition": [
+      5.135219356190152,
+      7.489892443284965,
+      -6.255909362553799,
+      8.052842353566206
+    ],
+    "targetVelocity": [
+      -0.7284238984624873,
+      2.5650792844658907,
+      3.8750379930053604,
+      -2.7799853735041844
+    ],
+    "targetAcceleration": [
+      3.7545312403824607,
+      2.9106182525371977,
+      5.506599201221674,
+      -4.476509308613032
+    ],
+    "maxVelocity": [
+      2.3116813618898018,
+      2.6706507701351763,
+      4.409653343481597,
+      3.6212266286443446
+    ],
+    "maxAcceleration": [
+      6.935791610220084,
+      5.378910037851645,
+      6.866401433787891,
+      6.2873902275958
+    ],
+    "maxJerk": [
+      14.573270781704007,
+      19.600495658454207,
+      19.572898103635907,
+      18.296238175897685
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.20763280801322,
+      -7.907618078798004,
+      9.899530085453343,
+      -6.937446747601994
+    ],
+    "currentVelocity": [
+      -3.6993711223447185,
+      -4.242903356775208,
+      -2.1258573721987064,
+      0.8786926640110133
+    ],
+    "currentAcceleration": [
+      -6.7475652739654155,
+      2.206828575819415,
+      -1.2999795757263741,
+      -4.0493347956084635
+    ],
+    "targetPosition": [
+      6.999795328041031,
+      -0.6979410271104776,
+      0.7921833900102513,
+      -7.898112214358903
+    ],
+    "targetVelocity": [
+      1.7910991113549235,
+      2.4117860477700974,
+      -1.6078623408216814,
+      2.802885091142593
+    ],
+    "targetAcceleration": [
+      -0.3414797594199621,
+      6.784262954542012,
+      3.345219230323476,
+      -0.9046184134134023
+    ],
+    "maxVelocity": [
+      5.500003875608859,
+      4.564601685205788,
+      4.795300540002806,
+      4.626233227598027
+    ],
+    "maxAcceleration": [
+      7.064931297786413,
+      9.225536211126254,
+      3.8480727693170182,
+      7.890964159932825
+    ],
+    "maxJerk": [
+      12.92919356195257,
+      12.251342741841786,
+      7.246570930180753,
+      12.303808655542118
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.395218188964003,
+      5.568324057175582,
+      6.7423784029336,
+      -9.68856657930572
+    ],
+    "currentVelocity": [
+      -1.2919942498887351,
+      -1.9500615781280368,
+      1.9467308883041383,
+      5.586624694422591
+    ],
+    "currentAcceleration": [
+      -0.3979910781098486,
+      0.5543888786309941,
+      -2.9336240357258108,
+      1.0985472066595392
+    ],
+    "targetPosition": [
+      -1.8695442244970213,
+      0.25091271575273844,
+      -8.075192969149255,
+      8.857181110017823
+    ],
+    "targetVelocity": [
+      1.6087755927297902,
+      4.699511256550574,
+      -0.2920582417781308,
+      -3.462418137684392
+    ],
+    "targetAcceleration": [
+      1.3612256546591568,
+      -4.269017800834229,
+      -4.485307049988131,
+      3.0131941607952752
+    ],
+    "maxVelocity": [
+      2.6675196502761365,
+      6.384148303348875,
+      4.762592252075013,
+      6.197592873532221
+    ],
+    "maxAcceleration": [
+      3.781777353168476,
+      4.955137737304313,
+      4.838622261864802,
+      3.670616278466957
+    ],
+    "maxJerk": [
+      7.5292886045203415,
+      7.176897321408098,
+      13.315601780520037,
+      19.74360889593848
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.5631925331219669,
+      1.6109350884739655,
+      -9.083017191820309,
+      2.4849651257065304
+    ],
+    "currentVelocity": [
+      3.1572773738254254,
+      3.6646680742903808,
+      4.098325220000701,
+      -4.720693368543782
+    ],
+    "currentAcceleration": [
+      -1.3379376510410657,
+      5.105871939839972,
+      -1.9279382847224809,
+      -3.1893420709302247
+    ],
+    "targetPosition": [
+      -5.149089298427507,
+      7.799159250024587,
+      -1.8970219574356797,
+      -1.516679307216931
+    ],
+    "targetVelocity": [
+      3.178274461547029,
+      -2.6295396591180284,
+      4.8008865834181655,
+      -0.46942509630717577
+    ],
+    "targetAcceleration": [
+      3.7100076152523283,
+      3.5774643752011155,
+      2.7881441275388243,
+      1.9554077198304292
+    ],
+    "maxVelocity": [
+      5.90693573160464,
+      6.344657057402365,
+      5.309751012389256,
+      6.541529831733362
+    ],
+    "maxAcceleration": [
+      6.798237902224118,
+      8.894996640928396,
+      3.8420025338182637,
+      4.350975019482352
+    ],
+    "maxJerk": [
+      13.276028658010523,
+      18.93284660054142,
+      7.060855704267809,
+      8.248703830193525
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.821087176101205,
+      5.549156340061273,
+      -0.32597328482425425,
+      -0.6590807138545429
+    ],
+    "currentVelocity": [
+      0.5845035607924114,
+      -3.042610602357278,
+      0.07779808771622498,
+      0.00943400139345929
+    ],
+    "currentAcceleration": [
+      -5.626506046029087,
+      1.0277027787141657,
+      6.489738959277151,
+      5.640867162159854
+    ],
+    "targetPosition": [
+      4.419771624264454,
+      6.2126331219009465,
+      -2.515626901062573,
+      -3.4557407451686633
+    ],
+    "targetVelocity": [
+      -0.13218918822668613,
+      1.7791517696798365,
+      5.082697025217304,
+      0.9960715339919854
+    ],
+    "targetAcceleration": [
+      -2.30709669218142,
+      -3.968438643883983,
+      2.055449902317367,
+      -4.747598903132512
+    ],
+    "maxVelocity": [
+      6.084093059072415,
+      3.193411178346501,
+      7.44466823507297,
+      3.091399678551543
+    ],
+    "maxAcceleration": [
+      9.772543526948162,
+      4.265236756732129,
+      8.088435546753695,
+      6.481861608719592
+    ],
+    "maxJerk": [
+      8.029132515053021,
+      13.874500395230948,
+      7.524742527840899,
+      11.4715517052434
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.619450110105854,
+      9.528813110454564,
+      -4.441125954469709,
+      -1.4117940535299383
+    ],
+    "currentVelocity": [
+      -6.573917125819958,
+      -0.36448585508543374,
+      -1.803658949334249,
+      0.7501506970005147
+    ],
+    "currentAcceleration": [
+      3.7477213995345284,
+      -0.2749025574977231,
+      -1.6255149418056911,
+      7.7754191222637985
+    ],
+    "targetPosition": [
+      -9.937161825106337,
+      7.485235092974396,
+      7.713084196415053,
+      1.2082142152805595
+    ],
+    "targetVelocity": [
+      3.54388530999055,
+      -0.9739158524167246,
+      0.14332756693939386,
+      -3.888935052064305
+    ],
+    "targetAcceleration": [
+      -5.554478120223662,
+      2.93835668658353,
+      3.4800927422222543,
+      -7.448650857034215
+    ],
+    "maxVelocity": [
+      7.490482933288691,
+      4.405582689406944,
+      2.0332500057381346,
+      7.423175766707778
+    ],
+    "maxAcceleration": [
+      6.275059384844486,
+      3.6159867536983716,
+      6.02918590956352,
+      8.74437300951168
+    ],
+    "maxJerk": [
+      14.276808060376519,
+      5.631874292824553,
+      15.4310168194645,
+      17.5324232724669
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.733671527374456,
+      -6.4061626674306265,
+      -1.660716065931382,
+      -0.8291371321997083
+    ],
+    "currentVelocity": [
+      4.263240816977891,
+      0.45501654045107154,
+      1.1660302660505906,
+      6.597831782799248
+    ],
+    "currentAcceleration": [
+      1.9406213789437894,
+      -4.84454776522874,
+      1.22131114053889,
+      -4.715581788389152
+    ],
+    "targetPosition": [
+      6.064516347716516,
+      -3.421586597586847,
+      5.202400576559496,
+      -6.535301899336712
+    ],
+    "targetVelocity": [
+      -3.087663812599852,
+      -1.2419753930744504,
+      -2.690907959403714,
+      -4.821452360986112
+    ],
+    "targetAcceleration": [
+      -4.390167550485664,
+      3.6593512881981995,
+      2.6196693699975775,
+      1.937313073115991
+    ],
+    "maxVelocity": [
+      4.70930931976209,
+      3.100267675372584,
+      4.237129013311716,
+      7.792192322408211
+    ],
+    "maxAcceleration": [
+      7.403266747593235,
+      5.571103497578425,
+      5.47814135099267,
+      8.044706522157952
+    ],
+    "maxJerk": [
+      6.636186968312593,
+      11.58706709064488,
+      8.719544203392248,
+      15.932705534917186
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.186109268136278,
+      9.622454145591856,
+      0.9113725373737083,
+      -7.189252355334159
+    ],
+    "currentVelocity": [
+      0.7895387402665426,
+      1.9547683488438015,
+      -0.06543759148424444,
+      -3.414563854063484
+    ],
+    "currentAcceleration": [
+      5.637599625656188,
+      3.942221498492028,
+      4.025693136002542,
+      6.677251977673935
+    ],
+    "targetPosition": [
+      9.337918359266467,
+      -2.485787126564974,
+      -9.764974221742662,
+      -5.1494055494963575
+    ],
+    "targetVelocity": [
+      -6.362900777347186,
+      0.7193528616101785,
+      0.30273256445068375,
+      -0.3699360749440195
+    ],
+    "targetAcceleration": [
+      -3.6132905296991673,
+      4.1906956555970005,
+      1.3352384974126386,
+      6.181353965703623
+    ],
+    "maxVelocity": [
+      6.430027629987025,
+      5.508425692922952,
+      2.498363604976962,
+      3.826869198218711
+    ],
+    "maxAcceleration": [
+      7.052729011527328,
+      7.135911428543606,
+      4.134452423188031,
+      6.968643864572918
+    ],
+    "maxJerk": [
+      12.241454434315392,
+      12.816935544609393,
+      6.7771964066383905,
+      10.791225889032214
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.5797314267240914,
+      6.031803725184087,
+      -1.425116636767573,
+      -2.974649035190218
+    ],
+    "currentVelocity": [
+      2.555312647403184,
+      2.683094346361462,
+      -1.0803986997448911,
+      -1.0911205664748633
+    ],
+    "currentAcceleration": [
+      5.203688683639897,
+      -3.126585765331506,
+      3.011916892908033,
+      -1.6956913924179993
+    ],
+    "targetPosition": [
+      4.213263218207054,
+      1.732857875300768,
+      -0.6606500844531578,
+      2.8984007253764155
+    ],
+    "targetVelocity": [
+      -4.515976416238583,
+      -3.9909654783519612,
+      2.5688641209980707,
+      -0.08942358997365529
+    ],
+    "targetAcceleration": [
+      3.9839429248337472,
+      -5.879290616064067,
+      -1.539454584909739,
+      0.3637497489609265
+    ],
+    "maxVelocity": [
+      7.077547874639702,
+      4.10124561592361,
+      5.029534116239958,
+      2.133254184142668
+    ],
+    "maxAcceleration": [
+      5.217251276241654,
+      7.243177547407558,
+      4.258836741569321,
+      3.6389452585749114
+    ],
+    "maxJerk": [
+      11.312268647695674,
+      18.60615862659882,
+      9.531597931297025,
+      16.939488706550186
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.760698495940872,
+      -0.7126991689025033,
+      4.0848262802921305,
+      5.860059725990773
+    ],
+    "currentVelocity": [
+      2.7227006526437822,
+      3.5954512468391524,
+      4.429630982104062,
+      -5.9632635340033175
+    ],
+    "currentAcceleration": [
+      -2.302290776142434,
+      -1.9711972712735397,
+      -7.026537573682639,
+      -1.567335443387786
+    ],
+    "targetPosition": [
+      -0.8452856739407739,
+      1.5052843577873674,
+      3.700900954260643,
+      4.233454032115242
+    ],
+    "targetVelocity": [
+      1.9919993213704634,
+      0.24266044986377544,
+      -0.07125684229812901,
+      3.34397681916876
+    ],
+    "targetAcceleration": [
+      -1.50069475154839,
+      -6.346649007736974,
+      3.9676629299894994,
+      3.5205126755764447
+    ],
+    "maxVelocity": [
+      2.896650679600338,
+      4.544617715278633,
+      7.406793568762433,
+      6.16535967622321
+    ],
+    "maxAcceleration": [
+      3.7009652289848263,
+      8.019709544619525,
+      9.74007310666629,
+      6.079222726878363
+    ],
+    "maxJerk": [
+      6.622444041446123,
+      17.263231355444326,
+      11.019736983101446,
+      6.551160636942923
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.354024983922264,
+      3.3241608208747806,
+      0.9004072753349739,
+      -5.187317276854491
+    ],
+    "currentVelocity": [
+      3.192032521011053,
+      -1.0309513017040288,
+      3.839704678857087,
+      -1.6586957469763428
+    ],
+    "currentAcceleration": [
+      -1.2417994163916024,
+      -0.2683731206859399,
+      0.8583871506938712,
+      6.907190653168781
+    ],
+    "targetPosition": [
+      -2.018704683567705,
+      6.608112715631247,
+      -6.72399115123657,
+      6.209430986298795
+    ],
+    "targetVelocity": [
+      -0.23145822398696403,
+      -2.6391894306160544,
+      -1.2234222898164386,
+      2.5405031307905004
+    ],
+    "targetAcceleration": [
+      -3.0267768322226623,
+      1.1368238865094225,
+      -3.9280785244336567,
+      0.8945234924170702
+    ],
+    "maxVelocity": [
+      6.458577704048587,
+      5.283744220540882,
+      7.738611594534447,
+      4.542736944053193
+    ],
+    "maxAcceleration": [
+      3.3611881432229294,
+      3.4102926377814984,
+      5.101441671919986,
+      7.995346168172958
+    ],
+    "maxJerk": [
+      13.251736179460236,
+      13.965940531541506,
+      19.373536558375058,
+      18.664667684698543
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.9083885729271506,
+      3.7630597876779763,
+      -3.109575733318377,
+      6.6179577647107095
+    ],
+    "currentVelocity": [
+      0.2647601097653709,
+      0.7105121145315323,
+      3.6823482726513035,
+      -0.55390522739836
+    ],
+    "currentAcceleration": [
+      5.17656594164302,
+      -3.4385142827079602,
+      2.8797654043803638,
+      -3.2565988979042677
+    ],
+    "targetPosition": [
+      7.832231436886751,
+      2.4159679487338597,
+      7.928812097554417,
+      1.0430483052522561
+    ],
+    "targetVelocity": [
+      -1.8730958976933045,
+      -2.0903898567975645,
+      2.7431046236946077,
+      -0.12834992803435963
+    ],
+    "targetAcceleration": [
+      -0.7892930540708143,
+      -4.681969752646566,
+      2.5021751379738966,
+      4.144501656529978
+    ],
+    "maxVelocity": [
+      2.1671312307734443,
+      3.537642604861446,
+      4.777014729548357,
+      6.6353893766667085
+    ],
+    "maxAcceleration": [
+      6.452416386038783,
+      5.510824845893741,
+      3.780930816070665,
+      7.8060962801917215
+    ],
+    "maxJerk": [
+      17.509216556610646,
+      19.739271295399135,
+      11.185904669236633,
+      17.622084821085352
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.8977555704359101,
+      3.667696542994129,
+      6.319263099808442,
+      3.0511011365828224
+    ],
+    "currentVelocity": [
+      3.4765960215578042,
+      -1.4137721495358262,
+      -2.0585934758269824,
+      0.12154236482658476
+    ],
+    "currentAcceleration": [
+      3.862257918428263,
+      -0.6521691925033481,
+      4.409341253583233,
+      1.3748895091413065
+    ],
+    "targetPosition": [
+      -2.0915531658430293,
+      -0.2847252705982619,
+      6.5826529924380495,
+      -0.44053987217915846
+    ],
+    "targetVelocity": [
+      4.648357092722974,
+      -4.233944222301635,
+      -0.6183177138105105,
+      -2.0885092911310865
+    ],
+    "targetAcceleration": [
+      -0.449873017373676,
+      4.023007085723439,
+      0.008840819640392183,
+      5.844027988766614
+    ],
+    "maxVelocity": [
+      6.540475688679414,
+      5.7881368952736025,
+      6.2794671879786375,
+      7.151460739089387
+    ],
+    "maxAcceleration": [
+      6.810204800143273,
+      6.084740201518436,
+      4.7727060457959345,
+      6.350528735412318
+    ],
+    "maxJerk": [
+      9.451724887519013,
+      8.640090589859994,
+      12.733607495057129,
+      8.509386935836726
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.1559296491586863,
+      0.7151508452271429,
+      -8.163195706617515,
+      -5.483000085680412
+    ],
+    "currentVelocity": [
+      -3.2610058460450646,
+      -1.4381986923283057,
+      1.7019087968166815,
+      -1.0246430362298187
+    ],
+    "currentAcceleration": [
+      0.8275285454901304,
+      6.621299904531571,
+      -3.757474022991947,
+      4.789368481407401
+    ],
+    "targetPosition": [
+      -5.364404724397247,
+      -5.322230376140828,
+      9.010652758826737,
+      4.512414131588887
+    ],
+    "targetVelocity": [
+      -6.376030288588114,
+      2.3595366075925757,
+      -3.2818774753027804,
+      -1.0624899379525605
+    ],
+    "targetAcceleration": [
+      -0.09560135508748813,
+      0.5281716208067833,
+      -0.9582174491800619,
+      0.9152818852578006
+    ],
+    "maxVelocity": [
+      6.864678551010375,
+      6.498886874108807,
+      5.346707477488692,
+      2.957380724053243
+    ],
+    "maxAcceleration": [
+      3.4577766428192147,
+      7.457094885077441,
+      4.634650410056487,
+      5.015142958627688
+    ],
+    "maxJerk": [
+      18.00842465061819,
+      16.651858677618137,
+      13.314066243119434,
+      18.016651663557226
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.523625976443672,
+      -7.681868918252457,
+      -8.16732903304353,
+      1.9411420707643394
+    ],
+    "currentVelocity": [
+      -1.9344308007623456,
+      -3.0653821257971448,
+      2.375178696835146,
+      1.0222331827592326
+    ],
+    "currentAcceleration": [
+      0.06254491215808855,
+      0.029053188030883526,
+      -1.2659866206705725,
+      2.9432187682446855
+    ],
+    "targetPosition": [
+      -4.050851902894664,
+      0.05580241401185049,
+      0.7706518415502099,
+      -0.40347958160551656
+    ],
+    "targetVelocity": [
+      1.416530750280364,
+      -4.877449770951266,
+      -5.139522733797315,
+      4.41479754563071
+    ],
+    "targetAcceleration": [
+      6.007298686395137,
+      3.829264268454473,
+      -5.8343639867671175,
+      0.3719664451823439
+    ],
+    "maxVelocity": [
+      5.261153115071566,
+      6.9626915254669814,
+      6.36111911263475,
+      4.453796056490641
+    ],
+    "maxAcceleration": [
+      6.4028216453446944,
+      7.6569428537802935,
+      8.217624545910532,
+      6.270727582090464
+    ],
+    "maxJerk": [
+      14.435046020287828,
+      10.95831314589193,
+      18.595856048088443,
+      15.19273864108072
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.0369034677433397,
+      5.16009692085472,
+      5.218005502355732,
+      3.741266628412202
+    ],
+    "currentVelocity": [
+      1.084025141425414,
+      3.2310711813850665,
+      0.26509781348780415,
+      -0.47156703321858284
+    ],
+    "currentAcceleration": [
+      3.8170119087014944,
+      -0.9164781170429781,
+      -6.005057221165607,
+      -3.515584774638392
+    ],
+    "targetPosition": [
+      -1.5631722678049407,
+      3.7367822503687425,
+      -8.726069926542843,
+      9.86467317239212
+    ],
+    "targetVelocity": [
+      -4.222437148602975,
+      0.6183878388143245,
+      -1.4034016630191042,
+      -0.5914886962150909
+    ],
+    "targetAcceleration": [
+      0.16132654210072594,
+      0.8940701834801215,
+      1.5181100049164993,
+      -0.5538169499144807
+    ],
+    "maxVelocity": [
+      7.657702313360208,
+      3.7748979464754746,
+      4.916403417488814,
+      4.963449279467
+    ],
+    "maxAcceleration": [
+      5.255969990902238,
+      3.094665544393591,
+      7.152634963370682,
+      8.635843631101462
+    ],
+    "maxJerk": [
+      19.176706113225542,
+      16.2660278784819,
+      5.531251798167077,
+      8.000648988848052
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.6037424203078423,
+      0.7476996746287856,
+      7.119196038782697,
+      -9.515049259029514
+    ],
+    "currentVelocity": [
+      2.614107115354104,
+      4.840567315885447,
+      1.1219943091733695,
+      -2.5977252761564733
+    ],
+    "currentAcceleration": [
+      2.464601567798402,
+      -0.83886000639699,
+      2.520958213642885,
+      5.535232605326543
+    ],
+    "targetPosition": [
+      8.352731202981236,
+      3.1506941204579775,
+      -9.254854036358719,
+      -0.4682282336937327
+    ],
+    "targetVelocity": [
+      0.8671779542990024,
+      -2.932777781232046,
+      -1.435664002253916,
+      -1.132986165296419
+    ],
+    "targetAcceleration": [
+      4.820854713086792,
+      1.4515957262638866,
+      -4.386500990174505,
+      -2.2693564579435614
+    ],
+    "maxVelocity": [
+      3.502548784350804,
+      7.018468432246798,
+      2.0951755827662106,
+      3.649109710491366
+    ],
+    "maxAcceleration": [
+      5.156459876947764,
+      3.351125618246151,
+      5.347954135818029,
+      6.074256946293048
+    ],
+    "maxJerk": [
+      18.69396098619995,
+      11.879215174491051,
+      9.29973951014053,
+      6.606428230276637
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.507923481393986,
+      -7.708930982436852,
+      7.454475820220072,
+      -3.7884751102431435
+    ],
+    "currentVelocity": [
+      -2.400514744080207,
+      6.823610070786697,
+      1.6511229699462087,
+      -1.6042177005563216
+    ],
+    "currentAcceleration": [
+      1.9856217902824618,
+      -1.9243076151533032,
+      3.319167162038868,
+      0.9765063954562958
+    ],
+    "targetPosition": [
+      -5.763398796867632,
+      4.549682452253901,
+      -0.8419368571848995,
+      -6.819853275428567
+    ],
+    "targetVelocity": [
+      0.5789863145653253,
+      6.927949084011863,
+      2.338602385767264,
+      1.8881312833559596
+    ],
+    "targetAcceleration": [
+      -4.207017729190458,
+      2.482418656262425,
+      -0.18867597133549907,
+      0.7596592918608147
+    ],
+    "maxVelocity": [
+      3.7812375541855863,
+      7.53428288283624,
+      2.546713517874065,
+      2.9558645010430036
+    ],
+    "maxAcceleration": [
+      6.788303404150403,
+      5.500666187823182,
+      8.285251500143236,
+      5.822948258121386
+    ],
+    "maxJerk": [
+      10.724379650396422,
+      16.032666289701147,
+      14.777238602302281,
+      12.893613126025354
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.4370102213327911,
+      -6.739263942838932,
+      3.529110241665247,
+      -9.391649458913783
+    ],
+    "currentVelocity": [
+      -2.1593585495939154,
+      3.831288126896328,
+      -3.684737894051021,
+      -3.8027957009872058
+    ],
+    "currentAcceleration": [
+      -1.489549926686498,
+      -6.350803607507572,
+      4.9052953306817155,
+      -1.7403897824289913
+    ],
+    "targetPosition": [
+      -0.5869198649242335,
+      -8.916826308611263,
+      -1.8646004408320458,
+      -9.90552084881529
+    ],
+    "targetVelocity": [
+      -6.83447282030836,
+      1.1455093930982647,
+      -4.434396140606924,
+      4.696044388265617
+    ],
+    "targetAcceleration": [
+      -3.173109235992218,
+      -5.284044489341255,
+      -1.0658818663442187,
+      -1.4078708267872808
+    ],
+    "maxVelocity": [
+      6.993955036292222,
+      5.386181774655866,
+      5.675816553439219,
+      5.306466210992627
+    ],
+    "maxAcceleration": [
+      4.7915486552965465,
+      7.616888247378099,
+      7.273213142591715,
+      4.839679483123369
+    ],
+    "maxJerk": [
+      7.363156075940484,
+      18.650790267606332,
+      15.468188853888805,
+      12.468295177217165
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.085333246857942,
+      8.408817705009096,
+      7.4743421683370315,
+      7.65946799412497
+    ],
+    "currentVelocity": [
+      6.187951588823341,
+      2.93947860490392,
+      1.961209291339352,
+      6.256832608110373
+    ],
+    "currentAcceleration": [
+      -2.116377358597932,
+      -4.46605273212935,
+      -1.6814459242769935,
+      -4.091203190075344
+    ],
+    "targetPosition": [
+      -9.56052780947102,
+      8.301126151843889,
+      -4.657950738013541,
+      -3.806207638157333
+    ],
+    "targetVelocity": [
+      2.6212522013961026,
+      -0.619247620553383,
+      -1.9129358343746738,
+      4.938259391581448
+    ],
+    "targetAcceleration": [
+      1.6858210159126652,
+      -3.0219940203125013,
+      -1.6807878313740343,
+      -3.136855047325298
+    ],
+    "maxVelocity": [
+      6.4551309255090485,
+      3.1245339499606155,
+      5.855029148406555,
+      6.5137098050320565
+    ],
+    "maxAcceleration": [
+      3.5862441211336242,
+      5.5602806984115105,
+      3.2549856920720743,
+      7.2435068840029215
+    ],
+    "maxJerk": [
+      14.092553780064454,
+      19.006014056554854,
+      13.206563398512301,
+      13.827688650213911
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.1402632454229344,
+      -2.073274311128655,
+      5.894145963252136,
+      -0.4647173092914674
+    ],
+    "currentVelocity": [
+      -6.768669023953456,
+      -1.4205873185953806,
+      -4.906768984802205,
+      1.3664785970935749
+    ],
+    "currentAcceleration": [
+      2.577544437709121,
+      -1.5832008373417334,
+      -1.3502196722397528,
+      3.8293454466544974
+    ],
+    "targetPosition": [
+      -4.3192238841712545,
+      5.954192388014723,
+      -6.7010706317827,
+      -6.404861032960603
+    ],
+    "targetVelocity": [
+      -0.503953738592231,
+      5.2054912307720596,
+      -5.45310045294094,
+      2.799941915817445
+    ],
+    "targetAcceleration": [
+      1.465953012996084,
+      -0.1341054580180039,
+      -2.04260507446259,
+      -0.977616616859251
+    ],
+    "maxVelocity": [
+      7.297131335739385,
+      6.7057339067164,
+      6.315561298220491,
+      3.419396085912392
+    ],
+    "maxAcceleration": [
+      3.983234037183143,
+      4.173440487301077,
+      9.648911168306732,
+      7.951350378502551
+    ],
+    "maxJerk": [
+      17.705885676697015,
+      19.490803849790915,
+      8.205596347098476,
+      11.9420933378338
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.097196447751806,
+      3.029456907604203,
+      4.5540343406622625,
+      9.249956324768704
+    ],
+    "currentVelocity": [
+      0.7652063571717083,
+      0.020066320676320526,
+      0.6907178966056442,
+      -1.9465608235448877
+    ],
+    "currentAcceleration": [
+      -1.1232934087427622,
+      -1.322952688124742,
+      -2.479144198666782,
+      -2.6214118706273957
+    ],
+    "targetPosition": [
+      -9.657301049979148,
+      8.315809453364466,
+      9.654671519470998,
+      -9.588909937794089
+    ],
+    "targetVelocity": [
+      -5.040113132894423,
+      -0.9136296237310639,
+      -5.120620393367474,
+      1.0199475916509355
+    ],
+    "targetAcceleration": [
+      0.3078035718952794,
+      -0.019006988869676444,
+      -2.2039794951573386,
+      -1.6511004892269012
+    ],
+    "maxVelocity": [
+      5.167641229013177,
+      2.1662170194173824,
+      6.366124236165616,
+      3.883374239307103
+    ],
+    "maxAcceleration": [
+      3.9669922039324783,
+      3.199020271771831,
+      3.314992114263857,
+      3.432371453721913
+    ],
+    "maxJerk": [
+      9.900991294050602,
+      19.92482565766754,
+      10.699654744146182,
+      19.717123776152075
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.8658878396892487,
+      -0.6609622739315579,
+      3.622479346253243,
+      9.200673611684543
+    ],
+    "currentVelocity": [
+      3.333053090316012,
+      -1.8878651572035698,
+      1.5519215529552368,
+      0.9831342585931919
+    ],
+    "currentAcceleration": [
+      -5.382248698508271,
+      -1.3553226843962847,
+      2.341696167362084,
+      2.074305197966239
+    ],
+    "targetPosition": [
+      -6.868856419826315,
+      4.579516028204747,
+      4.245862803319046,
+      -1.7024471132918038
+    ],
+    "targetVelocity": [
+      0.4249207829097008,
+      0.3991076097296684,
+      -1.878599152946638,
+      -1.9128734665108218
+    ],
+    "targetAcceleration": [
+      0.6463828666566638,
+      -0.42537538599152436,
+      0.8488921345602503,
+      -1.0897026625388953
+    ],
+    "maxVelocity": [
+      4.171112236236237,
+      5.386707291964557,
+      2.610822588342264,
+      2.631624942061793
+    ],
+    "maxAcceleration": [
+      6.318290980159297,
+      3.514533325883782,
+      4.292755761211435,
+      3.950610657080059
+    ],
+    "maxJerk": [
+      16.846779863386036,
+      18.935554129824016,
+      6.123835951717055,
+      17.492262999711805
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.8865856489638873,
+      -6.288235189477069,
+      0.8985573819198613,
+      2.666655931535251
+    ],
+    "currentVelocity": [
+      -1.9610313587758816,
+      1.5074734059268162,
+      -2.5718231665139877,
+      -2.229057359025846
+    ],
+    "currentAcceleration": [
+      1.8752595376767882,
+      -0.3349086408815758,
+      -2.2376796585227057,
+      0.8625231225721635
+    ],
+    "targetPosition": [
+      2.09120024805868,
+      9.636207062367532,
+      -9.70588848758289,
+      5.333769857455497
+    ],
+    "targetVelocity": [
+      0.9280704664383137,
+      -3.483531502805617,
+      3.9142252317861965,
+      0.08876008463936635
+    ],
+    "targetAcceleration": [
+      -0.1724138446468375,
+      -4.50700509661931,
+      -3.968250278521438,
+      -3.2788223667482974
+    ],
+    "maxVelocity": [
+      5.665490221148496,
+      3.843647975059246,
+      5.1784840565454155,
+      4.400188775545737
+    ],
+    "maxAcceleration": [
+      4.068696452239601,
+      9.64264016264914,
+      5.734273817728515,
+      7.686678241539054
+    ],
+    "maxJerk": [
+      6.777290741470453,
+      11.77699771274032,
+      16.51402983733465,
+      9.435044285819854
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.816246760373593,
+      8.377307637989716,
+      5.414258238450431,
+      4.886944223753014
+    ],
+    "currentVelocity": [
+      -0.841169210182247,
+      2.206733179715439,
+      3.2544127751809677,
+      -1.8936190198853442
+    ],
+    "currentAcceleration": [
+      -5.191484981166499,
+      -5.9771124298762075,
+      -1.9723168354973175,
+      -4.552654327020984
+    ],
+    "targetPosition": [
+      -3.5071098600021022,
+      8.586975305956138,
+      -9.76110417948787,
+      4.385634046147672
+    ],
+    "targetVelocity": [
+      1.4387979050122217,
+      0.30931121823330887,
+      1.3467437580513506,
+      -0.9004955313294212
+    ],
+    "targetAcceleration": [
+      3.188095278180139,
+      -5.0346903729594965,
+      -3.286902372993239,
+      1.1734795821124386
+    ],
+    "maxVelocity": [
+      4.2020080918752525,
+      5.035588242724057,
+      7.667638221867063,
+      4.677162014973595
+    ],
+    "maxAcceleration": [
+      5.409775335574038,
+      6.959429003416854,
+      3.6387160845773163,
+      4.620693774972608
+    ],
+    "maxJerk": [
+      8.158436669588696,
+      10.16321503124741,
+      8.610033297469139,
+      15.688293450928562
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.6363239758368344,
+      7.200118791609675,
+      -2.154777904390695,
+      8.655617776358728
+    ],
+    "currentVelocity": [
+      -1.5530293357453848,
+      2.5741146143692824,
+      1.415179697932461,
+      -2.083997636333928
+    ],
+    "currentAcceleration": [
+      -3.795145013417865,
+      -2.591516875430922,
+      -2.694256956215999,
+      -0.8057209624082939
+    ],
+    "targetPosition": [
+      -2.144073246664526,
+      7.026407764427255,
+      -9.409148549181953,
+      9.593458233998454
+    ],
+    "targetVelocity": [
+      2.087084577730539,
+      -3.805272984653736,
+      -2.6172978096479547,
+      -2.8239732182684913
+    ],
+    "targetAcceleration": [
+      -5.187359025350318,
+      4.763012273075024,
+      1.5032516138284189,
+      -0.6280121516155446
+    ],
+    "maxVelocity": [
+      6.719377660644281,
+      7.839168879715089,
+      3.6803583005853056,
+      5.375211991798743
+    ],
+    "maxAcceleration": [
+      6.523859930760848,
+      6.173398981318357,
+      3.9709968491727263,
+      4.431448275547485
+    ],
+    "maxJerk": [
+      15.350126809465918,
+      17.452915726283834,
+      18.978070793954437,
+      6.710457583364136
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.994309801467623,
+      3.748070317416465,
+      1.470447067757073,
+      9.976375282778918
+    ],
+    "currentVelocity": [
+      -4.926834526130557,
+      2.051218311788583,
+      -3.405865934838526,
+      -1.0066442421388175
+    ],
+    "currentAcceleration": [
+      -3.299896443850062,
+      -0.12967423742846051,
+      2.0975841095463554,
+      -2.0148419710233565
+    ],
+    "targetPosition": [
+      2.3288187106631835,
+      -2.3031074160713345,
+      0.4288858041289636,
+      -7.104185916494254
+    ],
+    "targetVelocity": [
+      -2.3941012719150576,
+      -1.3992836697258586,
+      -3.24406244499281,
+      -1.4118385554451867
+    ],
+    "targetAcceleration": [
+      -2.9397747282145508,
+      -0.5520107067294457,
+      4.610261045435175,
+      0.11200582996559838
+    ],
+    "maxVelocity": [
+      7.716323772742639,
+      2.506071991587679,
+      5.530677342081229,
+      3.2268623683927444
+    ],
+    "maxAcceleration": [
+      9.436315577650028,
+      4.734578077200518,
+      8.218803013007427,
+      4.0390419776177
+    ],
+    "maxJerk": [
+      7.203120616865739,
+      16.903135921130136,
+      9.180307355383539,
+      13.512835815759844
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.4260844142059934,
+      -9.452701058202448,
+      -2.258266403756708,
+      -5.815222303204535
+    ],
+    "currentVelocity": [
+      2.951902855021959,
+      0.8322876280613993,
+      -5.122240186813725,
+      4.037929856997011
+    ],
+    "currentAcceleration": [
+      0.8709447558720536,
+      -3.1122028381844586,
+      3.6806584703854988,
+      -2.8718689399121615
+    ],
+    "targetPosition": [
+      -5.073376025095846,
+      7.358137718643295,
+      2.34083097635464,
+      5.866034551065589
+    ],
+    "targetVelocity": [
+      -1.83527725088022,
+      -3.410496015317414,
+      3.8546034104716593,
+      3.528426449660137
+    ],
+    "targetAcceleration": [
+      0.6259008445539669,
+      4.901482757267641,
+      2.6091598119383335,
+      -1.2459249130753483
+    ],
+    "maxVelocity": [
+      3.685526657798967,
+      6.636495625258696,
+      5.974756444722475,
+      5.630774771412564
+    ],
+    "maxAcceleration": [
+      7.447260348515537,
+      7.510966807065896,
+      4.01264999861761,
+      5.903741832238552
+    ],
+    "maxJerk": [
+      11.391107188237088,
+      10.815505863551197,
+      7.310991242160894,
+      14.366386600735263
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.0385977322229945,
+      0.8124834333571229,
+      -3.0246078154261236,
+      7.6417496674648895
+    ],
+    "currentVelocity": [
+      -0.7159400487487027,
+      -1.808882359237859,
+      2.9504360214288976,
+      -1.6344351030032231
+    ],
+    "currentAcceleration": [
+      -3.132615986867198,
+      4.068380399973004,
+      -3.0057267018426357,
+      1.940220279522086
+    ],
+    "targetPosition": [
+      -0.478227074784785,
+      1.1898246412826694,
+      -8.391055533806542,
+      -2.477038910210072
+    ],
+    "targetVelocity": [
+      -1.7965136488084208,
+      1.5499939599704642,
+      3.3203344144768305,
+      0.1388224159753242
+    ],
+    "targetAcceleration": [
+      -0.579975128431677,
+      5.860593123201345,
+      1.698192120561413,
+      -2.935946863492721
+    ],
+    "maxVelocity": [
+      5.057703119572972,
+      2.002861352003359,
+      5.620691722615328,
+      2.16031284605104
+    ],
+    "maxAcceleration": [
+      5.836961964246015,
+      7.537813836567341,
+      3.205748195491223,
+      3.715888853643237
+    ],
+    "maxJerk": [
+      15.160860866786951,
+      14.46276789748143,
+      10.191614515799374,
+      7.596504749328107
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.309432043472228,
+      -4.006875458763521,
+      5.486959582130401,
+      1.605093984250626
+    ],
+    "currentVelocity": [
+      -0.9546388602470248,
+      1.0350360653681916,
+      -1.2536847384842336,
+      1.6841616051960209
+    ],
+    "currentAcceleration": [
+      3.313413425065832,
+      6.120669007515273,
+      -5.5110982864886395,
+      -4.842525751852989
+    ],
+    "targetPosition": [
+      7.7684890106562605,
+      -3.3917923615525147,
+      -0.02499208988114532,
+      -3.6326491072307228
+    ],
+    "targetVelocity": [
+      -1.7196651519070656,
+      -0.055186690862297105,
+      3.027457091824118,
+      -2.046937745016021
+    ],
+    "targetAcceleration": [
+      4.514285148589332,
+      6.435404971929454,
+      -5.718398183961111,
+      -3.6980138162886362
+    ],
+    "maxVelocity": [
+      4.2527156521288205,
+      2.5263817841472505,
+      7.175038160805455,
+      6.895416127506262
+    ],
+    "maxAcceleration": [
+      6.784392207569219,
+      9.22243168407282,
+      5.952765636155873,
+      6.148570604575803
+    ],
+    "maxJerk": [
+      12.447747009836386,
+      13.607452899860117,
+      15.659780805196878,
+      7.415821621901806
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.075554047799342,
+      -6.4529800894464495,
+      -6.736628978691663,
+      7.870587205553761
+    ],
+    "currentVelocity": [
+      -0.6302301069099756,
+      -5.137470689018533,
+      -5.489506795025897,
+      0.23260662461815507
+    ],
+    "currentAcceleration": [
+      3.3205674116622426,
+      0.8004575649714631,
+      -2.5576157630920324,
+      -1.3416471551251234
+    ],
+    "targetPosition": [
+      -1.2624534780203245,
+      7.946866977702566,
+      -2.253276303821412,
+      0.1147712304898807
+    ],
+    "targetVelocity": [
+      -2.6411202338974795,
+      -6.149837565537483,
+      -2.7923633699698325,
+      3.4435141559005977
+    ],
+    "targetAcceleration": [
+      -5.771711219848459,
+      -2.234402329136006,
+      3.104720268557104,
+      -4.756500602280601
+    ],
+    "maxVelocity": [
+      2.831203688599886,
+      6.25418294749327,
+      6.842155760307085,
+      4.475278518416021
+    ],
+    "maxAcceleration": [
+      9.728147131242533,
+      9.970025220066624,
+      6.6987992062902,
+      5.620721324996599
+    ],
+    "maxJerk": [
+      16.902955639667105,
+      18.632661999876127,
+      16.22954543485355,
+      14.453653222746928
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.2425565322000214,
+      6.9600963396739886,
+      7.784387629682069,
+      6.477744338434089
+    ],
+    "currentVelocity": [
+      6.049468035341316,
+      1.9659029782417865,
+      -1.8741364470172917,
+      2.7741938867398606
+    ],
+    "currentAcceleration": [
+      0.45709665266888555,
+      3.0589116676752157,
+      -1.5230684306143347,
+      4.66675693149963
+    ],
+    "targetPosition": [
+      -6.140676355907326,
+      2.2504253126426406,
+      -2.2756891044959193,
+      -9.240021029880399
+    ],
+    "targetVelocity": [
+      -3.606660129838998,
+      -1.6557525572727516,
+      -0.8361042633154172,
+      -4.05957149995747
+    ],
+    "targetAcceleration": [
+      -2.990077628824933,
+      1.2908522959238473,
+      -3.3795588678771225,
+      2.364618881158406
+    ],
+    "maxVelocity": [
+      7.583384797731312,
+      3.7479402233689902,
+      7.4664414667277965,
+      7.959383276589236
+    ],
+    "maxAcceleration": [
+      3.1432008102420275,
+      3.358975463562172,
+      5.934225702089384,
+      5.673042685165556
+    ],
+    "maxJerk": [
+      7.278009960634789,
+      15.312111968653891,
+      12.187631487147634,
+      6.543600089723345
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.623232930728694,
+      0.6107219471508589,
+      2.1847437758402055,
+      0.1588521740769977
+    ],
+    "currentVelocity": [
+      -4.164986297604697,
+      5.3108292608425245,
+      0.9522802461510045,
+      -0.8095154420210078
+    ],
+    "currentAcceleration": [
+      -0.15729280504259702,
+      -0.6133189196069462,
+      -2.107142350950544,
+      -3.473595354844354
+    ],
+    "targetPosition": [
+      -5.570748525986096,
+      9.992931841310629,
+      -0.6672314775497767,
+      -9.294306686525681
+    ],
+    "targetVelocity": [
+      -5.02250269683251,
+      -4.919600286111355,
+      -2.965337544613007,
+      1.167610441898399
+    ],
+    "targetAcceleration": [
+      0.13050142782109742,
+      3.019977530278773,
+      -0.25499707730477184,
+      4.579408813174064
+    ],
+    "maxVelocity": [
+      6.577109684113431,
+      6.734699738865354,
+      4.756601836770922,
+      2.102747740739786
+    ],
+    "maxAcceleration": [
+      7.30827897571555,
+      4.380469160777901,
+      6.747486522184999,
+      5.864437019615549
+    ],
+    "maxJerk": [
+      16.8633631380745,
+      9.26012046241952,
+      5.628832157894729,
+      11.877053644566402
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.517228640075757,
+      -6.634044082551411,
+      0.3689401676400834,
+      6.435415753466533
+    ],
+    "currentVelocity": [
+      1.3754645400637031,
+      2.4258232294970083,
+      -0.673318922075345,
+      2.0691443690263585
+    ],
+    "currentAcceleration": [
+      3.9206325517068583,
+      0.7657536569057131,
+      -2.601343903543098,
+      5.848067601695157
+    ],
+    "targetPosition": [
+      -5.538797604151262,
+      -8.52014286019065,
+      -5.725229376769045,
+      2.62958185174484
+    ],
+    "targetVelocity": [
+      0.9247991508234534,
+      3.2145439339626067,
+      -0.4540074414120605,
+      4.644875221271053
+    ],
+    "targetAcceleration": [
+      3.410786890399307,
+      -1.695081677990879,
+      -4.6360426292707375,
+      -4.725609093871728
+    ],
+    "maxVelocity": [
+      7.333119521797238,
+      5.985508836705539,
+      3.9675969640434907,
+      7.55062599955665
+    ],
+    "maxAcceleration": [
+      4.68437727639619,
+      3.247754504589115,
+      9.970768724871174,
+      6.736670322636031
+    ],
+    "maxJerk": [
+      12.705094193402008,
+      7.089848286338096,
+      16.445357442157377,
+      7.235850007871131
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.010843594792266,
+      -0.8067795459988609,
+      6.5963637478092245,
+      6.756949593770905
+    ],
+    "currentVelocity": [
+      -0.1016680993844572,
+      -1.7688470599494002,
+      2.0138292101175144,
+      1.2532254769681188
+    ],
+    "currentAcceleration": [
+      -4.549766379877756,
+      -0.24440231824415193,
+      -3.680285223322521,
+      -0.7504684736578442
+    ],
+    "targetPosition": [
+      6.478563408681431,
+      1.674631385022634,
+      -1.6419546499267632,
+      3.3246688811457865
+    ],
+    "targetVelocity": [
+      -1.279000691663807,
+      -0.09628663015475603,
+      0.6324000511745846,
+      -2.177021648507832
+    ],
+    "targetAcceleration": [
+      2.5864406712761454,
+      -1.0098057713159783,
+      2.3599032711489922,
+      -3.8933712177462967
+    ],
+    "maxVelocity": [
+      3.3600806133583974,
+      5.856193633059659,
+      3.997927721509058,
+      2.3271520461037207
+    ],
+    "maxAcceleration": [
+      7.446632313112103,
+      4.522718653974591,
+      8.541024730052557,
+      8.156500675855595
+    ],
+    "maxJerk": [
+      7.529325525661075,
+      6.3056576880247155,
+      17.60170130800944,
+      6.014302478226147
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.52578758077,
+      0.9159937026869933,
+      -7.39012931356543,
+      4.292712471432342
+    ],
+    "currentVelocity": [
+      2.7360396010312975,
+      3.9463394049351264,
+      -1.1390544591608949,
+      1.6712452976857541
+    ],
+    "currentAcceleration": [
+      6.245629259834062,
+      0.5893515144161032,
+      4.580418084075326,
+      -5.980034426813605
+    ],
+    "targetPosition": [
+      1.6708237801175123,
+      1.8304722238672149,
+      -3.2487632723356574,
+      -5.243494457844431
+    ],
+    "targetVelocity": [
+      -2.741001534403469,
+      -2.5880589615852116,
+      6.999621611823123,
+      7.220176459418294
+    ],
+    "targetAcceleration": [
+      -1.6834950090564336,
+      -1.7446976748656444,
+      2.0435628133004577,
+      1.278703673690119
+    ],
+    "maxVelocity": [
+      4.645715909451397,
+      4.536194222087436,
+      7.996491869812493,
+      7.5586966921895336
+    ],
+    "maxAcceleration": [
+      7.423611095006682,
+      3.4532400617030348,
+      9.964434789427575,
+      9.043709016368808
+    ],
+    "maxJerk": [
+      14.271959027580422,
+      9.708938188374047,
+      19.542842443097456,
+      10.140176019682414
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.988921328923661,
+      -3.8362886014717557,
+      -9.240291661546827,
+      3.9967623621387567
+    ],
+    "currentVelocity": [
+      -2.0272652009906396,
+      -4.306867262889366,
+      5.52272442922803,
+      3.132710751002503
+    ],
+    "currentAcceleration": [
+      3.6670439072226007,
+      3.0775150496983885,
+      -3.4716898428648104,
+      3.284826971124608
+    ],
+    "targetPosition": [
+      -8.425040055983668,
+      5.221192103992374,
+      -5.2812090001886265,
+      0.037293131743261654
+    ],
+    "targetVelocity": [
+      -2.3192659302181227,
+      -4.42448212238965,
+      -2.2207927764018116,
+      2.301857473527858
+    ],
+    "targetAcceleration": [
+      1.6998408704820047,
+      6.1179807515994975,
+      4.653892590446626,
+      -0.9774356790002479
+    ],
+    "maxVelocity": [
+      4.7383222389995,
+      7.470165431963039,
+      6.681902330019192,
+      5.634124156484332
+    ],
+    "maxAcceleration": [
+      9.557761636722677,
+      6.414897521102371,
+      5.539423100576613,
+      3.4651424310090873
+    ],
+    "maxJerk": [
+      11.667472310648911,
+      7.569771268091229,
+      15.609212233833917,
+      18.808791808484166
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.460360423825829,
+      1.7700663515349753,
+      -9.576946858871851,
+      6.679686284493517
+    ],
+    "currentVelocity": [
+      -3.805697064250758,
+      -0.10240235457069247,
+      3.3916794538216752,
+      0.8120359481335018
+    ],
+    "currentAcceleration": [
+      -1.7919644432345718,
+      -7.098721773963993,
+      2.16661680723937,
+      -1.963592013351
+    ],
+    "targetPosition": [
+      3.9260110930000245,
+      -4.873736977455216,
+      -4.298102324657906,
+      -0.3715291856412364
+    ],
+    "targetVelocity": [
+      3.707131737231613,
+      -5.589141863596092,
+      -1.1876232765355175,
+      1.4864256958974238
+    ],
+    "targetAcceleration": [
+      -1.693756273907944,
+      -0.24790684462660906,
+      0.5129577117069548,
+      -0.719344756894011
+    ],
+    "maxVelocity": [
+      7.4408174186403215,
+      7.194459964356574,
+      6.556781557120335,
+      2.1366222686084515
+    ],
+    "maxAcceleration": [
+      5.310489088995009,
+      9.224923974180467,
+      8.182690921194844,
+      5.0469924479409745
+    ],
+    "maxJerk": [
+      6.761737928341757,
+      15.91087165667119,
+      8.90549468041334,
+      12.306419698146211
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.40872078048184,
+      7.391976933243999,
+      7.8105166285943355,
+      0.13341066040438676
+    ],
+    "currentVelocity": [
+      -1.5209632718948995,
+      2.649192680653066,
+      3.1575777347555976,
+      2.199648348175182
+    ],
+    "currentAcceleration": [
+      -2.8636827721567517,
+      -3.364677501491811,
+      -2.9515859092198107,
+      -0.8230789694350382
+    ],
+    "targetPosition": [
+      4.815213490858312,
+      -4.977866155484674,
+      8.78482023344247,
+      -5.631284604298747
+    ],
+    "targetVelocity": [
+      2.2394493428135585,
+      -1.6135159879392889,
+      2.8003178568756306,
+      -2.270058241429987
+    ],
+    "targetAcceleration": [
+      1.3981913721154111,
+      1.8992383351864417,
+      -1.334240392886155,
+      -1.0357667001192659
+    ],
+    "maxVelocity": [
+      6.4218503170859735,
+      2.6887273802308553,
+      4.546981827083831,
+      2.5192053515845902
+    ],
+    "maxAcceleration": [
+      6.124175471844947,
+      4.298054653859427,
+      6.861802296692391,
+      4.283633820830814
+    ],
+    "maxJerk": [
+      9.334987466298806,
+      18.051070391921638,
+      11.14718002391486,
+      12.794568699063685
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.7149043007093212,
+      5.462068563592489,
+      -5.900995153548609,
+      -9.336756687906947
+    ],
+    "currentVelocity": [
+      -7.837382419389272,
+      -1.3612223434192785,
+      0.9966260744352424,
+      -2.2562603730440207
+    ],
+    "currentAcceleration": [
+      2.0541349423634783,
+      -0.14510787748842136,
+      5.5185662846693715,
+      -0.9826875202439833
+    ],
+    "targetPosition": [
+      0.9453431880355385,
+      -1.8383252286345542,
+      -4.458575561050708,
+      -9.464733170483226
+    ],
+    "targetVelocity": [
+      3.392551361328305,
+      -2.5576473161098927,
+      0.7619839927287528,
+      0.46627309574591846
+    ],
+    "targetAcceleration": [
+      -2.2432545952234784,
+      0.24329003349528344,
+      2.874209466204186,
+      2.8826700534011103
+    ],
+    "maxVelocity": [
+      7.94570682863406,
+      2.9243413915956524,
+      3.1709904371644435,
+      2.3879423005177998
+    ],
+    "maxAcceleration": [
+      5.79886191621047,
+      3.419360920619883,
+      5.680197200456807,
+      6.900491462534754
+    ],
+    "maxJerk": [
+      17.369564761554603,
+      8.18238118223754,
+      9.093825701380897,
+      5.478603669598401
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.635209126485721,
+      3.05872857122986,
+      -6.7579575218829895,
+      -6.193993643367952
+    ],
+    "currentVelocity": [
+      -3.4356158119768128,
+      3.2193794931882778,
+      3.7897981165726353,
+      -6.3697564731112335
+    ],
+    "currentAcceleration": [
+      2.393525529004836,
+      0.8691193538056314,
+      -2.378910331552758,
+      3.895978924955818
+    ],
+    "targetPosition": [
+      2.0714898771880463,
+      6.756445926898632,
+      6.61801769880833,
+      6.100002248029163
+    ],
+    "targetVelocity": [
+      -4.115321285272872,
+      -1.4223382013585542,
+      0.4974093129946118,
+      -5.110441953941062
+    ],
+    "targetAcceleration": [
+      -1.8320976852511335,
+      -4.776214068305281,
+      -4.1051981842672784,
+      3.209672449744126
+    ],
+    "maxVelocity": [
+      4.897314966721744,
+      4.962374664994808,
+      4.420587533751576,
+      7.625278043220319
+    ],
+    "maxAcceleration": [
+      3.7908507354209675,
+      9.199581016277966,
+      7.416098455162331,
+      8.419154481729155
+    ],
+    "maxJerk": [
+      18.087796949555745,
+      9.024433140416761,
+      15.625658971869882,
+      10.53183436641751
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.5133002907905,
+      -2.7655558468455244,
+      8.394964589908277,
+      -6.468367969922564
+    ],
+    "currentVelocity": [
+      1.684741340746414,
+      -3.90046890148757,
+      0.32605774071056715,
+      4.786758484499221
+    ],
+    "currentAcceleration": [
+      -1.3958595593655767,
+      1.9344349413494748,
+      1.8878762093762238,
+      3.572498344141499
+    ],
+    "targetPosition": [
+      4.628060072986159,
+      6.4136877633852905,
+      -7.330109001542747,
+      9.76178947128465
+    ],
+    "targetVelocity": [
+      1.1409564294348233,
+      3.0799109520714367,
+      -3.3782973530331244,
+      0.0896808764574395
+    ],
+    "targetAcceleration": [
+      -3.9207756367963964,
+      3.2205801976028243,
+      0.14210203202331462,
+      -1.2112199459659347
+    ],
+    "maxVelocity": [
+      2.2685193644302464,
+      4.623304094381003,
+      7.313071801283714,
+      7.79897398560822
+    ],
+    "maxAcceleration": [
+      4.993027855510992,
+      3.2365911200907287,
+      3.9514767357973475,
+      9.935614218423776
+    ],
+    "maxJerk": [
+      13.171620613212076,
+      11.314691747720701,
+      9.672801785650439,
+      14.209139905052387
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.003927571344256364,
+      7.552411751034196,
+      -9.078884031121785,
+      9.142468835179024
+    ],
+    "currentVelocity": [
+      -1.2024489402617005,
+      0.6949153034525142,
+      1.0453476505909083,
+      1.0386814827632662
+    ],
+    "currentAcceleration": [
+      -1.2213284898251988,
+      3.091809128425819,
+      4.55131748140608,
+      -1.7811578729088313
+    ],
+    "targetPosition": [
+      -1.171921327118806,
+      -6.939909977805085,
+      -5.780731947792073,
+      -9.853866821044475
+    ],
+    "targetVelocity": [
+      -2.194526137186788,
+      1.512997627809055,
+      -0.8669784148656325,
+      -3.9441240452883255
+    ],
+    "targetAcceleration": [
+      -0.6464851461061407,
+      -4.14065272800971,
+      -3.771834344519904,
+      3.5291792053571722
+    ],
+    "maxVelocity": [
+      3.611576970505661,
+      2.4311545331106714,
+      2.206383338284795,
+      4.957420378582366
+    ],
+    "maxAcceleration": [
+      9.9707361759746,
+      5.816944058445262,
+      5.03104528681679,
+      4.935970183905514
+    ],
+    "maxJerk": [
+      13.683608442800285,
+      17.159477872078337,
+      9.407722890459326,
+      7.011542901043742
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.071766694857919,
+      9.432974384341591,
+      -9.331672865632772,
+      2.363659774813428
+    ],
+    "currentVelocity": [
+      1.191278798522018,
+      4.226473170361669,
+      2.431705899239562,
+      -3.125522568032956
+    ],
+    "currentAcceleration": [
+      1.6368040695837287,
+      0.7175596874091541,
+      2.7708854135132484,
+      -2.879287739812324
+    ],
+    "targetPosition": [
+      5.417486678353658,
+      4.49976385726737,
+      5.509800910238582,
+      -2.3479478400431404
+    ],
+    "targetVelocity": [
+      1.9786704358864284,
+      -3.3789639145556776,
+      4.19980411857936,
+      -2.907251255657155
+    ],
+    "targetAcceleration": [
+      -0.9895950814833387,
+      2.210808995694764,
+      0.3661363586688253,
+      6.456110277140333
+    ],
+    "maxVelocity": [
+      3.028744716468327,
+      6.638193623828053,
+      5.379592887812729,
+      6.649691470568364
+    ],
+    "maxAcceleration": [
+      6.743314149452127,
+      5.537949719255483,
+      6.507847466723675,
+      7.92898921992559
+    ],
+    "maxJerk": [
+      5.648450937520653,
+      8.410806849360533,
+      6.402714591597038,
+      18.07387199383299
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.219398642139913,
+      0.6696410128116632,
+      -2.639164657833337,
+      5.020498945562821
+    ],
+    "currentVelocity": [
+      -6.267712327445796,
+      -6.835823077569033,
+      -1.5148071129417255,
+      -4.286536517227626
+    ],
+    "currentAcceleration": [
+      -3.0074649632854262,
+      -2.7960757776385257,
+      3.411909657606273,
+      5.93072089476181
+    ],
+    "targetPosition": [
+      1.4442593037602354,
+      -1.9735240861508707,
+      3.9421341581984635,
+      7.439093350719844
+    ],
+    "targetVelocity": [
+      2.156742539234756,
+      6.538862103841547,
+      1.008592888891802,
+      -3.8282311733066896
+    ],
+    "targetAcceleration": [
+      0.22011029204682941,
+      -2.3709079371933433,
+      -3.20113135968805,
+      1.2774032830896882
+    ],
+    "maxVelocity": [
+      7.096945102067547,
+      7.3031584295535446,
+      4.15327886182484,
+      4.683748592389383
+    ],
+    "maxAcceleration": [
+      3.306407693737407,
+      3.0509823718041926,
+      9.863051073196118,
+      9.096116468060051
+    ],
+    "maxJerk": [
+      18.119666816044,
+      15.086313849229617,
+      17.999116083217785,
+      6.470773627455385
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.9484413255450157,
+      -4.389154728622719,
+      -8.443994617439678,
+      6.9316002826878105
+    ],
+    "currentVelocity": [
+      -5.534783532442184,
+      -5.04568289320452,
+      -1.9039234850562525,
+      0.26497715699943836
+    ],
+    "currentAcceleration": [
+      4.565029666892484,
+      2.48044320750075,
+      -6.761719577918806,
+      2.758530111293579
+    ],
+    "targetPosition": [
+      1.2308016998053954,
+      -5.097940807559329,
+      7.014426169538083,
+      8.8690055846359
+    ],
+    "targetVelocity": [
+      4.794724532353419,
+      0.4582230746949385,
+      1.4320996330698317,
+      4.316493765591
+    ],
+    "targetAcceleration": [
+      -0.801313276416896,
+      -4.737899700962359,
+      4.651861335458236,
+      5.301546852683707
+    ],
+    "maxVelocity": [
+      7.523679864963146,
+      7.60178778567008,
+      3.8299819887861326,
+      6.06714727247785
+    ],
+    "maxAcceleration": [
+      5.9267702217226015,
+      7.48456216195917,
+      7.796051086808891,
+      6.486593058756476
+    ],
+    "maxJerk": [
+      7.0462391095340475,
+      13.359544765808884,
+      16.88817775624209,
+      5.8334901465108855
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.45475896592332,
+      7.6255079589689565,
+      0.47246348708451436,
+      5.922479745649847
+    ],
+    "currentVelocity": [
+      2.5199884472840957,
+      3.5278950707427192,
+      2.8553796166366867,
+      0.48879729741783606
+    ],
+    "currentAcceleration": [
+      0.1372816947203246,
+      -1.731715561102737,
+      -3.134761561988977,
+      -0.05858196927055559
+    ],
+    "targetPosition": [
+      7.406124451947157,
+      -7.149988920697645,
+      2.097885207890922,
+      -1.1353675277566957
+    ],
+    "targetVelocity": [
+      1.094380146339509,
+      -0.4864626563531118,
+      -1.3038846765496261,
+      -0.3054291216958642
+    ],
+    "targetAcceleration": [
+      1.341674472452083,
+      2.9158304254870533,
+      6.1549523212722015,
+      -5.6111949074889536
+    ],
+    "maxVelocity": [
+      2.6744282412371003,
+      5.411417149405686,
+      5.646171664615095,
+      7.209535968401056
+    ],
+    "maxAcceleration": [
+      7.57140150763706,
+      5.964205203713096,
+      6.573592458771001,
+      9.507897610837901
+    ],
+    "maxJerk": [
+      16.68921144877384,
+      5.4554315740198875,
+      13.983527988771195,
+      9.363709879517193
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.649638996674614,
+      2.8734158751420846,
+      -7.496205260838029,
+      -2.2326253332283468
+    ],
+    "currentVelocity": [
+      -1.1148555114253895,
+      2.356789685740737,
+      1.4513992853692952,
+      2.1149123427781173
+    ],
+    "currentAcceleration": [
+      -5.311449927237129,
+      -3.638759872337814,
+      2.9794904209979522,
+      -2.0243910567745926
+    ],
+    "targetPosition": [
+      -0.758946716915748,
+      -7.352136968618015,
+      -9.888226691810416,
+      0.9031488573746334
+    ],
+    "targetVelocity": [
+      0.4930574133673984,
+      -4.907540140759027,
+      0.5399225112229442,
+      6.600171619955384
+    ],
+    "targetAcceleration": [
+      -2.8373525656567633,
+      7.477065152681284,
+      -4.465623147498878,
+      -2.3288028011218884
+    ],
+    "maxVelocity": [
+      4.398248659208392,
+      7.34759231048733,
+      2.4673578017814686,
+      7.159007947615464
+    ],
+    "maxAcceleration": [
+      6.281548284044271,
+      9.777526865132316,
+      7.548688321360932,
+      5.264120251976022
+    ],
+    "maxJerk": [
+      8.470963490069439,
+      19.249108982250128,
+      7.777138726211219,
+      9.870994812974576
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.6256874674767374,
+      -3.8518434642831316,
+      4.2748653615106775,
+      -8.998249828320834
+    ],
+    "currentVelocity": [
+      0.7266512471812332,
+      -4.770678468268409,
+      -2.04680174444849,
+      -3.9775858544730007
+    ],
+    "currentAcceleration": [
+      3.2947551603330583,
+      -1.9881210367500248,
+      -2.012593754002724,
+      -0.38196869992904503
+    ],
+    "targetPosition": [
+      8.858061369195205,
+      -2.008120506946529,
+      -1.0405453433201153,
+      -7.26443294117149
+    ],
+    "targetVelocity": [
+      0.2820300114702299,
+      -0.8438956922590766,
+      0.7049925803377906,
+      -2.7563217292107027
+    ],
+    "targetAcceleration": [
+      2.11808620349682,
+      -2.785524087797523,
+      0.026090078291264085,
+      -2.4516278535143647
+    ],
+    "maxVelocity": [
+      2.5900135125257258,
+      5.663410584713085,
+      3.6169136844298317,
+      5.998255100589034
+    ],
+    "maxAcceleration": [
+      7.274054136623417,
+      3.9069759886018827,
+      3.043545571780834,
+      4.680344652505592
+    ],
+    "maxJerk": [
+      13.26901636041216,
+      15.402903584400345,
+      12.320109898487775,
+      6.13400205801906
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.8491597813938334,
+      3.6786372488868686,
+      2.2455241858769615,
+      6.619657336717747
+    ],
+    "currentVelocity": [
+      1.2062049364397103,
+      -4.006406585252507,
+      -0.7901125671994071,
+      -0.896703185374375
+    ],
+    "currentAcceleration": [
+      -6.23007297194563,
+      2.351927297304921,
+      -1.5601923846930106,
+      -1.5793331825376349
+    ],
+    "targetPosition": [
+      6.294477431126452,
+      7.956951022026239,
+      -3.8731670666043394,
+      -9.416153469165085
+    ],
+    "targetVelocity": [
+      -0.9865570791957312,
+      -2.9299493263845506,
+      2.922106210489,
+      -1.5050768412130475
+    ],
+    "targetAcceleration": [
+      -2.6497883672415306,
+      3.3309937696406786,
+      7.730859895838753,
+      -4.305015884098197
+    ],
+    "maxVelocity": [
+      6.777733066087104,
+      6.339519056956917,
+      3.6547594182164183,
+      4.31767714499744
+    ],
+    "maxAcceleration": [
+      7.3297355909828115,
+      5.806972789697336,
+      7.8490953461396895,
+      4.401389827229952
+    ],
+    "maxJerk": [
+      6.306195479305702,
+      6.52028480030439,
+      15.54554546542243,
+      8.299765045121262
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.408876311065988,
+      0.4515023835677603,
+      6.59063114159817,
+      6.710857008922424
+    ],
+    "currentVelocity": [
+      -3.527586317611186,
+      -4.323938625849911,
+      1.5300361379368317,
+      -0.4518419526819404
+    ],
+    "currentAcceleration": [
+      0.12706628788520513,
+      -2.7817175782443764,
+      -1.062434014610968,
+      -3.706437269376259
+    ],
+    "targetPosition": [
+      4.529273760178654,
+      7.606528177187197,
+      5.612215705782209,
+      4.250867545674772
+    ],
+    "targetVelocity": [
+      -2.3537097530944386,
+      -0.07755220255847828,
+      -2.9497645480677908,
+      -4.025717347202887
+    ],
+    "targetAcceleration": [
+      -0.31512334593129765,
+      -1.5749140796768897,
+      -4.367614463854661,
+      0.39341384582338
+    ],
+    "maxVelocity": [
+      3.86834825703684,
+      6.0216491983926765,
+      4.365361332070236,
+      7.239462917167815
+    ],
+    "maxAcceleration": [
+      3.2266897650935817,
+      6.969485534191113,
+      6.606350150982469,
+      4.163258678956294
+    ],
+    "maxJerk": [
+      9.945832476961854,
+      15.792209305003112,
+      13.586951214167925,
+      15.55047783225935
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.757041115002263,
+      5.351182507055443,
+      -4.419194376540007,
+      -4.915912337546664
+    ],
+    "currentVelocity": [
+      5.08842063304859,
+      -4.55636362333871,
+      4.66847738878429,
+      1.1060756573210417
+    ],
+    "currentAcceleration": [
+      -8.04043096496242,
+      0.08117918772684263,
+      -0.53550278527173,
+      -3.1879388778808204
+    ],
+    "targetPosition": [
+      9.96508213157189,
+      8.416773837589616,
+      -3.046881156409702,
+      7.6303235902595254
+    ],
+    "targetVelocity": [
+      4.77354894190248,
+      5.02599918641749,
+      -2.4016759063672977,
+      -5.616233239708396
+    ],
+    "targetAcceleration": [
+      7.103560138073949,
+      -0.5471639962164407,
+      0.2012259646988266,
+      -4.0187957146321365
+    ],
+    "maxVelocity": [
+      7.213823278013117,
+      6.872077421783834,
+      7.559464244441341,
+      6.00785035850145
+    ],
+    "maxAcceleration": [
+      9.919189634129037,
+      4.363964489856386,
+      4.2690266213604176,
+      4.442537847303778
+    ],
+    "maxJerk": [
+      17.742453932926956,
+      18.733559023871365,
+      8.830316882102831,
+      8.620802883338543
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.5758335444217604,
+      4.604587425131726,
+      -0.12500380595662897,
+      -0.9585995060460366
+    ],
+    "currentVelocity": [
+      0.44800292352602566,
+      -3.7039816113370687,
+      5.036806932609178,
+      -3.190630318558219
+    ],
+    "currentAcceleration": [
+      -1.4372900058993308,
+      2.2995747266331374,
+      -5.35910871178357,
+      4.083578931209144
+    ],
+    "targetPosition": [
+      -6.449637328181317,
+      1.8755451134139953,
+      -8.866502233412213,
+      -1.9806873420260924
+    ],
+    "targetVelocity": [
+      2.2865493461044086,
+      2.4444490070333753,
+      3.1835778708822406,
+      -2.418900503036973
+    ],
+    "targetAcceleration": [
+      -1.3885672313856476,
+      0.03122783282380137,
+      3.446297893458265,
+      0.4771732771008734
+    ],
+    "maxVelocity": [
+      3.8537993386213345,
+      7.453997289709186,
+      7.057656921840691,
+      6.543414624396318
+    ],
+    "maxAcceleration": [
+      5.875762062743355,
+      5.779989634255607,
+      5.6879422768756775,
+      7.126896637386024
+    ],
+    "maxJerk": [
+      15.562854214183604,
+      12.784279034348891,
+      11.338475431473789,
+      13.630131303091972
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.109716596387212,
+      -8.237639380072153,
+      -4.001056287684603,
+      6.4708505604147035
+    ],
+    "currentVelocity": [
+      -3.4622245490235435,
+      -4.165749932382208,
+      -4.421800736651285,
+      0.8144588707707694
+    ],
+    "currentAcceleration": [
+      -0.673546479646788,
+      2.935160600833809,
+      -2.488403396284701,
+      -5.936461375840537
+    ],
+    "targetPosition": [
+      -2.5234185422696527,
+      9.233377377313236,
+      -5.907478690206618,
+      -1.4756737992340767
+    ],
+    "targetVelocity": [
+      -3.2962954346194957,
+      0.9465550167524341,
+      2.731170351676198,
+      2.3238865465847667
+    ],
+    "targetAcceleration": [
+      1.0176196196008815,
+      -0.990777157404505,
+      -2.0946883582220988,
+      3.811161164020998
+    ],
+    "maxVelocity": [
+      7.339623115919589,
+      5.624004692313129,
+      5.375039788351309,
+      5.060207537212011
+    ],
+    "maxAcceleration": [
+      3.3035914400200594,
+      7.703760088086042,
+      8.409635760205555,
+      9.58151010789551
+    ],
+    "maxJerk": [
+      9.982386215421316,
+      14.099991255798413,
+      8.03125006192146,
+      6.5959602497575665
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.028109591660575,
+      1.0218359037171822,
+      5.32254842732139,
+      4.290498752488347
+    ],
+    "currentVelocity": [
+      1.001516653281497,
+      -3.116197990386109,
+      -3.48889393971596,
+      -1.5261309124123512
+    ],
+    "currentAcceleration": [
+      3.102442815452374,
+      6.091720251235069,
+      -4.198365021618536,
+      2.2033826273607406
+    ],
+    "targetPosition": [
+      5.455006098414826,
+      1.5105681119142105,
+      -6.67455654629925,
+      3.97286831481634
+    ],
+    "targetVelocity": [
+      -2.8563037302067205,
+      -2.264064668673404,
+      -1.2997320650146413,
+      -1.3571003652746443
+    ],
+    "targetAcceleration": [
+      4.068177037685436,
+      6.331395037598197,
+      4.019876111645358,
+      -2.0822852401937326
+    ],
+    "maxVelocity": [
+      7.273127052656092,
+      3.9310314410386025,
+      5.614625374001509,
+      3.8057539021209736
+    ],
+    "maxAcceleration": [
+      8.759520752884736,
+      7.351899487318303,
+      5.92654776028893,
+      4.849515709149539
+    ],
+    "maxJerk": [
+      6.14627209124381,
+      13.98633854736861,
+      14.921574380632848,
+      15.807283946142695
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.7808307639977308,
+      -3.1850535417646704,
+      4.852037102014053,
+      -1.5692943052283486
+    ],
+    "currentVelocity": [
+      3.8705232164620504,
+      2.6473315147974086,
+      -2.990627544244798,
+      0.5518403731756858
+    ],
+    "currentAcceleration": [
+      -1.370284360956787,
+      -0.6190782820255487,
+      -5.20750752352964,
+      4.1609391261969035
+    ],
+    "targetPosition": [
+      -5.618877656749075,
+      9.850481760035162,
+      8.661682134981675,
+      6.991698997509708
+    ],
+    "targetVelocity": [
+      4.146768891708728,
+      -4.674428509716651,
+      4.199127586916223,
+      -1.1367856898799777
+    ],
+    "targetAcceleration": [
+      -5.705095105499791,
+      -5.072742500460528,
+      -2.7024525029108757,
+      -2.6895265716577548
+    ],
+    "maxVelocity": [
+      5.730581687720452,
+      5.566328504559627,
+      4.635065669031237,
+      2.1726956815924323
+    ],
+    "maxAcceleration": [
+      7.055028079563104,
+      5.076733257412415,
+      5.571289949259034,
+      7.378704130092449
+    ],
+    "maxJerk": [
+      18.51902657684606,
+      11.488700615308174,
+      12.397289407799425,
+      12.709061923627747
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.737235526355693,
+      6.049554726094918,
+      6.090740416463156,
+      -4.629517717450642
+    ],
+    "currentVelocity": [
+      1.6123316313378915,
+      -1.3462836442425345,
+      -0.595750681606289,
+      3.2748718774447942
+    ],
+    "currentAcceleration": [
+      1.9447781577790852,
+      -3.136728746108729,
+      -1.8835045818305334,
+      -1.4069207090519331
+    ],
+    "targetPosition": [
+      9.162559852701634,
+      -3.7470240427239476,
+      6.321830057015269,
+      1.808453605508987
+    ],
+    "targetVelocity": [
+      0.7914566068262712,
+      0.2546318865662327,
+      0.7100843592651489,
+      4.20531836113638
+    ],
+    "targetAcceleration": [
+      6.361566589093709,
+      5.43940475416851,
+      4.345013963849198,
+      -0.6799665765993508
+    ],
+    "maxVelocity": [
+      7.633329574671029,
+      4.345630585458035,
+      2.811245471136874,
+      4.301240032263241
+    ],
+    "maxAcceleration": [
+      7.4018308310022185,
+      7.84964633499818,
+      5.467595558706417,
+      6.928564138623992
+    ],
+    "maxJerk": [
+      17.988255598172806,
+      8.001166296915347,
+      5.592699084670565,
+      18.25297558624795
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.747890014088632,
+      -0.3764914167632387,
+      3.134655488431388,
+      -9.280101935939589
+    ],
+    "currentVelocity": [
+      -1.2001885868903095,
+      2.739153733529572,
+      -1.2671713369007005,
+      0.5885049833225402
+    ],
+    "currentAcceleration": [
+      2.475176072022971,
+      -4.009579286951374,
+      5.612923821215495,
+      -1.0587547078271207
+    ],
+    "targetPosition": [
+      2.102997918302634,
+      -6.434892291255602,
+      -3.291562993336745,
+      -4.0866013158587045
+    ],
+    "targetVelocity": [
+      3.268684183630995,
+      -2.6206661754656135,
+      -1.9504566202288354,
+      1.7204262123377898
+    ],
+    "targetAcceleration": [
+      -4.933559852022798,
+      -7.313064593708103,
+      4.594883624264745,
+      -1.691895891813744
+    ],
+    "maxVelocity": [
+      6.897042001535233,
+      4.644379209946438,
+      3.7821889584816937,
+      4.0597897726673375
+    ],
+    "maxAcceleration": [
+      5.620180960894101,
+      7.360099520246372,
+      5.686461195156737,
+      3.045575229998925
+    ],
+    "maxJerk": [
+      8.52272029068801,
+      10.611073162401272,
+      18.778034179263116,
+      9.107900966422987
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.428152527647761,
+      4.529780879581548,
+      -4.12271178387686,
+      -9.019254788594925
+    ],
+    "currentVelocity": [
+      3.9603638406311967,
+      1.881444995748982,
+      3.673877683751172,
+      -1.1210518578399649
+    ],
+    "currentAcceleration": [
+      0.41907119767948897,
+      -1.9391628032594523,
+      5.297766158644292,
+      -2.140476910442106
+    ],
+    "targetPosition": [
+      -1.9105590884932706,
+      0.5620231216000544,
+      -5.2171672816371135,
+      -6.689667183377033
+    ],
+    "targetVelocity": [
+      -3.2785411293017233,
+      0.7963747445105795,
+      4.479513596162622,
+      -0.9857427577351068
+    ],
+    "targetAcceleration": [
+      3.6947819019022705,
+      2.839218193326226,
+      -2.9204302782317426,
+      -2.3614353150447247
+    ],
+    "maxVelocity": [
+      4.1020971913375694,
+      3.9885890488806117,
+      5.122661360405422,
+      5.855556865532581
+    ],
+    "maxAcceleration": [
+      3.7886726157963184,
+      7.362682659688576,
+      5.475793110826011,
+      7.9663150000008045
+    ],
+    "maxJerk": [
+      10.50840810386943,
+      12.204269662111665,
+      19.044197835081672,
+      13.423859473585534
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.874878644226813,
+      -0.9224740095683774,
+      -7.057569713169409,
+      6.969680289543675
+    ],
+    "currentVelocity": [
+      -1.505974458020391,
+      -0.3370511140247183,
+      1.0094668543223237,
+      -5.029427492798337
+    ],
+    "currentAcceleration": [
+      2.2619275408876023,
+      -9.544745594141768,
+      -1.2352448716894386,
+      0.7287933159057935
+    ],
+    "targetPosition": [
+      -7.018622616639654,
+      7.480421360239312,
+      3.9209950371760662,
+      1.977795501781701
+    ],
+    "targetVelocity": [
+      -1.967947747581932,
+      -0.23162866742035249,
+      3.6264215085218465,
+      -2.590262199705955
+    ],
+    "targetAcceleration": [
+      0.15664630751776887,
+      -7.736227307658458,
+      -1.0598875744576195,
+      -2.138955696738348
+    ],
+    "maxVelocity": [
+      3.6364419921103304,
+      5.206891459303165,
+      6.304046931373651,
+      5.045171375512804
+    ],
+    "maxAcceleration": [
+      3.508251956653596,
+      9.89399573139588,
+      3.767393769099069,
+      6.817347963971042
+    ],
+    "maxJerk": [
+      19.7434446831669,
+      9.744576427484251,
+      17.394320612597376,
+      5.938811735060515
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.814301662609452,
+      -8.127940089416917,
+      -3.7458395679138645,
+      1.3117120704822085
+    ],
+    "currentVelocity": [
+      -1.5989595754847272,
+      4.015192302635922,
+      0.41296381532892124,
+      -4.569291037206287
+    ],
+    "currentAcceleration": [
+      1.1226788831840881,
+      -6.705629737871329,
+      -2.2114227582018975,
+      3.896264481302648
+    ],
+    "targetPosition": [
+      -1.3454970420554968,
+      8.257884491541986,
+      -0.971608354759681,
+      9.38265045150574
+    ],
+    "targetVelocity": [
+      0.3509363789822606,
+      1.7855094865189596,
+      0.1501536241790955,
+      0.952921079750694
+    ],
+    "targetAcceleration": [
+      -4.232406091090064,
+      -7.348454113345083,
+      -0.07685910936463447,
+      2.191655946136672
+    ],
+    "maxVelocity": [
+      2.158978236845219,
+      4.165488577414397,
+      4.676784743654949,
+      5.151249231960336
+    ],
+    "maxAcceleration": [
+      8.3171335463672,
+      8.309315830014487,
+      4.717243107321133,
+      4.504238663047037
+    ],
+    "maxJerk": [
+      18.56638396679216,
+      18.715969145288835,
+      6.39173766084978,
+      15.441436345303478
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.8504725986141892,
+      -7.528494025790653,
+      -0.13099852170811488,
+      7.5796406957093545
+    ],
+    "currentVelocity": [
+      -3.3581412468122362,
+      -3.7768810163942437,
+      -2.163695711717503,
+      2.16726895364482
+    ],
+    "currentAcceleration": [
+      -4.016509437178693,
+      4.790234535788869,
+      3.8150747371265448,
+      -2.5982583880745374
+    ],
+    "targetPosition": [
+      8.645959433383293,
+      4.349765407866666,
+      8.59151983059212,
+      4.540489818362952
+    ],
+    "targetVelocity": [
+      -2.3512840709549403,
+      -2.830808789314688,
+      1.5333890038998979,
+      -0.8723195574250044
+    ],
+    "targetAcceleration": [
+      1.464107602535055,
+      -4.942624603915474,
+      -0.8283863159523177,
+      6.161365667247194
+    ],
+    "maxVelocity": [
+      4.752628089751395,
+      5.222430545048145,
+      2.4914491325331847,
+      3.786600259260556
+    ],
+    "maxAcceleration": [
+      7.639835412289941,
+      5.65747205371604,
+      5.044892504998539,
+      9.008407778054007
+    ],
+    "maxJerk": [
+      18.24274530564187,
+      11.496110415409227,
+      14.692219910339572,
+      18.913628313119425
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.236460367042492,
+      4.387405376967434,
+      -3.376361974793161,
+      -1.1282187414989142
+    ],
+    "currentVelocity": [
+      -2.6925273502836395,
+      -2.2000781679652297,
+      1.420363514571978,
+      -0.6813522133605936
+    ],
+    "currentAcceleration": [
+      -2.842918462947611,
+      -4.504333844922691,
+      2.9985894256081025,
+      -4.5796944301244755
+    ],
+    "targetPosition": [
+      1.2065245522459183,
+      -1.4323323228665608,
+      -3.2428925960994137,
+      0.15816525171302942
+    ],
+    "targetVelocity": [
+      -0.08495638660078964,
+      2.220008674938521,
+      1.536550702747931,
+      2.857957493996971
+    ],
+    "targetAcceleration": [
+      -1.1952931680293517,
+      7.364164456173061,
+      1.23791538699205,
+      -4.274413168835935
+    ],
+    "maxVelocity": [
+      5.345253765158922,
+      6.201594692105816,
+      4.470012311128027,
+      5.800702367624445
+    ],
+    "maxAcceleration": [
+      3.752011902498942,
+      9.4239533968201,
+      9.511422627107473,
+      9.18293611532823
+    ],
+    "maxJerk": [
+      18.9409209732491,
+      12.485368152727702,
+      6.742841534159803,
+      16.930836881784025
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.294508154736555,
+      0.19875799207878941,
+      9.53909110138493,
+      -8.616556635015034
+    ],
+    "currentVelocity": [
+      4.053405339837149,
+      -0.060398785924637544,
+      -0.21180344340075052,
+      -1.7498596980016825
+    ],
+    "currentAcceleration": [
+      4.24213814333669,
+      2.7616077086831745,
+      0.38608686392875136,
+      3.8353290352203926
+    ],
+    "targetPosition": [
+      -0.19770827715541017,
+      3.612280292835937,
+      -6.76202059044204,
+      -8.878031928396283
+    ],
+    "targetVelocity": [
+      -2.407814554721579,
+      -5.2261962139880955,
+      1.2739495165964017,
+      3.330058882214499
+    ],
+    "targetAcceleration": [
+      -2.9638395656732075,
+      -2.6990121461797267,
+      7.052082174193252,
+      4.094791104994683
+    ],
+    "maxVelocity": [
+      6.067070310624341,
+      7.034266025434986,
+      3.1912520630028216,
+      4.003692245740501
+    ],
+    "maxAcceleration": [
+      6.341546633349863,
+      3.2422192798267973,
+      8.428224320978973,
+      5.566770721238163
+    ],
+    "maxJerk": [
+      19.917829740630623,
+      16.189516774757905,
+      9.179070906369816,
+      10.133464629508214
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.2794797908674553,
+      4.3502065986753795,
+      5.30180912531347,
+      -0.5482322274274125
+    ],
+    "currentVelocity": [
+      1.6656371047498197,
+      3.8528753482944857,
+      -5.090679411482351,
+      4.8593409433971555
+    ],
+    "currentAcceleration": [
+      -2.0900393251268685,
+      1.2770028514667855,
+      -4.7869573316247775,
+      1.646180858769842
+    ],
+    "targetPosition": [
+      -1.9132961585219732,
+      3.3741708466226576,
+      -2.5236262663095754,
+      5.513326137232202
+    ],
+    "targetVelocity": [
+      4.415554922866393,
+      4.716532757345721,
+      1.0513102088903628,
+      -2.506800518872478
+    ],
+    "targetAcceleration": [
+      5.542225269910982,
+      0.570948431968092,
+      6.212941951826062,
+      -2.4990952789052012
+    ],
+    "maxVelocity": [
+      5.511198700205597,
+      6.8494011983039,
+      6.612710900103732,
+      5.13090108188837
+    ],
+    "maxAcceleration": [
+      6.645320622601852,
+      7.577971264784138,
+      8.807088057975113,
+      6.278057406599294
+    ],
+    "maxJerk": [
+      19.18417993892173,
+      9.522296017102738,
+      17.393449124416605,
+      10.677769358702344
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.81407785319388,
+      -6.784628859327492,
+      6.478156743118632,
+      0.2730353706279054
+    ],
+    "currentVelocity": [
+      -1.6232121226401142,
+      4.142391904667721,
+      2.972352257106592,
+      3.7714482105340483
+    ],
+    "currentAcceleration": [
+      -2.8901405189450005,
+      -0.4068264001317097,
+      -5.801186716108585,
+      6.360921797011127
+    ],
+    "targetPosition": [
+      3.2094248103973335,
+      9.348078798188716,
+      -5.361360004501286,
+      -7.133655596081594
+    ],
+    "targetVelocity": [
+      -0.2901182480339175,
+      5.954529827053219,
+      2.852731889817181,
+      4.537185849478016
+    ],
+    "targetAcceleration": [
+      0.5210605815849578,
+      -0.6193072002689188,
+      -4.399305897542869,
+      5.889350561868106
+    ],
+    "maxVelocity": [
+      2.871374372204128,
+      7.331441762667038,
+      7.587874809525585,
+      5.46225769141137
+    ],
+    "maxAcceleration": [
+      3.124527054235267,
+      8.811385323626451,
+      6.155784266496902,
+      9.174138249461425
+    ],
+    "maxJerk": [
+      18.971581299893018,
+      19.47383301122646,
+      9.65460821073645,
+      14.589697808560912
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.508649517640862,
+      -7.828713306334989,
+      -4.719616575821764,
+      -9.822449893281323
+    ],
+    "currentVelocity": [
+      0.6646541311796463,
+      -0.07934530356403346,
+      2.578098000349442,
+      -4.531197545297434
+    ],
+    "currentAcceleration": [
+      -2.594959805076195,
+      -1.477880073008147,
+      1.5696339205835077,
+      -1.3188886357272551
+    ],
+    "targetPosition": [
+      -5.903827359103895,
+      -5.774327159769241,
+      4.83088504392374,
+      6.4925757347239745
+    ],
+    "targetVelocity": [
+      -4.685534450143441,
+      -3.609552197174395,
+      2.727392470305814,
+      4.694674061263107
+    ],
+    "targetAcceleration": [
+      -3.239427247887769,
+      -1.4837172512554138,
+      0.6830737075181235,
+      7.934550487951604
+    ],
+    "maxVelocity": [
+      6.95529382033365,
+      4.779292988528905,
+      5.847189182413574,
+      4.858254511782101
+    ],
+    "maxAcceleration": [
+      4.638072165536161,
+      4.147419160786834,
+      3.433500256320243,
+      9.438798282337526
+    ],
+    "maxJerk": [
+      6.414668743497192,
+      12.021619074189244,
+      13.829758371741598,
+      18.063603067265795
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.39998356007010116,
+      -1.6374025062564623,
+      -6.489153240178036,
+      -1.1305268986508175
+    ],
+    "currentVelocity": [
+      5.334934855368337,
+      6.741906464388916,
+      4.041392545219772,
+      0.9613492396781425
+    ],
+    "currentAcceleration": [
+      0.5083102387916023,
+      0.04765902235101249,
+      1.183960101327095,
+      2.4737002204387473
+    ],
+    "targetPosition": [
+      -7.595375895950093,
+      2.217700144176318,
+      9.001695271130497,
+      -8.172295503684408
+    ],
+    "targetVelocity": [
+      1.892624988006384,
+      5.601395155147499,
+      3.8780611539899272,
+      -0.818805564470577
+    ],
+    "targetAcceleration": [
+      -3.3671234860351547,
+      2.3425282636763622,
+      -0.8262592819227015,
+      -1.7761658335306167
+    ],
+    "maxVelocity": [
+      6.56013096540765,
+      7.150061909000841,
+      5.202244039662126,
+      2.1849389375314288
+    ],
+    "maxAcceleration": [
+      3.52914085660921,
+      3.209074427745408,
+      8.206994685283398,
+      6.3894920364170655
+    ],
+    "maxJerk": [
+      15.201337558199228,
+      6.264728733855698,
+      6.944591246925085,
+      8.44322978188288
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -0.6392529328226288,
+      -5.496566380871666,
+      8.420202235883629,
+      1.8459093014758778
+    ],
+    "currentVelocity": [
+      1.7815820404450315,
+      -1.6848662155108571,
+      1.7798521598208046,
+      -0.050855738783726956
+    ],
+    "currentAcceleration": [
+      -1.0718018419376403,
+      8.574836059160958,
+      -1.1957216832468962,
+      0.17760824917673368
+    ],
+    "targetPosition": [
+      -4.048923767049026,
+      8.060693107862654,
+      -1.4532928553084652,
+      5.952162197841766
+    ],
+    "targetVelocity": [
+      1.79662009671104,
+      -3.2253565739099987,
+      -2.4485665139213095,
+      4.509844695028569
+    ],
+    "targetAcceleration": [
+      3.0830138112639984,
+      2.4273123912360983,
+      -7.812844267472423,
+      -0.3295601130611807
+    ],
+    "maxVelocity": [
+      3.284610621171682,
+      5.56280741410994,
+      4.266228006444741,
+      4.862459999173955
+    ],
+    "maxAcceleration": [
+      6.847971235638245,
+      8.764635353023795,
+      8.330849073086533,
+      3.24892767437969
+    ],
+    "maxJerk": [
+      9.797635195503094,
+      18.128993241811372,
+      15.49340827750776,
+      7.1194011366815415
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.165688403626719,
+      -8.177099036387055,
+      2.3467788793808744,
+      -9.87979234495576
+    ],
+    "currentVelocity": [
+      -1.6346496507835906,
+      0.8501917583372158,
+      -1.4422436615956358,
+      3.2708767769352827
+    ],
+    "currentAcceleration": [
+      -3.7902571417811646,
+      1.2296815564475896,
+      0.950103061648234,
+      -3.10695582070326
+    ],
+    "targetPosition": [
+      4.946851161345798,
+      -2.632657740856345,
+      -7.234833000710321,
+      7.081947171982243
+    ],
+    "targetVelocity": [
+      -4.024303544551007,
+      -2.3928330252026875,
+      -0.6624026845956172,
+      -1.8273555177101068
+    ],
+    "targetAcceleration": [
+      0.9887536894112312,
+      -3.4657044519322135,
+      0.7107140911869236,
+      0.6945014717515967
+    ],
+    "maxVelocity": [
+      4.656953893307926,
+      6.350949926021999,
+      3.139108204186023,
+      3.5062840557553088
+    ],
+    "maxAcceleration": [
+      5.738144327131519,
+      4.033812780972429,
+      3.613678746404626,
+      8.59216956441487
+    ],
+    "maxJerk": [
+      10.790302466285109,
+      9.438824378787515,
+      6.315052327350919,
+      6.93556860144439
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.2002293475282,
+      -5.909264094058912,
+      5.838626857533759,
+      -7.024736717528843
+    ],
+    "currentVelocity": [
+      -0.3699586804139985,
+      -1.0407712194511758,
+      2.51569691820953,
+      0.9592534566182191
+    ],
+    "currentAcceleration": [
+      -5.7879844568097765,
+      -0.2825609950154431,
+      -6.4908713027718346,
+      0.09329077824835075
+    ],
+    "targetPosition": [
+      -2.545046347872111,
+      9.829283399042243,
+      7.387594038961641,
+      8.053675574625355
+    ],
+    "targetVelocity": [
+      -3.424880893261196,
+      7.268002255701104,
+      2.393261722095289,
+      -6.2843955732693
+    ],
+    "targetAcceleration": [
+      -1.6285731792777014,
+      -2.3830406730369003,
+      -0.1513638728029676,
+      -3.479630430118009
+    ],
+    "maxVelocity": [
+      6.267504955989715,
+      7.668308368423425,
+      6.689960958729838,
+      7.33744869714209
+    ],
+    "maxAcceleration": [
+      5.959536745404886,
+      3.8205321627913094,
+      8.620643116941,
+      4.751037636292958
+    ],
+    "maxJerk": [
+      7.973462910872861,
+      18.88824005108657,
+      14.379900699558407,
+      8.746404683407821
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.8033136423055893,
+      -6.188133717024435,
+      -4.200055012205328,
+      2.9711496319197988
+    ],
+    "currentVelocity": [
+      0.6729061306363961,
+      -1.5755407656163447,
+      2.5158602244774846,
+      3.0419113214716678
+    ],
+    "currentAcceleration": [
+      1.699900069458974,
+      -4.29905836623821,
+      1.5987445268559268,
+      -1.208275024267886
+    ],
+    "targetPosition": [
+      6.648844327604692,
+      -6.704758929865406,
+      -7.68977498314765,
+      -7.020362325567433
+    ],
+    "targetVelocity": [
+      0.4648277620188854,
+      1.5015802262676425,
+      -3.6614860862214145,
+      -1.523206480802462
+    ],
+    "targetAcceleration": [
+      -0.49070959197669595,
+      2.8569890948815715,
+      3.5643486892332685,
+      -4.268621115850289
+    ],
+    "maxVelocity": [
+      3.5159530314223097,
+      5.19390561113714,
+      6.728968789844276,
+      7.238403233414365
+    ],
+    "maxAcceleration": [
+      5.11822872357457,
+      5.465070440501265,
+      4.44762457511689,
+      9.485698469906502
+    ],
+    "maxJerk": [
+      9.297184469326362,
+      16.19472542451551,
+      9.384807428765528,
+      19.26818098246345
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.215498233842329,
+      6.613031073355799,
+      -7.50113888964278,
+      2.968400950739378
+    ],
+    "currentVelocity": [
+      1.1283704441231972,
+      3.653026756886767,
+      4.560057176784051,
+      -4.65256454884554
+    ],
+    "currentAcceleration": [
+      8.120197792017914,
+      -1.1087985710244075,
+      3.8897726806096564,
+      -5.564388840222257
+    ],
+    "targetPosition": [
+      8.353111204935004,
+      -6.004970493409525,
+      6.368040299688651,
+      -6.419770866479886
+    ],
+    "targetVelocity": [
+      1.7772055767457307,
+      -1.619223140783959,
+      -4.533712573010834,
+      -4.40756501837119
+    ],
+    "targetAcceleration": [
+      4.969336834136637,
+      -0.32499818625068766,
+      -0.22322387470568827,
+      -4.0530256485204745
+    ],
+    "maxVelocity": [
+      7.478764823550421,
+      4.294639368713777,
+      7.954559851481397,
+      7.259708402023428
+    ],
+    "maxAcceleration": [
+      8.71075670688892,
+      5.138201572613218,
+      9.751507589415628,
+      7.226535267888332
+    ],
+    "maxJerk": [
+      14.278741888074617,
+      13.520756515583923,
+      18.665395585920052,
+      13.808088940160571
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.021342981659857,
+      -5.495804956997327,
+      -7.0031738302925355,
+      6.651260180087625
+    ],
+    "currentVelocity": [
+      4.957507658530081,
+      -4.807666846643167,
+      -0.5134399924282762,
+      -1.9978365306399228
+    ],
+    "currentAcceleration": [
+      2.7748908591317214,
+      4.667120590628043,
+      7.402279291996686,
+      -0.36921878139551323
+    ],
+    "targetPosition": [
+      -4.532021240247232,
+      -2.303509265303867,
+      -4.2405317476337085,
+      5.40454399979285
+    ],
+    "targetVelocity": [
+      -1.9100616594919781,
+      6.295905669625611,
+      0.5882120923767973,
+      -1.3259174119715853
+    ],
+    "targetAcceleration": [
+      -0.6259890849504597,
+      2.038680129449368,
+      6.754613147242658,
+      2.3370485089969826
+    ],
+    "maxVelocity": [
+      5.296855900443997,
+      7.957238998610752,
+      2.394320648598572,
+      2.089731701727321
+    ],
+    "maxAcceleration": [
+      4.240114422821547,
+      5.082349273314694,
+      8.175385615036124,
+      4.137229800104138
+    ],
+    "maxJerk": [
+      19.732764672605775,
+      12.814128910708641,
+      19.328960377197642,
+      16.540239103924613
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.653102946565548,
+      2.968513981982028,
+      -1.7457503451334837,
+      7.318510480180915
+    ],
+    "currentVelocity": [
+      3.005195366538576,
+      -3.7279858580515315,
+      -0.9326036368729849,
+      3.604506524409085
+    ],
+    "currentAcceleration": [
+      -3.1893361337448054,
+      3.9824547204976692,
+      3.0430575353859677,
+      -3.9689041671465843
+    ],
+    "targetPosition": [
+      -3.583577550424093,
+      -4.571518716315897,
+      8.120175275352569,
+      6.3281313045239145
+    ],
+    "targetVelocity": [
+      0.7785628922193224,
+      -1.344493998224236,
+      -1.451536751290746,
+      0.8775665430893671
+    ],
+    "targetAcceleration": [
+      2.2356516311323733,
+      2.3464837431380587,
+      -0.4105592445403978,
+      3.2572866169576624
+    ],
+    "maxVelocity": [
+      6.0202000741079775,
+      4.382277317426908,
+      5.481990323266505,
+      4.479306039125139
+    ],
+    "maxAcceleration": [
+      3.919222250704372,
+      5.560885058130648,
+      8.427787825967606,
+      4.42947615999749
+    ],
+    "maxJerk": [
+      6.341515979462034,
+      7.048630168863372,
+      7.917149857632398,
+      12.641023958375104
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -9.001421458180882,
+      4.96311505104841,
+      8.11859093153467,
+      9.293982135194739
+    ],
+    "currentVelocity": [
+      -1.4667506388036173,
+      -0.06002652725802626,
+      -3.391329707664946,
+      -1.7706185962172243
+    ],
+    "currentAcceleration": [
+      -2.8998279213155493,
+      -2.1216350978714833,
+      -0.6417338502863683,
+      1.4039834362232875
+    ],
+    "targetPosition": [
+      2.1827400548604796,
+      9.087262420526269,
+      -2.998842289090831,
+      -6.1492301855819065
+    ],
+    "targetVelocity": [
+      3.3749542820591714,
+      -4.9368920847393625,
+      1.0299099418776758,
+      -1.8088807929929729
+    ],
+    "targetAcceleration": [
+      8.181156104906451,
+      2.315839368549486,
+      2.577671148031742,
+      -1.521722043360004
+    ],
+    "maxVelocity": [
+      7.6138277255366535,
+      6.133978809722678,
+      3.7163624497844725,
+      2.244124970261229
+    ],
+    "maxAcceleration": [
+      8.216885906427455,
+      3.34527474207925,
+      3.742932528308887,
+      3.6176513445396394
+    ],
+    "maxJerk": [
+      7.255707219483327,
+      14.797822490924137,
+      7.863854295594988,
+      18.52231351064917
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.536227368720887,
+      0.3746792353340229,
+      -8.847543730595804,
+      7.761672990971469
+    ],
+    "currentVelocity": [
+      0.09386959477670942,
+      -6.632517582858336,
+      -2.976062089417134,
+      0.5964701332004343
+    ],
+    "currentAcceleration": [
+      2.6163148011542674,
+      0.7714126076914551,
+      4.949311675662969,
+      2.1188993890016077
+    ],
+    "targetPosition": [
+      -7.0409159480274734,
+      4.714691574115687,
+      -6.625467224921426,
+      -0.7757995332680814
+    ],
+    "targetVelocity": [
+      -1.882876350626778,
+      -5.055694772756717,
+      -1.3461318361845311,
+      -1.1513995208379035
+    ],
+    "targetAcceleration": [
+      1.133532335244034,
+      -6.184775700890051,
+      6.971211822289257,
+      2.812579068579809
+    ],
+    "maxVelocity": [
+      2.0563400659569098,
+      6.751337004180279,
+      3.064580160898874,
+      2.2231584431420304
+    ],
+    "maxAcceleration": [
+      9.676263804127203,
+      7.2503051203872895,
+      8.19453571479033,
+      4.697202168625656
+    ],
+    "maxJerk": [
+      5.00546958209046,
+      13.905818614132311,
+      19.707223450192934,
+      16.30723569213522
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.69597912621326,
+      9.6309627137841,
+      3.453697764310423,
+      -6.78672472868985
+    ],
+    "currentVelocity": [
+      2.3469180871350446,
+      -3.585848217882533,
+      0.049834588641711086,
+      2.1948614493470253
+    ],
+    "currentAcceleration": [
+      -3.0919889787233963,
+      0.7809807879656341,
+      -2.480274093724282,
+      3.486705481414755
+    ],
+    "targetPosition": [
+      -2.721248988039841,
+      4.419972901828395,
+      -1.1195774203892164,
+      2.6155213457088866
+    ],
+    "targetVelocity": [
+      1.3560658543176656,
+      -1.7798354671789802,
+      -4.5668141125210635,
+      2.1593745755422593
+    ],
+    "targetAcceleration": [
+      0.4267041133561271,
+      1.6882017491300867,
+      0.19449669753505638,
+      -0.6799533301706253
+    ],
+    "maxVelocity": [
+      3.1625910902768792,
+      3.739893254765832,
+      5.27428976491167,
+      3.186971715708139
+    ],
+    "maxAcceleration": [
+      4.710603922518158,
+      3.8044762674575874,
+      4.042859127980651,
+      4.175399285376679
+    ],
+    "maxJerk": [
+      15.649413743624262,
+      17.577161617563288,
+      16.488593162757894,
+      17.556966235982884
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.4582491075177995,
+      -4.270606375221306,
+      -7.445379835879615,
+      6.352746208700733
+    ],
+    "currentVelocity": [
+      0.016374171750450195,
+      0.9622951482179447,
+      -5.289166184506987,
+      -1.4112281014598471
+    ],
+    "currentAcceleration": [
+      -7.0515755292504485,
+      3.1968703541888974,
+      -2.178885610918206,
+      -4.153149378400304
+    ],
+    "targetPosition": [
+      -4.519440762410145,
+      7.223724337814808,
+      -9.96173534082654,
+      3.5355676184624905
+    ],
+    "targetVelocity": [
+      1.2905831506929424,
+      -1.7896654164102415,
+      -3.5882142072728067,
+      -0.08955777135147125
+    ],
+    "targetAcceleration": [
+      7.098684275587008,
+      0.7709990888366729,
+      -1.6453258599919418,
+      0.5654698239640901
+    ],
+    "maxVelocity": [
+      2.558598231117708,
+      3.3314994982887383,
+      6.536242149620643,
+      3.542791766782665
+    ],
+    "maxAcceleration": [
+      7.452436678378129,
+      6.460893366537242,
+      3.2159898266976157,
+      8.372051634417875
+    ],
+    "maxJerk": [
+      12.319287273520779,
+      6.264758351244503,
+      13.963192320871642,
+      12.705185104512577
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.8027995187236119,
+      9.272611432732532,
+      2.37652607985291,
+      -2.2790368331170807
+    ],
+    "currentVelocity": [
+      -0.9477591807362149,
+      -1.256139503718365,
+      0.5990435022269005,
+      -2.29833794997004
+    ],
+    "currentAcceleration": [
+      -5.545474349452963,
+      4.33313903468207,
+      -4.729946835519614,
+      5.6024206267329895
+    ],
+    "targetPosition": [
+      5.81569663944769,
+      -5.474116229923949,
+      -1.5687594189069127,
+      -6.544937095450671
+    ],
+    "targetVelocity": [
+      -0.8052169658791177,
+      1.5226566614164234,
+      -1.0683215200057297,
+      -3.045764499922784
+    ],
+    "targetAcceleration": [
+      0.6149200771689749,
+      -0.6977571473209982,
+      -5.517212454818642,
+      3.955614359621256
+    ],
+    "maxVelocity": [
+      4.283911544051186,
+      3.6165263243235355,
+      3.606918217253605,
+      4.275460083667069
+    ],
+    "maxAcceleration": [
+      8.27415856945783,
+      8.072248960143757,
+      9.534576630195918,
+      6.498117384492529
+    ],
+    "maxJerk": [
+      9.746723536784087,
+      18.858456468850818,
+      17.664039114952942,
+      7.7420661348412025
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.670353373944176,
+      3.84078611080092,
+      7.547932259627132,
+      3.932843457657537
+    ],
+    "currentVelocity": [
+      1.4642439119321553,
+      -2.5363553952270808,
+      0.1688146981579428,
+      3.69439514777737
+    ],
+    "currentAcceleration": [
+      -4.446923154942745,
+      -0.6277049568803794,
+      0.6132505836493163,
+      -1.0377728615291755
+    ],
+    "targetPosition": [
+      9.412124145314355,
+      5.994936589898661,
+      -5.601152807371768,
+      -6.8400700546853965
+    ],
+    "targetVelocity": [
+      0.3606426616697993,
+      -0.6336180172419863,
+      -0.5639861922158289,
+      -2.236515896532822
+    ],
+    "targetAcceleration": [
+      4.145621444144561,
+      2.1749857633890466,
+      -1.7366636028042217,
+      -6.401779814883357
+    ],
+    "maxVelocity": [
+      5.899111846018985,
+      2.9682967738923076,
+      2.1539742012955143,
+      5.178535780612202
+    ],
+    "maxAcceleration": [
+      5.833484234500732,
+      3.715160164007746,
+      4.968947937846942,
+      7.407671134532023
+    ],
+    "maxJerk": [
+      16.541455804665787,
+      9.27589631100679,
+      13.238762594978722,
+      18.12048684113738
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.9335826262310345,
+      8.227948822210273,
+      2.1884379457710885,
+      2.373539962150325
+    ],
+    "currentVelocity": [
+      -0.08833322854466186,
+      -2.502084828317873,
+      -2.157520656038751,
+      4.0340454989285295
+    ],
+    "currentAcceleration": [
+      -0.3949730855309559,
+      1.0250362160510438,
+      0.7453967064968605,
+      6.764797295895144
+    ],
+    "targetPosition": [
+      -4.257229567285423,
+      -5.683130915925281,
+      -3.699739253561159,
+      -0.667935025518398
+    ],
+    "targetVelocity": [
+      3.447823322230011,
+      -1.0767862538017385,
+      4.930224255486659,
+      -4.100346530371642
+    ],
+    "targetAcceleration": [
+      1.6357140588877188,
+      0.8880207311477175,
+      5.029373911334214,
+      -5.205766507259039
+    ],
+    "maxVelocity": [
+      5.545590115378186,
+      3.607953807151824,
+      7.723150796844064,
+      6.957265338206952
+    ],
+    "maxAcceleration": [
+      4.836643486523883,
+      3.0612674551625245,
+      5.739978039545604,
+      7.608730859993574
+    ],
+    "maxJerk": [
+      11.301793686030132,
+      8.639745119422024,
+      19.46730279013871,
+      17.54103865982524
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.549528077268965,
+      9.26348783168702,
+      -9.60604589267503,
+      9.408093417861746
+    ],
+    "currentVelocity": [
+      0.30226270815536704,
+      0.4335181029155737,
+      3.399722974596169,
+      -2.489643895298437
+    ],
+    "currentAcceleration": [
+      -1.4852325362018615,
+      0.33125080272003515,
+      3.7302118731283898,
+      -0.3178195174946268
+    ],
+    "targetPosition": [
+      7.662954249501777,
+      1.3756219732483999,
+      -1.0772624012794978,
+      9.890348934930639
+    ],
+    "targetVelocity": [
+      -1.3941965315202483,
+      -2.7128340142597027,
+      6.219988289259811,
+      -3.854328131170635
+    ],
+    "targetAcceleration": [
+      -0.6794062419942106,
+      -2.454331915515891,
+      5.9411876083866435,
+      -5.645913212803529
+    ],
+    "maxVelocity": [
+      6.948572238472744,
+      3.3292059344215863,
+      6.275471102621668,
+      6.2771615743880105
+    ],
+    "maxAcceleration": [
+      6.31200182815156,
+      3.8396177179282827,
+      6.3024654043348605,
+      5.839328517745357
+    ],
+    "maxJerk": [
+      12.813611814092749,
+      10.644419611792014,
+      18.012851014467806,
+      19.448615985883155
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.345979195124885,
+      8.34192973189338,
+      1.7816587216843232,
+      7.716816303995234
+    ],
+    "currentVelocity": [
+      4.138860801685862,
+      2.9934534498758163,
+      1.6264740607121433,
+      1.8984274628930642
+    ],
+    "currentAcceleration": [
+      -8.632630478256122,
+      -1.275359522629378,
+      -2.535465079170989,
+      -2.4829778683868566
+    ],
+    "targetPosition": [
+      4.185855946387694,
+      1.6995274827734193,
+      4.422288119460196,
+      5.016931873174022
+    ],
+    "targetVelocity": [
+      2.5276592829506015,
+      1.3547996256588943,
+      1.971775297526003,
+      1.2005684652643582
+    ],
+    "targetAcceleration": [
+      5.326001096222553,
+      -3.7207981938590677,
+      6.171794068943749,
+      2.1227323360831782
+    ],
+    "maxVelocity": [
+      5.6251185275305655,
+      4.779216398897328,
+      2.070112440103193,
+      2.466425276470951
+    ],
+    "maxAcceleration": [
+      9.098371491672335,
+      9.423585231705967,
+      9.000750263984912,
+      4.131605100905477
+    ],
+    "maxJerk": [
+      17.081066320683853,
+      11.528116093511535,
+      19.147214981128755,
+      13.362036948948761
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.228748191806046,
+      7.85562656591701,
+      -5.779937258752799,
+      8.384310878537239
+    ],
+    "currentVelocity": [
+      2.2171178673236778,
+      -3.650011828994096,
+      0.9044460048880714,
+      -1.56028896596785
+    ],
+    "currentAcceleration": [
+      -3.104540447010063,
+      -3.7915877820264,
+      7.299048976539493,
+      2.9295699921133576
+    ],
+    "targetPosition": [
+      7.239011937592348,
+      3.0806487355287775,
+      5.126918232940287,
+      -4.26514669471755
+    ],
+    "targetVelocity": [
+      1.913907795165339,
+      -5.072762004840355,
+      -2.703129383966432,
+      -4.154163367509211
+    ],
+    "targetAcceleration": [
+      4.330806128552343,
+      -1.4439695146507256,
+      1.5056710746068331,
+      -1.4488844861212895
+    ],
+    "maxVelocity": [
+      5.787183568465531,
+      5.712517217166152,
+      6.552047768923938,
+      4.239768725376244
+    ],
+    "maxAcceleration": [
+      7.425048159523747,
+      6.64259015469687,
+      7.913571561195458,
+      6.105085116105238
+    ],
+    "maxJerk": [
+      8.844012646730118,
+      13.819681848584896,
+      12.52728867925768,
+      6.938231774194412
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.23638907520419,
+      -0.6552783924485936,
+      -7.695584309242436,
+      3.0506760309366587
+    ],
+    "currentVelocity": [
+      0.33236303025418845,
+      -0.1309737680494334,
+      -1.9328806360550206,
+      1.3657860326632552
+    ],
+    "currentAcceleration": [
+      -1.480267519248002,
+      -4.589673225685813,
+      2.307495666840101,
+      -2.553375215588194
+    ],
+    "targetPosition": [
+      -3.02093472330907,
+      -6.457811128073998,
+      -3.4707353344393477,
+      -7.238735158949043
+    ],
+    "targetVelocity": [
+      5.070180603382503,
+      0.7039367059557913,
+      -3.9815223152584394,
+      -3.6117753886082027
+    ],
+    "targetAcceleration": [
+      -2.8870864851393767,
+      -0.3054393097083441,
+      -3.3318574664109537,
+      -3.032845410540844
+    ],
+    "maxVelocity": [
+      5.894217432541304,
+      2.9745601775371733,
+      4.436920969218756,
+      7.011037266403216
+    ],
+    "maxAcceleration": [
+      4.005039775013537,
+      5.553782067056143,
+      3.687137742987289,
+      3.51163253901899
+    ],
+    "maxJerk": [
+      10.483023492979084,
+      9.088823004258881,
+      6.4702440058300255,
+      6.9069249662077254
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.8138376323703547,
+      5.058850381301616,
+      4.985308626913515,
+      7.540724727483578
+    ],
+    "currentVelocity": [
+      -1.2613217205099654,
+      0.16073908277442595,
+      0.7678397970006223,
+      1.8463162417841792
+    ],
+    "currentAcceleration": [
+      2.298783539745595,
+      -3.3537272063190837,
+      -6.718471491124038,
+      1.229993793474332
+    ],
+    "targetPosition": [
+      -4.592916770739198,
+      4.136208265067765,
+      9.18029980432187,
+      9.957404069329428
+    ],
+    "targetVelocity": [
+      2.017657314863219,
+      -1.209725132044067,
+      -0.9134591021099716,
+      -2.3399109164301826
+    ],
+    "targetAcceleration": [
+      0.5208464566093154,
+      1.1926504189914997,
+      -6.886817170824783,
+      -0.264780809214189
+    ],
+    "maxVelocity": [
+      2.5402997605687947,
+      5.684773491295309,
+      7.271847242365617,
+      2.8145775123970953
+    ],
+    "maxAcceleration": [
+      5.654566405245288,
+      5.03142919632411,
+      8.432877150230256,
+      8.919657499111295
+    ],
+    "maxJerk": [
+      12.240293873789483,
+      12.040289666040717,
+      12.059203526241255,
+      16.689976670583516
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.2907158647562476,
+      -5.297970840859632,
+      -1.7086344748791387,
+      8.382042675073475
+    ],
+    "currentVelocity": [
+      -4.042952412690705,
+      -0.8472085182200702,
+      -2.0602935073276645,
+      -2.395076620815016
+    ],
+    "currentAcceleration": [
+      -1.0740253478821526,
+      -5.5435409893848036,
+      -4.172751639507067,
+      0.09832212884064173
+    ],
+    "targetPosition": [
+      7.431384765237272,
+      -8.066091873099587,
+      0.5871743285449345,
+      -5.025666461749809
+    ],
+    "targetVelocity": [
+      3.1923778314494715,
+      2.2061151852446574,
+      -0.06547046872460527,
+      -2.1632486365314123
+    ],
+    "targetAcceleration": [
+      2.819410811079778,
+      4.827670785733387,
+      -2.617625921567724,
+      3.8645790319477404
+    ],
+    "maxVelocity": [
+      4.193964005413749,
+      4.4514677756288545,
+      4.378428321313246,
+      2.7460106677787914
+    ],
+    "maxAcceleration": [
+      3.8815939709511253,
+      7.302980492255632,
+      5.787307602714021,
+      6.277706573784292
+    ],
+    "maxJerk": [
+      19.235238331231482,
+      5.215051975141457,
+      14.807882017584165,
+      13.054468548003962
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.867924998030448,
+      -0.4310582955015221,
+      2.881907297312992,
+      7.457423838941093
+    ],
+    "currentVelocity": [
+      2.4990991481136478,
+      3.284067079047986,
+      -1.7966540265111304,
+      3.187515072302366
+    ],
+    "currentAcceleration": [
+      2.14676264089033,
+      2.5141305307029693,
+      -5.889417923751657,
+      -1.858227110147066
+    ],
+    "targetPosition": [
+      6.047299165833191,
+      0.8935061168043106,
+      -4.332936479769913,
+      8.656239765773194
+    ],
+    "targetVelocity": [
+      -1.4645609829518635,
+      2.0584496622007546,
+      -1.0440946227171697,
+      -3.48245425796783
+    ],
+    "targetAcceleration": [
+      2.0800870744210833,
+      2.8319883027017587,
+      4.692613156004281,
+      4.4502653277048
+    ],
+    "maxVelocity": [
+      6.9288944730917015,
+      3.928632195978753,
+      6.4429864096178395,
+      4.044924238106037
+    ],
+    "maxAcceleration": [
+      4.356909919741629,
+      4.599143248375768,
+      9.279138745004028,
+      9.72222857738658
+    ],
+    "maxJerk": [
+      12.994887124501435,
+      13.188036860385823,
+      12.201965618834414,
+      17.694004710164492
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -8.267342394245565,
+      8.809698475453843,
+      -6.472679006334046,
+      5.512036802882932
+    ],
+    "currentVelocity": [
+      2.203817875600084,
+      1.3562872051588872,
+      1.325360200692339,
+      1.9951596564895215
+    ],
+    "currentAcceleration": [
+      4.903283232161037,
+      7.766445833882463,
+      -8.116895430939907,
+      8.421027054208006
+    ],
+    "targetPosition": [
+      -2.0969186251308747,
+      3.8923257572951275,
+      2.297219860364109,
+      -5.20411343108953
+    ],
+    "targetVelocity": [
+      2.957092113215742,
+      0.720918383162136,
+      -2.7253286933676564,
+      6.015941191870212
+    ],
+    "targetAcceleration": [
+      3.321989682490752,
+      -2.5303507112938135,
+      -9.086687258124694,
+      4.116291724246516
+    ],
+    "maxVelocity": [
+      5.9275751077603935,
+      4.078637291489613,
+      6.574180004208159,
+      7.837617621205943
+    ],
+    "maxAcceleration": [
+      9.046244701714583,
+      7.935252890948313,
+      9.297641354256378,
+      8.676759015912525
+    ],
+    "maxJerk": [
+      12.391612081741169,
+      18.04913013424523,
+      9.524415631766272,
+      18.76724652333462
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.387172755598542,
+      -4.266303681271042,
+      -0.9909627046485614,
+      -0.4496460899723296
+    ],
+    "currentVelocity": [
+      4.122883435623606,
+      -1.7741686724852705,
+      5.498383232150393,
+      -1.1457193200757927
+    ],
+    "currentAcceleration": [
+      -2.059735272164822,
+      6.9392540920159504,
+      0.04784440641467569,
+      -1.6183506894570088
+    ],
+    "targetPosition": [
+      -2.0151640230277597,
+      -2.8712246219207804,
+      7.585393645067967,
+      -9.615352336263335
+    ],
+    "targetVelocity": [
+      0.09637792823805746,
+      -3.250631912753528,
+      2.410300566763609,
+      -2.730889371055311
+    ],
+    "targetAcceleration": [
+      -3.8653107219039717,
+      -0.7815312973981516,
+      5.287856065557358,
+      -3.287847584579504
+    ],
+    "maxVelocity": [
+      4.637709200186546,
+      7.281005604268896,
+      6.501307385407132,
+      4.691043000945112
+    ],
+    "maxAcceleration": [
+      6.110667372734619,
+      6.960759935736013,
+      6.025802897306503,
+      4.6362775555137805
+    ],
+    "maxJerk": [
+      9.259265368152867,
+      13.177431325909113,
+      19.779449762228115,
+      11.95980828929418
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.162347763939032,
+      0.924565594033691,
+      -1.8031339332596747,
+      7.7523425716774454
+    ],
+    "currentVelocity": [
+      -0.8265446286722784,
+      -1.2433427539519029,
+      -3.7637258976379626,
+      -2.032619846006711
+    ],
+    "currentAcceleration": [
+      -3.3689932987269477,
+      0.7718852836611951,
+      0.7646749952908403,
+      -1.8759752027452326
+    ],
+    "targetPosition": [
+      -5.329612064957954,
+      -7.150722911221116,
+      6.715555731685235,
+      -6.745180757390403
+    ],
+    "targetVelocity": [
+      1.2671838528238792,
+      -2.357205233969357,
+      1.340430116302314,
+      0.45029616002582884
+    ],
+    "targetAcceleration": [
+      -7.193130249983087,
+      -0.0748105548731619,
+      -2.309698982509084,
+      -2.9539357202161707
+    ],
+    "maxVelocity": [
+      4.344533132465868,
+      6.0101430971430965,
+      5.779576168790957,
+      4.096627720649795
+    ],
+    "maxAcceleration": [
+      8.266638723365196,
+      9.64305057122813,
+      3.6909250000144826,
+      4.648949606733234
+    ],
+    "maxJerk": [
+      14.791923646672444,
+      12.270414822279704,
+      14.677800940234642,
+      7.961066216493059
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.726866837396631,
+      3.607554883535812,
+      8.962446218719503,
+      -8.344458617415853
+    ],
+    "currentVelocity": [
+      0.8599312678929678,
+      -0.9001376189831118,
+      -4.716063278226446,
+      6.493032156109782
+    ],
+    "currentAcceleration": [
+      -0.6596182453427901,
+      2.8924757991642833,
+      4.380141511191056,
+      1.3870264574746614
+    ],
+    "targetPosition": [
+      -0.9674365872472244,
+      1.526649403599107,
+      -2.0332412600476735,
+      0.386276608298882
+    ],
+    "targetVelocity": [
+      -2.5867946244264206,
+      0.21539320753986768,
+      -4.363852906445024,
+      -0.6794559952103398
+    ],
+    "targetAcceleration": [
+      2.6924276226247015,
+      -0.2396721577934784,
+      -1.6250509561714814,
+      -0.6836462803291359
+    ],
+    "maxVelocity": [
+      4.457582714749856,
+      6.42613558463516,
+      6.397115293374942,
+      7.482191732202542
+    ],
+    "maxAcceleration": [
+      3.366921632063562,
+      7.827711648636993,
+      6.821947550916324,
+      4.315966768187428
+    ],
+    "maxJerk": [
+      10.661192810519903,
+      11.543752725526822,
+      19.311908647070048,
+      16.478106931005442
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.127254144583546,
+      -4.518505492020875,
+      -8.208372713827588,
+      -5.463431679682673
+    ],
+    "currentVelocity": [
+      -0.7559999832146227,
+      -2.468130525285267,
+      2.431210730408491,
+      -4.176623205395582
+    ],
+    "currentAcceleration": [
+      6.483983942030596,
+      6.020082749692984,
+      7.431806011328144,
+      -7.893489217991621
+    ],
+    "targetPosition": [
+      -1.8000172538627073,
+      -1.6028481092924878,
+      3.4147183976892492,
+      3.0357247466301622
+    ],
+    "targetVelocity": [
+      1.020411724332166,
+      -1.3782861728462645,
+      -6.4589703483829,
+      -0.928534771384494
+    ],
+    "targetAcceleration": [
+      4.571075067793707,
+      2.364334429800131,
+      3.2176004221076333,
+      -5.082504412168003
+    ],
+    "maxVelocity": [
+      2.4776567281880064,
+      7.386841031275873,
+      7.620095221117216,
+      6.5969370965084355
+    ],
+    "maxAcceleration": [
+      7.468861361261267,
+      9.065740018525464,
+      8.505966617862406,
+      9.626002427076259
+    ],
+    "maxJerk": [
+      8.855684884377384,
+      15.688188754091225,
+      14.484658021663117,
+      19.850846004904525
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.0817019441009261,
+      -3.04576803164061,
+      8.994869270994357,
+      -8.367075116003814
+    ],
+    "currentVelocity": [
+      0.13118854184420403,
+      3.1335043387462127,
+      -3.330965810953876,
+      0.0972212144688065
+    ],
+    "currentAcceleration": [
+      0.9387948349636073,
+      -1.0412126858729822,
+      -0.06639447317124425,
+      3.989257399977955
+    ],
+    "targetPosition": [
+      -1.9242680676409307,
+      9.77909535270069,
+      -4.737087473060393,
+      -0.10485656827907164
+    ],
+    "targetVelocity": [
+      4.806705485126123,
+      -1.05010114488636,
+      -1.6988924423308456,
+      -1.1382226060955571
+    ],
+    "targetAcceleration": [
+      7.4190707106350935,
+      8.407759197816226,
+      -1.6974868274685169,
+      -4.108627667392987
+    ],
+    "maxVelocity": [
+      5.771961736128381,
+      3.8467952197565207,
+      6.112560907645548,
+      4.213388650199613
+    ],
+    "maxAcceleration": [
+      9.158352994087473,
+      8.46753436390707,
+      4.7826201872449285,
+      4.59561210811372
+    ],
+    "maxJerk": [
+      15.32335973543808,
+      17.876272885689197,
+      16.900977582175962,
+      15.259659873881454
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.4352827455483332,
+      -1.2129425314245008,
+      5.324213611462669,
+      -8.402682917486432
+    ],
+    "currentVelocity": [
+      3.01315394527113,
+      -0.7947532655650296,
+      -3.4516594071462556,
+      -4.262328250209032
+    ],
+    "currentAcceleration": [
+      -2.6013927169709783,
+      -2.009647274913474,
+      -4.038428110904098,
+      3.3248426598106278
+    ],
+    "targetPosition": [
+      6.259227961784703,
+      -0.13673160300015752,
+      -8.98270324050065,
+      4.829563758246312
+    ],
+    "targetVelocity": [
+      -0.8199661172042925,
+      1.064423620843277,
+      1.1853496636740743,
+      -1.1669773701276016
+    ],
+    "targetAcceleration": [
+      3.539711697548091,
+      2.261781364105441,
+      -8.074634477878137,
+      0.5903410924771189
+    ],
+    "maxVelocity": [
+      6.507194402000016,
+      4.97828403469763,
+      5.124552187953306,
+      6.346027071605756
+    ],
+    "maxAcceleration": [
+      4.562018407827116,
+      3.236824499685845,
+      8.352553109007161,
+      6.082803535878455
+    ],
+    "maxJerk": [
+      13.451692940035283,
+      5.804395436004637,
+      17.37477187944407,
+      12.066186760261594
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.219934596736514,
+      9.116417242780468,
+      -3.5150522701889964,
+      5.444268063374372
+    ],
+    "currentVelocity": [
+      -0.1877284850360521,
+      3.0094063908071735,
+      -2.2765022945576856,
+      -0.05221847573021776
+    ],
+    "currentAcceleration": [
+      -0.35652857039570485,
+      1.6217020420481223,
+      0.528444753867273,
+      -3.2155983223900524
+    ],
+    "targetPosition": [
+      3.048186355414124,
+      -9.751570965372522,
+      -1.209466012368722,
+      2.5773914452630144
+    ],
+    "targetVelocity": [
+      1.1356281234072707,
+      3.553432734005339,
+      -1.156844864067909,
+      0.9196748941798978
+    ],
+    "targetAcceleration": [
+      -4.037018763753875,
+      1.8204884216384043,
+      2.0302787859003235,
+      5.793951409204507
+    ],
+    "maxVelocity": [
+      5.572185211055636,
+      5.888221584503178,
+      2.3043061904050486,
+      2.1968943538786183
+    ],
+    "maxAcceleration": [
+      8.973561024900325,
+      4.718808976559243,
+      7.303945735074048,
+      9.26722470693483
+    ],
+    "maxJerk": [
+      8.042691308245793,
+      13.372732519705654,
+      10.99026060920684,
+      15.42300093680807
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.749748209273982,
+      3.2692143223895442,
+      -7.243561567142438,
+      -2.1660945863887964
+    ],
+    "currentVelocity": [
+      2.2604102757754925,
+      -2.8017639705351693,
+      0.9148356202852588,
+      6.02878799968402
+    ],
+    "currentAcceleration": [
+      -0.06264521278369273,
+      2.2855953931208943,
+      1.980197111835417,
+      0.6688902117275939
+    ],
+    "targetPosition": [
+      7.215360180492368,
+      3.516031314269693,
+      -2.8711695248497087,
+      -7.535660023044548
+    ],
+    "targetVelocity": [
+      0.4885035590359985,
+      2.93662873316598,
+      -2.3061363870148255,
+      5.831030764291235
+    ],
+    "targetAcceleration": [
+      -3.9700825573609873,
+      0.07939064668859164,
+      -4.412847925423306,
+      -0.4115976604605365
+    ],
+    "maxVelocity": [
+      4.13155491150116,
+      4.8375178017497005,
+      4.848641029234478,
+      6.1208284708517695
+    ],
+    "maxAcceleration": [
+      5.205695313763964,
+      3.0357808025997888,
+      7.119841661362822,
+      4.739388735371627
+    ],
+    "maxJerk": [
+      17.909936376906856,
+      6.589951014500713,
+      5.699261866590465,
+      14.391725362506822
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      3.043299998852813,
+      -6.576399190848332,
+      -9.948499905784516,
+      -8.026527677741344
+    ],
+    "currentVelocity": [
+      -2.861584280177613,
+      -0.23397721770050595,
+      1.334854966783654,
+      0.6216799932408623
+    ],
+    "currentAcceleration": [
+      1.1396690030642276,
+      4.204074560022656,
+      3.9480285648266857,
+      -2.357245459947751
+    ],
+    "targetPosition": [
+      -7.112897827351148,
+      4.896826266423078,
+      6.227490866481443,
+      -1.38962461215886
+    ],
+    "targetVelocity": [
+      2.008162323309466,
+      6.7497446127250305,
+      -7.1455642699546456,
+      -1.990975716087342
+    ],
+    "targetAcceleration": [
+      1.790908533241403,
+      3.010907946577321,
+      3.5030605182845047,
+      -1.45193828731382
+    ],
+    "maxVelocity": [
+      4.605664389506119,
+      7.6461984538603085,
+      7.61670287785606,
+      6.5265916150775976
+    ],
+    "maxAcceleration": [
+      9.96240309913362,
+      8.381692926703924,
+      9.156425774153925,
+      5.691558692853793
+    ],
+    "maxJerk": [
+      15.110286226663359,
+      14.160179056922454,
+      14.594639862226321,
+      9.04343421098344
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.4360859869133655,
+      -1.3339658362750288,
+      -0.2196362108266321,
+      3.8073306235625957
+    ],
+    "currentVelocity": [
+      4.444240055897545,
+      0.9242252967098841,
+      0.5778609651885755,
+      3.9102217537686634
+    ],
+    "currentAcceleration": [
+      1.3983845561741353,
+      -1.6359697220902651,
+      -4.730258421481403,
+      -5.784121974120143
+    ],
+    "targetPosition": [
+      -8.192986608078686,
+      7.20110927624323,
+      7.992590676584982,
+      8.58124481996498
+    ],
+    "targetVelocity": [
+      -0.0914573898670783,
+      -5.801760056924144,
+      -1.078331306679953,
+      -3.4465722257128406
+    ],
+    "targetAcceleration": [
+      -1.3109832174872702,
+      -1.8527836313730175,
+      5.040688125561394,
+      2.920689137316236
+    ],
+    "maxVelocity": [
+      6.44074793775577,
+      7.2598206107106185,
+      5.9261757165467905,
+      5.656077770172335
+    ],
+    "maxAcceleration": [
+      3.0705175823540554,
+      3.4226684112851453,
+      5.176783174608685,
+      7.407451208820941
+    ],
+    "maxJerk": [
+      9.072809839295305,
+      18.015977091026777,
+      18.364967265718665,
+      15.318572933637851
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -7.1711088511673005,
+      8.305765538132526,
+      -6.538446852897475,
+      3.3167507270422085
+    ],
+    "currentVelocity": [
+      0.039015430601129,
+      -4.591281729494709,
+      3.6579673216591946,
+      0.45735877855438156
+    ],
+    "currentAcceleration": [
+      7.520585216945451,
+      1.7049675873675358,
+      0.40114780861865684,
+      -2.77140965549441
+    ],
+    "targetPosition": [
+      9.463907841406737,
+      -4.905975038344312,
+      6.602206556292014,
+      -6.8684497155424085
+    ],
+    "targetVelocity": [
+      3.4976768717946527,
+      -1.052159248050204,
+      2.734953112141752,
+      -0.6978420102446616
+    ],
+    "targetAcceleration": [
+      1.5992543626294609,
+      3.9081770315822784,
+      -1.7069612350838383,
+      1.9834480206644827
+    ],
+    "maxVelocity": [
+      4.956658577305127,
+      7.576153556389089,
+      5.075366708264566,
+      3.102255249589941
+    ],
+    "maxAcceleration": [
+      9.01196826928812,
+      8.009655680886528,
+      3.5816953140354517,
+      8.928801375276851
+    ],
+    "maxJerk": [
+      17.677712514463643,
+      6.153475183435451,
+      13.45507032612162,
+      6.96312194881465
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -4.22992712551099,
+      1.171581177682608,
+      -6.2277265363967675,
+      -2.3459912141636767
+    ],
+    "currentVelocity": [
+      1.5677475092315207,
+      1.5742453816374171,
+      -4.266480826440351,
+      2.5943689565437786
+    ],
+    "currentAcceleration": [
+      1.6440295589728446,
+      -4.5829765471922626,
+      6.518530670817551,
+      -5.341317569829734
+    ],
+    "targetPosition": [
+      -5.501214511311834,
+      -3.6936526516835677,
+      0.42946461896329424,
+      1.837634889280789
+    ],
+    "targetVelocity": [
+      -1.4928035630072896,
+      -2.781134760960569,
+      0.28661120313619737,
+      3.262348796728853
+    ],
+    "targetAcceleration": [
+      0.6337478262767462,
+      3.2566797904602423,
+      2.726095860817349,
+      3.801494505895837
+    ],
+    "maxVelocity": [
+      5.1232079398780375,
+      6.376555840479875,
+      5.46152602543342,
+      6.480573980147856
+    ],
+    "maxAcceleration": [
+      7.824129712515228,
+      6.257502976139651,
+      8.343623148482948,
+      7.388523877151499
+    ],
+    "maxJerk": [
+      10.319365504881624,
+      14.244179406038533,
+      18.47910162153206,
+      12.56290852297401
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.190656118016815,
+      -3.174636637864414,
+      7.358358917403677,
+      8.938710467939913
+    ],
+    "currentVelocity": [
+      7.097179194309559,
+      -3.878055274884557,
+      2.1276350277655274,
+      0.3125742213943177
+    ],
+    "currentAcceleration": [
+      -5.610591795887961,
+      0.18000084705784447,
+      2.2826674367319804,
+      -9.313439224493028
+    ],
+    "targetPosition": [
+      -2.541434695634754,
+      -1.0915900771622074,
+      -9.14780881277837,
+      -3.5135823610052324
+    ],
+    "targetVelocity": [
+      2.842638563169542,
+      7.278616403318549,
+      -1.9959540886041385,
+      -4.609744379829655
+    ],
+    "targetAcceleration": [
+      6.402956125047737,
+      1.431149312036602,
+      3.4205477403435527,
+      -1.414302228950599
+    ],
+    "maxVelocity": [
+      7.630978180309189,
+      7.699590926522945,
+      4.1515669194403175,
+      4.803746445093571
+    ],
+    "maxAcceleration": [
+      6.816698575559364,
+      3.357294156565008,
+      6.719830227115656,
+      9.31745946039794
+    ],
+    "maxJerk": [
+      19.714054522839753,
+      14.926787336207816,
+      13.764761005044223,
+      15.086407058672089
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -5.958716324608357,
+      -7.698690439920228,
+      -0.49902858408971085,
+      -2.163211342869113
+    ],
+    "currentVelocity": [
+      1.7985121076186683,
+      1.001970544187448,
+      -1.894526119875405,
+      -4.5050414289136445
+    ],
+    "currentAcceleration": [
+      -0.5764858209168073,
+      -3.3038194877168365,
+      4.698115331607749,
+      4.3371117544722795
+    ],
+    "targetPosition": [
+      1.8349344038180995,
+      8.483603351389817,
+      1.5605347667210516,
+      -8.809250862534295
+    ],
+    "targetVelocity": [
+      -1.4174227461612556,
+      -3.4303235999073145,
+      -1.8920723963134565,
+      -3.2863931683405765
+    ],
+    "targetAcceleration": [
+      -4.5678540238126795,
+      2.104907761273755,
+      4.096442621834923,
+      -5.269928659240038
+    ],
+    "maxVelocity": [
+      5.961993696147229,
+      5.194291215461113,
+      4.598464939495545,
+      6.797648846593393
+    ],
+    "maxAcceleration": [
+      4.596829801861849,
+      3.8830798064212475,
+      5.332428107462363,
+      7.751103315915967
+    ],
+    "maxJerk": [
+      18.881178435910236,
+      15.291478513711033,
+      19.1899913490315,
+      9.517711845833166
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.249276377910304,
+      -4.424510385777993,
+      -3.0703437314059734,
+      1.1043380818406217
+    ],
+    "currentVelocity": [
+      0.09889600475202265,
+      -2.061248435350196,
+      0.45807229840161945,
+      -3.9623527156466958
+    ],
+    "currentAcceleration": [
+      -1.380952324305527,
+      2.0932688630946004,
+      0.06080245757722036,
+      -1.0054260499891177
+    ],
+    "targetPosition": [
+      -3.0789385293111344,
+      -0.04514762990256038,
+      0.5151875420309278,
+      -0.48958333264446985
+    ],
+    "targetVelocity": [
+      -2.232848801970847,
+      -0.5963952914910999,
+      -1.7223649211569767,
+      -3.627210772912451
+    ],
+    "targetAcceleration": [
+      0.7409626150948538,
+      0.04922545412581458,
+      4.106452077021142,
+      -3.942081899179038
+    ],
+    "maxVelocity": [
+      7.440823699526502,
+      2.471417538096583,
+      4.714731586012264,
+      5.74614761074742
+    ],
+    "maxAcceleration": [
+      3.898978331391242,
+      3.721451460018754,
+      6.316953799925383,
+      5.032191052508673
+    ],
+    "maxJerk": [
+      5.1542648235503705,
+      11.001648070291413,
+      7.267801102540326,
+      16.41102133441295
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.5972635948140237,
+      -5.946839875216721,
+      4.563107124791319,
+      4.362263029745515
+    ],
+    "currentVelocity": [
+      -1.1008685268316896,
+      1.4322337670217236,
+      -3.8167396583429727,
+      -7.155019900849825
+    ],
+    "currentAcceleration": [
+      -2.53210311844215,
+      3.519637656138009,
+      3.1802359410162495,
+      0.7895078997881679
+    ],
+    "targetPosition": [
+      -2.463031446521904,
+      1.1660400652358192,
+      -4.1562508508325235,
+      4.536801030342929
+    ],
+    "targetVelocity": [
+      3.3451896172092894,
+      0.18757676360992814,
+      2.0150547217694985,
+      4.4125441019886384
+    ],
+    "targetAcceleration": [
+      -3.5799437620181016,
+      -6.181613541304269,
+      0.8964785586965238,
+      -4.313872014819774
+    ],
+    "maxVelocity": [
+      5.152249137543404,
+      3.112714860050408,
+      6.645537586879135,
+      7.781127071751639
+    ],
+    "maxAcceleration": [
+      3.6673670759850667,
+      9.572506467363635,
+      8.316438760386022,
+      8.893321184226554
+    ],
+    "maxJerk": [
+      14.093561642426804,
+      8.741515876639605,
+      11.709460651406111,
+      8.398826175892044
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.503921781240132,
+      4.2839039784170865,
+      6.578549760870867,
+      -5.967368097771004
+    ],
+    "currentVelocity": [
+      0.4011799946428276,
+      0.6403110623982382,
+      0.030423681646175815,
+      -0.12040384464290543
+    ],
+    "currentAcceleration": [
+      -3.0343360390868175,
+      -0.7321231309860301,
+      -3.061281878358175,
+      1.508499107727042
+    ],
+    "targetPosition": [
+      -2.7315551190791076,
+      8.53038505927939,
+      -1.2942442657938695,
+      -9.932581801166132
+    ],
+    "targetVelocity": [
+      1.092166759905727,
+      3.0549099387564596,
+      -3.5863800374761725,
+      3.176763653750422
+    ],
+    "targetAcceleration": [
+      1.9967059316248945,
+      1.6939651730099503,
+      -2.2819114804474543,
+      -4.718698629536773
+    ],
+    "maxVelocity": [
+      2.841122521616396,
+      5.715433842610459,
+      5.425742142995448,
+      5.957712476329114
+    ],
+    "maxAcceleration": [
+      3.4166360775564795,
+      3.980611326404214,
+      4.642953367509136,
+      9.687247198336479
+    ],
+    "maxJerk": [
+      13.35281106205517,
+      6.4214796225807635,
+      19.017006113501573,
+      19.695664435552246
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.653992220904003,
+      -6.844742036074405,
+      5.852318966500556,
+      9.43841333860199
+    ],
+    "currentVelocity": [
+      5.9617276826120555,
+      -3.39840545731231,
+      1.985020788125408,
+      -2.2262269874088174
+    ],
+    "currentAcceleration": [
+      1.7385668387864506,
+      -3.1174435429478446,
+      1.8651449247443432,
+      3.398746998792748
+    ],
+    "targetPosition": [
+      5.417713947459962,
+      9.408396990619593,
+      4.102239629703956,
+      6.606594678008442
+    ],
+    "targetVelocity": [
+      3.4495761144127624,
+      1.4354570189295677,
+      1.8287520189870792,
+      -3.570353099100774
+    ],
+    "targetAcceleration": [
+      -0.09507725246300591,
+      -0.5219367236146648,
+      0.6899836713057725,
+      -1.6657227114169952
+    ],
+    "maxVelocity": [
+      6.16083785134987,
+      4.879784925182409,
+      3.7035376899940022,
+      7.227525909292251
+    ],
+    "maxAcceleration": [
+      3.853393517786544,
+      4.332860449614217,
+      4.881642323551764,
+      7.641355689181112
+    ],
+    "maxJerk": [
+      16.21638633927833,
+      5.463903272707434,
+      16.465571125818187,
+      10.122932449350824
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      1.5324084040539265,
+      7.379535024336981,
+      9.158132143885634,
+      6.506002501951315
+    ],
+    "currentVelocity": [
+      -2.0515431675364972,
+      3.205535685299477,
+      2.515343895864965,
+      0.07004997044888306
+    ],
+    "currentAcceleration": [
+      0.36759270035655334,
+      4.179482762262946,
+      3.226020474067734,
+      3.4060764567564803
+    ],
+    "targetPosition": [
+      1.4310237394394143,
+      -5.8826352782171405,
+      6.1862978950382335,
+      -1.2544198196816794
+    ],
+    "targetVelocity": [
+      -3.7357536132596256,
+      -1.5986336669427184,
+      2.1770018613654223,
+      4.600092579749044
+    ],
+    "targetAcceleration": [
+      1.6364324159035109,
+      -0.8064079116218368,
+      -0.5866471355166358,
+      5.027197905283241
+    ],
+    "maxVelocity": [
+      6.899314556692361,
+      5.646196641872768,
+      3.185772073930618,
+      6.609949198225276
+    ],
+    "maxAcceleration": [
+      5.01435184652612,
+      4.971496024325397,
+      3.3971445504525417,
+      5.553471273987462
+    ],
+    "maxJerk": [
+      13.861980702619054,
+      8.279116240174538,
+      8.660035933327595,
+      16.222764293834203
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.73167659522662,
+      7.025076997164756,
+      5.818819875781198,
+      2.973103962035804
+    ],
+    "currentVelocity": [
+      3.1724188295433375,
+      1.18892605499616,
+      0.39415290899093947,
+      6.178500278963764
+    ],
+    "currentAcceleration": [
+      -0.4180504844462094,
+      -2.0149341918303305,
+      -6.938843590346927,
+      1.8401448335014141
+    ],
+    "targetPosition": [
+      9.066405659521156,
+      -7.246384719512655,
+      0.7867194180097172,
+      -6.328205458104423
+    ],
+    "targetVelocity": [
+      3.227921428461155,
+      -3.913584390389503,
+      -1.7305386401514449,
+      -0.9875734972146324
+    ],
+    "targetAcceleration": [
+      -4.1394518026772085,
+      3.2671299979775332,
+      2.106171184937672,
+      0.1625800860774813
+    ],
+    "maxVelocity": [
+      6.146544639131228,
+      6.687442784934073,
+      3.0399759030119657,
+      7.017092937257944
+    ],
+    "maxAcceleration": [
+      4.5101134668567004,
+      3.6071773551977957,
+      7.701678519466926,
+      4.813144142943907
+    ],
+    "maxJerk": [
+      18.726492805425877,
+      9.052229396179992,
+      11.216985111051839,
+      17.10931077796188
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.4527269272751067,
+      8.209782138056859,
+      -5.485818760898898,
+      -0.6747364052733733
+    ],
+    "currentVelocity": [
+      0.6783876915403422,
+      -4.1154620576284575,
+      1.4468119256874132,
+      -4.31098403007508
+    ],
+    "currentAcceleration": [
+      4.268327779535751,
+      -6.0834230317757445,
+      0.3710627765163599,
+      -0.9954171161536274
+    ],
+    "targetPosition": [
+      -1.2125513817202442,
+      -3.5644225053369745,
+      7.5091668817077775,
+      -5.331795182312559
+    ],
+    "targetVelocity": [
+      2.3239035371680634,
+      3.2042428987383094,
+      -0.8580067327807206,
+      3.5725865787093047
+    ],
+    "targetAcceleration": [
+      -3.449809119840339,
+      -3.430539456575167,
+      -3.5962849742968332,
+      -2.9964300431692856
+    ],
+    "maxVelocity": [
+      3.5288920541862296,
+      6.745116264286514,
+      2.000673204385655,
+      7.609478741008574
+    ],
+    "maxAcceleration": [
+      7.345887560779804,
+      6.648899635059139,
+      5.903200875643165,
+      3.6532016933716895
+    ],
+    "maxJerk": [
+      17.731661551762286,
+      16.286068029878212,
+      13.751263623490626,
+      11.689366290299407
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.6138445111074535,
+      7.347766040569102,
+      -8.257936735757863,
+      3.0535899196739393
+    ],
+    "currentVelocity": [
+      3.6947519595601808,
+      3.790250866522924,
+      -0.23999988003028472,
+      0.6151458732916435
+    ],
+    "currentAcceleration": [
+      -2.157615133971189,
+      1.5927799927784445,
+      -1.9019361010352793,
+      -6.298339455969524
+    ],
+    "targetPosition": [
+      6.049421510212948,
+      -5.02254638354434,
+      -4.648616849771765,
+      -4.782700258913383
+    ],
+    "targetVelocity": [
+      7.210199336538857,
+      -1.001195384023597,
+      0.14610443889533542,
+      0.605453776087149
+    ],
+    "targetAcceleration": [
+      2.219706057049499,
+      -3.7110404172289657,
+      0.21482322142547217,
+      -3.196799688288973
+    ],
+    "maxVelocity": [
+      7.296796847858914,
+      5.578833657910416,
+      2.39643780298041,
+      4.213045126951401
+    ],
+    "maxAcceleration": [
+      3.1966465447543353,
+      6.250657360970708,
+      3.683728487555241,
+      7.657509193243687
+    ],
+    "maxJerk": [
+      7.870506761782006,
+      18.81285989534674,
+      11.631279282346313,
+      12.532853701458102
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.173393697309994,
+      3.7962525238871425,
+      2.1262464556155436,
+      2.8819513902985463
+    ],
+    "currentVelocity": [
+      1.6840944200742367,
+      -0.3646250884560889,
+      -0.8091235968028059,
+      0.1540025007552397
+    ],
+    "currentAcceleration": [
+      -4.80268529152186,
+      -0.32270631269578587,
+      2.2979442321359915,
+      1.2944492785359634
+    ],
+    "targetPosition": [
+      3.6430928601765302,
+      -8.282420431141047,
+      -6.37587842531225,
+      6.0916337152315805
+    ],
+    "targetVelocity": [
+      -1.8235286283825425,
+      2.8854781958932314,
+      6.192561743776843,
+      -1.3455654214945758
+    ],
+    "targetAcceleration": [
+      2.1116741889939075,
+      -2.026765433154808,
+      6.104476864492611,
+      0.9475610842658044
+    ],
+    "maxVelocity": [
+      4.192147966527049,
+      4.592452841402554,
+      7.222004120158505,
+      2.168735593456722
+    ],
+    "maxAcceleration": [
+      6.88116612182853,
+      3.412433715784003,
+      9.855426579185922,
+      5.990813111134877
+    ],
+    "maxJerk": [
+      5.63870528395849,
+      18.452846381252762,
+      10.543156617103794,
+      11.097572505923083
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.4843655240910998,
+      1.67980138535167,
+      3.6262693720287906,
+      -3.4888746741959364
+    ],
+    "currentVelocity": [
+      -2.138945918895536,
+      -0.23065675206101055,
+      -1.6367407967636582,
+      2.063631407481715
+    ],
+    "currentAcceleration": [
+      -4.068574814460833,
+      -3.4149190052474996,
+      -5.1677404017852755,
+      -1.080260252497716
+    ],
+    "targetPosition": [
+      -7.333432852085949,
+      -0.26143790474199236,
+      -6.756871154749984,
+      -0.7613361385790736
+    ],
+    "targetVelocity": [
+      -0.8163742768264863,
+      0.3169837160496871,
+      0.4288443689715793,
+      0.4329924327135952
+    ],
+    "targetAcceleration": [
+      -6.211921147918802,
+      -1.1808621356638733,
+      4.889173879305559,
+      -3.5986241724868044
+    ],
+    "maxVelocity": [
+      4.519759413998534,
+      3.1216097416003667,
+      6.05293681931834,
+      3.328437167396939
+    ],
+    "maxAcceleration": [
+      7.230824608094078,
+      4.326091521813314,
+      7.44265254964652,
+      5.029603275096711
+    ],
+    "maxJerk": [
+      7.128145560496161,
+      15.255434418696831,
+      10.055933244120832,
+      17.84146030883025
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.1947222002085045,
+      7.006717590322118,
+      -6.162256369879753,
+      -6.909952792592479
+    ],
+    "currentVelocity": [
+      2.175091138980034,
+      3.0305108483958545,
+      -2.803129618036234,
+      -4.918992101215309
+    ],
+    "currentAcceleration": [
+      -3.110188891124672,
+      -3.199210025817874,
+      -1.3185438284895905,
+      -1.4126159006174506
+    ],
+    "targetPosition": [
+      8.90649830344189,
+      2.053256108809565,
+      -6.820287097728588,
+      -2.364973653471023
+    ],
+    "targetVelocity": [
+      -1.907830600658539,
+      -5.976706524735667,
+      0.3149010152829459,
+      -1.164173265121354
+    ],
+    "targetAcceleration": [
+      -6.9248304849128886,
+      0.9498015254818295,
+      -1.8466759755621156,
+      2.8222063467141476
+    ],
+    "maxVelocity": [
+      5.8944228716617255,
+      7.900190816854327,
+      2.9452749007233527,
+      7.992865571573543
+    ],
+    "maxAcceleration": [
+      9.008320656647676,
+      9.275751752349823,
+      3.1302181552114883,
+      4.614660095705546
+    ],
+    "maxJerk": [
+      11.99223128317151,
+      6.340465333396647,
+      13.629699617212443,
+      10.127633252746579
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -2.6378201649024184,
+      6.26204651189293,
+      1.3772627066899261,
+      5.110630977489873
+    ],
+    "currentVelocity": [
+      -0.7479422784868812,
+      4.394947839528155,
+      5.399043371852546,
+      2.465337926960033
+    ],
+    "currentAcceleration": [
+      -1.8745161593294792,
+      0.3563969780537981,
+      -2.5115605558953247,
+      -3.6975712095192437
+    ],
+    "targetPosition": [
+      0.5426397157440288,
+      1.5644497100138999,
+      9.197353751691892,
+      -3.616372632442686
+    ],
+    "targetVelocity": [
+      1.0357210256289413,
+      4.507213234522795,
+      3.575633465137681,
+      6.149359167444632
+    ],
+    "targetAcceleration": [
+      -4.033566706017243,
+      -0.8948633636906962,
+      0.8765072296801426,
+      2.2515034347843983
+    ],
+    "maxVelocity": [
+      4.298571169468573,
+      5.739491358451855,
+      5.588285489645047,
+      6.475018698339535
+    ],
+    "maxAcceleration": [
+      7.571805224898197,
+      3.520589230250714,
+      4.865960065244393,
+      6.731116210891727
+    ],
+    "maxJerk": [
+      9.671686237678168,
+      7.694579686175283,
+      18.12837092653377,
+      7.853250492639618
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -6.026592632718435,
+      -8.058788768583225,
+      0.9488159102051341,
+      -9.350928281356145
+    ],
+    "currentVelocity": [
+      0.6002717142748235,
+      4.178927741529947,
+      -0.298315315234285,
+      0.5304596597440625
+    ],
+    "currentAcceleration": [
+      -3.460070543829607,
+      -0.2727159257097922,
+      -3.2954780536941577,
+      2.5639227913600147
+    ],
+    "targetPosition": [
+      -5.949156802975288,
+      6.214324072884445,
+      -8.21511064958623,
+      7.366032402950701
+    ],
+    "targetVelocity": [
+      -1.0668402252268594,
+      1.283623281086677,
+      1.5356946255191355,
+      -0.5126461238476487
+    ],
+    "targetAcceleration": [
+      -3.7430268505710473,
+      6.597837225354372,
+      1.3573311532551133,
+      0.6888460439470192
+    ],
+    "maxVelocity": [
+      2.4838074038519835,
+      5.194597415685198,
+      4.196068336026728,
+      7.4926471097085585
+    ],
+    "maxAcceleration": [
+      5.246109260219976,
+      7.556570794162852,
+      3.699671820829685,
+      4.491152359079183
+    ],
+    "maxJerk": [
+      6.7166732904103235,
+      15.368440535030867,
+      6.530669812107893,
+      8.831969612138039
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.9172038883606497,
+      7.789388809650426,
+      5.288488986683577,
+      -7.73055542023497
+    ],
+    "currentVelocity": [
+      0.03980771374657088,
+      -3.8274582451932733,
+      -5.968828640218207,
+      -2.3740816655457877
+    ],
+    "currentAcceleration": [
+      -7.2668088549753715,
+      -0.6996316515939727,
+      -2.8498171758594006,
+      -1.2959146344648556
+    ],
+    "targetPosition": [
+      5.446505600195522,
+      9.829732016866483,
+      -3.2732335626076132,
+      -1.004949461525511
+    ],
+    "targetVelocity": [
+      2.087916393773762,
+      -0.04893195705232678,
+      -1.3409079184941577,
+      -3.071837528300721
+    ],
+    "targetAcceleration": [
+      1.0558129985068536,
+      2.8783891927484415,
+      -2.0883427807523676,
+      -4.764146860464926
+    ],
+    "maxVelocity": [
+      4.442542385082236,
+      7.3345044658774095,
+      7.236544680618898,
+      7.139276004891104
+    ],
+    "maxAcceleration": [
+      8.067407359534059,
+      3.1489191437064132,
+      9.219557131767644,
+      5.493084411963238
+    ],
+    "maxJerk": [
+      11.778163868892154,
+      8.336405831525743,
+      6.42353287928156,
+      13.239185408604593
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.672636731928755,
+      -8.657537685183339,
+      -2.272897115573933,
+      2.7261762167616066
+    ],
+    "currentVelocity": [
+      1.7732192733305068,
+      -4.646154113319505,
+      1.0942459905790134,
+      -2.235354639441743
+    ],
+    "currentAcceleration": [
+      -6.861471705831908,
+      -6.220792614092992,
+      2.1299249821936055,
+      -0.920305327434062
+    ],
+    "targetPosition": [
+      5.210479946887347,
+      0.46602561847757684,
+      -7.0859511855959,
+      8.367764507988479
+    ],
+    "targetVelocity": [
+      -0.671982162823666,
+      3.2477156816744257,
+      -5.377314614153985,
+      3.352792275556375
+    ],
+    "targetAcceleration": [
+      -3.821190755160781,
+      -2.6542095499795577,
+      3.6592456178464534,
+      5.066817938860554
+    ],
+    "maxVelocity": [
+      2.921839883325859,
+      6.8108384078721675,
+      7.975819136091966,
+      5.83782319391203
+    ],
+    "maxAcceleration": [
+      7.132876784844589,
+      9.01688642321035,
+      5.990180949755144,
+      7.425510041389419
+    ],
+    "maxJerk": [
+      19.942508125437655,
+      15.077156907060425,
+      14.756364921854072,
+      17.54973703198512
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      7.574981304906977,
+      7.805098785942693,
+      -8.422772459743808,
+      -9.294207273912845
+    ],
+    "currentVelocity": [
+      1.094750488189291,
+      5.456618952656186,
+      2.1585636843316145,
+      3.983286991217158
+    ],
+    "currentAcceleration": [
+      2.8199967904853867,
+      -1.103109450457004,
+      -5.62070746693794,
+      -8.914684729053883
+    ],
+    "targetPosition": [
+      -5.25005880574734,
+      -4.56953242518561,
+      7.946378225838732,
+      -4.803681666683628
+    ],
+    "targetVelocity": [
+      -4.23980705820944,
+      0.009370688097527058,
+      0.9105372428554817,
+      -1.6714867922944618
+    ],
+    "targetAcceleration": [
+      0.8520638078330101,
+      -6.434532476464964,
+      1.4554377095450963,
+      7.726167071079523
+    ],
+    "maxVelocity": [
+      7.793898969841294,
+      5.705067915342651,
+      2.964381554954733,
+      5.154761733493343
+    ],
+    "maxAcceleration": [
+      3.8707501430361044,
+      7.552537384865239,
+      7.36614192565721,
+      9.429816459773232
+    ],
+    "maxJerk": [
+      15.416341304628451,
+      12.96704494229117,
+      10.906315772342909,
+      17.425924328085934
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.126240551574789,
+      -9.918107736217168,
+      2.7005613455675004,
+      3.2667054939443645
+    ],
+    "currentVelocity": [
+      -0.7783674990430902,
+      2.4529384864411075,
+      1.1090665405687896,
+      7.085305091045588
+    ],
+    "currentAcceleration": [
+      -1.9519610732499069,
+      0.5569201983663472,
+      -6.428516920720116,
+      -7.131141121755369
+    ],
+    "targetPosition": [
+      -9.339538725522356,
+      -3.5894170768670435,
+      6.3599221564276185,
+      -3.2185605399331347
+    ],
+    "targetVelocity": [
+      1.9892354060279356,
+      2.0149774027877143,
+      1.8270175191798974,
+      -5.779084867644367
+    ],
+    "targetAcceleration": [
+      0.6567604016624005,
+      0.011203213739026996,
+      3.539563277586721,
+      -8.33696038570135
+    ],
+    "maxVelocity": [
+      2.5275316208062577,
+      3.565733195526798,
+      2.7007533408266178,
+      7.629856369680039
+    ],
+    "maxAcceleration": [
+      4.076014293540675,
+      3.386717819939628,
+      6.530940584402487,
+      8.65602596697708
+    ],
+    "maxJerk": [
+      6.485319627481134,
+      19.60736977088454,
+      7.660754370998177,
+      6.338190988014053
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      6.44451524368311,
+      9.389915609008096,
+      7.483893668399006,
+      -9.48554638140747
+    ],
+    "currentVelocity": [
+      -2.264263961113027,
+      -2.6913839648520748,
+      3.6893215829814308,
+      4.935420711310972
+    ],
+    "currentAcceleration": [
+      2.4993604247200008,
+      -2.017727569382762,
+      0.43353931490604225,
+      -3.356804275135879
+    ],
+    "targetPosition": [
+      8.177800785240954,
+      -5.098190314253466,
+      -4.316138865244636,
+      -9.366832720074393
+    ],
+    "targetVelocity": [
+      -0.4959551199444052,
+      -0.17978253885972295,
+      -3.2887336519452046,
+      -1.8780596813222203
+    ],
+    "targetAcceleration": [
+      2.873725309600344,
+      -4.944866122210591,
+      -2.0614251247076307,
+      -1.3011967253699144
+    ],
+    "maxVelocity": [
+      2.26859542609506,
+      2.9710807184567263,
+      5.141727560585605,
+      6.427644588815378
+    ],
+    "maxAcceleration": [
+      6.243328426475802,
+      5.224063534818021,
+      5.165881304181086,
+      3.3966327653966712
+    ],
+    "maxJerk": [
+      17.926129790513734,
+      9.893914371247746,
+      13.444426661463423,
+      14.506724665978517
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      2.5935548775489536,
+      -3.969296087555958,
+      -3.8705295051912465,
+      -3.128656744207521
+    ],
+    "currentVelocity": [
+      -1.315655337819118,
+      1.0530662531995603,
+      1.6561964826472737,
+      -3.4743429815918567
+    ],
+    "currentAcceleration": [
+      1.0930383632201988,
+      0.30749207109909804,
+      -0.5144200256249762,
+      1.784294248027857
+    ],
+    "targetPosition": [
+      2.458148644801387,
+      0.7405797086451003,
+      0.7758671362421588,
+      -1.5316155076164826
+    ],
+    "targetVelocity": [
+      2.0985428701473854,
+      1.2055866628560103,
+      0.4176083948226057,
+      -2.7568578956324403
+    ],
+    "targetAcceleration": [
+      -4.9252843912291535,
+      0.6037230415936419,
+      5.948090394963881,
+      1.8377733299922
+    ],
+    "maxVelocity": [
+      3.0130540999327193,
+      4.069420969859748,
+      2.4585237839295653,
+      6.940094251970572
+    ],
+    "maxAcceleration": [
+      9.236013442025623,
+      4.590099928906473,
+      6.524979896518888,
+      5.254657711857989
+    ],
+    "maxJerk": [
+      15.559438301188562,
+      17.61517069751001,
+      8.450384070287262,
+      10.137085113867329
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      4.571143134335287,
+      1.7017014373721029,
+      -9.857859064683808,
+      4.037129094691272
+    ],
+    "currentVelocity": [
+      -3.7661787946473293,
+      2.801895620983343,
+      -1.162655554597385,
+      -0.10859338570378707
+    ],
+    "currentAcceleration": [
+      -5.723218192080389,
+      2.804044803979664,
+      -3.0871605415128878,
+      3.029751463951901
+    ],
+    "targetPosition": [
+      -1.9238581073495915,
+      6.483510358245745,
+      -1.245236072169277,
+      6.656086381037131
+    ],
+    "targetVelocity": [
+      -1.0850907590739292,
+      -0.24391961484845748,
+      -1.6631026498101749,
+      -2.564918640926284
+    ],
+    "targetAcceleration": [
+      -1.848657160665999,
+      -2.571070154459161,
+      -1.6012512078963432,
+      -2.05533171996881
+    ],
+    "maxVelocity": [
+      5.606483130042674,
+      4.326177877727245,
+      6.936529600279618,
+      4.461026599525701
+    ],
+    "maxAcceleration": [
+      6.798735114449274,
+      3.027269108555076,
+      6.691751226150874,
+      5.7155460162580125
+    ],
+    "maxJerk": [
+      18.546985816019536,
+      14.274025882892367,
+      10.337395726382196,
+      9.859042026925518
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.5538404165884447,
+      5.635149445498671,
+      7.897364257539984,
+      -4.331177366861782
+    ],
+    "currentVelocity": [
+      2.719975387749111,
+      1.178226111844845,
+      3.087390489515778,
+      1.8782006972229617
+    ],
+    "currentAcceleration": [
+      -2.7125222627136645,
+      6.6129718276818545,
+      1.149729036288135,
+      1.6994296112165808
+    ],
+    "targetPosition": [
+      -0.29046487634462714,
+      2.5070607772651083,
+      0.06732411161634211,
+      -5.973500864362382
+    ],
+    "targetVelocity": [
+      -4.073356367653726,
+      -2.1207635078690954,
+      -1.1363052124389084,
+      1.020133021159781
+    ],
+    "targetAcceleration": [
+      -2.6715862543516153,
+      2.3619976972135257,
+      -2.9005961164395977,
+      3.3892766792070583
+    ],
+    "maxVelocity": [
+      4.100752292333544,
+      4.056894918634005,
+      4.988956507944495,
+      3.1757787259866497
+    ],
+    "maxAcceleration": [
+      3.0971430585007496,
+      7.135412612231055,
+      3.695817480309893,
+      7.563835800202113
+    ],
+    "maxJerk": [
+      9.155863766915962,
+      15.193280394541485,
+      12.619604148937139,
+      13.28166111199379
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      8.325389471631041,
+      -0.4694877940704867,
+      4.889764295474992,
+      1.9430659216186648
+    ],
+    "currentVelocity": [
+      4.782221664284195,
+      -2.1091042054408384,
+      -2.883192614008116,
+      0.5171572411239098
+    ],
+    "currentAcceleration": [
+      1.4501416810839878,
+      -0.893534062451983,
+      4.140758542276107,
+      7.971289103655373
+    ],
+    "targetPosition": [
+      1.4107981283239148,
+      0.6758671140283425,
+      2.0102226859960464,
+      0.20534063717812856
+    ],
+    "targetVelocity": [
+      3.3869908566532905,
+      -0.8510283312925349,
+      -0.7644274956923462,
+      -1.7017335356096983
+    ],
+    "targetAcceleration": [
+      7.89831846135117,
+      4.226549495319971,
+      4.394157904990513,
+      7.50805410280465
+    ],
+    "maxVelocity": [
+      5.280532729186157,
+      2.7363150443665254,
+      3.005586593590568,
+      3.718462089854859
+    ],
+    "maxAcceleration": [
+      8.536393293756326,
+      5.707192018690635,
+      4.400410209070547,
+      8.593433660592208
+    ],
+    "maxJerk": [
+      8.07140662774362,
+      19.484710069302572,
+      13.541319329385221,
+      14.124101294112206
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      9.466484258822458,
+      -3.372121081207271,
+      -6.642775430513339,
+      -1.8054027436380142
+    ],
+    "currentVelocity": [
+      -4.546926512635971,
+      -0.08536008513637405,
+      1.8900029050951312,
+      3.7198767343271157
+    ],
+    "currentAcceleration": [
+      8.988941976515251,
+      -3.2337900605385776,
+      -0.5995722423188159,
+      3.4808678651955702
+    ],
+    "targetPosition": [
+      -3.6527449014926887,
+      -0.07495948683142295,
+      -2.8694353746725216,
+      -7.776927747656872
+    ],
+    "targetVelocity": [
+      -3.112810626635774,
+      1.80167667857219,
+      -0.26013515447636415,
+      -3.05569001667143
+    ],
+    "targetAcceleration": [
+      1.0220308681296846,
+      -5.167450980783378,
+      1.6192623052127946,
+      -2.6119056187182235
+    ],
+    "maxVelocity": [
+      5.543019700620506,
+      6.460935300552294,
+      2.298936319305847,
+      4.279589727442556
+    ],
+    "maxAcceleration": [
+      9.361643149652027,
+      6.771478244588277,
+      4.6629068298874605,
+      4.324355699228851
+    ],
+    "maxJerk": [
+      19.42374411013133,
+      11.390319759169774,
+      8.850574242892806,
+      12.862626212640894
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      5.384464683718457,
+      -7.595320920174928,
+      0.41888623712801376,
+      4.304803114098981
+    ],
+    "currentVelocity": [
+      -3.6347758634005545,
+      0.8578066204970458,
+      5.371191839952913,
+      6.180388194982897
+    ],
+    "currentAcceleration": [
+      -0.6514488746741369,
+      1.6599164979453231,
+      0.9162542501693931,
+      -0.9980431181878737
+    ],
+    "targetPosition": [
+      -9.134239729246747,
+      4.452742837779764,
+      -8.02574686737345,
+      -6.577955085376774
+    ],
+    "targetVelocity": [
+      2.068169708331375,
+      -0.46116860884305666,
+      3.679375183497654,
+      -5.720722437042111
+    ],
+    "targetAcceleration": [
+      0.7735180882190029,
+      0.35361632949489685,
+      -1.315614857930195,
+      -2.01610049856267
+    ],
+    "maxVelocity": [
+      7.081945767828319,
+      4.610230512431057,
+      5.476428012730444,
+      6.848950924926078
+    ],
+    "maxAcceleration": [
+      6.095507032974746,
+      6.205461436614957,
+      4.4556438854878015,
+      7.191199321834259
+    ],
+    "maxJerk": [
+      12.256914579125288,
+      18.106450552197103,
+      16.949334450206177,
+      15.58814005580558
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.112407060517894,
+      0.6907435817216587,
+      8.712608037450742,
+      -4.142160792261381
+    ],
+    "currentVelocity": [
+      -0.9171743998458013,
+      -1.1610139572553728,
+      -0.21931514565449906,
+      -2.071350938946806
+    ],
+    "currentAcceleration": [
+      -1.7934757510959303,
+      -0.44649918979870584,
+      -0.7011885865177883,
+      -4.189393484339826
+    ],
+    "targetPosition": [
+      5.666479536762331,
+      1.7497473002622659,
+      -8.598594286202921,
+      6.96775939693935
+    ],
+    "targetVelocity": [
+      2.6939073972811642,
+      -2.572017825648817,
+      4.133820929471537,
+      3.933664817398782
+    ],
+    "targetAcceleration": [
+      3.441915242887827,
+      -3.4321414594227972,
+      -5.165164114519671,
+      5.397262226657981
+    ],
+    "maxVelocity": [
+      2.8404471311415302,
+      2.6153574349674678,
+      5.8089923793875125,
+      5.64642770717311
+    ],
+    "maxAcceleration": [
+      8.586446230191525,
+      8.197770472387894,
+      6.616603823190527,
+      8.008649407961386
+    ],
+    "maxJerk": [
+      19.30867247593327,
+      16.050737353781194,
+      10.589802748260713,
+      19.99438544964702
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.499103358637205,
+      -1.8184158355550633,
+      -9.089772865661,
+      -7.095186724006865
+    ],
+    "currentVelocity": [
+      1.9296436385549294,
+      3.6103895493478673,
+      -3.560492758059991,
+      -3.462226552919107
+    ],
+    "currentAcceleration": [
+      1.297119157194592,
+      2.428736038951204,
+      1.2321072084461786,
+      3.6493598501301046
+    ],
+    "targetPosition": [
+      5.360956590047497,
+      9.096297750761071,
+      -9.538205578315246,
+      -0.6535889141310118
+    ],
+    "targetVelocity": [
+      -3.4709602701221067,
+      0.2025107648314295,
+      -3.6978335097230888,
+      -2.045603925823233
+    ],
+    "targetAcceleration": [
+      -3.310814757076871,
+      5.026226577718308,
+      -0.6981727495888217,
+      -2.9145968877234094
+    ],
+    "maxVelocity": [
+      3.50833771123097,
+      6.822313949426166,
+      6.968519711746256,
+      4.68828790514062
+    ],
+    "maxAcceleration": [
+      5.874209040149816,
+      8.107534559361762,
+      6.684231950061678,
+      6.199435175283132
+    ],
+    "maxJerk": [
+      12.947265780638942,
+      7.779594225461652,
+      11.56540933274507,
+      16.303251501408553
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -1.5394993806854025,
+      3.845589791629223,
+      0.21509934884757875,
+      2.3563113009550545
+    ],
+    "currentVelocity": [
+      -4.10572872339934,
+      2.0158188151927074,
+      0.0687840524132799,
+      1.6209213438004504
+    ],
+    "currentAcceleration": [
+      0.06675859281791219,
+      -1.5717064651408341,
+      -1.7128263744059309,
+      -2.4262362140152858
+    ],
+    "targetPosition": [
+      -0.6726105530222188,
+      6.5144969981965914,
+      5.32222829450407,
+      7.40015908056834
+    ],
+    "targetVelocity": [
+      -3.105237533825055,
+      -2.1853156898614796,
+      4.21411828329506,
+      4.26435558589473
+    ],
+    "targetAcceleration": [
+      6.287739128836252,
+      1.7153707550263189,
+      -1.6806047261276182,
+      -4.247261545311548
+    ],
+    "maxVelocity": [
+      7.6038114151427765,
+      2.523710581822071,
+      4.8423235441885675,
+      7.735983203093525
+    ],
+    "maxAcceleration": [
+      8.150556347506456,
+      5.348599397686316,
+      7.631241143850084,
+      9.789571651088181
+    ],
+    "maxJerk": [
+      11.51501915441425,
+      14.407268890976908,
+      6.855582515479114,
+      5.743085731532436
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.6612655167921915,
+      -2.172964835017506,
+      6.977225237719246,
+      -4.976089138697429
+    ],
+    "currentVelocity": [
+      2.1855169340007254,
+      -2.29834862616702,
+      4.477050092361779,
+      -2.9177064770373433
+    ],
+    "currentAcceleration": [
+      -3.28402909879184,
+      -2.4850855021343543,
+      0.848403607506298,
+      0.4517817969646103
+    ],
+    "targetPosition": [
+      1.0149195954701682,
+      -1.1693915503913708,
+      6.314501619607114,
+      9.114540560956101
+    ],
+    "targetVelocity": [
+      1.5106057429269582,
+      -2.9256794194650717,
+      0.4058719374052009,
+      -5.006512335529678
+    ],
+    "targetAcceleration": [
+      -1.7132924141844246,
+      -3.6431743990708116,
+      4.520249161682824,
+      3.167603767052409
+    ],
+    "maxVelocity": [
+      4.29577078595378,
+      3.0313619156604625,
+      6.499217846483983,
+      6.631333311946919
+    ],
+    "maxAcceleration": [
+      4.3592696925647285,
+      4.218178134188407,
+      4.667150377557921,
+      7.9594210896189495
+    ],
+    "maxJerk": [
+      5.203740501856599,
+      12.833792078391518,
+      12.307256970397875,
+      17.581496542712713
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      0.3621644083341806,
+      -3.8733900726681796,
+      -2.8512149440173733,
+      -8.209032431992739
+    ],
+    "currentVelocity": [
+      4.0238788170605835,
+      -1.139156698307473,
+      0.8882803328779025,
+      -5.1398917531005175
+    ],
+    "currentAcceleration": [
+      1.8684829445259865,
+      0.058812331439393795,
+      -3.224092358976002,
+      -1.1741869865110015
+    ],
+    "targetPosition": [
+      3.0589230663317046,
+      8.053235979260023,
+      -4.258017722494136,
+      5.7887256769333995
+    ],
+    "targetVelocity": [
+      -2.390048156898186,
+      -2.6700868754595017,
+      -2.182097808013678,
+      0.6249756579831525
+    ],
+    "targetAcceleration": [
+      -3.4082995305829735,
+      -0.23696129938599242,
+      -3.3133244366261363,
+      3.4740913787910594
+    ],
+    "maxVelocity": [
+      7.660457146178403,
+      4.956590182639353,
+      2.689025301888808,
+      6.910703077030304
+    ],
+    "maxAcceleration": [
+      7.605103738970817,
+      5.93801063175642,
+      3.4825990692101363,
+      5.395876153845909
+    ],
+    "maxJerk": [
+      11.457697916679706,
+      16.255176262251364,
+      16.757762601650082,
+      11.878893269935524
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  },
+  {
+    "degreesOfFreedom": 4,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [
+      -3.688097876509633,
+      4.968378066154989,
+      5.508623682904261,
+      1.0039012678670147
+    ],
+    "currentVelocity": [
+      -1.7015296152458483,
+      -2.659240804582298,
+      4.077161737182049,
+      -6.605822653890568
+    ],
+    "currentAcceleration": [
+      -0.42670376374772445,
+      5.053721249103615,
+      -8.256584333306298,
+      0.03987529292660774
+    ],
+    "targetPosition": [
+      -7.958483789617363,
+      2.6989336391227408,
+      -9.969523014770019,
+      6.158214152165616
+    ],
+    "targetVelocity": [
+      -0.5462221726163543,
+      -1.7797668462174456,
+      4.374716124923934,
+      6.328086500467745
+    ],
+    "targetAcceleration": [
+      0.6644656541982181,
+      5.004990387183234,
+      -4.766344816695533,
+      4.662664993137753
+    ],
+    "maxVelocity": [
+      5.110972297050291,
+      3.538099238804643,
+      6.091504694926403,
+      7.270117182103067
+    ],
+    "maxAcceleration": [
+      5.006371997847216,
+      9.951981024252934,
+      8.313607952599607,
+      5.125231416699938
+    ],
+    "maxJerk": [
+      9.137968132643184,
+      8.74309436708833,
+      12.541751307329124,
+      14.610811502019484
+    ],
+    "intermediatePositions": [],
+    "enabled": [
+      true,
+      true,
+      true,
+      true
+    ]
+  }
+]
diff --git a/tests/otg/steps/__init__.py b/tests/otg/steps/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/otg/steps/test_position_first_second.py b/tests/otg/steps/test_position_first_second.py
new file mode 100644
index 0000000..de59923
--- /dev/null
+++ b/tests/otg/steps/test_position_first_second.py
@@ -0,0 +1,306 @@
+"""Unit tests for the first/second-order position-interface step solvers
+(``math_tools.otg.steps.position_first_order``,
+``...position_second_order``).
+
+See ``.claude/specs/otg.md`` §Internal fidelity requirements 1, 2 and
+``.claude/action-plan/37-otg-position-first-second-steps.md``'s TDD steps:
+pin the velocity-limited-only analytic duration for the first-order
+(velocity interface) profile, and both the trapezoidal (cruise-phase) and
+triangular (no-cruise) analytic regimes for the second-order
+(velocity+acceleration interface) profile, in both directions (``Δp < 0``
+exercises ``Direction.DOWN``), plus a Step2 (prescribed-duration) case for
+each order. All boundary-array/position expectations are computed
+independently via ``integrate_jerk`` in each test (never by re-deriving
+them from ``Profile``'s own loop), matching
+``tests/otg/steps/test_velocity_steps.py``'s established convention.
+"""
+
+import math
+import unittest
+
+from math_tools.functional.roots import integrate_jerk
+from math_tools.otg.block import Block
+from math_tools.otg.enums import Direction
+from math_tools.otg.profile import Profile
+from math_tools.otg.steps.position_first_order import (
+    PositionFirstOrderStep1,
+    PositionFirstOrderStep2,
+)
+from math_tools.otg.steps.position_second_order import (
+    PositionSecondOrderStep1,
+    PositionSecondOrderStep2,
+)
+
+
+class TestPositionFirstOrderStep1Up(unittest.TestCase):
+    """Δp > 0: velocity-limited-only profile, ``t = Δp / vMax``,
+    ``Direction.UP``.
+
+    p0 = 0, pf = 5.0 => pd = 5.0; vMax = 2.0 => t3 = 2.5.
+    """
+
+    def setUp(self) -> None:
+        self.p0 = 0.0
+        self.pf = 5.0
+        self.v_max = 2.0
+        self.v_min = -2.0
+        self.step1 = PositionFirstOrderStep1(
+            p0=self.p0, pf=self.pf, v_max=self.v_max, v_min=self.v_min
+        )
+        self.input_profile = Profile()
+        self.input_profile.set_boundary(self.p0, 0.0, 0.0, self.pf, 0.0, 0.0)
+        self.block = Block()
+
+    def test_pins_duration_and_direction(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+
+        profile = self.block.p_min
+        expected_t3 = (self.pf - self.p0) / self.v_max
+        for i in (0, 1, 2, 4, 5, 6):
+            self.assertEqual(profile.t[i], 0.0, msg=f"t[{i}]")
+        self.assertAlmostEqual(profile.t[3], expected_t3, delta=1e-9)
+        self.assertAlmostEqual(profile.t_sum[-1], expected_t3, delta=1e-9)
+        self.assertAlmostEqual(self.block.t_min, expected_t3, delta=1e-9)
+        self.assertEqual(profile.direction, Direction.UP)
+
+    def test_pins_position_endpoint(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+        profile = self.block.p_min
+
+        p, _, _ = integrate_jerk(profile.t[3], self.p0, self.v_max, 0.0, 0.0)
+        self.assertAlmostEqual(profile.p[4], p, delta=1e-9)
+        self.assertAlmostEqual(profile.p[-1], self.pf, delta=1e-8)
+
+
+class TestPositionFirstOrderStep1Down(unittest.TestCase):
+    """Δp < 0: velocity-limited-only profile, ``t = |Δp| / vMin``,
+    ``Direction.DOWN``.
+
+    p0 = 0, pf = -5.0 => pd = -5.0; vMin = -2.0 => t3 = 2.5.
+    """
+
+    def setUp(self) -> None:
+        self.p0 = 0.0
+        self.pf = -5.0
+        self.v_max = 2.0
+        self.v_min = -2.0
+        self.step1 = PositionFirstOrderStep1(
+            p0=self.p0, pf=self.pf, v_max=self.v_max, v_min=self.v_min
+        )
+        self.input_profile = Profile()
+        self.input_profile.set_boundary(self.p0, 0.0, 0.0, self.pf, 0.0, 0.0)
+        self.block = Block()
+
+    def test_pins_duration_and_direction(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+
+        profile = self.block.p_min
+        expected_t3 = (self.pf - self.p0) / self.v_min
+        for i in (0, 1, 2, 4, 5, 6):
+            self.assertEqual(profile.t[i], 0.0, msg=f"t[{i}]")
+        self.assertAlmostEqual(profile.t[3], expected_t3, delta=1e-9)
+        self.assertAlmostEqual(profile.t_sum[-1], expected_t3, delta=1e-9)
+        self.assertAlmostEqual(self.block.t_min, expected_t3, delta=1e-9)
+        self.assertEqual(profile.direction, Direction.DOWN)
+
+    def test_pins_position_endpoint(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+        profile = self.block.p_min
+
+        p, _, _ = integrate_jerk(profile.t[3], self.p0, self.v_min, 0.0, 0.0)
+        self.assertAlmostEqual(profile.p[4], p, delta=1e-9)
+        self.assertAlmostEqual(profile.p[-1], self.pf, delta=1e-8)
+
+
+class TestPositionFirstOrderStep2(unittest.TestCase):
+    """Step2: a prescribed duration 2x the Step1 time-optimal duration
+    must still yield a valid profile that reaches the target position and
+    spans exactly the prescribed duration.
+    """
+
+    def test_prescribed_duration_reaches_target_position(self) -> None:
+        p0, pf, v_max, v_min = 0.0, 5.0, 2.0, -2.0
+        t_opt = (pf - p0) / v_max  # 2.5, per TestPositionFirstOrderStep1Up
+        tf = 2.0 * t_opt
+
+        profile = Profile()
+        profile.set_boundary(p0, 0.0, 0.0, pf, 0.0, 0.0)
+
+        step2 = PositionFirstOrderStep2(tf=tf, p0=p0, pf=pf, v_max=v_max, v_min=v_min)
+        success = step2.get_profile(profile)
+        self.assertTrue(success)
+
+        self.assertAlmostEqual(profile.t[3], tf, delta=1e-9)
+        self.assertAlmostEqual(profile.t_sum[-1], tf, delta=1e-8)
+        self.assertAlmostEqual(profile.p[-1], pf, delta=1e-8)
+
+
+class TestPositionSecondOrderStep1Trapezoidal(unittest.TestCase):
+    """|Δp| >= vMax^2/aMax: the time-optimal profile is trapezoidal
+    (ramp to vMax, cruise, ramp to 0), total time
+    ``t = Δp/vMax + vMax/aMax``, ``Direction.UP``.
+
+    vMax = aMax = 2.0 => vMax^2/aMax = 2.0; pd = 6.0 >= 2.0.
+    Hand-derived (point-to-point, v0 = vf = 0):
+        t0 = vMax/aMax = 1.0
+        t1 = pd/vMax - vMax/aMax = 3.0 - 1.0 = 2.0
+        t2 = vMax/aMax = 1.0
+    Total = pd/vMax + vMax/aMax = 3.0 + 1.0 = 4.0.
+    """
+
+    def setUp(self) -> None:
+        self.p0 = 0.0
+        self.pf = 6.0
+        self.v_max = 2.0
+        self.v_min = -2.0
+        self.a_max = 2.0
+        self.a_min = -2.0
+        self.step1 = PositionSecondOrderStep1(
+            p0=self.p0,
+            v0=0.0,
+            pf=self.pf,
+            vf=0.0,
+            v_max=self.v_max,
+            v_min=self.v_min,
+            a_max=self.a_max,
+            a_min=self.a_min,
+        )
+        self.input_profile = Profile()
+        self.input_profile.set_boundary(self.p0, 0.0, 0.0, self.pf, 0.0, 0.0)
+        self.block = Block()
+
+    def test_pins_trapezoidal_segment_times_and_direction(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+
+        pd = self.pf - self.p0
+        expected_t = [
+            self.v_max / self.a_max,
+            pd / self.v_max - self.v_max / self.a_max,
+            self.v_max / self.a_max,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+        ]
+        profile = self.block.p_min
+        for i, expected in enumerate(expected_t):
+            self.assertAlmostEqual(profile.t[i], expected, delta=1e-9, msg=f"t[{i}]")
+
+        expected_total = pd / self.v_max + self.v_max / self.a_max
+        self.assertAlmostEqual(profile.t_sum[-1], expected_total, delta=1e-9)
+        self.assertAlmostEqual(self.block.t_min, expected_total, delta=1e-9)
+        self.assertEqual(profile.direction, Direction.UP)
+
+    def test_pins_boundary_arrays(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+        profile = self.block.p_min
+
+        expected_a = [self.a_max, 0.0, self.a_min, 0.0, 0.0, 0.0, 0.0]
+        p, v = self.p0, 0.0
+        for i in range(7):
+            p, v, _ = integrate_jerk(profile.t[i], p, v, expected_a[i], 0.0)
+            self.assertAlmostEqual(profile.p[i + 1], p, delta=1e-9, msg=f"p[{i + 1}]")
+            self.assertAlmostEqual(profile.v[i + 1], v, delta=1e-9, msg=f"v[{i + 1}]")
+
+        self.assertAlmostEqual(profile.p[-1], self.pf, delta=1e-8)
+        self.assertAlmostEqual(profile.v[-1], 0.0, delta=1e-8)
+
+
+class TestPositionSecondOrderStep1Triangular(unittest.TestCase):
+    """|Δp| < vMax^2/aMax: the time-optimal profile is triangular (no
+    cruise phase), total time ``t = 2*sqrt(|Δp|/aMax)``, ``Direction.DOWN``.
+
+    vMax = aMax = 2.0 => vMax^2/aMax = 2.0; pd = -1.0, |pd| = 1.0 < 2.0.
+    Hand-derived (point-to-point, v0 = vf = 0, Solution 1 of ``timeNone``):
+        t0 = t2 = sqrt(|pd|/aMax) = sqrt(0.5)
+    Total = 2*sqrt(|pd|/aMax) = 2*sqrt(0.5).
+    """
+
+    def setUp(self) -> None:
+        self.p0 = 0.0
+        self.pf = -1.0
+        self.v_max = 2.0
+        self.v_min = -2.0
+        self.a_max = 2.0
+        self.a_min = -2.0
+        self.step1 = PositionSecondOrderStep1(
+            p0=self.p0,
+            v0=0.0,
+            pf=self.pf,
+            vf=0.0,
+            v_max=self.v_max,
+            v_min=self.v_min,
+            a_max=self.a_max,
+            a_min=self.a_min,
+        )
+        self.input_profile = Profile()
+        self.input_profile.set_boundary(self.p0, 0.0, 0.0, self.pf, 0.0, 0.0)
+        self.block = Block()
+
+    def test_pins_triangular_segment_times_and_direction(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+
+        pd = self.pf - self.p0
+        t0 = math.sqrt(abs(pd) / self.a_max)
+        expected_t = [t0, 0.0, t0, 0.0, 0.0, 0.0, 0.0]
+        profile = self.block.p_min
+        for i, expected in enumerate(expected_t):
+            self.assertAlmostEqual(profile.t[i], expected, delta=1e-9, msg=f"t[{i}]")
+
+        expected_total = 2.0 * math.sqrt(abs(pd) / self.a_max)
+        self.assertAlmostEqual(profile.t_sum[-1], expected_total, delta=1e-9)
+        self.assertAlmostEqual(self.block.t_min, expected_total, delta=1e-9)
+        self.assertEqual(profile.direction, Direction.DOWN)
+
+    def test_pins_boundary_arrays(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+        profile = self.block.p_min
+
+        expected_a = [self.a_min, 0.0, self.a_max, 0.0, 0.0, 0.0, 0.0]
+        p, v = self.p0, 0.0
+        for i in range(7):
+            p, v, _ = integrate_jerk(profile.t[i], p, v, expected_a[i], 0.0)
+            self.assertAlmostEqual(profile.p[i + 1], p, delta=1e-9, msg=f"p[{i + 1}]")
+            self.assertAlmostEqual(profile.v[i + 1], v, delta=1e-9, msg=f"v[{i + 1}]")
+
+        self.assertAlmostEqual(profile.p[-1], self.pf, delta=1e-8)
+        self.assertAlmostEqual(profile.v[-1], 0.0, delta=1e-8)
+
+
+class TestPositionSecondOrderStep2(unittest.TestCase):
+    """Step2: a prescribed duration 2x the Step1 time-optimal (trapezoidal)
+    duration must still yield a valid profile that reaches the target
+    position and spans exactly the prescribed duration.
+    """
+
+    def test_prescribed_duration_reaches_target_position(self) -> None:
+        p0, pf = 0.0, 6.0
+        v_max, v_min, a_max, a_min = 2.0, -2.0, 2.0, -2.0
+        pd = pf - p0
+        t_opt = pd / v_max + v_max / a_max  # 4.0, per the trapezoidal Step1 case
+        tf = 2.0 * t_opt
+
+        profile = Profile()
+        profile.set_boundary(p0, 0.0, 0.0, pf, 0.0, 0.0)
+
+        step2 = PositionSecondOrderStep2(
+            tf=tf, p0=p0, v0=0.0, pf=pf, vf=0.0, v_max=v_max, v_min=v_min, a_max=a_max, a_min=a_min
+        )
+        success = step2.get_profile(profile)
+        self.assertTrue(success)
+
+        self.assertAlmostEqual(profile.t_sum[-1], tf, delta=1e-8)
+        self.assertAlmostEqual(profile.p[-1], pf, delta=1e-8)
+        self.assertAlmostEqual(profile.v[-1], 0.0, delta=1e-7)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/steps/test_position_third_step1.py b/tests/otg/steps/test_position_third_step1.py
new file mode 100644
index 0000000..6246deb
--- /dev/null
+++ b/tests/otg/steps/test_position_third_step1.py
@@ -0,0 +1,270 @@
+"""Unit tests for the third-order (jerk-limited) position-interface Step 1
+solver (``math_tools.otg.steps.position_third_order_step1``).
+
+See ``.claude/specs/otg.md`` §Internal fidelity requirements 1, 2 and
+``.claude/action-plan/38-otg-position-third-step1.md``'s TDD steps: pin the
+segment times and total duration for three hand-derivable cases -- (a) a
+rest-to-rest long move that saturates velocity and acceleration limits
+(ACC0_ACC1_VEL), (b) a rest-to-rest short move that is jerk-dominated and
+never reaches either limit (NONE), and (c) a moving-start case (``a0 != 0``,
+still ``NONE``). All three are cross-checked by re-integrating the returned
+segment times independently via ``integrate_jerk`` and asserting the
+integration lands on the target ``p``/``v``/``a`` state, matching
+``tests/otg/steps/test_velocity_steps.py``'s established convention.
+"""
+
+import unittest
+
+from math_tools.functional.roots import integrate_jerk
+from math_tools.otg.block import Block
+from math_tools.otg.enums import ReachedLimits
+from math_tools.otg.profile import Profile
+from math_tools.otg.steps.position_third_order_step1 import PositionThirdOrderStep1
+
+
+class TestPositionThirdOrderStep1LongMove(unittest.TestCase):
+    """Rest-to-rest long move: velocity and acceleration limits are both
+    saturated (ACC0_ACC1_VEL), a symmetric jerk-limited S-curve.
+
+    v_max = 2, a_max = 1, j_max = 1 => t_j = a_max/j_max = 1 (jerk ramp
+    time), the acceleration phase reaches a_max with a genuine 1s dwell
+    (T_acc = v_max/a_max + a_max/j_max = 2 + 1 = 3, dwell = T_acc - 2*t_j =
+    1). Choosing pd = 10 gives the well-known time-optimal duration
+    identity ``t = pd/v_max + v_max/a_max + a_max/j_max = 5 + 2 + 1 = 8``
+    (see otg.md's numeric-oracle convention), decomposed by symmetry into
+    seven segments: jerk-up-accel, const-accel, jerk-down-accel (reaching
+    v_max), cruise, jerk-down-decel, const-decel, jerk-up-decel (reaching
+    rest) = [1, 1, 1, 2, 1, 1, 1].
+    """
+
+    def setUp(self) -> None:
+        self.p0 = 0.0
+        self.pf = 10.0
+        self.v_max = 2.0
+        self.v_min = -2.0
+        self.a_max = 1.0
+        self.a_min = -1.0
+        self.j_max = 1.0
+        self.step1 = PositionThirdOrderStep1(
+            p0=self.p0,
+            v0=0.0,
+            a0=0.0,
+            pf=self.pf,
+            vf=0.0,
+            af=0.0,
+            v_max=self.v_max,
+            v_min=self.v_min,
+            a_max=self.a_max,
+            a_min=self.a_min,
+            j_max=self.j_max,
+        )
+        self.input_profile = Profile()
+        self.input_profile.set_boundary(self.p0, 0.0, 0.0, self.pf, 0.0, 0.0)
+        self.block = Block()
+
+    def test_pins_segment_times_and_total_duration(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+
+        expected_t = [1.0, 1.0, 1.0, 2.0, 1.0, 1.0, 1.0]
+        profile = self.block.p_min
+        for i, expected in enumerate(expected_t):
+            self.assertAlmostEqual(profile.t[i], expected, delta=1e-9, msg=f"t[{i}]")
+
+        expected_total = self.pf / self.v_max + self.v_max / self.a_max + self.a_max / self.j_max
+        self.assertAlmostEqual(profile.t_sum[-1], expected_total, delta=1e-9)
+        self.assertAlmostEqual(self.block.t_min, expected_total, delta=1e-9)
+        self.assertEqual(profile.limits, ReachedLimits.ACC0_ACC1_VEL)
+
+    def test_reintegration_reaches_target_state(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+        profile = self.block.p_min
+
+        expected_j = [self.j_max, 0.0, -self.j_max, 0.0, -self.j_max, 0.0, self.j_max]
+        p, v, a = self.p0, 0.0, 0.0
+        for i in range(7):
+            p, v, a = integrate_jerk(profile.t[i], p, v, a, expected_j[i])
+        self.assertAlmostEqual(p, self.pf, delta=1e-8)
+        self.assertAlmostEqual(v, 0.0, delta=1e-8)
+        self.assertAlmostEqual(a, 0.0, delta=1e-9)
+
+
+class TestPositionThirdOrderStep1ShortMove(unittest.TestCase):
+    """Rest-to-rest short move: jerk-dominated, neither v_max nor a_max is
+    reached (NONE). The time-optimal three-segment jerk profile (+j, -j,
+    +j; the middle -j segment runs through the accel zero-crossing so it
+    covers twice the duration of the two ramps) has a closed form when
+    v0 = a0 = vf = af = 0::
+
+        t2 = (4 * pd / j_max) ** (1/3)
+        t0 = t6 = t2 / 2
+
+    derived from ``polynomNone`` collapsing to ``x*(x**3 - 4*pd/j) = 0``
+    when all boundary velocities/accelerations are zero.
+    """
+
+    def setUp(self) -> None:
+        self.p0 = 0.0
+        self.pf = 1.0
+        self.v_max = 100.0
+        self.v_min = -100.0
+        self.a_max = 100.0
+        self.a_min = -100.0
+        self.j_max = 1.0
+        self.step1 = PositionThirdOrderStep1(
+            p0=self.p0,
+            v0=0.0,
+            a0=0.0,
+            pf=self.pf,
+            vf=0.0,
+            af=0.0,
+            v_max=self.v_max,
+            v_min=self.v_min,
+            a_max=self.a_max,
+            a_min=self.a_min,
+            j_max=self.j_max,
+        )
+        self.input_profile = Profile()
+        self.input_profile.set_boundary(self.p0, 0.0, 0.0, self.pf, 0.0, 0.0)
+        self.block = Block()
+
+    def test_pins_segment_times_and_total_duration(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+
+        t2 = (4.0 * (self.pf - self.p0) / self.j_max) ** (1.0 / 3.0)
+        expected_t = [t2 / 2, 0.0, t2, 0.0, 0.0, 0.0, t2 / 2]
+        profile = self.block.p_min
+        for i, expected in enumerate(expected_t):
+            self.assertAlmostEqual(profile.t[i], expected, delta=1e-9, msg=f"t[{i}]")
+
+        expected_total = 2 * t2
+        self.assertAlmostEqual(profile.t_sum[-1], expected_total, delta=1e-9)
+        self.assertAlmostEqual(self.block.t_min, expected_total, delta=1e-9)
+        self.assertEqual(profile.limits, ReachedLimits.NONE)
+
+    def test_reintegration_reaches_target_state(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+        profile = self.block.p_min
+
+        expected_j = [self.j_max, 0.0, -self.j_max, 0.0, 0.0, 0.0, self.j_max]
+        p, v, a = self.p0, 0.0, 0.0
+        for i in range(7):
+            p, v, a = integrate_jerk(profile.t[i], p, v, a, expected_j[i])
+        self.assertAlmostEqual(p, self.pf, delta=1e-8)
+        self.assertAlmostEqual(v, 0.0, delta=1e-8)
+        self.assertAlmostEqual(a, 0.0, delta=1e-9)
+
+
+class TestPositionThirdOrderStep1MovingStart(unittest.TestCase):
+    """Moving-start case: a0 = af = 0.5 != 0 (v0 = vf = 0), neither v_max
+    nor a_max reached (NONE). With a0 = af = A the ``h2_none`` term
+    collapses (``(a0^2 - af^2)/(2j) + (vf - v0) = 0``), reducing the
+    quartic to the cubic ``t2^3 - (4*A^2/j^2)*t2 - 4*pd/j = 0``. Choosing
+    t2 = 2, j = 1, A = 0.5 pins pd = 1.5 (``8 - 1*2 - 4*pd = 0``).
+    Hand-derived segments (``h0 = h2_none/(2*j*t2) = 0`` since
+    ``h2_none = 0``): t0 = t2/2 - A/j = 0.5, t2 (index 2) = 2.0,
+    t6 = t2/2 + A/j = 1.5 -- verified by direct kinematic re-integration
+    below.
+    """
+
+    def setUp(self) -> None:
+        self.p0 = 0.0
+        self.a0 = 0.5
+        self.af = 0.5
+        self.pf = 1.5
+        self.v_max = 10.0
+        self.v_min = -10.0
+        self.a_max = 10.0
+        self.a_min = -10.0
+        self.j_max = 1.0
+        self.step1 = PositionThirdOrderStep1(
+            p0=self.p0,
+            v0=0.0,
+            a0=self.a0,
+            pf=self.pf,
+            vf=0.0,
+            af=self.af,
+            v_max=self.v_max,
+            v_min=self.v_min,
+            a_max=self.a_max,
+            a_min=self.a_min,
+            j_max=self.j_max,
+        )
+        self.input_profile = Profile()
+        self.input_profile.set_boundary(self.p0, 0.0, self.a0, self.pf, 0.0, self.af)
+        self.block = Block()
+
+    def test_pins_segment_times_and_total_duration(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+
+        expected_t = [0.5, 0.0, 2.0, 0.0, 0.0, 0.0, 1.5]
+        profile = self.block.p_min
+        for i, expected in enumerate(expected_t):
+            self.assertAlmostEqual(profile.t[i], expected, delta=1e-9, msg=f"t[{i}]")
+
+        expected_total = 4.0
+        self.assertAlmostEqual(profile.t_sum[-1], expected_total, delta=1e-9)
+        self.assertAlmostEqual(self.block.t_min, expected_total, delta=1e-9)
+        self.assertEqual(profile.limits, ReachedLimits.NONE)
+
+    def test_reintegration_reaches_target_state(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+        profile = self.block.p_min
+
+        expected_j = [self.j_max, 0.0, -self.j_max, 0.0, 0.0, 0.0, self.j_max]
+        p, v, a = self.p0, 0.0, self.a0
+        for i in range(7):
+            p, v, a = integrate_jerk(profile.t[i], p, v, a, expected_j[i])
+        self.assertAlmostEqual(p, self.pf, delta=1e-8)
+        self.assertAlmostEqual(v, 0.0, delta=1e-8)
+        self.assertAlmostEqual(a, self.af, delta=1e-9)
+
+
+class TestPositionThirdOrderStep1NegativeRadicandGuard(unittest.TestCase):
+    """Regression for post-audit finding E-3 (action-plan chunk 46).
+
+    ``_time_all_single_step`` (the zero-limits special case, entered from
+    ``get_profile`` when ``j_max == 0``) computes
+    ``q = sqrt(2 * a0 * pd + v0**2)`` with no guard. With ``a0 == af``
+    (required to enter this branch) and a radicand that goes negative --
+    e.g. ``a0 = af = -1``, ``v0 = 0``, ``pd = 1`` gives
+    ``2*(-1)*1 + 0 = -2`` -- Swift's ``Double.sqrt`` silently yields
+    ``nan`` and the candidate is rejected (``t[3] = nan`` fails the
+    ``>= 0.0`` guard immediately after). The un-guarded ``math.sqrt`` this
+    file used instead raised ``ValueError: math domain error``. Reproduced
+    directly at the ``PositionThirdOrderStep1.get_profile`` public entry --
+    not via fuzzing the full ``Otg.calculate`` stack, per the audit finding.
+    """
+
+    def test_negative_radicand_does_not_raise(self) -> None:
+        step1 = PositionThirdOrderStep1(
+            p0=0.0,
+            v0=0.0,
+            a0=-1.0,
+            pf=1.0,
+            vf=0.0,
+            af=-1.0,
+            v_max=10.0,
+            v_min=-10.0,
+            a_max=10.0,
+            a_min=-10.0,
+            j_max=0.0,
+        )
+        input_profile = Profile()
+        input_profile.set_boundary(0.0, 0.0, -1.0, 1.0, 0.0, -1.0)
+        block = Block()
+
+        # Must not raise ValueError ("math domain error"); the branch is
+        # rejected (returns False), matching Swift's nan-propagation
+        # behavior rather than crashing.
+        success = step1.get_profile(input_profile, block)
+        self.assertFalse(success)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/steps/test_position_third_step2.py b/tests/otg/steps/test_position_third_step2.py
new file mode 100644
index 0000000..1951141
--- /dev/null
+++ b/tests/otg/steps/test_position_third_step2.py
@@ -0,0 +1,276 @@
+"""Unit tests for the third-order (jerk-limited) position-interface Step 2
+solver (``math_tools.otg.steps.position_third_order_step2``).
+
+See ``.claude/specs/otg.md`` §Internal fidelity requirements 2, 4, 5 and
+``.claude/action-plan/39-otg-position-third-step2.md``'s TDD steps: reuse
+chunk 38 (``PositionThirdOrderStep1``)'s three analytic cases to compute
+each one's time-optimal duration, then ask Step2 to hit the SAME boundary
+conditions at 1.25x/1.5x/3x that duration (a prescribed, non-optimal
+duration -- Step2's whole purpose is multi-DOF time synchronization: "give
+me a profile that takes exactly this long"). Every scaled case must (a)
+report success, (b) land on the target ``pf``/``vf``/``af`` state, and (c)
+sum its segment times to exactly the prescribed ``tf``. A duration below
+the time-optimal minimum must be infeasible (no ``t >= 0`` decomposition
+exists) and so must fail.
+
+**Chunk 56 coverage note (post-audit finding E-10).** No new cases were
+added to this file for E-10 -- the multi-DOF corpus test
+(``test_calculator_target.py::TestMultiDofCorpusReachesStep2``) exercises
+these branches indirectly through 450 real synchronized multi-DOF cases,
+which is a more representative sample than hand-authored boundary
+conditions here. Statement coverage measured via ``sys.settrace`` over the
+full OTG test suite, before -> after chunk 56's additions (design
+constraint 1, "measure, don't assume"): ``check_root_udud`` 82% -> 98%,
+``_time_acc0_vel`` 39% -> 99% (effectively complete -- the one "uncovered"
+line is the ``def`` line itself, a measurement artifact), ``_time_acc1_vel``
+41% -> 99% (same artifact), ``_time_acc0_acc1`` 98% -> 98% (unchanged; one
+substantive branch, an alternate ``check_with_timing`` outcome at
+``position_third_order_step2.py:1267``, remains unreached -- recorded, not
+chased further). ``_time_none_smooth`` (0%, dead in Swift too) is out of
+this chunk's scope per its own "Out of scope" section.
+"""
+
+import unittest
+
+from math_tools.otg.block import Block
+from math_tools.otg.enums import ControlSigns
+from math_tools.otg.profile import Profile
+from math_tools.otg.steps.position_third_order_step1 import PositionThirdOrderStep1
+from math_tools.otg.steps.position_third_order_step2 import PositionThirdOrderStep2
+
+
+def _optimal_duration(
+    p0: float,
+    v0: float,
+    a0: float,
+    pf: float,
+    vf: float,
+    af: float,
+    v_max: float,
+    v_min: float,
+    a_max: float,
+    a_min: float,
+    j_max: float,
+) -> float:
+    """Time-optimal duration for a boundary condition, via chunk 38's Step 1
+    solver (the ground truth this chunk's Step 2 cases are scaled from)."""
+    step1 = PositionThirdOrderStep1(
+        p0=p0,
+        v0=v0,
+        a0=a0,
+        pf=pf,
+        vf=vf,
+        af=af,
+        v_max=v_max,
+        v_min=v_min,
+        a_max=a_max,
+        a_min=a_min,
+        j_max=j_max,
+    )
+    input_profile = Profile()
+    input_profile.set_boundary(p0, v0, a0, pf, vf, af)
+    block = Block()
+    success = step1.get_profile(input_profile, block)
+    assert success, "chunk 38 Step1 case must itself be feasible"
+    return block.t_min
+
+
+class _Step2ScaledDurationMixin:
+    """Shared assertions for a boundary condition run through Step2 at
+    several prescribed-duration scale factors of its Step1-optimal
+    duration."""
+
+    p0: float
+    v0: float
+    a0: float
+    pf: float
+    vf: float
+    af: float
+    v_max: float
+    v_min: float
+    a_max: float
+    a_min: float
+    j_max: float
+
+    def _t_opt(self) -> float:
+        return _optimal_duration(
+            self.p0,
+            self.v0,
+            self.a0,
+            self.pf,
+            self.vf,
+            self.af,
+            self.v_max,
+            self.v_min,
+            self.a_max,
+            self.a_min,
+            self.j_max,
+        )
+
+    def _run(self, tf: float) -> Profile:
+        step2 = PositionThirdOrderStep2(
+            tf,
+            self.p0,
+            self.v0,
+            self.a0,
+            self.pf,
+            self.vf,
+            self.af,
+            self.v_max,
+            self.v_min,
+            self.a_max,
+            self.a_min,
+            self.j_max,
+        )
+        profile = Profile()
+        profile.set_boundary(self.p0, self.v0, self.a0, self.pf, self.vf, self.af)
+        success = step2.get_profile(profile)
+        assert isinstance(self, unittest.TestCase)
+        self.assertTrue(success, f"expected a feasible profile at tf={tf}")
+        return profile
+
+    def test_scaled_durations_reach_target_at_exact_duration(self) -> None:
+        assert isinstance(self, unittest.TestCase)
+        t_opt = self._t_opt()
+        for scale in (1.25, 1.5, 3.0):
+            tf = scale * t_opt
+            with self.subTest(scale=scale):
+                profile = self._run(tf)
+                self.assertAlmostEqual(profile.p[-1], self.pf, delta=1e-8, msg="pf")
+                self.assertAlmostEqual(profile.v[-1], self.vf, delta=1e-8, msg="vf")
+                self.assertAlmostEqual(profile.a[-1], self.af, delta=1e-8, msg="af")
+                self.assertAlmostEqual(profile.t_sum[-1], tf, delta=1e-9, msg="t_sum")
+
+
+class TestPositionThirdOrderStep2LongMove(_Step2ScaledDurationMixin, unittest.TestCase):
+    """Rest-to-rest long move (chunk 38's ACC0_ACC1_VEL case): t_opt = 8."""
+
+    def setUp(self) -> None:
+        self.p0 = 0.0
+        self.v0 = 0.0
+        self.a0 = 0.0
+        self.pf = 10.0
+        self.vf = 0.0
+        self.af = 0.0
+        self.v_max = 2.0
+        self.v_min = -2.0
+        self.a_max = 1.0
+        self.a_min = -1.0
+        self.j_max = 1.0
+
+    def test_below_optimal_duration_is_infeasible(self) -> None:
+        t_opt = self._t_opt()
+        step2 = PositionThirdOrderStep2(
+            0.9 * t_opt,
+            self.p0,
+            self.v0,
+            self.a0,
+            self.pf,
+            self.vf,
+            self.af,
+            self.v_max,
+            self.v_min,
+            self.a_max,
+            self.a_min,
+            self.j_max,
+        )
+        profile = Profile()
+        profile.set_boundary(self.p0, self.v0, self.a0, self.pf, self.vf, self.af)
+        self.assertFalse(step2.get_profile(profile))
+
+
+class TestPositionThirdOrderStep2ShortMove(_Step2ScaledDurationMixin, unittest.TestCase):
+    """Rest-to-rest short, jerk-dominated move (chunk 38's NONE case)."""
+
+    def setUp(self) -> None:
+        self.p0 = 0.0
+        self.v0 = 0.0
+        self.a0 = 0.0
+        self.pf = 1.0
+        self.vf = 0.0
+        self.af = 0.0
+        self.v_max = 100.0
+        self.v_min = -100.0
+        self.a_max = 100.0
+        self.a_min = -100.0
+        self.j_max = 1.0
+
+
+class TestPositionThirdOrderStep2MovingStart(_Step2ScaledDurationMixin, unittest.TestCase):
+    """Moving-start case (chunk 38's a0 = af != 0 NONE case): t_opt = 4."""
+
+    def setUp(self) -> None:
+        self.p0 = 0.0
+        self.v0 = 0.0
+        self.a0 = 0.5
+        self.pf = 1.5
+        self.vf = 0.0
+        self.af = 0.5
+        self.v_max = 10.0
+        self.v_min = -10.0
+        self.a_max = 10.0
+        self.a_min = -10.0
+        self.j_max = 1.0
+
+
+class TestPositionThirdOrderStep2UdudT0246Discriminant(unittest.TestCase):
+    """Regression pin for chunk 44 (action-plan
+    ``44-otg-step2-udud-discriminant.md``, post-audit finding E-1).
+
+    ``_time_none``'s "UDUD T 0246" branch had ``j_max * self.tf_p3 *
+    self.tf`` (``j*tf**4``) at three sites where the Swift source
+    (``PositionThirdOrderStep2.swift:1279,1286,1289``) computes ``jMax *
+    tfP2 * tf`` (``j*tf**3``). Both the buggy and the Swift-faithful form
+    produce a profile that satisfies ``Profile.check_with_timing`` for this
+    boundary condition -- they just pick *different* profiles -- so no
+    existing oracle (including the 31-case numeric truth table, which is
+    1-DOF and never reaches Step2) can distinguish them.
+
+    This boundary condition was found by exhaustive random search
+    (``a0 != 0`` so the two earlier guard blocks in ``_time_none`` are
+    skipped and "UDUD T 0246" is the first branch tried) for an input where
+    the buggy and Swift-faithful forms of the discriminant select different
+    control-sign profiles. The expected segment times below were derived by
+    evaluating the Swift-faithful (``j*tf**3``) form of the three sites
+    in-memory (a patched copy of the module, `tf_p3` -> `tf_p2` at the
+    three UDUD-T0246 discriminant sites) against this same boundary
+    condition -- i.e. these are the Swift-faithful oracle values, not the
+    values the pre-fix Python produced.
+    """
+
+    def test_udud_t0246_branch_matches_swift_faithful_j_tf3_discriminant(self) -> None:
+        p0, v0, a0 = 0.0, -0.5237, 2.7015
+        pf, vf, af = -1.7271, -1.9901, 1.6448
+        v_max, v_min, a_max, a_min, j_max = 10.0, -10.0, 10.0, -10.0, 1.0
+        tf = 11.2581
+
+        step2 = PositionThirdOrderStep2(
+            tf, p0, v0, a0, pf, vf, af, v_max, v_min, a_max, a_min, j_max
+        )
+        profile = Profile()
+        profile.set_boundary(p0, v0, a0, pf, vf, af)
+        self.assertTrue(step2.get_profile(profile), f"expected a feasible profile at tf={tf}")
+
+        # Swift-faithful (j*tf**3) UDUD T0246 branch: control signs UDUD,
+        # t[1] = t[3] = t[5] = 0.
+        self.assertEqual(profile.control_signs, ControlSigns.UDUD)
+        expected_t = [
+            0.1810029002957043,
+            0.0,
+            5.82749192002557,
+            0.0,
+            4.919697099704295,
+            0.0,
+            0.3299080799744306,
+        ]
+        for i, (actual, expected) in enumerate(zip(profile.t, expected_t, strict=True)):
+            self.assertAlmostEqual(actual, expected, delta=1e-9, msg=f"t[{i}]")
+
+        self.assertAlmostEqual(profile.t_sum[-1], tf, delta=1e-9, msg="t_sum")
+        self.assertAlmostEqual(profile.p[-1], pf, delta=1e-8, msg="pf")
+        self.assertAlmostEqual(profile.v[-1], vf, delta=1e-8, msg="vf")
+        self.assertAlmostEqual(profile.a[-1], af, delta=1e-8, msg="af")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/steps/test_velocity_steps.py b/tests/otg/steps/test_velocity_steps.py
new file mode 100644
index 0000000..98680ca
--- /dev/null
+++ b/tests/otg/steps/test_velocity_steps.py
@@ -0,0 +1,245 @@
+"""Unit tests for the velocity-interface step solvers
+(``math_tools.otg.steps.velocity_second_order``,
+``...velocity_third_order``).
+
+See ``.claude/specs/otg.md`` §Internal fidelity requirements 1, 2 and
+``.claude/action-plan/36-otg-velocity-steps.md``'s TDD steps: pin both the
+trapezoidal-acceleration and triangular analytic regimes for the
+third-order (jerk-limited) interface, the ``t = Δv / a`` regime for the
+second-order (no jerk limit) interface, and a Step2 (prescribed-duration)
+case for each order. All boundary-array expectations are computed
+independently via ``integrate_jerk`` in each test (never by re-deriving
+them from ``Profile``'s own loop), matching ``tests/otg/test_profile.py``'s
+convention.
+"""
+
+import math
+import unittest
+
+from math_tools.functional.roots import integrate_jerk
+from math_tools.otg.block import Block
+from math_tools.otg.profile import Profile
+from math_tools.otg.steps.velocity_second_order import (
+    VelocitySecondOrderStep1,
+    VelocitySecondOrderStep2,
+)
+from math_tools.otg.steps.velocity_third_order import (
+    VelocityThirdOrderStep1,
+    VelocityThirdOrderStep2,
+)
+
+
+class TestVelocityThirdOrderStep1Trapezoidal(unittest.TestCase):
+    """Δv >= a²/j: the time-optimal profile is trapezoidal-acceleration
+    (ramp to +a, hold, ramp to 0), total time ``t = Δv/a + a/j``.
+
+    a = 2.0, j = 1.0 => a²/j = 4.0; Δv = 6.0 >= 4.0.
+    Hand-derived segment times (ACC0 reached limits, UDDU):
+        t0 = a/j = 2.0
+        t1 = Δv/a - a/j = 3.0 - 2.0 = 1.0
+        t2 = a/j = 2.0
+    Total = Δv/a + a/j = 3.0 + 2.0 = 5.0.
+    """
+
+    def setUp(self) -> None:
+        self.a = 2.0
+        self.j = 1.0
+        self.dv = 6.0
+        self.step1 = VelocityThirdOrderStep1(
+            v0=0.0, a0=0.0, vf=self.dv, af=0.0, a_max=self.a, a_min=-self.a, j_max=self.j
+        )
+        self.input_profile = Profile()
+        self.input_profile.set_boundary_for_velocity(
+            p0_new=0.0, v0_new=0.0, a0_new=0.0, vf_new=self.dv, af_new=0.0
+        )
+        self.block = Block()
+
+    def test_pins_trapezoidal_segment_times_and_total_duration(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+
+        expected_t = [
+            self.a / self.j,
+            self.dv / self.a - self.a / self.j,
+            self.a / self.j,
+            0.0,
+            0.0,
+            0.0,
+            0.0,
+        ]
+        profile = self.block.p_min
+        for i, expected in enumerate(expected_t):
+            self.assertAlmostEqual(profile.t[i], expected, delta=1e-9, msg=f"t[{i}]")
+
+        expected_total = self.dv / self.a + self.a / self.j
+        self.assertAlmostEqual(profile.t_sum[-1], expected_total, delta=1e-9)
+        self.assertAlmostEqual(self.block.t_min, expected_total, delta=1e-9)
+
+    def test_pins_boundary_arrays(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+        profile = self.block.p_min
+
+        expected_j = [self.j, 0.0, -self.j, 0.0, 0.0, 0.0, 0.0]
+        p, v, a = 0.0, 0.0, 0.0
+        for i in range(7):
+            p, v, a = integrate_jerk(profile.t[i], p, v, a, expected_j[i])
+            self.assertAlmostEqual(profile.p[i + 1], p, delta=1e-9, msg=f"p[{i + 1}]")
+            self.assertAlmostEqual(profile.v[i + 1], v, delta=1e-9, msg=f"v[{i + 1}]")
+            self.assertAlmostEqual(profile.a[i + 1], a, delta=1e-9, msg=f"a[{i + 1}]")
+
+        self.assertAlmostEqual(profile.v[-1], self.dv, delta=1e-8)
+        self.assertAlmostEqual(profile.a[-1], 0.0, delta=1e-10)
+
+
+class TestVelocityThirdOrderStep1Triangular(unittest.TestCase):
+    """Δv < a²/j: the time-optimal profile is triangular (no constant-accel
+    plateau), total time ``t = 2 * sqrt(Δv/j)``.
+
+    a = 2.0, j = 1.0 => a²/j = 4.0; Δv = 3.0 < 4.0.
+    Hand-derived (Solution 2 of ``timeNone``): t0 = t2 = sqrt(Δv/j),
+    t1 = 0. Peak accel reached = sqrt(j*Δv) = sqrt(3) < a = 2.0, so the
+    acceleration limit is never actually touched (NONE reached-limits).
+    """
+
+    def setUp(self) -> None:
+        self.a = 2.0
+        self.j = 1.0
+        self.dv = 3.0
+        self.step1 = VelocityThirdOrderStep1(
+            v0=0.0, a0=0.0, vf=self.dv, af=0.0, a_max=self.a, a_min=-self.a, j_max=self.j
+        )
+        self.input_profile = Profile()
+        self.input_profile.set_boundary_for_velocity(
+            p0_new=0.0, v0_new=0.0, a0_new=0.0, vf_new=self.dv, af_new=0.0
+        )
+        self.block = Block()
+
+    def test_pins_triangular_segment_times_and_total_duration(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+
+        t0 = math.sqrt(self.dv / self.j)
+        expected_t = [t0, 0.0, t0, 0.0, 0.0, 0.0, 0.0]
+        profile = self.block.p_min
+        for i, expected in enumerate(expected_t):
+            self.assertAlmostEqual(profile.t[i], expected, delta=1e-9, msg=f"t[{i}]")
+
+        expected_total = 2.0 * math.sqrt(self.dv / self.j)
+        self.assertAlmostEqual(profile.t_sum[-1], expected_total, delta=1e-9)
+        self.assertAlmostEqual(self.block.t_min, expected_total, delta=1e-9)
+
+    def test_pins_boundary_arrays(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+        profile = self.block.p_min
+
+        expected_j = [self.j, 0.0, -self.j, 0.0, 0.0, 0.0, 0.0]
+        p, v, a = 0.0, 0.0, 0.0
+        for i in range(7):
+            p, v, a = integrate_jerk(profile.t[i], p, v, a, expected_j[i])
+            self.assertAlmostEqual(profile.p[i + 1], p, delta=1e-9, msg=f"p[{i + 1}]")
+            self.assertAlmostEqual(profile.v[i + 1], v, delta=1e-9, msg=f"v[{i + 1}]")
+            self.assertAlmostEqual(profile.a[i + 1], a, delta=1e-9, msg=f"a[{i + 1}]")
+
+        self.assertAlmostEqual(profile.v[-1], self.dv, delta=1e-8)
+        self.assertAlmostEqual(profile.a[-1], 0.0, delta=1e-10)
+
+
+class TestVelocitySecondOrderStep1(unittest.TestCase):
+    """No jerk limit: the time-optimal profile is a single constant-accel
+    ramp, total time ``t = Δv / a``.
+
+    Δv = 4.0, aMax = 2.0 => t1 = Δv / aMax = 2.0.
+    """
+
+    def setUp(self) -> None:
+        self.a = 2.0
+        self.dv = 4.0
+        self.step1 = VelocitySecondOrderStep1(v0=0.0, vf=self.dv, a_max=self.a, a_min=-self.a)
+        self.input_profile = Profile()
+        self.input_profile.set_boundary_for_velocity(
+            p0_new=0.0, v0_new=0.0, a0_new=0.0, vf_new=self.dv, af_new=0.0
+        )
+        self.block = Block()
+
+    def test_pins_ramp_duration(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+
+        profile = self.block.p_min
+        expected_t1 = self.dv / self.a
+        self.assertEqual(profile.t[0], 0.0)
+        self.assertAlmostEqual(profile.t[1], expected_t1, delta=1e-9)
+        for i in range(2, 7):
+            self.assertEqual(profile.t[i], 0.0, msg=f"t[{i}]")
+
+        self.assertAlmostEqual(profile.t_sum[-1], expected_t1, delta=1e-9)
+        self.assertAlmostEqual(self.block.t_min, expected_t1, delta=1e-9)
+
+    def test_pins_boundary_arrays(self) -> None:
+        success = self.step1.get_profile(self.input_profile, self.block)
+        self.assertTrue(success)
+        profile = self.block.p_min
+
+        expected_a = [0.0, self.a, 0.0, 0.0, 0.0, 0.0, 0.0]
+        p, v = 0.0, 0.0
+        for i in range(7):
+            p, v, _ = integrate_jerk(profile.t[i], p, v, expected_a[i], 0.0)
+            self.assertAlmostEqual(profile.p[i + 1], p, delta=1e-9, msg=f"p[{i + 1}]")
+            self.assertAlmostEqual(profile.v[i + 1], v, delta=1e-9, msg=f"v[{i + 1}]")
+
+        self.assertAlmostEqual(profile.v[-1], self.dv, delta=1e-8)
+
+
+class TestVelocityThirdOrderStep2(unittest.TestCase):
+    """Step2: a prescribed duration 1.5x the Step1 time-optimal duration
+    for the same trapezoidal-regime target must still yield a valid
+    profile that hits the target velocity/acceleration, and must span
+    exactly the prescribed duration.
+    """
+
+    def test_prescribed_duration_hits_target_velocity(self) -> None:
+        a, j, dv = 2.0, 1.0, 6.0
+        t_opt = dv / a + a / j  # 5.0, per TestVelocityThirdOrderStep1Trapezoidal
+        tf = 1.5 * t_opt
+
+        profile = Profile()
+        profile.set_boundary_for_velocity(p0_new=0.0, v0_new=0.0, a0_new=0.0, vf_new=dv, af_new=0.0)
+
+        step2 = VelocityThirdOrderStep2(
+            tf=tf, v0=0.0, a0=0.0, vf=dv, af=0.0, a_max=a, a_min=-a, j_max=j
+        )
+        success = step2.get_profile(profile)
+        self.assertTrue(success)
+
+        self.assertAlmostEqual(profile.v[-1], dv, delta=1e-8)
+        self.assertAlmostEqual(profile.a[-1], 0.0, delta=1e-10)
+        self.assertAlmostEqual(profile.t_sum[-1], tf, delta=1e-8)
+        self.assertAlmostEqual(profile.pf, profile.p[7], delta=0.0)
+
+
+class TestVelocitySecondOrderStep2(unittest.TestCase):
+    """Step2: a prescribed duration 1.5x the Step1 time-optimal duration
+    must still yield a valid profile that hits the target velocity and
+    spans exactly the prescribed duration.
+    """
+
+    def test_prescribed_duration_hits_target_velocity(self) -> None:
+        a, dv = 2.0, 4.0
+        t_opt = dv / a  # 2.0, per TestVelocitySecondOrderStep1
+        tf = 1.5 * t_opt
+
+        profile = Profile()
+        profile.set_boundary_for_velocity(p0_new=0.0, v0_new=0.0, a0_new=0.0, vf_new=dv, af_new=0.0)
+
+        step2 = VelocitySecondOrderStep2(tf=tf, v0=0.0, vf=dv, a_max=a, a_min=-a)
+        success = step2.get_profile(profile)
+        self.assertTrue(success)
+
+        self.assertAlmostEqual(profile.v[-1], dv, delta=1e-8)
+        self.assertAlmostEqual(profile.t_sum[-1], tf, delta=1e-8)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/test_block.py b/tests/otg/test_block.py
new file mode 100644
index 0000000..f7ce7ce
--- /dev/null
+++ b/tests/otg/test_block.py
@@ -0,0 +1,246 @@
+"""Unit tests for ``math_tools.otg.block.Block``/``Interval``.
+
+See ``.claude/specs/otg.md`` §Internal fidelity requirement 3 and
+``.claude/action-plan/34-otg-block-brake-bound.md``'s TDD steps:
+``is_blocked`` boundary behavior at interval edges; ``get_profile`` returns
+the interval's profile for an in-interval ``t``.
+"""
+
+import unittest
+
+from math_tools.otg.block import Block, Interval
+from math_tools.otg.enums import Direction
+from math_tools.otg.profile import Profile
+
+
+def _profile(duration: float, direction: Direction = Direction.UP) -> Profile:
+    """A minimal ``Profile`` whose total duration (``t_sum[-1] +
+    brake.duration + accel.duration``) is exactly ``duration`` (brake/accel
+    left at their zero defaults)."""
+    profile = Profile()
+    profile.t_sum[-1] = duration
+    profile.direction = direction
+    return profile
+
+
+class TestInterval(unittest.TestCase):
+    def test_is_blocked_strictly_inside_open_interval(self) -> None:
+        interval = Interval(2.0, 5.0)
+        self.assertFalse(interval.is_blocked(2.0))
+        self.assertTrue(interval.is_blocked(2.0001))
+        self.assertTrue(interval.is_blocked(4.9999))
+        self.assertFalse(interval.is_blocked(5.0))
+        self.assertFalse(interval.is_blocked(1.999))
+        self.assertFalse(interval.is_blocked(5.001))
+
+    def test_from_profiles_orders_by_duration_and_keeps_slower_at_right(self) -> None:
+        faster = _profile(2.0)
+        slower = _profile(5.0)
+
+        interval = Interval.from_profiles(faster, slower)
+        self.assertEqual(interval.left, 2.0)
+        self.assertEqual(interval.right, 5.0)
+        self.assertIs(interval.profile, slower)
+
+        # Argument order must not matter for left/right/profile: the slower
+        # (larger-duration) profile always ends up as `profile`, at `right`.
+        interval_swapped = Interval.from_profiles(slower, faster)
+        self.assertEqual(interval_swapped.left, 2.0)
+        self.assertEqual(interval_swapped.right, 5.0)
+        self.assertIs(interval_swapped.profile, slower)
+
+    def test_from_profiles_includes_brake_and_accel_duration(self) -> None:
+        faster = _profile(2.0)
+        slower = _profile(2.0)
+        slower.brake.duration = 1.0
+        slower.accel.duration = 1.0
+
+        interval = Interval.from_profiles(faster, slower)
+        self.assertEqual(interval.left, 2.0)
+        self.assertEqual(interval.right, 4.0)
+        self.assertIs(interval.profile, slower)
+
+
+class TestBlockIsBlockedBoundaries(unittest.TestCase):
+    def test_before_t_min_is_blocked(self) -> None:
+        block = Block(p_min=Profile(), t_min=2.0)
+        self.assertTrue(block.is_blocked(1.999))
+        self.assertFalse(block.is_blocked(2.0))
+        self.assertFalse(block.is_blocked(2.001))
+
+    def test_no_intervals_only_t_min_governs(self) -> None:
+        block = Block(t_min=0.0)
+        self.assertFalse(block.is_blocked(0.0))
+        self.assertFalse(block.is_blocked(100.0))
+
+    def test_interval_a_edges(self) -> None:
+        block = Block(t_min=0.0)
+        block.a = Interval(2.0, 5.0)
+        self.assertFalse(block.is_blocked(2.0))
+        self.assertTrue(block.is_blocked(3.0))
+        self.assertFalse(block.is_blocked(5.0))
+
+    def test_interval_b_edges(self) -> None:
+        block = Block(t_min=0.0)
+        block.a = Interval(2.0, 5.0)
+        block.b = Interval(6.0, 9.0)
+        self.assertFalse(block.is_blocked(6.0))
+        self.assertTrue(block.is_blocked(7.0))
+        self.assertFalse(block.is_blocked(9.0))
+
+
+class TestBlockGetProfile(unittest.TestCase):
+    def test_returns_p_min_before_any_interval(self) -> None:
+        p_min = _profile(1.0)
+        other = _profile(5.0)
+        block = Block(p_min=p_min, t_min=1.0)
+        block.a = Interval(1.0, 5.0, profile=other)
+
+        self.assertIs(block.get_profile(0.5), p_min)
+
+    def test_returns_interval_a_profile_at_and_after_its_right_edge(self) -> None:
+        p_min = _profile(1.0)
+        other = _profile(5.0)
+        block = Block(p_min=p_min, t_min=1.0)
+        block.a = Interval(1.0, 5.0, profile=other)
+
+        self.assertIs(block.get_profile(5.0), other)
+        self.assertIs(block.get_profile(6.0), other)
+
+    def test_returns_interval_b_profile_at_and_after_its_right_edge(self) -> None:
+        p_min = _profile(1.0)
+        mid = _profile(5.0)
+        slowest = _profile(9.0)
+        block = Block(p_min=p_min, t_min=1.0)
+        block.a = Interval(1.0, 5.0, profile=mid)
+        block.b = Interval(5.0, 9.0, profile=slowest)
+
+        self.assertIs(block.get_profile(9.0), slowest)
+        self.assertIs(block.get_profile(4.9), p_min)
+
+    def test_falls_back_to_p_min_when_interval_profile_is_none(self) -> None:
+        p_min = _profile(1.0)
+        block = Block(p_min=p_min, t_min=1.0)
+        block.a = Interval(1.0, 5.0, profile=None)
+
+        self.assertIs(block.get_profile(6.0), p_min)
+
+
+class TestBlockSetMinProfile(unittest.TestCase):
+    def test_set_min_profile_computes_t_min_and_clears_intervals(self) -> None:
+        block = Block()
+        block.a = Interval(1.0, 2.0)
+        block.b = Interval(3.0, 4.0)
+
+        profile = _profile(7.0)
+        profile.brake.duration = 1.0
+        profile.accel.duration = 2.0
+
+        block.set_min_profile(profile)
+
+        self.assertIs(block.p_min, profile)
+        self.assertEqual(block.t_min, 10.0)
+        self.assertIsNone(block.a)
+        self.assertIsNone(block.b)
+
+
+class TestBlockRemoveProfile(unittest.TestCase):
+    def test_shifts_left_and_decrements_counter(self) -> None:
+        profiles = [_profile(1.0), _profile(2.0), _profile(3.0), _profile(4.0)]
+        new_counter = Block.remove_profile(profiles, 4, 1)
+        self.assertEqual(new_counter, 3)
+        self.assertEqual([p.t_sum[-1] for p in profiles[:new_counter]], [1.0, 3.0, 4.0])
+
+
+class TestCalculateBlock(unittest.TestCase):
+    def test_single_profile_sets_min_and_succeeds(self) -> None:
+        block = Block()
+        profile = _profile(3.0)
+        success, counter = Block.calculate_block(block, [profile], 1)
+
+        self.assertTrue(success)
+        self.assertEqual(counter, 1)
+        self.assertIs(block.p_min, profile)
+        self.assertEqual(block.t_min, 3.0)
+        self.assertIsNone(block.a)
+        self.assertIsNone(block.b)
+
+    def test_two_nearly_equal_profiles_picks_first_with_no_interval(self) -> None:
+        block = Block()
+        profiles = [_profile(3.0), _profile(3.0)]
+        success, counter = Block.calculate_block(block, profiles, 2)
+
+        self.assertTrue(success)
+        self.assertEqual(counter, 2)
+        self.assertIs(block.p_min, profiles[0])
+        self.assertIsNone(block.a)
+
+    def test_two_distinct_profiles_numerically_robust_creates_interval(self) -> None:
+        block = Block()
+        faster, slower = _profile(2.0), _profile(6.0)
+        success, counter = Block.calculate_block(block, [faster, slower], 2)
+
+        self.assertTrue(success)
+        self.assertEqual(counter, 2)
+        self.assertIs(block.p_min, faster)
+        self.assertIsNotNone(block.a)
+        assert block.a is not None
+        self.assertEqual(block.a.left, 2.0)
+        self.assertEqual(block.a.right, 6.0)
+        self.assertIs(block.a.profile, slower)
+
+    def test_two_distinct_profiles_not_numerically_robust_falls_through_false(self) -> None:
+        block = Block()
+        faster, slower = _profile(2.0), _profile(6.0)
+        success, counter = Block.calculate_block(
+            block, [faster, slower], 2, numerical_robust=False
+        )
+        # No branch returns True: falls through with block untouched by this
+        # call (still default-constructed) and no explicit success.
+        self.assertFalse(success)
+        self.assertEqual(counter, 2)
+
+    def test_three_profiles_creates_one_blocking_interval_around_the_fastest(self) -> None:
+        block = Block()
+        profiles = [_profile(5.0), _profile(1.0), _profile(9.0)]
+        success, counter = Block.calculate_block(block, profiles, 3)
+
+        self.assertTrue(success)
+        self.assertEqual(counter, 3)
+        self.assertIs(block.p_min, profiles[1])
+        self.assertIsNotNone(block.a)
+        self.assertIsNone(block.b)
+
+    def test_five_profiles_same_direction_creates_two_intervals(self) -> None:
+        block = Block()
+        profiles = [
+            _profile(1.0, Direction.UP),
+            _profile(2.0, Direction.UP),
+            _profile(3.0, Direction.UP),
+            _profile(4.0, Direction.UP),
+            _profile(5.0, Direction.UP),
+        ]
+        success, counter = Block.calculate_block(block, profiles, 5)
+
+        self.assertTrue(success)
+        self.assertEqual(counter, 5)
+        self.assertIs(block.p_min, profiles[0])
+        self.assertIsNotNone(block.a)
+        self.assertIsNotNone(block.b)
+
+    def test_four_valid_profiles_even_count_without_duplicate_returns_false(self) -> None:
+        block = Block()
+        profiles = [_profile(1.0), _profile(9.0), _profile(2.0), _profile(9.5)]
+        success, counter = Block.calculate_block(block, profiles, 4)
+        self.assertFalse(success)
+
+    def test_even_count_not_specially_handled_returns_false(self) -> None:
+        block = Block()
+        profiles = [_profile(float(i)) for i in range(6)]
+        success, counter = Block.calculate_block(block, profiles, 6)
+        self.assertFalse(success)
+        self.assertEqual(counter, 6)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/test_brake.py b/tests/otg/test_brake.py
new file mode 100644
index 0000000..a400b6b
--- /dev/null
+++ b/tests/otg/test_brake.py
@@ -0,0 +1,195 @@
+"""Unit tests for ``math_tools.otg.brake.BrakeProfile``.
+
+See ``.claude/specs/otg.md`` §Internal fidelity requirement 1 and
+``.claude/action-plan/34-otg-block-brake-bound.md``'s TDD steps: a state
+exceeding max acceleration produces a non-zero brake duration and
+``v_at_t(0) == v0``; a within-limits state produces an empty brake
+(``t[0] == 0``).
+"""
+
+import unittest
+
+from math_tools.otg.brake import BrakeProfile
+
+
+class TestBrakeProfileDefaults(unittest.TestCase):
+    def test_default_construction(self) -> None:
+        brake = BrakeProfile()
+        self.assertEqual(brake.duration, 0.0)
+        self.assertEqual(brake.t, [0.0, 0.0])
+        self.assertEqual(brake.j, [0.0, 0.0])
+        self.assertEqual(brake.a, [0.0, 0.0])
+        self.assertEqual(brake.v, [0.0, 0.0])
+        self.assertEqual(brake.p, [0.0, 0.0])
+
+    def test_equality(self) -> None:
+        a = BrakeProfile()
+        b = BrakeProfile()
+        self.assertEqual(a, b)
+        b.t[0] = 1.0
+        self.assertNotEqual(a, b)
+
+    def test_equality_rejects_non_brake_profile(self) -> None:
+        self.assertNotEqual(BrakeProfile(), object())
+
+
+class TestVelocityHelpers(unittest.TestCase):
+    def test_v_at_t_zero_time_returns_v0(self) -> None:
+        brake = BrakeProfile()
+        self.assertEqual(brake.v_at_t(3.0, -1.0, 2.0, 0.0), 3.0)
+
+    def test_v_at_t_matches_closed_form(self) -> None:
+        brake = BrakeProfile()
+        v0, a0, j, t = 1.0, 0.5, -2.0, 1.5
+        self.assertAlmostEqual(brake.v_at_t(v0, a0, j, t), v0 + t * (a0 + j * t / 2))
+
+    def test_v_at_a_zero_matches_closed_form(self) -> None:
+        brake = BrakeProfile()
+        v0, a0, j = 2.0, 3.0, -4.0
+        self.assertAlmostEqual(brake.v_at_a_zero(v0, a0, j), v0 + (a0 * a0) / (2 * j))
+
+
+class TestGetPositionBrakeTrajectory(unittest.TestCase):
+    """The chunk's pinned TDD cases for ``get_position_brake_trajectory``."""
+
+    def test_within_limits_state_produces_empty_brake(self) -> None:
+        brake = BrakeProfile()
+        # v0/a0 comfortably inside [vMin, vMax] / [aMin, aMax]: no braking needed.
+        brake.get_position_brake_trajectory(
+            v0=0.0, a0=0.0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0, j_max=10.0
+        )
+        self.assertEqual(brake.t[0], 0.0)
+        self.assertEqual(brake.duration, 0.0)
+
+    def test_zero_jerk_limit_produces_empty_brake(self) -> None:
+        brake = BrakeProfile()
+        brake.get_position_brake_trajectory(
+            v0=10.0, a0=10.0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0, j_max=0.0
+        )
+        self.assertEqual(brake.t, [0.0, 0.0])
+        self.assertEqual(brake.j, [0.0, 0.0])
+
+    def test_acceleration_exceeding_max_produces_nonzero_brake_duration(self) -> None:
+        brake = BrakeProfile()
+        v0, a0 = 0.0, 5.0  # a0 > aMax=2.0
+        brake.get_position_brake_trajectory(
+            v0=v0, a0=a0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0, j_max=10.0
+        )
+        self.assertGreater(brake.t[0], 0.0)
+        self.assertEqual(brake.v_at_t(v0, a0, brake.j[0], 0.0), v0)
+
+    def test_velocity_exceeding_max_with_zero_acceleration_produces_nonzero_brake(self) -> None:
+        brake = BrakeProfile()
+        v0, a0 = 10.0, 0.0  # v0 > vMax=4.0, within accel bounds.
+        brake.get_position_brake_trajectory(
+            v0=v0, a0=a0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0, j_max=10.0
+        )
+        self.assertGreater(brake.t[0], 0.0)
+        self.assertEqual(brake.v_at_t(v0, a0, brake.j[0], 0.0), v0)
+
+
+class TestFinalize(unittest.TestCase):
+    def test_finalize_empty_brake_is_identity(self) -> None:
+        brake = BrakeProfile()
+        p, v, a = brake.finalize(1.0, 2.0, 3.0)
+        self.assertEqual((p, v, a), (1.0, 2.0, 3.0))
+        self.assertEqual(brake.duration, 0.0)
+
+    def test_finalize_nonzero_brake_updates_duration_and_state(self) -> None:
+        brake = BrakeProfile()
+        brake.get_position_brake_trajectory(
+            v0=0.0, a0=5.0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0, j_max=10.0
+        )
+        p0, v0, a0 = 0.0, 0.0, 5.0
+        p, v, a = brake.finalize(p0, v0, a0)
+        self.assertEqual(brake.duration, sum(t for t in brake.t if t > 0.0))
+        self.assertEqual(brake.p[0], p0)
+        self.assertEqual(brake.v[0], v0)
+        self.assertEqual(brake.a[0], a0)
+        # After a nonzero brake, acceleration should have moved toward aMax.
+        self.assertNotEqual((p, v, a), (p0, v0, a0))
+
+    def test_finalize_second_order_empty_brake_is_identity(self) -> None:
+        brake = BrakeProfile()
+        p, v, a = brake.finalize_second_order(1.0, 2.0, 3.0)
+        self.assertEqual((p, v, a), (1.0, 2.0, 3.0))
+        self.assertEqual(brake.duration, 0.0)
+
+    def test_finalize_second_order_nonzero_brake_updates_state(self) -> None:
+        brake = BrakeProfile()
+        brake.get_second_order_position_brake_trajectory(
+            v0=10.0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0
+        )
+        self.assertGreater(brake.t[0], 0.0)
+        p0, v0, a0 = 0.0, 10.0, 0.0
+        p, v, a = brake.finalize_second_order(p0, v0, a0)
+        self.assertEqual(brake.duration, brake.t[0])
+        self.assertNotEqual((p, v), (p0, v0))
+
+
+class TestVelocityInterfaceBrakes(unittest.TestCase):
+    def test_get_velocity_brake_trajectory_within_limits_is_empty(self) -> None:
+        brake = BrakeProfile()
+        brake.get_velocity_brake_trajectory(a0=0.0, a_max=2.0, a_min=-2.0, j_max=10.0)
+        self.assertEqual(brake.t, [0.0, 0.0])
+
+    def test_get_velocity_brake_trajectory_exceeding_max_is_nonzero(self) -> None:
+        brake = BrakeProfile()
+        brake.get_velocity_brake_trajectory(a0=5.0, a_max=2.0, a_min=-2.0, j_max=10.0)
+        self.assertGreater(brake.t[0], 0.0)
+        self.assertEqual(brake.j[0], -10.0)
+
+    def test_get_velocity_brake_trajectory_below_min_is_nonzero(self) -> None:
+        brake = BrakeProfile()
+        brake.get_velocity_brake_trajectory(a0=-5.0, a_max=2.0, a_min=-2.0, j_max=10.0)
+        self.assertGreater(brake.t[0], 0.0)
+        self.assertEqual(brake.j[0], 10.0)
+
+    def test_get_velocity_brake_trajectory_zero_jerk_is_empty(self) -> None:
+        brake = BrakeProfile()
+        brake.get_velocity_brake_trajectory(a0=5.0, a_max=2.0, a_min=-2.0, j_max=0.0)
+        self.assertEqual(brake.t, [0.0, 0.0])
+
+    def test_get_second_order_velocity_brake_trajectory_resets(self) -> None:
+        brake = BrakeProfile()
+        brake.t = [1.0, 2.0]
+        brake.j = [3.0, 4.0]
+        brake.get_second_order_velocity_brake_trajectory()
+        self.assertEqual(brake.t, [0.0, 0.0])
+        self.assertEqual(brake.j, [0.0, 0.0])
+
+
+class TestSecondOrderPositionBrake(unittest.TestCase):
+    def test_within_limits_is_empty(self) -> None:
+        brake = BrakeProfile()
+        brake.get_second_order_position_brake_trajectory(
+            v0=0.0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0
+        )
+        self.assertEqual(brake.t[0], 0.0)
+
+    def test_velocity_above_max_brakes_with_a_min(self) -> None:
+        brake = BrakeProfile()
+        brake.get_second_order_position_brake_trajectory(
+            v0=10.0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0
+        )
+        self.assertGreater(brake.t[0], 0.0)
+        self.assertEqual(brake.a[0], -2.0)
+
+    def test_velocity_below_min_brakes_with_a_max(self) -> None:
+        brake = BrakeProfile()
+        brake.get_second_order_position_brake_trajectory(
+            v0=-10.0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0
+        )
+        self.assertGreater(brake.t[0], 0.0)
+        self.assertEqual(brake.a[0], 2.0)
+
+    def test_zero_accel_limit_is_empty(self) -> None:
+        brake = BrakeProfile()
+        brake.get_second_order_position_brake_trajectory(
+            v0=10.0, v_max=4.0, v_min=-4.0, a_max=0.0, a_min=-2.0
+        )
+        self.assertEqual(brake.t[0], 0.0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/test_calculator_target.py b/tests/otg/test_calculator_target.py
new file mode 100644
index 0000000..0c423a5
--- /dev/null
+++ b/tests/otg/test_calculator_target.py
@@ -0,0 +1,585 @@
+"""Unit tests for ``math_tools.otg.calculator_target.TargetCalculator``.
+
+See ``.claude/specs/otg.md`` §Internal fidelity requirement 3 and
+``.claude/action-plan/40-otg-calculator-target.md``'s TDD steps (a)-(e).
+Cases (a)-(c) reuse chunk 38's rest-to-rest ``PositionThirdOrderStep1``
+boundary conditions (``v_max=2, a_max=1, j_max=1``, ``pd/v_max +
+v_max/a_max + a_max/j_max`` as the closed-form optimal duration) scaled to
+different target distances, composed through the full ``calculate()`` path
+rather than the bare step solver.
+
+**Chunk 56 additions (post-audit findings E-4, E-5, E-6).** The classes
+below ``TestUnsolvableSynchronizationReturnsErrorNotRaise`` close three
+coverage gaps identified by the post-audit (``.claude/action-plan/
+56-test-closure-otg-oracles.md``):
+
+- ``TestMultiDofCorpusReachesStep2`` (E-4): the entire 1,784-case
+  classification corpus is 1-DOF, which takes the dedicated fast path at
+  ``calculator_target.py:553`` and never invokes
+  ``PositionThirdOrderStep2.get_profile``. ``tests/otg/data/
+  successful_trajectories_multi_dof.json`` (generated by
+  ``tests/otg/data/generate_multi_dof_corpus.py``, fixed seed) combines
+  1-DOF corpus cases into 2/3/4-DOF cases under the default ``TIME``
+  synchronization, which is exactly what forces the non-limiting DOFs
+  through Step2.
+- ``TestPhaseSynchronization*`` (E-5): drives ``Synchronization.PHASE``
+  through ``calculate()`` for real, both when the boundary conditions are
+  collinear (phase-sync succeeds without a Step2 solve) and when they are
+  not (falls back to per-DOF ``TIME`` synchronization, i.e. Step2).
+- ``TestDiscreteDuration``, ``TestMinimumDuration``,
+  ``TestTimeIfNecessarySynchronization``, ``TestVelocityControlInterface``
+  (E-6): each drives one previously-0%-covered ``calculate()`` path
+  end-to-end -- ``DurationDiscretization.DISCRETE``,
+  ``InputParameter.minimum_duration``,
+  ``Synchronization.TIME_IF_NECESSARY`` (both its "not necessary" early
+  exit and its "necessary" Step2 fallthrough), and
+  ``ControlInterface.VELOCITY``.
+"""
+
+import json
+import math
+import unittest
+from pathlib import Path
+from unittest.mock import patch
+
+import math_tools.otg.steps.position_third_order_step2 as step2_module
+from math_tools.otg.block import Interval
+from math_tools.otg.calculator_target import TargetCalculator
+from math_tools.otg.enums import ControlInterface, DurationDiscretization, Result, Synchronization
+from math_tools.otg.input_parameter import InputParameter
+from math_tools.otg.otg import Otg
+from math_tools.otg.output_parameter import OutputParameter
+from math_tools.otg.steps.position_third_order_step2 import PositionThirdOrderStep2
+from math_tools.otg.trajectory import Trajectory
+
+_DATA_DIR = Path(__file__).parent / "data"
+
+_V_MAX = 2.0
+_A_MAX = 1.0
+_J_MAX = 1.0
+
+
+def _rest_to_rest_optimal_duration(pd: float) -> float:
+    """Closed-form time-optimal duration for a rest-to-rest move of
+    distance ``pd`` under ``_V_MAX``/``_A_MAX``/``_J_MAX`` (matches chunk
+    38's ``expected_total = pf / v_max + v_max / a_max + a_max / j_max``,
+    valid whenever the move is long enough to saturate both limits)."""
+    return pd / _V_MAX + _V_MAX / _A_MAX + _A_MAX / _J_MAX
+
+
+def _make_position_input(dofs: int, targets: list[float]) -> InputParameter:
+    inp = InputParameter(dofs)
+    inp.target_position = list(targets)
+    inp.max_velocity = [_V_MAX] * dofs
+    inp.min_velocity = [-_V_MAX] * dofs
+    inp.max_acceleration = [_A_MAX] * dofs
+    inp.min_acceleration = [-_A_MAX] * dofs
+    inp.max_jerk = [_J_MAX] * dofs
+    return inp
+
+
+class TestSingleDofMatchesStep1AnalyticDuration(unittest.TestCase):
+    """(a) 1-DOF position case reproduces chunk 38's analytic duration
+    through the full ``calculate()`` path (the 1-DOF shortcut branch)."""
+
+    def test_matches_chunk_38_long_move_duration_and_segments(self) -> None:
+        dofs = 1
+        calc = TargetCalculator(dofs)
+        inp = _make_position_input(dofs, [10.0])
+
+        trajectory = Trajectory(dofs)
+        result = calc.calculate(inp, trajectory, delta_time=0.001)
+
+        self.assertEqual(result, Result.WORKING)
+        expected_duration = _rest_to_rest_optimal_duration(10.0)
+        self.assertAlmostEqual(trajectory.duration, expected_duration, delta=1e-9)
+        self.assertAlmostEqual(trajectory.cumulative_times[0], expected_duration, delta=1e-9)
+
+        expected_t = [1.0, 1.0, 1.0, 2.0, 1.0, 1.0, 1.0]
+        profile = trajectory.profiles[0][0]
+        for i, expected in enumerate(expected_t):
+            self.assertAlmostEqual(profile.t[i], expected, delta=1e-9, msg=f"t[{i}]")
+        self.assertAlmostEqual(profile.p[-1], 10.0, delta=1e-8)
+
+
+class TestThreeDofTimeSynchronization(unittest.TestCase):
+    """(b) 3-DOF TIME sync -- every DOF reports the same trajectory
+    duration, equal to the slowest DOF's own optimal duration."""
+
+    def test_all_dofs_reach_the_slowest_dofs_optimal_duration(self) -> None:
+        dofs = 3
+        calc = TargetCalculator(dofs)
+        targets = [10.0, 5.0, 2.0]
+        inp = _make_position_input(dofs, targets)
+        inp.synchronization = Synchronization.TIME
+
+        trajectory = Trajectory(dofs)
+        result = calc.calculate(inp, trajectory, delta_time=0.001)
+
+        self.assertEqual(result, Result.WORKING)
+        expected_duration = _rest_to_rest_optimal_duration(max(targets))
+        self.assertAlmostEqual(trajectory.duration, expected_duration, delta=1e-9)
+
+        for dof in range(dofs):
+            profile = trajectory.profiles[0][dof]
+            total = profile.t_sum[-1] + profile.brake.duration + profile.accel.duration
+            self.assertAlmostEqual(total, expected_duration, delta=1e-8, msg=f"dof {dof}")
+            self.assertAlmostEqual(profile.p[-1], targets[dof], delta=1e-6, msg=f"dof {dof}")
+
+
+class TestThreeDofNoneSynchronization(unittest.TestCase):
+    """(c) NONE sync -- per-DOF durations equal their independent optima
+    (not stretched to the slowest DOF)."""
+
+    def test_each_dof_keeps_its_own_optimal_duration(self) -> None:
+        dofs = 3
+        calc = TargetCalculator(dofs)
+        targets = [10.0, 5.0, 2.0]
+        inp = _make_position_input(dofs, targets)
+        inp.synchronization = Synchronization.NONE
+
+        trajectory = Trajectory(dofs)
+        result = calc.calculate(inp, trajectory, delta_time=0.001)
+
+        self.assertEqual(result, Result.WORKING)
+
+        for dof in range(dofs):
+            profile = trajectory.profiles[0][dof]
+            total = profile.t_sum[-1] + profile.brake.duration + profile.accel.duration
+            own_optimum = trajectory.independent_min_durations[dof]
+            self.assertAlmostEqual(total, own_optimum, delta=1e-8, msg=f"dof {dof}")
+            self.assertAlmostEqual(profile.p[-1], targets[dof], delta=1e-6, msg=f"dof {dof}")
+
+        # Distinct targets (10/5/2) under identical limits must give
+        # genuinely distinct independent optima -- otherwise this test
+        # can't distinguish NONE sync from TIME sync.
+        durations = trajectory.independent_min_durations
+        self.assertGreater(durations[0], durations[1])
+        self.assertGreater(durations[1], durations[2])
+
+        # The trajectory's own bookkeeping duration is still the max
+        # (slowest DOF), used for e.g. FINISHED detection by a driver.
+        self.assertAlmostEqual(trajectory.duration, max(durations), delta=1e-9)
+
+
+class TestDisabledDofStaysAtCurrentState(unittest.TestCase):
+    """(d) an ``enabled=False`` DOF stays at its current state."""
+
+    def test_disabled_dof_profile_holds_current_state(self) -> None:
+        dofs = 2
+        calc = TargetCalculator(dofs)
+        inp = _make_position_input(dofs, [10.0, 99.0])  # dof1's target is irrelevant (disabled).
+        inp.current_position = [0.0, 3.0]
+        inp.current_velocity = [0.0, 0.5]
+        inp.current_acceleration = [0.0, 0.1]
+        inp.enabled = [True, False]
+
+        trajectory = Trajectory(dofs)
+        result = calc.calculate(inp, trajectory, delta_time=0.001)
+
+        self.assertEqual(result, Result.WORKING)
+
+        disabled_profile = trajectory.profiles[0][1]
+        self.assertAlmostEqual(disabled_profile.p[-1], 3.0, delta=1e-12)
+        self.assertAlmostEqual(disabled_profile.v[-1], 0.5, delta=1e-12)
+        self.assertAlmostEqual(disabled_profile.a[-1], 0.1, delta=1e-12)
+        self.assertAlmostEqual(disabled_profile.t_sum[-1], 0.0, delta=1e-12)
+
+        # The enabled DOF must still solve normally.
+        enabled_profile = trajectory.profiles[0][0]
+        self.assertAlmostEqual(enabled_profile.p[-1], 10.0, delta=1e-6)
+
+
+class TestTrivialProfileUsesFixedLengthArrays(unittest.TestCase):
+    """(f) chunk 45 / post-audit finding E-2: the trivial "already at
+    target" branch must produce the same fixed-length ``Profile`` arrays
+    (``a``/``v``/``p`` length 8, ``t``/``t_sum``/``j`` length 7) as every
+    other path, per ``.claude/specs/otg.md`` §Internal fidelity requirement
+    1 -- not the 7-element form that made ``p.p[7]`` raise ``IndexError``.
+    """
+
+    def test_trivial_target_profile_arrays_are_fixed_length(self) -> None:
+        dofs = 1
+        calc = TargetCalculator(dofs)
+        inp = _make_position_input(dofs, [0.0])  # current_position defaults to 0.0 -> trivial.
+
+        trajectory = Trajectory(dofs)
+        result = calc.calculate(inp, trajectory, delta_time=0.001)
+
+        self.assertEqual(result, Result.WORKING)
+        profile = trajectory.profiles[0][0]
+        self.assertEqual(len(profile.p), 8)
+        self.assertEqual(len(profile.v), 8)
+        self.assertEqual(len(profile.a), 8)
+        self.assertEqual(len(profile.t), 7)
+        self.assertEqual(len(profile.t_sum), 7)
+        self.assertEqual(len(profile.j), 7)
+
+
+class TestTrivialProfilePositionExtrema(unittest.TestCase):
+    """(g) a trajectory parked at a non-zero position (trivial branch)
+    must report that position as both min and max extrema, not ``0.0`` --
+    requires ``p.pf`` to be set in the trivial branch."""
+
+    def test_parked_trajectory_extrema_report_parked_position(self) -> None:
+        dofs = 1
+        calc = TargetCalculator(dofs)
+        inp = _make_position_input(dofs, [5.0])
+        inp.current_position = [5.0]  # already at target -> trivial branch.
+
+        trajectory = Trajectory(dofs)
+        result = calc.calculate(inp, trajectory, delta_time=0.001)
+
+        self.assertEqual(result, Result.WORKING)
+        extrema = trajectory.position_extrema()
+        self.assertAlmostEqual(extrema[0].min, 5.0, delta=1e-12)
+        self.assertAlmostEqual(extrema[0].max, 5.0, delta=1e-12)
+
+
+class TestUnsolvableSynchronizationReturnsErrorNotRaise(unittest.TestCase):
+    """(e) an unsolvable synchronization input returns
+    ``ERROR_SYNCHRONIZATION_CALCULATION`` rather than raising.
+
+    ``TargetCalculator._synchronize``'s search is provably complete for any
+    ``Block`` state actually produced by a successful Step1 call: a DOF's
+    own ``t_min`` is never self-blocked at its own boundary, and neither is
+    an ``Interval``'s own ``right`` edge (``Interval.is_blocked`` excludes
+    both endpoints). Reaching "no candidate found" through a *naturally*
+    Step1-derived ``InputParameter`` would require an adversarial multi-DOF
+    interval coincidence that is impractical to hand-derive, so this is
+    exercised two ways instead: directly, with a hand-built ``Block`` state
+    proven (by construction, see the docstring below) to block every finite
+    candidate; and through ``calculate()`` itself, with ``_synchronize``
+    forced to fail via ``unittest.mock.patch.object`` to confirm the error
+    propagates to the ``Result`` code without an exception.
+    """
+
+    def test_synchronize_returns_false_without_raising_when_all_candidates_blocked(self) -> None:
+        calc = TargetCalculator(2)
+        calc._inp_per_dof_synchronization = [Synchronization.TIME, Synchronization.TIME]
+
+        # dof0: reachable only at t == 1.0 exactly (blocked for every t > 1.0
+        # via an interval with an infinite right edge).
+        calc._blocks[0].t_min = 1.0
+        calc._blocks[0].a = Interval(1.0, math.inf)
+
+        # dof1: its own t_min floor (2.0) blocks dof0's only escape point
+        # (t == 1.0 < 2.0 == dof1.t_min -> Block.is_blocked(1.0) is True for
+        # dof1), and dof1 contributes no interval of its own beyond that.
+        calc._blocks[1].t_min = 2.0
+
+        trajectory = Trajectory(2)
+        found, _t_sync, _limiting_dof = calc._synchronize(
+            None, trajectory.profiles[0], discrete_duration=False, delta_time=0.001
+        )
+
+        self.assertFalse(found)
+
+    def test_calculate_propagates_synchronization_failure_without_raising(self) -> None:
+        dofs = 2
+        calc = TargetCalculator(dofs)
+        inp = _make_position_input(dofs, [10.0, 5.0])
+
+        trajectory = Trajectory(dofs)
+        with patch.object(TargetCalculator, "_synchronize", return_value=(False, 0.0, None)):
+            result = calc.calculate(inp, trajectory, delta_time=0.001)
+
+        self.assertEqual(result, Result.ERROR_SYNCHRONIZATION_CALCULATION)
+
+
+class TestMultiDofCorpusReachesStep2(unittest.TestCase):
+    """Post-audit E-4: the 1-DOF classification corpus never reaches
+    ``PositionThirdOrderStep2`` (the 1-DOF fast path at
+    ``calculator_target.py:553`` copies the Step1 extremal profile
+    directly). ``successful_trajectories_multi_dof.json`` (2/3/4-DOF,
+    default ``TIME`` sync) is generated specifically to force the
+    non-limiting DOFs through Step2 -- verified here by measuring the
+    invocation count directly, not assuming reach from case shape alone."""
+
+    def test_all_cases_succeed_and_step2_is_invoked(self) -> None:
+        with (_DATA_DIR / "successful_trajectories_multi_dof.json").open() as f:
+            cases = json.load(f)
+        self.assertGreater(len(cases), 0, "successful_trajectories_multi_dof.json is empty")
+
+        original_get_profile = step2_module.PositionThirdOrderStep2.get_profile
+        invocation_count = 0
+
+        def counting_get_profile(step2_self: PositionThirdOrderStep2, profile: object) -> bool:
+            nonlocal invocation_count
+            invocation_count += 1
+            return original_get_profile(step2_self, profile)  # type: ignore[arg-type]
+
+        failures: list[tuple[int, Result]] = []
+        with patch.object(
+            step2_module.PositionThirdOrderStep2, "get_profile", counting_get_profile
+        ):
+            for index, case in enumerate(cases):
+                inp = InputParameter.from_dict(case)
+                otg = Otg(0.01, dofs=inp.degrees_of_freedom)
+                output = OutputParameter(dofs=inp.degrees_of_freedom)
+                result = otg.calculate(inp, output)
+                if result < 0:
+                    failures.append((index, result))
+
+        self.assertEqual(
+            failures,
+            [],
+            f"{len(failures)}/{len(cases)} multi-DOF corpus cases returned an error Result",
+        )
+        # The acceptance signal for the whole chunk (design constraint 1:
+        # measure, don't assume). Observed count at authoring time: 900
+        # invocations across 450 cases -- see the chunk's Resolution notes.
+        self.assertGreater(
+            invocation_count,
+            0,
+            "PositionThirdOrderStep2.get_profile was never invoked by the multi-DOF corpus",
+        )
+
+
+class TestPhaseSynchronizationCollinear(unittest.TestCase):
+    """Post-audit E-5: ``Synchronization.PHASE`` driven through
+    ``calculate()`` for a genuinely collinear 2-DOF rest-to-rest move
+    (proportional position deltas, zero velocity/acceleration everywhere,
+    which is trivially collinear per ``_is_input_collinear``'s algebra).
+    Phase sync must succeed without a Step2 solve: both DOFs finish at the
+    same duration by scaling the limiting DOF's own timing, not by an
+    independent per-DOF time-synchronization solve."""
+
+    def test_collinear_phase_sync_succeeds_without_step2(self) -> None:
+        dofs = 2
+        calc = TargetCalculator(dofs)
+        inp = _make_position_input(dofs, [10.0, 5.0])
+        inp.per_dof_synchronization = [Synchronization.PHASE, Synchronization.PHASE]
+
+        trajectory = Trajectory(dofs)
+        invocation_count = 0
+        original_get_profile = step2_module.PositionThirdOrderStep2.get_profile
+
+        def counting_get_profile(step2_self: PositionThirdOrderStep2, profile: object) -> bool:
+            nonlocal invocation_count
+            invocation_count += 1
+            return original_get_profile(step2_self, profile)  # type: ignore[arg-type]
+
+        with patch.object(
+            step2_module.PositionThirdOrderStep2, "get_profile", counting_get_profile
+        ):
+            result = calc.calculate(inp, trajectory, delta_time=0.001)
+
+        self.assertEqual(result, Result.WORKING)
+        self.assertEqual(invocation_count, 0, "collinear phase sync should not need Step2")
+
+        for dof, target in enumerate([10.0, 5.0]):
+            profile = trajectory.profiles[0][dof]
+            self.assertAlmostEqual(profile.p[-1], target, delta=1e-6, msg=f"dof {dof}")
+            self.assertAlmostEqual(
+                profile.t_sum[-1], trajectory.duration, delta=1e-9, msg=f"dof {dof}"
+            )
+
+
+class TestPhaseSynchronizationFallsBackToTime(unittest.TestCase):
+    """Post-audit E-5: when the ``PHASE``-tagged DOFs are NOT collinear
+    (here, a current velocity ratio that doesn't match the position-delta
+    ratio), otg.md's "Phase synchronize the DOFs when possible, else fall
+    back to TIME" contract requires falling back to per-DOF time
+    synchronization -- i.e. ``_is_input_collinear`` must return ``False``
+    and the non-limiting DOF must go through Step2."""
+
+    def test_non_collinear_phase_sync_falls_back_to_step2(self) -> None:
+        dofs = 2
+        calc = TargetCalculator(dofs)
+        inp = _make_position_input(dofs, [10.0, 5.0])
+        inp.current_velocity = [0.5, 0.7]  # not proportional to the 10:5 position ratio
+        inp.per_dof_synchronization = [Synchronization.PHASE, Synchronization.PHASE]
+        self.assertTrue(inp.validate(check_current_state_within_limits=True))
+
+        trajectory = Trajectory(dofs)
+        invocation_count = 0
+        original_get_profile = step2_module.PositionThirdOrderStep2.get_profile
+
+        def counting_get_profile(step2_self: PositionThirdOrderStep2, profile: object) -> bool:
+            nonlocal invocation_count
+            invocation_count += 1
+            return original_get_profile(step2_self, profile)  # type: ignore[arg-type]
+
+        with patch.object(
+            step2_module.PositionThirdOrderStep2, "get_profile", counting_get_profile
+        ):
+            result = calc.calculate(inp, trajectory, delta_time=0.001)
+
+        self.assertEqual(result, Result.WORKING)
+        self.assertGreater(
+            invocation_count, 0, "non-collinear phase sync must fall back to a Step2 solve"
+        )
+
+        for dof, target in enumerate([10.0, 5.0]):
+            profile = trajectory.profiles[0][dof]
+            self.assertAlmostEqual(profile.p[-1], target, delta=1e-6, msg=f"dof {dof}")
+
+
+class TestDiscreteDuration(unittest.TestCase):
+    """Post-audit E-6: ``DurationDiscretization.DISCRETE`` driven through
+    ``calculate()`` -- the synchronized duration must be rounded up to the
+    next multiple of ``delta_time`` (``calculator_target.py``'s
+    ``_synchronize`` discrete-rounding branch), not left at the raw
+    (non-multiple) time-optimal value."""
+
+    def test_duration_is_rounded_up_to_a_multiple_of_delta_time(self) -> None:
+        dofs = 1
+        calc = TargetCalculator(dofs)
+        inp = _make_position_input(dofs, [10.3])  # natural optimum 8.15, not a multiple of 0.1
+        inp.duration_discretization = DurationDiscretization.DISCRETE
+
+        trajectory = Trajectory(dofs)
+        delta_time = 0.1
+        result = calc.calculate(inp, trajectory, delta_time=delta_time)
+
+        self.assertEqual(result, Result.WORKING)
+        natural_optimum = _rest_to_rest_optimal_duration(10.3)
+        self.assertGreaterEqual(trajectory.duration, natural_optimum - 1e-9)
+        multiples = trajectory.duration / delta_time
+        self.assertAlmostEqual(multiples, round(multiples), delta=1e-6)
+        self.assertAlmostEqual(trajectory.profiles[0][0].p[-1], 10.3, delta=1e-6)
+
+
+class TestMinimumDuration(unittest.TestCase):
+    """Post-audit E-6: ``InputParameter.minimum_duration`` driven through
+    ``calculate()`` -- a 1-DOF move stretched to twice its natural optimal
+    duration must land exactly on ``minimum_duration`` (not the natural
+    optimum), via a genuine Step2 solve (the 1-DOF fast path is bypassed
+    whenever ``minimum_duration is not None``)."""
+
+    def test_duration_is_stretched_to_minimum_duration_via_step2(self) -> None:
+        dofs = 1
+        calc = TargetCalculator(dofs)
+        inp = _make_position_input(dofs, [10.0])
+        natural_optimum = _rest_to_rest_optimal_duration(10.0)
+        inp.minimum_duration = 2.0 * natural_optimum
+
+        trajectory = Trajectory(dofs)
+        invocation_count = 0
+        original_get_profile = step2_module.PositionThirdOrderStep2.get_profile
+
+        def counting_get_profile(step2_self: PositionThirdOrderStep2, profile: object) -> bool:
+            nonlocal invocation_count
+            invocation_count += 1
+            return original_get_profile(step2_self, profile)  # type: ignore[arg-type]
+
+        with patch.object(
+            step2_module.PositionThirdOrderStep2, "get_profile", counting_get_profile
+        ):
+            result = calc.calculate(inp, trajectory, delta_time=0.001)
+
+        self.assertEqual(result, Result.WORKING)
+        self.assertAlmostEqual(trajectory.duration, inp.minimum_duration, delta=1e-9)
+        self.assertGreater(invocation_count, 0, "minimum_duration stretch must go through Step2")
+        self.assertAlmostEqual(trajectory.profiles[0][0].p[-1], 10.0, delta=1e-6)
+        self.assertAlmostEqual(trajectory.profiles[0][0].v[-1], 0.0, delta=1e-6)
+        self.assertAlmostEqual(trajectory.profiles[0][0].a[-1], 0.0, delta=1e-6)
+
+
+class TestTimeIfNecessarySynchronization(unittest.TestCase):
+    """Post-audit E-6: ``Synchronization.TIME_IF_NECESSARY`` driven through
+    ``calculate()``, both branches of
+    ``calculator_target.py``'s early-exit check:
+
+    - "not necessary" (zero target velocity/acceleration): the DOF keeps
+      its own short, unstretched optimal profile and simply holds at the
+      target once it finishes early -- it is NOT stretched to match the
+      slower ``TIME``-synced DOF's duration.
+    - "necessary" (non-zero target velocity): the DOF must be stretched to
+      the synchronized duration via Step2, since arriving early and
+      holding would not reproduce the required non-zero terminal velocity
+      at the right moment.
+    """
+
+    def test_zero_target_velocity_keeps_its_own_short_duration(self) -> None:
+        dofs = 2
+        calc = TargetCalculator(dofs)
+        inp = _make_position_input(dofs, [10.0, 2.0])  # dof0 slow, dof1 fast
+        inp.per_dof_synchronization = [Synchronization.TIME, Synchronization.TIME_IF_NECESSARY]
+
+        trajectory = Trajectory(dofs)
+        result = calc.calculate(inp, trajectory, delta_time=0.001)
+
+        self.assertEqual(result, Result.WORKING)
+        slow_duration = _rest_to_rest_optimal_duration(10.0)
+        fast_duration = _rest_to_rest_optimal_duration(2.0)
+        self.assertAlmostEqual(trajectory.duration, slow_duration, delta=1e-9)
+
+        fast_profile = trajectory.profiles[0][1]
+        self.assertAlmostEqual(fast_profile.p[-1], 2.0, delta=1e-6)
+        self.assertAlmostEqual(
+            fast_profile.t_sum[-1],
+            fast_duration,
+            delta=1e-6,
+            msg="a not-necessary TIME_IF_NECESSARY DOF must keep its own optimal duration",
+        )
+
+    def test_nonzero_target_velocity_stretches_via_step2(self) -> None:
+        dofs = 2
+        calc = TargetCalculator(dofs)
+        inp = _make_position_input(dofs, [10.0, 2.0])
+        inp.target_velocity = [0.0, 0.3]
+        inp.per_dof_synchronization = [Synchronization.TIME, Synchronization.TIME_IF_NECESSARY]
+
+        trajectory = Trajectory(dofs)
+        invocation_count = 0
+        original_get_profile = step2_module.PositionThirdOrderStep2.get_profile
+
+        def counting_get_profile(step2_self: PositionThirdOrderStep2, profile: object) -> bool:
+            nonlocal invocation_count
+            invocation_count += 1
+            return original_get_profile(step2_self, profile)  # type: ignore[arg-type]
+
+        with patch.object(
+            step2_module.PositionThirdOrderStep2, "get_profile", counting_get_profile
+        ):
+            result = calc.calculate(inp, trajectory, delta_time=0.001)
+
+        self.assertEqual(result, Result.WORKING)
+        slow_duration = _rest_to_rest_optimal_duration(10.0)
+        self.assertGreater(invocation_count, 0, "a necessary TIME_IF_NECESSARY sync needs Step2")
+
+        fast_profile = trajectory.profiles[0][1]
+        self.assertAlmostEqual(
+            fast_profile.t_sum[-1],
+            slow_duration,
+            delta=1e-6,
+            msg="a necessary TIME_IF_NECESSARY DOF must be stretched to the synced duration",
+        )
+        self.assertAlmostEqual(fast_profile.p[-1], 2.0, delta=1e-6)
+        self.assertAlmostEqual(fast_profile.v[-1], 0.3, delta=1e-6)
+
+
+class TestVelocityControlInterface(unittest.TestCase):
+    """Post-audit E-6: ``ControlInterface.VELOCITY`` driven through
+    ``Otg.calculate`` -- previously exercised only by
+    ``InputParameter.validate``, never through the actual
+    ``set_boundary_for_velocity`` / velocity-brake / velocity-step-solver
+    dispatch path in ``calculate()``."""
+
+    def test_velocity_interface_reaches_target_velocity(self) -> None:
+        dofs = 1
+        inp = InputParameter(dofs)
+        inp.control_interface = ControlInterface.VELOCITY
+        inp.target_velocity = [3.0]
+        inp.max_acceleration = [1.0]
+        inp.min_acceleration = [-1.0]
+        inp.max_jerk = [1.0]
+
+        otg = Otg(0.01, dofs=dofs)
+        output = OutputParameter(dofs=dofs)
+        result = otg.calculate(inp, output)
+
+        self.assertEqual(result, Result.WORKING)
+        profile = output.trajectory.profiles[0][0]
+        self.assertAlmostEqual(profile.v[-1], 3.0, delta=1e-6)
+        self.assertAlmostEqual(profile.a[-1], 0.0, delta=1e-6)
+
+        final_p, final_v, final_a = output.trajectory.at_time(output.trajectory.duration)
+        self.assertAlmostEqual(final_v[0], 3.0, delta=1e-6)
+        self.assertAlmostEqual(final_a[0], 0.0, delta=1e-6)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/test_enums.py b/tests/otg/test_enums.py
new file mode 100644
index 0000000..6349e6c
--- /dev/null
+++ b/tests/otg/test_enums.py
@@ -0,0 +1,131 @@
+"""Unit tests for ``math_tools.otg.enums`` and ``math_tools.otg.errors``.
+
+Pins the wire-stable ``Result`` integer values (Ruckig parity, including the
+intentional gap at -103) and the string enums' values against
+``.claude/specs/otg.md`` §Public API, transcribed from
+``SWIFT_MATH/OTG/enums/*.swift``. See otg.md §Compliance 3.
+"""
+
+import unittest
+
+from math_tools.errors import MathToolsError
+from math_tools.otg.enums import (
+    ControlInterface,
+    ControlSigns,
+    Direction,
+    DurationDiscretization,
+    ReachedLimits,
+    Result,
+    Synchronization,
+)
+from math_tools.otg.errors import OtgError
+
+
+class TestResultEnum(unittest.TestCase):
+    def test_working_is_zero(self) -> None:
+        self.assertEqual(Result.WORKING, 0)
+
+    def test_finished_is_one(self) -> None:
+        self.assertEqual(Result.FINISHED, 1)
+
+    def test_error_is_negative_one(self) -> None:
+        self.assertEqual(Result.ERROR, -1)
+
+    def test_error_invalid_input_is_negative_100(self) -> None:
+        self.assertEqual(Result.ERROR_INVALID_INPUT, -100)
+
+    def test_error_trajectory_duration_is_negative_101(self) -> None:
+        self.assertEqual(Result.ERROR_TRAJECTORY_DURATION, -101)
+
+    def test_error_positional_limits_is_negative_102(self) -> None:
+        self.assertEqual(Result.ERROR_POSITIONAL_LIMITS, -102)
+
+    def test_error_zero_limits_is_negative_104(self) -> None:
+        self.assertEqual(Result.ERROR_ZERO_LIMITS, -104)
+
+    def test_error_execution_time_calculation_is_negative_110(self) -> None:
+        self.assertEqual(Result.ERROR_EXECUTION_TIME_CALCULATION, -110)
+
+    def test_error_synchronization_calculation_is_negative_111(self) -> None:
+        self.assertEqual(Result.ERROR_SYNCHRONIZATION_CALCULATION, -111)
+
+    def test_result_has_exactly_nine_members(self) -> None:
+        self.assertEqual(len(Result), 9)
+
+    def test_negative_103_gap_is_not_a_result(self) -> None:
+        with self.assertRaises(ValueError):
+            Result(-103)
+
+
+class TestControlInterfaceEnum(unittest.TestCase):
+    def test_position_value(self) -> None:
+        self.assertEqual(ControlInterface.POSITION, "Position")
+
+    def test_velocity_value(self) -> None:
+        self.assertEqual(ControlInterface.VELOCITY, "Velocity")
+
+
+class TestSynchronizationEnum(unittest.TestCase):
+    def test_time_value(self) -> None:
+        self.assertEqual(Synchronization.TIME, "Time")
+
+    def test_time_if_necessary_value(self) -> None:
+        self.assertEqual(Synchronization.TIME_IF_NECESSARY, "TimeIfNecessary")
+
+    def test_phase_value(self) -> None:
+        self.assertEqual(Synchronization.PHASE, "Phase")
+
+    def test_none_value(self) -> None:
+        self.assertEqual(Synchronization.NONE, "None")
+
+
+class TestDurationDiscretizationEnum(unittest.TestCase):
+    def test_continuous_value(self) -> None:
+        self.assertEqual(DurationDiscretization.CONTINUOUS, "Continuous")
+
+    def test_discrete_value(self) -> None:
+        self.assertEqual(DurationDiscretization.DISCRETE, "Discrete")
+
+
+class TestControlSignsEnum(unittest.TestCase):
+    def test_uddu_value(self) -> None:
+        self.assertEqual(ControlSigns.UDDU, "UDDU")
+
+    def test_udud_value(self) -> None:
+        self.assertEqual(ControlSigns.UDUD, "UDUD")
+
+
+class TestDirectionEnum(unittest.TestCase):
+    def test_up_value(self) -> None:
+        self.assertEqual(Direction.UP, "UP")
+
+    def test_down_value(self) -> None:
+        self.assertEqual(Direction.DOWN, "DOWN")
+
+
+class TestReachedLimitsEnum(unittest.TestCase):
+    def test_has_exactly_eight_members(self) -> None:
+        self.assertEqual(len(ReachedLimits), 8)
+
+    def test_member_values(self) -> None:
+        self.assertEqual(ReachedLimits.ACC0_ACC1_VEL, "ACC0_ACC1_VEL")
+        self.assertEqual(ReachedLimits.VEL, "VEL")
+        self.assertEqual(ReachedLimits.ACC0, "ACC0")
+        self.assertEqual(ReachedLimits.ACC1, "ACC1")
+        self.assertEqual(ReachedLimits.ACC0_ACC1, "ACC0_ACC1")
+        self.assertEqual(ReachedLimits.ACC0_VEL, "ACC0_VEL")
+        self.assertEqual(ReachedLimits.ACC1_VEL, "ACC1_VEL")
+        self.assertEqual(ReachedLimits.NONE, "NONE")
+
+
+class TestOtgError(unittest.TestCase):
+    def test_otg_error_subclasses_math_tools_error(self) -> None:
+        self.assertTrue(issubclass(OtgError, MathToolsError))
+
+    def test_otg_error_is_catchable_as_math_tools_error(self) -> None:
+        with self.assertRaises(MathToolsError):
+            raise OtgError("dof mismatch")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/test_input_parameter.py b/tests/otg/test_input_parameter.py
new file mode 100644
index 0000000..833fb59
--- /dev/null
+++ b/tests/otg/test_input_parameter.py
@@ -0,0 +1,314 @@
+"""Unit tests for ``math_tools.otg.input_parameter.InputParameter``.
+
+Field-for-field port of ``SWIFT_MATH/OTG/InputParameter.swift`` (validation
+logic) and ``SWIFT_MATH/OTG/extensions/InputParameter+codable.swift`` (wire
+codec). See ``.claude/specs/otg.md`` §Public API (InputParameter) and
+``.claude/action-plan/32-otg-input-parameter.md``.
+
+Deviation from the chunk's literal wording: the chunk lists "zero max jerk"
+as an invalidity class, but the Swift ``validateJerkLimits`` only rejects
+``jMax.isNaN || jMax < 0.0`` -- zero is a legal (if degenerate) jerk limit.
+The "limit positivity" check is exercised here with a *negative* max jerk,
+the actual boundary the Swift source enforces (see Resolution notes in the
+chunk file).
+"""
+
+import math
+import unittest
+
+from math_tools.otg.enums import (
+    ControlInterface,
+    DurationDiscretization,
+    Synchronization,
+)
+from math_tools.otg.input_parameter import InputParameter
+
+# Copied verbatim from spmMathTools' truthTables/successful_trajectories.json
+# (first entry), per otg.md §Oracle and test strategy.
+_TRUTH_TABLE_CASE = {
+    "degreesOfFreedom": 1,
+    "controlInterface": "Position",
+    "synchronization": "Time",
+    "durationDiscretization": "Continuous",
+    "currentPosition": [6.649087426675152],
+    "currentVelocity": [-1.7196585619659843],
+    "currentAcceleration": [-3.6835022695742996],
+    "targetPosition": [-4.632519332535045],
+    "targetVelocity": [1.9218188748830034],
+    "targetAcceleration": [5.820923498653984],
+    "maxVelocity": [2.36187254995664],
+    "maxAcceleration": [8.000641420127906],
+    "maxJerk": [13.235404890387207],
+    "intermediatePositions": [],
+    "enabled": [True],
+}
+
+
+def _valid_single_dof() -> InputParameter:
+    inp = InputParameter(1)
+    inp.current_position = [0.0]
+    inp.current_velocity = [0.0]
+    inp.current_acceleration = [0.0]
+    inp.target_position = [1.0]
+    inp.target_velocity = [0.0]
+    inp.target_acceleration = [0.0]
+    inp.max_velocity = [1.0]
+    inp.max_acceleration = [1.0]
+    inp.max_jerk = [1.0]
+    return inp
+
+
+class TestConstruction(unittest.TestCase):
+    def test_degrees_of_freedom_stored(self) -> None:
+        self.assertEqual(InputParameter(3).degrees_of_freedom, 3)
+
+    def test_zero_dofs_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            InputParameter(0)
+
+    def test_negative_dofs_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            InputParameter(-1)
+
+    def test_kinematic_state_arrays_sized_and_zeroed(self) -> None:
+        inp = InputParameter(3)
+        self.assertEqual(inp.current_position, [0.0, 0.0, 0.0])
+        self.assertEqual(inp.current_velocity, [0.0, 0.0, 0.0])
+        self.assertEqual(inp.current_acceleration, [0.0, 0.0, 0.0])
+        self.assertEqual(inp.target_position, [0.0, 0.0, 0.0])
+        self.assertEqual(inp.target_velocity, [0.0, 0.0, 0.0])
+        self.assertEqual(inp.target_acceleration, [0.0, 0.0, 0.0])
+
+    def test_max_velocity_defaults_zero(self) -> None:
+        self.assertEqual(InputParameter(2).max_velocity, [0.0, 0.0])
+
+    def test_max_acceleration_defaults_infinite(self) -> None:
+        self.assertEqual(InputParameter(2).max_acceleration, [math.inf, math.inf])
+
+    def test_max_jerk_defaults_infinite(self) -> None:
+        self.assertEqual(InputParameter(2).max_jerk, [math.inf, math.inf])
+
+    def test_enabled_defaults_true(self) -> None:
+        self.assertEqual(InputParameter(2).enabled, [True, True])
+
+    def test_control_configuration_defaults(self) -> None:
+        inp = InputParameter(1)
+        self.assertEqual(inp.control_interface, ControlInterface.POSITION)
+        self.assertEqual(inp.synchronization, Synchronization.TIME)
+        self.assertEqual(inp.duration_discretization, DurationDiscretization.CONTINUOUS)
+
+    def test_optional_fields_default_none(self) -> None:
+        inp = InputParameter(1)
+        self.assertIsNone(inp.min_velocity)
+        self.assertIsNone(inp.min_acceleration)
+        self.assertIsNone(inp.max_position)
+        self.assertIsNone(inp.min_position)
+        self.assertIsNone(inp.per_section_max_velocity)
+        self.assertIsNone(inp.per_section_max_acceleration)
+        self.assertIsNone(inp.per_section_max_jerk)
+        self.assertIsNone(inp.per_section_min_velocity)
+        self.assertIsNone(inp.per_section_min_acceleration)
+        self.assertIsNone(inp.per_section_max_position)
+        self.assertIsNone(inp.per_section_min_position)
+        self.assertIsNone(inp.per_dof_control_interface)
+        self.assertIsNone(inp.per_dof_synchronization)
+        self.assertIsNone(inp.minimum_duration)
+        self.assertIsNone(inp.per_section_minimum_duration)
+        self.assertIsNone(inp.interrupt_calculation_duration)
+
+    def test_intermediate_positions_defaults_empty(self) -> None:
+        self.assertEqual(InputParameter(1).intermediate_positions, [])
+
+
+class TestValidate(unittest.TestCase):
+    def test_valid_input_validates(self) -> None:
+        self.assertTrue(_valid_single_dof().validate())
+
+    def test_negative_max_jerk_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.max_jerk = [-1.0]
+        self.assertFalse(inp.validate())
+
+    def test_zero_max_jerk_is_legal(self) -> None:
+        # Swift's validateJerkLimits only rejects NaN or < 0.0; zero is legal.
+        inp = _valid_single_dof()
+        inp.max_jerk = [0.0]
+        self.assertTrue(inp.validate())
+
+    def test_nan_max_jerk_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.max_jerk = [math.nan]
+        self.assertFalse(inp.validate())
+
+    def test_negative_max_acceleration_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.max_acceleration = [-1.0]
+        self.assertFalse(inp.validate())
+
+    def test_positive_min_acceleration_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.min_acceleration = [1.0]
+        self.assertFalse(inp.validate())
+
+    def test_nan_current_acceleration_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.current_acceleration = [math.nan]
+        self.assertFalse(inp.validate())
+
+    def test_nan_target_acceleration_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.target_acceleration = [math.nan]
+        self.assertFalse(inp.validate())
+
+    def test_negative_max_velocity_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.max_velocity = [-1.0]
+        self.assertFalse(inp.validate())
+
+    def test_positive_min_velocity_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.min_velocity = [1.0]
+        self.assertFalse(inp.validate())
+
+    def test_target_velocity_over_limit_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.target_velocity = [2.0]  # max_velocity is 1.0
+        self.assertFalse(inp.validate(check_target_state_within_limits=True))
+        self.assertFalse(inp.validate())
+
+    def test_nan_target_velocity_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.target_velocity = [math.nan]
+        self.assertFalse(inp.validate())
+
+    def test_current_state_out_of_limits_ignored_by_default(self) -> None:
+        inp = _valid_single_dof()
+        inp.current_velocity = [5.0]  # exceeds max_velocity of 1.0
+        self.assertTrue(inp.validate())
+
+    def test_current_state_out_of_limits_checked_when_requested(self) -> None:
+        inp = _valid_single_dof()
+        inp.current_velocity = [5.0]
+        self.assertFalse(inp.validate(check_current_state_within_limits=True))
+
+    def test_velocity_check_skipped_for_velocity_control_interface(self) -> None:
+        inp = _valid_single_dof()
+        inp.control_interface = ControlInterface.VELOCITY
+        inp.target_velocity = [1000.0]  # would exceed max_velocity under Position
+        self.assertTrue(inp.validate())
+
+    def test_nan_current_position_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.current_position = [math.nan]
+        self.assertFalse(inp.validate())
+
+    def test_nan_target_position_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.target_position = [math.nan]
+        self.assertFalse(inp.validate())
+
+    def test_intermediate_positions_with_minimum_duration_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.intermediate_positions = [[0.5]]
+        inp.minimum_duration = 1.0
+        self.assertFalse(inp.validate())
+
+    def test_intermediate_positions_with_discrete_duration_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.intermediate_positions = [[0.5]]
+        inp.duration_discretization = DurationDiscretization.DISCRETE
+        self.assertFalse(inp.validate())
+
+    def test_intermediate_positions_with_per_dof_control_interface_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.intermediate_positions = [[0.5]]
+        inp.per_dof_control_interface = [ControlInterface.POSITION]
+        self.assertFalse(inp.validate())
+
+    def test_intermediate_positions_with_per_dof_synchronization_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.intermediate_positions = [[0.5]]
+        inp.per_dof_synchronization = [Synchronization.TIME]
+        self.assertFalse(inp.validate())
+
+    def test_intermediate_positions_with_infinite_jerk_invalidates(self) -> None:
+        inp = _valid_single_dof()
+        inp.intermediate_positions = [[0.5]]
+        inp.max_jerk = [math.inf]
+        self.assertFalse(inp.validate())
+
+    def test_intermediate_positions_otherwise_valid(self) -> None:
+        inp = _valid_single_dof()
+        inp.intermediate_positions = [[0.5]]
+        self.assertTrue(inp.validate())
+
+
+class TestEquality(unittest.TestCase):
+    def test_equal_when_all_fields_match(self) -> None:
+        self.assertEqual(_valid_single_dof(), _valid_single_dof())
+
+    def test_not_equal_when_a_field_differs(self) -> None:
+        a = _valid_single_dof()
+        b = _valid_single_dof()
+        b.target_position = [2.0]
+        self.assertNotEqual(a, b)
+
+    def test_not_equal_to_other_type(self) -> None:
+        self.assertNotEqual(_valid_single_dof(), object())
+
+
+class TestCodec(unittest.TestCase):
+    def test_from_dict_parses_truth_table_case(self) -> None:
+        inp = InputParameter.from_dict(_TRUTH_TABLE_CASE)
+        self.assertEqual(inp.degrees_of_freedom, 1)
+        self.assertEqual(inp.control_interface, ControlInterface.POSITION)
+        self.assertEqual(inp.current_position, [6.649087426675152])
+        self.assertEqual(inp.max_jerk, [13.235404890387207])
+        self.assertEqual(inp.enabled, [True])
+
+    def test_round_trip_truth_table_case(self) -> None:
+        inp = InputParameter.from_dict(_TRUTH_TABLE_CASE)
+        self.assertEqual(inp.to_dict(), _TRUTH_TABLE_CASE)
+
+    def test_round_trip_with_optional_fields(self) -> None:
+        inp = _valid_single_dof()
+        inp.min_velocity = [-2.0]
+        inp.min_acceleration = [-3.0]
+        inp.max_position = [10.0]
+        inp.min_position = [-10.0]
+        inp.per_section_max_velocity = [[1.0], [2.0]]
+        inp.per_dof_control_interface = [ControlInterface.POSITION]
+        inp.per_dof_synchronization = [Synchronization.PHASE]
+        inp.minimum_duration = 5.0
+        inp.per_section_minimum_duration = [1.0, 2.0]
+        inp.interrupt_calculation_duration = 0.5
+
+        round_tripped = InputParameter.from_dict(inp.to_dict())
+        self.assertEqual(inp, round_tripped)
+        self.assertEqual(
+            round_tripped.interrupt_calculation_duration,
+            0.5,
+        )
+
+    def test_to_dict_omits_none_optional_fields(self) -> None:
+        data = _valid_single_dof().to_dict()
+        self.assertNotIn("minVelocity", data)
+        self.assertNotIn("minAcceleration", data)
+        self.assertNotIn("maxPosition", data)
+        self.assertNotIn("minPosition", data)
+        self.assertNotIn("perSectionMaxVelocity", data)
+        self.assertNotIn("perDofControlInterface", data)
+        self.assertNotIn("perDofSynchronization", data)
+        self.assertNotIn("minimumDuration", data)
+        self.assertNotIn("perSectionMinimumDuration", data)
+        self.assertNotIn("interruptCalculationDuration", data)
+
+    def test_from_dict_ignores_unknown_keys(self) -> None:
+        data = dict(_TRUTH_TABLE_CASE)
+        data["error"] = "\n[ruckig] target velocity exceeds its maximum velocity limit."
+        inp = InputParameter.from_dict(data)
+        self.assertEqual(inp.degrees_of_freedom, 1)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/test_otg_comprehensive.py b/tests/otg/test_otg_comprehensive.py
new file mode 100644
index 0000000..5052903
--- /dev/null
+++ b/tests/otg/test_otg_comprehensive.py
@@ -0,0 +1,216 @@
+"""Comprehensive trajectory validation suite.
+
+Port of ``SWIFT_TESTS/OTGTests/OTGComprehensiveTests.swift``. See
+``.claude/specs/otg.md`` §Oracle and test strategy 3 and
+``.claude/action-plan/42-otg-oracle-suites.md``'s design constraint 4
+("port ... case-for-case; skip Swift cases that only test Swift-specific
+machinery; list every skip with a reason").
+
+**Ported (5 cases):** the "Bug Fix Tests" section (``testBugFix_*``), which
+asserts unconditional success plus the file's own ``validateTrajectory``
+helper (no negative time intervals, acceleration/velocity limits held
+throughout a 100-sample sweep, AND the final state matches the target
+within 0.01) -- strictly stronger than ``test_otg_failure_fixes.py``'s port
+of the same inputs from ``OTGFailureFixTests.swift`` (which only checks
+limits, not target-reached, and does so under the "may legitimately fail"
+contract). Both ports are kept: they assert different things about the
+same inputs, matching the two Swift source files' own duplication.
+
+**Chunk 56 correction (post-audit finding E-11).** The Swift source's "Bug
+Fix Tests" section defines 5 ``testBugFix_*`` cases, not 4:
+``testBugFix_NegativeTimeInterval_Case3`` was missing from this port (this
+docstring previously claimed "all 4" were ported, as did
+``.claude/action-plan/42-otg-oracle-suites.md``'s Resolution notes -- both
+corrected by this chunk). It matters beyond a count: the only prior port of
+that exact input (``test_otg_failure_fixes.py``'s ``test_case_3_...``) wraps
+every assertion in ``if result >= 0:``, so a regression to an error
+``Result`` would silently assert nothing there, whereas
+``TestBugFixNegativeTimeInterval.test_case_3`` below asserts unconditional
+success, closing that gap.
+
+**Skipped (5 cases), with reasons -- not "Swift-specific machinery" in the
+literal sense, but exact-data duplicates of suites this same chunk already
+lands, per Decision Framework "Define once, reference everywhere" /
+stay-in-scope's minimum-diff default:**
+
+- ``testTruthTable`` (3 cases: Swift's local ``TruthTableData.testCases``,
+  itself a copy-pasted subset -- cases 1, 2, and 24 -- of the full 31-case
+  array in ``OTGTruthTableTests.swift``): the full 31-case table is already
+  transcribed verbatim into ``tests/otg/data/otg_numeric_truth.json`` and
+  asserted by ``test_otg_truth_table.py::TestNumericTruthTable`` with a
+  *tighter* tolerance (duration rtol 1e-6, segment atol 1e-6, vs. this
+  Swift file's 0.001 accuracy on both) -- re-asserting the same 3 inputs
+  here with a looser bound would add no coverage.
+- ``testSuccessfulTrajectoriesFromJSON`` /
+  ``testFailedTrajectoriesFromJSON``: load the exact same
+  ``successful_trajectories.json`` / ``failed_trajectories.json`` files
+  copied byte-for-byte into ``tests/otg/data/`` by this same chunk, and
+  assert exactly the classify-only contract (non-error vs. error
+  ``Result``) that ``test_otg_truth_table.py``'s
+  ``TestClassificationCorpus*`` classes already assert over the identical
+  data.
+"""
+
+from __future__ import annotations
+
+import unittest
+
+from math_tools.otg.input_parameter import InputParameter
+from math_tools.otg.otg import Otg
+from math_tools.otg.output_parameter import OutputParameter
+from math_tools.otg.trajectory import Trajectory
+
+_CONTROL_CYCLE = 0.01
+_LIMIT_TOLERANCE = 0.001
+_TARGET_TOLERANCE = 0.01
+_SAMPLE_COUNT = 100
+
+
+def _calculate(inp: InputParameter) -> tuple[int, OutputParameter]:
+    otg = Otg(_CONTROL_CYCLE, dofs=inp.degrees_of_freedom)
+    output = OutputParameter(dofs=inp.degrees_of_freedom)
+    result = otg.calculate(inp, output)
+    return int(result), output
+
+
+def _validate_trajectory(
+    test: unittest.TestCase, trajectory: Trajectory, inp: InputParameter
+) -> None:
+    """``validateTrajectory`` -- no negative time intervals, acceleration
+    and velocity limits held throughout, and the final sampled state
+    matches the target."""
+    profile = trajectory.profiles[0][0]
+    for i in range(7):
+        test.assertGreaterEqual(
+            profile.t[i], 0.0, f"time interval t[{i}] must be non-negative, got {profile.t[i]}"
+        )
+
+    duration = trajectory.duration
+    dt = duration / _SAMPLE_COUNT
+    for i in range(_SAMPLE_COUNT + 1):
+        t = i * dt
+        _p, v, a = trajectory.at_time(t)
+        test.assertLessEqual(
+            abs(a[0]),
+            inp.max_acceleration[0] + _LIMIT_TOLERANCE,
+            f"acceleration {abs(a[0])} exceeds limit {inp.max_acceleration[0]} at t={t}",
+        )
+        test.assertLessEqual(
+            abs(v[0]),
+            inp.max_velocity[0] + _LIMIT_TOLERANCE,
+            f"velocity {abs(v[0])} exceeds limit {inp.max_velocity[0]} at t={t}",
+        )
+
+    final_p, final_v, final_a = trajectory.at_time(duration)
+    test.assertAlmostEqual(final_p[0], inp.target_position[0], delta=_TARGET_TOLERANCE)
+    test.assertAlmostEqual(final_v[0], inp.target_velocity[0], delta=_TARGET_TOLERANCE)
+    test.assertAlmostEqual(final_a[0], inp.target_acceleration[0], delta=_TARGET_TOLERANCE)
+
+
+class TestBugFixAccelerationLimit(unittest.TestCase):
+    """``testBugFix_AccelerationLimit_Case{1,2}`` -- must succeed (no
+    "may legitimately fail" escape hatch, unlike the failure-fix port),
+    and the full ``validateTrajectory`` contract must hold."""
+
+    def test_case_1(self) -> None:
+        inp = InputParameter(1)
+        inp.current_position = [-6.139891324284666]
+        inp.current_velocity = [0.0]
+        inp.current_acceleration = [0.0]
+        inp.target_position = [10.0]
+        inp.target_velocity = [-2.9531593910491565]
+        inp.target_acceleration = [0.0]
+        inp.max_velocity = [4.0]
+        inp.max_acceleration = [1.9425898752751283]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        self.assertGreaterEqual(result, 0, f"expected trajectory to succeed, got {result!r}")
+        _validate_trajectory(self, output.trajectory, inp)
+
+    def test_case_2(self) -> None:
+        inp = InputParameter(1)
+        inp.current_position = [-6.139891324284666]
+        inp.current_velocity = [0.0]
+        inp.current_acceleration = [0.0]
+        inp.target_position = [10.0]
+        inp.target_velocity = [1.345062591709465]
+        inp.target_acceleration = [0.0]
+        inp.max_velocity = [4.0]
+        inp.max_acceleration = [5.0]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        self.assertGreaterEqual(result, 0, f"expected trajectory to succeed, got {result!r}")
+        _validate_trajectory(self, output.trajectory, inp)
+
+
+class TestBugFixNegativeTimeInterval(unittest.TestCase):
+    """``testBugFix_NegativeTimeInterval_Case{1,2}`` -- same inputs as
+    ``test_otg_failure_fixes.py``'s ``TestNegativeTimeIntervalWithHighLimits``
+    cases 2 and 1 respectively, but here the Swift source asserts
+    unconditional success (no legitimate-failure escape hatch) plus the
+    full ``validateTrajectory`` contract."""
+
+    def test_case_1(self) -> None:
+        inp = InputParameter(1)
+        inp.current_position = [-2.2569699192956714]
+        inp.current_velocity = [0.6924924339691851]
+        inp.current_acceleration = [0.6756694790902418]
+        inp.target_position = [6.790054108584006]
+        inp.target_velocity = [-1.159379585473221]
+        inp.target_acceleration = [-1.2629539618488628]
+        inp.max_velocity = [10.0]
+        inp.max_acceleration = [10.0]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        self.assertGreaterEqual(result, 0, f"expected trajectory to succeed, got {result!r}")
+        _validate_trajectory(self, output.trajectory, inp)
+
+    def test_case_2(self) -> None:
+        inp = InputParameter(1)
+        inp.current_position = [2.6603799559471364]
+        inp.current_velocity = [1.9695301027900147]
+        inp.current_acceleration = [1.972541529001468]
+        inp.target_position = [-6.297064289647577]
+        inp.target_velocity = [-1.5414200165198237]
+        inp.target_acceleration = [-1.5255311582232012]
+        inp.max_velocity = [9.088312224669604]
+        inp.max_acceleration = [9.973774779735683]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        self.assertGreaterEqual(result, 0, f"expected trajectory to succeed, got {result!r}")
+        _validate_trajectory(self, output.trajectory, inp)
+
+    def test_case_3(self) -> None:
+        """``testBugFix_NegativeTimeInterval_Case3`` -- same input as
+        ``test_case_2`` but with a different (lower) ``max_velocity``. Same
+        input as ``test_otg_failure_fixes.py``'s
+        ``test_case_3_previously_produced_negative_t5_different_max_vel``,
+        but here unconditional success plus the full ``validateTrajectory``
+        contract are required (post-audit finding E-11)."""
+        inp = InputParameter(1)
+        inp.current_position = [2.6603799559471364]
+        inp.current_velocity = [1.9695301027900147]
+        inp.current_acceleration = [1.972541529001468]
+        inp.target_position = [-6.297064289647577]
+        inp.target_velocity = [-1.5414200165198237]
+        inp.target_acceleration = [-1.5255311582232012]
+        inp.max_velocity = [6.282291093061675]
+        inp.max_acceleration = [9.973774779735683]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        self.assertGreaterEqual(result, 0, f"expected trajectory to succeed, got {result!r}")
+        _validate_trajectory(self, output.trajectory, inp)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/test_otg_continuity.py b/tests/otg/test_otg_continuity.py
new file mode 100644
index 0000000..1a99869
--- /dev/null
+++ b/tests/otg/test_otg_continuity.py
@@ -0,0 +1,334 @@
+"""Continuity tests: no kinematic discontinuities at profile boundaries.
+
+Port of ``SWIFT_TESTS/OTGTests/OTGContinuityTests.swift`` (all 5 cases,
+test-for-test -- none are Swift-specific machinery). See
+``.claude/specs/otg.md`` §Oracle and test strategy 3, §Compliance 2, and
+``.claude/action-plan/42-otg-oracle-suites.md``'s design constraint 3.
+
+``_check_trajectory_continuity`` ports the Swift ``checkTrajectoryContinuity``
+helper: integrate forward across each of the profile's 7 segment boundaries
+using its own ``(t, j)`` and compare against the profile's own stored
+``p``/``v``/``a`` at that boundary. Both use the same closed-form
+constant-jerk integration (``integrate_jerk``), so this is a self-consistency
+check on the profile's internal bookkeeping, not a comparison against an
+external oracle -- exactly the Swift test's intent.
+
+**Chunk 56 addition (post-audit finding E-7).** The 5 classes above only
+call ``Otg.calculate`` once each and never cross a section boundary --
+a self-consistency check on one profile's own bookkeeping, not a check of
+continuity *across* real ``update()`` control cycles including the section
+transition ``OutputParameter.did_section_change`` flags. ``TestUpdateCycleContinuity``
+below drives a real ``update()`` control loop to completion and asserts
+continuity at every cycle boundary, including the one genuine section
+transition a single-section (no-waypoint) trajectory has: the cycle where
+``output.time`` first crosses ``trajectory.duration`` and
+``Trajectory._state_to_integrate_from`` switches from section 0 to the
+"past the last section" branch (``new_section = len(self.profiles) == 1``),
+which is exactly the cycle ``did_section_change`` flips ``True`` and
+``update()`` returns ``FINISHED``.
+"""
+
+from __future__ import annotations
+
+import unittest
+
+from math_tools.functional.roots import integrate_jerk
+from math_tools.otg.enums import Result
+from math_tools.otg.input_parameter import InputParameter
+from math_tools.otg.otg import Otg
+from math_tools.otg.output_parameter import OutputParameter
+from math_tools.otg.trajectory import Trajectory
+
+_CONTROL_CYCLE = 0.01
+_CONTINUITY_TOLERANCE = 1e-6
+_BOUNDARY_TOLERANCE = 1e-6
+
+_UPDATE_V_MAX = 2.0
+_UPDATE_A_MAX = 1.0
+_UPDATE_J_MAX = 1.0
+_UPDATE_CONTROL_CYCLE = 0.1
+_UPDATE_TARGET = 2.0
+
+
+def _check_trajectory_continuity(
+    trajectory: Trajectory, dof: int = 0, tolerance: float = _CONTINUITY_TOLERANCE
+) -> bool:
+    """``checkTrajectoryContinuity`` -- integrating from each profile
+    boundary's own stored state must reproduce the next boundary's stored
+    state, for all 7 segments."""
+    if not trajectory.profiles or len(trajectory.profiles[0]) <= dof:
+        return False
+
+    profile = trajectory.profiles[0][dof]
+
+    previous_p = profile.p[0]
+    previous_v = profile.v[0]
+    previous_a = profile.a[0]
+
+    for i in range(1, 8):
+        current_p = profile.p[i]
+        current_v = profile.v[i]
+        current_a = profile.a[i]
+
+        t = profile.t[i - 1]
+        j = profile.j[i - 1]
+        integrated_p, integrated_v, integrated_a = integrate_jerk(
+            t, previous_p, previous_v, previous_a, j
+        )
+
+        if abs(integrated_p - current_p) > tolerance:
+            return False
+        if abs(integrated_v - current_v) > tolerance:
+            return False
+        if abs(integrated_a - current_a) > tolerance:
+            return False
+
+        previous_p = current_p
+        previous_v = current_v
+        previous_a = current_a
+
+    return True
+
+
+def _calculate(inp: InputParameter) -> tuple[Result, OutputParameter]:
+    otg = Otg(_CONTROL_CYCLE, dofs=inp.degrees_of_freedom)
+    output = OutputParameter(dofs=inp.degrees_of_freedom)
+    result = otg.calculate(inp, output)
+    return result, output
+
+
+class TestNonZeroVelocityBoundaryConditions(unittest.TestCase):
+    def test_continuous_with_nonzero_start_and_end_velocity(self) -> None:
+        inp = InputParameter(1)
+        inp.current_position = [2.929012715930903]
+        inp.current_velocity = [1.3368222168905952]
+        inp.current_acceleration = [0.0]
+        inp.target_position = [10.0]
+        inp.target_velocity = [-1.3503178982725528]
+        inp.target_acceleration = [0.0]
+        inp.max_velocity = [4.0]
+        inp.max_acceleration = [5.0]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        self.assertGreaterEqual(result, 0, f"calculation should succeed, got {result!r}")
+        self.assertTrue(
+            _check_trajectory_continuity(output.trajectory), "trajectory must be continuous"
+        )
+
+        start_p, start_v, start_a = output.trajectory.at_time(0.0)
+        self.assertAlmostEqual(start_p[0], inp.current_position[0], delta=_BOUNDARY_TOLERANCE)
+        self.assertAlmostEqual(start_v[0], inp.current_velocity[0], delta=_BOUNDARY_TOLERANCE)
+        self.assertAlmostEqual(start_a[0], inp.current_acceleration[0], delta=_BOUNDARY_TOLERANCE)
+
+        end_p, end_v, end_a = output.trajectory.at_time(output.trajectory.duration)
+        self.assertAlmostEqual(end_p[0], inp.target_position[0], delta=_BOUNDARY_TOLERANCE)
+        self.assertAlmostEqual(end_v[0], inp.target_velocity[0], delta=_BOUNDARY_TOLERANCE)
+        self.assertAlmostEqual(end_a[0], inp.target_acceleration[0], delta=_BOUNDARY_TOLERANCE)
+
+
+class TestNonZeroAccelerationBoundaryConditions(unittest.TestCase):
+    def test_continuous_with_nonzero_start_and_end_acceleration(self) -> None:
+        inp = InputParameter(1)
+        inp.current_position = [0.0]
+        inp.current_velocity = [0.0]
+        inp.current_acceleration = [-1.5686480326295587]
+        inp.target_position = [10.0]
+        inp.target_velocity = [0.0]
+        inp.target_acceleration = [2.3736654270633393]
+        inp.max_velocity = [4.0]
+        inp.max_acceleration = [5.0]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        self.assertGreaterEqual(result, 0, f"calculation should succeed, got {result!r}")
+        self.assertTrue(
+            _check_trajectory_continuity(output.trajectory), "trajectory must be continuous"
+        )
+
+        start_p, start_v, start_a = output.trajectory.at_time(0.0)
+        self.assertAlmostEqual(start_p[0], inp.current_position[0], delta=_BOUNDARY_TOLERANCE)
+        self.assertAlmostEqual(start_v[0], inp.current_velocity[0], delta=_BOUNDARY_TOLERANCE)
+        self.assertAlmostEqual(start_a[0], inp.current_acceleration[0], delta=_BOUNDARY_TOLERANCE)
+
+        end_p, end_v, end_a = output.trajectory.at_time(output.trajectory.duration)
+        self.assertAlmostEqual(end_p[0], inp.target_position[0], delta=_BOUNDARY_TOLERANCE)
+        self.assertAlmostEqual(end_v[0], inp.target_velocity[0], delta=_BOUNDARY_TOLERANCE)
+        self.assertAlmostEqual(end_a[0], inp.target_acceleration[0], delta=_BOUNDARY_TOLERANCE)
+
+
+class TestInvertedBoundaryConditions(unittest.TestCase):
+    def test_continuous_with_inverted_start_and_target(self) -> None:
+        inp = InputParameter(1)
+        inp.current_position = [7.1647072936660265]
+        inp.current_velocity = [-1.5912907869481767]
+        inp.current_acceleration = [1.2187350047984646]
+        inp.target_position = [-0.1964371401151649]
+        inp.target_velocity = [1.8250659788867563]
+        inp.target_acceleration = [-1.9871641074856043]
+        inp.max_velocity = [4.0]
+        inp.max_acceleration = [5.0]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        self.assertGreaterEqual(result, 0, f"calculation should succeed, got {result!r}")
+        self.assertTrue(
+            _check_trajectory_continuity(output.trajectory), "trajectory must be continuous"
+        )
+
+        start_p, start_v, start_a = output.trajectory.at_time(0.0)
+        self.assertAlmostEqual(start_p[0], inp.current_position[0], delta=_BOUNDARY_TOLERANCE)
+        self.assertAlmostEqual(start_v[0], inp.current_velocity[0], delta=_BOUNDARY_TOLERANCE)
+        self.assertAlmostEqual(start_a[0], inp.current_acceleration[0], delta=_BOUNDARY_TOLERANCE)
+
+        end_p, end_v, end_a = output.trajectory.at_time(output.trajectory.duration)
+        self.assertAlmostEqual(end_p[0], inp.target_position[0], delta=_BOUNDARY_TOLERANCE)
+        self.assertAlmostEqual(end_v[0], inp.target_velocity[0], delta=_BOUNDARY_TOLERANCE)
+        self.assertAlmostEqual(end_a[0], inp.target_acceleration[0], delta=_BOUNDARY_TOLERANCE)
+
+
+class TestZeroTargetBoundaryConditions(unittest.TestCase):
+    def test_continuous_with_zero_target_conditions(self) -> None:
+        inp = InputParameter(1)
+        inp.current_position = [2.5]
+        inp.current_velocity = [1.2]
+        inp.current_acceleration = [-0.8]
+        inp.target_position = [10.0]
+        inp.target_velocity = [0.0]
+        inp.target_acceleration = [0.0]
+        inp.max_velocity = [4.0]
+        inp.max_acceleration = [5.0]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        self.assertGreaterEqual(result, 0, f"calculation should succeed, got {result!r}")
+        self.assertTrue(
+            _check_trajectory_continuity(output.trajectory), "trajectory must be continuous"
+        )
+
+
+class TestZeroInitialBoundaryConditions(unittest.TestCase):
+    def test_continuous_with_zero_initial_conditions(self) -> None:
+        inp = InputParameter(1)
+        inp.current_position = [0.0]
+        inp.current_velocity = [0.0]
+        inp.current_acceleration = [0.0]
+        inp.target_position = [10.0]
+        inp.target_velocity = [1.5]
+        inp.target_acceleration = [-2.0]
+        inp.max_velocity = [4.0]
+        inp.max_acceleration = [5.0]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        self.assertGreaterEqual(result, 0, f"calculation should succeed, got {result!r}")
+        self.assertTrue(
+            _check_trajectory_continuity(output.trajectory), "trajectory must be continuous"
+        )
+
+
+class TestUpdateCycleContinuity(unittest.TestCase):
+    """Post-audit E-7: continuity across real ``Otg.update()`` control
+    cycles, including the ``did_section_change`` transition."""
+
+    def test_continuous_across_update_cycles_including_section_change(self) -> None:
+        otg = Otg(_UPDATE_CONTROL_CYCLE, dofs=1)
+        inp = InputParameter(1)
+        inp.target_position = [_UPDATE_TARGET]
+        inp.max_velocity = [_UPDATE_V_MAX]
+        inp.min_velocity = [-_UPDATE_V_MAX]
+        inp.max_acceleration = [_UPDATE_A_MAX]
+        inp.min_acceleration = [-_UPDATE_A_MAX]
+        inp.max_jerk = [_UPDATE_J_MAX]
+        output = OutputParameter(dofs=1)
+
+        max_calls = 1000
+        calls = 0
+        result = Result.WORKING
+        section_change_cycles: list[int] = []
+        previous_state: tuple[float, float, float] | None = None
+
+        while result != Result.FINISHED:
+            calls += 1
+            self.assertLessEqual(calls, max_calls, "did not reach FINISHED within bound")
+
+            result = otg.update(inp, output)
+            self.assertGreaterEqual(result, 0, f"update() returned an error on call {calls}")
+
+            if output.did_section_change:
+                section_change_cycles.append(calls)
+
+            # A fresh, independent at_time() query at this cycle's time
+            # must reproduce update()'s own sampled state -- on every
+            # cycle, including the section-change cycle (this is the
+            # continuity check: at_time uses a different branch of
+            # Trajectory._state_to_integrate_from once time >= duration).
+            expected_p, expected_v, expected_a = output.trajectory.at_time(output.time)
+            self.assertAlmostEqual(
+                output.new_position[0], expected_p[0], delta=1e-9, msg=f"call {calls} position"
+            )
+            self.assertAlmostEqual(
+                output.new_velocity[0], expected_v[0], delta=1e-9, msg=f"call {calls} velocity"
+            )
+            self.assertAlmostEqual(
+                output.new_acceleration[0],
+                expected_a[0],
+                delta=1e-9,
+                msg=f"call {calls} acceleration",
+            )
+
+            # Cross-cycle continuity: the state must not jump beyond what
+            # one control cycle of bounded jerk/acceleration/velocity can
+            # produce -- generous bounds (a few control cycles' worth),
+            # not tight kinematic integration, since this is a
+            # discontinuity smoke check, not a duplicate of the numeric
+            # oracle.
+            current_state = (
+                output.new_position[0],
+                output.new_velocity[0],
+                output.new_acceleration[0],
+            )
+            if previous_state is not None:
+                prev_p, prev_v, prev_a = previous_state
+                self.assertLessEqual(
+                    abs(current_state[0] - prev_p),
+                    (_UPDATE_V_MAX + 1.0) * _UPDATE_CONTROL_CYCLE,
+                    f"call {calls}: position jump too large across cycle boundary",
+                )
+                self.assertLessEqual(
+                    abs(current_state[1] - prev_v),
+                    (_UPDATE_A_MAX + 1.0) * _UPDATE_CONTROL_CYCLE,
+                    f"call {calls}: velocity jump too large across cycle boundary",
+                )
+                self.assertLessEqual(
+                    abs(current_state[2] - prev_a),
+                    (_UPDATE_J_MAX + 1.0) * _UPDATE_CONTROL_CYCLE,
+                    f"call {calls}: acceleration jump too large across cycle boundary",
+                )
+            previous_state = current_state
+
+            output.pass_to_input(inp)
+
+        self.assertEqual(result, Result.FINISHED)
+        # A single-section (no-waypoint) trajectory has exactly one real
+        # section transition: section 0 -> "past the last section", which
+        # coincides with the FINISHED cycle.
+        self.assertEqual(
+            section_change_cycles,
+            [calls],
+            "expected exactly one did_section_change transition, on the FINISHED cycle",
+        )
+
+        # The transition itself must land exactly on the target state.
+        self.assertAlmostEqual(output.new_position[0], _UPDATE_TARGET, delta=1e-6)
+        self.assertAlmostEqual(output.new_velocity[0], 0.0, delta=1e-6)
+        self.assertAlmostEqual(output.new_acceleration[0], 0.0, delta=1e-6)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/test_otg_driver.py b/tests/otg/test_otg_driver.py
new file mode 100644
index 0000000..524762d
--- /dev/null
+++ b/tests/otg/test_otg_driver.py
@@ -0,0 +1,297 @@
+"""Unit tests for ``math_tools.otg.otg.Otg``.
+
+See ``.claude/specs/otg.md`` §Public API (Otg), §Error semantics,
+§Compliance 5 and ``.claude/action-plan/41-otg-driver.md``'s TDD steps: a
+1-DOF rest-to-rest move driven via repeated ``update`` reaches ``FINISHED``
+within ``duration/control_cycle + 2`` calls; ``output.new_position`` at each
+cycle matches ``trajectory.at_time(output.time)``; invalid input returns
+``ERROR_INVALID_INPUT`` without raising; a DOF mismatch raises ``OtgError``;
+``pass_to_input`` + ``update`` chaining is stable (``new_calculation`` is
+``False`` once the input stops changing).
+
+Limits (``v_max=2, a_max=1, j_max=1``) and the closed-form rest-to-rest
+optimal duration formula reuse chunk 40's ``test_calculator_target.py``
+convention, scaled to a short move (target distance 2.0) so the
+control-loop test converges in ~40 cycles instead of thousands.
+
+**Chunk 56 addition (post-audit finding E-8).** ``TestMidTrajectoryRetarget``
+pins a genuine mid-flight retarget (changing ``inp.target_position`` partway
+through an in-progress move), which no existing test drove: the closest
+case, ``TestUpdateLoopReachesFinishedWithinBound``, only asserts the
+*absence* of recalculation under an unchanging input.
+"""
+
+import math
+import unittest
+
+from math_tools.otg import ControlInterface, InputParameter, Otg, OtgError, OutputParameter, Result
+
+_V_MAX = 2.0
+_A_MAX = 1.0
+_J_MAX = 1.0
+_CONTROL_CYCLE = 0.1
+_TARGET = 2.0
+
+
+def _rest_to_rest_optimal_duration(pd: float) -> float:
+    """Closed-form time-optimal duration for a rest-to-rest move of
+    distance ``pd`` under ``_V_MAX``/``_A_MAX``/``_J_MAX`` (chunk 38/40's
+    ``pd / v_max + v_max / a_max + a_max / j_max``)."""
+    return pd / _V_MAX + _V_MAX / _A_MAX + _A_MAX / _J_MAX
+
+
+def _rest_to_rest_input(dofs: int = 1, target: float = _TARGET) -> InputParameter:
+    inp = InputParameter(dofs)
+    inp.target_position = [target] * dofs
+    inp.max_velocity = [_V_MAX] * dofs
+    inp.min_velocity = [-_V_MAX] * dofs
+    inp.max_acceleration = [_A_MAX] * dofs
+    inp.min_acceleration = [-_A_MAX] * dofs
+    inp.max_jerk = [_J_MAX] * dofs
+    return inp
+
+
+class TestUpdateLoopReachesFinishedWithinBound(unittest.TestCase):
+    """(1)+(2)+(5) drive a 1-DOF rest-to-rest move to completion, checking
+    the FINISHED-within-bound invariant, per-cycle sampling consistency
+    against ``trajectory.at_time``, and stable ``new_calculation`` chaining
+    -- all in one control loop, since they describe the same drive."""
+
+    def test_reaches_finished_within_bound_with_consistent_sampling(self) -> None:
+        otg = Otg(_CONTROL_CYCLE, dofs=1)
+        inp = _rest_to_rest_input()
+        output = OutputParameter(dofs=1)
+
+        expected_duration = _rest_to_rest_optimal_duration(_TARGET)
+        max_calls = math.ceil(expected_duration / _CONTROL_CYCLE) + 2
+
+        results = []
+        calls = 0
+        result = Result.WORKING
+        while result != Result.FINISHED:
+            calls += 1
+            self.assertLessEqual(calls, max_calls, "did not reach FINISHED within bound")
+
+            result = otg.update(inp, output)
+            self.assertNotIn(
+                result,
+                (
+                    Result.ERROR,
+                    Result.ERROR_INVALID_INPUT,
+                    Result.ERROR_TRAJECTORY_DURATION,
+                    Result.ERROR_ZERO_LIMITS,
+                    Result.ERROR_EXECUTION_TIME_CALCULATION,
+                    Result.ERROR_SYNCHRONIZATION_CALCULATION,
+                ),
+                f"update() returned an error Result on call {calls}: {result!r}",
+            )
+            results.append((calls, result, output.new_calculation))
+
+            # (2) the just-sampled state must match a fresh independent
+            # query of the same trajectory at the same time.
+            expected_p, expected_v, expected_a = output.trajectory.at_time(output.time)
+            for dof in range(1):
+                self.assertAlmostEqual(
+                    output.new_position[dof], expected_p[dof], delta=1e-9, msg=f"call {calls}"
+                )
+                self.assertAlmostEqual(
+                    output.new_velocity[dof], expected_v[dof], delta=1e-9, msg=f"call {calls}"
+                )
+                self.assertAlmostEqual(
+                    output.new_acceleration[dof], expected_a[dof], delta=1e-9, msg=f"call {calls}"
+                )
+
+            output.pass_to_input(inp)
+
+        self.assertEqual(result, Result.FINISHED)
+        self.assertLessEqual(calls, max_calls)
+
+        # (5) new_calculation is True only on the first (recalculating)
+        # cycle -- every later cycle reuses the cached trajectory because
+        # pass_to_input keeps `inp` and the driver's cached input in sync.
+        first_call, _first_result, first_new_calc = results[0]
+        self.assertEqual(first_call, 1)
+        self.assertTrue(first_new_calc)
+        for call_index, _cycle_result, new_calc in results[1:]:
+            self.assertFalse(new_calc, f"call {call_index} unexpectedly recalculated")
+
+        # Final position reaches the target.
+        self.assertAlmostEqual(output.new_position[0], _TARGET, delta=1e-6)
+        self.assertAlmostEqual(output.new_velocity[0], 0.0, delta=1e-6)
+        self.assertAlmostEqual(output.new_acceleration[0], 0.0, delta=1e-6)
+
+
+class TestInvalidInputReturnsErrorWithoutRaising(unittest.TestCase):
+    """(3) an invalid input (negative max_jerk) returns
+    ``ERROR_INVALID_INPUT`` from both ``calculate`` and ``update``, never
+    raising."""
+
+    def _invalid_input(self) -> InputParameter:
+        inp = _rest_to_rest_input()
+        inp.max_jerk = [-1.0]
+        return inp
+
+    def test_calculate_returns_error_invalid_input(self) -> None:
+        otg = Otg(_CONTROL_CYCLE, dofs=1)
+        output = OutputParameter(dofs=1)
+
+        result = otg.calculate(self._invalid_input(), output)
+
+        self.assertEqual(result, Result.ERROR_INVALID_INPUT)
+
+    def test_update_returns_error_invalid_input(self) -> None:
+        otg = Otg(_CONTROL_CYCLE, dofs=1)
+        output = OutputParameter(dofs=1)
+
+        result = otg.update(self._invalid_input(), output)
+
+        self.assertEqual(result, Result.ERROR_INVALID_INPUT)
+
+    def test_too_many_intermediate_positions_returns_error_invalid_input(self) -> None:
+        otg = Otg(_CONTROL_CYCLE, dofs=1, max_number_of_waypoints=1)
+        output = OutputParameter(dofs=1, max_number_of_waypoints=1)
+        inp = _rest_to_rest_input()
+        inp.control_interface = ControlInterface.POSITION
+        inp.intermediate_positions = [[0.5], [1.0], [1.5]]  # exceeds max_number_of_waypoints=1
+
+        result = otg.calculate(inp, output)
+
+        self.assertEqual(result, Result.ERROR_INVALID_INPUT)
+
+
+class TestDegreesOfFreedomMismatchRaises(unittest.TestCase):
+    """(4) a DOF mismatch between the driver and a per-cycle parameter is
+    structural misuse -- raises ``OtgError``, not a ``Result`` code."""
+
+    def test_input_dof_mismatch_raises_on_calculate(self) -> None:
+        otg = Otg(_CONTROL_CYCLE, dofs=2)
+        inp = _rest_to_rest_input(dofs=3)
+        output = OutputParameter(dofs=2)
+
+        with self.assertRaises(OtgError):
+            otg.calculate(inp, output)
+
+    def test_input_dof_mismatch_raises_on_update(self) -> None:
+        otg = Otg(_CONTROL_CYCLE, dofs=2)
+        inp = _rest_to_rest_input(dofs=3)
+        output = OutputParameter(dofs=2)
+
+        with self.assertRaises(OtgError):
+            otg.update(inp, output)
+
+    def test_output_dof_mismatch_raises(self) -> None:
+        otg = Otg(_CONTROL_CYCLE, dofs=2)
+        inp = _rest_to_rest_input(dofs=2)
+        output = OutputParameter(dofs=3)
+
+        with self.assertRaises(OtgError):
+            otg.calculate(inp, output)
+
+
+class TestConstructorStructuralMisuse(unittest.TestCase):
+    def test_non_positive_control_cycle_raises(self) -> None:
+        with self.assertRaises(OtgError):
+            Otg(0.0, dofs=1)
+        with self.assertRaises(OtgError):
+            Otg(-0.001, dofs=1)
+
+    def test_non_positive_dofs_raises(self) -> None:
+        with self.assertRaises(OtgError):
+            Otg(_CONTROL_CYCLE, dofs=0)
+
+
+class TestReset(unittest.TestCase):
+    def test_reset_forces_recalculation_on_next_update(self) -> None:
+        otg = Otg(_CONTROL_CYCLE, dofs=1)
+        inp = _rest_to_rest_input()
+        output = OutputParameter(dofs=1)
+
+        otg.update(inp, output)
+        self.assertTrue(output.new_calculation)
+        output.pass_to_input(inp)
+
+        otg.update(inp, output)
+        self.assertFalse(output.new_calculation)
+        output.pass_to_input(inp)
+
+        otg.reset()
+        otg.update(inp, output)
+        self.assertTrue(output.new_calculation)
+
+
+class TestMidTrajectoryRetarget(unittest.TestCase):
+    """Post-audit E-8: a genuine mid-flight target change must trigger
+    exactly one extra recalculation (``new_calculation`` True again) and
+    the control loop must converge to the NEW target, not the original
+    one. Unlike ``TestUpdateLoopReachesFinishedWithinBound``, which drives
+    an unchanging input and asserts the *absence* of any later
+    recalculation, this drives a real retarget partway through a longer
+    move."""
+
+    def test_retarget_mid_flight_triggers_one_recalculation_and_converges(self) -> None:
+        otg = Otg(_CONTROL_CYCLE, dofs=1)
+        inp = _rest_to_rest_input(target=6.0)
+        output = OutputParameter(dofs=1)
+
+        retarget_cycle = 11
+        new_target = -3.0
+        max_calls = 2000
+
+        calls = 0
+        result = Result.WORKING
+        new_calculation_cycles: list[int] = []
+        retargeted = False
+        while result != Result.FINISHED:
+            calls += 1
+            self.assertLessEqual(calls, max_calls, "did not reach FINISHED within a generous bound")
+
+            if calls == retarget_cycle and not retargeted:
+                inp.target_position = [new_target]
+                retargeted = True
+
+            result = otg.update(inp, output)
+            self.assertGreaterEqual(result, 0, f"update() returned an error on call {calls}")
+            if output.new_calculation:
+                new_calculation_cycles.append(calls)
+
+            output.pass_to_input(inp)
+
+        self.assertTrue(retargeted, "test setup error: retarget never applied before FINISHED")
+        self.assertEqual(
+            new_calculation_cycles,
+            [1, retarget_cycle],
+            "expected exactly the initial calculation plus one recalculation at the retarget "
+            "cycle, no more",
+        )
+
+        self.assertAlmostEqual(output.new_position[0], new_target, delta=1e-6)
+        self.assertAlmostEqual(output.new_velocity[0], 0.0, delta=1e-6)
+        self.assertAlmostEqual(output.new_acceleration[0], 0.0, delta=1e-6)
+
+
+class TestPublicSurface(unittest.TestCase):
+    """otg.md §Compliance 5: the public surface is exactly the
+    ``__init__.py`` re-export list, nothing else."""
+
+    def test_all_matches_spec_export_list(self) -> None:
+        import math_tools.otg as otg_package
+
+        expected = {
+            "ControlInterface",
+            "DurationDiscretization",
+            "InputParameter",
+            "Otg",
+            "OtgError",
+            "OutputParameter",
+            "Profile",
+            "Result",
+            "Synchronization",
+            "Trajectory",
+        }
+        self.assertEqual(set(otg_package.__all__), expected)
+        for name in expected:
+            self.assertTrue(hasattr(otg_package, name), f"missing export: {name}")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/test_otg_failure_fixes.py b/tests/otg/test_otg_failure_fixes.py
new file mode 100644
index 0000000..18fd177
--- /dev/null
+++ b/tests/otg/test_otg_failure_fixes.py
@@ -0,0 +1,190 @@
+"""Regression tests for previously-failing trajectory inputs.
+
+Port of ``SWIFT_TESTS/OTGTests/OTGFailureFixTests.swift`` (all 5 cases,
+test-for-test -- none are Swift-specific machinery). See
+``.claude/specs/otg.md`` §Oracle and test strategy 3 and
+``.claude/action-plan/42-otg-oracle-suites.md``'s design constraint 4.
+
+Two bug categories, each ported with the Swift source's own pass/fail
+contract:
+
+- **Bug #1 (acceleration-limit violations with non-zero target velocity):**
+  the Swift test asserts the calculation succeeds (``XCTFail`` otherwise)
+  and then checks no negative time intervals and that
+  acceleration/velocity limits hold throughout the sampled trajectory.
+- **Bug #2 (negative time intervals with high limits):** the Swift test
+  does NOT require success -- a legitimate failure is acceptable, it only
+  asserts that *if* the calculation succeeds, the returned profile has no
+  negative time intervals and respects its limits (i.e. it must never
+  silently return an invalid trajectory).
+"""
+
+from __future__ import annotations
+
+import unittest
+
+from math_tools.otg.input_parameter import InputParameter
+from math_tools.otg.otg import Otg
+from math_tools.otg.output_parameter import OutputParameter
+from math_tools.otg.trajectory import Trajectory
+
+_CONTROL_CYCLE = 0.01
+_LIMIT_TOLERANCE = 0.001
+_SAMPLE_COUNT = 100
+
+
+def _calculate(inp: InputParameter) -> tuple[int, OutputParameter]:
+    otg = Otg(_CONTROL_CYCLE, dofs=inp.degrees_of_freedom)
+    output = OutputParameter(dofs=inp.degrees_of_freedom)
+    result = otg.calculate(inp, output)
+    return int(result), output
+
+
+def _assert_no_negative_time_intervals(test: unittest.TestCase, trajectory: Trajectory) -> None:
+    profile = trajectory.profiles[0][0]
+    for i in range(7):
+        test.assertGreaterEqual(
+            profile.t[i], 0.0, f"time interval t[{i}] must be non-negative, got {profile.t[i]}"
+        )
+
+
+def _assert_acceleration_limit_respected(
+    test: unittest.TestCase, trajectory: Trajectory, max_acc: float
+) -> None:
+    duration = trajectory.duration
+    dt = duration / _SAMPLE_COUNT
+    for i in range(_SAMPLE_COUNT + 1):
+        t = i * dt
+        _p, _v, a = trajectory.at_time(t)
+        test.assertLessEqual(
+            abs(a[0]),
+            max_acc + _LIMIT_TOLERANCE,
+            f"acceleration {abs(a[0])} exceeds limit {max_acc} at t={t}",
+        )
+
+
+def _assert_velocity_limit_respected(
+    test: unittest.TestCase, trajectory: Trajectory, max_vel: float
+) -> None:
+    duration = trajectory.duration
+    dt = duration / _SAMPLE_COUNT
+    for i in range(_SAMPLE_COUNT + 1):
+        t = i * dt
+        _p, v, _a = trajectory.at_time(t)
+        test.assertLessEqual(
+            abs(v[0]),
+            max_vel + _LIMIT_TOLERANCE,
+            f"velocity {abs(v[0])} exceeds limit {max_vel} at t={t}",
+        )
+
+
+class TestAccelerationLimitWithNonZeroTargetVelocity(unittest.TestCase):
+    """Bug #1: must succeed, and the resulting trajectory must respect its
+    own limits throughout."""
+
+    def test_case_1(self) -> None:
+        # target_vel=-2.95, max_acc=1.94
+        inp = InputParameter(1)
+        inp.current_position = [-6.139891324284666]
+        inp.current_velocity = [0.0]
+        inp.current_acceleration = [0.0]
+        inp.target_position = [10.0]
+        inp.target_velocity = [-2.9531593910491565]
+        inp.target_acceleration = [0.0]
+        inp.max_velocity = [4.0]
+        inp.max_acceleration = [1.9425898752751283]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        self.assertGreaterEqual(result, 0, f"expected trajectory to succeed, got {result!r}")
+        _assert_no_negative_time_intervals(self, output.trajectory)
+        _assert_acceleration_limit_respected(self, output.trajectory, 1.9425898752751283)
+        _assert_velocity_limit_respected(self, output.trajectory, 4.0)
+
+    def test_case_2(self) -> None:
+        # target_vel=1.345, max_acc=5.0
+        inp = InputParameter(1)
+        inp.current_position = [-6.139891324284666]
+        inp.current_velocity = [0.0]
+        inp.current_acceleration = [0.0]
+        inp.target_position = [10.0]
+        inp.target_velocity = [1.345062591709465]
+        inp.target_acceleration = [0.0]
+        inp.max_velocity = [4.0]
+        inp.max_acceleration = [5.0]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        self.assertGreaterEqual(result, 0, f"expected trajectory to succeed, got {result!r}")
+        _assert_no_negative_time_intervals(self, output.trajectory)
+        _assert_acceleration_limit_respected(self, output.trajectory, 5.0)
+        _assert_velocity_limit_respected(self, output.trajectory, 4.0)
+
+
+class TestNegativeTimeIntervalWithHighLimits(unittest.TestCase):
+    """Bug #2: success is not required -- a legitimate failure is
+    acceptable. Only asserts that a returned trajectory (if any) never has
+    a negative time interval or violates its own limits."""
+
+    def test_case_1_previously_produced_negative_t5(self) -> None:
+        inp = InputParameter(1)
+        inp.current_position = [-2.2569699192956714]
+        inp.current_velocity = [0.6924924339691851]
+        inp.current_acceleration = [0.6756694790902418]
+        inp.target_position = [6.790054108584006]
+        inp.target_velocity = [-1.159379585473221]
+        inp.target_acceleration = [-1.2629539618488628]
+        inp.max_velocity = [10.0]
+        inp.max_acceleration = [10.0]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        if result >= 0:
+            _assert_no_negative_time_intervals(self, output.trajectory)
+            _assert_acceleration_limit_respected(self, output.trajectory, 10.0)
+            _assert_velocity_limit_respected(self, output.trajectory, 10.0)
+
+    def test_case_2_previously_produced_negative_t5(self) -> None:
+        inp = InputParameter(1)
+        inp.current_position = [2.6603799559471364]
+        inp.current_velocity = [1.9695301027900147]
+        inp.current_acceleration = [1.972541529001468]
+        inp.target_position = [-6.297064289647577]
+        inp.target_velocity = [-1.5414200165198237]
+        inp.target_acceleration = [-1.5255311582232012]
+        inp.max_velocity = [9.088312224669604]
+        inp.max_acceleration = [9.973774779735683]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        if result >= 0:
+            _assert_no_negative_time_intervals(self, output.trajectory)
+            _assert_acceleration_limit_respected(self, output.trajectory, 9.973774779735683)
+            _assert_velocity_limit_respected(self, output.trajectory, 9.088312224669604)
+
+    def test_case_3_previously_produced_negative_t5_different_max_vel(self) -> None:
+        inp = InputParameter(1)
+        inp.current_position = [2.6603799559471364]
+        inp.current_velocity = [1.9695301027900147]
+        inp.current_acceleration = [1.972541529001468]
+        inp.target_position = [-6.297064289647577]
+        inp.target_velocity = [-1.5414200165198237]
+        inp.target_acceleration = [-1.5255311582232012]
+        inp.max_velocity = [6.282291093061675]
+        inp.max_acceleration = [9.973774779735683]
+        inp.max_jerk = [10.0]
+
+        result, output = _calculate(inp)
+
+        if result >= 0:
+            _assert_no_negative_time_intervals(self, output.trajectory)
+            _assert_acceleration_limit_respected(self, output.trajectory, 9.973774779735683)
+            _assert_velocity_limit_respected(self, output.trajectory, 6.282291093061675)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/test_otg_invariants.py b/tests/otg/test_otg_invariants.py
new file mode 100644
index 0000000..e1ad506
--- /dev/null
+++ b/tests/otg/test_otg_invariants.py
@@ -0,0 +1,257 @@
+"""Invariant tests over seeded random valid inputs.
+
+See ``.claude/specs/otg.md`` §Oracle and test strategy 4 and
+``.claude/action-plan/42-otg-oracle-suites.md``'s design constraint 5: for
+randomized (seeded) valid inputs --
+
+1. output never exceeds max velocity/acceleration/jerk beyond 1e-9;
+2. ``at_time(duration)`` hits the target state within 1e-8;
+3. ``FINISHED`` is reached within ``duration/control_cycle + 2`` update
+   calls.
+
+Driven through ``Otg.update()`` in a real control loop (the "output" the
+spec refers to is ``OutputParameter.new_velocity``/``new_acceleration`` at
+each control cycle, matching ``test_otg_driver.py``'s convention), not a
+dense continuous re-sampling of ``at_time`` -- this is what a real
+consumer of this driver observes each cycle, and is the natural reading of
+"output never exceeds ... " (an ``OutputParameter`` field) plus the
+"within duration/control_cycle + 2 update calls" framing, which is
+inherently about the discrete ``update()`` call sequence.
+
+**Random-input generation.** ``InputParameter.validate()`` rejects a
+current/target velocity or acceleration that would push the profile beyond
+its own limits once acceleration decays to zero
+(``_velocity_at_acceleration_zero``), so candidates are generated with a
+comfortable margin (50% of the velocity limit, 30% of the acceleration
+limit) and then rejection-sampled through ``validate()`` (with both
+``check_current_state_within_limits`` and ``check_target_state_within_limits``
+set, since a transiently-out-of-limits *current* state is a deliberate
+brake-profile scenario the classification corpus already covers elsewhere,
+not part of this suite's "valid input" contract) to guarantee validity
+without asserting anything about the algorithm under test.
+
+**Chunk 56 additions (post-audit finding E-9).**
+
+- Limits (1) were previously checked only at the control-cycle instants
+  sampled by ``update()`` (``output.new_velocity``/``new_acceleration``),
+  which is blind to any intra-cycle peak between two consecutive cycles.
+  Each cycle now additionally samples ``output.trajectory.at_time(t)``
+  densely across the just-elapsed ``[previous_time, output.time]`` interval
+  (``at_time`` exposes position/velocity/acceleration, not jerk -- jerk is
+  piecewise-constant per profile segment, so it has no intra-segment peak
+  to miss the way a continuously-varying velocity/acceleration does).
+- Target-reached (2) was captured from ``output.trajectory`` only after
+  the control loop ended. Empirically this driver only recalculates once
+  per case here (``Otg.update``'s change-detection sees the caller's
+  ``pass_to_input``-updated state as identical to its own cached copy, so
+  the trajectory object is never re-planned for these well-behaved random
+  inputs) -- but asserting against a trajectory captured immediately after
+  the first (``new_calculation``) cycle, independent of whatever happens
+  for the rest of the loop, is the literal and more robust reading of "the
+  originally planned trajectory," so a ``copy.deepcopy`` snapshot is taken
+  at that point and used for this assertion instead of the post-loop
+  ``output.trajectory`` reference.
+"""
+
+from __future__ import annotations
+
+import copy
+import random
+import unittest
+
+from math_tools.otg.enums import Result
+from math_tools.otg.input_parameter import InputParameter
+from math_tools.otg.otg import Otg
+from math_tools.otg.output_parameter import OutputParameter
+from math_tools.otg.trajectory import Trajectory
+
+_SEED = 20260711
+_NUM_CASES = 50
+_MAX_GENERATION_ATTEMPTS = 200
+_CONTROL_CYCLE = 0.05
+
+_LIMIT_TOLERANCE = 1e-9
+_TARGET_TOLERANCE = 1e-8
+_INTRA_CYCLE_SAMPLES = 10
+
+_ERROR_RESULTS = (
+    Result.ERROR,
+    Result.ERROR_INVALID_INPUT,
+    Result.ERROR_TRAJECTORY_DURATION,
+    Result.ERROR_POSITIONAL_LIMITS,
+    Result.ERROR_ZERO_LIMITS,
+    Result.ERROR_EXECUTION_TIME_CALCULATION,
+    Result.ERROR_SYNCHRONIZATION_CALCULATION,
+)
+
+
+def _random_valid_input(rng: random.Random) -> InputParameter:
+    """Rejection-sample a random 1-DOF ``InputParameter`` that passes
+    ``validate()`` with both current and target state checked."""
+    for _attempt in range(_MAX_GENERATION_ATTEMPTS):
+        max_vel = rng.uniform(1.0, 10.0)
+        max_acc = rng.uniform(1.0, 10.0)
+        max_jerk = rng.uniform(1.0, 20.0)
+
+        inp = InputParameter(1)
+        inp.current_position = [rng.uniform(-10.0, 10.0)]
+        inp.target_position = [rng.uniform(-10.0, 10.0)]
+        inp.current_velocity = [rng.uniform(-0.5 * max_vel, 0.5 * max_vel)]
+        inp.target_velocity = [rng.uniform(-0.5 * max_vel, 0.5 * max_vel)]
+        inp.current_acceleration = [rng.uniform(-0.3 * max_acc, 0.3 * max_acc)]
+        inp.target_acceleration = [rng.uniform(-0.3 * max_acc, 0.3 * max_acc)]
+        inp.max_velocity = [max_vel]
+        inp.max_acceleration = [max_acc]
+        inp.max_jerk = [max_jerk]
+
+        if inp.validate(
+            check_current_state_within_limits=True, check_target_state_within_limits=True
+        ):
+            return inp
+
+    raise RuntimeError(
+        f"could not generate a valid random input in {_MAX_GENERATION_ATTEMPTS} attempts"
+    )
+
+
+def _generate_cases(seed: int, count: int) -> list[InputParameter]:
+    rng = random.Random(seed)
+    return [_random_valid_input(rng) for _ in range(count)]
+
+
+class TestRandomizedValidInputInvariants(unittest.TestCase):
+    """Drives each seeded-random valid input through a full ``update()``
+    control loop and checks all three invariants per case."""
+
+    def test_invariants_hold_for_seeded_random_valid_inputs(self) -> None:
+        cases = _generate_cases(_SEED, _NUM_CASES)
+        self.assertEqual(len(cases), _NUM_CASES)
+
+        for case_index, inp in enumerate(cases):
+            with self.subTest(case_index=case_index):
+                otg = Otg(_CONTROL_CYCLE, dofs=1)
+                output = OutputParameter(dofs=1)
+
+                # Bound calls generously (the exact optimal duration is not
+                # known up front for a random case); refine to the exact
+                # `duration / control_cycle + 2` bound once FINISHED is
+                # reached and the trajectory's true duration is known.
+                max_calls_generous = 100_000
+
+                calls = 0
+                result = Result.WORKING
+                exact_bound: int | None = None
+                previous_time = 0.0
+                first_trajectory: Trajectory | None = None
+                while result != Result.FINISHED:
+                    calls += 1
+                    self.assertLessEqual(
+                        calls,
+                        max_calls_generous,
+                        f"case {case_index}: did not reach FINISHED within a generous bound",
+                    )
+
+                    result = otg.update(inp, output)
+                    self.assertNotIn(
+                        result,
+                        _ERROR_RESULTS,
+                        f"case {case_index}: update() returned an error Result on call "
+                        f"{calls}: {result!r}",
+                    )
+
+                    if first_trajectory is None:
+                        # The originally-planned trajectory: snapshotted
+                        # immediately after the first (recalculating)
+                        # cycle, independent of anything that happens to
+                        # `output.trajectory` for the rest of the loop.
+                        self.assertTrue(
+                            output.new_calculation,
+                            f"case {case_index}: first update() call did not recalculate",
+                        )
+                        first_trajectory = copy.deepcopy(output.trajectory)
+
+                    if exact_bound is None:
+                        exact_bound = int(
+                            output.trajectory.duration / _CONTROL_CYCLE + 2
+                        )
+
+                    # (1) output never exceeds max velocity/acceleration/jerk
+                    # beyond 1e-9, checked both at the control-cycle instant
+                    # AND densely within the just-elapsed cycle interval
+                    # (intra-cycle peaks are invisible at the instant alone).
+                    self.assertLessEqual(
+                        abs(output.new_velocity[0]),
+                        inp.max_velocity[0] + _LIMIT_TOLERANCE,
+                        f"case {case_index} call {calls}: velocity "
+                        f"{output.new_velocity[0]} exceeds max_velocity "
+                        f"{inp.max_velocity[0]}",
+                    )
+                    self.assertLessEqual(
+                        abs(output.new_acceleration[0]),
+                        inp.max_acceleration[0] + _LIMIT_TOLERANCE,
+                        f"case {case_index} call {calls}: acceleration "
+                        f"{output.new_acceleration[0]} exceeds max_acceleration "
+                        f"{inp.max_acceleration[0]}",
+                    )
+                    self.assertLessEqual(
+                        abs(output.new_jerk[0]),
+                        inp.max_jerk[0] + _LIMIT_TOLERANCE,
+                        f"case {case_index} call {calls}: jerk {output.new_jerk[0]} "
+                        f"exceeds max_jerk {inp.max_jerk[0]}",
+                    )
+
+                    segment_start = min(previous_time, output.time)
+                    segment_end = output.time
+                    for sample_i in range(_INTRA_CYCLE_SAMPLES + 1):
+                        t = segment_start + (segment_end - segment_start) * (
+                            sample_i / _INTRA_CYCLE_SAMPLES
+                        )
+                        _p, v, a = output.trajectory.at_time(t)
+                        self.assertLessEqual(
+                            abs(v[0]),
+                            inp.max_velocity[0] + _LIMIT_TOLERANCE,
+                            f"case {case_index} call {calls}: intra-cycle velocity "
+                            f"{v[0]} at t={t} exceeds max_velocity {inp.max_velocity[0]}",
+                        )
+                        self.assertLessEqual(
+                            abs(a[0]),
+                            inp.max_acceleration[0] + _LIMIT_TOLERANCE,
+                            f"case {case_index} call {calls}: intra-cycle acceleration "
+                            f"{a[0]} at t={t} exceeds max_acceleration "
+                            f"{inp.max_acceleration[0]}",
+                        )
+                    previous_time = output.time
+
+                    output.pass_to_input(inp)
+
+                assert exact_bound is not None
+                self.assertLessEqual(
+                    calls,
+                    exact_bound,
+                    f"case {case_index}: FINISHED not reached within "
+                    f"duration/control_cycle + 2 = {exact_bound} update calls "
+                    f"(took {calls})",
+                )
+
+                # (2) at_time(duration) hits the target state within 1e-8,
+                # asserted against the ORIGINALLY planned trajectory
+                # (see the module docstring's chunk 56 addition), not
+                # whatever `output.trajectory` happens to reference once
+                # the loop ends. `inp.target_*` is never mutated by
+                # `pass_to_input` (only `current_*` is), so it still holds
+                # this case's original target throughout the loop.
+                assert first_trajectory is not None
+                final_p, final_v, final_a = first_trajectory.at_time(first_trajectory.duration)
+                self.assertAlmostEqual(
+                    final_p[0], inp.target_position[0], delta=_TARGET_TOLERANCE
+                )
+                self.assertAlmostEqual(
+                    final_v[0], inp.target_velocity[0], delta=_TARGET_TOLERANCE
+                )
+                self.assertAlmostEqual(
+                    final_a[0], inp.target_acceleration[0], delta=_TARGET_TOLERANCE
+                )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/test_otg_truth_table.py b/tests/otg/test_otg_truth_table.py
new file mode 100644
index 0000000..b865486
--- /dev/null
+++ b/tests/otg/test_otg_truth_table.py
@@ -0,0 +1,172 @@
+"""Oracle tests: the classification corpus and the numeric truth table.
+
+See ``.claude/specs/otg.md`` §Oracle and test strategy (1)-(2), §Compliance
+1, and ``.claude/action-plan/42-otg-oracle-suites.md``'s design constraints
+1-2.
+
+Two independent oracle tiers, both driven off data in ``tests/otg/data/``:
+
+1. **Classification corpus** (``successful_trajectories.json`` /
+   ``failed_trajectories.json``, ~1,680 / ~100 cases, copied byte-for-byte
+   from ``SWIFT_TESTS/OTGTests/truthTables/``): records inputs only, no
+   expected numbers. Each successful case must produce a non-error
+   ``Result`` (``>= 0``); each failed case must produce an error ``Result``
+   (``< 0``). The JSON's free-text ``"error"`` field on failed cases is
+   never mapped to a specific error code (design constraint 1) -- it is
+   ignored by ``InputParameter.from_dict``.
+2. **Numeric truth table** (``otg_numeric_truth.json``, transcribed
+   verbatim from the hardcoded Swift array in
+   ``SWIFT_TESTS/OTGTests/OTGTruthTableTests.swift``): pins the exact
+   trajectory duration and the 7 per-DOF profile segment times
+   (``Profile.t``) for 31 specific 1-DOF cases, which is a much stronger
+   assertion than "did it succeed" -- it pins which profile branch the
+   step solvers select, not just a coincidentally-summable duration.
+
+   The Swift source array (lines 27-490 of ``OTGTruthTableTests.swift``)
+   contains 31 entries (Test Case 1..31, no gaps, no duplicated indices)
+   -- verified by a mechanical regex parse of the Swift literal compared
+   field-for-field against ``otg_numeric_truth.json`` during authoring.
+   All 31 are transcribed and asserted.
+
+   Segment-time assertions use atol 1e-6, not a tighter value: the Swift
+   literals themselves are recorded to only 6 decimal places, so no
+   correct port can satisfy a tighter tolerance than the source data's
+   own precision ceiling (max possible rounding error 5e-7). See this
+   chunk's Resolution notes for the analysis.
+"""
+
+from __future__ import annotations
+
+import json
+import math
+import unittest
+from pathlib import Path
+from typing import Any
+
+from math_tools.otg.enums import Result
+from math_tools.otg.input_parameter import InputParameter
+from math_tools.otg.otg import Otg
+from math_tools.otg.output_parameter import OutputParameter
+
+_DATA_DIR = Path(__file__).parent / "data"
+_CONTROL_CYCLE = 0.01
+
+_DURATION_RTOL = 1e-6
+_TIME_INTERVAL_ATOL = 1e-6
+
+
+def _load_json(name: str) -> Any:
+    with (_DATA_DIR / name).open() as f:
+        return json.load(f)
+
+
+class TestClassificationCorpusSuccessfulCases(unittest.TestCase):
+    """otg.md §Oracle and test strategy 1: every case in
+    ``successful_trajectories.json`` must ``calculate`` to a non-error
+    ``Result`` (``Result >= 0``, i.e. ``WORKING`` or ``FINISHED``)."""
+
+    def test_all_successful_cases_calculate_without_error(self) -> None:
+        cases = _load_json("successful_trajectories.json")
+        self.assertGreater(len(cases), 0, "successful_trajectories.json is empty")
+
+        failures: list[tuple[int, Result]] = []
+        for index, case in enumerate(cases):
+            inp = InputParameter.from_dict(case)
+            otg = Otg(_CONTROL_CYCLE, dofs=inp.degrees_of_freedom)
+            output = OutputParameter(dofs=inp.degrees_of_freedom)
+
+            result = otg.calculate(inp, output)
+            if result < 0:
+                failures.append((index, result))
+
+        self.assertEqual(
+            failures,
+            [],
+            f"{len(failures)}/{len(cases)} classification-corpus 'successful' cases "
+            f"returned an error Result (first few: {failures[:10]})",
+        )
+
+
+class TestClassificationCorpusFailedCases(unittest.TestCase):
+    """otg.md §Oracle and test strategy 1: every case in
+    ``failed_trajectories.json`` must ``calculate`` to an error ``Result``
+    (``Result < 0``). The free-text ``"error"`` field is not asserted
+    against a specific error code."""
+
+    def test_all_failed_cases_calculate_to_an_error(self) -> None:
+        cases = _load_json("failed_trajectories.json")
+        self.assertGreater(len(cases), 0, "failed_trajectories.json is empty")
+
+        unexpected_successes: list[int] = []
+        for index, case in enumerate(cases):
+            inp = InputParameter.from_dict(case)
+            otg = Otg(_CONTROL_CYCLE, dofs=inp.degrees_of_freedom)
+            output = OutputParameter(dofs=inp.degrees_of_freedom)
+
+            result = otg.calculate(inp, output)
+            if result >= 0:
+                unexpected_successes.append(index)
+
+        self.assertEqual(
+            unexpected_successes,
+            [],
+            f"{len(unexpected_successes)}/{len(cases)} classification-corpus 'failed' "
+            f"cases unexpectedly succeeded (indices: {unexpected_successes[:10]})",
+        )
+
+
+class TestNumericTruthTable(unittest.TestCase):
+    """otg.md §Oracle and test strategy 2, §Compliance 1: the 31-case
+    (see module docstring) hardcoded numeric oracle -- duration rtol
+    1e-6, segment times atol 1e-6."""
+
+    def test_all_cases_match_expected_duration_and_segment_times(self) -> None:
+        data = _load_json("otg_numeric_truth.json")
+        cases = data["cases"]
+        self.assertGreater(len(cases), 0, "otg_numeric_truth.json has no cases")
+
+        for case in cases:
+            with self.subTest(case_id=case["id"], description=case["description"]):
+                inp = InputParameter(1)
+                inp.current_position = [case["currentPosition"]]
+                inp.current_velocity = [case["currentVelocity"]]
+                inp.current_acceleration = [case["currentAcceleration"]]
+                inp.target_position = [case["targetPosition"]]
+                inp.target_velocity = [case["targetVelocity"]]
+                inp.target_acceleration = [case["targetAcceleration"]]
+                inp.max_velocity = [case["maxVelocity"]]
+                inp.max_acceleration = [case["maxAcceleration"]]
+                inp.max_jerk = [case["maxJerk"]]
+
+                otg = Otg(_CONTROL_CYCLE, dofs=1)
+                output = OutputParameter(dofs=1)
+                result = otg.calculate(inp, output)
+
+                self.assertGreaterEqual(
+                    result,
+                    0,
+                    f"case {case['id']}: calculate() failed with {result!r}",
+                )
+
+                trajectory = output.trajectory
+                self.assertTrue(
+                    math.isclose(
+                        trajectory.duration, case["expectedDuration"], rel_tol=_DURATION_RTOL
+                    ),
+                    f"case {case['id']}: duration {trajectory.duration} != "
+                    f"expected {case['expectedDuration']} (rtol {_DURATION_RTOL})",
+                )
+
+                profile = trajectory.profiles[0][0]
+                self.assertEqual(len(profile.t), 7)
+                for segment_index, expected_t in enumerate(case["expectedTimeIntervals"]):
+                    actual_t = profile.t[segment_index]
+                    self.assertTrue(
+                        math.isclose(actual_t, expected_t, abs_tol=_TIME_INTERVAL_ATOL),
+                        f"case {case['id']}: t[{segment_index}] = {actual_t} != "
+                        f"expected {expected_t} (atol {_TIME_INTERVAL_ATOL})",
+                    )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/test_output_parameter.py b/tests/otg/test_output_parameter.py
new file mode 100644
index 0000000..ffbf4fb
--- /dev/null
+++ b/tests/otg/test_output_parameter.py
@@ -0,0 +1,111 @@
+"""Unit tests for ``math_tools.otg.output_parameter.OutputParameter``.
+
+See ``.claude/specs/otg.md`` §Public API (OutputParameter) and
+``.claude/action-plan/35-otg-trajectory-and-output.md``'s TDD steps:
+``pass_to_input`` must copy every kinematic field, asserted against a
+sentinel-filled ``InputParameter``.
+"""
+
+import unittest
+
+from math_tools.otg.input_parameter import InputParameter
+from math_tools.otg.output_parameter import OutputParameter
+
+
+class TestDefaultConstruction(unittest.TestCase):
+    def test_default_field_shapes(self) -> None:
+        output = OutputParameter(dofs=2)
+        self.assertEqual(output.degrees_of_freedom, 2)
+        self.assertEqual(output.new_position, [0.0, 0.0])
+        self.assertEqual(output.new_velocity, [0.0, 0.0])
+        self.assertEqual(output.new_acceleration, [0.0, 0.0])
+        self.assertEqual(output.new_jerk, [0.0, 0.0])
+        self.assertEqual(output.time, 0.0)
+        self.assertEqual(output.new_section, 0)
+        self.assertFalse(output.did_section_change)
+        self.assertFalse(output.new_calculation)
+        self.assertEqual(output.calculation_duration, 0.0)
+        self.assertEqual(output.trajectory.degrees_of_freedom, 2)
+
+    def test_rejects_non_positive_dofs(self) -> None:
+        with self.assertRaises(ValueError):
+            OutputParameter(dofs=0)
+
+    def test_max_number_of_waypoints_sizes_trajectory_sections(self) -> None:
+        output = OutputParameter(dofs=1, max_number_of_waypoints=3)
+        self.assertEqual(len(output.trajectory.profiles), 4)
+
+
+class TestPassToInputFieldCoverage(unittest.TestCase):
+    def _sentinel_input(self, dofs: int) -> InputParameter:
+        input_parameter = InputParameter(dofs=dofs)
+        input_parameter.current_position = [-999.0] * dofs
+        input_parameter.current_velocity = [-999.0] * dofs
+        input_parameter.current_acceleration = [-999.0] * dofs
+        return input_parameter
+
+    def test_copies_every_kinematic_field(self) -> None:
+        dofs = 3
+        output = OutputParameter(dofs=dofs)
+        output.new_position = [1.0, 2.0, 3.0]
+        output.new_velocity = [4.0, 5.0, 6.0]
+        output.new_acceleration = [7.0, 8.0, 9.0]
+
+        input_parameter = self._sentinel_input(dofs)
+        output.pass_to_input(input_parameter)
+
+        for dof in range(dofs):
+            self.assertEqual(input_parameter.current_position[dof], output.new_position[dof])
+            self.assertEqual(input_parameter.current_velocity[dof], output.new_velocity[dof])
+            self.assertEqual(
+                input_parameter.current_acceleration[dof], output.new_acceleration[dof]
+            )
+
+    def test_section_change_removes_first_intermediate_position(self) -> None:
+        output = OutputParameter(dofs=1)
+        output.did_section_change = True
+        input_parameter = self._sentinel_input(1)
+        input_parameter.intermediate_positions = [[1.0], [2.0]]
+
+        output.pass_to_input(input_parameter)
+
+        self.assertEqual(input_parameter.intermediate_positions, [[2.0]])
+
+    def test_no_section_change_keeps_intermediate_positions(self) -> None:
+        output = OutputParameter(dofs=1)
+        output.did_section_change = False
+        input_parameter = self._sentinel_input(1)
+        input_parameter.intermediate_positions = [[1.0], [2.0]]
+
+        output.pass_to_input(input_parameter)
+
+        self.assertEqual(input_parameter.intermediate_positions, [[1.0], [2.0]])
+
+    def test_section_change_with_no_intermediate_positions_is_a_no_op(self) -> None:
+        output = OutputParameter(dofs=1)
+        output.did_section_change = True
+        input_parameter = self._sentinel_input(1)
+
+        output.pass_to_input(input_parameter)  # must not raise
+
+        self.assertEqual(input_parameter.intermediate_positions, [])
+
+    def test_mismatched_array_size_raises(self) -> None:
+        output = OutputParameter(dofs=2)
+        output.new_position = [1.0]  # wrong length
+        input_parameter = self._sentinel_input(2)
+
+        with self.assertRaises(ValueError):
+            output.pass_to_input(input_parameter)
+
+
+class TestRepr(unittest.TestCase):
+    def test_repr_contains_field_labels(self) -> None:
+        output = OutputParameter(dofs=1)
+        text = repr(output)
+        self.assertIn("out.new_position", text)
+        self.assertIn("out.new_velocity", text)
+        self.assertIn("out.new_acceleration", text)
+        self.assertIn("out.new_jerk", text)
+        self.assertIn("out.time", text)
+        self.assertIn("out.calculation_duration", text)
diff --git a/tests/otg/test_profile.py b/tests/otg/test_profile.py
new file mode 100644
index 0000000..0d837ae
--- /dev/null
+++ b/tests/otg/test_profile.py
@@ -0,0 +1,359 @@
+"""Unit tests for ``math_tools.otg.profile.Profile``.
+
+See ``.claude/specs/otg.md`` §Internal fidelity requirement 1 and
+``.claude/action-plan/33-otg-profile.md``. Boundary-array expectations are
+computed independently via ``integrate_jerk`` in each test (never by
+re-deriving them from ``Profile``'s own loop), per the chunk's TDD steps.
+"""
+
+import math
+import unittest
+from dataclasses import dataclass
+
+from math_tools.functional.roots import integrate_jerk
+from math_tools.otg.enums import ControlSigns, Direction, ReachedLimits
+from math_tools.otg.profile import Profile
+
+
+@dataclass
+class _FakeBound:
+    """Minimal stand-in for the not-yet-landed ``Bound`` (chunk 34):
+    ``check_position_extremum``/``check_step_for_position_extremum`` only
+    need these four mutable float attributes, matching
+    ``Profile``'s ``_PositionExtremumSink`` protocol structurally."""
+
+    min: float = math.inf
+    max: float = -math.inf
+    t_min: float = 0.0
+    t_max: float = 0.0
+
+
+class TestProfileDefaults(unittest.TestCase):
+    def test_default_construction_shapes(self) -> None:
+        profile = Profile()
+        self.assertEqual(profile.t, [0.0] * 7)
+        self.assertEqual(profile.t_sum, [0.0] * 7)
+        self.assertEqual(profile.j, [0.0] * 7)
+        self.assertEqual(profile.a, [0.0] * 8)
+        self.assertEqual(profile.v, [0.0] * 8)
+        self.assertEqual(profile.p, [0.0] * 8)
+        self.assertEqual(profile.brake.duration, 0.0)
+        self.assertEqual(profile.accel.duration, 0.0)
+        self.assertEqual(profile.pf, 0.0)
+        self.assertEqual(profile.vf, 0.0)
+        self.assertEqual(profile.af, 0.0)
+        self.assertEqual(profile.limits, ReachedLimits.NONE)
+        self.assertEqual(profile.direction, Direction.DOWN)
+        self.assertEqual(profile.control_signs, ControlSigns.UDDU)
+
+    def test_equality(self) -> None:
+        a = Profile()
+        b = Profile()
+        self.assertEqual(a, b)
+        b.t[3] = 1.0
+        self.assertNotEqual(a, b)
+
+    def test_equality_rejects_non_profile(self) -> None:
+        self.assertNotEqual(Profile(), object())
+
+
+class TestProfileCheckBoundaryIntegration(unittest.TestCase):
+    """The hand-constructed 7-phase constant-jerk (UDDU) S-curve fixture
+    shared by the ``check``-family tests below: jf=+/-2.0, every segment
+    1.0s, starting and ending at rest."""
+
+    def _expected_pva(self) -> tuple[list[float], list[float], list[float]]:
+        jf = 2.0
+        t = [1.0] * 7
+        j = [jf, 0.0, -jf, 0.0, -jf, 0.0, jf]
+        p = [0.0] * 8
+        v = [0.0] * 8
+        a = [0.0] * 8
+        for i in range(7):
+            p[i + 1], v[i + 1], a[i + 1] = integrate_jerk(t[i], p[i], v[i], a[i], j[i])
+        return p, v, a
+
+    def _valid_profile(self) -> Profile:
+        profile = Profile()
+        profile.t = [1.0] * 7
+        return profile
+
+    def test_boundary_array_integration(self) -> None:
+        expected_p, expected_v, expected_a = self._expected_pva()
+        profile = self._valid_profile()
+        profile.pf, profile.vf, profile.af = expected_p[-1], expected_v[-1], expected_a[-1]
+
+        accepted = profile.check(
+            2.0,
+            v_max=4.0,
+            v_min=-4.0,
+            a_max=2.0,
+            a_min=-2.0,
+            control_signs=ControlSigns.UDDU,
+            limits=ReachedLimits.NONE,
+        )
+
+        self.assertTrue(accepted)
+        self.assertEqual(profile.p, expected_p)
+        self.assertEqual(profile.v, expected_v)
+        self.assertEqual(profile.a, expected_a)
+
+    def test_t_sum_is_prefix_sum_of_t(self) -> None:
+        profile = self._valid_profile()
+        profile.pf, profile.vf, profile.af = 16.0, 0.0, 0.0
+        profile.check(
+            2.0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0,
+            control_signs=ControlSigns.UDDU, limits=ReachedLimits.NONE,
+        )
+        self.assertEqual(profile.t_sum, [1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0])
+
+    def test_perturbed_profile_is_rejected(self) -> None:
+        expected_p, expected_v, expected_a = self._expected_pva()
+        profile = self._valid_profile()
+        profile.pf, profile.vf, profile.af = expected_p[-1], expected_v[-1], expected_a[-1]
+        profile.t[3] += 1e-3
+
+        accepted = profile.check(
+            2.0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0,
+            control_signs=ControlSigns.UDDU, limits=ReachedLimits.NONE,
+        )
+
+        self.assertFalse(accepted)
+
+    def test_check_with_timing_delegates_without_j_max(self) -> None:
+        expected_p, expected_v, expected_a = self._expected_pva()
+        profile = self._valid_profile()
+        profile.pf, profile.vf, profile.af = expected_p[-1], expected_v[-1], expected_a[-1]
+
+        self.assertTrue(
+            profile.check_with_timing(
+                0.0, 2.0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0,
+                control_signs=ControlSigns.UDDU, limits=ReachedLimits.NONE,
+            )
+        )
+
+    def test_check_with_timing_rejects_when_jf_exceeds_j_max(self) -> None:
+        profile = self._valid_profile()
+        profile.pf, profile.vf, profile.af = 16.0, 0.0, 0.0
+
+        accepted = profile.check_with_timing(
+            0.0, 2.0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0,
+            control_signs=ControlSigns.UDDU, limits=ReachedLimits.NONE, j_max=1.5,
+        )
+        self.assertFalse(accepted)
+
+    def test_check_with_timing_accepts_when_jf_within_j_max(self) -> None:
+        expected_p, expected_v, expected_a = self._expected_pva()
+        profile = self._valid_profile()
+        profile.pf, profile.vf, profile.af = expected_p[-1], expected_v[-1], expected_a[-1]
+
+        accepted = profile.check_with_timing(
+            0.0, 2.0, v_max=4.0, v_min=-4.0, a_max=2.0, a_min=-2.0,
+            control_signs=ControlSigns.UDDU, limits=ReachedLimits.NONE, j_max=3.0,
+        )
+        self.assertTrue(accepted)
+
+
+class TestProfileCheckForVelocity(unittest.TestCase):
+    def test_accepts_valid_profile(self) -> None:
+        jf = 2.0
+        t = [1.0] * 7
+        j = [jf, 0.0, -jf, 0.0, -jf, 0.0, jf]
+        p = [0.0] * 8
+        v = [0.0] * 8
+        a = [0.0] * 8
+        for i in range(7):
+            p[i + 1], v[i + 1], a[i + 1] = integrate_jerk(t[i], p[i], v[i], a[i], j[i])
+
+        profile = Profile()
+        profile.t = t
+        profile.af, profile.vf = a[-1], v[-1]
+
+        accepted = profile.check_for_velocity(
+            jf, a_max=2.0, a_min=-2.0, control_signs=ControlSigns.UDDU, limits=ReachedLimits.NONE
+        )
+        self.assertTrue(accepted)
+        self.assertEqual(profile.a, a)
+        self.assertEqual(profile.v, v)
+
+    def test_with_timing_rejects_when_jf_exceeds_j_max(self) -> None:
+        profile = Profile()
+        profile.t = [1.0] * 7
+        profile.af, profile.vf = 0.0, 0.0
+
+        accepted = profile.check_for_velocity_with_timing(
+            0.0, 2.0, a_max=2.0, a_min=-2.0, control_signs=ControlSigns.UDDU,
+            limits=ReachedLimits.NONE, j_max=1.0,
+        )
+        self.assertFalse(accepted)
+
+
+class TestProfileSecondOrderVelocity(unittest.TestCase):
+    def test_accepts_valid_profile(self) -> None:
+        t1, a_up, v0 = 2.0, 3.0, 1.0
+        p = [0.0] * 8
+        v = [v0] * 8
+        a = [0.0, a_up, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0]
+        for i in range(7):
+            p[i + 1], v[i + 1], _ = integrate_jerk(t1, p[i], v[i], a[i], 0.0)
+
+        profile = Profile()
+        profile.t = [t1] * 7  # check_for_second_order_velocity integrates real per-phase t[i]
+        profile.v[0] = v0
+        profile.af, profile.vf = 0.0, v[-1]
+
+        accepted = profile.check_for_second_order_velocity(
+            a_up, control_signs=ControlSigns.UDDU, limits=ReachedLimits.NONE
+        )
+        self.assertTrue(accepted)
+        self.assertEqual(profile.p, p)
+        self.assertEqual(profile.v, v)
+
+    def test_with_timing_rejects_out_of_bound_a_up(self) -> None:
+        profile = Profile()
+        profile.t[1] = 2.0
+        profile.v[0] = 1.0
+        profile.vf = 100.0  # deliberately unreachable; a-bound should fail first
+
+        accepted = profile.check_for_second_order_velocity_with_timing(
+            0.0, 5.0, control_signs=ControlSigns.UDDU, limits=ReachedLimits.NONE,
+            a_max=2.0, a_min=-2.0,
+        )
+        self.assertFalse(accepted)
+
+
+class TestProfileSecondOrderPosition(unittest.TestCase):
+    def test_accepts_valid_profile(self) -> None:
+        a_up, a_down = 2.0, -2.0
+        t = [1.0] * 7
+        a = [a_up, 0.0, a_down, 0.0, a_down, 0.0, a_up, 0.0]
+        p = [0.0] * 8
+        v = [0.0] * 8
+        for i in range(7):
+            p[i + 1], v[i + 1], _ = integrate_jerk(t[i], p[i], v[i], a[i], 0.0)
+
+        profile = Profile()
+        profile.t = t
+        profile.pf, profile.vf = p[-1], v[-1]
+
+        accepted = profile.check_for_second_order(
+            a_up, a_down, v_max=2.0, v_min=-2.0,
+            control_signs=ControlSigns.UDDU, limits=ReachedLimits.NONE,
+        )
+        self.assertTrue(accepted)
+        self.assertEqual(profile.p, p)
+        self.assertEqual(profile.v, v)
+
+
+class TestProfileFirstOrder(unittest.TestCase):
+    def test_accepts_valid_profile(self) -> None:
+        v_up = 2.0
+        profile = Profile()
+        profile.t[3] = 3.0
+        profile.pf = 6.0
+
+        accepted = profile.check_for_first_order(
+            v_up, control_signs=ControlSigns.UDDU, limits=ReachedLimits.NONE
+        )
+        self.assertTrue(accepted)
+        self.assertEqual(profile.p[-1], 6.0)
+
+    def test_with_timing_rejects_out_of_bound_v_up(self) -> None:
+        profile = Profile()
+        profile.t[3] = 3.0
+        profile.pf = 100.0
+
+        accepted = profile.check_for_first_order_with_timing(
+            0.0, 5.0, control_signs=ControlSigns.UDDU, limits=ReachedLimits.NONE,
+            v_max=2.0, v_min=-2.0,
+        )
+        self.assertFalse(accepted)
+
+
+class TestProfileSetBoundary(unittest.TestCase):
+    def test_set_boundary_from_profile_copies_state(self) -> None:
+        source = Profile()
+        source.a[0], source.v[0], source.p[0] = 1.0, 2.0, 3.0
+        source.af, source.vf, source.pf = 4.0, 5.0, 6.0
+
+        target = Profile()
+        target.set_boundary(source)
+
+        self.assertEqual(target.a[0], 1.0)
+        self.assertEqual(target.v[0], 2.0)
+        self.assertEqual(target.p[0], 3.0)
+        self.assertEqual(target.af, 4.0)
+        self.assertEqual(target.vf, 5.0)
+        self.assertEqual(target.pf, 6.0)
+        self.assertIs(target.brake, source.brake)
+        self.assertIs(target.accel, source.accel)
+
+    def test_set_boundary_from_scalars(self) -> None:
+        profile = Profile()
+        profile.set_boundary(10.0, 20.0, 30.0, 40.0, 50.0, 60.0)
+
+        self.assertEqual(profile.p[0], 10.0)
+        self.assertEqual(profile.v[0], 20.0)
+        self.assertEqual(profile.a[0], 30.0)
+        self.assertEqual(profile.pf, 40.0)
+        self.assertEqual(profile.vf, 50.0)
+        self.assertEqual(profile.af, 60.0)
+
+    def test_set_boundary_for_velocity(self) -> None:
+        profile = Profile()
+        profile.set_boundary_for_velocity(1.0, 2.0, 3.0, 4.0, 5.0)
+
+        self.assertEqual(profile.p[0], 1.0)
+        self.assertEqual(profile.v[0], 2.0)
+        self.assertEqual(profile.a[0], 3.0)
+        self.assertEqual(profile.vf, 4.0)
+        self.assertEqual(profile.af, 5.0)
+
+
+class TestProfilePositionExtremumStatics(unittest.TestCase):
+    def test_check_position_extremum_updates_max_for_downward_acceleration(self) -> None:
+        t_ext, t_sum, t, p, v, a, j = 0.5, 10.0, 1.0, 0.0, 1.0, -1.0, 0.0
+        expected_p_ext, _, expected_a_ext = integrate_jerk(t_ext, p, v, a, j)
+        self.assertLess(expected_a_ext, 0.0)
+
+        ext = _FakeBound()
+        Profile.check_position_extremum(t_ext, t_sum, t, p, v, a, j, ext)
+
+        self.assertEqual(ext.max, expected_p_ext)
+        self.assertEqual(ext.t_max, t_sum + t_ext)
+        self.assertEqual(ext.min, math.inf)  # untouched
+
+    def test_check_position_extremum_ignores_root_outside_interval(self) -> None:
+        ext = _FakeBound()
+        # t_ext == t is not strictly inside (0, t): no-op per Swift's `0 < tExt && tExt < t`.
+        Profile.check_position_extremum(1.0, 0.0, 1.0, 0.0, 1.0, -1.0, 0.0, ext)
+        self.assertEqual(ext, _FakeBound())
+
+    def test_check_step_for_position_extremum_two_real_roots(self) -> None:
+        t_sum, t, p, v, a, j = 0.0, 2.0, 5.0, -1.0, 0.0, 2.0
+
+        ext = _FakeBound()
+        Profile.check_step_for_position_extremum(t_sum, t, p, v, a, j, ext)
+
+        # The raw sample point p=5.0 sets both min and max first.
+        # Root t_ext=1.0 (of the two roots -1.0/1.0) lies in (0, t) and its
+        # integrated position (~4.333) undercuts the min set by the sample.
+        expected_p_ext, _, expected_a_ext = integrate_jerk(1.0, p, v, a, j)
+        self.assertGreater(expected_a_ext, 0.0)
+
+        self.assertEqual(ext.max, 5.0)
+        self.assertEqual(ext.t_max, 0.0)
+        self.assertEqual(ext.min, expected_p_ext)
+        self.assertEqual(ext.t_min, 1.0)
+
+    def test_check_step_for_position_extremum_zero_jerk_only_samples_endpoint(self) -> None:
+        ext = _FakeBound()
+        Profile.check_step_for_position_extremum(3.0, 1.0, 2.0, 0.5, 0.0, 0.0, ext)
+        self.assertEqual(ext.min, 2.0)
+        self.assertEqual(ext.max, 2.0)
+        self.assertEqual(ext.t_min, 3.0)
+        self.assertEqual(ext.t_max, 3.0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/otg/test_trajectory.py b/tests/otg/test_trajectory.py
new file mode 100644
index 0000000..b81992f
--- /dev/null
+++ b/tests/otg/test_trajectory.py
@@ -0,0 +1,179 @@
+"""Unit tests for ``math_tools.otg.trajectory.Trajectory``.
+
+See ``.claude/specs/otg.md`` §Public API (Trajectory) and
+``.claude/action-plan/35-otg-trajectory-and-output.md``'s TDD steps: a
+single-DOF ``Trajectory`` built from chunk 33's hand-constructed 7-phase
+``Profile`` fixture. Endpoint/midpoint expectations are computed
+independently via ``integrate_jerk`` in each test, never re-derived from
+``Trajectory``'s own sampling loop.
+"""
+
+import unittest
+
+from math_tools.functional.roots import integrate_jerk
+from math_tools.otg.enums import ControlSigns, ReachedLimits
+from math_tools.otg.profile import Profile
+from math_tools.otg.trajectory import Trajectory
+
+
+def _seven_phase_profile() -> Profile:
+    """chunk 33's shared fixture: jf=+/-2.0, every segment 1.0s, UDDU
+    control signs, starting and ending at rest (rest-to-rest S-curve)."""
+    profile = Profile()
+    profile.t = [1.0] * 7
+    jf = 2.0
+    expected_j = [jf, 0.0, -jf, 0.0, -jf, 0.0, jf]
+    p = [0.0] * 8
+    v = [0.0] * 8
+    a = [0.0] * 8
+    for i in range(7):
+        p[i + 1], v[i + 1], a[i + 1] = integrate_jerk(1.0, p[i], v[i], a[i], expected_j[i])
+    profile.pf, profile.vf, profile.af = p[-1], v[-1], a[-1]
+
+    accepted = profile.check(
+        jf,
+        v_max=4.0,
+        v_min=-4.0,
+        a_max=2.0,
+        a_min=-2.0,
+        control_signs=ControlSigns.UDDU,
+        limits=ReachedLimits.NONE,
+    )
+    assert accepted, "fixture profile must be accepted by check()"
+    return profile
+
+
+def _single_dof_trajectory(profile: Profile) -> Trajectory:
+    trajectory = Trajectory(dofs=1)
+    trajectory.profiles = [[profile]]
+    trajectory.duration = profile.t_sum[-1] + profile.brake.duration
+    trajectory.cumulative_times = [trajectory.duration]
+    return trajectory
+
+
+class TestAtTimeEndpointsAndMidpoint(unittest.TestCase):
+    def setUp(self) -> None:
+        self.profile = _seven_phase_profile()
+        self.trajectory = _single_dof_trajectory(self.profile)
+
+    def test_at_time_zero_returns_initial_state(self) -> None:
+        p, v, a = self.trajectory.at_time(0.0)
+        self.assertEqual(p, [self.profile.p[0]])
+        self.assertEqual(v, [self.profile.v[0]])
+        self.assertEqual(a, [self.profile.a[0]])
+
+    def test_at_time_duration_returns_target_state(self) -> None:
+        p, v, a = self.trajectory.at_time(self.trajectory.duration)
+        self.assertAlmostEqual(p[0], self.profile.pf, delta=1e-9)
+        self.assertAlmostEqual(v[0], self.profile.vf, delta=1e-9)
+        self.assertAlmostEqual(a[0], self.profile.af, delta=1e-9)
+
+    def test_at_time_midpoint_within_first_segment(self) -> None:
+        # t=0.5 falls within segment 0 (t_sum == [1, 2, 3, 4, 5, 6, 7]).
+        expected_p, expected_v, expected_a = integrate_jerk(
+            0.5, self.profile.p[0], self.profile.v[0], self.profile.a[0], self.profile.j[0]
+        )
+        p, v, a = self.trajectory.at_time(0.5)
+        self.assertAlmostEqual(p[0], expected_p, places=12)
+        self.assertAlmostEqual(v[0], expected_v, places=12)
+        self.assertAlmostEqual(a[0], expected_a, places=12)
+
+    def test_at_time_midpoint_crosses_segment_boundary(self) -> None:
+        # t=3.5 falls within segment 3 (local offset 0.5 past t_sum[2] == 3.0).
+        expected_p, expected_v, expected_a = integrate_jerk(
+            0.5, self.profile.p[3], self.profile.v[3], self.profile.a[3], self.profile.j[3]
+        )
+        p, v, a = self.trajectory.at_time(3.5)
+        self.assertAlmostEqual(p[0], expected_p, places=12)
+        self.assertAlmostEqual(v[0], expected_v, places=12)
+        self.assertAlmostEqual(a[0], expected_a, places=12)
+
+    def test_at_time_negative_clamps_to_start(self) -> None:
+        self.assertEqual(self.trajectory.at_time(-5.0), self.trajectory.at_time(0.0))
+
+    def test_at_time_beyond_duration_clamps_to_end(self) -> None:
+        beyond = self.trajectory.duration + 100.0
+        self.assertEqual(
+            self.trajectory.at_time(beyond), self.trajectory.at_time(self.trajectory.duration)
+        )
+
+
+class TestPositionExtrema(unittest.TestCase):
+    def test_single_section_monotonic_profile(self) -> None:
+        # Rest-to-rest forward S-curve: velocity never goes negative, so
+        # position is monotonically non-decreasing -- min is the start
+        # position, max is the final (target) position.
+        profile = _seven_phase_profile()
+        trajectory = _single_dof_trajectory(profile)
+
+        extrema = trajectory.position_extrema()
+
+        self.assertEqual(len(extrema), 1)
+        self.assertAlmostEqual(extrema[0].min, profile.p[0], places=9)
+        self.assertAlmostEqual(extrema[0].max, profile.pf, places=9)
+
+    def test_merges_across_multiple_sections(self) -> None:
+        profile_a = _seven_phase_profile()
+        profile_b = _seven_phase_profile()
+        # Shift the second section's boundary values up, so its max exceeds
+        # the first section's (and its min no longer beats the first's).
+        for i in range(8):
+            profile_b.p[i] += 10.0
+        profile_b.pf += 10.0
+
+        trajectory = Trajectory(dofs=1, max_number_of_waypoints=1)
+        trajectory.profiles = [[profile_a], [profile_b]]
+        trajectory.cumulative_times = [
+            profile_a.t_sum[-1],
+            profile_a.t_sum[-1] + profile_b.t_sum[-1],
+        ]
+        trajectory.duration = trajectory.cumulative_times[-1]
+
+        extrema = trajectory.position_extrema()
+
+        self.assertEqual(len(extrema), 1)
+        self.assertAlmostEqual(extrema[0].max, profile_b.pf, places=9)
+        self.assertAlmostEqual(extrema[0].min, profile_a.p[0], places=9)
+
+
+class TestGetFirstTimeAtPosition(unittest.TestCase):
+    def test_finds_time_within_first_segment(self) -> None:
+        profile = _seven_phase_profile()
+        trajectory = _single_dof_trajectory(profile)
+
+        # profile.p[1] is reached exactly at t == profile.t[0] == 1.0.
+        found_time = trajectory._get_first_time_at_position(0, profile.p[1])
+
+        self.assertIsNotNone(found_time)
+        assert found_time is not None
+        self.assertAlmostEqual(found_time, 1.0, places=6)
+
+    def test_out_of_range_dof_returns_none(self) -> None:
+        trajectory = _single_dof_trajectory(_seven_phase_profile())
+        self.assertIsNone(trajectory._get_first_time_at_position(5, 0.0))
+
+    def test_unreached_position_returns_none(self) -> None:
+        trajectory = _single_dof_trajectory(_seven_phase_profile())
+        self.assertIsNone(trajectory._get_first_time_at_position(0, 1e9))
+
+
+class TestGetIntermediateDurations(unittest.TestCase):
+    def test_returns_cumulative_times(self) -> None:
+        trajectory = _single_dof_trajectory(_seven_phase_profile())
+        self.assertEqual(trajectory._get_intermediate_durations(), trajectory.cumulative_times)
+
+
+class TestConstruction(unittest.TestCase):
+    def test_single_section_default(self) -> None:
+        trajectory = Trajectory(dofs=2)
+        self.assertEqual(trajectory.degrees_of_freedom, 2)
+        self.assertEqual(len(trajectory.profiles), 1)
+        self.assertEqual(len(trajectory.profiles[0]), 2)
+        self.assertEqual(trajectory.cumulative_times, [0.0])
+        self.assertEqual(trajectory.duration, 0.0)
+        self.assertEqual(trajectory.independent_min_durations, [0.0, 0.0])
+
+    def test_max_number_of_waypoints_sizes_sections(self) -> None:
+        trajectory = Trajectory(dofs=1, max_number_of_waypoints=3)
+        self.assertEqual(len(trajectory.profiles), 4)
+        self.assertEqual(trajectory.cumulative_times, [0.0, 0.0, 0.0, 0.0])
diff --git a/tests/precision_time/__init__.py b/tests/precision_time/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/precision_time/test_precision_time_interval.py b/tests/precision_time/test_precision_time_interval.py
new file mode 100644
index 0000000..1022844
--- /dev/null
+++ b/tests/precision_time/test_precision_time_interval.py
@@ -0,0 +1,427 @@
+"""Unit tests for ``PrecisionTimeInterval``.
+
+Covers precisionTimeMath.md §Compliance requirements 2, 3, 4, 5, 6, 10 (the
+interval half), plus construction, accessors, full arithmetic/comparison
+surface, hashability, and ``NotImplemented`` fallback to ``TypeError``.
+"""
+
+import unittest
+from typing import Any
+
+from foundation_abc.math.mathEnums import NumericSign
+from foundation_abc.math.precisionTimeABC import (
+    ATTOSECONDS_PER_SECOND,
+    PrecisionTimeIntervalABC,
+)
+from foundationTypes.mathTypes.MathTypes import PrecisionTimeIntervalType
+
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+
+
+class TestConstruction(unittest.TestCase):
+    def test_default_is_zero(self) -> None:
+        interval = PrecisionTimeInterval()
+        self.assertEqual(interval.seconds, 0)
+        self.assertEqual(interval.attoseconds, 0)
+        self.assertEqual(interval.sign, NumericSign.ZERO)
+
+    def test_basic_seconds_and_attoseconds(self) -> None:
+        interval = PrecisionTimeInterval(seconds=5, attoseconds=250, sign=NumericSign.POSITIVE)
+        self.assertEqual(interval.seconds, 5)
+        self.assertEqual(interval.attoseconds, 250)
+        self.assertEqual(interval.sign, NumericSign.POSITIVE)
+
+    def test_negative_seconds_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            PrecisionTimeInterval(seconds=-1)
+
+    def test_negative_attoseconds_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            PrecisionTimeInterval(attoseconds=-1)
+
+    def test_carry_normalization(self) -> None:
+        """Compliance 4: attoseconds >= 10**18 carries into seconds."""
+        interval = PrecisionTimeInterval(
+            seconds=0, attoseconds=ATTOSECONDS_PER_SECOND + 5, sign=NumericSign.POSITIVE
+        )
+        self.assertEqual(interval.seconds, 1)
+        self.assertEqual(interval.attoseconds, 5)
+
+    def test_carry_normalization_multiple_seconds(self) -> None:
+        interval = PrecisionTimeInterval(
+            seconds=2, attoseconds=3 * ATTOSECONDS_PER_SECOND + 7, sign=NumericSign.POSITIVE
+        )
+        self.assertEqual(interval.seconds, 5)
+        self.assertEqual(interval.attoseconds, 7)
+
+    def test_zero_magnitude_forces_zero_sign(self) -> None:
+        interval = PrecisionTimeInterval(seconds=0, attoseconds=0, sign=NumericSign.NEGATIVE)
+        self.assertEqual(interval.sign, NumericSign.ZERO)
+
+
+class TestFromSeconds(unittest.TestCase):
+    def test_from_int_seconds(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(3)
+        self.assertEqual(interval.total_attoseconds, 3 * ATTOSECONDS_PER_SECOND)
+
+    def test_from_negative_int_seconds(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(-3)
+        self.assertEqual(interval.total_attoseconds, -3 * ATTOSECONDS_PER_SECOND)
+        self.assertEqual(interval.sign, NumericSign.NEGATIVE)
+
+    def test_from_float_seconds(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(1.5)
+        self.assertEqual(interval.total_attoseconds, 1_500_000_000_000_000_000)
+
+    def test_from_negative_float_seconds(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(-2.25)
+        self.assertEqual(interval.total_attoseconds, -2_250_000_000_000_000_000)
+
+    def test_from_zero_seconds_is_zero_sign(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(0)
+        self.assertEqual(interval.sign, NumericSign.ZERO)
+
+    def test_from_non_finite_float_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            PrecisionTimeInterval.from_seconds(float("inf"))
+        with self.assertRaises(ValueError):
+            PrecisionTimeInterval.from_seconds(float("nan"))
+
+
+class TestFromAttoseconds(unittest.TestCase):
+    def test_positive_total(self) -> None:
+        interval = PrecisionTimeInterval.from_attoseconds(ATTOSECONDS_PER_SECOND + 1)
+        self.assertEqual(interval.seconds, 1)
+        self.assertEqual(interval.attoseconds, 1)
+        self.assertEqual(interval.sign, NumericSign.POSITIVE)
+
+    def test_negative_total(self) -> None:
+        interval = PrecisionTimeInterval.from_attoseconds(-(ATTOSECONDS_PER_SECOND + 1))
+        self.assertEqual(interval.seconds, 1)
+        self.assertEqual(interval.attoseconds, 1)
+        self.assertEqual(interval.sign, NumericSign.NEGATIVE)
+
+    def test_zero_total(self) -> None:
+        interval = PrecisionTimeInterval.from_attoseconds(0)
+        self.assertEqual(interval.sign, NumericSign.ZERO)
+
+
+class TestFromString(unittest.TestCase):
+    def test_from_string_one_point_five(self) -> None:
+        """Compliance 2: from_string("1", "5") equals 1.5s exactly."""
+        interval = PrecisionTimeInterval.from_string("1", "5")
+        self.assertEqual(interval.total_attoseconds, 1_500_000_000_000_000_000)
+
+    def test_from_string_one_attosecond(self) -> None:
+        """Compliance 2: from_string("0", "000000000000000001") is 1 attosecond."""
+        interval = PrecisionTimeInterval.from_string("0", "000000000000000001")
+        self.assertEqual(interval.total_attoseconds, 1)
+
+    def test_from_string_negative(self) -> None:
+        interval = PrecisionTimeInterval.from_string("-2", "5")
+        self.assertEqual(interval.total_attoseconds, -2_500_000_000_000_000_000)
+        self.assertEqual(interval.sign, NumericSign.NEGATIVE)
+
+    def test_from_string_empty_fractional(self) -> None:
+        interval = PrecisionTimeInterval.from_string("7", "")
+        self.assertEqual(interval.total_attoseconds, 7 * ATTOSECONDS_PER_SECOND)
+
+    def test_from_string_too_many_fractional_digits_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            PrecisionTimeInterval.from_string("0", "1" * 19)
+
+    def test_from_string_non_numeric_seconds_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            PrecisionTimeInterval.from_string("abc", "5")
+
+    def test_from_string_non_numeric_fractional_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            PrecisionTimeInterval.from_string("1", "abc")
+
+
+class TestConstants(unittest.TestCase):
+    def test_zero(self) -> None:
+        self.assertEqual(PrecisionTimeInterval.ZERO.total_attoseconds, 0)
+
+    def test_one_second(self) -> None:
+        self.assertEqual(PrecisionTimeInterval.ONE_SECOND.total_attoseconds, ATTOSECONDS_PER_SECOND)
+
+    def test_one_decisecond(self) -> None:
+        self.assertEqual(
+            PrecisionTimeInterval.ONE_DECISECOND.total_attoseconds, ATTOSECONDS_PER_SECOND // 10
+        )
+
+    def test_one_millisecond(self) -> None:
+        self.assertEqual(
+            PrecisionTimeInterval.ONE_MILLISECOND.total_attoseconds,
+            ATTOSECONDS_PER_SECOND // 1_000,
+        )
+
+    def test_one_microsecond(self) -> None:
+        self.assertEqual(
+            PrecisionTimeInterval.ONE_MICROSECOND.total_attoseconds,
+            ATTOSECONDS_PER_SECOND // 1_000_000,
+        )
+
+
+class TestAccessors(unittest.TestCase):
+    def test_total_attoseconds_signed(self) -> None:
+        interval = PrecisionTimeInterval(seconds=1, attoseconds=0, sign=NumericSign.NEGATIVE)
+        self.assertEqual(interval.total_attoseconds, -ATTOSECONDS_PER_SECOND)
+
+    def test_seconds_as_float(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(2.5)
+        self.assertAlmostEqual(interval.seconds_as_float, 2.5)
+
+    def test_seconds_as_float_negative(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(-2.5)
+        self.assertAlmostEqual(interval.seconds_as_float, -2.5)
+
+
+class TestArithmeticExactness(unittest.TestCase):
+    def test_attosecond_exactness(self) -> None:
+        """Compliance 3: ONE_SECOND - from_attoseconds(1) has seconds=0,
+        attoseconds=10**18 - 1."""
+        result = PrecisionTimeInterval.ONE_SECOND - PrecisionTimeInterval.from_attoseconds(1)
+        self.assertEqual(result.seconds, 0)
+        self.assertEqual(result.attoseconds, ATTOSECONDS_PER_SECOND - 1)
+
+    def test_addition(self) -> None:
+        a = PrecisionTimeInterval.from_seconds(1)
+        b = PrecisionTimeInterval.from_seconds(2)
+        self.assertEqual((a + b).total_attoseconds, 3 * ATTOSECONDS_PER_SECOND)
+
+    def test_subtraction_crossing_zero(self) -> None:
+        a = PrecisionTimeInterval.from_seconds(1)
+        b = PrecisionTimeInterval.from_seconds(3)
+        result = a - b
+        self.assertEqual(result.total_attoseconds, -2 * ATTOSECONDS_PER_SECOND)
+        self.assertEqual(result.sign, NumericSign.NEGATIVE)
+
+    def test_unary_neg_and_pos(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(4)
+        self.assertEqual((-interval).total_attoseconds, -4 * ATTOSECONDS_PER_SECOND)
+        self.assertEqual((+interval).total_attoseconds, 4 * ATTOSECONDS_PER_SECOND)
+
+    def test_abs(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(-4)
+        self.assertEqual(abs(interval).total_attoseconds, 4 * ATTOSECONDS_PER_SECOND)
+
+
+class TestSignAlgebra(unittest.TestCase):
+    def test_negating_flips_sign(self) -> None:
+        """Compliance 5: negating flips sign; zero is NumericSign.ZERO and bool False."""
+        interval = PrecisionTimeInterval.from_seconds(3)
+        self.assertEqual(interval.sign, NumericSign.POSITIVE)
+        negated = -interval
+        self.assertEqual(negated.sign, NumericSign.NEGATIVE)
+        self.assertEqual((-negated).sign, NumericSign.POSITIVE)
+
+    def test_zero_sign_and_bool(self) -> None:
+        zero = PrecisionTimeInterval.ZERO
+        self.assertEqual(zero.sign, NumericSign.ZERO)
+        self.assertFalse(bool(zero))
+
+    def test_nonzero_bool_is_true(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(1)
+        self.assertTrue(bool(interval))
+
+    def test_negating_zero_is_still_zero(self) -> None:
+        self.assertEqual((-PrecisionTimeInterval.ZERO).sign, NumericSign.ZERO)
+
+
+class TestScalarRounding(unittest.TestCase):
+    def test_scalar_multiplication_rounds_to_nearest_attosecond(self) -> None:
+        """Compliance 6: pinned mult case — 3 atto * 2.5 (exact tie) rounds
+        half-to-even to 8."""
+        interval = PrecisionTimeInterval.from_attoseconds(3)
+        result = interval * 2.5
+        self.assertEqual(result.total_attoseconds, 8)
+
+    def test_scalar_multiplication_is_commutative(self) -> None:
+        interval = PrecisionTimeInterval.from_attoseconds(3)
+        self.assertEqual((interval * 2.5).total_attoseconds, (2.5 * interval).total_attoseconds)
+
+    def test_scalar_int_multiplication_is_exact(self) -> None:
+        interval = PrecisionTimeInterval.from_attoseconds(7)
+        self.assertEqual((interval * 3).total_attoseconds, 21)
+        self.assertEqual((3 * interval).total_attoseconds, 21)
+
+    def test_scalar_division_rounds_to_nearest_attosecond(self) -> None:
+        """Compliance 6: pinned div case — 7 atto / 2.0 (exact tie) rounds
+        half-to-even to 4."""
+        interval = PrecisionTimeInterval.from_attoseconds(7)
+        result = interval / 2.0
+        self.assertEqual(result.total_attoseconds, 4)
+
+    def test_scalar_int_division(self) -> None:
+        interval = PrecisionTimeInterval.from_attoseconds(9)
+        self.assertEqual((interval / 3).total_attoseconds, 3)
+
+    def test_scalar_division_by_zero_raises(self) -> None:
+        interval = PrecisionTimeInterval.from_attoseconds(9)
+        with self.assertRaises(ZeroDivisionError):
+            interval / 0
+
+    def test_scalar_multiplication_by_zero_is_zero(self) -> None:
+        interval = PrecisionTimeInterval.from_attoseconds(9)
+        self.assertEqual((interval * 0).sign, NumericSign.ZERO)
+
+
+class TestIntervalDivision(unittest.TestCase):
+    def test_interval_divided_by_interval_is_float_ratio(self) -> None:
+        numerator = PrecisionTimeInterval.from_attoseconds(10)
+        denominator = PrecisionTimeInterval.from_attoseconds(4)
+        result = numerator / denominator
+        self.assertIsInstance(result, float)
+        self.assertEqual(result, 2.5)
+
+    def test_interval_divided_by_zero_interval_raises(self) -> None:
+        numerator = PrecisionTimeInterval.from_attoseconds(10)
+        with self.assertRaises(ZeroDivisionError):
+            numerator / PrecisionTimeInterval.ZERO
+
+
+class TestOrdering(unittest.TestCase):
+    def test_equality(self) -> None:
+        a = PrecisionTimeInterval.from_seconds(1)
+        b = PrecisionTimeInterval.from_attoseconds(ATTOSECONDS_PER_SECOND)
+        self.assertEqual(a, b)
+
+    def test_less_than(self) -> None:
+        a = PrecisionTimeInterval.from_seconds(1)
+        b = PrecisionTimeInterval.from_seconds(2)
+        self.assertTrue(a < b)
+        self.assertFalse(b < a)
+
+    def test_less_than_or_equal(self) -> None:
+        a = PrecisionTimeInterval.from_seconds(1)
+        b = PrecisionTimeInterval.from_seconds(1)
+        self.assertTrue(a <= b)
+
+    def test_greater_than(self) -> None:
+        a = PrecisionTimeInterval.from_seconds(2)
+        b = PrecisionTimeInterval.from_seconds(1)
+        self.assertTrue(a > b)
+
+    def test_greater_than_or_equal(self) -> None:
+        a = PrecisionTimeInterval.from_seconds(2)
+        b = PrecisionTimeInterval.from_seconds(2)
+        self.assertTrue(a >= b)
+
+    def test_negative_orders_below_positive(self) -> None:
+        a = PrecisionTimeInterval.from_seconds(-1)
+        b = PrecisionTimeInterval.from_seconds(1)
+        self.assertTrue(a < b)
+
+    def test_total_ordering_sortable(self) -> None:
+        values = [
+            PrecisionTimeInterval.from_seconds(2),
+            PrecisionTimeInterval.from_seconds(-1),
+            PrecisionTimeInterval.from_seconds(0),
+        ]
+        ordered = sorted(values)
+        self.assertEqual(
+            [v.total_attoseconds for v in ordered],
+            [-ATTOSECONDS_PER_SECOND, 0, 2 * ATTOSECONDS_PER_SECOND],
+        )
+
+
+class TestHashability(unittest.TestCase):
+    def test_hash_is_consistent_with_equality(self) -> None:
+        a = PrecisionTimeInterval.from_seconds(1)
+        b = PrecisionTimeInterval.from_attoseconds(ATTOSECONDS_PER_SECOND)
+        self.assertEqual(a, b)
+        self.assertEqual(hash(a), hash(b))
+
+    def test_usable_as_dict_key(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(1)
+        mapping = {interval: "one second"}
+        self.assertEqual(mapping[PrecisionTimeInterval.from_seconds(1)], "one second")
+
+    def test_usable_in_set(self) -> None:
+        values = {
+            PrecisionTimeInterval.from_seconds(1),
+            PrecisionTimeInterval.from_attoseconds(ATTOSECONDS_PER_SECOND),
+        }
+        self.assertEqual(len(values), 1)
+
+
+class TestNotImplementedFallback(unittest.TestCase):
+    def test_addition_with_foreign_type_raises_type_error(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(1)
+        with self.assertRaises(TypeError):
+            interval + 1.0  # type: ignore[operator]
+
+    def test_subtraction_with_foreign_type_raises_type_error(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(1)
+        with self.assertRaises(TypeError):
+            interval - "not an interval"  # type: ignore[operator]
+
+    def test_equality_with_foreign_type_is_false(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(1)
+        self.assertFalse(interval == 1.0)
+        self.assertNotEqual(interval, object())
+
+    def test_ordering_with_foreign_type_raises_type_error(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(1)
+        with self.assertRaises(TypeError):
+            _ = interval < 1.0  # type: ignore[operator]
+
+    def test_division_by_foreign_type_raises_type_error(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(1)
+        with self.assertRaises(TypeError):
+            interval / "not a number"  # type: ignore[operator]
+
+
+class TestIsinstanceAndAbc(unittest.TestCase):
+    def test_isinstance_of_abc(self) -> None:
+        """Compliance 10: isinstance(x, PrecisionTimeIntervalABC)."""
+        interval = PrecisionTimeInterval.from_seconds(1)
+        self.assertIsInstance(interval, PrecisionTimeIntervalABC)
+
+
+class TestSerializationRoundTrip(unittest.TestCase):
+    """Compliance 1 (interval half): round-trip with the Tier-1 wire dict."""
+
+    def _round_trip(self, payload: dict[str, Any]) -> None:
+        wire = PrecisionTimeIntervalType.from_dict(payload).to_dict()
+        result = PrecisionTimeInterval.from_dict(wire).to_dict()
+        self.assertEqual(result, payload)
+
+    def test_round_trip_positive(self) -> None:
+        self._round_trip({"attoseconds": 123456789012345678, "seconds": 42, "sign": "positive"})
+
+    def test_round_trip_negative(self) -> None:
+        self._round_trip({"attoseconds": 1, "seconds": 0, "sign": "negative"})
+
+    def test_round_trip_zero(self) -> None:
+        self._round_trip({"attoseconds": 0, "seconds": 0, "sign": "zero"})
+
+    def test_round_trip_large_seconds(self) -> None:
+        self._round_trip(
+            {"attoseconds": 999999999999999999, "seconds": 10_000_000_000, "sign": "positive"}
+        )
+
+    def test_to_dict_matches_abc_shape(self) -> None:
+        interval = PrecisionTimeInterval(seconds=3, attoseconds=7, sign=NumericSign.POSITIVE)
+        self.assertEqual(
+            interval.to_dict(), {"attoseconds": 7, "seconds": 3, "sign": "positive"}
+        )
+
+    def test_from_dict_rejects_non_dict(self) -> None:
+        with self.assertRaises(TypeError):
+            PrecisionTimeInterval.from_dict("not a dict")
+
+
+class TestRepr(unittest.TestCase):
+    def test_repr_contains_components(self) -> None:
+        interval = PrecisionTimeInterval(seconds=3, attoseconds=7, sign=NumericSign.POSITIVE)
+        text = repr(interval)
+        self.assertIn("3", text)
+        self.assertIn("7", text)
+        self.assertIn("PrecisionTimeInterval", text)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/precision_time/test_precision_timestamp.py b/tests/precision_time/test_precision_timestamp.py
new file mode 100644
index 0000000..ae03350
--- /dev/null
+++ b/tests/precision_time/test_precision_timestamp.py
@@ -0,0 +1,468 @@
+"""Unit tests for ``PrecisionTimestamp``.
+
+Covers precisionTimeMath.md §Compliance requirements 1 (timestamp half), 7, 8,
+9, 10, plus construction, accessors, arithmetic, ordering, hash/eq-with-metadata,
+and serialization round-trip.
+"""
+
+import datetime
+import unittest
+from typing import Any
+
+from foundation_abc.math.mathEnums import NumericSign, ReferenceFrame, Timescale
+from foundation_abc.math.precisionTimeABC import (
+    ATTOSECONDS_PER_SECOND,
+    PrecisionTimestampABC,
+)
+from foundationTypes.mathTypes.MathTypes import PrecisionTimestampType
+
+from math_tools.errors import TimestampComparisonError
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.precision_time.precision_timestamp import PrecisionTimestamp
+
+
+class TestConstruction(unittest.TestCase):
+    def test_default_is_epoch(self) -> None:
+        ts = PrecisionTimestamp()
+        self.assertEqual(ts.seconds, 0)
+        self.assertEqual(ts.attoseconds, 0)
+        self.assertEqual(ts.sign, NumericSign.ZERO)
+        self.assertIsNone(ts.timescale)
+        self.assertIsNone(ts.reference_frame)
+        self.assertIsNone(ts.uncertainty)
+
+    def test_basic_seconds_and_attoseconds(self) -> None:
+        ts = PrecisionTimestamp(seconds=5, attoseconds=250, sign=NumericSign.POSITIVE)
+        self.assertEqual(ts.seconds, 5)
+        self.assertEqual(ts.attoseconds, 250)
+        self.assertEqual(ts.sign, NumericSign.POSITIVE)
+
+    def test_metadata_kwargs(self) -> None:
+        ts = PrecisionTimestamp(
+            seconds=1,
+            timescale=Timescale.TAI,
+            reference_frame=ReferenceFrame.EARTH_CENTER,
+            uncertainty=10,
+        )
+        self.assertEqual(ts.timescale, Timescale.TAI)
+        self.assertEqual(ts.reference_frame, ReferenceFrame.EARTH_CENTER)
+        self.assertEqual(ts.uncertainty, 10)
+
+
+class TestFromInterval(unittest.TestCase):
+    def test_from_interval_basic(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(5)
+        ts = PrecisionTimestamp.from_interval(interval)
+        self.assertEqual(ts.interval, interval)
+
+    def test_from_interval_with_metadata(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(5)
+        ts = PrecisionTimestamp.from_interval(interval, timescale=Timescale.UTC)
+        self.assertEqual(ts.timescale, Timescale.UTC)
+
+    def test_from_interval_negative(self) -> None:
+        interval = PrecisionTimeInterval.from_seconds(-5)
+        ts = PrecisionTimestamp.from_interval(interval)
+        self.assertEqual(ts.sign, NumericSign.NEGATIVE)
+        self.assertEqual(ts.seconds, 5)
+
+
+class TestFromDatetime(unittest.TestCase):
+    def test_naive_datetime_raises(self) -> None:
+        naive = datetime.datetime(2020, 1, 1)
+        with self.assertRaises(ValueError):
+            PrecisionTimestamp.from_datetime(naive)
+
+    def test_aware_datetime_after_epoch(self) -> None:
+        dt = datetime.datetime(2020, 1, 1, tzinfo=datetime.timezone.utc)
+        ts = PrecisionTimestamp.from_datetime(dt)
+        self.assertEqual(ts.sign, NumericSign.POSITIVE)
+        expected_seconds = int(dt.timestamp())
+        self.assertEqual(ts.seconds, expected_seconds)
+
+    def test_aware_datetime_pre_epoch(self) -> None:
+        dt = datetime.datetime(1960, 1, 1, tzinfo=datetime.timezone.utc)
+        ts = PrecisionTimestamp.from_datetime(dt)
+        self.assertEqual(ts.sign, NumericSign.NEGATIVE)
+
+    def test_aware_datetime_non_utc_tz(self) -> None:
+        tz = datetime.timezone(datetime.timedelta(hours=5))
+        dt = datetime.datetime(2020, 1, 1, tzinfo=tz)
+        ts = PrecisionTimestamp.from_datetime(dt)
+        expected = datetime.datetime(2020, 1, 1, tzinfo=tz).astimezone(datetime.timezone.utc)
+        self.assertEqual(ts.seconds, int(expected.timestamp()))
+
+
+class TestNow(unittest.TestCase):
+    def test_now_is_after_epoch(self) -> None:
+        ts = PrecisionTimestamp.now()
+        self.assertTrue(ts.is_after_epoch)
+
+    def test_now_carries_metadata(self) -> None:
+        ts = PrecisionTimestamp.now(timescale=Timescale.TAI)
+        self.assertEqual(ts.timescale, Timescale.TAI)
+
+
+class TestFromDays(unittest.TestCase):
+    def test_from_days_basic(self) -> None:
+        ts = PrecisionTimestamp.from_days(1)
+        self.assertEqual(ts.seconds, 86_400)
+
+    def test_from_days_with_attoseconds_of_day(self) -> None:
+        ts = PrecisionTimestamp.from_days(1, attoseconds_of_day=ATTOSECONDS_PER_SECOND * 5)
+        self.assertEqual(ts.seconds, 86_405)
+
+    def test_from_days_negative_sign(self) -> None:
+        ts = PrecisionTimestamp.from_days(1, sign=NumericSign.NEGATIVE)
+        self.assertEqual(ts.sign, NumericSign.NEGATIVE)
+        self.assertEqual(ts.seconds, 86_400)
+
+
+class TestEpochConstant(unittest.TestCase):
+    def test_epoch_is_epoch(self) -> None:
+        """Acceptance: EPOCH.is_epoch is True."""
+        self.assertTrue(PrecisionTimestamp.EPOCH.is_epoch)
+
+    def test_epoch_has_no_metadata(self) -> None:
+        self.assertIsNone(PrecisionTimestamp.EPOCH.timescale)
+        self.assertIsNone(PrecisionTimestamp.EPOCH.reference_frame)
+        self.assertIsNone(PrecisionTimestamp.EPOCH.uncertainty)
+
+
+class TestAccessors(unittest.TestCase):
+    def test_days_since_epoch(self) -> None:
+        ts = PrecisionTimestamp(seconds=86_400 * 3 + 10)
+        self.assertEqual(ts.days_since_epoch, 3)
+
+    def test_seconds_of_day(self) -> None:
+        ts = PrecisionTimestamp(seconds=86_400 * 3 + 10)
+        self.assertEqual(ts.seconds_of_day, 10)
+
+    def test_days_since_epoch_pre_epoch_is_negative(self) -> None:
+        """B-2: days_since_epoch is a signed offset, not a magnitude."""
+        ts = PrecisionTimestamp(seconds=10, sign=NumericSign.NEGATIVE)
+        self.assertEqual(ts.days_since_epoch, -1)
+
+    def test_seconds_of_day_pre_epoch_wraps_to_wall_clock_second(self) -> None:
+        """1969-12-31T23:59:50Z is 10s before epoch: the wall-clock second
+        within the UTC day is 86_390, not -10 or 10."""
+        ts = PrecisionTimestamp(seconds=10, sign=NumericSign.NEGATIVE)
+        self.assertEqual(ts.seconds_of_day, 86_390)
+
+    def test_days_since_epoch_far_pre_epoch(self) -> None:
+        dt = datetime.datetime(1960, 1, 1, tzinfo=datetime.timezone.utc)
+        ts = PrecisionTimestamp.from_datetime(dt)
+        self.assertEqual(ts.days_since_epoch, -3653)
+
+    def test_seconds_of_day_far_pre_epoch_midnight_is_zero(self) -> None:
+        dt = datetime.datetime(1960, 1, 1, tzinfo=datetime.timezone.utc)
+        ts = PrecisionTimestamp.from_datetime(dt)
+        self.assertEqual(ts.seconds_of_day, 0)
+
+    def test_seconds_of_day_bounds_pre_epoch(self) -> None:
+        ts = PrecisionTimestamp(seconds=10, sign=NumericSign.NEGATIVE)
+        self.assertGreaterEqual(ts.seconds_of_day, 0)
+        self.assertLess(ts.seconds_of_day, 86_400)
+
+    def test_seconds_of_day_bounds_post_epoch(self) -> None:
+        ts = PrecisionTimestamp(seconds=86_400 * 3 + 10)
+        self.assertGreaterEqual(ts.seconds_of_day, 0)
+        self.assertLess(ts.seconds_of_day, 86_400)
+
+    def test_as_datetime_round_trip_to_microsecond(self) -> None:
+        """Compliance 9: as_datetime/from_datetime round-trips to microsecond
+        precision."""
+        dt = datetime.datetime(2020, 6, 15, 12, 30, 45, 123456, tzinfo=datetime.timezone.utc)
+        ts = PrecisionTimestamp.from_datetime(dt)
+        self.assertEqual(ts.as_datetime, dt)
+
+    def test_as_datetime_round_trip_pre_epoch(self) -> None:
+        """Compliance 9: round-trip including a pre-epoch instant."""
+        dt = datetime.datetime(1955, 11, 12, 6, 0, 0, 654321, tzinfo=datetime.timezone.utc)
+        ts = PrecisionTimestamp.from_datetime(dt)
+        self.assertEqual(ts.as_datetime, dt)
+
+    def test_as_datetime_is_utc(self) -> None:
+        ts = PrecisionTimestamp.EPOCH
+        self.assertEqual(ts.as_datetime.tzinfo, datetime.timezone.utc)
+
+
+class TestArithmetic(unittest.TestCase):
+    def test_timestamp_plus_interval(self) -> None:
+        ts = PrecisionTimestamp.from_interval(PrecisionTimeInterval.from_seconds(5))
+        result = ts + PrecisionTimeInterval.from_seconds(3)
+        self.assertEqual(result.seconds, 8)
+
+    def test_interval_plus_timestamp(self) -> None:
+        ts = PrecisionTimestamp.from_interval(PrecisionTimeInterval.from_seconds(5))
+        result = PrecisionTimeInterval.from_seconds(3) + ts
+        self.assertEqual(result.seconds, 8)
+
+    def test_timestamp_minus_interval(self) -> None:
+        ts = PrecisionTimestamp.from_interval(PrecisionTimeInterval.from_seconds(5))
+        result = ts - PrecisionTimeInterval.from_seconds(3)
+        self.assertEqual(result.seconds, 2)
+
+    def test_timestamp_minus_timestamp_is_interval(self) -> None:
+        a = PrecisionTimestamp.from_interval(PrecisionTimeInterval.from_seconds(5))
+        b = PrecisionTimestamp.from_interval(PrecisionTimeInterval.from_seconds(3))
+        result = a - b
+        self.assertIsInstance(result, PrecisionTimeInterval)
+        self.assertEqual(result, PrecisionTimeInterval.from_seconds(2))
+
+    def test_timestamp_minus_timestamp_across_epoch_is_exact(self) -> None:
+        """Compliance 7: timestamp - timestamp across the epoch (one
+        pre-1970 operand) is exact."""
+        after = PrecisionTimestamp.from_interval(PrecisionTimeInterval.from_seconds(5))
+        before = PrecisionTimestamp.from_interval(PrecisionTimeInterval.from_seconds(-3))
+        result = after - before
+        self.assertEqual(result, PrecisionTimeInterval.from_seconds(8))
+
+    def test_metadata_carried_from_timestamp_on_add(self) -> None:
+        """Metadata propagation on ts +/- interval: carried from the
+        timestamp."""
+        ts = PrecisionTimestamp(
+            seconds=5,
+            timescale=Timescale.TAI,
+            reference_frame=ReferenceFrame.EARTH_CENTER,
+            uncertainty=7,
+        )
+        result = ts + PrecisionTimeInterval.from_seconds(1)
+        self.assertEqual(result.timescale, Timescale.TAI)
+        self.assertEqual(result.reference_frame, ReferenceFrame.EARTH_CENTER)
+        self.assertEqual(result.uncertainty, 7)
+
+    def test_metadata_carried_from_timestamp_on_sub(self) -> None:
+        ts = PrecisionTimestamp(seconds=5, timescale=Timescale.UTC)
+        result = ts - PrecisionTimeInterval.from_seconds(1)
+        self.assertEqual(result.timescale, Timescale.UTC)
+
+    def test_metadata_carried_when_interval_plus_timestamp(self) -> None:
+        ts = PrecisionTimestamp(seconds=5, timescale=Timescale.UTC)
+        result = PrecisionTimeInterval.from_seconds(1) + ts
+        self.assertEqual(result.timescale, Timescale.UTC)
+
+
+class TestOrdering(unittest.TestCase):
+    def test_equality_includes_metadata(self) -> None:
+        a = PrecisionTimestamp(seconds=1, timescale=Timescale.TAI)
+        b = PrecisionTimestamp(seconds=1, timescale=Timescale.UTC)
+        self.assertNotEqual(a, b)
+
+    def test_equality_same_metadata(self) -> None:
+        a = PrecisionTimestamp(seconds=1, timescale=Timescale.TAI)
+        b = PrecisionTimestamp(seconds=1, timescale=Timescale.TAI)
+        self.assertEqual(a, b)
+
+    def test_equality_ignores_uncertainty_difference_fails(self) -> None:
+        """Uncertainty IS part of eq's metadata per spec (all metadata
+        included in hash/eq)."""
+        a = PrecisionTimestamp(seconds=1, uncertainty=5)
+        b = PrecisionTimestamp(seconds=1, uncertainty=6)
+        self.assertNotEqual(a, b)
+
+    def test_ordering_compares_offsets_only(self) -> None:
+        """< / <= / > / >= compare offsets only (numeric ordering, ignoring
+        metadata)."""
+        a = PrecisionTimestamp(seconds=1, timescale=Timescale.TAI)
+        b = PrecisionTimestamp(seconds=2, timescale=Timescale.UTC)
+        self.assertTrue(a < b)
+        self.assertTrue(b > a)
+        self.assertTrue(a <= b)
+        self.assertTrue(b >= a)
+
+    def test_total_ordering_sortable(self) -> None:
+        values = [
+            PrecisionTimestamp.from_interval(PrecisionTimeInterval.from_seconds(2)),
+            PrecisionTimestamp.from_interval(PrecisionTimeInterval.from_seconds(-1)),
+            PrecisionTimestamp.from_interval(PrecisionTimeInterval.from_seconds(0)),
+        ]
+        ordered = sorted(values)
+        self.assertEqual(
+            [v.interval.total_attoseconds for v in ordered],
+            [-ATTOSECONDS_PER_SECOND, 0, 2 * ATTOSECONDS_PER_SECOND],
+        )
+
+
+class TestCanCompare(unittest.TestCase):
+    def test_both_none_metadata_can_compare(self) -> None:
+        a = PrecisionTimestamp(seconds=1)
+        b = PrecisionTimestamp(seconds=2)
+        self.assertTrue(a.can_compare(b))
+
+    def test_one_none_one_set_can_compare(self) -> None:
+        a = PrecisionTimestamp(seconds=1, timescale=Timescale.TAI)
+        b = PrecisionTimestamp(seconds=2)
+        self.assertTrue(a.can_compare(b))
+
+    def test_same_timescale_can_compare(self) -> None:
+        a = PrecisionTimestamp(seconds=1, timescale=Timescale.TAI)
+        b = PrecisionTimestamp(seconds=2, timescale=Timescale.TAI)
+        self.assertTrue(a.can_compare(b))
+
+    def test_differing_timescale_cannot_compare(self) -> None:
+        a = PrecisionTimestamp(seconds=1, timescale=Timescale.TAI)
+        b = PrecisionTimestamp(seconds=2, timescale=Timescale.UTC)
+        self.assertFalse(a.can_compare(b))
+
+    def test_differing_reference_frame_cannot_compare(self) -> None:
+        a = PrecisionTimestamp(seconds=1, reference_frame=ReferenceFrame.EARTH_CENTER)
+        b = PrecisionTimestamp(seconds=2, reference_frame=ReferenceFrame.LUNAR_CENTER)
+        self.assertFalse(a.can_compare(b))
+
+    def test_can_compare_ignores_uncertainty(self) -> None:
+        """can_compare is True when either side's metadata is None and
+        ignores uncertainty entirely."""
+        a = PrecisionTimestamp(seconds=1, uncertainty=1000)
+        b = PrecisionTimestamp(seconds=1, uncertainty=1)
+        self.assertTrue(a.can_compare(b))
+
+
+class TestCompareValidated(unittest.TestCase):
+    """Compliance 8: compare_validated raises TimestampComparisonError on
+    differing timescale (both set), differing frame (both set), and
+    overlapping uncertainty (both set, delta <= combined -- boundary case
+    delta == combined raises). Returns -1/0/1 otherwise."""
+
+    def test_returns_negative_one_when_less(self) -> None:
+        a = PrecisionTimestamp(seconds=1)
+        b = PrecisionTimestamp(seconds=2)
+        self.assertEqual(a.compare_validated(b), -1)
+
+    def test_returns_zero_when_equal(self) -> None:
+        a = PrecisionTimestamp(seconds=1)
+        b = PrecisionTimestamp(seconds=1)
+        self.assertEqual(a.compare_validated(b), 0)
+
+    def test_returns_positive_one_when_greater(self) -> None:
+        a = PrecisionTimestamp(seconds=2)
+        b = PrecisionTimestamp(seconds=1)
+        self.assertEqual(a.compare_validated(b), 1)
+
+    def test_raises_on_differing_timescale(self) -> None:
+        a = PrecisionTimestamp(seconds=1, timescale=Timescale.TAI)
+        b = PrecisionTimestamp(seconds=2, timescale=Timescale.UTC)
+        with self.assertRaises(TimestampComparisonError):
+            a.compare_validated(b)
+
+    def test_raises_on_differing_reference_frame(self) -> None:
+        a = PrecisionTimestamp(seconds=1, reference_frame=ReferenceFrame.EARTH_CENTER)
+        b = PrecisionTimestamp(seconds=2, reference_frame=ReferenceFrame.LUNAR_CENTER)
+        with self.assertRaises(TimestampComparisonError):
+            a.compare_validated(b)
+
+    def test_raises_on_overlapping_uncertainty(self) -> None:
+        a = PrecisionTimestamp(seconds=1, uncertainty=ATTOSECONDS_PER_SECOND)
+        b = PrecisionTimestamp(seconds=2, uncertainty=ATTOSECONDS_PER_SECOND)
+        with self.assertRaises(TimestampComparisonError):
+            a.compare_validated(b)
+
+    def test_boundary_delta_equals_combined_uncertainty_raises(self) -> None:
+        """Pinned boundary: delta == combined uncertainty raises (not <)."""
+        a = PrecisionTimestamp(seconds=1, uncertainty=1)
+        b = PrecisionTimestamp(
+            seconds=1, attoseconds=2, uncertainty=1
+        )  # delta = 2 atto, combined = 2 atto
+        with self.assertRaises(TimestampComparisonError):
+            a.compare_validated(b)
+
+    def test_delta_just_outside_combined_uncertainty_does_not_raise(self) -> None:
+        a = PrecisionTimestamp(seconds=1, uncertainty=1)
+        b = PrecisionTimestamp(
+            seconds=1, attoseconds=3, uncertainty=1
+        )  # delta = 3 atto, combined = 2 atto
+        self.assertEqual(a.compare_validated(b), -1)
+
+    def test_uncertainty_only_checked_when_both_set(self) -> None:
+        a = PrecisionTimestamp(seconds=1, uncertainty=ATTOSECONDS_PER_SECOND * 100)
+        b = PrecisionTimestamp(seconds=1, attoseconds=1)
+        self.assertEqual(a.compare_validated(b), -1)
+
+
+class TestHashability(unittest.TestCase):
+    def test_hash_includes_metadata(self) -> None:
+        a = PrecisionTimestamp(seconds=1, timescale=Timescale.TAI)
+        b = PrecisionTimestamp(seconds=1, timescale=Timescale.TAI)
+        self.assertEqual(a, b)
+        self.assertEqual(hash(a), hash(b))
+
+    def test_usable_in_set(self) -> None:
+        values = {
+            PrecisionTimestamp(seconds=1, timescale=Timescale.TAI),
+            PrecisionTimestamp(seconds=1, timescale=Timescale.TAI),
+        }
+        self.assertEqual(len(values), 1)
+
+
+class TestNotImplementedFallback(unittest.TestCase):
+    def test_equality_with_foreign_type_is_false(self) -> None:
+        ts = PrecisionTimestamp(seconds=1)
+        self.assertFalse(ts == 1.0)
+        self.assertNotEqual(ts, object())
+
+    def test_ordering_with_foreign_type_raises_type_error(self) -> None:
+        ts = PrecisionTimestamp(seconds=1)
+        with self.assertRaises(TypeError):
+            _ = ts < 1.0  # type: ignore[operator]
+
+    def test_addition_with_foreign_type_raises_type_error(self) -> None:
+        ts = PrecisionTimestamp(seconds=1)
+        with self.assertRaises(TypeError):
+            ts + 1.0  # type: ignore[operator]
+
+    def test_subtraction_with_foreign_type_raises_type_error(self) -> None:
+        ts = PrecisionTimestamp(seconds=1)
+        with self.assertRaises(TypeError):
+            ts - "not valid"  # type: ignore[operator]
+
+
+class TestIsinstanceAndAbc(unittest.TestCase):
+    def test_isinstance_of_abc(self) -> None:
+        """Compliance 10: isinstance(x, PrecisionTimestampABC)."""
+        ts = PrecisionTimestamp(seconds=1)
+        self.assertIsInstance(ts, PrecisionTimestampABC)
+
+
+class TestSerializationRoundTrip(unittest.TestCase):
+    """Compliance 1 (timestamp half): round-trip with PrecisionTimestampType
+    wire dicts (camelCase optional keys)."""
+
+    def _round_trip(self, payload: dict[str, Any]) -> None:
+        wire = PrecisionTimestampType.from_dict(payload).to_dict()
+        result = PrecisionTimestamp.from_dict(wire).to_dict()
+        self.assertEqual(result, payload)
+
+    def test_round_trip_minimal(self) -> None:
+        self._round_trip({"attoseconds": 0, "seconds": 5, "sign": "positive"})
+
+    def test_round_trip_with_all_metadata(self) -> None:
+        self._round_trip(
+            {
+                "attoseconds": 123,
+                "seconds": 5,
+                "sign": "positive",
+                "referenceFrame": "EarthCenter",
+                "timescale": "TAI",
+                "uncertainty": 42,
+            }
+        )
+
+    def test_round_trip_negative(self) -> None:
+        self._round_trip({"attoseconds": 1, "seconds": 0, "sign": "negative"})
+
+    def test_from_dict_rejects_non_dict(self) -> None:
+        with self.assertRaises(TypeError):
+            PrecisionTimestamp.from_dict("not a dict")
+
+
+class TestRepr(unittest.TestCase):
+    def test_repr_contains_components(self) -> None:
+        ts = PrecisionTimestamp(seconds=3, attoseconds=7)
+        text = repr(ts)
+        self.assertIn("3", text)
+        self.assertIn("7", text)
+        self.assertIn("PrecisionTimestamp", text)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/spatial/__init__.py b/tests/spatial/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/spatial/test_position.py b/tests/spatial/test_position.py
new file mode 100644
index 0000000..f98db91
--- /dev/null
+++ b/tests/spatial/test_position.py
@@ -0,0 +1,501 @@
+"""Unit tests for ``Position``.
+
+Covers spatialMath.md §Compliance requirements 1 (position half), 2, 3, 10,
+plus construction, accessors, arithmetic, normalization, and serialization
+round-trip.
+"""
+
+import unittest
+from typing import Any
+
+import numpy as np
+from foundation_abc.math.spatialABCs import PositionABC
+from foundationTypes.mathTypes.MathTypes import PositionType
+
+from math_tools.spatial.position import (
+    CylindricalCoordinates,
+    Position,
+    SphericalCoordinates,
+    SphericalIsoCoordinates,
+)
+
+
+class TestConstruction(unittest.TestCase):
+    def test_default_is_origin(self) -> None:
+        p = Position()
+        self.assertEqual(p.x, 0.0)
+        self.assertEqual(p.y, 0.0)
+        self.assertEqual(p.z, 0.0)
+
+    def test_basic_components(self) -> None:
+        p = Position(1.0, 2.0, 3.0)
+        self.assertEqual(p.x, 1.0)
+        self.assertEqual(p.y, 2.0)
+        self.assertEqual(p.z, 3.0)
+
+    def test_settable_components(self) -> None:
+        """Mutable: p.x = 1.0 is allowed."""
+        p = Position()
+        p.x = 1.0
+        p.y = 2.0
+        p.z = 3.0
+        self.assertEqual((p.x, p.y, p.z), (1.0, 2.0, 3.0))
+
+    def test_from_vector(self) -> None:
+        p = Position.from_vector([1.0, 2.0, 3.0])
+        self.assertEqual((p.x, p.y, p.z), (1.0, 2.0, 3.0))
+
+    def test_from_vector_copies(self) -> None:
+        arr = np.array([1.0, 2.0, 3.0])
+        p = Position.from_vector(arr)
+        arr[0] = 99.0
+        self.assertEqual(p.x, 1.0)
+
+    def test_from_vector_wrong_shape_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            Position.from_vector([1.0, 2.0])
+
+    def test_from_vector_wrong_shape_raises_too_many(self) -> None:
+        with self.assertRaises(ValueError):
+            Position.from_vector([1.0, 2.0, 3.0, 4.0])
+
+    def test_from_components(self) -> None:
+        p = Position.from_components(x=1.0, y=2.0, z=3.0)
+        self.assertEqual((p.x, p.y, p.z), (1.0, 2.0, 3.0))
+
+    def test_from_components_default(self) -> None:
+        p = Position.from_components()
+        self.assertEqual((p.x, p.y, p.z), (0.0, 0.0, 0.0))
+
+    def test_origin(self) -> None:
+        p = Position.origin()
+        self.assertEqual((p.x, p.y, p.z), (0.0, 0.0, 0.0))
+
+    def test_unit_x(self) -> None:
+        p = Position.unit_x()
+        self.assertEqual((p.x, p.y, p.z), (1.0, 0.0, 0.0))
+
+    def test_unit_y(self) -> None:
+        p = Position.unit_y()
+        self.assertEqual((p.x, p.y, p.z), (0.0, 1.0, 0.0))
+
+    def test_unit_z(self) -> None:
+        p = Position.unit_z()
+        self.assertEqual((p.x, p.y, p.z), (0.0, 0.0, 1.0))
+
+
+class TestCylindrical(unittest.TestCase):
+    def test_from_cylindrical_quarter_turn(self) -> None:
+        p = Position.from_cylindrical(radius=2.0, angle=np.pi / 2, height=5.0)
+        self.assertAlmostEqual(p.x, 0.0, places=12)
+        self.assertAlmostEqual(p.y, 2.0, places=12)
+        self.assertAlmostEqual(p.z, 5.0, places=12)
+
+    def test_cylindrical_accessor_type(self) -> None:
+        p = Position.from_cylindrical(radius=1.0, angle=0.3, height=1.0)
+        self.assertIsInstance(p.cylindrical, CylindricalCoordinates)
+
+    def test_cylindrical_inverse_grid(self) -> None:
+        """Compliance 2: init/accessor are mutual inverses over a grid."""
+        radii = [0.1, 1.0, 3.5, 10.0]
+        angles = np.linspace(-np.pi, np.pi, 13)
+        heights = [-2.0, 0.0, 4.0]
+        for radius in radii:
+            for angle in angles:
+                for height in heights:
+                    p = Position.from_cylindrical(radius, float(angle), height)
+                    result = p.cylindrical
+                    self.assertAlmostEqual(result.radius, radius, places=12)
+                    self.assertAlmostEqual(result.height, height, places=12)
+                    # angle is only well-defined when radius > 0
+                    self.assertAlmostEqual(
+                        np.arctan2(np.sin(result.angle - angle), np.cos(result.angle - angle)),
+                        0.0,
+                        places=12,
+                    )
+
+
+class TestSpherical(unittest.TestCase):
+    def test_from_spherical_equator(self) -> None:
+        p = Position.from_spherical(radius=1.0, azimuth=0.0, elevation=0.0)
+        self.assertAlmostEqual(p.x, 1.0, places=12)
+        self.assertAlmostEqual(p.y, 0.0, places=12)
+        self.assertAlmostEqual(p.z, 0.0, places=12)
+
+    def test_from_spherical_north_pole(self) -> None:
+        p = Position.from_spherical(radius=1.0, azimuth=0.0, elevation=np.pi / 2)
+        self.assertAlmostEqual(p.x, 0.0, places=12)
+        self.assertAlmostEqual(p.y, 0.0, places=12)
+        self.assertAlmostEqual(p.z, 1.0, places=12)
+
+    def test_spherical_accessor_type(self) -> None:
+        p = Position.from_spherical(radius=1.0, azimuth=0.3, elevation=0.2)
+        self.assertIsInstance(p.spherical, SphericalCoordinates)
+
+    def test_spherical_inverse_grid(self) -> None:
+        """Compliance 2: both spherical conventions inverse-tested over a
+        radius/angle grid, atol 1e-12."""
+        radii = [0.1, 1.0, 5.0]
+        azimuths = np.linspace(-np.pi + 1e-6, np.pi - 1e-6, 9)
+        elevations = np.linspace(-np.pi / 2 + 1e-6, np.pi / 2 - 1e-6, 9)
+        for radius in radii:
+            for azimuth in azimuths:
+                for elevation in elevations:
+                    p = Position.from_spherical(radius, float(azimuth), float(elevation))
+                    result = p.spherical
+                    self.assertAlmostEqual(result.radius, radius, delta=1e-9)
+                    self.assertAlmostEqual(result.elevation, float(elevation), delta=1e-9)
+                    self.assertAlmostEqual(
+                        np.arctan2(
+                            np.sin(result.azimuth - azimuth), np.cos(result.azimuth - azimuth)
+                        ),
+                        0.0,
+                        delta=1e-9,
+                    )
+
+
+class TestSphericalIso(unittest.TestCase):
+    def test_from_spherical_iso_north_pole(self) -> None:
+        p = Position.from_spherical_iso(radius=1.0, azimuth=0.0, polar=0.0)
+        self.assertAlmostEqual(p.x, 0.0, places=12)
+        self.assertAlmostEqual(p.y, 0.0, places=12)
+        self.assertAlmostEqual(p.z, 1.0, places=12)
+
+    def test_from_spherical_iso_equator(self) -> None:
+        p = Position.from_spherical_iso(radius=1.0, azimuth=0.0, polar=np.pi / 2)
+        self.assertAlmostEqual(p.x, 1.0, places=12)
+        self.assertAlmostEqual(p.y, 0.0, places=12)
+        self.assertAlmostEqual(p.z, 0.0, places=12)
+
+    def test_spherical_iso_accessor_type(self) -> None:
+        p = Position.from_spherical_iso(radius=1.0, azimuth=0.3, polar=0.2)
+        self.assertIsInstance(p.spherical_iso, SphericalIsoCoordinates)
+
+    def test_spherical_iso_inverse_grid(self) -> None:
+        """Compliance 2: ISO convention inverse-tested over a radius/angle
+        grid, atol 1e-12. Distinct convention from geographic ``spherical``:
+        polar (colatitude from +z) vs. elevation (from xy-plane)."""
+        radii = [0.1, 1.0, 5.0]
+        azimuths = np.linspace(-np.pi + 1e-6, np.pi - 1e-6, 9)
+        polars = np.linspace(1e-6, np.pi - 1e-6, 9)
+        for radius in radii:
+            for azimuth in azimuths:
+                for polar in polars:
+                    p = Position.from_spherical_iso(radius, float(azimuth), float(polar))
+                    result = p.spherical_iso
+                    self.assertAlmostEqual(result.radius, radius, delta=1e-9)
+                    self.assertAlmostEqual(result.polar, float(polar), delta=1e-9)
+                    self.assertAlmostEqual(
+                        np.arctan2(
+                            np.sin(result.azimuth - azimuth), np.cos(result.azimuth - azimuth)
+                        ),
+                        0.0,
+                        delta=1e-9,
+                    )
+
+    def test_spherical_and_spherical_iso_are_distinct_conventions(self) -> None:
+        """Same inputs (radius, azimuth, angle) produce different points
+        under the two conventions, except at shared reference points."""
+        p_geo = Position.from_spherical(radius=1.0, azimuth=0.3, elevation=0.3)
+        p_iso = Position.from_spherical_iso(radius=1.0, azimuth=0.3, polar=0.3)
+        self.assertFalse(p_geo.isclose(p_iso))
+
+
+class TestVectorProperties(unittest.TestCase):
+    def test_vector_returns_copy(self) -> None:
+        p = Position(1.0, 2.0, 3.0)
+        v = p.vector
+        v[0] = 99.0
+        self.assertEqual(p.x, 1.0)
+
+    def test_vector_values(self) -> None:
+        p = Position(1.0, 2.0, 3.0)
+        np.testing.assert_array_equal(p.vector, np.array([1.0, 2.0, 3.0]))
+
+    def test_components(self) -> None:
+        p = Position(1.0, 2.0, 3.0)
+        self.assertEqual(p.components, [1.0, 2.0, 3.0])
+
+    def test_magnitude(self) -> None:
+        p = Position(3.0, 4.0, 0.0)
+        self.assertEqual(p.magnitude, 5.0)
+
+    def test_magnitude_squared(self) -> None:
+        p = Position(3.0, 4.0, 0.0)
+        self.assertEqual(p.magnitude_squared, 25.0)
+
+    def test_norm_is_alias_of_magnitude(self) -> None:
+        p = Position(3.0, 4.0, 0.0)
+        self.assertEqual(p.norm, p.magnitude)
+
+    def test_abs_is_magnitude(self) -> None:
+        p = Position(3.0, 4.0, 0.0)
+        self.assertEqual(abs(p), p.magnitude)
+
+    def test_is_unit_true(self) -> None:
+        p = Position.unit_x()
+        self.assertTrue(p.is_unit)
+
+    def test_is_unit_false(self) -> None:
+        p = Position(2.0, 0.0, 0.0)
+        self.assertFalse(p.is_unit)
+
+    def test_is_unit_false_just_outside_tolerance(self) -> None:
+        """B-1: rtol must not leak in; 1e-5 relative slack is far outside the
+        spec's 1e-12 absolute tolerance."""
+        p = Position(1.00001, 0.0, 0.0)
+        self.assertFalse(p.is_unit)
+
+    def test_is_unit_true_just_inside_tolerance(self) -> None:
+        p = Position(1.0 + 1e-13, 0.0, 0.0)
+        self.assertTrue(p.is_unit)
+
+
+class TestCrossProduct(unittest.TestCase):
+    def test_unit_x_cross_unit_y_is_unit_z(self) -> None:
+        """Compliance 3: cross follows the right-hand rule."""
+        result = Position.unit_x().cross(Position.unit_y())
+        self.assertTrue(result.isclose(Position.unit_z()))
+
+    def test_unit_y_cross_unit_z_is_unit_x(self) -> None:
+        result = Position.unit_y().cross(Position.unit_z())
+        self.assertTrue(result.isclose(Position.unit_x()))
+
+    def test_unit_z_cross_unit_x_is_unit_y(self) -> None:
+        result = Position.unit_z().cross(Position.unit_x())
+        self.assertTrue(result.isclose(Position.unit_y()))
+
+    def test_cross_returns_position(self) -> None:
+        result = Position.unit_x().cross(Position.unit_y())
+        self.assertIsInstance(result, Position)
+
+
+class TestDotProduct(unittest.TestCase):
+    def test_dot_orthogonal_is_zero(self) -> None:
+        self.assertEqual(Position.unit_x().dot(Position.unit_y()), 0.0)
+
+    def test_dot_parallel(self) -> None:
+        self.assertEqual(Position(2.0, 0.0, 0.0).dot(Position(3.0, 0.0, 0.0)), 6.0)
+
+    def test_dot_general(self) -> None:
+        a = Position(1.0, 2.0, 3.0)
+        b = Position(4.0, 5.0, 6.0)
+        self.assertEqual(a.dot(b), 1 * 4 + 2 * 5 + 3 * 6)
+
+
+class TestDistance(unittest.TestCase):
+    def test_distance(self) -> None:
+        a = Position(0.0, 0.0, 0.0)
+        b = Position(3.0, 4.0, 0.0)
+        self.assertEqual(a.distance(b), 5.0)
+
+    def test_distance_squared(self) -> None:
+        a = Position(0.0, 0.0, 0.0)
+        b = Position(3.0, 4.0, 0.0)
+        self.assertEqual(a.distance_squared(b), 25.0)
+
+    def test_distance_to_self_is_zero(self) -> None:
+        p = Position(1.0, 2.0, 3.0)
+        self.assertEqual(p.distance(p), 0.0)
+
+
+class TestArithmeticOperators(unittest.TestCase):
+    def test_add_position(self) -> None:
+        result = Position(1.0, 2.0, 3.0) + Position(4.0, 5.0, 6.0)
+        self.assertEqual((result.x, result.y, result.z), (5.0, 7.0, 9.0))
+
+    def test_add_scalar(self) -> None:
+        result = Position(1.0, 2.0, 3.0) + 1.0
+        self.assertEqual((result.x, result.y, result.z), (2.0, 3.0, 4.0))
+
+    def test_radd_scalar(self) -> None:
+        result = 1.0 + Position(1.0, 2.0, 3.0)
+        self.assertEqual((result.x, result.y, result.z), (2.0, 3.0, 4.0))
+
+    def test_sub_position(self) -> None:
+        result = Position(4.0, 5.0, 6.0) - Position(1.0, 2.0, 3.0)
+        self.assertEqual((result.x, result.y, result.z), (3.0, 3.0, 3.0))
+
+    def test_sub_scalar(self) -> None:
+        result = Position(4.0, 5.0, 6.0) - 1.0
+        self.assertEqual((result.x, result.y, result.z), (3.0, 4.0, 5.0))
+
+    def test_rsub_scalar(self) -> None:
+        """scalar - position: component-wise."""
+        result = 10.0 - Position(1.0, 2.0, 3.0)
+        self.assertEqual((result.x, result.y, result.z), (9.0, 8.0, 7.0))
+
+    def test_mul_scalar(self) -> None:
+        result = Position(1.0, 2.0, 3.0) * 2.0
+        self.assertEqual((result.x, result.y, result.z), (2.0, 4.0, 6.0))
+
+    def test_rmul_scalar(self) -> None:
+        result = 2.0 * Position(1.0, 2.0, 3.0)
+        self.assertEqual((result.x, result.y, result.z), (2.0, 4.0, 6.0))
+
+    def test_truediv_scalar(self) -> None:
+        result = Position(2.0, 4.0, 6.0) / 2.0
+        self.assertEqual((result.x, result.y, result.z), (1.0, 2.0, 3.0))
+
+    def test_iadd_position(self) -> None:
+        p = Position(1.0, 2.0, 3.0)
+        p += Position(1.0, 1.0, 1.0)
+        self.assertEqual((p.x, p.y, p.z), (2.0, 3.0, 4.0))
+
+    def test_iadd_scalar(self) -> None:
+        p = Position(1.0, 2.0, 3.0)
+        p += 1.0
+        self.assertEqual((p.x, p.y, p.z), (2.0, 3.0, 4.0))
+
+    def test_isub_position(self) -> None:
+        p = Position(4.0, 5.0, 6.0)
+        p -= Position(1.0, 1.0, 1.0)
+        self.assertEqual((p.x, p.y, p.z), (3.0, 4.0, 5.0))
+
+    def test_imul_scalar(self) -> None:
+        p = Position(1.0, 2.0, 3.0)
+        p *= 2.0
+        self.assertEqual((p.x, p.y, p.z), (2.0, 4.0, 6.0))
+
+    def test_itruediv_scalar(self) -> None:
+        p = Position(2.0, 4.0, 6.0)
+        p /= 2.0
+        self.assertEqual((p.x, p.y, p.z), (1.0, 2.0, 3.0))
+
+    def test_neg(self) -> None:
+        result = -Position(1.0, -2.0, 3.0)
+        self.assertEqual((result.x, result.y, result.z), (-1.0, 2.0, -3.0))
+
+    def test_pos(self) -> None:
+        p = Position(1.0, -2.0, 3.0)
+        result = +p
+        self.assertEqual((result.x, result.y, result.z), (1.0, -2.0, 3.0))
+        self.assertIsNot(result, p)
+
+    def test_add_unsupported_type_returns_not_implemented(self) -> None:
+        with self.assertRaises(TypeError):
+            Position(1.0, 2.0, 3.0) + "not a position"  # type: ignore[operator]
+
+    def test_mul_unsupported_type_raises(self) -> None:
+        with self.assertRaises(TypeError):
+            Position(1.0, 2.0, 3.0) * Position(1.0, 2.0, 3.0)  # type: ignore[operator]
+
+
+class TestNormalization(unittest.TestCase):
+    def test_normalize_in_place(self) -> None:
+        p = Position(3.0, 4.0, 0.0)
+        p.normalize()
+        self.assertAlmostEqual(p.magnitude, 1.0, places=12)
+        self.assertAlmostEqual(p.x, 0.6, places=12)
+        self.assertAlmostEqual(p.y, 0.8, places=12)
+
+    def test_normalize_zero_vector_raises(self) -> None:
+        p = Position(0.0, 0.0, 0.0)
+        with self.assertRaises(ValueError):
+            p.normalize()
+
+    def test_normalized_returns_copy(self) -> None:
+        p = Position(3.0, 4.0, 0.0)
+        result = p.normalized()
+        self.assertIsNot(result, p)
+        self.assertEqual(p.magnitude, 5.0)  # original unchanged
+        self.assertAlmostEqual(result.magnitude, 1.0, places=12)
+
+    def test_normalized_zero_vector_raises(self) -> None:
+        p = Position(0.0, 0.0, 0.0)
+        with self.assertRaises(ValueError):
+            p.normalized()
+
+    def test_normalized_is_unit(self) -> None:
+        p = Position(1.0, 2.0, 3.0).normalized()
+        self.assertTrue(p.is_unit)
+
+
+class TestComparison(unittest.TestCase):
+    def test_equality_exact(self) -> None:
+        self.assertEqual(Position(1.0, 2.0, 3.0), Position(1.0, 2.0, 3.0))
+
+    def test_equality_different_values(self) -> None:
+        self.assertNotEqual(Position(1.0, 2.0, 3.0), Position(1.0, 2.0, 3.1))
+
+    def test_equality_with_foreign_type_is_false(self) -> None:
+        self.assertFalse(Position(1.0, 2.0, 3.0) == "not a position")
+        self.assertNotEqual(Position(1.0, 2.0, 3.0), object())
+
+    def test_isclose_within_tolerance(self) -> None:
+        a = Position(1.0, 2.0, 3.0)
+        b = Position(1.0 + 1e-10, 2.0, 3.0)
+        self.assertTrue(a.isclose(b, rtol=1e-9, atol=1e-9))
+
+    def test_isclose_outside_tolerance(self) -> None:
+        a = Position(1.0, 2.0, 3.0)
+        b = Position(1.1, 2.0, 3.0)
+        self.assertFalse(a.isclose(b, rtol=1e-9, atol=0.0))
+
+    def test_repr_contains_components(self) -> None:
+        text = repr(Position(1.0, 2.0, 3.0))
+        self.assertIn("Position", text)
+        self.assertIn("1.0", text)
+        self.assertIn("2.0", text)
+        self.assertIn("3.0", text)
+
+
+class TestHashability(unittest.TestCase):
+    def test_hash_is_none(self) -> None:
+        """Compliance 10: __hash__ is None (mutable -> unhashable)."""
+        self.assertIsNone(Position.__hash__)
+
+    def test_unhashable_raises_type_error(self) -> None:
+        with self.assertRaises(TypeError):
+            hash(Position(1.0, 2.0, 3.0))
+
+
+class TestArrayConversion(unittest.TestCase):
+    def test_asarray_shape(self) -> None:
+        """Compliance 10: np.asarray(p) returns the (3,) vector."""
+        p = Position(1.0, 2.0, 3.0)
+        arr = np.asarray(p)
+        self.assertEqual(arr.shape, (3,))
+        np.testing.assert_array_equal(arr, np.array([1.0, 2.0, 3.0]))
+
+    def test_asarray_is_independent_copy(self) -> None:
+        p = Position(1.0, 2.0, 3.0)
+        arr = np.asarray(p)
+        arr[0] = 99.0
+        self.assertEqual(p.x, 1.0)
+
+
+class TestIsinstanceAndAbc(unittest.TestCase):
+    def test_isinstance_of_abc(self) -> None:
+        p = Position(1.0, 2.0, 3.0)
+        self.assertIsInstance(p, PositionABC)
+
+
+class TestSerializationRoundTrip(unittest.TestCase):
+    """Compliance 1 (position half): round-trip with PositionType wire dicts."""
+
+    def _round_trip(self, payload: dict[str, Any]) -> None:
+        wire = PositionType.from_dict(payload).to_dict()
+        result = Position.from_dict(wire).to_dict()
+        self.assertEqual(result, payload)
+
+    def test_round_trip_origin(self) -> None:
+        self._round_trip({"x": 0.0, "y": 0.0, "z": 0.0})
+
+    def test_round_trip_general(self) -> None:
+        self._round_trip({"x": 1.0, "y": 2.0, "z": 3.0})
+
+    def test_round_trip_negative(self) -> None:
+        self._round_trip({"x": -1.5, "y": 2.5, "z": -3.5})
+
+    def test_to_dict_keys(self) -> None:
+        d = Position(1.0, 2.0, 3.0).to_dict()
+        self.assertEqual(d, {"x": 1.0, "y": 2.0, "z": 3.0})
+
+    def test_from_dict_with_integers(self) -> None:
+        p = Position.from_dict({"x": 1, "y": 2, "z": 3})
+        self.assertEqual((p.x, p.y, p.z), (1.0, 2.0, 3.0))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/spatial/test_quaternion_additions.py b/tests/spatial/test_quaternion_additions.py
new file mode 100644
index 0000000..8e4b5cf
--- /dev/null
+++ b/tests/spatial/test_quaternion_additions.py
@@ -0,0 +1,131 @@
+"""Unit tests for the chunk 07 ``Quaternion`` additions.
+
+Covers spatialMath.md §Quaternion additions: ``dot``,
+``rotation_matrix_elements``, ``rotate_position``, ``__array__``, and the
+snake_case aliases ``from_numpy_quaternion`` / ``to_unit_spherical_small_circle``.
+
+The existing ``tests/test_quaternion.py`` (~90 tests) is untouched by this
+chunk; this file only exercises the additive surface.
+"""
+
+import unittest
+from dataclasses import FrozenInstanceError
+
+import numpy as np
+from numpy.testing import assert_allclose
+
+from math_tools.spatial.position import Position
+from math_tools.spatial.quaternion import Quaternion, RotationMatrixElements
+
+
+class TestDot(unittest.TestCase):
+    def test_orthogonal_is_zero(self) -> None:
+        q1 = Quaternion.from_components(1.0, 0.0, 0.0, 0.0)
+        q2 = Quaternion.from_components(0.0, 1.0, 0.0, 0.0)
+        self.assertEqual(q1.dot(q2), 0.0)
+
+    def test_self_dot_is_norm_squared(self) -> None:
+        q = Quaternion.from_components(1.0, 2.0, 3.0, 4.0)
+        assert_allclose(q.dot(q), q.norm**2, rtol=1e-12)
+
+    def test_general_dot(self) -> None:
+        q1 = Quaternion.from_components(1.0, 2.0, 3.0, 4.0)
+        q2 = Quaternion.from_components(5.0, 6.0, 7.0, 8.0)
+        expected = 1.0 * 5.0 + 2.0 * 6.0 + 3.0 * 7.0 + 4.0 * 8.0
+        assert_allclose(q1.dot(q2), expected, rtol=1e-12)
+
+
+class TestRotationMatrixElements(unittest.TestCase):
+    def test_matches_to_rotation_matrix(self) -> None:
+        q = Quaternion.from_axis_angle(np.array([0.0, 0.0, 1.0]), np.pi / 3)
+        matrix = q.to_rotation_matrix()
+        elements = q.rotation_matrix_elements
+
+        self.assertIsInstance(elements, RotationMatrixElements)
+        assert_allclose(elements.xx, matrix[0, 0])
+        assert_allclose(elements.xy, matrix[0, 1])
+        assert_allclose(elements.xz, matrix[0, 2])
+        assert_allclose(elements.yx, matrix[1, 0])
+        assert_allclose(elements.yy, matrix[1, 1])
+        assert_allclose(elements.yz, matrix[1, 2])
+        assert_allclose(elements.zx, matrix[2, 0])
+        assert_allclose(elements.zy, matrix[2, 1])
+        assert_allclose(elements.zz, matrix[2, 2])
+
+    def test_is_frozen(self) -> None:
+        q = Quaternion.identity()
+        elements = q.rotation_matrix_elements
+        with self.assertRaises(FrozenInstanceError):
+            elements.xx = 99.0  # type: ignore[misc]
+
+
+class TestRotatePosition(unittest.TestCase):
+    def test_matches_rotate_vector(self) -> None:
+        q = Quaternion.from_axis_angle(np.array([0.0, 0.0, 1.0]), np.pi / 2)
+        p = Position(1.0, 0.0, 0.0)
+
+        rotated = q.rotate_position(p)
+        expected = q.rotate_vector(p.vector)
+
+        self.assertIsInstance(rotated, Position)
+        assert_allclose(rotated.vector, expected, atol=1e-12)
+
+    def test_identity_leaves_position_unchanged(self) -> None:
+        q = Quaternion.identity()
+        p = Position(1.0, 2.0, 3.0)
+        rotated = q.rotate_position(p)
+        assert_allclose(rotated.vector, p.vector)
+
+
+class TestArrayConversion(unittest.TestCase):
+    def test_array_order_is_wxyz(self) -> None:
+        q = Quaternion.from_components(1.0, 2.0, 3.0, 4.0)
+        arr = np.asarray(q)
+        assert_allclose(arr, [1.0, 2.0, 3.0, 4.0])
+        self.assertEqual(arr.dtype, np.float64)
+
+    def test_array_via_dunder_directly(self) -> None:
+        q = Quaternion.from_components(0.5, 0.5, 0.5, 0.5)
+        arr = q.__array__()
+        assert_allclose(arr, [0.5, 0.5, 0.5, 0.5])
+
+
+class TestSnakeCaseAliases(unittest.TestCase):
+    def test_from_numpy_quaternion_is_same_as_camel_case(self) -> None:
+        self.assertIs(Quaternion.from_numpy_quaternion, Quaternion.fromNumpyQuaternion)
+
+    def test_from_numpy_quaternion_behaves_the_same(self) -> None:
+        import quaternion as npq  # type: ignore[import-untyped]
+
+        raw = npq.quaternion(1.0, 2.0, 3.0, 4.0)
+        q = Quaternion.from_numpy_quaternion(raw)
+        self.assertEqual((q.w, q.x, q.y, q.z), (1.0, 2.0, 3.0, 4.0))
+
+    def test_to_unit_spherical_small_circle_is_same_as_camel_case(self) -> None:
+        self.assertIs(
+            Quaternion.to_unit_spherical_small_circle,
+            Quaternion.to_unitSphericalSmallCircle,
+        )
+
+    def test_to_unit_spherical_small_circle_behaves_the_same(self) -> None:
+        q = Quaternion.identity()
+        result = q.to_unit_spherical_small_circle()
+        expected = q.to_unitSphericalSmallCircle()
+        self.assertEqual(result.azimuth, expected.azimuth)
+        self.assertEqual(result.polar, expected.polar)
+        self.assertEqual(result.radius_angle, expected.radius_angle)
+
+
+class TestHashability(unittest.TestCase):
+    def test_hash_is_none(self) -> None:
+        """spatialMath.md Compliance 10: __hash__ is None for all three
+        classes, set explicitly (not merely a dataclass side effect)."""
+        self.assertIsNone(Quaternion.__hash__)
+
+    def test_unhashable_raises_type_error(self) -> None:
+        with self.assertRaises(TypeError):
+            hash(Quaternion.from_components(1.0, 0.0, 0.0, 0.0))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/spatial/test_spatial_pose.py b/tests/spatial/test_spatial_pose.py
new file mode 100644
index 0000000..8f5a391
--- /dev/null
+++ b/tests/spatial/test_spatial_pose.py
@@ -0,0 +1,416 @@
+"""Unit tests for ``SpatialPose``.
+
+Covers spatialMath.md §SpatialPose and §Compliance requirements 4-8:
+Denavit-Hartenberg construction (4), composition algebra (5), interpolation
+(6), double-cover-safe angular distance (7), and the homogeneous-matrix
+round trip (8). Also covers construction, passthrough properties,
+translation, inverse/relative pose, distances, normalization, comparison,
+and wire-format round trip against ``SpatialTransformType``.
+"""
+
+import unittest
+from typing import Any
+
+import numpy as np
+from foundation_abc.math.spatialABCs import SpatialTransformABC
+from foundationTypes.mathTypes.MathTypes import SpatialTransformType
+from numpy.testing import assert_allclose
+
+from math_tools.spatial.position import Position
+from math_tools.spatial.quaternion import Quaternion
+from math_tools.spatial.spatial_pose import SpatialPose
+
+
+class TestConstruction(unittest.TestCase):
+    def test_default_is_identity(self) -> None:
+        pose = SpatialPose()
+        self.assertEqual((pose.x, pose.y, pose.z), (0.0, 0.0, 0.0))
+        self.assertEqual((pose.qw, pose.qx, pose.qy, pose.qz), (1.0, 0.0, 0.0, 0.0))
+
+    def test_explicit_components(self) -> None:
+        position = Position(1.0, 2.0, 3.0)
+        orientation = Quaternion.from_axis_angle(np.array([0.0, 0.0, 1.0]), np.pi / 2)
+        pose = SpatialPose(position, orientation)
+        self.assertEqual((pose.x, pose.y, pose.z), (1.0, 2.0, 3.0))
+        self.assertIs(pose.orientation, orientation)
+
+    def test_position_is_copied_not_aliased(self) -> None:
+        """Position is mutable; SpatialPose must not alias the caller's instance."""
+        position = Position(1.0, 2.0, 3.0)
+        pose = SpatialPose(position)
+        position.x = 99.0
+        self.assertEqual(pose.x, 1.0)
+
+    def test_identity_classmethod(self) -> None:
+        pose = SpatialPose.identity()
+        self.assertEqual((pose.x, pose.y, pose.z), (0.0, 0.0, 0.0))
+        self.assertEqual((pose.qw, pose.qx, pose.qy, pose.qz), (1.0, 0.0, 0.0, 0.0))
+
+    def test_from_components_defaults(self) -> None:
+        pose = SpatialPose.from_components()
+        self.assertTrue(pose.isclose(SpatialPose.identity()))
+
+    def test_from_components_explicit(self) -> None:
+        pose = SpatialPose.from_components(x=1.0, y=2.0, z=3.0, qw=0.0, qx=1.0, qy=0.0, qz=0.0)
+        self.assertEqual((pose.x, pose.y, pose.z), (1.0, 2.0, 3.0))
+        self.assertEqual((pose.qw, pose.qx, pose.qy, pose.qz), (0.0, 1.0, 0.0, 0.0))
+
+    def test_isinstance_of_abc(self) -> None:
+        pose = SpatialPose()
+        self.assertIsInstance(pose, SpatialTransformABC)
+
+
+class TestFromHomogeneous(unittest.TestCase):
+    def test_wrong_shape_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            SpatialPose.from_homogeneous(np.eye(3))
+
+    def test_non_rigid_bottom_row_raises(self) -> None:
+        matrix = np.eye(4)
+        matrix[3, 3] = 2.0
+        with self.assertRaises(ValueError):
+            SpatialPose.from_homogeneous(matrix)
+
+    def test_non_rigid_bottom_row_nonzero_raises(self) -> None:
+        matrix = np.eye(4)
+        matrix[3, 0] = 1.0
+        with self.assertRaises(ValueError):
+            SpatialPose.from_homogeneous(matrix)
+
+    def test_identity_round_trip(self) -> None:
+        pose = SpatialPose.identity()
+        recovered = SpatialPose.from_homogeneous(pose.homogeneous)
+        self.assertTrue(recovered.isclose(pose, atol=1e-9))
+
+    def test_round_trip_general(self) -> None:
+        """Compliance 8: homogeneous / from_homogeneous round-trip."""
+        position = Position(1.0, -2.0, 3.5)
+        orientation = Quaternion.from_axis_angle(np.array([1.0, 1.0, 0.0]), 1.234)
+        pose = SpatialPose(position, orientation)
+        recovered = SpatialPose.from_homogeneous(pose.homogeneous)
+        self.assertTrue(recovered.isclose(pose, atol=1e-9))
+
+    def test_round_trip_non_normalized_orientation(self) -> None:
+        """Compliance 8: non-normalized input quaternion is normalized on export."""
+        position = Position(1.0, 2.0, 3.0)
+        non_unit_orientation = Quaternion.from_components(2.0, 0.0, 0.0, 0.0)  # norm == 2
+        pose = SpatialPose(position, non_unit_orientation)
+
+        matrix = pose.homogeneous
+        recovered = SpatialPose.from_homogeneous(matrix)
+
+        self.assertTrue(recovered.position.isclose(position, atol=1e-9))
+        self.assertTrue(recovered.orientation.isclose(Quaternion.identity(), atol=1e-9))
+        self.assertAlmostEqual(recovered.orientation.norm, 1.0, places=9)
+
+
+class TestDenavitHartenberg(unittest.TestCase):
+    """Compliance 4: pinned against published DH parameter sets."""
+
+    def test_two_link_planar_arm(self) -> None:
+        """a1 = a2 = 1, alpha = d = 0, theta = (90deg, 0deg).
+
+        Link 1 (a=1, alpha=0, d=0, theta=90deg): position (0, 1, 0),
+        rotation = +90deg about z.
+        Link 2, expressed in link 1's frame (a=1, alpha=0, d=0, theta=0deg):
+        position (1, 0, 0), identity rotation.
+        Chained: end_effector = pose1 * pose2.
+        position = pos1 + R1 @ pos2 = (0, 1, 0) + R_z(90deg) @ (1, 0, 0)
+                 = (0, 1, 0) + (0, 1, 0) = (0, 2, 0).
+        """
+        pose1 = SpatialPose.from_denavit_hartenberg(a=1.0, alpha=0.0, d=0.0, theta=np.pi / 2)
+        pose2 = SpatialPose.from_denavit_hartenberg(a=1.0, alpha=0.0, d=0.0, theta=0.0)
+
+        end_effector = pose1 * pose2
+
+        assert_allclose(end_effector.position.vector, [0.0, 2.0, 0.0], atol=1e-9)
+
+    def test_non_planar_link_with_nonzero_alpha(self) -> None:
+        """a=1, alpha=90deg, d=1, theta=90deg (a non-planar set: alpha != 0).
+
+        ct=cos(90deg)=0, st=sin(90deg)=1, ca=cos(90deg)=0, sa=sin(90deg)=1.
+        position = (a*ct, a*st, d) = (0, 1, 1).
+        rotation matrix (standard DH form):
+            [ ct, -st*ca,  st*sa ]   [ 0, 0, 1 ]
+            [ st,  ct*ca, -ct*sa ] = [ 1, 0, 0 ]
+            [  0,     sa,     ca ]   [ 0, 1, 0 ]
+        (a proper rotation: e_x -> e_y, e_y -> e_z, e_z -> e_x, a 120deg
+        rotation about the (1, 1, 1) axis).
+        """
+        pose = SpatialPose.from_denavit_hartenberg(a=1.0, alpha=np.pi / 2, d=1.0, theta=np.pi / 2)
+
+        expected_position = [0.0, 1.0, 1.0]
+        expected_rotation_matrix = np.array(
+            [
+                [0.0, 0.0, 1.0],
+                [1.0, 0.0, 0.0],
+                [0.0, 1.0, 0.0],
+            ]
+        )
+
+        assert_allclose(pose.position.vector, expected_position, atol=1e-9)
+        assert_allclose(pose.orientation.to_rotation_matrix(), expected_rotation_matrix, atol=1e-9)
+
+
+class TestComposition(unittest.TestCase):
+    """Compliance 5: composition algebra."""
+
+    def _sample_poses(self) -> tuple[SpatialPose, SpatialPose]:
+        a = SpatialPose(
+            Position(1.0, 2.0, 3.0),
+            Quaternion.from_axis_angle(np.array([0.0, 0.0, 1.0]), np.pi / 3),
+        )
+        b = SpatialPose(
+            Position(-1.0, 0.5, 2.0),
+            Quaternion.from_axis_angle(np.array([1.0, 0.0, 0.0]), np.pi / 5),
+        )
+        return a, b
+
+    def test_composition_recipe(self) -> None:
+        a, b = self._sample_poses()
+        result = a * b
+
+        expected_position = a.position + a.orientation.rotate_position(b.position)
+        expected_orientation = a.orientation * b.orientation
+
+        self.assertTrue(result.position.isclose(expected_position, atol=1e-12))
+        self.assertTrue(result.orientation.isclose(expected_orientation, atol=1e-12))
+
+    def test_pose_times_position_equals_transform(self) -> None:
+        a, _ = self._sample_poses()
+        p = Position(0.5, -0.25, 1.5)
+
+        self.assertTrue((a * p).isclose(a.transform(p), atol=1e-12))
+
+    def test_pose_times_inverse_is_identity(self) -> None:
+        a, _ = self._sample_poses()
+        result = a * a.inverse()
+        self.assertTrue(result.isclose(SpatialPose.identity(), atol=1e-9))
+
+    def test_composition_associativity_via_transform(self) -> None:
+        a, b = self._sample_poses()
+        p = Position(2.0, -3.0, 0.5)
+
+        composed = (a * b).transform(p)
+        chained = a.transform(b.transform(p))
+
+        self.assertTrue(composed.isclose(chained, atol=1e-9))
+
+
+class TestTranslated(unittest.TestCase):
+    def test_shifts_position_only(self) -> None:
+        orientation = Quaternion.from_axis_angle(np.array([0.0, 1.0, 0.0]), 0.7)
+        pose = SpatialPose(Position(1.0, 1.0, 1.0), orientation)
+        shifted = pose.translated(Position(1.0, 2.0, 3.0))
+
+        assert_allclose(shifted.position.vector, [2.0, 3.0, 4.0])
+        self.assertTrue(shifted.orientation.isclose(orientation))
+
+
+class TestRelativePose(unittest.TestCase):
+    def test_relative_pose_matches_inverse_times_other(self) -> None:
+        a = SpatialPose(
+            Position(1.0, 0.0, 0.0),
+            Quaternion.from_axis_angle(np.array([0.0, 0.0, 1.0]), np.pi / 4),
+        )
+        b = SpatialPose(
+            Position(0.0, 1.0, 0.0),
+            Quaternion.from_axis_angle(np.array([0.0, 0.0, 1.0]), np.pi / 2),
+        )
+
+        relative = a.relative_pose(b)
+        expected = a.inverse() * b
+
+        self.assertTrue(relative.isclose(expected, atol=1e-12))
+
+    def test_relative_pose_to_self_is_identity(self) -> None:
+        a = SpatialPose(
+            Position(3.0, -1.0, 2.0),
+            Quaternion.from_axis_angle(np.array([1.0, 1.0, 1.0]), 1.1),
+        )
+        self.assertTrue(a.relative_pose(a).isclose(SpatialPose.identity(), atol=1e-9))
+
+
+class TestInterpolate(unittest.TestCase):
+    """Compliance 6: endpoints + half-angle midpoint."""
+
+    def _rotation_only_poses(self) -> tuple[SpatialPose, SpatialPose]:
+        start = SpatialPose.identity()
+        end = SpatialPose(
+            Position.origin(), Quaternion.from_axis_angle(np.array([0.0, 0.0, 1.0]), np.pi / 2)
+        )
+        return start, end
+
+    def test_t_zero_returns_self(self) -> None:
+        start, end = self._rotation_only_poses()
+        result = start.interpolate(end, 0.0)
+        self.assertTrue(result.isclose(start, atol=1e-12))
+
+    def test_t_one_returns_other(self) -> None:
+        start, end = self._rotation_only_poses()
+        result = start.interpolate(end, 1.0)
+        self.assertTrue(result.isclose(end, atol=1e-9))
+
+    def test_midpoint_is_half_angle_for_pure_rotation(self) -> None:
+        start, end = self._rotation_only_poses()
+        midpoint = start.interpolate(end, 0.5)
+        self.assertAlmostEqual(midpoint.orientation.angle, (np.pi / 2) / 2.0, places=9)
+
+    def test_position_lerp(self) -> None:
+        start = SpatialPose(Position(0.0, 0.0, 0.0))
+        end = SpatialPose(Position(4.0, 0.0, 0.0))
+        result = start.interpolate(end, 0.25)
+        assert_allclose(result.position.vector, [1.0, 0.0, 0.0], atol=1e-12)
+
+    def test_t_unclamped_extrapolates(self) -> None:
+        start, end = self._rotation_only_poses()
+        result = start.interpolate(end, 2.0)
+        # 2x the 90deg rotation from start to end
+        self.assertAlmostEqual(result.orientation.angle, np.pi, places=9)
+
+
+class TestAngularDistance(unittest.TestCase):
+    """Compliance 7: angular_distance(q, -q) == 0."""
+
+    def test_double_cover_distance_is_zero(self) -> None:
+        orientation = Quaternion.from_axis_angle(np.array([0.0, 0.0, 1.0]), np.pi / 2)
+        a = SpatialPose(Position.origin(), orientation)
+        b = SpatialPose(Position.origin(), -orientation)
+
+        self.assertAlmostEqual(a.angular_distance(b), 0.0, places=9)
+
+    def test_identity_to_self_is_zero(self) -> None:
+        a = SpatialPose.identity()
+        self.assertAlmostEqual(a.angular_distance(a), 0.0, places=9)
+
+    def test_known_angle(self) -> None:
+        a = SpatialPose.identity()
+        b = SpatialPose(
+            Position.origin(), Quaternion.from_axis_angle(np.array([0.0, 0.0, 1.0]), np.pi / 3)
+        )
+        self.assertAlmostEqual(a.angular_distance(b), np.pi / 3, places=9)
+
+
+class TestPositionDistance(unittest.TestCase):
+    def test_position_distance_matches_position_distance(self) -> None:
+        a = SpatialPose(Position(0.0, 0.0, 0.0))
+        b = SpatialPose(Position(3.0, 4.0, 0.0))
+        self.assertAlmostEqual(a.position_distance(b), 5.0, places=12)
+
+    def test_position_distance_squared(self) -> None:
+        a = SpatialPose(Position(0.0, 0.0, 0.0))
+        b = SpatialPose(Position(3.0, 4.0, 0.0))
+        self.assertAlmostEqual(a.position_distance_squared(b), 25.0, places=12)
+
+
+class TestNormalize(unittest.TestCase):
+    def test_normalized_returns_copy_with_unit_orientation(self) -> None:
+        position = Position(1.0, 2.0, 3.0)
+        non_unit = Quaternion.from_components(2.0, 0.0, 0.0, 0.0)
+        pose = SpatialPose(position, non_unit)
+
+        result = pose.normalized()
+
+        self.assertAlmostEqual(result.orientation.norm, 1.0, places=12)
+        self.assertTrue(result.position.isclose(position))
+        # original is untouched
+        self.assertAlmostEqual(pose.orientation.norm, 2.0, places=12)
+
+    def test_normalize_mutates_in_place(self) -> None:
+        non_unit = Quaternion.from_components(2.0, 0.0, 0.0, 0.0)
+        pose = SpatialPose(Position(1.0, 2.0, 3.0), non_unit)
+        pose.normalize()
+        self.assertAlmostEqual(pose.orientation.norm, 1.0, places=12)
+
+    def test_is_unit_delegates_to_orientation(self) -> None:
+        pose = SpatialPose(Position(1.0, 2.0, 3.0), Quaternion.from_components(2.0, 0.0, 0.0, 0.0))
+        self.assertFalse(pose.is_unit)
+        pose.normalize()
+        self.assertTrue(pose.is_unit)
+
+
+class TestComparison(unittest.TestCase):
+    def test_equal_poses(self) -> None:
+        a = SpatialPose(Position(1.0, 2.0, 3.0), Quaternion.from_components(1.0, 0.0, 0.0, 0.0))
+        b = SpatialPose(Position(1.0, 2.0, 3.0), Quaternion.from_components(1.0, 0.0, 0.0, 0.0))
+        self.assertEqual(a, b)
+
+    def test_unequal_poses(self) -> None:
+        a = SpatialPose(Position(1.0, 2.0, 3.0))
+        b = SpatialPose(Position(1.0, 2.0, 3.1))
+        self.assertNotEqual(a, b)
+
+    def test_equal_to_non_pose_is_false(self) -> None:
+        a = SpatialPose()
+        self.assertFalse(a == object())
+
+    def test_isclose(self) -> None:
+        a = SpatialPose(Position(1.0, 2.0, 3.0))
+        b = SpatialPose(Position(1.0 + 1e-12, 2.0, 3.0))
+        self.assertTrue(a.isclose(b))
+
+    def test_isclose_double_cover_orientation(self) -> None:
+        """Compliance 7 / spatialMath double-cover: q and -q are the same
+        rotation, so isclose must treat them as equal poses."""
+        position = Position(1.0, 2.0, 3.0)
+        orientation = Quaternion.from_axis_angle(np.array([0.0, 0.0, 1.0]), np.pi / 3)
+        a = SpatialPose(position, orientation)
+        b = SpatialPose(Position(1.0, 2.0, 3.0), -orientation)
+        self.assertTrue(a.isclose(b))
+
+    def test_isclose_false_for_different_orientation(self) -> None:
+        a = SpatialPose(Position(1.0, 2.0, 3.0), Quaternion.from_components(1.0, 0.0, 0.0, 0.0))
+        b = SpatialPose(
+            Position(1.0, 2.0, 3.0),
+            Quaternion.from_axis_angle(np.array([0.0, 0.0, 1.0]), np.pi / 2),
+        )
+        self.assertFalse(a.isclose(b))
+
+    def test_hash_is_none(self) -> None:
+        """Mutable, numpy-backed: unhashable, pinned by test."""
+        self.assertIsNone(SpatialPose.__hash__)
+
+    def test_repr(self) -> None:
+        pose = SpatialPose()
+        self.assertIn("SpatialPose", repr(pose))
+
+
+class TestSerializationRoundTrip(unittest.TestCase):
+    """Compliance 1: round-trip with SpatialTransformType wire dicts."""
+
+    def _round_trip(self, payload: dict[str, Any]) -> None:
+        wire = SpatialTransformType.from_dict(payload).to_dict()
+        result = SpatialPose.from_dict(wire).to_dict()
+        self.assertEqual(result, payload)
+
+    def test_round_trip_identity(self) -> None:
+        self._round_trip(
+            {
+                "position": {"x": 0.0, "y": 0.0, "z": 0.0},
+                "orientation": {"w": 1.0, "x": 0.0, "y": 0.0, "z": 0.0},
+            }
+        )
+
+    def test_round_trip_general(self) -> None:
+        self._round_trip(
+            {
+                "position": {"x": 1.0, "y": -2.0, "z": 3.5},
+                "orientation": {
+                    "w": 0.7071067811865476,
+                    "x": 0.0,
+                    "y": 0.0,
+                    "z": 0.7071067811865476,
+                },
+            }
+        )
+
+    def test_to_dict_keys(self) -> None:
+        pose = SpatialPose(Position(1.0, 2.0, 3.0), Quaternion.from_components(1.0, 0.0, 0.0, 0.0))
+        d = pose.to_dict()
+        self.assertEqual(set(d.keys()), {"position", "orientation"})
+        self.assertEqual(d["position"], {"x": 1.0, "y": 2.0, "z": 3.0})
+        self.assertEqual(d["orientation"], {"w": 1.0, "x": 0.0, "y": 0.0, "z": 0.0})
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/spherical/__init__.py b/tests/spherical/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/spherical/test_public_surface.py b/tests/spherical/test_public_surface.py
new file mode 100644
index 0000000..a7a042b
--- /dev/null
+++ b/tests/spherical/test_public_surface.py
@@ -0,0 +1,96 @@
+"""Pin the ``math_tools.spherical`` and ``math_plot_helpers`` public surface.
+
+Per mathToolsArchitecture.md §Shared conventions (Public surface), every
+package/subpackage ``__init__.py`` re-exports its public API with
+``__all__``, and consumers import from the subpackage level, never deep
+module paths. This test pins each subpackage's ``__all__`` and asserts every
+name resolves to the module-defined function by identity (no shadow copies),
+mirroring ``tests/test_public_surface.py``'s identity-check shape.
+"""
+
+import unittest
+
+import math_plot_helpers
+import math_plot_helpers.plot_unit_spherical
+import math_tools.spherical
+import math_tools.spherical.constructors
+import math_tools.spherical.spherical_generators
+import math_tools.spherical.spherical_transforms
+
+
+class TestSphericalPublicSurface(unittest.TestCase):
+    def test_all_pins_exact_function_set(self) -> None:
+        expected = {
+            "arc_from_two_points",
+            "generate_spherical_arc_points",
+            "generate_spherical_small_circle_points",
+            "cartesian_to_spherical",
+            "compute_spherical_arc_endpoint",
+            "plate_carree_transform",
+            "spherical_to_cartesian",
+        }
+        self.assertEqual(set(math_tools.spherical.__all__), expected)
+        self.assertEqual(len(math_tools.spherical.__all__), len(expected))
+
+    def test_every_public_name_resolves_by_identity(self) -> None:
+        identity_sources = {
+            "arc_from_two_points": (
+                math_tools.spherical.constructors.arc_from_two_points
+            ),
+            "generate_spherical_arc_points": (
+                math_tools.spherical.spherical_generators.generate_spherical_arc_points
+            ),
+            "generate_spherical_small_circle_points": (
+                math_tools.spherical.spherical_generators.generate_spherical_small_circle_points
+            ),
+            "cartesian_to_spherical": (
+                math_tools.spherical.spherical_transforms.cartesian_to_spherical
+            ),
+            "compute_spherical_arc_endpoint": (
+                math_tools.spherical.spherical_transforms.compute_spherical_arc_endpoint
+            ),
+            "plate_carree_transform": (
+                math_tools.spherical.spherical_transforms.plate_carree_transform
+            ),
+            "spherical_to_cartesian": (
+                math_tools.spherical.spherical_transforms.spherical_to_cartesian
+            ),
+        }
+        for name, source in identity_sources.items():
+            with self.subTest(name=name):
+                self.assertIs(getattr(math_tools.spherical, name), source)
+
+
+class TestMathPlotHelpersPublicSurface(unittest.TestCase):
+    def test_all_pins_exact_function_set(self) -> None:
+        expected = {
+            "plot_unit_spherical_advanced",
+            "plot_unit_spherical_polar",
+            "plot_unit_spherical_3d",
+            "plot_unit_spherical_multiplot",
+        }
+        self.assertEqual(set(math_plot_helpers.__all__), expected)
+        self.assertEqual(len(math_plot_helpers.__all__), len(expected))
+
+    def test_every_public_name_resolves_by_identity(self) -> None:
+        identity_sources = {
+            "plot_unit_spherical_advanced": (
+                math_plot_helpers.plot_unit_spherical.plot_unit_spherical_advanced
+            ),
+            "plot_unit_spherical_polar": (
+                math_plot_helpers.plot_unit_spherical.plot_unit_spherical_polar
+            ),
+            "plot_unit_spherical_3d": (
+                math_plot_helpers.plot_unit_spherical.plot_unit_spherical_3d
+            ),
+            "plot_unit_spherical_multiplot": (
+                math_plot_helpers.plot_unit_spherical.plot_unit_spherical_multiplot
+            ),
+        }
+        for name, source in identity_sources.items():
+            with self.subTest(name=name):
+                self.assertIs(getattr(math_plot_helpers, name), source)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_errors.py b/tests/test_errors.py
new file mode 100644
index 0000000..a546ae6
--- /dev/null
+++ b/tests/test_errors.py
@@ -0,0 +1,46 @@
+"""Unit tests for the ``math_tools.errors`` exception hierarchy."""
+
+import unittest
+
+from math_tools.errors import (
+    MathToolsError,
+    PolynomialSolveError,
+    TimestampComparisonError,
+    WaveformCompatibilityError,
+)
+
+
+class TestMathToolsErrorHierarchy(unittest.TestCase):
+    def test_math_tools_error_is_an_exception(self) -> None:
+        self.assertTrue(issubclass(MathToolsError, Exception))
+
+    def test_waveform_compatibility_error_subclasses_math_tools_error(self) -> None:
+        self.assertTrue(issubclass(WaveformCompatibilityError, MathToolsError))
+
+    def test_timestamp_comparison_error_subclasses_math_tools_error(self) -> None:
+        self.assertTrue(issubclass(TimestampComparisonError, MathToolsError))
+
+    def test_polynomial_solve_error_subclasses_math_tools_error(self) -> None:
+        self.assertTrue(issubclass(PolynomialSolveError, MathToolsError))
+
+    def test_waveform_compatibility_error_is_catchable_as_math_tools_error(self) -> None:
+        with self.assertRaises(MathToolsError):
+            raise WaveformCompatibilityError("dt mismatch")
+
+    def test_timestamp_comparison_error_is_catchable_as_math_tools_error(self) -> None:
+        with self.assertRaises(MathToolsError):
+            raise TimestampComparisonError("timescale mismatch")
+
+    def test_polynomial_solve_error_is_catchable_as_math_tools_error(self) -> None:
+        with self.assertRaises(MathToolsError):
+            raise PolynomialSolveError("ill-posed request")
+
+    def test_math_tools_error_message_is_preserved(self) -> None:
+        try:
+            raise WaveformCompatibilityError("boom")
+        except MathToolsError as exc:
+            self.assertEqual(str(exc), "boom")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_governance.py b/tests/test_governance.py
new file mode 100644
index 0000000..e55f021
--- /dev/null
+++ b/tests/test_governance.py
@@ -0,0 +1,128 @@
+"""Governance-doc conformance tests.
+
+Per templateConformance.md §Gap 3-4 (compliance checklist):
+
+- ``.claude/CLAUDE.md`` exists and links every ``*.md`` under ``.claude/specs/``.
+- ``README.md`` no longer contains the "Boilerplate" stub text.
+- No ``pyMathTools`` (pre-rename name) references remain anywhere in the tree.
+- Every public package (an ``__init__.py`` that defines ``__all__``) ships
+  ``py.typed``.
+"""
+
+import ast
+import unittest
+from pathlib import Path
+
+REPO_ROOT = Path(__file__).resolve().parent.parent
+CLAUDE_MD = REPO_ROOT / ".claude" / "CLAUDE.md"
+SPECS_DIR = REPO_ROOT / ".claude" / "specs"
+README_MD = REPO_ROOT / "README.md"
+SRC_DIR = REPO_ROOT / "src"
+MAKEFILE = REPO_ROOT / "Makefile"
+PYPROJECT_TOML = REPO_ROOT / "pyproject.toml"
+EXAMPLES_DIR = REPO_ROOT / "examples"
+TESTS_DIR = REPO_ROOT / "tests"
+
+
+class TestClaudeMdExistsAndLinksSpecs(unittest.TestCase):
+    def test_claude_md_exists(self) -> None:
+        self.assertTrue(CLAUDE_MD.is_file(), f"expected {CLAUDE_MD} to exist")
+
+    def test_claude_md_links_every_spec(self) -> None:
+        claude_md_text = CLAUDE_MD.read_text(encoding="utf-8")
+        spec_files = sorted(SPECS_DIR.glob("*.md"))
+        self.assertGreaterEqual(len(spec_files), 1, f"expected specs under {SPECS_DIR}")
+
+        missing = [
+            spec_file.name for spec_file in spec_files if spec_file.name not in claude_md_text
+        ]
+        self.assertEqual(
+            missing,
+            [],
+            f".claude/CLAUDE.md is missing links to: {missing}",
+        )
+
+
+class TestReadmeHasNoBoilerplate(unittest.TestCase):
+    def test_readme_exists(self) -> None:
+        self.assertTrue(README_MD.is_file(), f"expected {README_MD} to exist")
+
+    def test_readme_contains_no_boilerplate_text(self) -> None:
+        readme_text = README_MD.read_text(encoding="utf-8")
+        self.assertNotIn("Boilerplate", readme_text)
+
+
+class TestNoPreRenamePackageName(unittest.TestCase):
+    """templateConformance.md Gap 1 (rename): ``pyMathTools`` must never
+    reappear -- a rename regression (stray import, stale doc reference)
+    would otherwise pass the gate silently."""
+
+    # Built via concatenation, not a literal, so this test doesn't trip on
+    # its own docstring/name when scanning source text for the string.
+    _STALE_NAME = "py" + "MathTools"
+
+    _SCAN_ROOTS = (SRC_DIR, TESTS_DIR, EXAMPLES_DIR)
+    _SCAN_FILES = (MAKEFILE, PYPROJECT_TOML)
+    _TEXT_SUFFIXES = {".py", ".md", ".json", ".toml", ".cfg", ".txt"}
+    # This governance test's own module necessarily documents the stale
+    # name it is checking for; exclude it from the scan.
+    _SELF = Path(__file__).resolve()
+
+    def test_no_pymathtools_references(self) -> None:
+        hits: list[str] = []
+        for root in self._SCAN_ROOTS:
+            for path in root.rglob("*"):
+                if (
+                    not path.is_file()
+                    or path == self._SELF
+                    or "__pycache__" in path.parts
+                    or path.suffix not in self._TEXT_SUFFIXES
+                ):
+                    continue
+                text = path.read_text(encoding="utf-8", errors="ignore")
+                if self._STALE_NAME in text:
+                    hits.append(str(path.relative_to(REPO_ROOT)))
+        for path in self._SCAN_FILES:
+            text = path.read_text(encoding="utf-8", errors="ignore")
+            if self._STALE_NAME in text:
+                hits.append(str(path.relative_to(REPO_ROOT)))
+
+        self.assertEqual(hits, [], f"found stale '{self._STALE_NAME}' references in: {hits}")
+
+
+class TestPublicPackagesShipPyTyped(unittest.TestCase):
+    """templateConformance.md Gap 1.4: every package dir with a public API
+    (an ``__init__.py`` defining ``__all__``) must ship ``py.typed``
+    (PEP 561), so a dropped marker fails the gate instead of silently
+    degrading downstream type-checking."""
+
+    @staticmethod
+    def _assigns_dunder_all(node: ast.stmt) -> bool:
+        if not isinstance(node, ast.Assign):
+            return False
+        return any(
+            isinstance(target, ast.Name) and target.id == "__all__" for target in node.targets
+        )
+
+    def _public_package_dirs(self) -> list[Path]:
+        public_dirs: list[Path] = []
+        for init_file in SRC_DIR.rglob("__init__.py"):
+            tree = ast.parse(init_file.read_text(encoding="utf-8"), filename=str(init_file))
+            if any(self._assigns_dunder_all(node) for node in tree.body):
+                public_dirs.append(init_file.parent)
+        return public_dirs
+
+    def test_every_public_package_has_py_typed(self) -> None:
+        public_dirs = self._public_package_dirs()
+        self.assertGreaterEqual(len(public_dirs), 1, f"expected public packages under {SRC_DIR}")
+
+        missing = [
+            str(pkg_dir.relative_to(REPO_ROOT))
+            for pkg_dir in public_dirs
+            if not (pkg_dir / "py.typed").is_file()
+        ]
+        self.assertEqual(missing, [], f"public package(s) missing py.typed: {missing}")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_package_layering.py b/tests/test_package_layering.py
new file mode 100644
index 0000000..eaa0bc5
--- /dev/null
+++ b/tests/test_package_layering.py
@@ -0,0 +1,159 @@
+"""Dependency-direction tests for the ``math_tools`` / ``math_plot_helpers`` split.
+
+Per templateConformance.md §Gap 5, the layering contract is:
+
+- ``math_tools`` never imports ``math_plot_helpers`` or ``matplotlib``.
+- ``math_plot_helpers`` may import ``math_tools``.
+- Only ``math_plot_helpers`` imports ``matplotlib``.
+- ``math_tools.otg`` (once it exists) never imports ``numpy`` (real-time
+  control-loop constraint; guarded to skip until the package exists so OTG
+  chunks inherit enforcement for free).
+
+Enforced via a static AST scan (no imports executed) of every module under
+``src/``, mirroring py-foundationTools' ``tests/test_package_layering.py``.
+"""
+
+import ast
+from pathlib import Path
+
+SRC_ROOT = Path(__file__).resolve().parent.parent / "src"
+MATH_TOOLS_ROOT = SRC_ROOT / "math_tools"
+MATH_PLOT_HELPERS_ROOT = SRC_ROOT / "math_plot_helpers"
+OTG_ROOT = MATH_TOOLS_ROOT / "otg"
+DSP_ROOT = MATH_TOOLS_ROOT / "waveforms" / "dsp"
+_DSP_ALLOWED_SIBLING_MODULES = {"_protocol", "_common"}
+
+
+def _imported_top_level_names(module_path: Path) -> set[str]:
+    """Return the top-level package name of every module imported by ``module_path``."""
+    tree = ast.parse(module_path.read_text(encoding="utf-8"), filename=str(module_path))
+    names: set[str] = set()
+    for node in ast.walk(tree):
+        if isinstance(node, ast.Import):
+            for alias in node.names:
+                names.add(alias.name.split(".")[0])
+        elif isinstance(node, ast.ImportFrom):
+            # node.level > 0 is a relative import (`from . import x`); it can only
+            # resolve within the same package, so it is never forbidden.
+            if node.level == 0 and node.module:
+                names.add(node.module.split(".")[0])
+    return names
+
+
+def test_math_tools_does_not_import_math_plot_helpers() -> None:
+    violations: dict[str, set[str]] = {}
+    for module_path in MATH_TOOLS_ROOT.rglob("*.py"):
+        imported = _imported_top_level_names(module_path) & {"math_plot_helpers"}
+        if imported:
+            violations[str(module_path.relative_to(SRC_ROOT))] = imported
+
+    assert not violations, (
+        "math_tools must not import math_plot_helpers (one-way dependency: "
+        f"math_plot_helpers -> math_tools), but found: {violations}"
+    )
+
+
+def test_math_tools_does_not_import_matplotlib() -> None:
+    violations: dict[str, set[str]] = {}
+    for module_path in MATH_TOOLS_ROOT.rglob("*.py"):
+        imported = _imported_top_level_names(module_path) & {"matplotlib"}
+        if imported:
+            violations[str(module_path.relative_to(SRC_ROOT))] = imported
+
+    assert not violations, (
+        "math_tools must not import matplotlib (matplotlib is "
+        f"math_plot_helpers-only), but found: {violations}"
+    )
+
+
+def test_only_math_plot_helpers_imports_matplotlib() -> None:
+    violations: dict[str, set[str]] = {}
+    for module_path in SRC_ROOT.rglob("*.py"):
+        if MATH_PLOT_HELPERS_ROOT in module_path.parents:
+            continue
+        imported = _imported_top_level_names(module_path) & {"matplotlib"}
+        if imported:
+            violations[str(module_path.relative_to(SRC_ROOT))] = imported
+
+    assert not violations, f"only math_plot_helpers may import matplotlib, but found: {violations}"
+
+
+def test_otg_does_not_import_numpy() -> None:
+    """OTG is a real-time control loop; it must not depend on numpy.
+
+    Guarded to skip if ``math_tools/otg`` does not exist yet so this
+    enforcement is inherited for free once the OTG chunks land.
+    """
+    if not OTG_ROOT.is_dir():
+        return
+
+    violations: dict[str, set[str]] = {}
+    for module_path in OTG_ROOT.rglob("*.py"):
+        imported = _imported_top_level_names(module_path) & {"numpy"}
+        if imported:
+            violations[str(module_path.relative_to(SRC_ROOT))] = imported
+
+    assert not violations, f"math_tools.otg must not import numpy, but found: {violations}"
+
+
+def _dsp_sibling_imports(module_path: Path) -> set[str]:
+    """Sibling ``dsp/_*`` module names ``module_path`` imports (its own name excluded),
+    in both absolute (``math_tools.waveforms.dsp._foo``) and relative
+    (``from ._foo import ...`` / ``from . import _foo``) forms."""
+    tree = ast.parse(module_path.read_text(encoding="utf-8"), filename=str(module_path))
+    found: set[str] = set()
+    for node in ast.walk(tree):
+        if not isinstance(node, ast.ImportFrom):
+            continue
+        if node.level == 0 and node.module == "math_tools.waveforms.dsp":
+            found.update(alias.name for alias in node.names)
+        elif (
+            node.level == 0 and node.module and node.module.startswith("math_tools.waveforms.dsp.")
+        ):
+            found.add(node.module.split(".")[-1])
+        elif node.level >= 1:
+            if node.module:
+                found.add(node.module.split(".")[-1])
+            else:
+                found.update(alias.name for alias in node.names)
+    found -= _DSP_ALLOWED_SIBLING_MODULES
+    found.discard(module_path.stem)
+    return found
+
+
+def test_dsp_mixins_do_not_import_sibling_mixins() -> None:
+    """waveformDsp.md §Compliance 2 / §Organization: each ``dsp/_*.py`` mixin module
+    imports scipy/numpy plus ``_protocol``/``_common`` only -- no sibling mixin
+    imports (shared helpers live in ``dsp/_common.py``).
+
+    Guarded to skip if ``waveforms/dsp`` does not exist yet so this enforcement is
+    inherited for free (mirrors ``test_otg_does_not_import_numpy``'s pattern).
+    """
+    if not DSP_ROOT.is_dir():
+        return
+
+    violations: dict[str, set[str]] = {}
+    for module_path in DSP_ROOT.glob("_*.py"):
+        # `_*.py` also matches `__init__.py` (leading `__` starts with `_`), but the
+        # package `__init__` is not a mixin module -- from chunk 30 onward it is
+        # expected to import every mixin to re-export them (waveformDsp.md
+        # §Organization), which is exactly the pattern this test forbids for the
+        # mixin modules themselves.
+        if module_path.name == "__init__.py":
+            continue
+        if module_path.stem in _DSP_ALLOWED_SIBLING_MODULES:
+            continue
+        sibling_imports = _dsp_sibling_imports(module_path)
+        if sibling_imports:
+            violations[str(module_path.relative_to(SRC_ROOT))] = sibling_imports
+
+    assert not violations, (
+        "dsp mixin modules must import only _protocol/_common from within "
+        f"waveforms/dsp/, but found sibling-mixin imports: {violations}"
+    )
+
+
+def test_math_tools_is_scanned() -> None:
+    """Guard against the scan silently finding zero files (e.g. a bad glob root)."""
+    scanned = list(MATH_TOOLS_ROOT.rglob("*.py"))
+    assert len(scanned) >= 1, f"expected at least 1 module under math_tools/, found {scanned}"
diff --git a/tests/test_public_surface.py b/tests/test_public_surface.py
new file mode 100644
index 0000000..2edd9e8
--- /dev/null
+++ b/tests/test_public_surface.py
@@ -0,0 +1,78 @@
+"""Pin the curated root ``math_tools`` public surface.
+
+Per mathToolsArchitecture.md §Shared conventions (Public surface), the root
+``math_tools/__init__.py`` re-exports a flat working set so
+``import math_tools as mt`` is coherent. This test pins ``__all__`` to the
+umbrella spec's literal list, imports every name, and asserts each resolves
+to the subpackage-defined class/object by identity (no shadow copies).
+"""
+
+import unittest
+
+import math_tools
+import math_tools.functional
+import math_tools.otg
+import math_tools.precision_time
+import math_tools.spatial
+import math_tools.waveforms
+
+
+class TestPublicSurface(unittest.TestCase):
+    def test_all_pins_exact_umbrella_spec_list(self) -> None:
+        expected = {
+            "Position",
+            "Quaternion",
+            "SpatialPose",
+            "PrecisionTimeInterval",
+            "PrecisionTimestamp",
+            "Waveform1D",
+            "WaveformPosition",
+            "WaveformQuaternion",
+            "WaveformSpatialPose",
+            "UnivariatePolynomial",
+            "Otg",
+            "InputParameter",
+            "OutputParameter",
+            "Trajectory",
+            "Result",
+            "MathToolsError",
+            "WaveformCompatibilityError",
+            "TimestampComparisonError",
+            "PolynomialSolveError",
+        }
+        self.assertEqual(set(math_tools.__all__), expected)
+        self.assertEqual(len(math_tools.__all__), len(expected))
+
+    def test_every_public_name_resolves_by_identity(self) -> None:
+        identity_sources = {
+            "Position": math_tools.spatial.Position,
+            "Quaternion": math_tools.spatial.Quaternion,
+            "SpatialPose": math_tools.spatial.SpatialPose,
+            "PrecisionTimeInterval": math_tools.precision_time.PrecisionTimeInterval,
+            "PrecisionTimestamp": math_tools.precision_time.PrecisionTimestamp,
+            "Waveform1D": math_tools.waveforms.Waveform1D,
+            "WaveformPosition": math_tools.waveforms.WaveformPosition,
+            "WaveformQuaternion": math_tools.waveforms.WaveformQuaternion,
+            "WaveformSpatialPose": math_tools.waveforms.WaveformSpatialPose,
+            "UnivariatePolynomial": math_tools.functional.UnivariatePolynomial,
+            "Otg": math_tools.otg.Otg,
+            "InputParameter": math_tools.otg.InputParameter,
+            "OutputParameter": math_tools.otg.OutputParameter,
+            "Trajectory": math_tools.otg.Trajectory,
+            "Result": math_tools.otg.Result,
+            "MathToolsError": math_tools.errors.MathToolsError,
+            "WaveformCompatibilityError": math_tools.errors.WaveformCompatibilityError,
+            "TimestampComparisonError": math_tools.errors.TimestampComparisonError,
+            "PolynomialSolveError": math_tools.errors.PolynomialSolveError,
+        }
+        for name, source in identity_sources.items():
+            with self.subTest(name=name):
+                self.assertIs(getattr(math_tools, name), source)
+
+    def test_waveform1d_sine_smoke(self) -> None:
+        waveform = math_tools.Waveform1D.sine(n=8)
+        self.assertEqual(len(waveform), 8)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/test_quaternion.py b/tests/test_quaternion.py
index 384379d..9fd97e8 100644
--- a/tests/test_quaternion.py
+++ b/tests/test_quaternion.py
@@ -13,16 +13,17 @@
 """
 
 import unittest
+
 import numpy as np
 from numpy.testing import assert_allclose, assert_array_almost_equal
 
-from pyMathTools.spatial.Quaternion import Quaternion
+from math_tools.spatial.quaternion import Quaternion
 
 
 class TestQuaternionConstruction(unittest.TestCase):
     """Test various construction methods for Quaternion."""
 
-    def test_from_components_identity(self):
+    def test_from_components_identity(self) -> None:
         """Test creating identity quaternion from components."""
         q = Quaternion.from_components(1, 0, 0, 0)
         self.assertEqual(q.w, 1.0)
@@ -30,7 +31,7 @@ def test_from_components_identity(self):
         self.assertEqual(q.y, 0.0)
         self.assertEqual(q.z, 0.0)
 
-    def test_from_components_general(self):
+    def test_from_components_general(self) -> None:
         """Test creating general quaternion from components."""
         q = Quaternion.from_components(0.7071, 0.0, 0.0, 0.7071)
         assert_allclose(q.w, 0.7071, rtol=1e-4)
@@ -38,7 +39,7 @@ def test_from_components_general(self):
         assert_allclose(q.y, 0.0, atol=1e-10)
         assert_allclose(q.z, 0.7071, rtol=1e-4)
 
-    def test_from_components_default(self):
+    def test_from_components_default(self) -> None:
         """Test default values in from_components."""
         q = Quaternion.from_components()
         self.assertEqual(q.w, 1.0)
@@ -46,7 +47,7 @@ def test_from_components_default(self):
         self.assertEqual(q.y, 0.0)
         self.assertEqual(q.z, 0.0)
 
-    def test_identity(self):
+    def test_identity(self) -> None:
         """Test identity quaternion constructor."""
         q = Quaternion.identity()
         self.assertEqual(q.w, 1.0)
@@ -55,7 +56,7 @@ def test_identity(self):
         self.assertEqual(q.z, 0.0)
         self.assertTrue(q.is_unit)
 
-    def test_from_axis_angle_z_90(self):
+    def test_from_axis_angle_z_90(self) -> None:
         """Test construction from axis-angle (90° around Z)."""
         axis = np.array([0, 0, 1])
         angle = np.pi / 2
@@ -66,7 +67,7 @@ def test_from_axis_angle_z_90(self):
         assert_allclose(q.y, 0.0, atol=1e-10)
         assert_allclose(q.z, np.sin(np.pi / 4), rtol=1e-10)
 
-    def test_from_axis_angle_x_180(self):
+    def test_from_axis_angle_x_180(self) -> None:
         """Test construction from axis-angle (180° around X)."""
         axis = np.array([1, 0, 0])
         angle = np.pi
@@ -77,7 +78,7 @@ def test_from_axis_angle_x_180(self):
         assert_allclose(q.y, 0.0, atol=1e-10)
         assert_allclose(q.z, 0.0, atol=1e-10)
 
-    def test_from_axis_angle_unnormalized(self):
+    def test_from_axis_angle_unnormalized(self) -> None:
         """Test that axis gets normalized automatically."""
         axis = np.array([2, 0, 0])  # Not normalized
         angle = np.pi / 2
@@ -86,7 +87,7 @@ def test_from_axis_angle_unnormalized(self):
         # Should be same as normalized axis
         self.assertTrue(q.is_unit)
 
-    def test_from_vector_part(self):
+    def test_from_vector_part(self) -> None:
         """Test creating pure quaternion from vector."""
         vec = np.array([1.0, 2.0, 3.0])
         q = Quaternion.from_vector_part(vec)
@@ -100,61 +101,61 @@ def test_from_vector_part(self):
 class TestQuaternionProperties(unittest.TestCase):
     """Test quaternion properties and attributes."""
 
-    def test_norm_identity(self):
+    def test_norm_identity(self) -> None:
         """Test norm of identity quaternion."""
         q = Quaternion.identity()
         assert_allclose(q.norm, 1.0)
 
-    def test_norm_general(self):
+    def test_norm_general(self) -> None:
         """Test norm of general quaternion."""
         q = Quaternion.from_components(1, 2, 3, 4)
         expected_norm = np.sqrt(1 + 4 + 9 + 16)
         assert_allclose(q.norm, expected_norm)
 
-    def test_is_unit_true(self):
+    def test_is_unit_true(self) -> None:
         """Test is_unit for unit quaternion."""
         q = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 2)
         self.assertTrue(q.is_unit)
 
-    def test_is_unit_false(self):
+    def test_is_unit_false(self) -> None:
         """Test is_unit for non-unit quaternion."""
         q = Quaternion.from_components(1, 1, 1, 1)
         self.assertFalse(q.is_unit)
 
-    def test_angle_identity(self):
+    def test_angle_identity(self) -> None:
         """Test angle of identity quaternion."""
         q = Quaternion.identity()
         assert_allclose(q.angle, 0.0, atol=1e-10)
 
-    def test_angle_90_degrees(self):
+    def test_angle_90_degrees(self) -> None:
         """Test angle extraction for 90° rotation."""
         q = Quaternion.from_axis_angle(np.array([1, 0, 0]), np.pi / 2)
         assert_allclose(q.angle, np.pi / 2, rtol=1e-10)
 
-    def test_angle_180_degrees(self):
+    def test_angle_180_degrees(self) -> None:
         """Test angle extraction for 180° rotation."""
         q = Quaternion.from_axis_angle(np.array([0, 1, 0]), np.pi)
         assert_allclose(q.angle, np.pi, rtol=1e-10)
 
-    def test_axis_z(self):
+    def test_axis_z(self) -> None:
         """Test axis extraction for Z-axis rotation."""
         axis = np.array([0, 0, 1])
         q = Quaternion.from_axis_angle(axis, np.pi / 2)
         assert_array_almost_equal(q.axis, axis, decimal=10)
 
-    def test_axis_general(self):
+    def test_axis_general(self) -> None:
         """Test axis extraction for general rotation."""
         axis = np.array([1, 1, 1]) / np.sqrt(3)
         q = Quaternion.from_axis_angle(axis, np.pi / 4)
         assert_array_almost_equal(q.axis, axis, decimal=10)
 
-    def test_axis_identity(self):
+    def test_axis_identity(self) -> None:
         """Test axis for identity quaternion (defaults to Z)."""
         q = Quaternion.identity()
         # Identity should return default axis
         self.assertEqual(q.axis.shape, (3,))
 
-    def test_to_components(self):
+    def test_to_components(self) -> None:
         """Test components tuple extraction."""
         q = Quaternion.from_components(1, 2, 3, 4)
         w, x, y, z = q.to_components()
@@ -167,7 +168,7 @@ def test_to_components(self):
 class TestQuaternionArithmetic(unittest.TestCase):
     """Test arithmetic operations on quaternions."""
 
-    def test_add_quaternions(self):
+    def test_add_quaternions(self) -> None:
         """Test quaternion addition."""
         q1 = Quaternion.from_components(1, 2, 3, 4)
         q2 = Quaternion.from_components(5, 6, 7, 8)
@@ -178,7 +179,7 @@ def test_add_quaternions(self):
         self.assertEqual(q3.y, 10.0)
         self.assertEqual(q3.z, 12.0)
 
-    def test_add_scalar(self):
+    def test_add_scalar(self) -> None:
         """Test adding scalar to quaternion."""
         q1 = Quaternion.from_components(1, 2, 3, 4)
         q2 = q1 + 5
@@ -188,7 +189,7 @@ def test_add_scalar(self):
         self.assertEqual(q2.y, 3.0)
         self.assertEqual(q2.z, 4.0)
 
-    def test_radd_scalar(self):
+    def test_radd_scalar(self) -> None:
         """Test right addition with scalar."""
         q1 = Quaternion.from_components(1, 2, 3, 4)
         q2 = 5 + q1
@@ -198,7 +199,7 @@ def test_radd_scalar(self):
         self.assertEqual(q2.y, 3.0)
         self.assertEqual(q2.z, 4.0)
 
-    def test_subtract_quaternions(self):
+    def test_subtract_quaternions(self) -> None:
         """Test quaternion subtraction."""
         q1 = Quaternion.from_components(5, 6, 7, 8)
         q2 = Quaternion.from_components(1, 2, 3, 4)
@@ -209,7 +210,7 @@ def test_subtract_quaternions(self):
         self.assertEqual(q3.y, 4.0)
         self.assertEqual(q3.z, 4.0)
 
-    def test_multiply_quaternions(self):
+    def test_multiply_quaternions(self) -> None:
         """Test quaternion multiplication (Hamilton product)."""
         # 90° rotation around Z followed by 90° rotation around X
         q1 = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 2)
@@ -219,7 +220,7 @@ def test_multiply_quaternions(self):
         # Result should be a valid rotation
         self.assertTrue(q3.is_unit)
 
-    def test_multiply_scalar(self):
+    def test_multiply_scalar(self) -> None:
         """Test multiplying quaternion by scalar."""
         q1 = Quaternion.from_components(1, 2, 3, 4)
         q2 = q1 * 2
@@ -229,7 +230,7 @@ def test_multiply_scalar(self):
         self.assertEqual(q2.y, 6.0)
         self.assertEqual(q2.z, 8.0)
 
-    def test_divide_quaternions(self):
+    def test_divide_quaternions(self) -> None:
         """Test quaternion division."""
         q1 = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 2)
         q2 = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 4)
@@ -239,7 +240,7 @@ def test_divide_quaternions(self):
         self.assertTrue(q3.is_unit)
         assert_allclose(q3.angle, np.pi / 4, rtol=1e-10)
 
-    def test_divide_scalar(self):
+    def test_divide_scalar(self) -> None:
         """Test dividing quaternion by scalar."""
         q1 = Quaternion.from_components(2, 4, 6, 8)
         q2 = q1 / 2
@@ -249,15 +250,15 @@ def test_divide_scalar(self):
         self.assertEqual(q2.y, 3.0)
         self.assertEqual(q2.z, 4.0)
 
-    def test_power(self):
+    def test_power(self) -> None:
         """Test quaternion power operation."""
         q1 = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 2)
-        q2 = q1 ** 2
+        q2 = q1**2
 
         # (90° rotation)^2 should be 180° rotation
         assert_allclose(q2.angle, np.pi, rtol=1e-10)
 
-    def test_negate(self):
+    def test_negate(self) -> None:
         """Test quaternion negation."""
         q1 = Quaternion.from_components(1, 2, 3, 4)
         q2 = -q1
@@ -267,7 +268,7 @@ def test_negate(self):
         self.assertEqual(q2.y, -3.0)
         self.assertEqual(q2.z, -4.0)
 
-    def test_positive(self):
+    def test_positive(self) -> None:
         """Test unary positive."""
         q1 = Quaternion.from_components(1, 2, 3, 4)
         q2 = +q1
@@ -277,7 +278,7 @@ def test_positive(self):
         self.assertEqual(q2.y, 3.0)
         self.assertEqual(q2.z, 4.0)
 
-    def test_abs(self):
+    def test_abs(self) -> None:
         """Test absolute value (norm)."""
         q = Quaternion.from_components(1, 2, 3, 4)
         expected_norm = np.sqrt(30)
@@ -287,43 +288,43 @@ def test_abs(self):
 class TestQuaternionComparison(unittest.TestCase):
     """Test comparison operations."""
 
-    def test_equality_same(self):
+    def test_equality_same(self) -> None:
         """Test equality for identical quaternions."""
         q1 = Quaternion.from_components(1, 2, 3, 4)
         q2 = Quaternion.from_components(1, 2, 3, 4)
         self.assertEqual(q1, q2)
 
-    def test_equality_different(self):
+    def test_equality_different(self) -> None:
         """Test equality for different quaternions."""
         q1 = Quaternion.from_components(1, 2, 3, 4)
         q2 = Quaternion.from_components(1, 2, 3, 5)
         self.assertNotEqual(q1, q2)
 
-    def test_inequality(self):
+    def test_inequality(self) -> None:
         """Test inequality operator."""
         q1 = Quaternion.from_components(1, 2, 3, 4)
         q2 = Quaternion.from_components(1, 2, 3, 5)
         self.assertNotEqual(q1, q2)
 
-    def test_isclose_true(self):
+    def test_isclose_true(self) -> None:
         """Test isclose for nearly equal quaternions."""
         q1 = Quaternion.from_components(1.0, 2.0, 3.0, 4.0)
         q2 = Quaternion.from_components(1.0 + 1e-10, 2.0, 3.0, 4.0)
         self.assertTrue(q1.isclose(q2))
 
-    def test_isclose_false(self):
+    def test_isclose_false(self) -> None:
         """Test isclose for different quaternions."""
         q1 = Quaternion.from_components(1.0, 2.0, 3.0, 4.0)
         q2 = Quaternion.from_components(1.1, 2.0, 3.0, 4.0)
         self.assertFalse(q1.isclose(q2))
 
-    def test_allclose_true(self):
+    def test_allclose_true(self) -> None:
         """Test static allclose method."""
         q1 = Quaternion.from_components(1.0, 2.0, 3.0, 4.0)
         q2 = Quaternion.from_components(1.0 + 1e-10, 2.0, 3.0, 4.0)
         self.assertTrue(Quaternion.allclose(q1, q2))
 
-    def test_repr(self):
+    def test_repr(self) -> None:
         """Test __repr__ output."""
         q = Quaternion.from_components(1, 2, 3, 4)
         repr_str = repr(q)
@@ -331,7 +332,7 @@ def test_repr(self):
         self.assertIn("w=1", repr_str)
         self.assertIn("x=2", repr_str)
 
-    def test_str(self):
+    def test_str(self) -> None:
         """Test __str__ output."""
         q = Quaternion.from_components(1, 2, 3, 4)
         str_repr = str(q)
@@ -341,7 +342,7 @@ def test_str(self):
 class TestQuaternionUnaryOperations(unittest.TestCase):
     """Test unary operations on quaternions."""
 
-    def test_conjugate(self):
+    def test_conjugate(self) -> None:
         """Test quaternion conjugate."""
         q = Quaternion.from_components(1, 2, 3, 4)
         q_conj = q.conjugate()
@@ -351,13 +352,13 @@ def test_conjugate(self):
         self.assertEqual(q_conj.y, -3.0)
         self.assertEqual(q_conj.z, -4.0)
 
-    def test_conjugate_identity(self):
+    def test_conjugate_identity(self) -> None:
         """Test conjugate of identity."""
         q = Quaternion.identity()
         q_conj = q.conjugate()
         self.assertEqual(q, q_conj)
 
-    def test_inverse_unit(self):
+    def test_inverse_unit(self) -> None:
         """Test inverse of unit quaternion."""
         q = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 2)
         q_inv = q.inverse()
@@ -365,7 +366,7 @@ def test_inverse_unit(self):
         # For unit quaternions, inverse equals conjugate
         self.assertTrue(q_inv.isclose(q.conjugate()))
 
-    def test_inverse_times_quaternion(self):
+    def test_inverse_times_quaternion(self) -> None:
         """Test that q * q^-1 = identity."""
         q = Quaternion.from_components(1, 2, 3, 4)
         q_inv = q.inverse()
@@ -375,7 +376,7 @@ def test_inverse_times_quaternion(self):
         identity = Quaternion.identity()
         self.assertTrue(result.isclose(identity, atol=1e-10))
 
-    def test_normalized_general(self):
+    def test_normalized_general(self) -> None:
         """Test normalization of general quaternion."""
         q = Quaternion.from_components(1, 2, 3, 4)
         q_norm = q.normalized()
@@ -383,7 +384,7 @@ def test_normalized_general(self):
         self.assertTrue(q_norm.is_unit)
         assert_allclose(q_norm.norm, 1.0)
 
-    def test_normalized_already_unit(self):
+    def test_normalized_already_unit(self) -> None:
         """Test normalizing already unit quaternion."""
         q = Quaternion.identity()
         q_norm = q.normalized()
@@ -394,7 +395,7 @@ def test_normalized_already_unit(self):
 class TestRotationMatrixConversions(unittest.TestCase):
     """Test conversions to/from rotation matrices."""
 
-    def test_to_rotation_matrix_identity(self):
+    def test_to_rotation_matrix_identity(self) -> None:
         """Test identity quaternion to rotation matrix."""
         q = Quaternion.identity()
         matrix = q.to_rotation_matrix()
@@ -402,52 +403,40 @@ def test_to_rotation_matrix_identity(self):
         expected = np.eye(3)
         assert_array_almost_equal(matrix, expected, decimal=10)
 
-    def test_to_rotation_matrix_90z(self):
+    def test_to_rotation_matrix_90z(self) -> None:
         """Test 90° Z rotation to matrix."""
         q = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 2)
         matrix = q.to_rotation_matrix()
 
         # 90° Z rotation matrix
-        expected = np.array([
-            [0, -1, 0],
-            [1,  0, 0],
-            [0,  0, 1]
-        ])
+        expected = np.array([[0, -1, 0], [1, 0, 0], [0, 0, 1]])
         assert_array_almost_equal(matrix, expected, decimal=10)
 
-    def test_to_rotation_matrix_180x(self):
+    def test_to_rotation_matrix_180x(self) -> None:
         """Test 180° X rotation to matrix."""
         q = Quaternion.from_axis_angle(np.array([1, 0, 0]), np.pi)
         matrix = q.to_rotation_matrix()
 
         # 180° X rotation matrix
-        expected = np.array([
-            [1,  0,  0],
-            [0, -1,  0],
-            [0,  0, -1]
-        ])
+        expected = np.array([[1, 0, 0], [0, -1, 0], [0, 0, -1]])
         assert_array_almost_equal(matrix, expected, decimal=10)
 
-    def test_from_rotation_matrix_identity(self):
+    def test_from_rotation_matrix_identity(self) -> None:
         """Test creating quaternion from identity matrix."""
         matrix = np.eye(3)
         q = Quaternion.from_rotation_matrix(matrix)
 
         self.assertTrue(q.isclose(Quaternion.identity()))
 
-    def test_from_rotation_matrix_90z(self):
+    def test_from_rotation_matrix_90z(self) -> None:
         """Test creating quaternion from 90° Z rotation matrix."""
-        matrix = np.array([
-            [0, -1, 0],
-            [1,  0, 0],
-            [0,  0, 1]
-        ])
+        matrix = np.array([[0, -1, 0], [1, 0, 0], [0, 0, 1]])
         q = Quaternion.from_rotation_matrix(matrix)
 
         expected = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 2)
         self.assertTrue(q.isclose(expected))
 
-    def test_roundtrip_matrix_conversion(self):
+    def test_roundtrip_matrix_conversion(self) -> None:
         """Test quaternion -> matrix -> quaternion roundtrip."""
         q_original = Quaternion.from_axis_angle(np.array([1, 1, 1]) / np.sqrt(3), np.pi / 3)
         matrix = q_original.to_rotation_matrix()
@@ -460,14 +449,14 @@ def test_roundtrip_matrix_conversion(self):
 class TestRotationVectorConversions(unittest.TestCase):
     """Test conversions to/from rotation vectors (axis-angle)."""
 
-    def test_to_rotation_vector_identity(self):
+    def test_to_rotation_vector_identity(self) -> None:
         """Test identity quaternion to rotation vector."""
         q = Quaternion.identity()
         vec = q.to_rotation_vector()
 
         assert_array_almost_equal(vec, np.zeros(3), decimal=10)
 
-    def test_to_rotation_vector_90z(self):
+    def test_to_rotation_vector_90z(self) -> None:
         """Test 90° Z rotation to rotation vector."""
         q = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 2)
         vec = q.to_rotation_vector()
@@ -475,14 +464,14 @@ def test_to_rotation_vector_90z(self):
         expected = np.array([0, 0, np.pi / 2])
         assert_array_almost_equal(vec, expected, decimal=10)
 
-    def test_from_rotation_vector_identity(self):
+    def test_from_rotation_vector_identity(self) -> None:
         """Test creating quaternion from zero rotation vector."""
         vec = np.zeros(3)
         q = Quaternion.from_rotation_vector(vec)
 
         self.assertTrue(q.isclose(Quaternion.identity()))
 
-    def test_from_rotation_vector_general(self):
+    def test_from_rotation_vector_general(self) -> None:
         """Test creating quaternion from rotation vector."""
         vec = np.array([0, np.pi / 2, 0])  # 90° around Y
         q = Quaternion.from_rotation_vector(vec)
@@ -490,7 +479,7 @@ def test_from_rotation_vector_general(self):
         expected = Quaternion.from_axis_angle(np.array([0, 1, 0]), np.pi / 2)
         self.assertTrue(q.isclose(expected))
 
-    def test_roundtrip_rotation_vector(self):
+    def test_roundtrip_rotation_vector(self) -> None:
         """Test quaternion -> rotation vector -> quaternion roundtrip."""
         q_original = Quaternion.from_axis_angle(np.array([1, 0, 0]), np.pi / 4)
         vec = q_original.to_rotation_vector()
@@ -502,7 +491,7 @@ def test_roundtrip_rotation_vector(self):
 class TestEulerAngleConversions(unittest.TestCase):
     """Test conversions to/from Euler angles."""
 
-    def test_to_euler_angles_identity(self):
+    def test_to_euler_angles_identity(self) -> None:
         """Test identity quaternion to Euler angles."""
         q = Quaternion.identity()
         euler = q.to_euler_angles()
@@ -510,13 +499,13 @@ def test_to_euler_angles_identity(self):
         # Identity should give zero or small angles
         self.assertEqual(euler.shape, (3,))
 
-    def test_from_euler_angles_zeros(self):
+    def test_from_euler_angles_zeros(self) -> None:
         """Test creating quaternion from zero Euler angles."""
         q = Quaternion.from_euler_angles(0, 0, 0)
 
         self.assertTrue(q.isclose(Quaternion.identity()))
 
-    def test_roundtrip_euler_angles(self):
+    def test_roundtrip_euler_angles(self) -> None:
         """Test quaternion -> Euler -> quaternion roundtrip."""
         q_original = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 2)
         euler = q_original.to_euler_angles()
@@ -529,14 +518,14 @@ def test_roundtrip_euler_angles(self):
 class TestVectorOperations(unittest.TestCase):
     """Test vector-related operations."""
 
-    def test_to_vector_part(self):
+    def test_to_vector_part(self) -> None:
         """Test extracting vector part."""
         q = Quaternion.from_components(1, 2, 3, 4)
         vec = q.to_vector_part()
 
         assert_array_almost_equal(vec, np.array([2, 3, 4]))
 
-    def test_rotate_vector_identity(self):
+    def test_rotate_vector_identity(self) -> None:
         """Test rotating vector with identity quaternion."""
         q = Quaternion.identity()
         vec = np.array([1, 2, 3])
@@ -544,7 +533,7 @@ def test_rotate_vector_identity(self):
 
         assert_array_almost_equal(rotated, vec, decimal=10)
 
-    def test_rotate_vector_90z(self):
+    def test_rotate_vector_90z(self) -> None:
         """Test rotating vector 90° around Z."""
         q = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 2)
         vec = np.array([1, 0, 0])
@@ -553,7 +542,7 @@ def test_rotate_vector_90z(self):
         expected = np.array([0, 1, 0])
         assert_array_almost_equal(rotated, expected, decimal=10)
 
-    def test_rotate_vector_180x(self):
+    def test_rotate_vector_180x(self) -> None:
         """Test rotating vector 180° around X."""
         q = Quaternion.from_axis_angle(np.array([1, 0, 0]), np.pi)
         vec = np.array([0, 1, 0])
@@ -562,7 +551,7 @@ def test_rotate_vector_180x(self):
         expected = np.array([0, -1, 0])
         assert_array_almost_equal(rotated, expected, decimal=10)
 
-    def test_rotate_vector_general(self):
+    def test_rotate_vector_general(self) -> None:
         """Test general vector rotation."""
         q = Quaternion.from_axis_angle(np.array([1, 1, 1]) / np.sqrt(3), 2 * np.pi / 3)
         vec = np.array([1, 0, 0])
@@ -576,7 +565,7 @@ def test_rotate_vector_general(self):
 class TestSLERP(unittest.TestCase):
     """Test spherical linear interpolation."""
 
-    def test_slerp_endpoints(self):
+    def test_slerp_endpoints(self) -> None:
         """Test SLERP at endpoints."""
         q1 = Quaternion.identity()
         q2 = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 2)
@@ -589,7 +578,7 @@ def test_slerp_endpoints(self):
         q_end = q1.slerp(q2, 1.0)
         self.assertTrue(q_end.isclose(q2))
 
-    def test_slerp_midpoint(self):
+    def test_slerp_midpoint(self) -> None:
         """Test SLERP at midpoint."""
         q1 = Quaternion.identity()
         q2 = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 2)
@@ -600,7 +589,7 @@ def test_slerp_midpoint(self):
         expected = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi / 4)
         self.assertTrue(q_mid.isclose(expected))
 
-    def test_slerp_unit_preservation(self):
+    def test_slerp_unit_preservation(self) -> None:
         """Test that SLERP preserves unit norm."""
         q1 = Quaternion.from_axis_angle(np.array([1, 0, 0]), np.pi / 4)
         q2 = Quaternion.from_axis_angle(np.array([0, 1, 0]), np.pi / 3)
@@ -609,7 +598,7 @@ def test_slerp_unit_preservation(self):
             q_interp = q1.slerp(q2, t)
             self.assertTrue(q_interp.is_unit)
 
-    def test_slerp_smooth_interpolation(self):
+    def test_slerp_smooth_interpolation(self) -> None:
         """Test that SLERP produces smooth interpolation."""
         q1 = Quaternion.identity()
         q2 = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi)
@@ -623,7 +612,7 @@ def test_slerp_smooth_interpolation(self):
         for i in range(len(angles) - 1):
             self.assertLessEqual(angles[i], angles[i + 1])
 
-    def test_slerp_opposite_quaternions(self):
+    def test_slerp_opposite_quaternions(self) -> None:
         """Test SLERP between opposite quaternions."""
         q1 = Quaternion.from_axis_angle(np.array([0, 0, 1]), 0)
         q2 = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi)
@@ -637,7 +626,7 @@ def test_slerp_opposite_quaternions(self):
 class TestArrayConversions(unittest.TestCase):
     """Test array conversion methods."""
 
-    def test_as_float_array(self):
+    def test_as_float_array(self) -> None:
         """Test conversion to float array."""
         q = Quaternion.from_components(1, 2, 3, 4)
         arr = q.as_float_array()
@@ -645,7 +634,7 @@ def test_as_float_array(self):
         expected = np.array([1, 2, 3, 4])
         assert_array_almost_equal(arr, expected)
 
-    def test_as_float_array_shape(self):
+    def test_as_float_array_shape(self) -> None:
         """Test shape of float array."""
         q = Quaternion.from_components(1, 2, 3, 4)
         arr = q.as_float_array()
@@ -656,13 +645,13 @@ def test_as_float_array_shape(self):
 class TestEdgeCases(unittest.TestCase):
     """Test edge cases and special scenarios."""
 
-    def test_very_small_rotation(self):
+    def test_very_small_rotation(self) -> None:
         """Test very small rotation angle."""
         q = Quaternion.from_axis_angle(np.array([1, 0, 0]), 1e-10)
 
         self.assertTrue(q.isclose(Quaternion.identity()))
 
-    def test_very_large_angle(self):
+    def test_very_large_angle(self) -> None:
         """Test angle larger than 2π."""
         # Should wrap around
         q = Quaternion.from_axis_angle(np.array([0, 0, 1]), 3 * np.pi)
@@ -671,7 +660,7 @@ def test_very_large_angle(self):
         expected = Quaternion.from_axis_angle(np.array([0, 0, 1]), np.pi)
         self.assertTrue(q.isclose(expected) or q.isclose(-expected))
 
-    def test_zero_norm_handling(self):
+    def test_zero_norm_handling(self) -> None:
         """Test that operations handle near-zero quaternions appropriately."""
         # This would be an invalid quaternion, but we test defensive handling
         # Note: actual zero quaternion would cause division by zero in some operations
@@ -683,9 +672,9 @@ def test_zero_norm_handling(self):
 
 
 class TestQuaternionSerialization(unittest.TestCase):
-    """Test serialization/deserialization methods and DataModelHelper inheritance."""
+    """Test serialization/deserialization methods and QuaternionABC inheritance."""
 
-    def test_to_dict_identity(self):
+    def test_to_dict_identity(self) -> None:
         """Test to_dict for identity quaternion."""
         q = Quaternion.identity()
         d = q.to_dict()
@@ -700,7 +689,7 @@ def test_to_dict_identity(self):
         self.assertEqual(d["y"], 0.0)
         self.assertEqual(d["z"], 0.0)
 
-    def test_to_dict_general(self):
+    def test_to_dict_general(self) -> None:
         """Test to_dict for general quaternion."""
         q = Quaternion.from_components(1.0, 2.0, 3.0, 4.0)
         d = q.to_dict()
@@ -710,7 +699,7 @@ def test_to_dict_general(self):
         self.assertEqual(d["y"], 3.0)
         self.assertEqual(d["z"], 4.0)
 
-    def test_to_dict_normalized(self):
+    def test_to_dict_normalized(self) -> None:
         """Test to_dict preserves values for normalized quaternion."""
         q = Quaternion.from_axis_angle(np.array([1, 0, 0]), np.pi / 2)
         d = q.to_dict()
@@ -727,7 +716,7 @@ def test_to_dict_normalized(self):
         self.assertAlmostEqual(d["y"], q.y)
         self.assertAlmostEqual(d["z"], q.z)
 
-    def test_from_dict_identity(self):
+    def test_from_dict_identity(self) -> None:
         """Test from_dict for identity quaternion."""
         d = {"w": 1.0, "x": 0.0, "y": 0.0, "z": 0.0}
         q = Quaternion.from_dict(d)
@@ -738,7 +727,7 @@ def test_from_dict_identity(self):
         self.assertEqual(q.y, 0.0)
         self.assertEqual(q.z, 0.0)
 
-    def test_from_dict_general(self):
+    def test_from_dict_general(self) -> None:
         """Test from_dict for general quaternion."""
         d = {"w": 1.0, "x": 2.0, "y": 3.0, "z": 4.0}
         q = Quaternion.from_dict(d)
@@ -748,7 +737,7 @@ def test_from_dict_general(self):
         self.assertEqual(q.y, 3.0)
         self.assertEqual(q.z, 4.0)
 
-    def test_from_dict_with_integers(self):
+    def test_from_dict_with_integers(self) -> None:
         """Test from_dict accepts integer values."""
         d = {"w": 1, "x": 2, "y": 3, "z": 4}
         q = Quaternion.from_dict(d)
@@ -758,7 +747,7 @@ def test_from_dict_with_integers(self):
         self.assertEqual(q.y, 3.0)
         self.assertEqual(q.z, 4.0)
 
-    def test_roundtrip_serialization_identity(self):
+    def test_roundtrip_serialization_identity(self) -> None:
         """Test roundtrip: quaternion -> dict -> quaternion for identity."""
         q_original = Quaternion.identity()
         d = q_original.to_dict()
@@ -766,7 +755,7 @@ def test_roundtrip_serialization_identity(self):
 
         self.assertTrue(q_original.isclose(q_recovered))
 
-    def test_roundtrip_serialization_general(self):
+    def test_roundtrip_serialization_general(self) -> None:
         """Test roundtrip: quaternion -> dict -> quaternion for general quaternion."""
         q_original = Quaternion.from_components(1.0, 2.0, 3.0, 4.0)
         d = q_original.to_dict()
@@ -774,7 +763,7 @@ def test_roundtrip_serialization_general(self):
 
         self.assertTrue(q_original.isclose(q_recovered))
 
-    def test_roundtrip_serialization_rotation(self):
+    def test_roundtrip_serialization_rotation(self) -> None:
         """Test roundtrip for rotation quaternion."""
         q_original = Quaternion.from_axis_angle(np.array([1, 1, 1]) / np.sqrt(3), np.pi / 3)
         d = q_original.to_dict()
@@ -782,7 +771,7 @@ def test_roundtrip_serialization_rotation(self):
 
         self.assertTrue(q_original.isclose(q_recovered))
 
-    def test_roundtrip_with_negatives(self):
+    def test_roundtrip_with_negatives(self) -> None:
         """Test roundtrip with negative components."""
         q_original = Quaternion.from_components(-0.5, -0.5, 0.5, 0.5)
         d = q_original.to_dict()
@@ -793,7 +782,7 @@ def test_roundtrip_with_negatives(self):
         self.assertEqual(q_recovered.y, 0.5)
         self.assertEqual(q_recovered.z, 0.5)
 
-    def test_to_dict_returns_new_dict(self):
+    def test_to_dict_returns_new_dict(self) -> None:
         """Test that to_dict returns a new dictionary each time."""
         q = Quaternion.from_components(1.0, 2.0, 3.0, 4.0)
         d1 = q.to_dict()
@@ -802,7 +791,7 @@ def test_to_dict_returns_new_dict(self):
         self.assertIsNot(d1, d2)
         self.assertEqual(d1, d2)
 
-    def test_dict_modification_doesnt_affect_quaternion(self):
+    def test_dict_modification_doesnt_affect_quaternion(self) -> None:
         """Test that modifying the dict doesn't affect the quaternion."""
         q = Quaternion.from_components(1.0, 2.0, 3.0, 4.0)
         d = q.to_dict()
@@ -815,21 +804,21 @@ def test_dict_modification_doesnt_affect_quaternion(self):
         self.assertEqual(q.w, 1.0)
         self.assertEqual(q.x, 2.0)
 
-    def test_inheritance_from_quaternion_type(self):
-        """Test that Quaternion properly inherits from QuaternionType."""
-        from foundationTypes.mathTypes.QuaternionType import QuaternionType
+    def test_inheritance_from_quaternion_type(self) -> None:
+        """Test that Quaternion properly inherits from the shared QuaternionABC."""
+        from foundation_abc.math.spatialABCs import QuaternionABC
 
         q = Quaternion.from_components(1.0, 2.0, 3.0, 4.0)
-        self.assertIsInstance(q, QuaternionType)
+        self.assertIsInstance(q, QuaternionABC)
 
-    def test_inheritance_from_data_model_helper(self):
-        """Test that Quaternion inherits from DataModelHelper."""
-        from foundationTypes.dataModelHelper import DataModelHelper
+    def test_inheritance_from_data_model_helper(self) -> None:
+        """Test that Quaternion inherits from QuaternionABC (ABC-only, not DataModelHelper)."""
+        from foundation_abc.math.spatialABCs import QuaternionABC
 
         q = Quaternion.from_components(1.0, 2.0, 3.0, 4.0)
-        self.assertIsInstance(q, DataModelHelper)
+        self.assertIsInstance(q, QuaternionABC)
 
-    def test_has_serialization_methods(self):
+    def test_has_serialization_methods(self) -> None:
         """Test that Quaternion has the required serialization methods."""
         q = Quaternion.identity()
 
diff --git a/tests/waveforms/__init__.py b/tests/waveforms/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/waveforms/dsp/__init__.py b/tests/waveforms/dsp/__init__.py
new file mode 100644
index 0000000..e69de29
diff --git a/tests/waveforms/dsp/test_calc.py b/tests/waveforms/dsp/test_calc.py
new file mode 100644
index 0000000..f0a4626
--- /dev/null
+++ b/tests/waveforms/dsp/test_calc.py
@@ -0,0 +1,152 @@
+"""Unit tests for ``dsp/_calc.py`` (``CalcMixin``: ``integrate``/``derivative``).
+
+Covers waveformDsp.md §Family contracts (``CalcMixin``), §Numerical
+conventions, §Compliance 1-2. Exercises the mixin directly on ``Waveform1D``, which
+composes every DSP mixin from the compose chunk (30) onward.
+"""
+
+import unittest
+
+import numpy as np
+
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+def _wrap(base: WaveformProtocol) -> Waveform1D:
+    """Rewrap a ``WaveformProtocol``-satisfying result (a bare ``Waveform1D``, whether
+    from a generator classmethod's static ``-> Waveform1D`` return type -- even when
+    called as ``Waveform1D.sine(...)`` -- or from ``CalcMixin``'s own ``-> WaveformProtocol``
+    results) as ``Waveform1D`` so ``CalcMixin`` methods are statically visible under mypy
+    strict."""
+    return Waveform1D(base.values, dt=base.dt, t0=base.t0)
+
+
+class TestDerivativeOfLinearRampIsConstant(unittest.TestCase):
+    """§Compliance 1: derivative of a linear ramp is constant (atol 1e-9)."""
+
+    def test_constant_slope(self) -> None:
+        n = 500
+        dt_seconds = 1.0 / 500.0
+        w = _wrap(Waveform1D.linear_ramp(n, start_value=0.0, end_value=1.0, dt_seconds=dt_seconds))
+        derived = w.derivative()
+
+        expected_slope = 1.0 / ((n - 1) * dt_seconds)
+        np.testing.assert_allclose(
+            derived.values, np.full(n, expected_slope), rtol=0.0, atol=1e-9
+        )
+
+    def test_negative_slope(self) -> None:
+        n = 200
+        dt_seconds = 0.01
+        w = _wrap(
+            Waveform1D.linear_ramp(n, start_value=5.0, end_value=-5.0, dt_seconds=dt_seconds)
+        )
+        derived = w.derivative()
+
+        expected_slope = -10.0 / ((n - 1) * dt_seconds)
+        np.testing.assert_allclose(
+            derived.values, np.full(n, expected_slope), rtol=0.0, atol=1e-9
+        )
+
+
+class TestIntegrateOfConstantIsARamp(unittest.TestCase):
+    """§Compliance 1: integrate of a constant is a ramp."""
+
+    def test_exact_linear_ramp(self) -> None:
+        n = 300
+        dt_seconds = 0.02
+        level = 3.0
+        w = _wrap(Waveform1D.constant(n, value=level, dt_seconds=dt_seconds))
+        integrated = w.integrate()
+
+        expected = level * dt_seconds * np.arange(n, dtype=np.float64)
+        np.testing.assert_allclose(integrated.values, expected, rtol=0.0, atol=1e-9)
+
+    def test_initial_value_offsets_the_ramp(self) -> None:
+        n = 100
+        dt_seconds = 0.05
+        level = 2.0
+        initial_value = 10.0
+        w = _wrap(Waveform1D.constant(n, value=level, dt_seconds=dt_seconds))
+        integrated = w.integrate(initial_value=initial_value)
+
+        expected = initial_value + level * dt_seconds * np.arange(n, dtype=np.float64)
+        np.testing.assert_allclose(integrated.values, expected, rtol=0.0, atol=1e-9)
+        self.assertEqual(integrated.values[0], initial_value)
+
+    def test_default_initial_value_is_zero(self) -> None:
+        w = _wrap(Waveform1D.constant(50, value=1.0, dt_seconds=0.1))
+        integrated = w.integrate()
+        self.assertEqual(integrated.values[0], 0.0)
+
+
+class TestIntegrateThenDerivativeRecoversInterior(unittest.TestCase):
+    """§Compliance 1: ``integrate().derivative()`` recovers a smooth signal
+    (interior points, rtol 1e-6)."""
+
+    def test_sine_wave(self) -> None:
+        n = 10_000
+        dt_seconds = 1.0 / n
+        original = _wrap(Waveform1D.sine(n, frequency=2.0, amplitude=1.0, dt_seconds=dt_seconds))
+
+        integrated = original.integrate()
+        # `integrate()` builds its result via `_with_values`, which (per
+        # `Waveform1D._with_values`) always yields a bare `Waveform1D` --
+        # rewrap in `Waveform1D` to exercise `CalcMixin.derivative` again.
+        recovered = _wrap(integrated).derivative()
+
+        interior = slice(10, -10)
+        np.testing.assert_allclose(
+            recovered.values[interior], original.values[interior], rtol=1e-6, atol=1e-9
+        )
+
+
+class TestMetadataPreserved(unittest.TestCase):
+    """``integrate``/``derivative`` results share ``dt``/``t0`` with the source."""
+
+    def test_integrate_preserves_dt_and_t0(self) -> None:
+        w = _wrap(Waveform1D.constant(20, value=1.0, dt_seconds=0.25, t0_seconds=5.0))
+        integrated = w.integrate()
+        self.assertEqual(integrated.dt, w.dt)
+        self.assertEqual(integrated.t0, w.t0)
+
+    def test_derivative_preserves_dt_and_t0(self) -> None:
+        w = _wrap(
+            Waveform1D.linear_ramp(
+                20, start_value=0.0, end_value=1.0, dt_seconds=0.25, t0_seconds=5.0
+            )
+        )
+        derived = w.derivative()
+        self.assertEqual(derived.dt, w.dt)
+        self.assertEqual(derived.t0, w.t0)
+
+
+class TestMinimumLengthRaises(unittest.TestCase):
+    """waveformDsp.md §Numerical conventions: too-short input raises ``ValueError``
+    naming the requirement (this is not a detector method)."""
+
+    def test_integrate_on_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.integrate()
+
+    def test_derivative_on_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.derivative()
+
+    def test_derivative_on_single_sample_raises(self) -> None:
+        w = Waveform1D([1.0])
+        with self.assertRaises(ValueError):
+            w.derivative()
+
+    def test_integrate_on_single_sample_succeeds(self) -> None:
+        # integrate only needs >= 1 sample (unlike derivative's >= 2).
+        w = Waveform1D([7.0])
+        integrated = w.integrate(initial_value=2.0)
+        self.assertEqual(list(integrated.values), [2.0])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/dsp/test_compose.py b/tests/waveforms/dsp/test_compose.py
new file mode 100644
index 0000000..71c1643
--- /dev/null
+++ b/tests/waveforms/dsp/test_compose.py
@@ -0,0 +1,147 @@
+"""Tests for the DSP mixin composition onto ``Waveform1D`` (waveformDsp.md
+§Organization "Composition phasing", §Compliance 4).
+
+This is the chunk-30 "compose" chunk's own test: it pins that all twelve
+DSP mixins are composed onto the concrete ``Waveform1D`` class exactly once,
+that the composed class remains concrete (no abstract methods left
+unimplemented), that bare construction still succeeds, and that a method
+from each mixin family is actually reachable and returns a correct,
+non-``None`` result on a live instance -- the same kind of runtime check
+that caught chunk 18's C3-linearization bug (mypy alone would not have).
+"""
+
+import unittest
+
+import numpy as np
+
+from math_tools.waveforms.dsp._calc import CalcMixin
+from math_tools.waveforms.dsp._correlation import CorrelationMixin
+from math_tools.waveforms.dsp._envelope import EnvelopeMixin
+from math_tools.waveforms.dsp._filtering import FilteringMixin
+from math_tools.waveforms.dsp._peaks import PeakMixin
+from math_tools.waveforms.dsp._phase import PhaseMixin
+from math_tools.waveforms.dsp._resampling import ResamplingMixin
+from math_tools.waveforms.dsp._spectral import SpectralMixin
+from math_tools.waveforms.dsp._time_alignment import TimeAlignmentMixin
+from math_tools.waveforms.dsp._triggers import TriggerMixin
+from math_tools.waveforms.dsp._windowing import WindowingMixin
+from math_tools.waveforms.dsp._zero_crossings import ZeroCrossingMixin
+from math_tools.waveforms.waveform1d import Waveform1D
+
+_EXPECTED_MIXINS = (
+    CalcMixin,
+    CorrelationMixin,
+    EnvelopeMixin,
+    SpectralMixin,
+    FilteringMixin,
+    PeakMixin,
+    PhaseMixin,
+    ResamplingMixin,
+    TimeAlignmentMixin,
+    TriggerMixin,
+    WindowingMixin,
+    ZeroCrossingMixin,
+)
+
+
+class TestMroComposesEveryMixinExactlyOnce(unittest.TestCase):
+    def test_every_mixin_appears_exactly_once(self) -> None:
+        mro = Waveform1D.__mro__
+        for mixin in _EXPECTED_MIXINS:
+            self.assertEqual(
+                mro.count(mixin),
+                1,
+                f"{mixin.__name__} should appear exactly once in Waveform1D.__mro__, "
+                f"found {mro.count(mixin)}",
+            )
+
+
+class TestComposedClassRemainsConcrete(unittest.TestCase):
+    def test_no_abstract_methods_remain(self) -> None:
+        self.assertEqual(Waveform1D.__abstractmethods__, frozenset())
+
+    def test_bare_construction_succeeds(self) -> None:
+        w = Waveform1D([1.0, 2.0])
+        self.assertEqual(list(w.values), [1.0, 2.0])
+
+
+class TestEveryDspFamilyIsCallableDirectlyOnWaveform1D(unittest.TestCase):
+    """One smoke call per mixin family on a short sine, proving the method is
+    reachable through the composed MRO and returns a correct, non-``None``
+    result -- not just that mypy resolves the attribute."""
+
+    def setUp(self) -> None:
+        self.n = 200
+        self.fs = 200.0
+        self.w = Waveform1D.sine(
+            self.n, frequency=10.0, amplitude=1.0, dt_seconds=1.0 / self.fs
+        )
+
+    def test_calc_derivative(self) -> None:
+        result = self.w.derivative()
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result.values), self.n)
+
+    def test_correlation_auto_correlation(self) -> None:
+        result = self.w.auto_correlation()
+        self.assertIsNotNone(result)
+        self.assertGreater(len(result.values), 0)
+
+    def test_envelope_amplitude_envelope(self) -> None:
+        result = self.w.amplitude_envelope()
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result.values), self.n)
+
+    def test_spectral_fft(self) -> None:
+        spectrum = self.w.fft()
+        self.assertIsNotNone(spectrum)
+        peak_index = int(np.argmax(spectrum.magnitudes))
+        self.assertAlmostEqual(spectrum.frequencies[peak_index], 10.0, delta=self.fs / self.n)
+
+    def test_filtering_low_pass_filter(self) -> None:
+        result = self.w.low_pass_filter(cutoff_hz=50.0)
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result.values), self.n)
+
+    def test_peaks_detect_peaks(self) -> None:
+        peaks = self.w.detect_peaks()
+        self.assertIsNotNone(peaks)
+        self.assertGreater(len(peaks), 0)
+
+    def test_phase_instantaneous_phase(self) -> None:
+        result = self.w.instantaneous_phase()
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result.values), self.n)
+
+    def test_resampling_decimated(self) -> None:
+        result = self.w.decimated(2)
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result.values), self.n // 2)
+
+    def test_time_alignment_time_windows(self) -> None:
+        windows = self.w.time_windows(window_duration=0.5)
+        self.assertIsNotNone(windows)
+        self.assertGreater(len(windows), 0)
+
+    def test_trigger_detect_edge_triggers(self) -> None:
+        from math_tools.waveforms.support import WaveformEdgeType
+
+        events = self.w.detect_edge_triggers(level=0.0, edge=WaveformEdgeType.RISING)
+        self.assertIsNotNone(events)
+        self.assertGreater(len(events), 0)
+
+    def test_windowing_windowed(self) -> None:
+        from math_tools.waveforms.support import WaveformWindowType
+
+        result = self.w.windowed(WaveformWindowType.HANN)
+        self.assertIsNotNone(result)
+        self.assertEqual(len(result.values), self.n)
+
+    def test_zero_crossing_zero_crossings(self) -> None:
+        crossings = self.w.zero_crossings()
+        self.assertIsNotNone(crossings)
+        self.assertGreater(len(crossings), 0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/dsp/test_correlation.py b/tests/waveforms/dsp/test_correlation.py
new file mode 100644
index 0000000..6a7ba5d
--- /dev/null
+++ b/tests/waveforms/dsp/test_correlation.py
@@ -0,0 +1,241 @@
+"""Unit tests for ``dsp/_correlation.py`` (``CorrelationMixin``).
+
+Covers waveformDsp.md §Family contracts (``CorrelationMixin``), §Numerical
+conventions, §Compliance 1-2. Exercises the mixin directly on ``Waveform1D``, which
+composes every DSP mixin from the compose chunk (30) onward.
+"""
+
+import unittest
+
+import numpy as np
+from scipy.signal import correlate
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+def _wrap(base: WaveformProtocol) -> Waveform1D:
+    """Rewrap a ``WaveformProtocol``-satisfying result as ``Waveform1D`` (see ``test_calc.py``)."""
+    return Waveform1D(base.values, dt=base.dt, t0=base.t0)
+
+
+class TestAutoCorrelationOfWhiteNoiseIsApproximatelyADeltaFunction(unittest.TestCase):
+    """§Compliance 1: autocorrelation of white noise ~= delta (lag-0 dominates)."""
+
+    def test_lag_zero_is_one_and_dominates(self) -> None:
+        n = 2000
+        w = _wrap(Waveform1D.white_noise(n, amplitude=1.0, seed=42, dt_seconds=0.001))
+
+        auto_corr = w.auto_correlation(normalized=True)
+
+        self.assertAlmostEqual(float(auto_corr.values[0]), 1.0, places=9)
+        # Off-zero lags should be small relative to the lag-0 peak for white noise.
+        self.assertTrue(np.all(np.abs(auto_corr.values[1:]) < 0.2))
+
+    def test_result_length_matches_default_max_lag(self) -> None:
+        n = 40
+        w = _wrap(Waveform1D.white_noise(n, seed=1, dt_seconds=0.01))
+        auto_corr = w.auto_correlation()
+        self.assertEqual(len(auto_corr.values), n // 2 + 1)
+
+    def test_custom_max_lag(self) -> None:
+        n = 40
+        w = _wrap(Waveform1D.white_noise(n, seed=1, dt_seconds=0.01))
+        auto_corr = w.auto_correlation(max_lag=5)
+        self.assertEqual(len(auto_corr.values), 6)
+
+    def test_max_lag_clamped_to_sample_count_minus_one(self) -> None:
+        n = 5
+        w = _wrap(Waveform1D.white_noise(n, seed=1, dt_seconds=0.01))
+        auto_corr = w.auto_correlation(max_lag=100)
+        self.assertEqual(len(auto_corr.values), n)
+
+    def test_negative_max_lag_raises(self) -> None:
+        w = _wrap(Waveform1D.white_noise(10, seed=1, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.auto_correlation(max_lag=-1)
+
+
+class TestAutoCorrelationEdgeCases(unittest.TestCase):
+    """Zero-variance (constant) signals and empty input."""
+
+    def test_nonzero_constant_signal_is_one_at_every_lag(self) -> None:
+        w = _wrap(Waveform1D.constant(10, value=5.0, dt_seconds=0.1))
+        auto_corr = w.auto_correlation(normalized=True)
+        np.testing.assert_allclose(auto_corr.values, np.ones(len(auto_corr.values)))
+
+    def test_all_zero_signal_is_zero_at_every_lag(self) -> None:
+        w = _wrap(Waveform1D.constant(10, value=0.0, dt_seconds=0.1))
+        auto_corr = w.auto_correlation(normalized=True)
+        np.testing.assert_allclose(auto_corr.values, np.zeros(len(auto_corr.values)))
+
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.auto_correlation()
+
+    def test_unnormalized_lag_zero_equals_signal_energy(self) -> None:
+        values = [1.0, 2.0, 3.0, 2.0, 1.0]
+        w = Waveform1D(values, dt_seconds=0.1)
+        auto_corr = w.auto_correlation(normalized=False)
+        expected_energy = sum(v * v for v in values)
+        self.assertAlmostEqual(float(auto_corr.values[0]), expected_energy, places=9)
+
+
+class TestCrossCorrelationDtMismatchRaises(unittest.TestCase):
+    """Design constraint: dt mismatch -> ``WaveformCompatibilityError``."""
+
+    def test_cross_correlation_dt_mismatch(self) -> None:
+        w1 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.2)
+        with self.assertRaises(WaveformCompatibilityError):
+            w1.cross_correlation(w2)
+
+    def test_find_max_correlation_dt_mismatch(self) -> None:
+        w1 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.2)
+        with self.assertRaises(WaveformCompatibilityError):
+            w1.find_max_correlation(w2)
+
+
+class TestCrossCorrelationBasics(unittest.TestCase):
+    def test_full_mode_output_length(self) -> None:
+        w1 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 1.0, 1.0], dt_seconds=0.1)
+        cross = w1.cross_correlation(w2)
+        self.assertEqual(len(cross.values), 5)  # 3 + 3 - 1
+
+    def test_identical_signals_peak_at_zero_lag_and_near_one(self) -> None:
+        values = [1.0, 2.0, 3.0, 2.0, 1.0]
+        w1 = Waveform1D(values, dt_seconds=0.1)
+        w2 = Waveform1D(values, dt_seconds=0.1)
+        cross = w1.cross_correlation(w2, normalized=True)
+        center_index = len(cross.values) // 2
+        self.assertEqual(int(np.argmax(cross.values)), center_index)
+        self.assertAlmostEqual(float(cross.values[center_index]), 1.0, places=9)
+
+    def test_normalized_bounds(self) -> None:
+        w1 = Waveform1D([1.0, 3.0, 2.0, 4.0, 1.0], dt_seconds=0.1)
+        w2 = Waveform1D([2.0, 1.0, 3.0, 1.0, 2.0], dt_seconds=0.1)
+        cross = w1.cross_correlation(w2, normalized=True)
+        self.assertTrue(np.all(cross.values >= -1.0 - 1e-9))
+        self.assertTrue(np.all(cross.values <= 1.0 + 1e-9))
+
+    def test_max_lag_trims_output(self) -> None:
+        w1 = Waveform1D(list(range(20)), dt_seconds=0.1)
+        w2 = Waveform1D(list(range(20)), dt_seconds=0.1)
+        cross = w1.cross_correlation(w2, max_lag=3)
+        self.assertEqual(len(cross.values), 7)  # lags -3..3
+
+    def test_negative_max_lag_raises(self) -> None:
+        w1 = Waveform1D([1.0, 2.0], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w1.cross_correlation(w2, max_lag=-1)
+
+    def test_empty_waveform_raises(self) -> None:
+        w1 = Waveform1D([], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w1.cross_correlation(w2)
+
+
+class TestCrossCorrelationUnnormalizedRawEnergy(unittest.TestCase):
+    """§Gap 16 (chunk 55): the ``normalized=False`` raw-energy branch
+    (``_correlation.py:155``) had no numeric assertion -- pin it against a
+    direct ``scipy.signal.correlate`` call on the un-demeaned, un-scaled values."""
+
+    def test_matches_direct_scipy_correlate(self) -> None:
+        w1 = Waveform1D([1.0, 3.0, 2.0, 4.0, 1.0], dt_seconds=0.1)
+        w2 = Waveform1D([2.0, 1.0, 3.0, 1.0, 2.0], dt_seconds=0.1)
+
+        result = w1.cross_correlation(w2, normalized=False)
+
+        expected = correlate(
+            np.array([1.0, 3.0, 2.0, 4.0, 1.0]),
+            np.array([2.0, 1.0, 3.0, 1.0, 2.0]),
+            mode="full",
+        )
+        np.testing.assert_allclose(result.values, expected, rtol=0.0, atol=1e-12)
+
+    def test_self_correlation_lag_zero_equals_energy(self) -> None:
+        values = [1.0, 2.0, 3.0, 2.0, 1.0]
+        w1 = Waveform1D(values, dt_seconds=0.1)
+        w2 = Waveform1D(values, dt_seconds=0.1)
+
+        result = w1.cross_correlation(w2, normalized=False)
+
+        center_index = len(result.values) // 2
+        expected_energy = sum(v * v for v in values)
+        self.assertAlmostEqual(float(result.values[center_index]), expected_energy, places=9)
+
+
+class TestFindMaxCorrelationKnownShiftRecoversExactLag(unittest.TestCase):
+    """Acceptance criterion: known-shift lag recovery exact for k in {0, 3, 17}.
+
+    ``other`` is built as ``np.roll(self.values, k)`` -- i.e.
+    ``other[i] == self[i - k]`` (``other`` trails ``self`` by ``k``
+    samples). Per this module's documented lag sign convention (scipy's
+    native one), that yields ``lag_samples == -k``.
+    """
+
+    def _check_known_shift(self, k: int) -> None:
+        n = 2000
+        base = Waveform1D.white_noise(n, amplitude=1.0, seed=42, dt_seconds=0.001)
+        w1 = _wrap(base)
+        shifted_values = np.roll(base.values, k)
+        w2 = Waveform1D(shifted_values, dt=base.dt, t0=base.t0)
+
+        result = w1.find_max_correlation(w2)
+
+        self.assertEqual(result.lag_samples, -k)
+        self.assertAlmostEqual(result.lag_seconds, -k * 0.001, places=9)
+        self.assertGreater(result.correlation, 0.95)
+
+    def test_zero_shift(self) -> None:
+        self._check_known_shift(0)
+
+    def test_three_sample_shift(self) -> None:
+        self._check_known_shift(3)
+
+    def test_seventeen_sample_shift(self) -> None:
+        self._check_known_shift(17)
+
+
+class TestFindMaxCorrelationBasics(unittest.TestCase):
+    def test_identical_signals_zero_lag_high_correlation(self) -> None:
+        values = [1.0, 3.0, 2.0, 4.0, 1.0]
+        w1 = Waveform1D(values, dt_seconds=0.1)
+        w2 = Waveform1D(values, dt_seconds=0.1)
+        result = w1.find_max_correlation(w2)
+        self.assertEqual(result.lag_samples, 0)
+        self.assertEqual(result.lag_seconds, 0.0)
+        self.assertGreater(result.correlation, 0.9)
+
+    def test_max_lag_restricts_search(self) -> None:
+        n = 2000
+        base = Waveform1D.white_noise(n, amplitude=1.0, seed=7, dt_seconds=0.001)
+        w1 = _wrap(base)
+        shifted_values = np.roll(base.values, 17)
+        w2 = Waveform1D(shifted_values, dt=base.dt, t0=base.t0)
+
+        restricted = w1.find_max_correlation(w2, max_lag=5)
+
+        self.assertLessEqual(abs(restricted.lag_samples), 5)
+
+    def test_negative_max_lag_raises(self) -> None:
+        w1 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w1.find_max_correlation(w2, max_lag=-1)
+
+    def test_empty_waveform_raises(self) -> None:
+        w1 = Waveform1D([], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w1.find_max_correlation(w2)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/dsp/test_envelope.py b/tests/waveforms/dsp/test_envelope.py
new file mode 100644
index 0000000..4f8e6b3
--- /dev/null
+++ b/tests/waveforms/dsp/test_envelope.py
@@ -0,0 +1,263 @@
+"""Unit tests for ``dsp/_envelope.py`` (``EnvelopeMixin``).
+
+Covers waveformDsp.md §Family contracts (``EnvelopeMixin``), §Numerical
+conventions, §Compliance 1-2. Exercises the mixin directly on ``Waveform1D``, which
+composes every DSP mixin from the compose chunk (30) onward.
+"""
+
+import unittest
+
+import numpy as np
+
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformInstantaneousMethod
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+def _wrap(base: WaveformProtocol) -> Waveform1D:
+    """Rewrap a ``WaveformProtocol``-satisfying result as ``Waveform1D`` (see ``test_calc.py``)."""
+    return Waveform1D(base.values, dt=base.dt, t0=base.t0)
+
+
+class TestAmplitudeEnvelopeOfSineIsApproximatelyConstant(unittest.TestCase):
+    """§Compliance 1: envelope of ``A*sin`` is ~= A on the interior (rtol 5e-2)."""
+
+    def test_interior_matches_amplitude(self) -> None:
+        n = 2000
+        amplitude = 3.0
+        w = _wrap(
+            Waveform1D.sine(n, frequency=20.0, amplitude=amplitude, dt_seconds=1.0 / 2000.0)
+        )
+
+        envelope = w.amplitude_envelope()
+
+        interior = slice(50, -50)
+        np.testing.assert_allclose(
+            envelope.values[interior],
+            np.full(n, amplitude)[interior],
+            rtol=5e-2,
+        )
+
+    def test_result_length_matches_input(self) -> None:
+        w = _wrap(Waveform1D.sine(500, frequency=10.0, dt_seconds=1.0 / 500.0))
+        envelope = w.amplitude_envelope()
+        self.assertEqual(len(envelope.values), 500)
+
+    def test_metadata_preserved(self) -> None:
+        w = _wrap(
+            Waveform1D.sine(100, frequency=5.0, dt_seconds=0.01, t0_seconds=2.0)
+        )
+        envelope = w.amplitude_envelope()
+        self.assertEqual(envelope.dt, w.dt)
+        self.assertEqual(envelope.t0, w.t0)
+
+
+class TestAmplitudeEnvelopeOfDampedSinusoidTracksDecay(unittest.TestCase):
+    """§Compliance 1: envelope of a damped sinusoid tracks ``A*exp(-t/tau)`` (interior)."""
+
+    def test_interior_tracks_exponential_decay(self) -> None:
+        n = 4000
+        dt_seconds = 1.0 / 4000.0
+        amplitude = 2.0
+        time_constant = 1.5
+        w = _wrap(
+            Waveform1D.damped_sinusoid(
+                n,
+                frequency=30.0,
+                damping_constant=time_constant,
+                amplitude=amplitude,
+                dt_seconds=dt_seconds,
+            )
+        )
+
+        envelope = w.amplitude_envelope()
+
+        t = np.arange(n, dtype=np.float64) * dt_seconds
+        expected = amplitude * np.exp(-t / time_constant)
+        interior = slice(100, -100)
+        np.testing.assert_allclose(
+            envelope.values[interior], expected[interior], rtol=0.1
+        )
+
+
+class TestAmplitudeEnvelopeMinimumLengthRaises(unittest.TestCase):
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.amplitude_envelope()
+
+
+class TestUpperLowerEnvelopes(unittest.TestCase):
+    """§Compliance 1: upper >= lower everywhere."""
+
+    def test_upper_at_least_lower_for_sine(self) -> None:
+        w = _wrap(Waveform1D.sine(500, frequency=10.0, amplitude=2.0, dt_seconds=1.0 / 500.0))
+        upper, lower = w.upper_lower_envelopes()
+        self.assertTrue(np.all(upper.values >= lower.values - 1e-9))
+
+    def test_upper_at_least_lower_for_white_noise(self) -> None:
+        w = _wrap(Waveform1D.white_noise(500, amplitude=1.0, seed=3, dt_seconds=0.01))
+        upper, lower = w.upper_lower_envelopes()
+        self.assertTrue(np.all(upper.values >= lower.values - 1e-9))
+
+    def test_result_lengths_match_input(self) -> None:
+        w = _wrap(Waveform1D.sine(300, frequency=5.0, dt_seconds=0.01))
+        upper, lower = w.upper_lower_envelopes()
+        self.assertEqual(len(upper.values), 300)
+        self.assertEqual(len(lower.values), 300)
+
+    def test_metadata_preserved(self) -> None:
+        w = _wrap(Waveform1D.sine(200, frequency=5.0, dt_seconds=0.02, t0_seconds=1.0))
+        upper, lower = w.upper_lower_envelopes()
+        self.assertEqual(upper.dt, w.dt)
+        self.assertEqual(upper.t0, w.t0)
+        self.assertEqual(lower.dt, w.dt)
+        self.assertEqual(lower.t0, w.t0)
+
+    def test_boundary_samples_are_anchored(self) -> None:
+        # A monotonic ramp has no interior local extrema, so the envelope must
+        # fall back to interpolating between the two boundary samples.
+        w = _wrap(Waveform1D.linear_ramp(50, start_value=0.0, end_value=10.0, dt_seconds=0.1))
+        upper, lower = w.upper_lower_envelopes()
+        self.assertAlmostEqual(float(upper.values[0]), 0.0, places=9)
+        self.assertAlmostEqual(float(upper.values[-1]), 10.0, places=9)
+        self.assertAlmostEqual(float(lower.values[0]), 0.0, places=9)
+        self.assertAlmostEqual(float(lower.values[-1]), 10.0, places=9)
+
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.upper_lower_envelopes()
+
+    def test_upper_and_lower_track_plus_and_minus_amplitude(self) -> None:
+        """§Gap 17 (chunk 55): ``upper_lower_envelopes`` (``_envelope.py:106``) never
+        asserted upper ~= +A / lower ~= -A for ``A*sin`` on the interior -- only
+        the weaker ``upper >= lower`` ordering check existed."""
+        n = 2000
+        amplitude = 3.0
+        w = _wrap(
+            Waveform1D.sine(n, frequency=20.0, amplitude=amplitude, dt_seconds=1.0 / 2000.0)
+        )
+
+        upper, lower = w.upper_lower_envelopes()
+
+        # A larger leading/trailing trim than a Hilbert-based envelope needs: the
+        # first/last anchors are the boundary samples themselves (not necessarily
+        # extrema), so the peak-interpolated envelope tapers over the first and
+        # last partial periods.
+        interior = slice(100, -100)
+        np.testing.assert_allclose(
+            upper.values[interior], np.full(n, amplitude)[interior], rtol=5e-2
+        )
+        np.testing.assert_allclose(
+            lower.values[interior], np.full(n, -amplitude)[interior], rtol=5e-2, atol=1e-6
+        )
+
+
+class TestInstantaneousAmplitudeMethods(unittest.TestCase):
+    """§Compliance 1: each ``WaveformInstantaneousMethod`` returns the right length."""
+
+    def test_hilbert_length(self) -> None:
+        w = _wrap(Waveform1D.sine(400, frequency=10.0, dt_seconds=0.01))
+        result = w.instantaneous_amplitude(WaveformInstantaneousMethod.HILBERT)
+        self.assertEqual(len(result.values), 400)
+
+    def test_rms_length(self) -> None:
+        w = _wrap(Waveform1D.sine(400, frequency=10.0, dt_seconds=0.01))
+        result = w.instantaneous_amplitude(WaveformInstantaneousMethod.RMS)
+        self.assertEqual(len(result.values), 400)
+
+    def test_peak_length(self) -> None:
+        w = _wrap(Waveform1D.sine(400, frequency=10.0, dt_seconds=0.01))
+        result = w.instantaneous_amplitude(WaveformInstantaneousMethod.PEAK)
+        self.assertEqual(len(result.values), 400)
+
+    def test_hilbert_matches_amplitude_envelope(self) -> None:
+        w = _wrap(Waveform1D.sine(400, frequency=10.0, dt_seconds=0.01))
+        via_dispatch = w.instantaneous_amplitude(WaveformInstantaneousMethod.HILBERT)
+        via_direct = w.amplitude_envelope()
+        np.testing.assert_allclose(via_dispatch.values, via_direct.values)
+
+    def test_rms_is_nonnegative(self) -> None:
+        w = _wrap(Waveform1D.white_noise(300, amplitude=1.0, seed=1, dt_seconds=0.01))
+        result = w.instantaneous_amplitude(WaveformInstantaneousMethod.RMS)
+        self.assertTrue(np.all(result.values >= 0.0))
+
+    def test_rms_window_size_less_than_one_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(50, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.instantaneous_amplitude(WaveformInstantaneousMethod.RMS, window_size=0)
+
+    def test_peak_is_nonnegative(self) -> None:
+        w = _wrap(Waveform1D.sine(400, frequency=10.0, dt_seconds=0.01))
+        result = w.instantaneous_amplitude(WaveformInstantaneousMethod.PEAK)
+        self.assertTrue(np.all(result.values >= -1e-9))
+
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.instantaneous_amplitude()
+
+    def test_default_method_is_hilbert(self) -> None:
+        w = _wrap(Waveform1D.sine(200, frequency=10.0, dt_seconds=0.01))
+        default_result = w.instantaneous_amplitude()
+        hilbert_result = w.instantaneous_amplitude(WaveformInstantaneousMethod.HILBERT)
+        np.testing.assert_allclose(default_result.values, hilbert_result.values)
+
+    def test_metadata_preserved(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=5.0, dt_seconds=0.02, t0_seconds=1.0))
+        result = w.instantaneous_amplitude(WaveformInstantaneousMethod.RMS)
+        self.assertEqual(result.dt, w.dt)
+        self.assertEqual(result.t0, w.t0)
+
+    def test_peak_method_interior_matches_amplitude(self) -> None:
+        """§Gap 17 (chunk 55): ``_peak_envelope`` (``_envelope.py:67``) never asserted
+        a sine's rectified peak envelope ~= amplitude -- only non-negativity/length."""
+        n = 2000
+        amplitude = 2.5
+        w = _wrap(
+            Waveform1D.sine(n, frequency=20.0, amplitude=amplitude, dt_seconds=1.0 / 2000.0)
+        )
+
+        result = w.instantaneous_amplitude(WaveformInstantaneousMethod.PEAK)
+
+        interior = slice(50, -50)
+        np.testing.assert_allclose(
+            result.values[interior], np.full(n, amplitude)[interior], rtol=5e-2
+        )
+
+
+class TestWindowedRmsKnownAnswer(unittest.TestCase):
+    """§Gap 17 (chunk 55): ``_windowed_rms`` (``_envelope.py:80``) had no known
+    answer, and even ``window_size`` (the asymmetric edge-pad + truncation branch,
+    ``_envelope.py:88``) was never exercised. At a strictly interior sample index
+    ``i`` on ``values = arange(n)``, the centered/odd window covers
+    ``[i-half, i+half]`` while the even window's asymmetric offset (see the module
+    docstring's edge-padding construction) covers ``[i-half, i+half)`` -- both
+    hand-derivable directly from the "centered moving-window RMS" definition
+    without reproducing the private helper's own code.
+    """
+
+    def test_odd_window_matches_symmetric_hand_computed_rms(self) -> None:
+        n = 20
+        w = Waveform1D(np.arange(n, dtype=np.float64), dt_seconds=0.1)
+
+        result = w.instantaneous_amplitude(WaveformInstantaneousMethod.RMS, window_size=5)
+
+        i, half = 10, 2
+        expected = float(np.sqrt(np.mean(np.arange(i - half, i + half + 1) ** 2.0)))
+        self.assertAlmostEqual(float(result.values[i]), expected, places=9)
+
+    def test_even_window_matches_asymmetric_hand_computed_rms(self) -> None:
+        n = 20
+        w = Waveform1D(np.arange(n, dtype=np.float64), dt_seconds=0.1)
+
+        result = w.instantaneous_amplitude(WaveformInstantaneousMethod.RMS, window_size=4)
+
+        i, half = 10, 2
+        expected = float(np.sqrt(np.mean(np.arange(i - half, i + half) ** 2.0)))
+        self.assertAlmostEqual(float(result.values[i]), expected, places=9)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/dsp/test_filtering.py b/tests/waveforms/dsp/test_filtering.py
new file mode 100644
index 0000000..30809ad
--- /dev/null
+++ b/tests/waveforms/dsp/test_filtering.py
@@ -0,0 +1,552 @@
+"""Unit tests for ``dsp/_filtering.py`` (``FilteringMixin``).
+
+Covers waveformDsp.md §Family contracts (``FilteringMixin``), §Numerical
+conventions, §Compliance 1-2. Exercises the mixin directly on ``Waveform1D``, which
+composes every DSP mixin from the compose chunk (30) onward.
+"""
+
+import unittest
+
+import numpy as np
+import numpy.typing as npt
+from scipy.signal import butter, freqz, lfilter, savgol_filter
+
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformFilterType
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+def _wrap(base: WaveformProtocol) -> Waveform1D:
+    """Rewrap a ``WaveformProtocol``-satisfying result as ``Waveform1D`` (see ``test_calc.py``).
+
+    Needed after any call that returns via ``_with_values`` (a bare ``Waveform1D``,
+    which does not carry ``FilteringMixin``'s methods) -- construct a fresh ``Waveform1D``
+    directly instead when building test fixtures from raw arrays.
+    """
+    return Waveform1D(base.values, dt=base.dt, t0=base.t0)
+
+
+def _rfft_magnitude_at(
+    values: npt.NDArray[np.float64], dt_seconds: float, target_hz: float
+) -> float:
+    """Chunk-local rfft magnitude nearest ``target_hz`` (no dependency on ``SpectralMixin``)."""
+    n = values.shape[0]
+    spectrum = np.fft.rfft(values)
+    frequencies = np.fft.rfftfreq(n, d=dt_seconds)
+    index = int(np.argmin(np.abs(frequencies - target_hz)))
+    return float(np.abs(spectrum[index]))
+
+
+class TestLowPassFilterAttenuatesHighFrequency(unittest.TestCase):
+    """§Compliance 1: 5 Hz + 200 Hz mix (fs=2kHz) -> low_pass_filter(50) attenuates the
+    200 Hz component by >= 40 dB while the 5 Hz amplitude survives (rtol 5e-2)."""
+
+    def test_attenuation_and_passband_survival(self) -> None:
+        n = 4000
+        fs = 2000.0
+        dt_seconds = 1.0 / fs
+        low = Waveform1D.sine(n, frequency=5.0, amplitude=1.0, dt_seconds=dt_seconds)
+        high = Waveform1D.sine(n, frequency=200.0, amplitude=1.0, dt_seconds=dt_seconds)
+        mixed = Waveform1D(low.values + high.values, dt_seconds=dt_seconds)
+
+        filtered = mixed.low_pass_filter(cutoff_hz=50.0, order=4)
+
+        original_5 = _rfft_magnitude_at(mixed.values, dt_seconds, 5.0)
+        filtered_5 = _rfft_magnitude_at(filtered.values, dt_seconds, 5.0)
+        self.assertAlmostEqual(filtered_5 / original_5, 1.0, delta=5e-2)
+
+        original_200 = _rfft_magnitude_at(mixed.values, dt_seconds, 200.0)
+        filtered_200 = _rfft_magnitude_at(filtered.values, dt_seconds, 200.0)
+        attenuation_db = 20.0 * np.log10(original_200 / filtered_200)
+        self.assertGreaterEqual(attenuation_db, 40.0)
+
+
+class TestHighPassFilterAttenuatesLowFrequency(unittest.TestCase):
+    """§Compliance 1: high-pass mirror of the low-pass test."""
+
+    def test_attenuation_and_passband_survival(self) -> None:
+        n = 4000
+        fs = 2000.0
+        dt_seconds = 1.0 / fs
+        low = Waveform1D.sine(n, frequency=5.0, amplitude=1.0, dt_seconds=dt_seconds)
+        high = Waveform1D.sine(n, frequency=200.0, amplitude=1.0, dt_seconds=dt_seconds)
+        mixed = Waveform1D(low.values + high.values, dt_seconds=dt_seconds)
+
+        filtered = mixed.high_pass_filter(cutoff_hz=50.0, order=4)
+
+        original_200 = _rfft_magnitude_at(mixed.values, dt_seconds, 200.0)
+        filtered_200 = _rfft_magnitude_at(filtered.values, dt_seconds, 200.0)
+        self.assertAlmostEqual(filtered_200 / original_200, 1.0, delta=5e-2)
+
+        original_5 = _rfft_magnitude_at(mixed.values, dt_seconds, 5.0)
+        filtered_5 = _rfft_magnitude_at(filtered.values, dt_seconds, 5.0)
+        attenuation_db = 20.0 * np.log10(original_5 / filtered_5)
+        self.assertGreaterEqual(attenuation_db, 40.0)
+
+
+class TestBandPassFilterKeepsOnlyInBandTone(unittest.TestCase):
+    """§Compliance 1: band-pass keeps only the in-band tone."""
+
+    def test_only_in_band_tone_survives(self) -> None:
+        n = 4000
+        fs = 2000.0
+        dt_seconds = 1.0 / fs
+        below = Waveform1D.sine(n, frequency=5.0, amplitude=1.0, dt_seconds=dt_seconds)
+        in_band = Waveform1D.sine(n, frequency=50.0, amplitude=1.0, dt_seconds=dt_seconds)
+        above = Waveform1D.sine(n, frequency=200.0, amplitude=1.0, dt_seconds=dt_seconds)
+        mixed = Waveform1D(below.values + in_band.values + above.values, dt_seconds=dt_seconds)
+
+        filtered = mixed.band_pass_filter(low_hz=20.0, high_hz=100.0, order=4)
+
+        original_in_band = _rfft_magnitude_at(mixed.values, dt_seconds, 50.0)
+        filtered_in_band = _rfft_magnitude_at(filtered.values, dt_seconds, 50.0)
+        self.assertAlmostEqual(filtered_in_band / original_in_band, 1.0, delta=5e-2)
+
+        for out_of_band_hz in (5.0, 200.0):
+            original = _rfft_magnitude_at(mixed.values, dt_seconds, out_of_band_hz)
+            filtered_mag = _rfft_magnitude_at(filtered.values, dt_seconds, out_of_band_hz)
+            attenuation_db = 20.0 * np.log10(original / filtered_mag)
+            self.assertGreaterEqual(attenuation_db, 40.0)
+
+
+class TestFilteredDispatcher(unittest.TestCase):
+    """``filtered`` dispatches to the same Butterworth design as the named methods."""
+
+    def test_low_pass_matches_dedicated_method(self) -> None:
+        w = _wrap(Waveform1D.sine(1000, frequency=200.0, dt_seconds=1.0 / 2000.0))
+        via_dispatch = w.filtered(WaveformFilterType.LOW_PASS, cutoff_hz=50.0, order=4)
+        via_dedicated = w.low_pass_filter(cutoff_hz=50.0, order=4)
+        np.testing.assert_allclose(via_dispatch.values, via_dedicated.values, rtol=0.0, atol=1e-12)
+
+    def test_band_stop_is_reachable_only_via_dispatch(self) -> None:
+        n = 4000
+        fs = 2000.0
+        dt_seconds = 1.0 / fs
+        in_band = Waveform1D.sine(n, frequency=50.0, amplitude=1.0, dt_seconds=dt_seconds)
+        out_of_band = Waveform1D.sine(n, frequency=5.0, amplitude=1.0, dt_seconds=dt_seconds)
+        mixed = Waveform1D(in_band.values + out_of_band.values, dt_seconds=dt_seconds)
+
+        filtered = mixed.filtered(WaveformFilterType.BAND_STOP, low_hz=20.0, high_hz=100.0, order=4)
+
+        original_in_band = _rfft_magnitude_at(mixed.values, dt_seconds, 50.0)
+        filtered_in_band = _rfft_magnitude_at(filtered.values, dt_seconds, 50.0)
+        attenuation_db = 20.0 * np.log10(original_in_band / filtered_in_band)
+        self.assertGreaterEqual(attenuation_db, 40.0)
+
+        original_out = _rfft_magnitude_at(mixed.values, dt_seconds, 5.0)
+        filtered_out = _rfft_magnitude_at(filtered.values, dt_seconds, 5.0)
+        self.assertAlmostEqual(filtered_out / original_out, 1.0, delta=5e-2)
+
+    def test_missing_cutoff_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(1000, frequency=10.0, dt_seconds=0.001))
+        with self.assertRaises(ValueError):
+            w.filtered(WaveformFilterType.LOW_PASS)
+
+    def test_missing_band_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(1000, frequency=10.0, dt_seconds=0.001))
+        with self.assertRaises(ValueError):
+            w.filtered(WaveformFilterType.BAND_PASS, low_hz=10.0)
+
+
+class TestNyquistViolationRaises(unittest.TestCase):
+    """waveformDsp.md's Butterworth designs validate cutoffs against Nyquist."""
+
+    def test_low_pass_cutoff_at_nyquist_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(1000, frequency=10.0, dt_seconds=0.01))
+        nyquist = w.sampling_frequency_hz / 2.0
+        with self.assertRaises(ValueError):
+            w.low_pass_filter(cutoff_hz=nyquist)
+
+    def test_low_pass_cutoff_above_nyquist_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(1000, frequency=10.0, dt_seconds=0.01))
+        nyquist = w.sampling_frequency_hz / 2.0
+        with self.assertRaises(ValueError):
+            w.low_pass_filter(cutoff_hz=nyquist * 2.0)
+
+    def test_high_pass_cutoff_above_nyquist_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(1000, frequency=10.0, dt_seconds=0.01))
+        nyquist = w.sampling_frequency_hz / 2.0
+        with self.assertRaises(ValueError):
+            w.high_pass_filter(cutoff_hz=nyquist * 1.5)
+
+    def test_band_pass_high_above_nyquist_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(1000, frequency=10.0, dt_seconds=0.01))
+        nyquist = w.sampling_frequency_hz / 2.0
+        with self.assertRaises(ValueError):
+            w.band_pass_filter(low_hz=1.0, high_hz=nyquist * 1.5)
+
+    def test_band_pass_low_above_high_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(1000, frequency=10.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.band_pass_filter(low_hz=100.0, high_hz=50.0)
+
+
+class TestMovingAverageFilter(unittest.TestCase):
+    """§Compliance 1: moving average of a constant is identity."""
+
+    def test_constant_is_identity(self) -> None:
+        w = _wrap(Waveform1D.constant(50, value=3.0, dt_seconds=0.1))
+        filtered = w.moving_average_filter(window_size=5)
+        np.testing.assert_allclose(filtered.values, w.values, rtol=0.0, atol=1e-12)
+
+    def test_smooths_a_noisy_signal_at_interior_points(self) -> None:
+        rng = np.random.default_rng(3)
+        n = 500
+        noisy = Waveform1D(np.full(n, 1.0) + rng.normal(scale=0.5, size=n), dt_seconds=0.01)
+
+        filtered = noisy.moving_average_filter(window_size=25)
+
+        interior = slice(50, -50)
+        self.assertLess(
+            float(np.std(filtered.values[interior])), float(np.std(noisy.values[interior]))
+        )
+
+    def test_invalid_window_size_raises(self) -> None:
+        w = _wrap(Waveform1D.constant(10, value=1.0, dt_seconds=0.1))
+        with self.assertRaises(ValueError):
+            w.moving_average_filter(window_size=0)
+
+
+class TestExponentialFilter(unittest.TestCase):
+    """Exponential (EMA) smoothing: alpha=1 is identity; smaller alpha smooths."""
+
+    def test_alpha_one_is_identity(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=3.0, dt_seconds=0.01))
+        filtered = w.exponential_filter(alpha=1.0)
+        np.testing.assert_allclose(filtered.values, w.values, rtol=0.0, atol=1e-12)
+
+    def test_first_sample_unchanged(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=3.0, dt_seconds=0.01))
+        filtered = w.exponential_filter(alpha=0.2)
+        self.assertEqual(filtered.values[0], w.values[0])
+
+    def test_smooths_a_step(self) -> None:
+        values = np.concatenate([np.zeros(20), np.ones(20)])
+        w = Waveform1D(values, dt_seconds=0.01)
+        filtered = w.exponential_filter(alpha=0.3)
+        # The step response should not jump immediately to 1.0 the sample after the step.
+        self.assertLess(float(filtered.values[20]), 1.0)
+
+    def test_invalid_alpha_raises(self) -> None:
+        w = _wrap(Waveform1D.constant(10, value=1.0, dt_seconds=0.1))
+        with self.assertRaises(ValueError):
+            w.exponential_filter(alpha=0.0)
+        with self.assertRaises(ValueError):
+            w.exponential_filter(alpha=1.5)
+
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.exponential_filter(alpha=0.5)
+
+
+class TestSavitzkyGolayFilter(unittest.TestCase):
+    """§Compliance 1: savgol on a noiseless cubic reproduces it (atol 1e-8)."""
+
+    def test_cubic_is_reproduced(self) -> None:
+        n = 101
+        x = np.linspace(-1.0, 1.0, n)
+        cubic = 2.0 * x**3 - 3.0 * x**2 + 0.5 * x + 1.0
+        w = Waveform1D(cubic, dt_seconds=0.01)
+
+        filtered = w.savitzky_golay_filter(window_length=11, polyorder=3, deriv=0)
+
+        np.testing.assert_allclose(filtered.values, cubic, rtol=0.0, atol=1e-8)
+
+    def test_invalid_window_length_raises(self) -> None:
+        w = _wrap(Waveform1D.constant(50, value=1.0, dt_seconds=0.1))
+        with self.assertRaises(ValueError):
+            w.savitzky_golay_filter(window_length=4, polyorder=2)  # even window
+
+    def test_polyorder_too_large_raises(self) -> None:
+        w = _wrap(Waveform1D.constant(50, value=1.0, dt_seconds=0.1))
+        with self.assertRaises(ValueError):
+            w.savitzky_golay_filter(window_length=5, polyorder=5)
+
+    def test_deriv_exceeds_polyorder_raises(self) -> None:
+        w = _wrap(Waveform1D.constant(50, value=1.0, dt_seconds=0.1))
+        with self.assertRaises(ValueError):
+            w.savitzky_golay_filter(window_length=5, polyorder=2, deriv=3)
+
+
+class TestWhittakerHendersonFilter(unittest.TestCase):
+    """§Compliance 1: lam -> 0 approximates identity; large lam approximates a linear trend."""
+
+    def test_small_lambda_approximates_identity(self) -> None:
+        rng = np.random.default_rng(11)
+        n = 200
+        noisy = Waveform1D(np.full(n, 2.0) + rng.normal(scale=0.1, size=n), dt_seconds=0.05)
+
+        smoothed = noisy.whittaker_henderson_filter(lam=1e-9, order=2)
+
+        np.testing.assert_allclose(smoothed.values, noisy.values, rtol=1e-4, atol=1e-4)
+
+    def test_large_lambda_approximates_linear_trend(self) -> None:
+        n = 200
+        dt_seconds = 0.05
+        rng = np.random.default_rng(13)
+        ramp = Waveform1D.linear_ramp(n, start_value=0.0, end_value=10.0, dt_seconds=dt_seconds)
+        noisy = Waveform1D(ramp.values + rng.normal(scale=0.2, size=n), dt_seconds=dt_seconds)
+
+        smoothed = noisy.whittaker_henderson_filter(lam=1e8, order=2)
+
+        # A degree-1 polynomial least-squares fit to the noisy ramp is the reference
+        # "linear trend"; the heavily-smoothed result should track it closely away
+        # from the very ends.
+        coeffs = np.polyfit(np.arange(n), noisy.values, 1)
+        trend = np.polyval(coeffs, np.arange(n))
+        interior = slice(10, -10)
+        np.testing.assert_allclose(
+            smoothed.values[interior], trend[interior], rtol=0.0, atol=0.2
+        )
+
+    def test_invalid_order_raises(self) -> None:
+        w = _wrap(Waveform1D.constant(50, value=1.0, dt_seconds=0.1))
+        with self.assertRaises(ValueError):
+            w.whittaker_henderson_filter(lam=1.0, order=0)
+
+    def test_too_few_samples_raises(self) -> None:
+        w = Waveform1D([1.0, 2.0])
+        with self.assertRaises(ValueError):
+            w.whittaker_henderson_filter(lam=1.0, order=2)
+
+
+class TestFrequencyResponse(unittest.TestCase):
+    """``frequency_response`` returns a ``WaveformSpectrum`` sampling the filter's
+    magnitude/phase response over frequency."""
+
+    def test_low_pass_passes_dc_and_attenuates_high_frequency(self) -> None:
+        w = _wrap(Waveform1D.constant(1000, value=1.0, dt_seconds=1.0 / 2000.0))
+        response = w.frequency_response(
+            WaveformFilterType.LOW_PASS, cutoff_hz=50.0, order=4, num_points=512
+        )
+
+        self.assertAlmostEqual(float(response.magnitudes[0]), 1.0, delta=1e-2)
+        near_nyquist_index = -1
+        self.assertLess(float(response.magnitudes[near_nyquist_index]), 0.01)
+
+    def test_result_lengths_match_num_points(self) -> None:
+        w = _wrap(Waveform1D.constant(1000, value=1.0, dt_seconds=1.0 / 2000.0))
+        response = w.frequency_response(
+            WaveformFilterType.HIGH_PASS, cutoff_hz=50.0, order=4, num_points=128
+        )
+        self.assertEqual(len(response.frequencies), 128)
+        self.assertEqual(len(response.magnitudes), 128)
+        self.assertEqual(len(response.phases), 128)
+
+    def test_band_pass_and_band_stop_and_phases_match_direct_scipy(self) -> None:
+        """§Gap 6 (chunk 55): ``phases`` and BAND_PASS/BAND_STOP pinned against a
+        direct ``scipy.signal.freqz`` call on the same ``butter``-designed coefficients."""
+        w = _wrap(Waveform1D.constant(1000, value=1.0, dt_seconds=1.0 / 2000.0))
+        fs = w.sampling_frequency_hz
+
+        for filter_type, btype, kwargs in (
+            (WaveformFilterType.BAND_PASS, "bandpass", {"low_hz": 20.0, "high_hz": 100.0}),
+            (WaveformFilterType.BAND_STOP, "bandstop", {"low_hz": 20.0, "high_hz": 100.0}),
+        ):
+            with self.subTest(filter_type=filter_type):
+                response = w.frequency_response(filter_type, order=4, num_points=256, **kwargs)
+                b, a = butter(4, [20.0, 100.0], btype=btype, fs=fs)
+                expected_freq, expected_response = freqz(b, a, worN=256, fs=fs)
+                np.testing.assert_allclose(response.frequencies, expected_freq)
+                np.testing.assert_allclose(response.magnitudes, np.abs(expected_response))
+                np.testing.assert_allclose(response.phases, np.angle(expected_response))
+
+
+class TestCausalFilterUsesLfilterNotFiltfilt(unittest.TestCase):
+    """§Gap 1 (chunk 55): ``causal=True`` selects a single-pass ``scipy.signal.lfilter``
+    (matched exactly, coefficient-for-coefficient), and differs from the zero-phase
+    ``filtfilt`` default -- pinning waveformDsp.md §Numerical conventions' ``causal=``
+    flag, previously never exercised by any test in the suite."""
+
+    def test_low_pass_causal_matches_direct_lfilter(self) -> None:
+        n = 1000
+        fs = 2000.0
+        w = _wrap(Waveform1D.sine(n, frequency=200.0, dt_seconds=1.0 / fs))
+
+        causal = w.low_pass_filter(cutoff_hz=50.0, order=4, causal=True)
+
+        b, a = butter(4, 50.0, btype="low", fs=fs)
+        expected = lfilter(b, a, w.values)
+        np.testing.assert_allclose(causal.values, expected, rtol=0.0, atol=1e-12)
+
+    def test_causal_differs_from_zero_phase_default(self) -> None:
+        n = 1000
+        fs = 2000.0
+        w = _wrap(Waveform1D.sine(n, frequency=200.0, dt_seconds=1.0 / fs))
+
+        causal = w.low_pass_filter(cutoff_hz=50.0, order=4, causal=True)
+        zero_phase = w.low_pass_filter(cutoff_hz=50.0, order=4, causal=False)
+
+        self.assertFalse(np.allclose(causal.values, zero_phase.values))
+
+    def test_high_pass_causal_matches_direct_lfilter(self) -> None:
+        n = 1000
+        fs = 2000.0
+        w = _wrap(Waveform1D.sine(n, frequency=5.0, dt_seconds=1.0 / fs))
+
+        causal = w.high_pass_filter(cutoff_hz=50.0, order=4, causal=True)
+
+        b, a = butter(4, 50.0, btype="high", fs=fs)
+        expected = lfilter(b, a, w.values)
+        np.testing.assert_allclose(causal.values, expected, rtol=0.0, atol=1e-12)
+
+    def test_band_pass_causal_matches_direct_lfilter(self) -> None:
+        n = 1000
+        fs = 2000.0
+        w = _wrap(Waveform1D.sine(n, frequency=50.0, dt_seconds=1.0 / fs))
+
+        causal = w.band_pass_filter(low_hz=20.0, high_hz=100.0, order=4, causal=True)
+
+        b, a = butter(4, [20.0, 100.0], btype="bandpass", fs=fs)
+        expected = lfilter(b, a, w.values)
+        np.testing.assert_allclose(causal.values, expected, rtol=0.0, atol=1e-12)
+
+    def test_filtered_dispatch_honors_causal(self) -> None:
+        n = 1000
+        fs = 2000.0
+        w = _wrap(Waveform1D.sine(n, frequency=200.0, dt_seconds=1.0 / fs))
+
+        via_dispatch = w.filtered(WaveformFilterType.LOW_PASS, cutoff_hz=50.0, causal=True)
+        via_dedicated = w.low_pass_filter(cutoff_hz=50.0, causal=True)
+        np.testing.assert_allclose(via_dispatch.values, via_dedicated.values, rtol=0.0, atol=1e-12)
+
+
+class TestValidateOrderRaisesForEveryButterworthMethod(unittest.TestCase):
+    """§Gap 4 (chunk 55): ``order < 1`` (the raise-don't-clamp policy's load-bearing
+    path, ``_filtering.py:63``) was never triggered for any Butterworth method."""
+
+    def test_low_pass_order_zero_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.low_pass_filter(cutoff_hz=10.0, order=0)
+
+    def test_high_pass_order_zero_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.high_pass_filter(cutoff_hz=10.0, order=0)
+
+    def test_band_pass_order_zero_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.band_pass_filter(low_hz=5.0, high_hz=10.0, order=0)
+
+    def test_filtered_order_zero_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.filtered(WaveformFilterType.LOW_PASS, cutoff_hz=10.0, order=0)
+
+    def test_frequency_response_order_zero_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.frequency_response(WaveformFilterType.LOW_PASS, cutoff_hz=10.0, order=0)
+
+    def test_negative_order_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.low_pass_filter(cutoff_hz=10.0, order=-1)
+
+
+class TestValidateCutoffLowerBoundRaises(unittest.TestCase):
+    """§Gap 5 (chunk 55): ``cutoff_hz <= 0`` (``_filtering.py:68``) was untested --
+    only the upper (Nyquist) bound was exercised before this chunk."""
+
+    def test_low_pass_zero_cutoff_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.low_pass_filter(cutoff_hz=0.0)
+
+    def test_low_pass_negative_cutoff_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.low_pass_filter(cutoff_hz=-10.0)
+
+    def test_high_pass_zero_cutoff_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.high_pass_filter(cutoff_hz=0.0)
+
+    def test_band_pass_zero_low_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.band_pass_filter(low_hz=0.0, high_hz=10.0)
+
+
+class TestExponentialFilterClosedForm(unittest.TestCase):
+    """§Gap 7 (chunk 55): pin the closed-form recursion ``y[i] = alpha*x[i] +
+    (1-alpha)*y[i-1]`` at a specific interior ``i`` -- the existing suite only
+    checked ``alpha=1.0`` (identity) and ``values[20] < 1.0`` (a bound a swapped
+    ``alpha``/``1-alpha`` would also satisfy)."""
+
+    def test_recursion_matches_hand_computed_value_at_i5(self) -> None:
+        values = [1.0, 4.0, 2.0, 9.0, 5.0, 7.0, 3.0]
+        alpha = 0.3
+        w = Waveform1D(values, dt_seconds=0.1)
+
+        filtered = w.exponential_filter(alpha=alpha)
+
+        expected = values[0]
+        for x in values[1:6]:
+            expected = alpha * x + (1.0 - alpha) * expected
+        self.assertAlmostEqual(float(filtered.values[5]), expected, places=12)
+
+    def test_swapped_alpha_would_not_match(self) -> None:
+        """Sanity check that the closed-form pin above actually distinguishes a
+        swapped alpha/(1-alpha) -- guards against a vacuously-passing assertion."""
+        values = [1.0, 4.0, 2.0, 9.0, 5.0, 7.0, 3.0]
+        alpha = 0.3
+        w = Waveform1D(values, dt_seconds=0.1)
+
+        filtered = w.exponential_filter(alpha=alpha)
+
+        wrong_expected = values[0]
+        for x in values[1:6]:
+            wrong_expected = (1.0 - alpha) * x + alpha * wrong_expected
+        self.assertNotAlmostEqual(float(filtered.values[5]), wrong_expected, places=6)
+
+
+class TestSavitzkyGolayDerivativeUnits(unittest.TestCase):
+    """§Gap 2 (chunk 55): ``deriv > 0`` is the only place ``delta=dt_seconds`` is
+    applied (``_filtering.py:356``) -- a wrong ``delta`` silently returns
+    per-sample rather than per-second derivatives, and no existing test set
+    ``deriv > 0``."""
+
+    def test_matches_direct_scipy_call_with_delta(self) -> None:
+        """Pins that the mixin forwards exactly ``delta=dt_seconds`` to scipy --
+        a direct-scipy-reference comparison (design constraint 1)."""
+        n = 500
+        dt_seconds = 1.0 / 2000.0
+        w = _wrap(Waveform1D.sine(n, frequency=50.0, amplitude=1.0, dt_seconds=dt_seconds))
+
+        result = w.savitzky_golay_filter(window_length=11, polyorder=3, deriv=1)
+
+        expected = savgol_filter(
+            np.asarray(w.values), 11, 3, deriv=1, delta=dt_seconds
+        )
+        np.testing.assert_allclose(result.values, expected, rtol=0.0, atol=1e-12)
+
+    def test_interior_matches_analytic_derivative_in_per_second_units(self) -> None:
+        """A wrong ``delta`` (e.g. the unscaled per-sample default of 1.0) would
+        return values off by a factor of ``dt_seconds`` (~2e-4 here) -- this
+        analytic comparison to ``2*pi*f*A*cos(2*pi*f*t)`` fails loudly in that case."""
+        n = 1000
+        fs = 2000.0
+        dt_seconds = 1.0 / fs
+        frequency = 50.0
+        amplitude = 1.0
+        w = _wrap(
+            Waveform1D.sine(n, frequency=frequency, amplitude=amplitude, dt_seconds=dt_seconds)
+        )
+
+        result = w.savitzky_golay_filter(window_length=11, polyorder=3, deriv=1)
+
+        t = np.arange(n, dtype=np.float64) * dt_seconds
+        analytic = 2.0 * np.pi * frequency * amplitude * np.cos(2.0 * np.pi * frequency * t)
+        interior = slice(20, -20)
+        np.testing.assert_allclose(
+            result.values[interior], analytic[interior], rtol=2e-2, atol=1.0
+        )
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/dsp/test_peaks.py b/tests/waveforms/dsp/test_peaks.py
new file mode 100644
index 0000000..6a91d58
--- /dev/null
+++ b/tests/waveforms/dsp/test_peaks.py
@@ -0,0 +1,234 @@
+"""Unit tests for ``dsp/_peaks.py`` (``PeakMixin``).
+
+Covers waveformDsp.md §Family contracts (``PeakMixin``), §Numerical
+conventions, §Compliance 1-2. Exercises the mixin directly on ``Waveform1D``, which
+composes every DSP mixin from the compose chunk (30) onward.
+"""
+
+import math
+import unittest
+
+import numpy as np
+from scipy.signal import find_peaks, peak_prominences
+
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+def _wrap(base: WaveformProtocol) -> Waveform1D:
+    """Rewrap a ``WaveformProtocol``-satisfying result as ``Waveform1D`` (see ``test_calc.py``)."""
+    return Waveform1D(base.values, dt=base.dt, t0=base.t0)
+
+
+class TestDetectPeaksOnSineHasExactCount(unittest.TestCase):
+    """§Compliance 1: ``sine(n, f, fs)`` yields exactly ``floor(n*f/fs)`` peaks.
+
+    ``n=1000``, ``frequency=10``, ``fs=1000`` (``dt_seconds=0.001``) is
+    unambiguous: 10 whole periods (100 samples each) fit exactly in 1000
+    samples, so every peak (one per period, at the quarter-period sample)
+    falls strictly in the interior -- no boundary-peak ambiguity.
+    """
+
+    def test_exact_peak_count(self) -> None:
+        n = 1000
+        frequency = 10.0
+        fs = 1000.0
+        w = _wrap(Waveform1D.sine(n, frequency=frequency, dt_seconds=1.0 / fs))
+
+        peaks = w.detect_peaks()
+
+        expected_count = math.floor(n * frequency / fs)
+        self.assertEqual(expected_count, 10)
+        self.assertEqual(len(peaks), expected_count)
+
+    def test_peak_indices_and_time_seconds(self) -> None:
+        n = 1000
+        frequency = 10.0
+        fs = 1000.0
+        dt_seconds = 1.0 / fs
+        w = _wrap(Waveform1D.sine(n, frequency=frequency, dt_seconds=dt_seconds))
+
+        peaks = w.detect_peaks()
+
+        expected_indices = [25 + 100 * m for m in range(10)]
+        self.assertEqual([p.index for p in peaks], expected_indices)
+        for peak in peaks:
+            self.assertAlmostEqual(peak.time_seconds, peak.index * dt_seconds, places=12)
+            self.assertAlmostEqual(peak.value, 1.0, places=6)
+
+
+class TestDetectValleysMirrorPeaksUnderNegation(unittest.TestCase):
+    """§TDD step 1: valleys mirror peaks under negation."""
+
+    def test_matches_negated_detect_peaks(self) -> None:
+        values = [1.0, 3.0, 0.5, 4.0, -2.0, 5.0, -3.0, 2.0, 6.0, 0.0]
+        w = Waveform1D(values, dt_seconds=0.1)
+        negated_w = Waveform1D([-v for v in values], dt_seconds=0.1)
+
+        valleys = w.detect_valleys()
+        negated_peaks = negated_w.detect_peaks()
+
+        self.assertTrue(len(valleys) > 0)
+        self.assertEqual(len(valleys), len(negated_peaks))
+        for valley, negated_peak in zip(valleys, negated_peaks, strict=True):
+            self.assertEqual(valley.index, negated_peak.index)
+            self.assertAlmostEqual(valley.time_seconds, negated_peak.time_seconds, places=12)
+            self.assertAlmostEqual(valley.value, -negated_peak.value, places=12)
+
+    def test_sine_valley_count_matches_peak_count(self) -> None:
+        n = 1000
+        frequency = 10.0
+        fs = 1000.0
+        w = _wrap(Waveform1D.sine(n, frequency=frequency, dt_seconds=1.0 / fs))
+
+        self.assertEqual(len(w.detect_valleys()), len(w.detect_peaks()))
+
+    def test_min_height_bounds_value_from_above(self) -> None:
+        values = [5.0, 1.0, 4.0, -3.0, 4.0, 0.5, 5.0]
+        w = Waveform1D(values, dt_seconds=0.1)
+
+        valleys = w.detect_valleys(min_height=2.0)
+
+        self.assertEqual(len(valleys), 1)
+        self.assertEqual(valleys[0].index, 3)
+        self.assertAlmostEqual(valleys[0].value, -3.0, places=12)
+
+
+class TestFindMostProminentPeaksOrdering(unittest.TestCase):
+    """§TDD step 1: prominence ordering on a two-tone signal returns the big ones first."""
+
+    def _two_tone_waveform(self) -> Waveform1D:
+        values = [0.0, 0.0, 0.0, 10.0, 0.0, 0.0, 0.0, 3.0, 0.0, 0.0, 0.0]
+        return Waveform1D(values, dt_seconds=0.1)
+
+    def test_big_peak_returned_before_small_peak(self) -> None:
+        w = self._two_tone_waveform()
+
+        top_peaks = w.find_most_prominent_peaks(count=2)
+
+        self.assertEqual(len(top_peaks), 2)
+        self.assertEqual(top_peaks[0].peak.index, 3)
+        self.assertAlmostEqual(top_peaks[0].peak.value, 10.0, places=12)
+        self.assertEqual(top_peaks[1].peak.index, 7)
+        self.assertAlmostEqual(top_peaks[1].peak.value, 3.0, places=12)
+        self.assertGreater(top_peaks[0].prominence, top_peaks[1].prominence)
+
+    def test_count_one_returns_only_the_biggest(self) -> None:
+        w = self._two_tone_waveform()
+
+        top_peaks = w.find_most_prominent_peaks(count=1)
+
+        self.assertEqual(len(top_peaks), 1)
+        self.assertEqual(top_peaks[0].peak.index, 3)
+
+    def test_count_larger_than_available_peaks_truncates_gracefully(self) -> None:
+        w = self._two_tone_waveform()
+
+        top_peaks = w.find_most_prominent_peaks(count=10)
+
+        self.assertEqual(len(top_peaks), 2)
+
+    def test_non_positive_count_returns_empty(self) -> None:
+        w = self._two_tone_waveform()
+
+        self.assertEqual(w.find_most_prominent_peaks(count=0), [])
+        self.assertEqual(w.find_most_prominent_peaks(count=-1), [])
+
+    def test_prominence_values_match_direct_scipy_peak_prominences(self) -> None:
+        """§Gap 18 (chunk 55): ``WaveformPeakWithProminence.prominence``
+        (``_peaks.py:144``) only had its ordering asserted, never the numeric
+        value -- pin it against a direct ``scipy.signal.peak_prominences`` call."""
+        w = self._two_tone_waveform()
+        values = np.array([0.0, 0.0, 0.0, 10.0, 0.0, 0.0, 0.0, 3.0, 0.0, 0.0, 0.0])
+
+        top_peaks = w.find_most_prominent_peaks(count=2)
+
+        indices, _ = find_peaks(values)
+        expected_prominences, _, _ = peak_prominences(values, indices)
+        expected_by_index = dict(zip(indices.tolist(), expected_prominences.tolist(), strict=True))
+        for peak_with_prominence in top_peaks:
+            self.assertAlmostEqual(
+                peak_with_prominence.prominence,
+                expected_by_index[peak_with_prominence.peak.index],
+                places=9,
+            )
+
+    def test_min_distance_suppresses_close_secondary_peak(self) -> None:
+        """§Gap 18 (chunk 55): ``min_distance`` (``_peaks.py:131``) was never passed
+        to ``find_most_prominent_peaks`` by any test."""
+        values = [0.0, 5.0, 0.0, 6.0, 0.0, 4.0, 0.0]
+        w = Waveform1D(values, dt_seconds=0.1)
+
+        unfiltered = w.find_most_prominent_peaks(count=3)
+        filtered = w.find_most_prominent_peaks(count=3, min_distance=5)
+
+        self.assertEqual(len(unfiltered), 3)
+        self.assertLess(len(filtered), len(unfiltered))
+        self.assertIn(3, [p.peak.index for p in filtered])
+
+
+class TestFlatSignalHasNoPeaksOrValleys(unittest.TestCase):
+    """§TDD step 1: flat signal -> []."""
+
+    def test_detect_peaks_empty(self) -> None:
+        w = _wrap(Waveform1D.constant(10, value=5.0, dt_seconds=0.1))
+        self.assertEqual(w.detect_peaks(), [])
+
+    def test_detect_valleys_empty(self) -> None:
+        w = _wrap(Waveform1D.constant(10, value=5.0, dt_seconds=0.1))
+        self.assertEqual(w.detect_valleys(), [])
+
+    def test_find_most_prominent_peaks_empty(self) -> None:
+        w = _wrap(Waveform1D.constant(10, value=5.0, dt_seconds=0.1))
+        self.assertEqual(w.find_most_prominent_peaks(count=5), [])
+
+
+class TestEmptyWaveformNeverRaises(unittest.TestCase):
+    """waveformDsp.md §Numerical conventions: detectors return [] on no-hit, never raise."""
+
+    def test_detect_peaks_on_empty_waveform(self) -> None:
+        w = Waveform1D([])
+        self.assertEqual(w.detect_peaks(), [])
+
+    def test_detect_valleys_on_empty_waveform(self) -> None:
+        w = Waveform1D([])
+        self.assertEqual(w.detect_valleys(), [])
+
+    def test_find_most_prominent_peaks_on_empty_waveform(self) -> None:
+        w = Waveform1D([])
+        self.assertEqual(w.find_most_prominent_peaks(count=3), [])
+
+
+class TestDetectPeaksFilters(unittest.TestCase):
+    def test_min_height_filters_low_peaks(self) -> None:
+        values = [0.0, 0.0, 0.0, 10.0, 0.0, 0.0, 0.0, 3.0, 0.0, 0.0, 0.0]
+        w = Waveform1D(values, dt_seconds=0.1)
+
+        peaks = w.detect_peaks(min_height=5.0)
+
+        self.assertEqual(len(peaks), 1)
+        self.assertEqual(peaks[0].index, 3)
+
+    def test_min_prominence_filters_low_prominence_peaks(self) -> None:
+        values = [0.0, 0.0, 0.0, 10.0, 0.0, 0.0, 0.0, 3.0, 0.0, 0.0, 0.0]
+        w = Waveform1D(values, dt_seconds=0.1)
+
+        peaks = w.detect_peaks(min_prominence=5.0)
+
+        self.assertEqual(len(peaks), 1)
+        self.assertEqual(peaks[0].index, 3)
+
+    def test_min_distance_suppresses_close_secondary_peaks(self) -> None:
+        values = [0.0, 5.0, 0.0, 6.0, 0.0, 4.0, 0.0]
+        w = Waveform1D(values, dt_seconds=0.1)
+
+        unfiltered = w.detect_peaks()
+        filtered = w.detect_peaks(min_distance=5)
+
+        self.assertEqual(len(unfiltered), 3)
+        self.assertLess(len(filtered), len(unfiltered))
+        self.assertIn(3, [p.index for p in filtered])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/dsp/test_phase.py b/tests/waveforms/dsp/test_phase.py
new file mode 100644
index 0000000..bfa62cb
--- /dev/null
+++ b/tests/waveforms/dsp/test_phase.py
@@ -0,0 +1,295 @@
+"""Unit tests for ``dsp/_phase.py`` (``PhaseMixin``).
+
+Covers waveformDsp.md §Family contracts (``PhaseMixin``), §Numerical
+conventions, §Compliance 1-2. Exercises the mixin directly on ``Waveform1D``, which
+composes every DSP mixin from the compose chunk (30) onward.
+"""
+
+import unittest
+
+import numpy as np
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.waveforms.dsp._phase import PhaseMixin
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformInstantaneousFrequency
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+def _wrap(base: WaveformProtocol) -> Waveform1D:
+    """Rewrap a ``WaveformProtocol``-satisfying result as ``Waveform1D`` (see ``test_calc.py``)."""
+    return Waveform1D(base.values, dt=base.dt, t0=base.t0)
+
+
+class TestInstantaneousPhaseOfChirpIsMonotoneIncreasingWhenUnwrapped(unittest.TestCase):
+    """§Compliance 1: unwrapped phase of a chirp is monotone increasing."""
+
+    def test_chirp_unwrapped_phase_is_monotone(self) -> None:
+        n = 2000
+        w = _wrap(
+            Waveform1D.chirp(n, start_frequency=5.0, end_frequency=50.0, dt_seconds=1.0 / 1000.0)
+        )
+        phase = w.instantaneous_phase(unwrapped=True)
+
+        interior = phase.values[10:-10]
+        self.assertTrue(np.all(np.diff(interior) > 0.0))
+
+    def test_wrapped_phase_stays_within_pi(self) -> None:
+        n = 2000
+        w = _wrap(
+            Waveform1D.chirp(n, start_frequency=5.0, end_frequency=50.0, dt_seconds=1.0 / 1000.0)
+        )
+        phase = w.instantaneous_phase(unwrapped=False)
+
+        self.assertTrue(np.all(phase.values >= -np.pi - 1e-9))
+        self.assertTrue(np.all(phase.values <= np.pi + 1e-9))
+
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.instantaneous_phase()
+
+
+class TestUnwrapPhase(unittest.TestCase):
+    """``unwrap_phase`` treats ``self.values`` as already-computed phase data."""
+
+    def test_recovers_a_linear_ramp_from_wrapped_phase(self) -> None:
+        n = 500
+        true_phase = np.linspace(0.0, 40.0 * np.pi, n)
+        wrapped = np.angle(np.exp(1j * true_phase))
+        w = Waveform1D(wrapped, dt_seconds=0.01)
+
+        unwrapped = w.unwrap_phase()
+
+        # Unwrapping recovers the true phase up to a constant 2*pi*k offset
+        # (np.unwrap anchors on the first sample, which is already wrapped).
+        offset = unwrapped.values[0] - true_phase[0]
+        np.testing.assert_allclose(unwrapped.values, true_phase + offset, atol=1e-6)
+
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.unwrap_phase()
+
+    def test_threshold_changes_whether_a_borderline_step_is_corrected(self) -> None:
+        """§Gap 19 (chunk 55): ``threshold`` (``_phase.py:107``) was never varied
+        from the default. A constant per-sample step of 3.3 rad sits strictly
+        between ``pi`` (~3.14159, the default) and 3.4: the default threshold
+        registers it as a discontinuity and unwraps it, while ``threshold=3.4``
+        treats the same data as already continuous and leaves it untouched."""
+        n = 5
+        raw_phase = np.arange(n, dtype=np.float64) * 3.3
+        w = Waveform1D(raw_phase, dt_seconds=0.01)
+
+        unchanged = w.unwrap_phase(threshold=3.4)
+        np.testing.assert_allclose(unchanged.values, raw_phase)
+
+        corrected = w.unwrap_phase()  # default threshold=pi
+        expected = np.unwrap(raw_phase, discont=np.pi)
+        np.testing.assert_allclose(corrected.values, expected)
+        self.assertFalse(np.allclose(corrected.values, raw_phase))
+
+    def test_matches_direct_numpy_unwrap_at_a_non_default_threshold(self) -> None:
+        n = 5
+        raw_phase = np.arange(n, dtype=np.float64) * 3.3
+        w = Waveform1D(raw_phase, dt_seconds=0.01)
+
+        result = w.unwrap_phase(threshold=3.29)
+
+        expected = np.unwrap(raw_phase, discont=3.29)
+        np.testing.assert_allclose(result.values, expected)
+
+
+class TestInstantaneousFrequencyOfPureSineApproximatesFrequency(unittest.TestCase):
+    """§Compliance 1: instantaneous frequency of a pure f-Hz sine ~= f on the
+    interior (rtol 1e-2)."""
+
+    def test_ten_hz_sine(self) -> None:
+        n = 5000
+        frequency = 10.0
+        dt_seconds = 1.0 / 1000.0
+        w = _wrap(Waveform1D.sine(n, frequency=frequency, amplitude=1.0, dt_seconds=dt_seconds))
+
+        result = w.instantaneous_frequency()
+
+        self.assertIsInstance(result, WaveformInstantaneousFrequency)
+        interior = result.frequencies_hz[20:-20]
+        np.testing.assert_allclose(interior, frequency, rtol=1e-2)
+
+    def test_times_seconds_matches_time_axis(self) -> None:
+        n = 100
+        dt_seconds = 0.01
+        w = _wrap(Waveform1D.sine(n, frequency=5.0, dt_seconds=dt_seconds))
+        result = w.instantaneous_frequency()
+        expected_times = np.arange(n, dtype=np.float64) * dt_seconds
+        np.testing.assert_allclose(result.times_seconds, expected_times)
+
+    def test_single_sample_raises(self) -> None:
+        w = Waveform1D([1.0])
+        with self.assertRaises(ValueError):
+            w.instantaneous_frequency()
+
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.instantaneous_frequency()
+
+
+class TestPhaseDifferenceOfSinVsCosApproximatesHalfPi(unittest.TestCase):
+    """§Compliance 1: ``phase_difference`` of ``sin`` vs ``cos`` ~= pi/2 interior."""
+
+    def test_magnitude_is_approximately_half_pi(self) -> None:
+        n = 2000
+        dt_seconds = 1.0 / 1000.0
+        sine = _wrap(Waveform1D.sine(n, frequency=10.0, dt_seconds=dt_seconds))
+        cosine = _wrap(Waveform1D.cosine(n, frequency=10.0, dt_seconds=dt_seconds))
+
+        diff = sine.phase_difference(cosine)
+
+        interior = diff.values[20:-20]
+        np.testing.assert_allclose(np.abs(interior), np.pi / 2.0, atol=0.05)
+
+    def test_dt_mismatch_raises(self) -> None:
+        w1 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.2)
+        with self.assertRaises(WaveformCompatibilityError):
+            w1.phase_difference(w2)
+
+    def test_sample_count_mismatch_raises(self) -> None:
+        w1 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0], dt_seconds=0.1)
+        with self.assertRaises(WaveformCompatibilityError):
+            w1.phase_difference(w2)
+
+    def test_empty_waveform_raises(self) -> None:
+        w1 = Waveform1D([], dt_seconds=0.1)
+        w2 = Waveform1D([], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w1.phase_difference(w2)
+
+
+class TestPhaseSynchronizationIndex(unittest.TestCase):
+    """§Compliance 1: PLV of a signal with itself == 1.0; with independent
+    seeded-noise signal < 0.3."""
+
+    def test_signal_with_itself_is_one(self) -> None:
+        n = 1000
+        w = _wrap(Waveform1D.sine(n, frequency=7.0, dt_seconds=0.001))
+        plv = w.phase_synchronization_index(w)
+        self.assertAlmostEqual(plv, 1.0, places=9)
+
+    def test_independent_noise_signals_are_weakly_synchronized(self) -> None:
+        n = 4000
+        w1 = _wrap(Waveform1D.white_noise(n, amplitude=1.0, seed=1, dt_seconds=0.001))
+        w2 = _wrap(Waveform1D.white_noise(n, amplitude=1.0, seed=2, dt_seconds=0.001))
+        plv = w1.phase_synchronization_index(w2)
+        self.assertLess(plv, 0.3)
+
+    def test_dt_mismatch_raises(self) -> None:
+        w1 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.2)
+        with self.assertRaises(WaveformCompatibilityError):
+            w1.phase_synchronization_index(w2)
+
+    def test_empty_waveform_raises(self) -> None:
+        w1 = Waveform1D([], dt_seconds=0.1)
+        w2 = Waveform1D([], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w1.phase_synchronization_index(w2)
+
+
+class TestPhaseCoherence(unittest.TestCase):
+    def test_signal_with_itself_is_approximately_one_in_every_window(self) -> None:
+        n = 2000
+        w = _wrap(Waveform1D.sine(n, frequency=7.0, dt_seconds=0.001))
+        coherence = w.phase_coherence(w, window=200)
+        np.testing.assert_allclose(coherence.values, 1.0, atol=1e-9)
+
+    def test_independent_noise_signals_have_low_coherence(self) -> None:
+        n = 4000
+        w1 = _wrap(Waveform1D.white_noise(n, amplitude=1.0, seed=3, dt_seconds=0.001))
+        w2 = _wrap(Waveform1D.white_noise(n, amplitude=1.0, seed=4, dt_seconds=0.001))
+        coherence = w1.phase_coherence(w2, window=200)
+        self.assertTrue(np.all(coherence.values < 0.6))
+
+    def test_output_length_matches_number_of_windows(self) -> None:
+        w = Waveform1D(np.zeros(1000), dt_seconds=0.001)
+        coherence = w.phase_coherence(w, window=100)
+        self.assertEqual(len(coherence.values), 10)
+
+    def test_window_out_of_range_raises(self) -> None:
+        w = Waveform1D(np.zeros(10), dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.phase_coherence(w, window=0)
+        with self.assertRaises(ValueError):
+            w.phase_coherence(w, window=11)
+
+    def test_dt_mismatch_raises(self) -> None:
+        w1 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.2)
+        with self.assertRaises(WaveformCompatibilityError):
+            w1.phase_coherence(w2)
+
+    def test_single_sample_raises(self) -> None:
+        w = Waveform1D([1.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.phase_coherence(w)
+
+    def test_default_window_matches_sample_count_over_four_when_small(self) -> None:
+        """§Gap 19 (chunk 55): the default ``window`` expression (``_phase.py:187``,
+        ``min(256, max(1, sample_count // 4))``) was never exercised -- pin the
+        unclamped branch (``sample_count // 4 < 256``) by comparing against an
+        explicit matching ``window``."""
+        w = Waveform1D(np.zeros(40), dt_seconds=0.001)
+        default_result = w.phase_coherence(w)
+        explicit_result = w.phase_coherence(w, window=40 // 4)
+        self.assertEqual(len(default_result.values), len(explicit_result.values))
+
+    def test_default_window_clamps_to_256_when_sample_count_over_four_exceeds_it(self) -> None:
+        """Pins the ``min(256, ...)`` clamp branch (``sample_count // 4 > 256``)."""
+        w = Waveform1D(np.zeros(2000), dt_seconds=0.001)
+        default_result = w.phase_coherence(w)
+        explicit_result = w.phase_coherence(w, window=256)
+        self.assertEqual(len(default_result.values), len(explicit_result.values))
+
+
+class TestGroupDelay(unittest.TestCase):
+    """A linear phase-vs-frequency response has a constant group delay."""
+
+    def test_linear_phase_gives_constant_group_delay(self) -> None:
+        frequencies = np.linspace(1.0, 100.0, 200)
+        delay_seconds = 0.005
+        phases = -2.0 * np.pi * frequencies * delay_seconds
+
+        result = PhaseMixin.group_delay(frequencies, phases)
+
+        np.testing.assert_allclose(result, delay_seconds, atol=1e-9)
+
+    def test_callable_on_an_instance_too(self) -> None:
+        w = Waveform1D([1.0, 2.0], dt_seconds=0.1)
+        frequencies = np.array([1.0, 2.0, 3.0])
+        phases = np.array([0.0, -0.1, -0.2])
+        result = w.group_delay(frequencies, phases)
+        self.assertEqual(result.shape, (3,))
+
+    def test_shape_mismatch_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            PhaseMixin.group_delay(np.array([1.0, 2.0, 3.0]), np.array([0.0, 0.1]))
+
+    def test_too_short_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            PhaseMixin.group_delay(np.array([1.0]), np.array([0.0]))
+
+
+class TestMetadataPreserved(unittest.TestCase):
+    """Unary results share ``dt``/``t0`` with the source."""
+
+    def test_instantaneous_phase_preserves_dt_and_t0(self) -> None:
+        w = _wrap(Waveform1D.sine(50, frequency=5.0, dt_seconds=0.02, t0_seconds=3.0))
+        phase = w.instantaneous_phase()
+        self.assertEqual(phase.dt, w.dt)
+        self.assertEqual(phase.t0, w.t0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/dsp/test_resampling.py b/tests/waveforms/dsp/test_resampling.py
new file mode 100644
index 0000000..8a0ca95
--- /dev/null
+++ b/tests/waveforms/dsp/test_resampling.py
@@ -0,0 +1,345 @@
+"""Unit tests for ``dsp/_resampling.py`` (``ResamplingMixin``).
+
+Covers waveformDsp.md §Family contracts (``ResamplingMixin``), §Numerical
+conventions, §Compliance 1-2. Exercises the mixin directly on ``Waveform1D``, which
+composes every DSP mixin from the compose chunk (30) onward.
+"""
+
+import unittest
+
+import numpy as np
+from scipy.signal import resample as scipy_resample
+from scipy.signal import resample_poly as scipy_resample_poly
+
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformInterpolationMethod
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+def _wrap(base: WaveformProtocol) -> Waveform1D:
+    """Rewrap a ``WaveformProtocol``-satisfying result as ``Waveform1D`` (see ``test_calc.py``)."""
+    return Waveform1D(base.values, dt=base.dt, t0=base.t0)
+
+
+class TestDecimatedFactorValidation(unittest.TestCase):
+    def test_factor_zero_raises(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.decimated(0)
+
+    def test_negative_factor_raises(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.decimated(-2)
+
+    def test_non_int_factor_raises(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.decimated(1.5)  # type: ignore[arg-type]
+
+
+class TestDecimatedDtIsExact(unittest.TestCase):
+    """§Design constraints: integer-factor ``dt`` bookkeeping is attosecond-exact."""
+
+    def test_decimated_by_four_dt_exact(self) -> None:
+        n = 2000
+        w = _wrap(Waveform1D.sine(n, frequency=5.0, amplitude=1.0, dt_seconds=1.0 / 1000.0))
+        decimated = w.decimated(4)
+        self.assertEqual(decimated.dt, w.dt * 4)
+
+    def test_decimated_by_one_is_identity_dt(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0, 5.0], dt_seconds=0.25)
+        decimated = w.decimated(1)
+        self.assertEqual(decimated.dt, w.dt)
+        np.testing.assert_allclose(decimated.values, w.values)
+
+    def test_decimated_preserves_t0(self) -> None:
+        n = 2000
+        w = _wrap(
+            Waveform1D.sine(
+                n, frequency=5.0, amplitude=1.0, dt_seconds=1.0 / 1000.0, t0_seconds=3.0
+            )
+        )
+        decimated = w.decimated(4)
+        self.assertEqual(decimated.t0, w.t0)
+
+
+class TestInterpolatedFactorValidation(unittest.TestCase):
+    def test_factor_zero_raises(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.interpolated(0)
+
+    def test_negative_factor_raises(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.interpolated(-3)
+
+    def test_non_int_factor_raises(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.interpolated(2.5)  # type: ignore[arg-type]
+
+
+class TestInterpolatedDtIsExact(unittest.TestCase):
+    def test_interpolated_by_two_dt_exact(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.5)
+        interpolated = w.interpolated(2)
+        self.assertEqual(interpolated.dt, w.dt / 2)
+
+    def test_interpolated_by_one_is_identity_dt(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.2)
+        interpolated = w.interpolated(1)
+        self.assertEqual(interpolated.dt, w.dt)
+        np.testing.assert_allclose(interpolated.values, w.values)
+
+    def test_interpolated_preserves_t0(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.5, t0_seconds=1.0)
+        interpolated = w.interpolated(2)
+        self.assertEqual(interpolated.t0, w.t0)
+
+    def test_interpolated_endpoint_preserving_length(self) -> None:
+        n = 10
+        w = Waveform1D(list(range(n)), dt_seconds=1.0)
+        interpolated = w.interpolated(3)
+        self.assertEqual(len(interpolated.values), (n - 1) * 3 + 1)
+
+
+class TestInterpolatedDecimatedRoundTrip(unittest.TestCase):
+    """§Compliance 1 (TDD step 1): ``interpolated(2).decimated(2)`` round-trips a
+    smooth signal interior (rtol 1e-3)."""
+
+    def test_sine_round_trip(self) -> None:
+        n = 2000
+        original = _wrap(Waveform1D.sine(n, frequency=5.0, amplitude=1.0, dt_seconds=1.0 / 1000.0))
+
+        round_tripped = _wrap(original.interpolated(2)).decimated(2)
+
+        self.assertEqual(len(round_tripped.values), n)
+        interior = slice(20, -20)
+        np.testing.assert_allclose(
+            round_tripped.values[interior], original.values[interior], rtol=1e-3, atol=1e-3
+        )
+
+    def test_cubic_method_round_trip(self) -> None:
+        n = 2000
+        original = _wrap(Waveform1D.sine(n, frequency=5.0, amplitude=1.0, dt_seconds=1.0 / 1000.0))
+
+        round_tripped = _wrap(
+            original.interpolated(2, method=WaveformInterpolationMethod.CUBIC)
+        ).decimated(2)
+
+        interior = slice(20, -20)
+        np.testing.assert_allclose(
+            round_tripped.values[interior], original.values[interior], rtol=1e-3, atol=1e-3
+        )
+
+
+class TestResampledValidation(unittest.TestCase):
+    def test_zero_target_frequency_raises(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.resampled(0.0)
+
+    def test_negative_target_frequency_raises(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.resampled(-10.0)
+
+
+class TestResampledDerivesDtFromAchievedRate(unittest.TestCase):
+    def test_doubling_rate_halves_dt(self) -> None:
+        n = 1000
+        w = _wrap(Waveform1D.sine(n, frequency=5.0, amplitude=1.0, dt_seconds=1.0 / 100.0))
+        target_hz = 2.0 * w.sampling_frequency_hz
+
+        resampled = w.resampled(target_hz)
+
+        self.assertAlmostEqual(
+            resampled.dt.seconds_as_float, w.dt.seconds_as_float / 2.0, places=9
+        )
+        self.assertEqual(len(resampled.values), 2 * n)
+        self.assertEqual(resampled.t0, w.t0)
+
+
+class TestResampledToMatch(unittest.TestCase):
+    """§Compliance 1 (TDD step 1): ``resampled_to_match`` yields matching ``dt``
+    and length within ±1."""
+
+    def test_matches_other_rate_and_length(self) -> None:
+        duration_seconds = 2.0
+        n1 = 1000
+        n2 = 500
+        w1 = _wrap(
+            Waveform1D.sine(n1, frequency=5.0, amplitude=1.0, dt_seconds=duration_seconds / n1)
+        )
+        other = _wrap(
+            Waveform1D.sine(n2, frequency=5.0, amplitude=1.0, dt_seconds=duration_seconds / n2)
+        )
+
+        matched = w1.resampled_to_match(other)
+
+        self.assertAlmostEqual(
+            matched.dt.seconds_as_float, other.dt.seconds_as_float, places=6
+        )
+        self.assertLessEqual(abs(len(matched.values) - len(other.values)), 1)
+
+    def test_samples_match_direct_scipy_resample(self) -> None:
+        """§Gap 14 (chunk 55): samples were never compared to the reference --
+        only ``dt``/length. Pin against the same ``scipy.signal.resample`` call
+        the implementation makes internally at the achieved length."""
+        n1 = 200
+        n2 = 130
+        w1 = _wrap(Waveform1D.sine(n1, frequency=5.0, amplitude=1.0, dt_seconds=0.01))
+        other = Waveform1D.sine(n2, frequency=5.0, amplitude=1.0, dt_seconds=0.015)
+
+        matched = w1.resampled_to_match(other)
+
+        expected_length = round(n1 * other.sampling_frequency_hz / w1.sampling_frequency_hz)
+        expected = scipy_resample(np.asarray(w1.values), expected_length)
+        np.testing.assert_allclose(matched.values, expected)
+
+
+class TestPolyphaseResampled(unittest.TestCase):
+    """§Compliance 1 (TDD step 1): polyphase 3:2 length check."""
+
+    def test_three_two_length(self) -> None:
+        n = 100
+        w = _wrap(Waveform1D.sine(n, frequency=5.0, amplitude=1.0, dt_seconds=0.01))
+        result = w.polyphase_resampled(up=3, down=2)
+        expected_length = -(-(n * 3) // 2)  # ceil(n * up / down)
+        self.assertEqual(len(result.values), expected_length)
+
+    def test_dt_is_exact(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0, 5.0, 6.0], dt_seconds=0.5)
+        result = w.polyphase_resampled(up=3, down=2)
+        self.assertEqual(result.dt, (w.dt * 2) / 3)
+
+    def test_samples_match_direct_scipy_resample_poly(self) -> None:
+        """§Gap 15 (chunk 55): no numeric check against the source existed --
+        only length/dt. Pin against a direct ``scipy.signal.resample_poly`` call."""
+        w = _wrap(Waveform1D.sine(100, frequency=5.0, amplitude=1.0, dt_seconds=0.01))
+
+        result = w.polyphase_resampled(up=3, down=2)
+
+        expected = scipy_resample_poly(np.asarray(w.values), 3, 2)
+        np.testing.assert_allclose(result.values, expected)
+
+    def test_invalid_up_raises(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.polyphase_resampled(up=0, down=2)
+
+    def test_invalid_down_raises(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.polyphase_resampled(up=2, down=0)
+
+
+class TestResampledTimesTwoThenHalfRoundTrips(unittest.TestCase):
+    """§Gap 3 (chunk 55): waveformDsp.md §Compliance 1's own named case --
+    "``resampled`` x2 then /2 round-trips (rtol 1e-3, interior)" -- was
+    substituted by ``interpolated(2).decimated(2)`` in the existing suite. This
+    is the literal ``resampled`` round trip."""
+
+    def test_sine_round_trip(self) -> None:
+        n = 1000
+        w = _wrap(Waveform1D.sine(n, frequency=5.0, amplitude=1.0, dt_seconds=1.0 / 1000.0))
+        fs = w.sampling_frequency_hz
+
+        round_tripped = _wrap(w.resampled(2.0 * fs)).resampled(fs)
+
+        self.assertEqual(len(round_tripped.values), n)
+        interior = slice(20, -20)
+        np.testing.assert_allclose(
+            round_tripped.values[interior], w.values[interior], rtol=1e-3, atol=1e-3
+        )
+
+
+class TestNearestInterpolation(unittest.TestCase):
+    """§Gap 12 (chunk 55): ``NEAREST`` (``_resampling.py:116``) was never exercised
+    by any test -- including its banker's-rounding (round-half-to-even) half-sample
+    bias at exactly-.5 target positions."""
+
+    def test_half_sample_positions_round_to_even_index(self) -> None:
+        # target_positions for factor=2 on 3 samples: [0, 0.5, 1, 1.5, 2].
+        # np.round's banker's rounding sends 0.5 -> 0 (even) and 1.5 -> 2 (even).
+        w = Waveform1D([0.0, 10.0, 20.0], dt_seconds=1.0)
+
+        result = w.interpolated(2, method=WaveformInterpolationMethod.NEAREST)
+
+        np.testing.assert_allclose(result.values, [0.0, 0.0, 10.0, 20.0, 20.0])
+
+    def test_endpoints_and_length_preserved(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.5)
+        result = w.interpolated(3, method=WaveformInterpolationMethod.NEAREST)
+        self.assertEqual(len(result.values), (4 - 1) * 3 + 1)
+        self.assertEqual(float(result.values[0]), 1.0)
+        self.assertEqual(float(result.values[-1]), 4.0)
+
+
+class TestFourierInterpolation(unittest.TestCase):
+    """§Gap 13 (chunk 55): ``FOURIER`` (``_resampling.py:102``) was never exercised
+    -- pin it against a direct ``scipy.signal.resample`` call at the same
+    target length."""
+
+    def test_matches_direct_scipy_resample(self) -> None:
+        n = 200
+        w = _wrap(Waveform1D.sine(n, frequency=5.0, amplitude=1.0, dt_seconds=0.01))
+        new_length = (n - 1) * 2 + 1
+
+        result = w.interpolated(2, method=WaveformInterpolationMethod.FOURIER)
+
+        expected = scipy_resample(np.asarray(w.values), new_length)
+        np.testing.assert_allclose(result.values, expected)
+
+
+class TestMinimumLengthRaises(unittest.TestCase):
+    def test_decimated_on_single_sample_raises(self) -> None:
+        w = Waveform1D([1.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.decimated(2)
+
+    def test_interpolated_on_single_sample_raises(self) -> None:
+        w = Waveform1D([1.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.interpolated(2)
+
+    def test_resampled_on_single_sample_raises(self) -> None:
+        w = Waveform1D([1.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.resampled(20.0)
+
+    def test_polyphase_resampled_on_single_sample_raises(self) -> None:
+        w = Waveform1D([1.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.polyphase_resampled(up=3, down=2)
+
+
+class TestMetadataPreserved(unittest.TestCase):
+    """dt/t0 are ``PrecisionTimeInterval``/``PrecisionTimestamp`` typed, and ``t0``
+    is always unchanged by resampling (waveformDsp.md's stated design constraint)."""
+
+    def test_resampled_t0_unchanged(self) -> None:
+        w = _wrap(
+            Waveform1D.sine(500, frequency=5.0, dt_seconds=1.0 / 500.0, t0_seconds=10.0)
+        )
+        resampled = w.resampled(250.0)
+        self.assertEqual(resampled.t0, w.t0)
+
+    def test_polyphase_t0_unchanged(self) -> None:
+        w = _wrap(
+            Waveform1D.sine(100, frequency=5.0, dt_seconds=0.01, t0_seconds=2.0)
+        )
+        result = w.polyphase_resampled(up=3, down=2)
+        self.assertEqual(result.t0, w.t0)
+
+    def test_dt_is_precision_time_interval(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1)
+        decimated = w.decimated(2)
+        self.assertIsInstance(decimated.dt, PrecisionTimeInterval)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/dsp/test_spectral.py b/tests/waveforms/dsp/test_spectral.py
new file mode 100644
index 0000000..f7e3171
--- /dev/null
+++ b/tests/waveforms/dsp/test_spectral.py
@@ -0,0 +1,484 @@
+"""Unit tests for ``dsp/_spectral.py`` (``SpectralMixin``).
+
+Covers waveformDsp.md §Family contracts (``SpectralMixin``), §Numerical
+conventions, §Compliance 1-2. Exercises the mixin directly on ``Waveform1D``, which
+composes every DSP mixin from the compose chunk (30) onward.
+"""
+
+import unittest
+
+import numpy as np
+from scipy.signal import get_window, welch
+from scipy.signal import spectrogram as scipy_spectrogram
+
+from math_tools.waveforms.dsp import _spectral as spectral_module
+from math_tools.waveforms.dsp._common import DEFAULT_KAISER_BETA
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.dsp._spectral import _mel_filterbank
+from math_tools.waveforms.dsp._windowing import WindowingMixin
+from math_tools.waveforms.support import WaveformPSDScaling, WaveformWindowType
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+def _wrap(base: WaveformProtocol) -> Waveform1D:
+    """Rewrap a ``WaveformProtocol``-satisfying result as ``Waveform1D`` (see ``test_calc.py``)."""
+    return Waveform1D(base.values, dt=base.dt, t0=base.t0)
+
+
+class TestFftPeakBin(unittest.TestCase):
+    """§Compliance 1: fft of a pure 10 Hz sine (fs=1kHz, n=1000) peaks at the 10 Hz bin."""
+
+    def test_peak_at_10hz(self) -> None:
+        n = 1000
+        fs = 1000.0
+        w = _wrap(Waveform1D.sine(n, frequency=10.0, amplitude=1.0, dt_seconds=1.0 / fs))
+
+        spectrum = w.fft()
+
+        peak_index = int(np.argmax(spectrum.magnitudes))
+        self.assertAlmostEqual(float(spectrum.frequencies[peak_index]), 10.0, places=6)
+
+    def test_frequency_axis_length_matches_rfft_convention(self) -> None:
+        n = 256
+        w = _wrap(Waveform1D.sine(n, frequency=5.0, dt_seconds=0.01))
+        spectrum = w.fft()
+        self.assertEqual(len(spectrum.frequencies), n // 2 + 1)
+        self.assertEqual(len(spectrum.magnitudes), n // 2 + 1)
+        self.assertEqual(len(spectrum.phases), n // 2 + 1)
+
+    def test_minimum_length_raises(self) -> None:
+        w = Waveform1D([1.0])
+        with self.assertRaises(ValueError):
+            w.fft()
+
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.fft()
+
+
+class TestFftParsevalSanity(unittest.TestCase):
+    """§Compliance 1: Parseval's theorem holds for the returned one-sided magnitudes."""
+
+    def test_parseval_relation_holds(self) -> None:
+        n = 512  # even, so the one-sided reconstruction weighting below is exact
+        w = _wrap(Waveform1D.white_noise(n, amplitude=1.0, seed=7, dt_seconds=0.01))
+
+        spectrum = w.fft()
+        # One-sided reconstruction: sum(x^2) == (1/N) * (|X[0]|^2 + |X[N/2]|^2
+        # + 2 * sum(|X[1..N/2-1]|^2)) for even N.
+        mag_sq = spectrum.magnitudes**2
+        reconstructed = (mag_sq[0] + mag_sq[-1] + 2.0 * np.sum(mag_sq[1:-1])) / n
+
+        time_domain_energy = float(np.sum(w.values**2))
+        self.assertAlmostEqual(reconstructed / time_domain_energy, 1.0, delta=1e-6)
+
+
+class TestPowerSpectralDensityOfWhiteNoiseIsFlat(unittest.TestCase):
+    """§Compliance 1: PSD of white noise is flat within a loose band."""
+
+    def test_psd_is_approximately_flat(self) -> None:
+        n = 20_000
+        w = _wrap(Waveform1D.white_noise(n, amplitude=1.0, seed=11, dt_seconds=1.0 / 2000.0))
+
+        spectrum = w.power_spectral_density(nperseg=512)
+
+        # Exclude DC; white-noise PSD should vary loosely around its mean once
+        # enough segments have been averaged (Welch's method).
+        interior = spectrum.magnitudes[1:]
+        mean_power = float(np.mean(interior))
+        relative_deviation = float(np.std(interior)) / mean_power
+        self.assertLess(relative_deviation, 0.5)
+
+    def test_result_length_matches_frequency_axis(self) -> None:
+        w = _wrap(Waveform1D.white_noise(1000, amplitude=1.0, seed=3, dt_seconds=0.01))
+        spectrum = w.power_spectral_density(nperseg=128)
+        self.assertEqual(len(spectrum.magnitudes), len(spectrum.frequencies))
+        self.assertTrue(np.all(spectrum.phases == 0.0))
+
+    def test_minimum_length_raises(self) -> None:
+        w = Waveform1D([1.0])
+        with self.assertRaises(ValueError):
+            w.power_spectral_density()
+
+    def test_nperseg_exceeding_sample_count_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(50, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.power_spectral_density(nperseg=100)
+
+
+class TestSpectrogramOfChirpIsMonotone(unittest.TestCase):
+    """§Compliance 1: spectrogram of a chirp has a monotonically increasing
+    argmax-frequency per time frame."""
+
+    def test_peak_frequency_increases_with_time(self) -> None:
+        n = 4000
+        fs = 4000.0
+        w = _wrap(
+            Waveform1D.chirp(
+                n, start_frequency=50.0, end_frequency=500.0, amplitude=1.0, dt_seconds=1.0 / fs
+            )
+        )
+
+        spec = w.spectrogram(nperseg=256, overlap=0.75)
+
+        peak_freqs = spec.frequencies[np.argmax(spec.magnitudes, axis=1)]
+        # Trim the first/last couple of frames (window-edge artifacts) and allow a
+        # small negative tolerance (one frequency bin) for quantization noise.
+        interior = peak_freqs[2:-2]
+        freq_resolution = float(spec.frequencies[1] - spec.frequencies[0])
+        diffs = np.diff(interior)
+        self.assertTrue(np.all(diffs >= -freq_resolution))
+        self.assertGreater(interior[-1], interior[0])
+
+    def test_result_shape(self) -> None:
+        w = _wrap(Waveform1D.sine(2000, frequency=10.0, dt_seconds=0.001))
+        spec = w.spectrogram(nperseg=256, overlap=0.5)
+        self.assertEqual(spec.magnitudes.shape, (len(spec.times), len(spec.frequencies)))
+
+    def test_minimum_length_raises(self) -> None:
+        w = Waveform1D([1.0])
+        with self.assertRaises(ValueError):
+            w.spectrogram()
+
+    def test_invalid_overlap_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(200, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.spectrogram(overlap=1.0)
+        with self.assertRaises(ValueError):
+            w.spectrogram(overlap=-0.1)
+
+    def test_nperseg_exceeding_sample_count_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(50, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.spectrogram(nperseg=100)
+
+
+class TestMelFilterbankRowsSumToOne(unittest.TestCase):
+    """§Compliance 1: mel filterbank rows sum ~= 1 where fully inside the band."""
+
+    def test_rows_sum_to_approximately_one(self) -> None:
+        frequency_bins = np.linspace(0.0, 500.0, 257)
+        filterbank, mel_centers = _mel_filterbank(
+            frequency_bins_hz=frequency_bins,
+            n_mels=20,
+            min_frequency_hz=0.0,
+            max_frequency_hz=500.0,
+        )
+        row_sums = np.sum(filterbank, axis=1)
+        np.testing.assert_allclose(row_sums, np.ones(20), rtol=1e-6, atol=1e-9)
+        self.assertEqual(len(mel_centers), 20)
+
+
+class TestMelSpectrogram(unittest.TestCase):
+    """§Compliance 1: mel_spectrogram round-trips sanely through the FFT/mel pipeline."""
+
+    def test_result_shape(self) -> None:
+        w = _wrap(Waveform1D.sine(2000, frequency=50.0, dt_seconds=1.0 / 2000.0))
+        mel_spec = w.mel_spectrogram(n_mels=10, nperseg=256, overlap=0.5)
+        self.assertEqual(mel_spec.magnitudes.shape, (len(mel_spec.times), 10))
+        self.assertEqual(len(mel_spec.mel_frequencies), 10)
+
+    def test_magnitudes_are_nonnegative(self) -> None:
+        w = _wrap(Waveform1D.white_noise(1000, amplitude=1.0, seed=5, dt_seconds=0.01))
+        mel_spec = w.mel_spectrogram(n_mels=8, nperseg=128)
+        self.assertTrue(np.all(mel_spec.magnitudes >= -1e-9))
+
+    def test_n_mels_less_than_one_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(200, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.mel_spectrogram(n_mels=0)
+
+    def test_minimum_length_raises(self) -> None:
+        w = Waveform1D([1.0])
+        with self.assertRaises(ValueError):
+            w.mel_spectrogram()
+
+    def test_inverted_frequency_band_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(200, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.mel_spectrogram(min_frequency_hz=100.0, max_frequency_hz=10.0)
+
+
+class TestSpectralFeaturesOfSine(unittest.TestCase):
+    """§Compliance 1: spectral centroid of the 10 Hz sine ~= 10 Hz (rtol 5e-2)."""
+
+    def test_centroid_matches_sine_frequency(self) -> None:
+        n = 1000
+        fs = 1000.0
+        w = _wrap(Waveform1D.sine(n, frequency=10.0, amplitude=1.0, dt_seconds=1.0 / fs))
+
+        features = w.spectral_features()
+
+        self.assertAlmostEqual(features.centroid, 10.0, delta=10.0 * 5e-2)
+
+    def test_spread_is_nonnegative(self) -> None:
+        w = _wrap(Waveform1D.white_noise(1000, amplitude=1.0, seed=9, dt_seconds=0.01))
+        features = w.spectral_features()
+        self.assertGreaterEqual(features.spread, 0.0)
+
+    def test_rolloff_within_nyquist_range(self) -> None:
+        w = _wrap(Waveform1D.sine(1000, frequency=10.0, dt_seconds=0.001))
+        features = w.spectral_features()
+        self.assertGreaterEqual(features.rolloff, 0.0)
+        self.assertLessEqual(features.rolloff, w.nyquist_frequency_hz)
+
+    def test_flatness_in_unit_range(self) -> None:
+        w = _wrap(Waveform1D.white_noise(1000, amplitude=1.0, seed=13, dt_seconds=0.01))
+        features = w.spectral_features()
+        self.assertGreaterEqual(features.flatness, 0.0)
+        self.assertLessEqual(features.flatness, 1.0 + 1e-9)
+
+    def test_minimum_length_raises(self) -> None:
+        w = Waveform1D([1.0])
+        with self.assertRaises(ValueError):
+            w.spectral_features()
+
+    def test_invalid_rolloff_fraction_raises(self) -> None:
+        w = _wrap(Waveform1D.sine(200, frequency=5.0, dt_seconds=0.01))
+        with self.assertRaises(ValueError):
+            w.spectral_features(rolloff_fraction=0.0)
+        with self.assertRaises(ValueError):
+            w.spectral_features(rolloff_fraction=1.5)
+
+
+class TestPsdScalingParameter(unittest.TestCase):
+    """§Gap 8 (chunk 55): ``scaling: WaveformPSDScaling`` (``_spectral.py:232``) was
+    never passed by any test -- pin both members against a direct
+    ``scipy.signal.welch`` call and confirm they diverge materially."""
+
+    def test_density_matches_direct_scipy_call(self) -> None:
+        n = 4000
+        fs = 2000.0
+        w = _wrap(Waveform1D.sine(n, frequency=50.0, amplitude=1.0, dt_seconds=1.0 / fs))
+        window_array = spectral_module._window_array(WaveformWindowType.HANN, 512)
+
+        result = w.power_spectral_density(nperseg=512, scaling=WaveformPSDScaling.DENSITY)
+
+        _, expected = welch(
+            np.asarray(w.values), fs=fs, window=window_array, nperseg=512, scaling="density"
+        )
+        np.testing.assert_allclose(result.magnitudes, expected)
+
+    def test_spectrum_matches_direct_scipy_call(self) -> None:
+        n = 4000
+        fs = 2000.0
+        w = _wrap(Waveform1D.sine(n, frequency=50.0, amplitude=1.0, dt_seconds=1.0 / fs))
+        window_array = spectral_module._window_array(WaveformWindowType.HANN, 512)
+
+        result = w.power_spectral_density(nperseg=512, scaling=WaveformPSDScaling.SPECTRUM)
+
+        _, expected = welch(
+            np.asarray(w.values), fs=fs, window=window_array, nperseg=512, scaling="spectrum"
+        )
+        np.testing.assert_allclose(result.magnitudes, expected)
+
+    def test_density_and_spectrum_diverge_materially(self) -> None:
+        n = 4000
+        fs = 2000.0
+        w = _wrap(Waveform1D.sine(n, frequency=50.0, amplitude=1.0, dt_seconds=1.0 / fs))
+
+        density = w.power_spectral_density(nperseg=512, scaling=WaveformPSDScaling.DENSITY)
+        spectrum = w.power_spectral_density(nperseg=512, scaling=WaveformPSDScaling.SPECTRUM)
+
+        peak_ratio = float(np.max(spectrum.magnitudes) / np.max(density.magnitudes))
+        # Observed ratio for this nperseg/fs combination is ~5.9x -- assert it is
+        # far from 1.0 so a `scaling` parameter that silently no-ops would fail.
+        self.assertGreater(peak_ratio, 2.0)
+
+
+class TestSpectralWindowVariedToKaiser(unittest.TestCase):
+    """§Gap 9 (chunk 55): ``window: WaveformWindowType`` (``_spectral.py:231,268,292``)
+    was never varied from ``HANN`` in any test -- the KAISER branch of
+    ``_window_array``/``_scipy_window_spec`` (``get_window`` with an explicit beta
+    tuple) was unreached."""
+
+    def test_power_spectral_density_kaiser_matches_direct_scipy(self) -> None:
+        n = 2000
+        fs = 1000.0
+        w = _wrap(Waveform1D.white_noise(n, amplitude=1.0, seed=5, dt_seconds=1.0 / fs))
+        kaiser_array = get_window(("kaiser", DEFAULT_KAISER_BETA), 256)
+
+        result = w.power_spectral_density(window=WaveformWindowType.KAISER, nperseg=256)
+
+        _, expected = welch(np.asarray(w.values), fs=fs, window=kaiser_array, nperseg=256)
+        np.testing.assert_allclose(result.magnitudes, expected)
+
+    def test_spectrogram_kaiser_matches_direct_scipy(self) -> None:
+        n = 2000
+        fs = 1000.0
+        w = _wrap(Waveform1D.sine(n, frequency=50.0, dt_seconds=1.0 / fs))
+        kaiser_array = get_window(("kaiser", DEFAULT_KAISER_BETA), 256)
+
+        result = w.spectrogram(window=WaveformWindowType.KAISER, nperseg=256, overlap=0.5)
+
+        expected_f, expected_t, expected_sxx = scipy_spectrogram(
+            np.asarray(w.values),
+            fs=fs,
+            window=kaiser_array,
+            nperseg=256,
+            noverlap=128,
+            mode="magnitude",
+        )
+        np.testing.assert_allclose(result.frequencies, expected_f)
+        np.testing.assert_allclose(result.times, expected_t)
+        np.testing.assert_allclose(result.magnitudes, expected_sxx.T)
+
+
+class TestMelSpectrogramConcentratesEnergyInTonalBand(unittest.TestCase):
+    """§Gap 10 (chunk 55): mel magnitudes for a pure tone should concentrate in the
+    mel band nearest the tone's frequency, not merely be non-negative of the right
+    shape (the existing coverage before this chunk)."""
+
+    def test_1khz_tone_dominates_its_nearest_mel_band(self) -> None:
+        n = 8000
+        fs = 8000.0
+        w = _wrap(Waveform1D.sine(n, frequency=1000.0, amplitude=1.0, dt_seconds=1.0 / fs))
+
+        mel_spec = w.mel_spectrogram(n_mels=40, nperseg=512, overlap=0.5)
+
+        mean_per_mel_band = np.mean(mel_spec.magnitudes, axis=0)
+        peak_band_index = int(np.argmax(mean_per_mel_band))
+        peak_band_frequency = float(mel_spec.mel_frequencies[peak_band_index])
+
+        self.assertAlmostEqual(peak_band_frequency, 1000.0, delta=100.0)
+        energy_fraction_at_peak = float(
+            mean_per_mel_band[peak_band_index] / np.sum(mean_per_mel_band)
+        )
+        self.assertGreater(energy_fraction_at_peak, 0.5)
+
+
+class TestSpectralFeaturesKnownAnswerTwoTone(unittest.TestCase):
+    """§Gap 11 (chunk 55): a two-tone signal with exact-bin-resolved frequencies
+    (no spectral leakage) gives hand-derivable centroid/spread/rolloff/flatness --
+    closing the range-check-only coverage that a swapped mean or a power-vs-
+    magnitude weighting would previously have passed.
+
+    ``n=1000``, ``fs=1000`` gives 1 Hz bin resolution; ``f1=10 Hz`` (bin 10,
+    amplitude 1.0 -> magnitude ~500) and ``f2=100 Hz`` (bin 100, amplitude 3.0
+    -> magnitude ~1500) are each an exact integer number of periods, so (up to
+    floating-point noise ~1e-10 relative) all spectral energy is concentrated
+    in exactly those two bins.
+    """
+
+    def setUp(self) -> None:
+        n = 1000
+        fs = 1000.0
+        dt_seconds = 1.0 / fs
+        tone_low = Waveform1D.sine(n, frequency=10.0, amplitude=1.0, dt_seconds=dt_seconds)
+        tone_high = Waveform1D.sine(n, frequency=100.0, amplitude=3.0, dt_seconds=dt_seconds)
+        self.w = Waveform1D(tone_low.values + tone_high.values, dt_seconds=dt_seconds)
+        # Magnitude-weighted-mean-frequency closed form for two dominant bins
+        # (m1 ~= 500 at 10 Hz, m2 ~= 1500 at 100 Hz):
+        self.expected_centroid = (10.0 * 500.0 + 100.0 * 1500.0) / 2000.0
+        self.expected_spread = float(
+            np.sqrt(
+                (500.0 * (10.0 - self.expected_centroid) ** 2
+                 + 1500.0 * (100.0 - self.expected_centroid) ** 2)
+                / 2000.0
+            )
+        )
+
+    def test_centroid_matches_hand_derived_weighted_mean(self) -> None:
+        features = self.w.spectral_features()
+        self.assertAlmostEqual(features.centroid, self.expected_centroid, places=6)
+
+    def test_spread_matches_hand_derived_weighted_std(self) -> None:
+        features = self.w.spectral_features()
+        self.assertAlmostEqual(features.spread, self.expected_spread, places=6)
+
+    def test_rolloff_lands_at_the_second_tone_bin(self) -> None:
+        # Cumulative magnitude reaches 25% of total at bin 10 (500/2000), then
+        # stays flat until it jumps to 100% at bin 100 (2000/2000) -- so the
+        # default 95%-rolloff must land exactly on the 100 Hz bin.
+        features = self.w.spectral_features()
+        self.assertAlmostEqual(features.rolloff, 100.0, places=6)
+
+    def test_flatness_matches_independent_geomean_over_arithmean(self) -> None:
+        """Flatness has no scipy reference; derive it independently from the raw
+        FFT magnitude array (following the method's own documented definition)
+        rather than by calling any private helper of the implementation."""
+        values = np.asarray(self.w.values, dtype=np.float64)
+        magnitudes = np.abs(np.fft.rfft(values))
+        nonzero = magnitudes[magnitudes > 0.0]
+        expected_flatness = float(np.exp(np.mean(np.log(nonzero))) / np.mean(magnitudes))
+
+        features = self.w.spectral_features()
+
+        self.assertAlmostEqual(features.flatness, expected_flatness, places=9)
+        # Sanity: this two-tone signal is strongly tonal, so flatness should be
+        # near zero -- catches a geomean/arithmean swap (which would report ~1
+        # or a value >> the ~1e-13 observed here).
+        self.assertLess(features.flatness, 1e-6)
+
+
+class TestDescriptorsRoundTripFromMethods(unittest.TestCase):
+    """Acceptance: all four descriptor types round out of the methods without
+    eq/hash errors (waveformDsp.md §Compliance 3)."""
+
+    def test_fft_result_eq_does_not_raise(self) -> None:
+        w = _wrap(Waveform1D.sine(200, frequency=5.0, dt_seconds=0.01))
+        a, b = w.fft(), w.fft()
+        self.assertFalse(a == b)  # eq=False -> identity comparison, never raises
+        self.assertEqual(a, a)
+
+    def test_spectrogram_result_eq_does_not_raise(self) -> None:
+        w = _wrap(Waveform1D.sine(500, frequency=5.0, dt_seconds=0.01))
+        a, b = w.spectrogram(nperseg=64), w.spectrogram(nperseg=64)
+        self.assertFalse(a == b)
+        self.assertEqual(a, a)
+
+    def test_mel_spectrogram_result_eq_does_not_raise(self) -> None:
+        w = _wrap(Waveform1D.sine(500, frequency=5.0, dt_seconds=0.01))
+        a, b = w.mel_spectrogram(n_mels=4, nperseg=64), w.mel_spectrogram(n_mels=4, nperseg=64)
+        self.assertFalse(a == b)
+        self.assertEqual(a, a)
+
+    def test_spectral_features_result_eq_does_not_raise(self) -> None:
+        w = _wrap(Waveform1D.sine(200, frequency=5.0, dt_seconds=0.01))
+        a, b = w.spectral_features(), w.spectral_features()
+        # Scalar-only dataclass: default eq compares field values.
+        self.assertEqual(a, b)
+
+
+class TestSharedKaiserBetaConstant(unittest.TestCase):
+    """Chunk 53 acceptance: ``_spectral.py`` sources its Kaiser beta from the
+    shared ``dsp/_common.py`` constant -- not an independent literal -- and
+    its own internal window array is unaffected by the reconciliation
+    (design constraint 4: no default-behavior change)."""
+
+    def test_spectral_module_constant_matches_common(self) -> None:
+        self.assertEqual(spectral_module.DEFAULT_KAISER_BETA, DEFAULT_KAISER_BETA)
+
+    def test_internal_kaiser_window_matches_windowing_periodic_convention(self) -> None:
+        n = 64
+        spectral_kaiser = spectral_module._window_array(WaveformWindowType.KAISER, n)
+        windowing_kaiser = WindowingMixin.generate_window(
+            WaveformWindowType.KAISER, n, periodic=True
+        )
+        np.testing.assert_allclose(spectral_kaiser, windowing_kaiser)
+
+    def test_power_spectral_density_default_unchanged(self) -> None:
+        """Regression pin: default PSD output is bit-identical pre/post chunk 53
+        (additive parameters only, per design constraint 4)."""
+        n = 2000
+        w = _wrap(Waveform1D.white_noise(n, amplitude=1.0, seed=17, dt_seconds=0.01))
+        spectrum = w.power_spectral_density(nperseg=256)
+        window_array = spectral_module._window_array(WaveformWindowType.HANN, 256)
+        # HANN default is periodic (scipy's own default) -- confirms this
+        # module's internal convention is untouched by the new `periodic`
+        # parameter, which lives only on WindowingMixin.
+        self.assertAlmostEqual(
+            float(np.mean(window_array)),
+            float(
+                np.mean(
+                    WindowingMixin.generate_window(WaveformWindowType.HANN, 256, periodic=True)
+                )
+            ),
+            places=12,
+        )
+        self.assertEqual(len(spectrum.magnitudes), len(spectrum.frequencies))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/dsp/test_time_alignment.py b/tests/waveforms/dsp/test_time_alignment.py
new file mode 100644
index 0000000..a3e70b7
--- /dev/null
+++ b/tests/waveforms/dsp/test_time_alignment.py
@@ -0,0 +1,279 @@
+"""Unit tests for ``dsp/_time_alignment.py`` (``TimeAlignmentMixin``).
+
+Covers waveformDsp.md §Family contracts (``TimeAlignmentMixin``), §Numerical
+conventions, §Compliance 1-2. Exercises the mixin directly on ``Waveform1D``,
+which composes both ``TimeAlignmentMixin`` and ``CorrelationMixin`` (the
+``aligned``/``time_lag`` ``CORRELATION`` path calls
+``CorrelationMixin.find_max_correlation`` through a structural ``Protocol``)
+from the compose chunk (30) onward.
+"""
+
+import unittest
+
+import numpy as np
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformAlignmentMethod
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+def _wrap(base: WaveformProtocol) -> Waveform1D:
+    """Rewrap a ``WaveformProtocol``-satisfying result as ``Waveform1D`` (see ``test_calc.py``)."""
+    return Waveform1D(base.values, dt=base.dt, t0=base.t0)
+
+
+class TestAlignedCorrelationRecoversKnownShift(unittest.TestCase):
+    """Acceptance criterion: ``aligned`` recovers a k-sample shift (result lag 0
+    afterward). ``other`` is built as ``np.roll(base.values, k)`` at the *same*
+    ``t0`` as ``self`` (matching ``test_correlation.py``'s known-shift convention),
+    so ``self.aligned(to=other)`` must shift ``t0`` forward by exactly ``k * dt``
+    for a subsequent ``time_lag`` against ``other`` to land back at 0.
+    """
+
+    def _check_known_shift(self, k: int) -> None:
+        n = 2000
+        base = Waveform1D.white_noise(n, amplitude=1.0, seed=42, dt_seconds=0.001)
+        w1 = _wrap(base)
+        shifted_values = np.roll(base.values, k)
+        w2 = Waveform1D(shifted_values, dt=base.dt, t0=base.t0)
+
+        aligned = w1.aligned(w2)
+
+        self.assertEqual(aligned.t0, w1.t0 + w1.dt * k)
+        np.testing.assert_allclose(aligned.values, w1.values)
+        self.assertEqual(aligned.dt, w1.dt)
+
+        lag_after = _wrap(aligned).time_lag(w2)
+        self.assertIsNotNone(lag_after)
+        assert lag_after is not None  # mypy narrowing for the assertions below
+        self.assertEqual(lag_after.lag_samples, 0)
+        self.assertEqual(lag_after.lag_seconds, 0.0)
+        self.assertGreater(lag_after.correlation, 0.95)
+
+    def test_zero_shift(self) -> None:
+        self._check_known_shift(0)
+
+    def test_three_sample_shift(self) -> None:
+        self._check_known_shift(3)
+
+    def test_seventeen_sample_shift(self) -> None:
+        self._check_known_shift(17)
+
+
+class TestAlignedStartTime(unittest.TestCase):
+    def test_adopts_reference_t0_unchanged_values_and_dt(self) -> None:
+        w1 = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1, t0_seconds=0.0)
+        w2 = Waveform1D([5.0, 6.0, 7.0, 8.0], dt_seconds=0.1, t0_seconds=2.5)
+
+        aligned = w1.aligned(w2, method=WaveformAlignmentMethod.START_TIME)
+
+        self.assertEqual(aligned.t0, w2.t0)
+        self.assertEqual(aligned.dt, w1.dt)
+        np.testing.assert_allclose(aligned.values, w1.values)
+
+    def test_no_qualifying_correlation_peak_returns_self_unshifted(self) -> None:
+        w1 = Waveform1D([0.0] * 10, dt_seconds=0.1)
+        w2 = Waveform1D(list(range(10)), dt_seconds=0.1)
+
+        aligned = w1.aligned(w2)  # default CORRELATION method
+
+        self.assertEqual(aligned.t0, w1.t0)
+        np.testing.assert_allclose(aligned.values, w1.values)
+
+
+class TestTimeLagNoneWhenNoCorrelatablePeak(unittest.TestCase):
+    """``time_lag`` returns ``None`` when the strongest match carries zero
+    correlation magnitude (an all-zero waveform correlates to exactly 0 against
+    anything, per ``CorrelationMixin``'s zero-variance handling)."""
+
+    def test_all_zero_waveform_yields_none(self) -> None:
+        w1 = Waveform1D([0.0] * 10, dt_seconds=0.1)
+        w2 = Waveform1D(list(range(10)), dt_seconds=0.1)
+        self.assertIsNone(w1.time_lag(w2))
+
+
+class TestTimeLagAccountsForExistingT0Offset(unittest.TestCase):
+    """``time_lag`` is ``t0``-aware: identical values at different ``t0``s still
+    report a nonzero real-world lag (unlike ``CorrelationMixin.find_max_correlation``,
+    which is purely value-domain and would report 0 here)."""
+
+    def test_identical_values_different_t0_reports_the_t0_offset(self) -> None:
+        values = [1.0, 3.0, 2.0, 4.0, 1.0, 5.0, 2.0]
+        w1 = Waveform1D(values, dt_seconds=0.1, t0_seconds=0.5)
+        w2 = Waveform1D(values, dt_seconds=0.1, t0_seconds=0.2)
+
+        lag = w1.time_lag(w2)
+
+        self.assertIsNotNone(lag)
+        assert lag is not None
+        self.assertEqual(lag.lag_samples, 3)
+        self.assertAlmostEqual(lag.lag_seconds, 0.3, places=9)
+
+
+class TestTimeLagMaxLagRestrictsSearch(unittest.TestCase):
+    """§Gap 20 (chunk 55): ``max_lag`` (``_time_alignment.py:171``) was never passed
+    to ``time_lag`` by any test."""
+
+    def test_max_lag_bounds_the_result(self) -> None:
+        n = 2000
+        base = Waveform1D.white_noise(n, amplitude=1.0, seed=7, dt_seconds=0.001)
+        w1 = _wrap(base)
+        shifted_values = np.roll(base.values, 17)
+        w2 = Waveform1D(shifted_values, dt=base.dt, t0=base.t0)
+
+        unrestricted = w1.time_lag(w2)
+        restricted = w1.time_lag(w2, max_lag=5)
+
+        self.assertIsNotNone(unrestricted)
+        self.assertIsNotNone(restricted)
+        assert unrestricted is not None
+        assert restricted is not None
+        self.assertEqual(unrestricted.lag_samples, -17)
+        self.assertLessEqual(abs(restricted.lag_samples), 5)
+        self.assertNotEqual(restricted.lag_samples, unrestricted.lag_samples)
+
+
+class TestTimeLagPropagatesCorrelationMixinValidation(unittest.TestCase):
+    def test_dt_mismatch_raises(self) -> None:
+        w1 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.2)
+        with self.assertRaises(WaveformCompatibilityError):
+            w1.time_lag(w2)
+
+    def test_empty_waveform_raises(self) -> None:
+        w1 = Waveform1D([], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w1.time_lag(w2)
+
+
+class TestSynchronizeCommonOverlap(unittest.TestCase):
+    """Acceptance criterion: ``synchronize`` of two offset waveforms returns
+    equal-length overlaps with matching ``t0``."""
+
+    def test_two_offset_waveforms_return_matching_overlap(self) -> None:
+        w1 = Waveform1D(np.arange(50, dtype=np.float64), dt_seconds=0.1, t0_seconds=0.0)
+        w2 = Waveform1D(np.arange(100.0, 150.0), dt_seconds=0.1, t0_seconds=1.0)
+
+        synced = Waveform1D.synchronize([w1, w2])
+
+        self.assertEqual(len(synced), 2)
+        self.assertEqual(len(synced[0].values), 40)
+        self.assertEqual(len(synced[1].values), 40)
+        self.assertEqual(synced[0].t0, synced[1].t0)
+        self.assertEqual(synced[0].t0, w2.t0)
+        np.testing.assert_allclose(synced[0].values, np.arange(10, 50, dtype=np.float64))
+        np.testing.assert_allclose(synced[1].values, np.arange(100.0, 140.0))
+
+    def test_empty_sequence_returns_empty_list(self) -> None:
+        self.assertEqual(Waveform1D.synchronize([]), [])
+
+    def test_dt_mismatch_raises(self) -> None:
+        w1 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.2)
+        with self.assertRaises(WaveformCompatibilityError):
+            Waveform1D.synchronize([w1, w2])
+
+    def test_empty_waveform_raises(self) -> None:
+        w1 = Waveform1D([], dt_seconds=0.1)
+        w2 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            Waveform1D.synchronize([w1, w2])
+
+    def test_no_overlap_raises(self) -> None:
+        w1 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1, t0_seconds=0.0)
+        w2 = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1, t0_seconds=10.0)
+        with self.assertRaises(ValueError):
+            Waveform1D.synchronize([w1, w2])
+
+
+class TestTimeWindowsCountFormula(unittest.TestCase):
+    """Acceptance criterion: ``time_windows(1.0, overlap=0.5)`` count formula pinned."""
+
+    def test_pinned_window_count(self) -> None:
+        w = Waveform1D(np.arange(100, dtype=np.float64), dt_seconds=0.1)
+
+        windows = w.time_windows(1.0, overlap=0.5)
+
+        self.assertEqual(len(windows), 19)
+        for window in windows:
+            self.assertEqual(len(window.values), 10)
+            self.assertEqual(window.dt, w.dt)
+
+    def test_window_start_times_step_by_overlap(self) -> None:
+        w = Waveform1D(np.arange(100, dtype=np.float64), dt_seconds=0.1)
+        windows = w.time_windows(1.0, overlap=0.5)
+
+        self.assertEqual(windows[0].t0, w.t0)
+        self.assertEqual(windows[1].t0, w.t0 + w.dt * 5)
+        np.testing.assert_allclose(windows[0].values, np.arange(0, 10, dtype=np.float64))
+        np.testing.assert_allclose(windows[1].values, np.arange(5, 15, dtype=np.float64))
+
+    def test_no_overlap_default(self) -> None:
+        w = Waveform1D(np.arange(30, dtype=np.float64), dt_seconds=0.1)
+        windows = w.time_windows(1.0)
+        self.assertEqual(len(windows), 3)
+
+    def test_non_positive_duration_raises(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.time_windows(0.0)
+
+    def test_overlap_out_of_range_raises(self) -> None:
+        w = Waveform1D(np.arange(10, dtype=np.float64), dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.time_windows(0.5, overlap=1.0)
+
+    def test_too_short_for_one_window_raises(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.time_windows(1.0)
+
+
+class TestTimeSegmentsBoundariesRespected(unittest.TestCase):
+    """Acceptance criterion: segment boundaries respected."""
+
+    def test_boundaries_split_into_three_segments(self) -> None:
+        w = Waveform1D(np.arange(10, dtype=np.float64), dt_seconds=1.0, t0_seconds=0.0)
+
+        segments = w.time_segments([3.0, 6.0])
+
+        self.assertEqual(len(segments), 3)
+        np.testing.assert_allclose(segments[0].values, [0.0, 1.0, 2.0])
+        np.testing.assert_allclose(segments[1].values, [3.0, 4.0, 5.0])
+        np.testing.assert_allclose(segments[2].values, [6.0, 7.0, 8.0, 9.0])
+        self.assertEqual(segments[0].t0, w.t0)
+        self.assertEqual(segments[1].t0, w.t0 + w.dt * 3)
+        self.assertEqual(segments[2].t0, w.t0 + w.dt * 6)
+
+    def test_empty_boundaries_returns_whole_waveform_unsplit(self) -> None:
+        w = Waveform1D(np.arange(10, dtype=np.float64), dt_seconds=1.0)
+        segments = w.time_segments([])
+        self.assertEqual(len(segments), 1)
+        np.testing.assert_allclose(segments[0].values, w.values)
+        self.assertEqual(segments[0].t0, w.t0)
+
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([], dt_seconds=1.0)
+        with self.assertRaises(ValueError):
+            w.time_segments([1.0])
+
+    def test_boundary_out_of_range_raises(self) -> None:
+        w = Waveform1D(np.arange(10, dtype=np.float64), dt_seconds=1.0)
+        with self.assertRaises(ValueError):
+            w.time_segments([9.0])
+
+    def test_non_increasing_boundaries_raise(self) -> None:
+        w = Waveform1D(np.arange(10, dtype=np.float64), dt_seconds=1.0)
+        with self.assertRaises(ValueError):
+            w.time_segments([5.0, 3.0])
+
+    def test_boundaries_rounding_to_same_index_raise(self) -> None:
+        w = Waveform1D(np.arange(10, dtype=np.float64), dt_seconds=1.0)
+        with self.assertRaises(ValueError):
+            w.time_segments([3.0, 3.01])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/dsp/test_triggers.py b/tests/waveforms/dsp/test_triggers.py
new file mode 100644
index 0000000..a6944de
--- /dev/null
+++ b/tests/waveforms/dsp/test_triggers.py
@@ -0,0 +1,373 @@
+"""Unit tests for ``dsp/_triggers.py`` (``TriggerMixin``).
+
+Covers waveformDsp.md §Family contracts (``TriggerMixin``), §Numerical
+conventions, §Compliance 1-2. Exercises the mixin directly on ``Waveform1D``, which
+composes every DSP mixin from the compose chunk (30) onward.
+"""
+
+import unittest
+
+import numpy as np
+
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.waveforms.support import (
+    WaveformEdgeType,
+    WaveformTrigger,
+    WaveformTriggerType,
+    WaveformWindowTriggerType,
+)
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+def _square_pulses(cycles: int, samples_per_phase: int, low: float, high: float) -> np.ndarray:
+    """A LOW/HIGH pulse train bracketed by LOW on both ends: LOW, HIGH, LOW, HIGH, ..., LOW.
+
+    Every HIGH pulse is a fully interior block (a real sample precedes and follows
+    it), so this yields exactly ``cycles`` low->high (rising) transitions and
+    exactly ``cycles`` high->low (falling) transitions -- no boundary ambiguity.
+    """
+    low_block = np.full(samples_per_phase, low, dtype=np.float64)
+    high_block = np.full(samples_per_phase, high, dtype=np.float64)
+    blocks = [low_block]
+    for _ in range(cycles):
+        blocks.append(high_block)
+        blocks.append(low_block)
+    return np.concatenate(blocks)
+
+
+class TestDetectEdgeTriggersOnSquareWave(unittest.TestCase):
+    """Acceptance criterion: square-wave edge counts exact."""
+
+    def setUp(self) -> None:
+        self.cycles = 5
+        values = _square_pulses(self.cycles, samples_per_phase=20, low=-1.0, high=1.0)
+        self.w = Waveform1D(values, dt_seconds=0.01)
+
+    def test_rising_edge_count_equals_cycle_count(self) -> None:
+        events = self.w.detect_edge_triggers(level=0.0, edge=WaveformEdgeType.RISING)
+        self.assertEqual(len(events), self.cycles)
+        for event in events:
+            self.assertEqual(event.kind, WaveformTriggerType.EDGE)
+            self.assertAlmostEqual(event.time_seconds, event.index * 0.01, places=9)
+
+    def test_falling_edge_count_equals_cycle_count(self) -> None:
+        events = self.w.detect_edge_triggers(level=0.0, edge=WaveformEdgeType.FALLING)
+        self.assertEqual(len(events), self.cycles)
+
+    def test_both_is_sum_of_rising_and_falling(self) -> None:
+        rising = self.w.detect_edge_triggers(level=0.0, edge=WaveformEdgeType.RISING)
+        falling = self.w.detect_edge_triggers(level=0.0, edge=WaveformEdgeType.FALLING)
+        both = self.w.detect_edge_triggers(level=0.0, edge=WaveformEdgeType.BOTH)
+        self.assertEqual(len(both), len(rising) + len(falling))
+        self.assertEqual(
+            sorted(e.index for e in both),
+            sorted([e.index for e in rising] + [e.index for e in falling]),
+        )
+
+    def test_rising_and_falling_alternate(self) -> None:
+        rising = self.w.detect_edge_triggers(level=0.0, edge=WaveformEdgeType.RISING)
+        falling = self.w.detect_edge_triggers(level=0.0, edge=WaveformEdgeType.FALLING)
+        rising_indices = [e.index for e in rising]
+        falling_indices = [e.index for e in falling]
+        # Bracketed by LOW on both ends: every rising is followed by a later falling
+        # before the next rising.
+        for rise, fall in zip(rising_indices, falling_indices, strict=True):
+            self.assertLess(rise, fall)
+
+
+class TestDetectEdgeTriggersNoHit(unittest.TestCase):
+    def test_level_outside_range_returns_empty(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 2.0, 1.0], dt_seconds=0.1)
+        self.assertEqual(w.detect_edge_triggers(level=100.0), [])
+
+    def test_too_short_returns_empty(self) -> None:
+        w = Waveform1D([1.0], dt_seconds=0.1)
+        self.assertEqual(w.detect_edge_triggers(level=0.0), [])
+
+    def test_empty_waveform_returns_empty(self) -> None:
+        w = Waveform1D([], dt_seconds=0.1)
+        self.assertEqual(w.detect_edge_triggers(level=0.0), [])
+
+
+class TestDetectEdgeTriggersMinimumInterval(unittest.TestCase):
+    """Two rising edges closer together than ``minimum_interval`` collapse to one event."""
+
+    def test_second_close_rising_edge_is_dropped(self) -> None:
+        # Rising at index 1, falling at 2, rising again at 3 (too close), falling at 4.
+        values = [-1.0, 1.0, -1.0, 1.0, -1.0]
+        w = Waveform1D(values, dt_seconds=1.0)
+        events = w.detect_edge_triggers(
+            level=0.0,
+            edge=WaveformEdgeType.RISING,
+            minimum_interval=PrecisionTimeInterval.from_seconds(5.0),
+        )
+        self.assertEqual([e.index for e in events], [1])
+
+    def test_far_apart_rising_edges_both_kept(self) -> None:
+        values = [-1.0, 1.0, -1.0, 1.0, -1.0]
+        w = Waveform1D(values, dt_seconds=1.0)
+        events = w.detect_edge_triggers(
+            level=0.0,
+            edge=WaveformEdgeType.RISING,
+            minimum_interval=PrecisionTimeInterval.from_seconds(0.5),
+        )
+        self.assertEqual([e.index for e in events], [1, 3])
+
+
+class TestDetectLevelTriggersMinimumInterval(unittest.TestCase):
+    """§Gap 21 (chunk 55): ``minimum_interval`` dedup was verified through only
+    ``detect_edge_triggers`` -- this closes the ``detect_level_triggers`` entry
+    point (2 of 5)."""
+
+    def test_second_close_rising_level_is_dropped(self) -> None:
+        values = [-1.0, 1.0, -1.0, 1.0, -1.0]
+        w = Waveform1D(values, dt_seconds=1.0)
+        events = w.detect_level_triggers(
+            level=0.0, minimum_interval=PrecisionTimeInterval.from_seconds(5.0)
+        )
+        self.assertEqual([e.index for e in events], [1])
+
+    def test_far_apart_rising_levels_both_kept(self) -> None:
+        values = [-1.0, 1.0, -1.0, 1.0, -1.0]
+        w = Waveform1D(values, dt_seconds=1.0)
+        events = w.detect_level_triggers(
+            level=0.0, minimum_interval=PrecisionTimeInterval.from_seconds(0.5)
+        )
+        self.assertEqual([e.index for e in events], [1, 3])
+
+
+class TestDetectLevelTriggers(unittest.TestCase):
+    def test_default_rising_matches_edge_rising(self) -> None:
+        values = _square_pulses(3, samples_per_phase=10, low=-1.0, high=1.0)
+        w = Waveform1D(values, dt_seconds=0.1)
+        level_events = w.detect_level_triggers(level=0.0)
+        edge_events = w.detect_edge_triggers(level=0.0, edge=WaveformEdgeType.RISING)
+        self.assertEqual([e.index for e in level_events], [e.index for e in edge_events])
+        for event in level_events:
+            self.assertEqual(event.kind, WaveformTriggerType.LEVEL)
+
+    def test_falling_direction(self) -> None:
+        values = _square_pulses(3, samples_per_phase=10, low=-1.0, high=1.0)
+        w = Waveform1D(values, dt_seconds=0.1)
+        level_events = w.detect_level_triggers(level=0.0, edge=WaveformEdgeType.FALLING)
+        edge_events = w.detect_edge_triggers(level=0.0, edge=WaveformEdgeType.FALLING)
+        self.assertEqual([e.index for e in level_events], [e.index for e in edge_events])
+
+    def test_no_hit_returns_empty(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        self.assertEqual(w.detect_level_triggers(level=100.0), [])
+
+
+class TestDetectWindowTriggersPairUp(unittest.TestCase):
+    """Acceptance criterion: window ENTER/EXIT pair up on a sine crossing a band."""
+
+    def setUp(self) -> None:
+        self.cycles = 3
+        samples_per_cycle = 300
+        n = self.cycles * samples_per_cycle
+        # sin(0) == 0 at both the first and last sample, safely below `low` -- no
+        # boundary ambiguity at either end of the array.
+        self.w = Waveform1D(
+            Waveform1D.sine(n, frequency=1.0, dt_seconds=1.0 / samples_per_cycle).values,
+            dt_seconds=1.0 / samples_per_cycle,
+        )
+        self.low = 0.3
+        self.high = 0.8
+
+    def test_enter_and_exit_counts_match_and_are_nonzero(self) -> None:
+        enters = self.w.detect_window_triggers(self.low, self.high, WaveformWindowTriggerType.ENTER)
+        exits = self.w.detect_window_triggers(self.low, self.high, WaveformWindowTriggerType.EXIT)
+        self.assertGreater(len(enters), 0)
+        self.assertEqual(len(enters), len(exits))
+        for event in enters:
+            self.assertEqual(event.kind, WaveformTriggerType.WINDOW)
+
+    def test_each_enter_is_followed_by_its_exit_before_the_next_enter(self) -> None:
+        enters = self.w.detect_window_triggers(self.low, self.high, WaveformWindowTriggerType.ENTER)
+        exits = self.w.detect_window_triggers(self.low, self.high, WaveformWindowTriggerType.EXIT)
+        enter_indices = [e.index for e in enters]
+        exit_indices = [e.index for e in exits]
+        for i, enter_index in enumerate(enter_indices):
+            self.assertLess(enter_index, exit_indices[i])
+            if i + 1 < len(enter_indices):
+                self.assertLess(exit_indices[i], enter_indices[i + 1])
+
+    def test_low_greater_than_high_returns_empty(self) -> None:
+        self.assertEqual(
+            self.w.detect_window_triggers(0.8, 0.3, WaveformWindowTriggerType.ENTER), []
+        )
+
+    def test_band_never_reached_returns_empty(self) -> None:
+        self.assertEqual(
+            self.w.detect_window_triggers(10.0, 20.0, WaveformWindowTriggerType.ENTER), []
+        )
+
+
+class TestDetectWindowTriggersMinimumInterval(unittest.TestCase):
+    """§Gap 21 (chunk 55): ``minimum_interval`` dedup entry point 3 of 5
+    (``detect_window_triggers``)."""
+
+    def test_second_close_enter_is_dropped(self) -> None:
+        values = [0.0, 0.5, 0.0, 0.5, 0.0]
+        w = Waveform1D(values, dt_seconds=1.0)
+        no_dedup = w.detect_window_triggers(0.3, 0.8, WaveformWindowTriggerType.ENTER)
+        self.assertEqual([e.index for e in no_dedup], [1, 3])
+
+        deduped = w.detect_window_triggers(
+            0.3, 0.8, WaveformWindowTriggerType.ENTER,
+            minimum_interval=PrecisionTimeInterval.from_seconds(5.0),
+        )
+        self.assertEqual([e.index for e in deduped], [1])
+
+
+class TestDetectPatternTriggersFindsPlantedIndices(unittest.TestCase):
+    """Acceptance criterion: pattern trigger finds an embedded motif at the planted indices."""
+
+    def setUp(self) -> None:
+        self.motif = [1.0, 2.0, 3.0, 2.0, 1.0]
+        self.planted_indices = [5, 30, 60]
+        values = np.zeros(90, dtype=np.float64)
+        for index in self.planted_indices:
+            values[index : index + len(self.motif)] = self.motif
+        self.w = Waveform1D(values, dt_seconds=0.1)
+
+    def test_exact_match_finds_planted_indices(self) -> None:
+        events = self.w.detect_pattern_triggers(self.motif, tolerance=1e-9)
+        self.assertEqual([e.index for e in events], self.planted_indices)
+        for event, index in zip(events, self.planted_indices, strict=True):
+            self.assertEqual(event.kind, WaveformTriggerType.PATTERN)
+            self.assertAlmostEqual(event.time_seconds, index * 0.1, places=9)
+
+    def test_within_tolerance_still_matches(self) -> None:
+        noisy_pattern = [v + 0.01 for v in self.motif]
+        events = self.w.detect_pattern_triggers(noisy_pattern, tolerance=0.05)
+        self.assertEqual([e.index for e in events], self.planted_indices)
+
+    def test_outside_tolerance_no_hit(self) -> None:
+        far_off_pattern = [v + 5.0 for v in self.motif]
+        events = self.w.detect_pattern_triggers(far_off_pattern, tolerance=1e-9)
+        self.assertEqual(events, [])
+
+    def test_pattern_longer_than_waveform_returns_empty(self) -> None:
+        events = self.w.detect_pattern_triggers([0.0] * 200, tolerance=1.0)
+        self.assertEqual(events, [])
+
+    def test_empty_pattern_returns_empty(self) -> None:
+        self.assertEqual(self.w.detect_pattern_triggers([], tolerance=1.0), [])
+
+
+class TestDetectPatternTriggersMinimumInterval(unittest.TestCase):
+    """§Gap 21 (chunk 55): ``minimum_interval`` dedup entry point 4 of 5
+    (``detect_pattern_triggers``)."""
+
+    def test_close_matches_are_deduped(self) -> None:
+        motif = [1.0, 0.0]
+        values = np.zeros(10)
+        values[1] = 1.0
+        values[3] = 1.0
+        values[7] = 1.0
+        w = Waveform1D(values, dt_seconds=1.0)
+
+        no_dedup = w.detect_pattern_triggers(motif, tolerance=1e-9)
+        self.assertEqual([e.index for e in no_dedup], [1, 3, 7])
+
+        deduped = w.detect_pattern_triggers(
+            motif, tolerance=1e-9, minimum_interval=PrecisionTimeInterval.from_seconds(3.0)
+        )
+        self.assertEqual([e.index for e in deduped], [1, 7])
+
+
+class TestDetectTriggersGenericDispatch(unittest.TestCase):
+    def setUp(self) -> None:
+        self.square = Waveform1D(
+            _square_pulses(4, samples_per_phase=10, low=-1.0, high=1.0), dt_seconds=0.1
+        )
+
+    def test_edge_kind_dispatches_with_default_both(self) -> None:
+        via_trigger = self.square.detect_triggers(
+            WaveformTrigger(kind=WaveformTriggerType.EDGE, level=0.0)
+        )
+        direct = self.square.detect_edge_triggers(level=0.0, edge=WaveformEdgeType.BOTH)
+        self.assertEqual([e.index for e in via_trigger], [e.index for e in direct])
+
+    def test_edge_kind_honors_explicit_edge_field(self) -> None:
+        via_trigger = self.square.detect_triggers(
+            WaveformTrigger(kind=WaveformTriggerType.EDGE, level=0.0, edge=WaveformEdgeType.RISING)
+        )
+        direct = self.square.detect_edge_triggers(level=0.0, edge=WaveformEdgeType.RISING)
+        self.assertEqual([e.index for e in via_trigger], [e.index for e in direct])
+
+    def test_edge_kind_missing_level_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            self.square.detect_triggers(WaveformTrigger(kind=WaveformTriggerType.EDGE))
+
+    def test_level_kind_dispatches_with_default_rising(self) -> None:
+        via_trigger = self.square.detect_triggers(
+            WaveformTrigger(kind=WaveformTriggerType.LEVEL, level=0.0)
+        )
+        direct = self.square.detect_level_triggers(level=0.0)
+        self.assertEqual([e.index for e in via_trigger], [e.index for e in direct])
+
+    def test_level_kind_missing_level_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            self.square.detect_triggers(WaveformTrigger(kind=WaveformTriggerType.LEVEL))
+
+    def test_window_kind_dispatches_with_default_enter(self) -> None:
+        via_trigger = self.square.detect_triggers(
+            WaveformTrigger(kind=WaveformTriggerType.WINDOW, lower=0.0, upper=1.5)
+        )
+        direct = self.square.detect_window_triggers(0.0, 1.5, WaveformWindowTriggerType.ENTER)
+        self.assertEqual([e.index for e in via_trigger], [e.index for e in direct])
+
+    def test_window_kind_missing_bounds_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            self.square.detect_triggers(WaveformTrigger(kind=WaveformTriggerType.WINDOW))
+
+    def test_pattern_kind_dispatches(self) -> None:
+        motif = [1.0, -1.0]
+        via_trigger = self.square.detect_triggers(
+            WaveformTrigger(kind=WaveformTriggerType.PATTERN, pattern=tuple(motif), tolerance=0.01)
+        )
+        direct = self.square.detect_pattern_triggers(motif, tolerance=0.01)
+        self.assertEqual([e.index for e in via_trigger], [e.index for e in direct])
+
+    def test_pattern_kind_missing_fields_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            self.square.detect_triggers(WaveformTrigger(kind=WaveformTriggerType.PATTERN))
+
+    def test_minimum_interval_honored_through_generic_dispatch(self) -> None:
+        """§Gap 21 (chunk 55): ``minimum_interval`` dedup entry point 5 of 5
+        (``detect_triggers``'s generic ``WaveformTrigger``-driven dispatch)."""
+        values = [-1.0, 1.0, -1.0, 1.0, -1.0]
+        w = Waveform1D(values, dt_seconds=1.0)
+        min_interval = PrecisionTimeInterval.from_seconds(5.0)
+
+        via_trigger = w.detect_triggers(
+            WaveformTrigger(kind=WaveformTriggerType.EDGE, level=0.0, minimum_interval=min_interval)
+        )
+        direct = w.detect_edge_triggers(level=0.0, minimum_interval=min_interval)
+        self.assertEqual([e.index for e in via_trigger], [1])
+        self.assertEqual([e.index for e in via_trigger], [e.index for e in direct])
+
+
+class TestWithEventMarkers(unittest.TestCase):
+    def test_markers_built_from_events(self) -> None:
+        w = Waveform1D(_square_pulses(2, samples_per_phase=10, low=-1.0, high=1.0), dt_seconds=0.1)
+        events = w.detect_edge_triggers(level=0.0, edge=WaveformEdgeType.RISING)
+
+        result = w.with_event_markers(events)
+
+        self.assertIs(result.waveform, w)
+        self.assertEqual(len(result.events), len(events))
+        for marker, event in zip(result.events, events, strict=True):
+            self.assertEqual(marker.index, event.index)
+            self.assertEqual(marker.label, event.kind.value)
+
+    def test_empty_events_yields_no_markers(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.1)
+        result = w.with_event_markers([])
+        self.assertEqual(result.events, ())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/dsp/test_windowing.py b/tests/waveforms/dsp/test_windowing.py
new file mode 100644
index 0000000..4256184
--- /dev/null
+++ b/tests/waveforms/dsp/test_windowing.py
@@ -0,0 +1,243 @@
+"""Unit tests for ``dsp/_windowing.py`` (``WindowingMixin``).
+
+Covers waveformDsp.md §Family contracts (``WindowingMixin``), §Numerical
+conventions, §Compliance 1-2. Exercises the mixin directly on ``Waveform1D``, which
+composes every DSP mixin from the compose chunk (30) onward.
+"""
+
+import unittest
+
+import numpy as np
+from scipy.signal import get_window as scipy_get_window
+
+from math_tools.waveforms.dsp import _spectral as spectral_module
+from math_tools.waveforms.dsp import _windowing as windowing_module
+from math_tools.waveforms.dsp._common import DEFAULT_KAISER_BETA
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.dsp._windowing import WindowingMixin
+from math_tools.waveforms.support import WaveformWindowType
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+def _wrap(base: WaveformProtocol) -> Waveform1D:
+    """Rewrap a ``WaveformProtocol``-satisfying result as ``Waveform1D`` (see ``test_calc.py``)."""
+    return Waveform1D(base.values, dt=base.dt, t0=base.t0)
+
+
+class TestGenerateWindowEveryMember(unittest.TestCase):
+    """Acceptance criterion: every ``WaveformWindowType`` member generates without error."""
+
+    def test_all_members_generate_correct_length(self) -> None:
+        length = 32
+        for window in WaveformWindowType:
+            coefficients = WindowingMixin.generate_window(window, length)
+            self.assertEqual(coefficients.shape, (length,))
+
+    def test_zero_length_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            WindowingMixin.generate_window(WaveformWindowType.HANN, 0)
+
+    def test_negative_length_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            WindowingMixin.generate_window(WaveformWindowType.HANN, -5)
+
+    def test_single_sample_is_one(self) -> None:
+        for window in WaveformWindowType:
+            coefficients = WindowingMixin.generate_window(window, 1)
+            np.testing.assert_allclose(coefficients, [1.0])
+
+
+class TestWindowCoefficientsMatchScipyDirectly(unittest.TestCase):
+    """§Gap 22 (chunk 55): coefficients were verified only for HANN; HAMMING,
+    BLACKMAN, BARTLETT, and KAISER were checked only for shape, so a wrong
+    ``_WINDOW_NAME_MAP`` entry (``_windowing.py:56``) would still pass. Pin the
+    full coefficient array for every member against a direct
+    ``scipy.signal.get_window`` call (symmetric convention)."""
+
+    def test_hamming_matches_scipy(self) -> None:
+        n = 33
+        result = WindowingMixin.generate_window(WaveformWindowType.HAMMING, n)
+        expected = scipy_get_window("hamming", n, fftbins=False)
+        np.testing.assert_allclose(result, expected)
+
+    def test_blackman_matches_scipy(self) -> None:
+        n = 33
+        result = WindowingMixin.generate_window(WaveformWindowType.BLACKMAN, n)
+        expected = scipy_get_window("blackman", n, fftbins=False)
+        np.testing.assert_allclose(result, expected)
+
+    def test_bartlett_matches_scipy(self) -> None:
+        n = 33
+        result = WindowingMixin.generate_window(WaveformWindowType.BARTLETT, n)
+        expected = scipy_get_window("bartlett", n, fftbins=False)
+        np.testing.assert_allclose(result, expected)
+
+    def test_kaiser_matches_scipy_with_shared_beta(self) -> None:
+        n = 33
+        result = WindowingMixin.generate_window(WaveformWindowType.KAISER, n)
+        expected = scipy_get_window(("kaiser", DEFAULT_KAISER_BETA), n, fftbins=False)
+        np.testing.assert_allclose(result, expected)
+
+    def test_rectangular_matches_scipy(self) -> None:
+        n = 33
+        result = WindowingMixin.generate_window(WaveformWindowType.RECTANGULAR, n)
+        expected = scipy_get_window("boxcar", n, fftbins=False)
+        np.testing.assert_allclose(result, expected)
+
+
+class TestHannShape(unittest.TestCase):
+    """Acceptance criterion: HANN endpoints ~= 0 and midpoint ~= 1."""
+
+    def test_endpoints_near_zero_and_midpoint_near_one(self) -> None:
+        length = 101  # odd -> exact midpoint sample
+        coefficients = WindowingMixin.generate_window(WaveformWindowType.HANN, length)
+        self.assertAlmostEqual(float(coefficients[0]), 0.0, places=9)
+        self.assertAlmostEqual(float(coefficients[-1]), 0.0, places=9)
+        self.assertAlmostEqual(float(coefficients[length // 2]), 1.0, places=9)
+
+
+class TestWindowCoherentGain(unittest.TestCase):
+    """Acceptance criterion: coherent gain of HANN ~= 0.5 (rtol 1e-2, finite length)."""
+
+    def test_hann_coherent_gain(self) -> None:
+        w = _wrap(Waveform1D.constant(1000, value=1.0, dt_seconds=0.1))
+        gain = w.window_coherent_gain(WaveformWindowType.HANN)
+        self.assertAlmostEqual(gain, 0.5, delta=0.5 * 1e-2)
+
+    def test_rectangular_coherent_gain_is_one(self) -> None:
+        w = _wrap(Waveform1D.constant(50, value=1.0, dt_seconds=0.1))
+        gain = w.window_coherent_gain(WaveformWindowType.RECTANGULAR)
+        self.assertEqual(gain, 1.0)
+
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.window_coherent_gain(WaveformWindowType.HANN)
+
+
+class TestWindowProcessingGain(unittest.TestCase):
+    def test_rectangular_processing_gain_is_one(self) -> None:
+        w = _wrap(Waveform1D.constant(50, value=1.0, dt_seconds=0.1))
+        gain = w.window_processing_gain(WaveformWindowType.RECTANGULAR)
+        self.assertEqual(gain, 1.0)
+
+    def test_hann_processing_gain_between_zero_and_one(self) -> None:
+        w = _wrap(Waveform1D.constant(1000, value=1.0, dt_seconds=0.1))
+        gain = w.window_processing_gain(WaveformWindowType.HANN)
+        self.assertLess(gain, 1.0)
+        self.assertGreater(gain, 0.0)
+
+    def test_hann_processing_gain_matches_analytic_sqrt_3_over_8(self) -> None:
+        """§Gap 22 (chunk 55): HANN's known-answer processing gain
+        (``sqrt(3/8) ~= 0.6124``) was available but unpinned -- only the loose
+        ``RECTANGULAR``-only known-answer test existed."""
+        w = _wrap(Waveform1D.constant(1001, value=1.0, dt_seconds=0.001))
+        gain = w.window_processing_gain(WaveformWindowType.HANN)
+        self.assertAlmostEqual(gain, float(np.sqrt(3.0 / 8.0)), delta=1e-3)
+
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.window_processing_gain(WaveformWindowType.HANN)
+
+
+class TestWindowed(unittest.TestCase):
+    """Acceptance criterion: RECTANGULAR ``windowed`` is identity."""
+
+    def test_rectangular_is_identity(self) -> None:
+        w = _wrap(Waveform1D.sine(100, frequency=5.0, amplitude=2.0, dt_seconds=0.001))
+        windowed = w.windowed(WaveformWindowType.RECTANGULAR)
+        np.testing.assert_allclose(windowed.values, w.values)
+        self.assertEqual(windowed.dt, w.dt)
+        self.assertEqual(windowed.t0, w.t0)
+
+    def test_hann_tapers_endpoints_to_near_zero(self) -> None:
+        w = _wrap(Waveform1D.constant(101, value=1.0, dt_seconds=0.1))
+        windowed = w.windowed(WaveformWindowType.HANN)
+        self.assertAlmostEqual(float(windowed.values[0]), 0.0, places=9)
+        self.assertAlmostEqual(float(windowed.values[-1]), 0.0, places=9)
+        self.assertAlmostEqual(float(windowed.values[50]), 1.0, places=9)
+
+    def test_metadata_preserved(self) -> None:
+        w = _wrap(Waveform1D.constant(20, value=1.0, dt_seconds=0.25, t0_seconds=5.0))
+        windowed = w.windowed(WaveformWindowType.HAMMING)
+        self.assertEqual(windowed.dt, w.dt)
+        self.assertEqual(windowed.t0, w.t0)
+
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.windowed(WaveformWindowType.HANN)
+
+
+class TestPeriodicConvention(unittest.TestCase):
+    """Post-audit D-windowing-(c) / chunk 53: ``periodic=True`` pins scipy's
+    default (``fftbins=True``) convention -- the one ``SpectralMixin``
+    actually applies -- and ``periodic=False`` (default) keeps the existing
+    symmetric convention unchanged."""
+
+    def test_periodic_true_matches_scipy_default(self) -> None:
+        n = 64
+        coefficients = WindowingMixin.generate_window(WaveformWindowType.HANN, n, periodic=True)
+        expected = scipy_get_window("hann", n)
+        np.testing.assert_allclose(coefficients, expected)
+
+    def test_periodic_false_matches_scipy_symmetric(self) -> None:
+        n = 64
+        coefficients = WindowingMixin.generate_window(WaveformWindowType.HANN, n, periodic=False)
+        expected = scipy_get_window("hann", n, fftbins=False)
+        np.testing.assert_allclose(coefficients, expected)
+
+    def test_default_argument_is_symmetric_unchanged(self) -> None:
+        n = 64
+        default = WindowingMixin.generate_window(WaveformWindowType.HANN, n)
+        symmetric = WindowingMixin.generate_window(WaveformWindowType.HANN, n, periodic=False)
+        np.testing.assert_allclose(default, symmetric)
+
+
+class TestGainHelpersDescribePeriodicConvention(unittest.TestCase):
+    """Chunk 53 acceptance: the gain helpers, asked for ``periodic=True``,
+    describe the exact window ``power_spectral_density``/``spectrogram``
+    apply internally (``dsp/_spectral.py``'s ``_window_array``)."""
+
+    def test_coherent_gain_periodic_matches_spectral_window(self) -> None:
+        n = 128
+        w = _wrap(Waveform1D.constant(n, value=1.0, dt_seconds=0.01))
+        gain = w.window_coherent_gain(WaveformWindowType.HANN, periodic=True)
+        spectral_window = spectral_module._window_array(WaveformWindowType.HANN, n)
+        self.assertAlmostEqual(gain, float(np.mean(spectral_window)), places=12)
+
+    def test_processing_gain_periodic_matches_spectral_window(self) -> None:
+        n = 128
+        w = _wrap(Waveform1D.constant(n, value=1.0, dt_seconds=0.01))
+        gain = w.window_processing_gain(WaveformWindowType.HANN, periodic=True)
+        spectral_window = spectral_module._window_array(WaveformWindowType.HANN, n)
+        self.assertAlmostEqual(gain, float(np.sqrt(np.mean(spectral_window**2))), places=12)
+
+    def test_default_periodic_false_is_unchanged_from_before_chunk_53(self) -> None:
+        n = 128
+        w = _wrap(Waveform1D.constant(n, value=1.0, dt_seconds=0.01))
+        default_gain = w.window_coherent_gain(WaveformWindowType.HANN)
+        symmetric_gain = w.window_coherent_gain(WaveformWindowType.HANN, periodic=False)
+        self.assertEqual(default_gain, symmetric_gain)
+
+
+class TestSharedKaiserBeta(unittest.TestCase):
+    """Chunk 53 acceptance: one shared Kaiser beta constant backs both
+    ``_windowing.py`` and ``_spectral.py`` -- not two independent literals."""
+
+    def test_both_modules_reference_the_same_constant(self) -> None:
+        self.assertEqual(windowing_module.DEFAULT_KAISER_BETA, DEFAULT_KAISER_BETA)
+        self.assertEqual(spectral_module.DEFAULT_KAISER_BETA, DEFAULT_KAISER_BETA)
+
+    def test_kaiser_windows_agree_at_matching_length_and_convention(self) -> None:
+        n = 64
+        windowing_kaiser = WindowingMixin.generate_window(
+            WaveformWindowType.KAISER, n, periodic=True
+        )
+        spectral_kaiser = spectral_module._window_array(WaveformWindowType.KAISER, n)
+        np.testing.assert_allclose(windowing_kaiser, spectral_kaiser)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/dsp/test_zero_crossings.py b/tests/waveforms/dsp/test_zero_crossings.py
new file mode 100644
index 0000000..0d676e9
--- /dev/null
+++ b/tests/waveforms/dsp/test_zero_crossings.py
@@ -0,0 +1,198 @@
+"""Unit tests for ``dsp/_zero_crossings.py`` (``ZeroCrossingMixin``).
+
+Covers waveformDsp.md §Family contracts (``ZeroCrossingMixin``), §Numerical
+conventions, §Compliance 1-2. Exercises the mixin directly on ``Waveform1D``, which
+composes every DSP mixin from the compose chunk (30) onward.
+"""
+
+import unittest
+
+import numpy as np
+
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.support import WaveformZeroCrossingDirection
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+def _wrap(base: WaveformProtocol) -> Waveform1D:
+    """Rewrap a ``WaveformProtocol``-satisfying result as ``Waveform1D`` (see ``test_calc.py``)."""
+    return Waveform1D(base.values, dt=base.dt, t0=base.t0)
+
+
+class TestZeroCrossingRateOfSine(unittest.TestCase):
+    """§Compliance 1: an f-Hz sine over an integer number of periods has
+    ``zero_crossing_rate() == 2f`` (within one crossing's worth of tolerance)."""
+
+    def test_rate_matches_2f(self) -> None:
+        frequency = 5.0
+        periods = 20
+        n = 4000
+        dt_seconds = (periods / frequency) / n
+        w = _wrap(Waveform1D.sine(n, frequency=frequency, amplitude=1.0, dt_seconds=dt_seconds))
+
+        rate = w.zero_crossing_rate()
+
+        duration_seconds = (n - 1) * dt_seconds
+        one_crossing_tolerance = 1.0 / duration_seconds
+        self.assertAlmostEqual(rate, 2.0 * frequency, delta=one_crossing_tolerance + 1e-6)
+
+    def test_count_matches_2f_times_duration(self) -> None:
+        frequency = 5.0
+        periods = 20
+        n = 4000
+        dt_seconds = (periods / frequency) / n
+        w = _wrap(Waveform1D.sine(n, frequency=frequency, amplitude=1.0, dt_seconds=dt_seconds))
+
+        count = w.zero_crossing_count()
+
+        expected = 2 * periods
+        self.assertLessEqual(abs(count - expected), 1)
+
+
+class TestPositiveNegativeSumToBoth(unittest.TestCase):
+    """§Compliance 1: POSITIVE + NEGATIVE counts sum to BOTH."""
+
+    def test_direction_counts_sum(self) -> None:
+        w = _wrap(Waveform1D.sine(2000, frequency=7.0, amplitude=1.0, dt_seconds=0.0005))
+
+        positive = w.zero_crossing_count(direction=WaveformZeroCrossingDirection.POSITIVE)
+        negative = w.zero_crossing_count(direction=WaveformZeroCrossingDirection.NEGATIVE)
+        both = w.zero_crossing_count(direction=WaveformZeroCrossingDirection.BOTH)
+
+        self.assertEqual(positive + negative, both)
+        self.assertGreater(positive, 0)
+        self.assertGreater(negative, 0)
+
+    def test_direction_filters_events(self) -> None:
+        w = _wrap(Waveform1D.sine(2000, frequency=7.0, amplitude=1.0, dt_seconds=0.0005))
+
+        positive_events = w.zero_crossings(direction=WaveformZeroCrossingDirection.POSITIVE)
+        negative_events = w.zero_crossings(direction=WaveformZeroCrossingDirection.NEGATIVE)
+
+        self.assertTrue(
+            all(e.direction is WaveformZeroCrossingDirection.POSITIVE for e in positive_events)
+        )
+        self.assertTrue(
+            all(e.direction is WaveformZeroCrossingDirection.NEGATIVE for e in negative_events)
+        )
+
+
+class TestSubSampleInterpolation(unittest.TestCase):
+    """§Compliance 1: crossing of a line ``y = t - 0.5`` lands at 0.5 s
+    (atol dt/100)."""
+
+    def test_linear_ramp_crossing_interpolated(self) -> None:
+        dt_seconds = 0.03
+        n = 60
+        values = np.arange(n, dtype=np.float64) * dt_seconds - 0.5
+        w = Waveform1D(values, dt_seconds=dt_seconds)
+
+        crossings = w.zero_crossings()
+
+        self.assertEqual(len(crossings), 1)
+        self.assertAlmostEqual(crossings[0].time_seconds, 0.5, delta=dt_seconds / 100.0)
+        self.assertEqual(crossings[0].direction, WaveformZeroCrossingDirection.POSITIVE)
+
+    def test_exact_zero_sample_counts_once(self) -> None:
+        # Sample lands exactly on zero at index 5 -- must not be double-counted
+        # as both an approach-to-zero and a departure-from-zero crossing.
+        values = np.array([-2.0, -1.0, 0.0, 1.0, 2.0], dtype=np.float64)
+        w = Waveform1D(values, dt_seconds=1.0)
+
+        crossings = w.zero_crossings()
+
+        self.assertEqual(len(crossings), 1)
+        self.assertAlmostEqual(crossings[0].time_seconds, 2.0, delta=1e-9)
+
+
+class TestEmptyOrTooShortReturnsEmptyList(unittest.TestCase):
+    """waveformDsp.md §Numerical conventions: ``zero_crossings`` is a detector
+    -- empty/too-short input returns ``[]``, never raises."""
+
+    def test_empty_waveform(self) -> None:
+        w = Waveform1D([], dt_seconds=0.1)
+        self.assertEqual(w.zero_crossings(), [])
+        self.assertEqual(w.zero_crossing_count(), 0)
+        self.assertEqual(w.zero_crossing_rate(), 0.0)
+
+    def test_single_sample(self) -> None:
+        w = Waveform1D([1.0], dt_seconds=0.1)
+        self.assertEqual(w.zero_crossings(), [])
+
+    def test_no_crossing_all_positive(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1)
+        self.assertEqual(w.zero_crossings(), [])
+        self.assertEqual(w.zero_crossing_rate(), 0.0)
+
+
+class TestSegmentsBetweenZeroCrossings(unittest.TestCase):
+    """Acceptance criterion: segments' t0s are monotonically increasing and
+    lengths sum to ~= n."""
+
+    def test_monotonic_t0_and_length_sum(self) -> None:
+        n = 2000
+        w = _wrap(Waveform1D.sine(n, frequency=6.0, amplitude=1.0, dt_seconds=0.0005))
+
+        segments = w.segments_between_zero_crossings()
+
+        self.assertGreater(len(segments), 1)
+        t0s = [segment.t0 for segment in segments]
+        self.assertEqual(t0s, sorted(t0s))
+        for earlier, later in zip(t0s, t0s[1:], strict=False):
+            self.assertLess(earlier, later)
+
+        total_length = sum(len(segment.values) for segment in segments)
+        # Each internal boundary sample is shared by two adjacent segments, so the
+        # sum slightly overshoots n by roughly one sample per internal boundary.
+        self.assertGreaterEqual(total_length, n)
+        self.assertLessEqual(total_length, n + len(segments))
+
+    def test_no_crossings_returns_whole_waveform(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.1, t0_seconds=1.0)
+        segments = w.segments_between_zero_crossings()
+        self.assertEqual(len(segments), 1)
+        np.testing.assert_allclose(segments[0].values, w.values)
+        self.assertEqual(segments[0].t0, w.t0)
+
+    def test_single_sample_returns_single_segment(self) -> None:
+        w = Waveform1D([5.0], dt_seconds=0.1)
+        segments = w.segments_between_zero_crossings()
+        self.assertEqual(len(segments), 1)
+        np.testing.assert_allclose(segments[0].values, [5.0])
+
+    def test_empty_waveform_raises(self) -> None:
+        w = Waveform1D([], dt_seconds=0.1)
+        with self.assertRaises(ValueError):
+            w.segments_between_zero_crossings()
+
+    def test_segment_dt_preserved(self) -> None:
+        w = _wrap(Waveform1D.sine(500, frequency=4.0, amplitude=1.0, dt_seconds=0.001))
+        segments = w.segments_between_zero_crossings()
+        for segment in segments:
+            self.assertEqual(segment.dt, w.dt)
+
+    def test_inclusive_slicing_pinned_on_hand_computed_case(self) -> None:
+        """§Gap 23 (chunk 55): the inclusive ``[start:stop+1]`` slicing
+        (``_zero_crossings.py:206``) was never pinned against a hand-computed
+        case. ``values = [1, -1, 1, -1, 1]`` (alternating sign, ``dt=1s``) has
+        BOTH-direction crossings landing at indices ``[1, 2, 3, 4]`` (each pair
+        change is a crossing); with ``split_points = [0, 1, 2, 3, 4, 4]`` (the
+        trailing duplicate ``sample_count - 1 == 4`` dropped, since
+        ``start >= stop``), the four inclusive segments are
+        ``values[0:2], values[1:3], values[2:4], values[3:5]`` -- each interior
+        boundary sample shared by exactly two adjacent segments.
+        """
+        values = [1.0, -1.0, 1.0, -1.0, 1.0]
+        w = Waveform1D(values, dt_seconds=1.0, t0_seconds=0.0)
+
+        segments = w.segments_between_zero_crossings()
+
+        self.assertEqual(len(segments), 4)
+        expected_slices = [(0, 2), (1, 3), (2, 4), (3, 5)]
+        for segment, (start, stop) in zip(segments, expected_slices, strict=True):
+            np.testing.assert_allclose(segment.values, values[start:stop])
+            self.assertEqual(segment.t0, w.t0 + w.dt * start)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/test_support.py b/tests/waveforms/test_support.py
new file mode 100644
index 0000000..9e2e063
--- /dev/null
+++ b/tests/waveforms/test_support.py
@@ -0,0 +1,216 @@
+"""Unit tests for ``waveforms/support.py`` and ``dsp/_protocol.py``.
+
+Covers waveformDsp.md §Support descriptor types and §Compliance 3: every
+spec-listed enum member exists, every descriptor dataclass is frozen
+(mutation raises), every ndarray-bearing descriptor has ``eq=False`` (``==``
+on two equal-content instances must not raise), and ``Waveform1D``
+structurally satisfies ``WaveformProtocol`` both at runtime
+(``isinstance``, via ``@runtime_checkable``) and under mypy strict (a
+protocol-typed assignment).
+"""
+
+import dataclasses
+import unittest
+from typing import Any
+
+import numpy as np
+
+from math_tools.waveforms import support as sup
+from math_tools.waveforms.dsp._protocol import WaveformProtocol
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+class TestEnumMembers(unittest.TestCase):
+    """Every enum member listed in waveformDsp.md §Support descriptor types exists."""
+
+    def _assert_members(self, enum_cls: type, expected: list[str]) -> None:
+        for name in expected:
+            self.assertTrue(
+                hasattr(enum_cls, name), f"{enum_cls.__name__} is missing member {name}"
+            )
+
+    def test_waveform_filter_type(self) -> None:
+        self._assert_members(
+            sup.WaveformFilterType, ["LOW_PASS", "HIGH_PASS", "BAND_PASS", "BAND_STOP"]
+        )
+
+    def test_waveform_window_type(self) -> None:
+        self._assert_members(
+            sup.WaveformWindowType,
+            ["HANN", "HAMMING", "BLACKMAN", "BARTLETT", "KAISER", "RECTANGULAR"],
+        )
+
+    def test_waveform_interpolation_method(self) -> None:
+        self._assert_members(
+            sup.WaveformInterpolationMethod, ["LINEAR", "CUBIC", "NEAREST", "FOURIER"]
+        )
+
+    def test_waveform_instantaneous_method(self) -> None:
+        self._assert_members(sup.WaveformInstantaneousMethod, ["HILBERT", "RMS", "PEAK"])
+
+    def test_waveform_edge_type(self) -> None:
+        self._assert_members(sup.WaveformEdgeType, ["RISING", "FALLING", "BOTH"])
+
+    def test_waveform_window_trigger_type(self) -> None:
+        self._assert_members(sup.WaveformWindowTriggerType, ["ENTER", "EXIT"])
+
+    def test_waveform_alignment_method(self) -> None:
+        self._assert_members(sup.WaveformAlignmentMethod, ["CORRELATION", "START_TIME"])
+
+    def test_waveform_zero_crossing_direction(self) -> None:
+        self._assert_members(sup.WaveformZeroCrossingDirection, ["POSITIVE", "NEGATIVE", "BOTH"])
+
+    def test_waveform_padding_strategy(self) -> None:
+        self._assert_members(sup.WaveformPaddingStrategy, ["ZERO", "EDGE", "REFLECT", "WRAP"])
+
+    def test_waveform_psd_scaling(self) -> None:
+        self._assert_members(sup.WaveformPSDScaling, ["DENSITY", "SPECTRUM"])
+
+    def test_waveform_spectrogram_scaling(self) -> None:
+        self._assert_members(sup.WaveformSpectrogramScaling, ["LINEAR", "DB", "MEL"])
+
+    def test_waveform_trigger_type(self) -> None:
+        self._assert_members(sup.WaveformTriggerType, ["EDGE", "LEVEL", "WINDOW", "PATTERN"])
+
+    def test_enum_values_are_snake_case_strings(self) -> None:
+        for enum_cls in (
+            sup.WaveformFilterType,
+            sup.WaveformWindowType,
+            sup.WaveformInterpolationMethod,
+            sup.WaveformInstantaneousMethod,
+            sup.WaveformEdgeType,
+            sup.WaveformWindowTriggerType,
+            sup.WaveformAlignmentMethod,
+            sup.WaveformZeroCrossingDirection,
+            sup.WaveformPaddingStrategy,
+            sup.WaveformPSDScaling,
+            sup.WaveformSpectrogramScaling,
+            sup.WaveformTriggerType,
+        ):
+            for member in enum_cls:
+                self.assertIsInstance(member.value, str)
+                self.assertEqual(member.value, member.value.lower())
+                self.assertNotIn(" ", member.value)
+
+
+def _sample_instances() -> list[Any]:
+    """One instance of every descriptor dataclass in support.py."""
+    freq = np.array([1.0, 2.0, 3.0])
+    mag = np.array([4.0, 5.0, 6.0])
+    phases = np.array([0.1, 0.2, 0.3])
+    peak = sup.WaveformPeak(index=1, time_seconds=0.1, value=2.0)
+    waveform = Waveform1D([1.0, 2.0, 3.0])
+    return [
+        sup.WaveformSpectrum(frequencies=freq, magnitudes=mag, phases=phases),
+        sup.WaveformSpectrogram(times=freq, frequencies=freq, magnitudes=mag),
+        sup.WaveformMelSpectrogram(times=freq, mel_frequencies=freq, magnitudes=mag),
+        sup.WaveformSpectralFeatures(centroid=1.0, spread=2.0, rolloff=3.0, flatness=0.5),
+        peak,
+        sup.WaveformPeakWithProminence(peak=peak, prominence=0.5),
+        sup.WaveformTimeLag(lag_samples=3, lag_seconds=0.03, correlation=0.9),
+        sup.WaveformTrigger(kind=sup.WaveformTriggerType.LEVEL, level=1.0),
+        sup.WaveformTriggerEvent(
+            index=1, time_seconds=0.1, value=2.0, kind=sup.WaveformTriggerType.EDGE
+        ),
+        sup.WaveformEventMarker(index=1, label="peak"),
+        sup.WaveformWithEvents(
+            waveform=waveform, events=(sup.WaveformEventMarker(index=0, label="a"),)
+        ),
+        sup.WaveformZeroCrossing(
+            index=1, time_seconds=0.1, direction=sup.WaveformZeroCrossingDirection.POSITIVE
+        ),
+        sup.WaveformInstantaneousFrequency(frequencies_hz=freq, times_seconds=freq),
+        sup.WaveformFrequencyRange(low_hz=1.0, high_hz=10.0),
+        sup.WaveformFilterCoefficients(numerator=freq, denominator=mag),
+    ]
+
+
+_NDARRAY_BEARING_TYPES: tuple[type, ...] = (
+    sup.WaveformSpectrum,
+    sup.WaveformSpectrogram,
+    sup.WaveformMelSpectrogram,
+    sup.WaveformInstantaneousFrequency,
+    sup.WaveformFilterCoefficients,
+)
+
+
+class TestDataclassesAreFrozen(unittest.TestCase):
+    """Every descriptor dataclass raises on mutation (frozen=True)."""
+
+    def test_mutation_raises(self) -> None:
+        for instance in _sample_instances():
+            field = dataclasses.fields(instance)[0]
+            with self.assertRaises(
+                dataclasses.FrozenInstanceError,
+                msg=f"{type(instance).__name__} did not raise on mutation",
+            ):
+                setattr(instance, field.name, getattr(instance, field.name))
+
+    def test_all_dataclasses_are_slots(self) -> None:
+        for instance in _sample_instances():
+            self.assertFalse(
+                hasattr(instance, "__dict__"),
+                f"{type(instance).__name__} is missing slots=True (has __dict__)",
+            )
+
+
+class TestNdarrayDescriptorsHaveSafeEquality(unittest.TestCase):
+    """waveformDsp.md §Compliance 3: eq=False on ndarray descriptors -- '==' must not raise."""
+
+    def test_equal_content_instances_compare_without_raising(self) -> None:
+        for cls in _NDARRAY_BEARING_TYPES:
+            with self.subTest(cls=cls.__name__):
+                all_instances = _sample_instances() + _sample_instances()
+                instances = [inst for inst in all_instances if type(inst) is cls]
+                a, b = instances[0], instances[1]
+                try:
+                    result = a == b
+                except Exception as exc:  # pragma: no cover - failure path
+                    self.fail(f"{cls.__name__}.__eq__ raised: {exc!r}")
+                self.assertIsInstance(result, bool)
+
+    def test_ndarray_descriptors_use_identity_eq(self) -> None:
+        # eq=False means no dataclass-generated __eq__: object identity applies, so two
+        # distinct equal-content instances are unequal (never raise, per the test above).
+        freq = np.array([1.0, 2.0, 3.0])
+        a = sup.WaveformFilterCoefficients(numerator=freq, denominator=freq)
+        b = sup.WaveformFilterCoefficients(numerator=freq, denominator=freq)
+        self.assertFalse(a == b)
+        self.assertEqual(a, a)
+
+
+class TestWaveformProtocol(unittest.TestCase):
+    """``Waveform1D`` structurally satisfies ``WaveformProtocol``."""
+
+    def test_isinstance_via_runtime_checkable(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        self.assertIsInstance(w, WaveformProtocol)
+
+    def test_protocol_typed_assignment(self) -> None:
+        # Exercises the mypy-strict-checkable surface: a Waveform1D is assignable to a
+        # WaveformProtocol-typed variable without a cast/ignore.
+        w: WaveformProtocol = Waveform1D([1.0, 2.0, 3.0])
+        self.assertEqual(list(w.values), [1.0, 2.0, 3.0])
+        self.assertEqual(w.sampling_frequency_hz, 1.0)
+        new_w = w._with_values(np.array([4.0, 5.0, 6.0]))
+        self.assertEqual(list(new_w.values), [4.0, 5.0, 6.0])
+        self.assertEqual(new_w.dt, w.dt)
+        self.assertEqual(new_w.t0, w.t0)
+
+
+class TestWithValues(unittest.TestCase):
+    """``Waveform1D._with_values`` returns a new instance sharing dt/t0."""
+
+    def test_new_instance_shares_dt_and_t0(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.5, t0_seconds=10.0)
+        new_w = w._with_values(np.array([9.0, 8.0, 7.0]))
+        self.assertIsNot(new_w, w)
+        self.assertEqual(new_w.dt, w.dt)
+        self.assertEqual(new_w.t0, w.t0)
+        self.assertEqual(list(new_w.values), [9.0, 8.0, 7.0])
+        # original is untouched
+        self.assertEqual(list(w.values), [1.0, 2.0, 3.0])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/test_waveform1d_core.py b/tests/waveforms/test_waveform1d_core.py
new file mode 100644
index 0000000..d05f763
--- /dev/null
+++ b/tests/waveforms/test_waveform1d_core.py
@@ -0,0 +1,633 @@
+"""Unit tests for ``Waveform1D`` (core container: no operators, no DSP).
+
+Covers waveformCore.md §Compliance requirements 1, 3, 5, 6, 7, 11, plus
+construction, time axis, statistics, indexing/slicing, value_at_*,
+mutation, comparison, iteration/array interop, and generator coverage.
+"""
+
+import time
+import unittest
+
+import numpy as np
+from foundationTypes.mathTypes.MathTypes import ScalarWaveformType
+
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.precision_time.precision_timestamp import PrecisionTimestamp
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+class TestSpecCompliance11Instantiability(unittest.TestCase):
+    """§Compliance 11: bare construction, concreteness, array/iteration interop."""
+
+    def test_bare_construction_with_no_time_args(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        self.assertEqual(w.dt, PrecisionTimeInterval.from_seconds(1.0))
+        self.assertEqual(w.t0, PrecisionTimestamp.EPOCH)
+
+    def test_no_abstract_methods_remain(self) -> None:
+        self.assertEqual(Waveform1D.__abstractmethods__, frozenset())
+
+    def test_np_asarray_equals_samples(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        np.testing.assert_array_equal(np.asarray(w), np.array([1.0, 2.0, 3.0]))
+
+    def test_iteration_yields_samples(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        self.assertEqual(list(w), [1.0, 2.0, 3.0])
+
+    def test_np_asarray_then_mean_interop(self) -> None:
+        # np.mean(w) directly hits numpy's `a.mean` duck-typing fast path,
+        # which collides with our spec-mandated `mean` *property* (not a
+        # method) -- np.asarray(w) is the documented interop surface
+        # (§Compliance 11), not a bare np.mean(w) call.
+        w = Waveform1D([1.0, 2.0, 3.0])
+        self.assertEqual(float(np.mean(np.asarray(w))), 2.0)
+
+    def test_array_copy_false_raises_value_error(self) -> None:
+        # NumPy 2's __array__(copy=...) protocol: a copy is unavoidable here
+        # (the returned array must not alias the mutable backing store), so
+        # copy=False must raise rather than silently copy anyway (finding C-7).
+        w = Waveform1D([1.0, 2.0, 3.0])
+        with self.assertRaises(ValueError):
+            np.array(w, copy=False)
+
+    def test_waveform_abc_accessor_returns_samples_as_float_list(self) -> None:
+        """C-11: the ABC-required ``waveform`` accessor (waveformCore.md's
+        load-bearing O(n) materialization path) has no direct test elsewhere
+        -- only exercised indirectly via to_dict."""
+        w = Waveform1D([1.0, 2.0, 3.0])
+        result = w.waveform
+        self.assertEqual(result, [1.0, 2.0, 3.0])
+        self.assertIsInstance(result, list)
+        self.assertTrue(all(isinstance(value, float) for value in result))
+
+
+class TestSpecCompliance1SerializationRoundTrip(unittest.TestCase):
+    """§Compliance 1: to_dict round-trips through ScalarWaveformType."""
+
+    def test_round_trip_equal(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.5, t0_seconds=10.0)
+        wire = ScalarWaveformType.from_dict(w.to_dict())
+        self.assertEqual(w.to_dict(), wire.to_dict())
+
+    def test_from_dict_reconstructs_equal_waveform(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.5, t0_seconds=10.0)
+        w2 = Waveform1D.from_dict(w.to_dict())
+        self.assertEqual(w, w2)
+
+    def test_isinstance_of_abc(self) -> None:
+        from foundation_abc.math.waveformABCs import Waveform1dABC
+
+        self.assertIsInstance(Waveform1D([1.0]), Waveform1dABC)
+
+
+class TestConstruction(unittest.TestCase):
+    def test_integer_dtype_preserved(self) -> None:
+        w = Waveform1D(np.array([1, 2, 3], dtype=np.int32))
+        self.assertEqual(w.values.dtype, np.int32)
+
+    def test_float_dtype_is_float64(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        self.assertEqual(w.values.dtype, np.float64)
+
+    def test_python_list_of_ints_preserves_integer_dtype(self) -> None:
+        w = Waveform1D([1, 2, 3])
+        self.assertTrue(np.issubdtype(w.values.dtype, np.integer))
+
+    def test_values_copied_not_aliased(self) -> None:
+        arr = np.array([1.0, 2.0, 3.0])
+        w = Waveform1D(arr)
+        arr[0] = 99.0
+        self.assertEqual(w[0], 1.0)
+
+    def test_non_1d_raises(self) -> None:
+        with self.assertRaises(ValueError):
+            Waveform1D([[1.0, 2.0], [3.0, 4.0]])
+
+    def test_both_dt_and_dt_seconds_raises_type_error(self) -> None:
+        with self.assertRaises(TypeError):
+            Waveform1D([1.0], dt=PrecisionTimeInterval.ONE_SECOND, dt_seconds=1.0)
+
+    def test_both_t0_and_t0_seconds_raises_type_error(self) -> None:
+        with self.assertRaises(TypeError):
+            Waveform1D([1.0], t0=PrecisionTimestamp.EPOCH, t0_seconds=1.0)
+
+    def test_zero_dt_seconds_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            Waveform1D([1.0], dt_seconds=0.0)
+
+    def test_negative_dt_seconds_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            Waveform1D([1.0], dt_seconds=-1.0)
+
+    def test_dt_seconds_sets_dt(self) -> None:
+        w = Waveform1D([1.0, 2.0], dt_seconds=0.25)
+        self.assertEqual(w.dt, PrecisionTimeInterval.from_seconds(0.25))
+
+    def test_t0_seconds_sets_t0(self) -> None:
+        w = Waveform1D([1.0, 2.0], t0_seconds=5.0)
+        self.assertEqual(w.t0, PrecisionTimestamp.EPOCH + PrecisionTimeInterval.from_seconds(5.0))
+
+    def test_negative_t0_seconds_is_pre_epoch(self) -> None:
+        w = Waveform1D([1.0], t0_seconds=-2.0)
+        self.assertEqual(w.t0, PrecisionTimestamp.EPOCH - PrecisionTimeInterval.from_seconds(2.0))
+
+
+class TestTimeAxis(unittest.TestCase):
+    def test_duration_is_dt_times_n_minus_1(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0], dt_seconds=0.5)
+        self.assertEqual(w.duration, PrecisionTimeInterval.from_seconds(1.5))
+
+    def test_duration_zero_for_single_sample(self) -> None:
+        w = Waveform1D([1.0], dt_seconds=0.5)
+        self.assertEqual(w.duration, PrecisionTimeInterval.ZERO)
+
+    def test_duration_zero_for_empty(self) -> None:
+        w = Waveform1D([], dt_seconds=0.5)
+        self.assertEqual(w.duration, PrecisionTimeInterval.ZERO)
+
+    def test_duration_seconds(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0], dt_seconds=2.0)
+        self.assertEqual(w.duration_seconds, 4.0)
+
+    def test_sampling_frequency_hz(self) -> None:
+        w = Waveform1D([1.0, 2.0], dt_seconds=0.1)
+        self.assertAlmostEqual(w.sampling_frequency_hz, 10.0)
+
+    def test_nyquist_frequency_hz(self) -> None:
+        w = Waveform1D([1.0, 2.0], dt_seconds=0.1)
+        self.assertAlmostEqual(w.nyquist_frequency_hz, 5.0)
+
+    def test_sample_count_and_len(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        self.assertEqual(w.sample_count, 3)
+        self.assertEqual(len(w), 3)
+
+    def test_time_axis(self) -> None:
+        w = Waveform1D([0.0, 0.0, 0.0, 0.0], dt_seconds=0.5)
+        np.testing.assert_allclose(w.time_axis(), [0.0, 0.5, 1.0, 1.5])
+
+
+class TestSpecCompliance5Statistics(unittest.TestCase):
+    """§Compliance 5: stats match numpy references; variance/rms pinned literally."""
+
+    def setUp(self) -> None:
+        self.w = Waveform1D([1.0, 2.0, 3.0, 4.0])
+
+    def test_minimum(self) -> None:
+        self.assertEqual(self.w.minimum, 1.0)
+
+    def test_maximum(self) -> None:
+        self.assertEqual(self.w.maximum, 4.0)
+
+    def test_peak_to_peak(self) -> None:
+        self.assertEqual(self.w.peak_to_peak, 3.0)
+
+    def test_mean(self) -> None:
+        self.assertEqual(self.w.mean, 2.5)
+
+    def test_sum(self) -> None:
+        self.assertEqual(self.w.sum, 10.0)
+
+    def test_absolute_sum(self) -> None:
+        w = Waveform1D([-1.0, 2.0, -3.0])
+        self.assertEqual(w.absolute_sum, 6.0)
+
+    def test_rms_matches_sqrt_mean_square(self) -> None:
+        expected = float(np.sqrt(np.mean(np.square([1.0, 2.0, 3.0, 4.0]))))
+        rms = self.w.rms
+        assert rms is not None
+        self.assertAlmostEqual(rms, expected)
+
+    def test_variance_is_population_variance_ddof0_literal(self) -> None:
+        # mean = 2.5; squared deviations: 2.25, 0.25, 0.25, 2.25; population
+        # variance (ddof=0) = 5.0 / 4 = 1.25. This is the pinned choice
+        # (waveformCore.md §Compliance 5) -- ddof=1 (sample variance) would
+        # give 5.0 / 3 = 1.6666... instead.
+        self.assertEqual(self.w.variance, 1.25)
+
+    def test_standard_deviation_is_sqrt_of_population_variance(self) -> None:
+        standard_deviation = self.w.standard_deviation
+        assert standard_deviation is not None
+        self.assertAlmostEqual(standard_deviation, float(np.sqrt(1.25)))
+
+    def test_stats_none_on_empty(self) -> None:
+        empty = Waveform1D([])
+        self.assertIsNone(empty.minimum)
+        self.assertIsNone(empty.maximum)
+        self.assertIsNone(empty.peak_to_peak)
+        self.assertIsNone(empty.mean)
+        self.assertIsNone(empty.rms)
+        self.assertIsNone(empty.standard_deviation)
+        self.assertIsNone(empty.variance)
+        self.assertIsNone(empty.sum)
+        self.assertIsNone(empty.absolute_sum)
+
+
+class TestSpecCompliance3Slicing(unittest.TestCase):
+    """§Compliance 3: slice t0 adjusts by exactly start * dt (attosecond-exact)."""
+
+    def test_slice_t0_shift_is_attosecond_exact(self) -> None:
+        w = Waveform1D([0.0, 1.0, 2.0, 3.0, 4.0, 5.0], dt_seconds=0.1)
+        sliced = w[2:5]
+        self.assertEqual(sliced.t0 - w.t0, w.dt * 2)
+
+    def test_slice_returns_correct_values(self) -> None:
+        w = Waveform1D([0.0, 1.0, 2.0, 3.0, 4.0, 5.0])
+        sliced = w[2:5]
+        self.assertEqual(list(sliced), [2.0, 3.0, 4.0])
+
+    def test_slice_preserves_dt(self) -> None:
+        w = Waveform1D([0.0, 1.0, 2.0, 3.0], dt_seconds=0.25)
+        sliced = w[1:3]
+        self.assertEqual(sliced.dt, w.dt)
+
+    def test_slice_step_not_one_raises(self) -> None:
+        w = Waveform1D([0.0, 1.0, 2.0, 3.0])
+        with self.assertRaises(ValueError):
+            _ = w[0:4:2]
+
+    def test_index_returns_scalar(self) -> None:
+        w = Waveform1D([10.0, 20.0, 30.0])
+        self.assertEqual(w[1], 20.0)
+
+
+class TestSubsetTime(unittest.TestCase):
+    def test_subset_time_with_floats(self) -> None:
+        w = Waveform1D([0.0, 1.0, 2.0, 3.0, 4.0], dt_seconds=1.0)
+        sub = w.subset_time(1.0, 3.0)
+        self.assertEqual(list(sub), [1.0, 2.0])
+
+    def test_subset_time_with_timestamps(self) -> None:
+        w = Waveform1D([0.0, 1.0, 2.0, 3.0, 4.0], dt_seconds=1.0)
+        start = w.t0 + PrecisionTimeInterval.from_seconds(1.0)
+        end = w.t0 + PrecisionTimeInterval.from_seconds(3.0)
+        sub = w.subset_time(start, end)
+        self.assertEqual(list(sub), [1.0, 2.0])
+
+    def test_empty_range_raises(self) -> None:
+        w = Waveform1D([0.0, 1.0, 2.0], dt_seconds=1.0)
+        with self.assertRaises(ValueError):
+            w.subset_time(2.0, 2.0)
+
+    def test_invalid_range_raises(self) -> None:
+        w = Waveform1D([0.0, 1.0, 2.0], dt_seconds=1.0)
+        with self.assertRaises(ValueError):
+            w.subset_time(2.0, 1.0)
+
+    def test_start_before_t0_clamps_to_first_sample(self) -> None:
+        """C-13: a start_time before t0 must clamp rather than raise/skip samples."""
+        w = Waveform1D([0.0, 1.0, 2.0, 3.0, 4.0], dt_seconds=1.0)
+        sub = w.subset_time(-5.0, 2.0)
+        self.assertEqual(list(sub), [0.0, 1.0])
+
+    def test_end_past_span_clamps_to_last_sample(self) -> None:
+        """C-13: an end_time past the waveform's span must clamp to the end."""
+        w = Waveform1D([0.0, 1.0, 2.0, 3.0, 4.0], dt_seconds=1.0)
+        sub = w.subset_time(2.0, 100.0)
+        self.assertEqual(list(sub), [2.0, 3.0, 4.0])
+
+    def test_both_bounds_outside_span_returns_everything(self) -> None:
+        """C-13: both bounds clamp simultaneously."""
+        w = Waveform1D([0.0, 1.0, 2.0, 3.0, 4.0], dt_seconds=1.0)
+        sub = w.subset_time(-100.0, 100.0)
+        self.assertEqual(list(sub), [0.0, 1.0, 2.0, 3.0, 4.0])
+
+
+class TestValueAt(unittest.TestCase):
+    def test_value_at_index_exact_sample(self) -> None:
+        w = Waveform1D([0.0, 10.0, 20.0])
+        self.assertEqual(w.value_at_index(1.0), 10.0)
+
+    def test_value_at_index_interpolates(self) -> None:
+        w = Waveform1D([0.0, 10.0, 20.0])
+        self.assertEqual(w.value_at_index(0.5), 5.0)
+
+    def test_value_at_index_out_of_range_raises(self) -> None:
+        w = Waveform1D([0.0, 10.0, 20.0])
+        with self.assertRaises(ValueError):
+            w.value_at_index(-0.1)
+        with self.assertRaises(ValueError):
+            w.value_at_index(2.1)
+
+    def test_value_at_index_empty_raises(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(ValueError):
+            w.value_at_index(0.0)
+
+    def test_spec_compliance_6_midpoint_returns_average(self) -> None:
+        """§Compliance 6: value_at_time midpoint between two samples returns their average."""
+        w = Waveform1D([0.0, 10.0], dt_seconds=1.0)
+        self.assertEqual(w.value_at_time(0.5), 5.0)
+
+    def test_value_at_time_exact_sample(self) -> None:
+        w = Waveform1D([0.0, 10.0, 20.0], dt_seconds=2.0)
+        self.assertEqual(w.value_at_time(2.0), 10.0)
+
+    def test_value_at_time_out_of_range_raises(self) -> None:
+        w = Waveform1D([0.0, 10.0], dt_seconds=1.0)
+        with self.assertRaises(ValueError):
+            w.value_at_time(5.0)
+
+    def test_value_at_time_with_timestamp(self) -> None:
+        w = Waveform1D([0.0, 10.0], dt_seconds=1.0)
+        t = w.t0 + PrecisionTimeInterval.from_seconds(0.5)
+        self.assertEqual(w.value_at_time(t), 5.0)
+
+
+class TestSpecCompliance7Mutation(unittest.TestCase):
+    """§Compliance 7: mutation verbs match stdlib list semantics."""
+
+    def test_append(self) -> None:
+        w = Waveform1D([1.0, 2.0])
+        w.append(3.0)
+        self.assertEqual(list(w), [1.0, 2.0, 3.0])
+
+    def test_append_values(self) -> None:
+        w = Waveform1D([1.0])
+        w.append_values([2.0, 3.0])
+        self.assertEqual(list(w), [1.0, 2.0, 3.0])
+
+    def test_prepend_shifts_t0_back_by_one_dt(self) -> None:
+        w = Waveform1D([2.0, 3.0], dt_seconds=1.0)
+        original_t0 = w.t0
+        w.prepend(1.0)
+        self.assertEqual(list(w), [1.0, 2.0, 3.0])
+        self.assertEqual(original_t0 - w.t0, w.dt)
+
+    def test_prepend_values_shifts_t0_back_by_k_dt(self) -> None:
+        w = Waveform1D([3.0, 4.0], dt_seconds=1.0)
+        original_t0 = w.t0
+        w.prepend_values([1.0, 2.0])
+        self.assertEqual(list(w), [1.0, 2.0, 3.0, 4.0])
+        self.assertEqual(original_t0 - w.t0, w.dt * 2)
+
+    def test_insert(self) -> None:
+        w = Waveform1D([1.0, 3.0])
+        w.insert(1, 2.0)
+        self.assertEqual(list(w), [1.0, 2.0, 3.0])
+
+    def test_replace(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        w.replace(1, 99.0)
+        self.assertEqual(list(w), [1.0, 99.0, 3.0])
+
+    def test_replace_range(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0])
+        w.replace_range(slice(1, 3), [8.0, 9.0])
+        self.assertEqual(list(w), [1.0, 8.0, 9.0, 4.0])
+
+    def test_replace_range_longer_replacement_raises_value_error(self) -> None:
+        """C-12: waveformCore.md §Compliance 7 says mutation verbs match
+        stdlib list semantics, but the storage is numpy, not a Python list.
+        A Python list slice-assignment resizes silently
+        (``[1,2,3,4][1:3] = [8,9,10]`` -> ``[1,8,9,10,4]``); this numpy-backed
+        implementation instead requires the replacement to broadcast onto the
+        slice's length, raising ``ValueError`` when it cannot -- pinned here
+        as the actual (numpy, not stdlib-list) semantics."""
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0])
+        with self.assertRaises(ValueError):
+            w.replace_range(slice(1, 3), [8.0, 9.0, 10.0])
+
+    def test_replace_range_single_element_broadcasts_not_shrinks(self) -> None:
+        """C-12: a single-element replacement *broadcasts* across the slice
+        (numpy assignment semantics) rather than shrinking the waveform the
+        way ``[1,2,3,4][1:3] = [8]`` (-> ``[1,8,4]``) would under stdlib list
+        semantics."""
+        w = Waveform1D([1.0, 2.0, 3.0, 4.0])
+        w.replace_range(slice(1, 3), [8.0])
+        self.assertEqual(list(w), [1.0, 8.0, 8.0, 4.0])
+
+    def test_pop_default_removes_last(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        value = w.pop()
+        self.assertEqual(value, 3.0)
+        self.assertEqual(list(w), [1.0, 2.0])
+
+    def test_pop_with_index(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        value = w.pop(0)
+        self.assertEqual(value, 1.0)
+        self.assertEqual(list(w), [2.0, 3.0])
+
+    def test_pop_on_empty_raises_index_error(self) -> None:
+        w = Waveform1D([])
+        with self.assertRaises(IndexError):
+            w.pop()
+
+    def test_pop_out_of_range_raises_index_error(self) -> None:
+        w = Waveform1D([1.0, 2.0])
+        with self.assertRaises(IndexError):
+            w.pop(5)
+
+    def test_clear_empties(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        w.clear()
+        self.assertEqual(list(w), [])
+        self.assertEqual(len(w), 0)
+
+    def test_append_float_onto_integer_waveform_truncates_to_dtype(self) -> None:
+        """C-6: ``append``/``insert`` cast the new value to the storage
+        dtype (numpy's ``np.asarray(value, dtype=...)`` semantics), so
+        appending a float onto an int waveform silently truncates. Pinning
+        the current (confirmed intentional) behavior, not a defect: mutation
+        verbs preserve dtype exactly, unlike the in-place arithmetic
+        operators (see TestInPlaceOperatorDtypePromotion in
+        test_waveform1d_operators.py) which promote it."""
+        w = Waveform1D(np.array([1, 2, 3], dtype=np.int64))
+        w.append(9.7)
+        self.assertEqual(w.values.dtype, np.int64)
+        self.assertEqual(list(w), [1, 2, 3, 9])
+
+    def test_insert_float_onto_integer_waveform_truncates_to_dtype(self) -> None:
+        w = Waveform1D(np.array([1, 2, 3], dtype=np.int64))
+        w.insert(1, 9.7)
+        self.assertEqual(w.values.dtype, np.int64)
+        self.assertEqual(list(w), [1, 9, 2, 3])
+
+
+class TestSpecCompliance10VectorizedBulkOps(unittest.TestCase):
+    """§Compliance 10: bulk ops never construct per-element objects;
+    smoke-test at 1e6 samples, guarding the vectorized design."""
+
+    def test_arithmetic_and_stats_smoke_test_large_n(self) -> None:
+        n = 1_000_000
+        rng = np.random.default_rng(0)
+        w = Waveform1D(rng.standard_normal(n), dt_seconds=0.001)
+        start = time.monotonic()
+        result = (w + 1.0) * 2.0
+        _ = result.mean
+        _ = result.rms
+        elapsed = time.monotonic() - start
+        self.assertLess(elapsed, 5.0)
+        self.assertEqual(len(result), n)
+
+
+class TestEquality(unittest.TestCase):
+    def test_equal_samples_dt_t0(self) -> None:
+        w1 = Waveform1D([1.0, 2.0], dt_seconds=0.5, t0_seconds=1.0)
+        w2 = Waveform1D([1.0, 2.0], dt_seconds=0.5, t0_seconds=1.0)
+        self.assertEqual(w1, w2)
+
+    def test_unequal_samples(self) -> None:
+        w1 = Waveform1D([1.0, 2.0])
+        w2 = Waveform1D([1.0, 3.0])
+        self.assertNotEqual(w1, w2)
+
+    def test_unequal_dt(self) -> None:
+        w1 = Waveform1D([1.0, 2.0], dt_seconds=0.5)
+        w2 = Waveform1D([1.0, 2.0], dt_seconds=1.0)
+        self.assertNotEqual(w1, w2)
+
+    def test_unequal_t0(self) -> None:
+        w1 = Waveform1D([1.0, 2.0], t0_seconds=0.0)
+        w2 = Waveform1D([1.0, 2.0], t0_seconds=1.0)
+        self.assertNotEqual(w1, w2)
+
+    def test_not_equal_to_other_type(self) -> None:
+        w = Waveform1D([1.0, 2.0])
+        self.assertNotEqual(w, "not a waveform")
+
+    def test_unhashable(self) -> None:
+        w = Waveform1D([1.0, 2.0])
+        with self.assertRaises(TypeError):
+            hash(w)
+
+
+class TestRepr(unittest.TestCase):
+    def test_repr_contains_sample_count(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        self.assertIn("3", repr(w))
+        self.assertIn("Waveform1D", repr(w))
+
+
+class TestGenerators(unittest.TestCase):
+    def test_sine_matches_np_sin(self) -> None:
+        w = Waveform1D.sine(n=100, frequency=5.0, dt_seconds=0.001)
+        t = np.arange(100) * 0.001
+        expected = np.sin(2.0 * np.pi * 5.0 * t)
+        np.testing.assert_allclose(w.values, expected, atol=1e-12)
+
+    def test_cosine_matches_np_cos(self) -> None:
+        w = Waveform1D.cosine(n=50, frequency=2.0, dt_seconds=0.01)
+        t = np.arange(50) * 0.01
+        expected = np.cos(2.0 * np.pi * 2.0 * t)
+        np.testing.assert_allclose(w.values, expected, atol=1e-12)
+
+    def test_white_noise_seeded_is_reproducible(self) -> None:
+        w1 = Waveform1D.white_noise(n=20, seed=42)
+        w2 = Waveform1D.white_noise(n=20, seed=42)
+        np.testing.assert_array_equal(w1.values, w2.values)
+
+    def test_white_noise_different_seeds_differ(self) -> None:
+        w1 = Waveform1D.white_noise(n=20, seed=1)
+        w2 = Waveform1D.white_noise(n=20, seed=2)
+        self.assertFalse(np.array_equal(w1.values, w2.values))
+
+    def test_impulse_sums_to_amplitude(self) -> None:
+        w = Waveform1D.impulse(n=10, amplitude=3.0, impulse_index=4)
+        self.assertEqual(float(np.sum(w.values)), 3.0)
+        self.assertEqual(w.values[4], 3.0)
+
+    def test_constant(self) -> None:
+        w = Waveform1D.constant(n=5, value=7.0)
+        np.testing.assert_array_equal(w.values, np.full(5, 7.0))
+
+    def test_linear_ramp(self) -> None:
+        w = Waveform1D.linear_ramp(n=5, start_value=0.0, end_value=4.0)
+        np.testing.assert_allclose(w.values, [0.0, 1.0, 2.0, 3.0, 4.0])
+
+    def test_linear_ramp_single_sample_uses_start_value(self) -> None:
+        w = Waveform1D.linear_ramp(n=1, start_value=2.0, end_value=8.0)
+        np.testing.assert_allclose(w.values, [2.0])
+
+    def test_polynomial_horner(self) -> None:
+        # 1 + 2t + 3t^2, dt=1.0 -> t = [0, 1, 2]
+        w = Waveform1D.polynomial(n=3, coefficients=[1.0, 2.0, 3.0], dt_seconds=1.0)
+        np.testing.assert_allclose(w.values, [1.0, 6.0, 17.0])
+
+    def test_polynomial_empty_coefficients_is_zero(self) -> None:
+        w = Waveform1D.polynomial(n=4, coefficients=[])
+        np.testing.assert_allclose(w.values, [0.0, 0.0, 0.0, 0.0])
+
+    def test_square_bipolar(self) -> None:
+        w = Waveform1D.square(n=4, frequency=0.25, dt_seconds=1.0)
+        for value in w.values:
+            self.assertIn(value, (1.0, -1.0))
+
+    def test_counter_integer_dtype(self) -> None:
+        w = Waveform1D.counter(n=5, start_value=0, increment=2)
+        np.testing.assert_array_equal(w.values, [0, 2, 4, 6, 8])
+        self.assertTrue(np.issubdtype(w.values.dtype, np.integer))
+
+    def test_digital_square_two_levels(self) -> None:
+        w = Waveform1D.digital_square(
+            n=8, frequency=0.25, high_value=5, low_value=-5, dt_seconds=1.0
+        )
+        for value in w.values:
+            self.assertIn(value, (5, -5))
+
+    def test_exponential_decay(self) -> None:
+        w = Waveform1D.exponential_decay(n=3, time_constant=1.0, dt_seconds=1.0)
+        expected = np.exp(-np.arange(3))
+        np.testing.assert_allclose(w.values, expected)
+
+    def test_exponential_growth(self) -> None:
+        w = Waveform1D.exponential_growth(n=3, time_constant=1.0, dt_seconds=1.0)
+        expected = np.exp(np.arange(3))
+        np.testing.assert_allclose(w.values, expected)
+
+    def test_generator_time_kwargs_pass_through(self) -> None:
+        t0 = PrecisionTimestamp.EPOCH + PrecisionTimeInterval.from_seconds(100.0)
+        w = Waveform1D.sine(n=10, frequency=1.0, dt=PrecisionTimeInterval.from_seconds(0.5), t0=t0)
+        self.assertEqual(w.dt, PrecisionTimeInterval.from_seconds(0.5))
+        self.assertEqual(w.t0, t0)
+
+    def test_damped_sinusoid_decays(self) -> None:
+        w = Waveform1D.damped_sinusoid(
+            n=1000, frequency=1.0, damping_constant=0.1, dt_seconds=0.001
+        )
+        # Envelope decays -- later peak magnitude much smaller than earlier one.
+        self.assertLess(abs(w.values[-1]), abs(w.values[10]))
+
+    def test_heaviside_step(self) -> None:
+        w = Waveform1D.heaviside(n=10, amplitude=1.0, step_time=5.0, dt_seconds=1.0)
+        np.testing.assert_array_equal(w.values[:5], [0.0] * 5)
+        np.testing.assert_array_equal(w.values[5:], [1.0] * 5)
+
+    def test_relu(self) -> None:
+        w = Waveform1D.relu(n=5, threshold=2.0, dt_seconds=1.0)
+        np.testing.assert_allclose(w.values, [0.0, 0.0, 0.0, 1.0, 2.0])
+
+    def test_sigmoid_bounded(self) -> None:
+        w = Waveform1D.sigmoid(n=100, dt_seconds=0.1)
+        self.assertTrue(np.all(w.values > 0.0))
+        self.assertTrue(np.all(w.values < 1.0))
+
+    def test_logarithm_and_logarithm10(self) -> None:
+        w1 = Waveform1D.logarithm(n=5, offset=1.0, dt_seconds=1.0)
+        w2 = Waveform1D.logarithm10(n=5, offset=1.0, dt_seconds=1.0)
+        t = np.arange(5) + 1.0
+        np.testing.assert_allclose(w1.values, np.log(t))
+        np.testing.assert_allclose(w2.values, np.log10(t))
+
+    def test_square_root(self) -> None:
+        w = Waveform1D.square_root(n=5, dt_seconds=1.0)
+        np.testing.assert_allclose(w.values, np.sqrt(np.arange(5, dtype=np.float64)))
+
+    def test_sawtooth_and_triangle_ranges(self) -> None:
+        saw = Waveform1D.sawtooth(n=100, frequency=1.0, dt_seconds=0.01)
+        tri = Waveform1D.triangle(n=100, frequency=1.0, dt_seconds=0.01)
+        self.assertTrue(np.all(saw.values >= -1.0 - 1e-9))
+        self.assertTrue(np.all(saw.values <= 1.0 + 1e-9))
+        self.assertTrue(np.all(tri.values >= -1.0 - 1e-9))
+        self.assertTrue(np.all(tri.values <= 1.0 + 1e-9))
+
+    def test_chirp_sweeps_frequency(self) -> None:
+        w = Waveform1D.chirp(n=1000, start_frequency=1.0, end_frequency=10.0, dt_seconds=0.001)
+        self.assertEqual(len(w), 1000)
+        self.assertTrue(np.all(np.abs(w.values) <= 1.0 + 1e-9))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/test_waveform1d_generators.py b/tests/waveforms/test_waveform1d_generators.py
new file mode 100644
index 0000000..a7b422b
--- /dev/null
+++ b/tests/waveforms/test_waveform1d_generators.py
@@ -0,0 +1,308 @@
+"""Dedicated compliance tests for the ``Waveform1D`` signal generators.
+
+Covers waveformCore.md §Waveform1D Constructors (generators) and §Compliance
+4. The generators themselves were implemented as part of chunk 11 (the
+umbrella spec groups them under "Constructors"); chunk 11's own test suite
+(``test_waveform1d_core.py::TestGenerators``) already exercises every
+generator's shape. This file supplies the specific named compliance-4
+checks the chunk plan calls for (sine vs. ``np.sin``, seeded white-noise
+reproducibility/divergence, impulse summation, chirp instantaneous-frequency
+endpoints) plus the no-time-args / no-frequency-arg construction pinned by
+this chunk's own acceptance criteria, rather than duplicating chunk 11's
+broader shape coverage.
+"""
+
+from __future__ import annotations
+
+import unittest
+
+import numpy as np
+
+from math_tools.waveforms import Waveform1D
+
+_ALL_GENERATOR_NAMES = [
+    "sine",
+    "cosine",
+    "square",
+    "triangle",
+    "sawtooth",
+    "chirp",
+    "exponential_decay",
+    "exponential_growth",
+    "polynomial",
+    "linear_ramp",
+    "logarithm",
+    "logarithm10",
+    "square_root",
+    "heaviside",
+    "relu",
+    "sigmoid",
+    "white_noise",
+    "constant",
+    "impulse",
+    "damped_sinusoid",
+    "counter",
+    "digital_square",
+]
+
+
+class TestAllGeneratorsExist(unittest.TestCase):
+    def test_all_21_plus_generators_are_classmethods(self) -> None:
+        for name in _ALL_GENERATOR_NAMES:
+            self.assertTrue(hasattr(Waveform1D, name), f"missing generator: {name}")
+            self.assertTrue(callable(getattr(Waveform1D, name)))
+        self.assertGreaterEqual(len(_ALL_GENERATOR_NAMES), 21)
+
+
+class TestSineNoTimeArgs(unittest.TestCase):
+    def test_sine_n_only_constructs_with_dt_one_second(self) -> None:
+        """waveformCore.md §Time axis / this chunk's acceptance criteria pin
+        ``Waveform1D.sine(n=1000)`` as legal with no other arguments."""
+        w = Waveform1D.sine(n=1000)
+        self.assertEqual(len(w), 1000)
+        self.assertEqual(w.dt.seconds_as_float, 1.0)
+
+
+class TestComplianceFourSine(unittest.TestCase):
+    def test_sine_matches_np_sin_on_time_axis(self) -> None:
+        w = Waveform1D.sine(n=200, frequency=3.0, amplitude=2.0, dt_seconds=0.005)
+        t = w.time_axis()
+        expected = 2.0 * np.sin(2.0 * np.pi * 3.0 * t)
+        np.testing.assert_allclose(w.values, expected, atol=1e-12)
+
+
+class TestComplianceFourWhiteNoise(unittest.TestCase):
+    def test_seeded_white_noise_is_reproducible(self) -> None:
+        a = Waveform1D.white_noise(n=50, seed=7)
+        b = Waveform1D.white_noise(n=50, seed=7)
+        np.testing.assert_array_equal(a.values, b.values)
+
+    def test_white_noise_k_plus_one_seed_differs(self) -> None:
+        a = Waveform1D.white_noise(n=50, seed=7)
+        b = Waveform1D.white_noise(n=50, seed=8)
+        self.assertFalse(np.array_equal(a.values, b.values))
+
+
+class TestComplianceFourImpulse(unittest.TestCase):
+    def test_impulse_sums_to_one_sample_of_amplitude(self) -> None:
+        w = Waveform1D.impulse(n=20, amplitude=4.5, impulse_index=3)
+        self.assertAlmostEqual(float(np.sum(w.values)), 4.5)
+        nonzero = np.flatnonzero(w.values)
+        self.assertEqual(len(nonzero), 1)
+        self.assertEqual(nonzero[0], 3)
+
+
+class TestComplianceFourCounter(unittest.TestCase):
+    def test_counter_is_arange_based(self) -> None:
+        w = Waveform1D.counter(n=6, start_value=10, increment=3)
+        np.testing.assert_array_equal(w.values, 10 + 3 * np.arange(6))
+
+
+class TestComplianceFourChirp(unittest.TestCase):
+    def test_chirp_instantaneous_frequency_endpoints(self) -> None:
+        """Coarse check via zero-crossing counts in the first vs. last quarter:
+        a chirp sweeping low-to-high frequency should cross zero far more
+        often in its last quarter than its first."""
+        n = 4000
+        w = Waveform1D.chirp(n=n, start_frequency=1.0, end_frequency=50.0, dt_seconds=0.001)
+        values = w.values
+        quarter = n // 4
+
+        def zero_crossings(segment: np.typing.NDArray[np.float64]) -> int:
+            return int(np.sum(np.diff(np.sign(segment)) != 0))
+
+        first_quarter_crossings = zero_crossings(values[:quarter])
+        last_quarter_crossings = zero_crossings(values[-quarter:])
+        self.assertGreater(last_quarter_crossings, first_quarter_crossings)
+
+
+class TestGeneratorSpanConvention(unittest.TestCase):
+    """waveformCore.md's generator span convention: for an ``n``-sample
+    waveform, the span is ``(n-1)*dt`` (endpoint-inclusive), not ``n*dt``.
+    Pins chunk 51 / post-audit finding C-15."""
+
+    def test_heaviside_default_step_time_is_midpoint_of_sample_span(self) -> None:
+        """``n=5``, ``dt=1s`` -> true span ``[0, 4]``, midpoint ``t=2`` lands
+        exactly on sample index 2. The buggy ``n*dt/2 = 2.5`` convention
+        would instead step at index 3: ``[0, 0, 0, 1, 1]``."""
+        w = Waveform1D.heaviside(n=5, dt_seconds=1.0)
+        np.testing.assert_array_equal(w.values, [0.0, 0.0, 1.0, 1.0, 1.0])
+
+    def test_sigmoid_default_center_is_midpoint_of_sample_span(self) -> None:
+        """Same ``n=5`` span; a logistic sigmoid centered exactly on a sample
+        evaluates to ``0.5`` there. The buggy ``n*dt/2 = 2.5`` convention
+        would put the center between samples 2 and 3, so sample 2 would not
+        be ``0.5``."""
+        w = Waveform1D.sigmoid(n=5, dt_seconds=1.0)
+        self.assertAlmostEqual(w.values[2], 0.5, places=12)
+
+    def test_chirp_final_sample_instantaneous_frequency_equals_end_frequency(self) -> None:
+        """Recover the chirp's realized sweep rate from its own zero
+        crossings (interpolated crossing times fit against the quadratic
+        phase model ``k/2 = start*t + 0.5*sr*t**2``, with the crossing
+        order used as a linear proxy for ``k`` -- valid since the swept
+        frequency stays positive and monotonic throughout, so no crossing is
+        missed or duplicated) and check the resulting final-sample
+        instantaneous frequency against ``end_frequency``. This is a real
+        measurement of the generated samples, not a re-derivation of the
+        generator's own formula: under the pre-fix ``n*dt`` span convention
+        the realized sweep rate is measurably slower, so the recovered final
+        frequency undershoots ``end_frequency`` by ``(end-start)/n``.
+        """
+        n = 201
+        dt_seconds = 0.001
+        start_frequency = 5.0
+        end_frequency = 50.0
+        w = Waveform1D.chirp(
+            n=n,
+            start_frequency=start_frequency,
+            end_frequency=end_frequency,
+            dt_seconds=dt_seconds,
+        )
+        t = w.time_axis()
+        values = w.values
+
+        signs = np.sign(values)
+        crossing_indices = np.flatnonzero(np.diff(signs) != 0)
+        t0s = t[crossing_indices]
+        t1s = t[crossing_indices + 1]
+        v0s = values[crossing_indices]
+        v1s = values[crossing_indices + 1]
+        crossing_times = t0s + (0.0 - v0s) * (t1s - t0s) / (v1s - v0s)
+        self.assertGreater(
+            len(crossing_times), 4, "need several zero crossings to fit the sweep rate"
+        )
+
+        order = np.arange(len(crossing_times), dtype=np.float64)
+        y = order / 2.0 - start_frequency * crossing_times
+        x = crossing_times * crossing_times
+        slope, _intercept = np.polyfit(x, y, 1)
+        measured_sweep_rate = 2.0 * slope
+
+        measured_final_frequency = start_frequency + measured_sweep_rate * t[-1]
+        self.assertAlmostEqual(measured_final_frequency, end_frequency, delta=0.05)
+
+    def test_generators_with_n_equals_one_do_not_raise(self) -> None:
+        """``n=1`` is a zero-length span; none of the three affected
+        generators should divide by zero or otherwise raise."""
+        heaviside = Waveform1D.heaviside(n=1, dt_seconds=1.0)
+        sigmoid = Waveform1D.sigmoid(n=1, dt_seconds=1.0)
+        chirp = Waveform1D.chirp(n=1, start_frequency=1.0, end_frequency=10.0, dt_seconds=1.0)
+
+        self.assertEqual(len(heaviside), 1)
+        self.assertEqual(len(sigmoid), 1)
+        self.assertEqual(len(chirp), 1)
+        self.assertAlmostEqual(sigmoid.values[0], 0.5, places=12)
+
+
+class TestComplianceFourSquareDutyCycle(unittest.TestCase):
+    """C-9: ``square``'s ``duty_cycle`` was never exercised beyond its default."""
+
+    def test_quarter_duty_cycle_matches_analytic_phase_split(self) -> None:
+        # period = 1 s (frequency=1), 8 samples/period -> duty=0.25 keeps the
+        # first 2 of every 8 samples at +amplitude.
+        w = Waveform1D.square(n=8, frequency=1.0, amplitude=3.0, duty_cycle=0.25, dt_seconds=0.125)
+        expected = np.array([3.0, 3.0, -3.0, -3.0, -3.0, -3.0, -3.0, -3.0])
+        np.testing.assert_array_equal(w.values, expected)
+
+
+class TestComplianceFourDigitalSquareDutyCycle(unittest.TestCase):
+    """C-9: ``digital_square``'s ``duty_cycle`` was never exercised."""
+
+    def test_quarter_duty_cycle_matches_analytic_phase_split(self) -> None:
+        w = Waveform1D.digital_square(
+            n=8, frequency=1.0, high_value=5.0, low_value=1.0, duty_cycle=0.25, dt_seconds=0.125
+        )
+        expected = np.array([5.0, 5.0, 1.0, 1.0, 1.0, 1.0, 1.0, 1.0])
+        np.testing.assert_array_equal(w.values, expected)
+
+
+class TestComplianceFourSawtooth(unittest.TestCase):
+    """C-9: ``sawtooth`` was only range-checked, never value-pinned."""
+
+    def test_matches_analytic_ramp(self) -> None:
+        w = Waveform1D.sawtooth(n=4, frequency=1.0, amplitude=2.0, dt_seconds=0.25)
+        expected = np.array([-2.0, -1.0, 0.0, 1.0])
+        np.testing.assert_allclose(w.values, expected, atol=1e-12)
+
+
+class TestComplianceFourTriangle(unittest.TestCase):
+    """C-9: ``triangle`` was only range-checked, never value-pinned."""
+
+    def test_matches_analytic_triangle(self) -> None:
+        w = Waveform1D.triangle(n=4, frequency=1.0, amplitude=2.0, dt_seconds=0.25)
+        expected = np.array([-2.0, 0.0, 2.0, 0.0])
+        np.testing.assert_allclose(w.values, expected, atol=1e-12)
+
+
+class TestComplianceFourHeavisideStepTime(unittest.TestCase):
+    """C-9: the explicit (non-default) ``step_time`` argument was never pinned."""
+
+    def test_explicit_step_time_overrides_default_midpoint(self) -> None:
+        w = Waveform1D.heaviside(n=5, amplitude=2.0, step_time=1.0, dt_seconds=1.0)
+        np.testing.assert_array_equal(w.values, [0.0, 2.0, 2.0, 2.0, 2.0])
+
+
+class TestComplianceFourSigmoid(unittest.TestCase):
+    """C-9: ``center``/``steepness`` were never exercised beyond the default center."""
+
+    def test_explicit_center_and_steepness_match_logistic_formula(self) -> None:
+        n, dt_seconds, amplitude, steepness, center = 6, 0.5, 4.0, 2.0, 1.0
+        w = Waveform1D.sigmoid(
+            n=n, amplitude=amplitude, steepness=steepness, center=center, dt_seconds=dt_seconds
+        )
+        t = np.arange(n) * dt_seconds
+        expected = amplitude / (1.0 + np.exp(-steepness * (t - center)))
+        np.testing.assert_allclose(w.values, expected, atol=1e-12)
+        self.assertAlmostEqual(float(w.value_at_time(center)), amplitude / 2.0, places=9)
+
+
+class TestComplianceFourRelu(unittest.TestCase):
+    """C-9: ``slope`` was never exercised beyond the default of 1.0."""
+
+    def test_slope_and_threshold_match_analytic_ramp(self) -> None:
+        w = Waveform1D.relu(n=5, slope=3.0, threshold=1.0, dt_seconds=1.0)
+        # t = [0, 1, 2, 3, 4]; x = t - 1 = [-1, 0, 1, 2, 3]; relu(x) * slope
+        expected = np.array([0.0, 0.0, 3.0, 6.0, 9.0])
+        np.testing.assert_allclose(w.values, expected, atol=1e-12)
+
+
+class TestComplianceFourWhiteNoiseAmplitude(unittest.TestCase):
+    """C-9: ``amplitude`` was never pinned -- only shape/seed reproducibility."""
+
+    def test_amplitude_scales_the_seeded_generator_output(self) -> None:
+        seed = 42
+        unit = Waveform1D.white_noise(n=32, amplitude=1.0, seed=seed)
+        scaled = Waveform1D.white_noise(n=32, amplitude=5.0, seed=seed)
+        np.testing.assert_allclose(scaled.values, 5.0 * unit.values, atol=1e-12)
+
+    def test_matches_scaled_rng_reference(self) -> None:
+        seed, amplitude, n = 11, 2.5, 16
+        w = Waveform1D.white_noise(n=n, amplitude=amplitude, seed=seed)
+        reference = amplitude * np.random.default_rng(seed).standard_normal(n)
+        np.testing.assert_allclose(w.values, reference, atol=1e-12)
+
+
+class TestComplianceFourDampedSinusoid(unittest.TestCase):
+    """C-9: the damped sinusoid's analytic form (envelope x oscillation) was
+    never pinned."""
+
+    def test_matches_analytic_envelope_times_sinusoid(self) -> None:
+        n, dt_seconds = 50, 0.01
+        frequency, damping_constant, amplitude, phase = 3.0, 0.2, 2.0, 0.3
+        w = Waveform1D.damped_sinusoid(
+            n=n,
+            frequency=frequency,
+            damping_constant=damping_constant,
+            amplitude=amplitude,
+            phase=phase,
+            dt_seconds=dt_seconds,
+        )
+        t = np.arange(n) * dt_seconds
+        envelope = np.exp(-t / damping_constant)
+        expected = amplitude * envelope * np.sin(2.0 * np.pi * frequency * t + phase)
+        np.testing.assert_allclose(w.values, expected, atol=1e-12)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/test_waveform1d_operators.py b/tests/waveforms/test_waveform1d_operators.py
new file mode 100644
index 0000000..fecb2e0
--- /dev/null
+++ b/tests/waveforms/test_waveform1d_operators.py
@@ -0,0 +1,400 @@
+"""Unit tests for ``Waveform1D`` operators (arithmetic, bitwise, comparison).
+
+Covers waveformCore.md §Waveform1D Operators and §Compliance requirement 2
+(dt/length mismatch -> ``WaveformCompatibilityError``).
+"""
+
+import unittest
+
+import numpy as np
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.precision_time.precision_timestamp import PrecisionTimestamp
+from math_tools.waveforms.waveform1d import Waveform1D
+
+
+class TestSpecCompliance2Compatibility(unittest.TestCase):
+    """§Compliance 2: dt/length mismatch on a binary op raises WaveformCompatibilityError."""
+
+    def test_dt_mismatch_raises(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0], dt_seconds=1.0)
+        b = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.5)
+        with self.assertRaises(WaveformCompatibilityError):
+            a + b
+
+    def test_length_mismatch_raises(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0], dt_seconds=1.0)
+        b = Waveform1D([1.0, 2.0], dt_seconds=1.0)
+        with self.assertRaises(WaveformCompatibilityError):
+            a + b
+
+    def test_equal_dt_and_length_path_is_exact(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0], dt_seconds=1.0)
+        b = Waveform1D([10.0, 20.0, 30.0], dt_seconds=1.0)
+        result = a + b
+        np.testing.assert_array_equal(result.values, np.array([11.0, 22.0, 33.0]))
+
+    def test_dt_mismatch_raises_for_all_binary_ops(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0], dt_seconds=1.0)
+        b = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.5)
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = a - b
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = a * b
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = a / b
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = a // b
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = a % b
+
+    def test_length_mismatch_raises_for_all_binary_ops(self) -> None:
+        """C-8: length-mismatch was previously pinned only for ``+``."""
+        a = Waveform1D([1.0, 2.0, 3.0], dt_seconds=1.0)
+        b = Waveform1D([1.0, 2.0], dt_seconds=1.0)
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = a - b
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = a * b
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = a / b
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = a // b
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = a % b
+        ai = Waveform1D(np.array([1, 2, 3], dtype=np.int64), dt_seconds=1.0)
+        bi = Waveform1D(np.array([1, 2], dtype=np.int64), dt_seconds=1.0)
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = ai & bi
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = ai | bi
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = ai ^ bi
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = ai << bi
+        with self.assertRaises(WaveformCompatibilityError):
+            _ = ai >> bi
+
+
+class TestScalarBothOrders(unittest.TestCase):
+    def test_waveform_plus_scalar(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        result = w + 1.0
+        np.testing.assert_array_equal(result.values, np.array([2.0, 3.0, 4.0]))
+
+    def test_scalar_plus_waveform(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        result = 1.0 + w
+        np.testing.assert_array_equal(result.values, np.array([2.0, 3.0, 4.0]))
+
+    def test_waveform_minus_scalar(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        result = w - 1.0
+        np.testing.assert_array_equal(result.values, np.array([0.0, 1.0, 2.0]))
+
+    def test_scalar_minus_waveform_is_reflected_not_forward(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        result = 10.0 - w
+        np.testing.assert_array_equal(result.values, np.array([9.0, 8.0, 7.0]))
+
+    def test_waveform_times_scalar_and_reflected(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        np.testing.assert_array_equal((w * 2.0).values, np.array([2.0, 4.0, 6.0]))
+        np.testing.assert_array_equal((2.0 * w).values, np.array([2.0, 4.0, 6.0]))
+
+    def test_result_carries_dt_and_t0_from_left_operand(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0], dt_seconds=2.0, t0_seconds=5.0)
+        result = w + 1.0
+        self.assertEqual(result.t0, w.t0)
+        self.assertEqual(result.dt, w.dt)
+        self.assertIsNot(result, w)
+
+    def test_foreign_type_returns_not_implemented_and_raises_type_error(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        with self.assertRaises(TypeError):
+            _ = w + "not a number"
+
+    def test_foreign_type_dunder_returns_not_implemented_directly(self) -> None:
+        """C-8: NotImplemented was previously only observed indirectly via the
+        resulting TypeError; call the dunder directly to pin the sentinel."""
+        w = Waveform1D([1.0, 2.0, 3.0])
+        self.assertIs(w.__add__("not a number"), NotImplemented)
+        self.assertIs(w.__radd__("not a number"), NotImplemented)
+        self.assertIs(w.__mul__(object()), NotImplemented)
+        self.assertIs(w.__and__("not a number"), NotImplemented)
+
+    def test_reflected_truediv(self) -> None:
+        w = Waveform1D([1.0, 2.0, 4.0])
+        result = 8.0 / w
+        np.testing.assert_array_equal(result.values, np.array([8.0, 4.0, 2.0]))
+
+    def test_reflected_floordiv(self) -> None:
+        w = Waveform1D(np.array([2, 3, 4], dtype=np.int64))
+        result = 10 // w
+        np.testing.assert_array_equal(result.values, np.array([5, 3, 2]))
+
+    def test_reflected_mod(self) -> None:
+        w = Waveform1D(np.array([3, 4, 5], dtype=np.int64))
+        result = 10 % w
+        np.testing.assert_array_equal(result.values, np.array([1, 2, 0]))
+
+    def test_numpy_scalar_reflected_add_returns_waveform_not_bare_ndarray(self) -> None:
+        # Regression guard: without __array_ufunc__ = None, numpy's ufunc
+        # machinery unwraps `w` via __array__ before Python's operator
+        # protocol gets a chance to call w.__radd__, silently discarding
+        # dt/t0 and returning a bare ndarray instead of a Waveform1D.
+        w = Waveform1D([1.0, 2.0, 3.0], dt_seconds=2.0, t0_seconds=5.0)
+        result = np.float64(2.0) + w
+        self.assertIsInstance(result, Waveform1D)
+        self.assertEqual(result.t0, w.t0)
+        self.assertEqual(result.dt, w.dt)
+        np.testing.assert_array_equal(result.values, np.array([3.0, 4.0, 5.0]))
+
+
+class TestInPlaceOperators(unittest.TestCase):
+    def test_iadd_mutates_and_returns_same_object(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        x = w
+        w += 1.0
+        self.assertIs(w, x)
+        np.testing.assert_array_equal(w.values, np.array([2.0, 3.0, 4.0]))
+
+    def test_isub_mutates_in_place(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        x = w
+        w -= 1.0
+        self.assertIs(w, x)
+        np.testing.assert_array_equal(w.values, np.array([0.0, 1.0, 2.0]))
+
+    def test_imul_mutates_in_place(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        x = w
+        w *= 2.0
+        self.assertIs(w, x)
+        np.testing.assert_array_equal(w.values, np.array([2.0, 4.0, 6.0]))
+
+    def test_itruediv_mutates_in_place(self) -> None:
+        w = Waveform1D([2.0, 4.0, 6.0])
+        x = w
+        w /= 2.0
+        self.assertIs(w, x)
+        np.testing.assert_array_equal(w.values, np.array([1.0, 2.0, 3.0]))
+
+    def test_ifloordiv_mutates_in_place(self) -> None:
+        w = Waveform1D(np.array([7, 8, 9], dtype=np.int64))
+        x = w
+        w //= 2
+        self.assertIs(w, x)
+        np.testing.assert_array_equal(w.values, np.array([3, 4, 4]))
+
+    def test_imod_mutates_in_place(self) -> None:
+        w = Waveform1D(np.array([7, 8, 9], dtype=np.int64))
+        x = w
+        w %= 3
+        self.assertIs(w, x)
+        np.testing.assert_array_equal(w.values, np.array([1, 2, 0]))
+
+
+class TestInPlaceOperatorDtypePromotion(unittest.TestCase):
+    """C-6: in-place operators reassign a newly-constructed result rather
+    than mutating the numpy buffer via true in-place ufuncs, so they *silently
+    promote* dtype on mixed int/float arithmetic instead of raising numpy's
+    'same_kind' casting error. Pinning this as the confirmed, intentional
+    current behavior (numpy in-place ``arr += 0.5`` on an int array would
+    raise; this class's ``+=`` does not)."""
+
+    def test_iadd_scalar_float_promotes_int_waveform_to_float64(self) -> None:
+        w = Waveform1D(np.array([1, 2, 3], dtype=np.int64))
+        self.assertEqual(w.values.dtype, np.int64)
+        w += 0.5
+        self.assertEqual(w.values.dtype, np.float64)
+        np.testing.assert_array_equal(w.values, np.array([1.5, 2.5, 3.5]))
+
+
+class TestBitwiseOperators(unittest.TestCase):
+    def test_bitwise_on_float_dtype_raises_type_error(self) -> None:
+        w = Waveform1D([1.0, 2.0, 3.0])
+        with self.assertRaises(TypeError):
+            w & 1
+
+    def test_bitwise_and_between_int_waveforms(self) -> None:
+        a = Waveform1D(np.array([0b110, 0b101], dtype=np.int64))
+        b = Waveform1D(np.array([0b011, 0b110], dtype=np.int64))
+        result = a & b
+        np.testing.assert_array_equal(result.values, np.array([0b010, 0b100]))
+
+    def test_int_modulo_works(self) -> None:
+        w = Waveform1D(np.array([5, 6, 7], dtype=np.int64))
+        result = w % 3
+        np.testing.assert_array_equal(result.values, np.array([2, 0, 1]))
+
+    def test_int_left_shift_works(self) -> None:
+        w = Waveform1D(np.array([1, 2, 3], dtype=np.int64))
+        result = w << 1
+        np.testing.assert_array_equal(result.values, np.array([2, 4, 6]))
+
+    def test_invert_on_int_waveform(self) -> None:
+        w = Waveform1D(np.array([0, 1], dtype=np.int64))
+        result = ~w
+        np.testing.assert_array_equal(result.values, np.array([-1, -2]))
+
+    def test_invert_on_float_waveform_raises_type_error(self) -> None:
+        w = Waveform1D([1.0, 2.0])
+        with self.assertRaises(TypeError):
+            _ = ~w
+
+    def test_bitwise_or_between_int_waveforms(self) -> None:
+        a = Waveform1D(np.array([0b100, 0b010], dtype=np.int64))
+        b = Waveform1D(np.array([0b001, 0b010], dtype=np.int64))
+        result = a | b
+        np.testing.assert_array_equal(result.values, np.array([0b101, 0b010]))
+
+    def test_bitwise_xor_between_int_waveforms(self) -> None:
+        a = Waveform1D(np.array([0b110, 0b101], dtype=np.int64))
+        b = Waveform1D(np.array([0b011, 0b110], dtype=np.int64))
+        result = a ^ b
+        np.testing.assert_array_equal(result.values, np.array([0b101, 0b011]))
+
+    def test_int_right_shift_works(self) -> None:
+        w = Waveform1D(np.array([4, 8, 16], dtype=np.int64))
+        result = w >> 1
+        np.testing.assert_array_equal(result.values, np.array([2, 4, 8]))
+
+    def test_reflected_and(self) -> None:
+        w = Waveform1D(np.array([0b110, 0b101], dtype=np.int64))
+        result = 0b011 & w
+        np.testing.assert_array_equal(result.values, np.array([0b010, 0b001]))
+
+    def test_reflected_or(self) -> None:
+        w = Waveform1D(np.array([0b100], dtype=np.int64))
+        result = 0b010 | w
+        np.testing.assert_array_equal(result.values, np.array([0b110]))
+
+    def test_reflected_xor(self) -> None:
+        w = Waveform1D(np.array([0b110], dtype=np.int64))
+        result = 0b011 ^ w
+        np.testing.assert_array_equal(result.values, np.array([0b101]))
+
+    def test_reflected_lshift(self) -> None:
+        w = Waveform1D(np.array([1, 2], dtype=np.int64))
+        result = 2 << w
+        np.testing.assert_array_equal(result.values, np.array([4, 8]))
+
+    def test_reflected_rshift(self) -> None:
+        w = Waveform1D(np.array([1, 2], dtype=np.int64))
+        result = 16 >> w
+        np.testing.assert_array_equal(result.values, np.array([8, 4]))
+
+    def test_iand_mutates_in_place(self) -> None:
+        w = Waveform1D(np.array([0b110, 0b101], dtype=np.int64))
+        x = w
+        w &= 0b011
+        self.assertIs(w, x)
+        np.testing.assert_array_equal(w.values, np.array([0b010, 0b001]))
+
+    def test_ior_mutates_in_place(self) -> None:
+        w = Waveform1D(np.array([0b100, 0b010], dtype=np.int64))
+        x = w
+        w |= 0b001
+        self.assertIs(w, x)
+        np.testing.assert_array_equal(w.values, np.array([0b101, 0b011]))
+
+    def test_ixor_mutates_in_place(self) -> None:
+        w = Waveform1D(np.array([0b110, 0b101], dtype=np.int64))
+        x = w
+        w ^= 0b011
+        self.assertIs(w, x)
+        np.testing.assert_array_equal(w.values, np.array([0b101, 0b110]))
+
+    def test_ilshift_mutates_in_place(self) -> None:
+        w = Waveform1D(np.array([1, 2], dtype=np.int64))
+        x = w
+        w <<= 2
+        self.assertIs(w, x)
+        np.testing.assert_array_equal(w.values, np.array([4, 8]))
+
+    def test_irshift_mutates_in_place(self) -> None:
+        w = Waveform1D(np.array([8, 16], dtype=np.int64))
+        x = w
+        w >>= 2
+        self.assertIs(w, x)
+        np.testing.assert_array_equal(w.values, np.array([2, 4]))
+
+
+class TestUnaryOperators(unittest.TestCase):
+    def test_negation(self) -> None:
+        w = Waveform1D([1.0, -2.0, 3.0])
+        np.testing.assert_array_equal((-w).values, np.array([-1.0, 2.0, -3.0]))
+
+    def test_unary_plus(self) -> None:
+        w = Waveform1D([1.0, -2.0, 3.0])
+        np.testing.assert_array_equal((+w).values, np.array([1.0, -2.0, 3.0]))
+
+    def test_abs(self) -> None:
+        w = Waveform1D([1.0, -2.0, 3.0])
+        np.testing.assert_array_equal(abs(w).values, np.array([1.0, 2.0, 3.0]))
+
+
+class TestComparisonProducers(unittest.TestCase):
+    def test_elements_equal(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0])
+        b = Waveform1D([1.0, 5.0, 3.0])
+        np.testing.assert_array_equal(a.elements_equal(b), np.array([True, False, True]))
+
+    def test_elements_less_than(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0])
+        b = Waveform1D([2.0, 2.0, 2.0])
+        np.testing.assert_array_equal(a.elements_less_than(b), np.array([True, False, False]))
+
+    def test_elements_greater_than(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0])
+        b = Waveform1D([2.0, 2.0, 2.0])
+        np.testing.assert_array_equal(a.elements_greater_than(b), np.array([False, False, True]))
+
+    def test_comparison_producers_raise_on_dt_mismatch(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0], dt_seconds=1.0)
+        b = Waveform1D([1.0, 2.0, 3.0], dt_seconds=0.5)
+        with self.assertRaises(WaveformCompatibilityError):
+            a.elements_equal(b)
+
+
+class TestIscloseElementwise(unittest.TestCase):
+    def test_within_tolerance_passes(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0])
+        b = Waveform1D([1.0000000001, 2.0, 3.0])
+        result = a.isclose_elementwise(b, rtol=1e-6, atol=0.0)
+        np.testing.assert_array_equal(result, np.array([True, True, True]))
+
+    def test_outside_tolerance_fails(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0])
+        b = Waveform1D([1.1, 2.0, 3.0])
+        result = a.isclose_elementwise(b, rtol=1e-6, atol=0.0)
+        np.testing.assert_array_equal(result, np.array([False, True, True]))
+
+
+class TestIscloseWholeWaveform(unittest.TestCase):
+    def test_equal_waveforms_are_close(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0], dt_seconds=1.0, t0_seconds=0.0)
+        b = Waveform1D([1.0, 2.0, 3.0], dt_seconds=1.0, t0_seconds=0.0)
+        self.assertTrue(a.isclose(b))
+
+    def test_false_when_only_t0_differs(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0], dt_seconds=1.0, t0=PrecisionTimestamp.EPOCH)
+        b = Waveform1D(
+            [1.0, 2.0, 3.0], dt_seconds=1.0, t0=PrecisionTimestamp.EPOCH + a.dt
+        )
+        self.assertFalse(a.isclose(b))
+
+    def test_false_when_dt_differs(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0], dt_seconds=1.0)
+        b = Waveform1D([1.0, 2.0, 3.0], dt_seconds=2.0)
+        self.assertFalse(a.isclose(b))
+
+    def test_false_when_samples_differ_beyond_tolerance(self) -> None:
+        a = Waveform1D([1.0, 2.0, 3.0])
+        b = Waveform1D([1.0, 2.0, 3.5])
+        self.assertFalse(a.isclose(b))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/test_waveform_position.py b/tests/waveforms/test_waveform_position.py
new file mode 100644
index 0000000..9dc37bb
--- /dev/null
+++ b/tests/waveforms/test_waveform_position.py
@@ -0,0 +1,479 @@
+"""Unit tests for ``WaveformPosition`` (the position time-series container).
+
+Covers waveformCore.md §Aggregate containers with ``Element = Position``, and
+§Compliance requirements 1, 2, 8, 10 (see 15-waveform-position.md for the
+governing chunk).
+"""
+
+import time
+import unittest
+
+import numpy as np
+from foundation_abc.math.waveformABCs import PositionWaveformABC
+from foundationTypes.mathTypes.MathTypes import PositionWaveformType
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.precision_time.precision_timestamp import PrecisionTimestamp
+from math_tools.spatial.position import Position
+from math_tools.waveforms.waveform1d import Waveform1D
+from math_tools.waveforms.waveform_position import WaveformPosition
+
+
+def _make(n: int = 3, dt_seconds: float = 1.0, t0_seconds: float = 0.0) -> WaveformPosition:
+    positions = [Position(float(i), float(i) * 2.0, float(i) * 3.0) for i in range(n)]
+    return WaveformPosition(positions, dt_seconds=dt_seconds, t0_seconds=t0_seconds)
+
+
+class TestSpecCompliance1SerializationRoundTrip(unittest.TestCase):
+    """§Compliance 1: to_dict round-trips through PositionWaveformType."""
+
+    def test_round_trip_equal(self) -> None:
+        w = _make(n=3, dt_seconds=0.5, t0_seconds=10.0)
+        wire = PositionWaveformType.from_dict(w.to_dict())
+        self.assertEqual(w.to_dict(), wire.to_dict())
+
+    def test_from_dict_reconstructs_equal_waveform(self) -> None:
+        w = _make(n=3, dt_seconds=0.5, t0_seconds=10.0)
+        w2 = WaveformPosition.from_dict(w.to_dict())
+        self.assertEqual(w, w2)
+
+    def test_isinstance_of_abc(self) -> None:
+        self.assertIsInstance(_make(), PositionWaveformABC)
+
+    def test_no_abstract_methods_remain(self) -> None:
+        self.assertEqual(WaveformPosition.__abstractmethods__, frozenset())
+
+
+class TestConstruction(unittest.TestCase):
+    def test_from_position_list(self) -> None:
+        positions = [Position(1.0, 2.0, 3.0), Position(4.0, 5.0, 6.0)]
+        w = WaveformPosition(positions)
+        np.testing.assert_array_equal(
+            w.positions_array, np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
+        )
+
+    def test_from_raw_array(self) -> None:
+        arr = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
+        w = WaveformPosition(arr)
+        np.testing.assert_array_equal(w.positions_array, arr)
+
+    def test_positions_array_copied_not_aliased(self) -> None:
+        arr = np.array([[1.0, 2.0, 3.0]])
+        w = WaveformPosition(arr)
+        arr[0, 0] = 99.0
+        self.assertEqual(w[0].x, 1.0)
+
+    def test_empty_construction(self) -> None:
+        w = WaveformPosition([])
+        self.assertEqual(len(w), 0)
+        self.assertEqual(w.positions_array.shape, (0, 3))
+
+    def test_wrong_shape_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            WaveformPosition(np.array([[1.0, 2.0], [3.0, 4.0]]))
+
+    def test_both_dt_and_dt_seconds_raises_type_error(self) -> None:
+        with self.assertRaises(TypeError):
+            WaveformPosition([], dt=PrecisionTimeInterval.ONE_SECOND, dt_seconds=1.0)
+
+    def test_both_t0_and_t0_seconds_raises_type_error(self) -> None:
+        with self.assertRaises(TypeError):
+            WaveformPosition([], t0=PrecisionTimestamp.EPOCH, t0_seconds=1.0)
+
+    def test_zero_dt_seconds_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            WaveformPosition([], dt_seconds=0.0)
+
+    def test_negative_dt_seconds_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            WaveformPosition([], dt_seconds=-1.0)
+
+    def test_default_dt_is_one_second(self) -> None:
+        w = WaveformPosition([Position(1.0, 2.0, 3.0)])
+        self.assertEqual(w.dt, PrecisionTimeInterval.from_seconds(1.0))
+        self.assertEqual(w.t0, PrecisionTimestamp.EPOCH)
+
+
+class TestTimeAxis(unittest.TestCase):
+    def test_duration_is_dt_times_n_minus_1(self) -> None:
+        w = _make(n=4, dt_seconds=0.5)
+        self.assertEqual(w.duration, PrecisionTimeInterval.from_seconds(1.5))
+
+    def test_duration_zero_for_single_sample(self) -> None:
+        w = _make(n=1, dt_seconds=0.5)
+        self.assertEqual(w.duration, PrecisionTimeInterval.ZERO)
+
+    def test_duration_zero_for_empty(self) -> None:
+        w = WaveformPosition([], dt_seconds=0.5)
+        self.assertEqual(w.duration, PrecisionTimeInterval.ZERO)
+
+    def test_duration_seconds(self) -> None:
+        w = _make(n=3, dt_seconds=2.0)
+        self.assertEqual(w.duration_seconds, 4.0)
+
+    def test_sampling_frequency_hz(self) -> None:
+        w = _make(n=2, dt_seconds=0.1)
+        self.assertAlmostEqual(w.sampling_frequency_hz, 10.0)
+
+    def test_nyquist_frequency_hz(self) -> None:
+        w = _make(n=2, dt_seconds=0.1)
+        self.assertAlmostEqual(w.nyquist_frequency_hz, 5.0)
+
+    def test_sample_count_and_len(self) -> None:
+        w = _make(n=3)
+        self.assertEqual(w.sample_count, 3)
+        self.assertEqual(len(w), 3)
+
+    def test_time_axis(self) -> None:
+        w = _make(n=4, dt_seconds=0.5)
+        np.testing.assert_allclose(w.time_axis(), [0.0, 0.5, 1.0, 1.5])
+
+
+class TestSpecCompliance8FromComponents(unittest.TestCase):
+    """§Compliance 8: component_waveforms -> from_components round-trips exactly."""
+
+    def test_round_trip(self) -> None:
+        w = _make(n=5, dt_seconds=0.25, t0_seconds=3.0)
+        components = w.component_waveforms
+        rebuilt = WaveformPosition.from_components(components.x, components.y, components.z)
+        self.assertEqual(w, rebuilt)
+
+    def test_component_waveforms_share_dt_and_t0(self) -> None:
+        w = _make(n=3, dt_seconds=0.25, t0_seconds=3.0)
+        components = w.component_waveforms
+        for component in (components.x, components.y, components.z):
+            self.assertEqual(component.dt, w.dt)
+            self.assertEqual(component.t0, w.t0)
+
+    def test_component_waveforms_field_order_is_x_y_z(self) -> None:
+        w = WaveformPosition([Position(1.0, 2.0, 3.0)])
+        components = w.component_waveforms
+        self.assertEqual(components.x[0], 1.0)
+        self.assertEqual(components.y[0], 2.0)
+        self.assertEqual(components.z[0], 3.0)
+
+    def test_mismatched_length_raises_value_error(self) -> None:
+        x = Waveform1D([1.0, 2.0], dt_seconds=1.0)
+        y = Waveform1D([1.0, 2.0, 3.0], dt_seconds=1.0)
+        z = Waveform1D([1.0, 2.0], dt_seconds=1.0)
+        with self.assertRaises(ValueError):
+            WaveformPosition.from_components(x, y, z)
+
+    def test_mismatched_dt_raises_value_error(self) -> None:
+        x = Waveform1D([1.0, 2.0], dt_seconds=1.0)
+        y = Waveform1D([1.0, 2.0], dt_seconds=2.0)
+        z = Waveform1D([1.0, 2.0], dt_seconds=1.0)
+        with self.assertRaises(ValueError):
+            WaveformPosition.from_components(x, y, z)
+
+
+class TestElementAccess(unittest.TestCase):
+    def test_index_returns_position_equal_to_stored_row(self) -> None:
+        w = _make(n=3)
+        self.assertEqual(w[1], Position(1.0, 2.0, 3.0))
+
+    def test_slice_returns_waveform_position(self) -> None:
+        w = _make(n=5, dt_seconds=0.1)
+        sliced = w[1:3]
+        self.assertIsInstance(sliced, WaveformPosition)
+        self.assertEqual(len(sliced), 2)
+        self.assertEqual(sliced[0], Position(1.0, 2.0, 3.0))
+
+    def test_slice_t0_shift_is_attosecond_exact(self) -> None:
+        w = _make(n=5, dt_seconds=0.1)
+        sliced = w[2:4]
+        self.assertEqual(sliced.t0 - w.t0, w.dt * 2)
+
+    def test_slice_step_not_one_raises(self) -> None:
+        w = _make(n=4)
+        with self.assertRaises(ValueError):
+            _ = w[0:4:2]
+
+    def test_get_in_range(self) -> None:
+        w = _make(n=3)
+        self.assertEqual(w.get(1), Position(1.0, 2.0, 3.0))
+
+    def test_get_out_of_range_returns_none(self) -> None:
+        w = _make(n=3)
+        self.assertIsNone(w.get(10))
+        self.assertIsNone(w.get(-10))
+
+    def test_iteration_yields_positions(self) -> None:
+        w = _make(n=3)
+        materialized = list(w)
+        self.assertEqual(
+            materialized,
+            [Position(0.0, 0.0, 0.0), Position(1.0, 2.0, 3.0), Position(2.0, 4.0, 6.0)],
+        )
+
+    def test_materialized_positions_are_independent_objects(self) -> None:
+        w = _make(n=1)
+        p1 = w[0]
+        p1.x = 99.0
+        p2 = w[0]
+        self.assertEqual(p2.x, 0.0)
+
+
+class TestAreAllUnit(unittest.TestCase):
+    def test_all_unit_true(self) -> None:
+        w = WaveformPosition([Position(1.0, 0.0, 0.0), Position(0.0, 1.0, 0.0)])
+        self.assertTrue(w.are_all_unit)
+
+    def test_all_unit_false(self) -> None:
+        w = WaveformPosition([Position(1.0, 0.0, 0.0), Position(2.0, 0.0, 0.0)])
+        self.assertFalse(w.are_all_unit)
+
+    def test_all_unit_true_on_empty(self) -> None:
+        w = WaveformPosition([])
+        self.assertTrue(w.are_all_unit)
+
+
+class TestNormalize(unittest.TestCase):
+    def test_normalize_in_place(self) -> None:
+        w = WaveformPosition([Position(2.0, 0.0, 0.0), Position(0.0, 3.0, 0.0)])
+        w.normalize()
+        np.testing.assert_allclose(w.positions_array, [[1.0, 0.0, 0.0], [0.0, 1.0, 0.0]])
+
+    def test_normalized_returns_copy(self) -> None:
+        w = WaveformPosition([Position(2.0, 0.0, 0.0)])
+        result = w.normalized()
+        np.testing.assert_allclose(result.positions_array, [[1.0, 0.0, 0.0]])
+        # original left unmodified
+        np.testing.assert_allclose(w.positions_array, [[2.0, 0.0, 0.0]])
+
+    def test_normalize_zero_row_raises_value_error(self) -> None:
+        w = WaveformPosition([Position(1.0, 0.0, 0.0), Position(0.0, 0.0, 0.0)])
+        with self.assertRaises(ValueError):
+            w.normalize()
+
+    def test_normalized_zero_row_raises_value_error(self) -> None:
+        w = WaveformPosition([Position(0.0, 0.0, 0.0)])
+        with self.assertRaises(ValueError):
+            w.normalized()
+
+
+class TestSpecCompliance10VectorizedBulkOps(unittest.TestCase):
+    """§Compliance 10: bulk ops never construct per-element objects; smoke-test at scale."""
+
+    def test_normalize_smoke_test_large_n(self) -> None:
+        n = 1_000_000
+        rng = np.random.default_rng(0)
+        arr = rng.standard_normal((n, 3)) + 1.0  # avoid zero rows
+        w = WaveformPosition(arr)
+        start = time.monotonic()
+        w.normalize()
+        elapsed = time.monotonic() - start
+        self.assertLess(elapsed, 5.0)
+
+    def test_component_waveforms_smoke_test_large_n(self) -> None:
+        n = 1_000_000
+        rng = np.random.default_rng(0)
+        arr = rng.standard_normal((n, 3))
+        w = WaveformPosition(arr)
+        start = time.monotonic()
+        components = w.component_waveforms
+        elapsed = time.monotonic() - start
+        self.assertLess(elapsed, 5.0)
+        self.assertEqual(len(components.x), n)
+
+
+class TestMutation(unittest.TestCase):
+    def test_append(self) -> None:
+        w = WaveformPosition([Position(1.0, 1.0, 1.0)])
+        w.append(Position(2.0, 2.0, 2.0))
+        self.assertEqual(list(w), [Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0)])
+
+    def test_append_values(self) -> None:
+        w = WaveformPosition([Position(1.0, 1.0, 1.0)])
+        w.append_values([Position(2.0, 2.0, 2.0), Position(3.0, 3.0, 3.0)])
+        self.assertEqual(len(w), 3)
+
+    def test_prepend_shifts_t0_back_by_one_dt(self) -> None:
+        w = WaveformPosition([Position(2.0, 2.0, 2.0)], dt_seconds=1.0)
+        original_t0 = w.t0
+        w.prepend(Position(1.0, 1.0, 1.0))
+        self.assertEqual(list(w), [Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0)])
+        self.assertEqual(original_t0 - w.t0, w.dt)
+
+    def test_prepend_values_shifts_t0_back_by_k_dt(self) -> None:
+        w = WaveformPosition([Position(3.0, 3.0, 3.0)], dt_seconds=1.0)
+        original_t0 = w.t0
+        w.prepend_values([Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0)])
+        self.assertEqual(len(w), 3)
+        self.assertEqual(original_t0 - w.t0, w.dt * 2)
+
+    def test_insert(self) -> None:
+        w = WaveformPosition([Position(1.0, 1.0, 1.0), Position(3.0, 3.0, 3.0)])
+        w.insert(1, Position(2.0, 2.0, 2.0))
+        self.assertEqual(
+            list(w),
+            [Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0), Position(3.0, 3.0, 3.0)],
+        )
+
+    def test_replace(self) -> None:
+        w = WaveformPosition([Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0)])
+        w.replace(1, Position(99.0, 99.0, 99.0))
+        self.assertEqual(w[1], Position(99.0, 99.0, 99.0))
+
+    def test_replace_range(self) -> None:
+        w = WaveformPosition(
+            [Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0), Position(3.0, 3.0, 3.0)]
+        )
+        w.replace_range(slice(1, 3), [Position(8.0, 8.0, 8.0), Position(9.0, 9.0, 9.0)])
+        self.assertEqual(list(w)[1:], [Position(8.0, 8.0, 8.0), Position(9.0, 9.0, 9.0)])
+
+    def test_pop_default_removes_last(self) -> None:
+        w = WaveformPosition([Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0)])
+        value = w.pop()
+        self.assertEqual(value, Position(2.0, 2.0, 2.0))
+        self.assertEqual(len(w), 1)
+
+    def test_pop_with_index(self) -> None:
+        w = WaveformPosition([Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0)])
+        value = w.pop(0)
+        self.assertEqual(value, Position(1.0, 1.0, 1.0))
+
+    def test_pop_on_empty_raises_index_error(self) -> None:
+        w = WaveformPosition([])
+        with self.assertRaises(IndexError):
+            w.pop()
+
+    def test_pop_out_of_range_raises_index_error(self) -> None:
+        """C-14: only the empty case was previously pinned."""
+        w = WaveformPosition([Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0)])
+        with self.assertRaises(IndexError):
+            w.pop(5)
+
+    def test_clear_empties(self) -> None:
+        w = WaveformPosition([Position(1.0, 1.0, 1.0)])
+        w.clear()
+        self.assertEqual(len(w), 0)
+
+
+class TestSpecCompliance2ExtendConcatenate(unittest.TestCase):
+    """§Compliance 2: dt mismatch on extend/concatenate raises WaveformCompatibilityError."""
+
+    def test_extend_equal_dt_appends(self) -> None:
+        w1 = _make(n=2, dt_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=1.0)
+        w1.extend(w2)
+        self.assertEqual(len(w1), 4)
+
+    def test_extend_dt_mismatch_raises(self) -> None:
+        w1 = _make(n=2, dt_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=2.0)
+        with self.assertRaises(WaveformCompatibilityError):
+            w1.extend(w2)
+
+    def test_concatenate_equal_dt(self) -> None:
+        w1 = _make(n=2, dt_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=1.0)
+        result = w1.concatenate(w2)
+        self.assertEqual(len(result), 4)
+        self.assertEqual(len(w1), 2)  # original unmodified
+
+    def test_concatenate_dt_mismatch_raises(self) -> None:
+        w1 = _make(n=2, dt_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=2.0)
+        with self.assertRaises(WaveformCompatibilityError):
+            w1.concatenate(w2)
+
+
+class TestEquality(unittest.TestCase):
+    def test_equal_positions_dt_t0(self) -> None:
+        w1 = _make(n=2, dt_seconds=0.5, t0_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=0.5, t0_seconds=1.0)
+        self.assertEqual(w1, w2)
+
+    def test_unequal_positions(self) -> None:
+        w1 = WaveformPosition([Position(1.0, 1.0, 1.0)])
+        w2 = WaveformPosition([Position(2.0, 2.0, 2.0)])
+        self.assertNotEqual(w1, w2)
+
+    def test_unequal_dt(self) -> None:
+        w1 = _make(n=2, dt_seconds=0.5)
+        w2 = _make(n=2, dt_seconds=1.0)
+        self.assertNotEqual(w1, w2)
+
+    def test_unequal_t0(self) -> None:
+        w1 = _make(n=2, t0_seconds=0.0)
+        w2 = _make(n=2, t0_seconds=1.0)
+        self.assertNotEqual(w1, w2)
+
+    def test_not_equal_to_other_type(self) -> None:
+        w = _make(n=2)
+        self.assertNotEqual(w, "not a waveform")
+
+    def test_unhashable(self) -> None:
+        w = _make(n=2)
+        with self.assertRaises(TypeError):
+            hash(w)
+
+
+class TestRepr(unittest.TestCase):
+    def test_repr_contains_sample_count(self) -> None:
+        w = _make(n=3)
+        self.assertIn("3", repr(w))
+        self.assertIn("WaveformPosition", repr(w))
+
+
+class TestArrayInterop(unittest.TestCase):
+    """mathToolsArchitecture.md §API idioms: ``__array__`` so ``np.asarray(w)`` works."""
+
+    def test_asarray_matches_positions_array(self) -> None:
+        w = _make(n=4)
+        np.testing.assert_array_equal(np.asarray(w), w.positions_array)
+
+    def test_asarray_shape_is_sample_count_by_3(self) -> None:
+        w = _make(n=4)
+        self.assertEqual(np.asarray(w).shape, (4, 3))
+
+    def test_asarray_returns_a_copy(self) -> None:
+        w = _make(n=2)
+        arr = np.asarray(w)
+        arr[0, 0] = 99.0
+        self.assertEqual(w[0].x, 0.0)
+
+    def test_array_copy_false_raises_value_error(self) -> None:
+        w = _make(n=2)
+        with self.assertRaises(ValueError):
+            np.array(w, copy=False)
+
+
+class TestIsClose(unittest.TestCase):
+    def test_true_within_tolerance(self) -> None:
+        # index 1's x-component is nonzero (_make's Position(1, 2, 3)); atol
+        # defaults to 0.0 (mirroring Position.isclose), so a perturbation at an
+        # exact-zero component would not be "close" -- perturb a nonzero one.
+        w1 = _make(n=3)
+        arr = w1.positions_array
+        arr[1, 0] += 1e-10
+        w2 = WaveformPosition(arr, dt=w1.dt, t0=w1.t0)
+        self.assertTrue(w1.isclose(w2))
+
+    def test_false_outside_tolerance(self) -> None:
+        w1 = _make(n=3)
+        arr = w1.positions_array
+        arr[1, 0] += 1.0
+        w2 = WaveformPosition(arr, dt=w1.dt, t0=w1.t0)
+        self.assertFalse(w1.isclose(w2))
+
+    def test_false_on_differing_sample_count(self) -> None:
+        w1 = _make(n=3)
+        w2 = _make(n=4)
+        self.assertFalse(w1.isclose(w2))
+
+    def test_false_on_differing_dt(self) -> None:
+        w1 = _make(n=3, dt_seconds=1.0)
+        w2 = _make(n=3, dt_seconds=2.0)
+        self.assertFalse(w1.isclose(w2))
+
+    def test_true_for_identical_waveform(self) -> None:
+        w1 = _make(n=3)
+        w2 = _make(n=3)
+        self.assertTrue(w1.isclose(w2))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/test_waveform_quaternion.py b/tests/waveforms/test_waveform_quaternion.py
new file mode 100644
index 0000000..23423b7
--- /dev/null
+++ b/tests/waveforms/test_waveform_quaternion.py
@@ -0,0 +1,613 @@
+"""Unit tests for ``WaveformQuaternion`` (the quaternion time-series container).
+
+Covers waveformCore.md §Aggregate containers with ``Element = Quaternion``,
+and §Compliance requirements 1, 2, 8, 10 (see 16-waveform-quaternion.md for
+the governing chunk).
+"""
+
+import time
+import unittest
+
+import numpy as np
+from foundation_abc.math.waveformABCs import QuaternionWaveformABC
+from foundationTypes.mathTypes.MathTypes import QuaternionWaveformType
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.precision_time.precision_timestamp import PrecisionTimestamp
+from math_tools.spatial.quaternion import Quaternion
+from math_tools.waveforms.waveform1d import Waveform1D
+from math_tools.waveforms.waveform_quaternion import WaveformQuaternion
+
+
+def _make(n: int = 3, dt_seconds: float = 1.0, t0_seconds: float = 0.0) -> WaveformQuaternion:
+    quaternions = [
+        Quaternion.from_components(float(i), float(i) * 2.0, float(i) * 3.0, float(i) * 4.0)
+        for i in range(n)
+    ]
+    return WaveformQuaternion(quaternions, dt_seconds=dt_seconds, t0_seconds=t0_seconds)
+
+
+class TestSpecCompliance1SerializationRoundTrip(unittest.TestCase):
+    """§Compliance 1: to_dict round-trips through QuaternionWaveformType."""
+
+    def test_round_trip_equal(self) -> None:
+        w = _make(n=3, dt_seconds=0.5, t0_seconds=10.0)
+        wire = QuaternionWaveformType.from_dict(w.to_dict())
+        self.assertEqual(w.to_dict(), wire.to_dict())
+
+    def test_from_dict_reconstructs_equal_waveform(self) -> None:
+        w = _make(n=3, dt_seconds=0.5, t0_seconds=10.0)
+        w2 = WaveformQuaternion.from_dict(w.to_dict())
+        self.assertEqual(w, w2)
+
+    def test_isinstance_of_abc(self) -> None:
+        self.assertIsInstance(_make(), QuaternionWaveformABC)
+
+    def test_no_abstract_methods_remain(self) -> None:
+        self.assertEqual(WaveformQuaternion.__abstractmethods__, frozenset())
+
+    def test_wire_dict_is_per_element_w_x_y_z(self) -> None:
+        w = WaveformQuaternion([Quaternion.from_components(1.0, 2.0, 3.0, 4.0)])
+        wire = w.to_dict()
+        self.assertEqual(set(wire["quaternions"][0].keys()), {"w", "x", "y", "z"})
+        self.assertEqual(
+            wire["quaternions"][0],
+            {"w": 1.0, "x": 2.0, "y": 3.0, "z": 4.0},
+        )
+
+
+class TestConstruction(unittest.TestCase):
+    def test_from_quaternion_list(self) -> None:
+        quaternions = [
+            Quaternion.from_components(1.0, 2.0, 3.0, 4.0),
+            Quaternion.from_components(5.0, 6.0, 7.0, 8.0),
+        ]
+        w = WaveformQuaternion(quaternions)
+        np.testing.assert_array_equal(
+            w.quaternions_array, np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]])
+        )
+
+    def test_from_raw_array(self) -> None:
+        arr = np.array([[1.0, 2.0, 3.0, 4.0], [5.0, 6.0, 7.0, 8.0]])
+        w = WaveformQuaternion(arr)
+        np.testing.assert_array_equal(w.quaternions_array, arr)
+
+    def test_quaternions_array_copied_not_aliased(self) -> None:
+        arr = np.array([[1.0, 2.0, 3.0, 4.0]])
+        w = WaveformQuaternion(arr)
+        arr[0, 0] = 99.0
+        self.assertEqual(w[0].w, 1.0)
+
+    def test_empty_construction(self) -> None:
+        w = WaveformQuaternion([])
+        self.assertEqual(len(w), 0)
+        self.assertEqual(w.quaternions_array.shape, (0, 4))
+
+    def test_wrong_shape_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            WaveformQuaternion(np.array([[1.0, 2.0], [3.0, 4.0]]))
+
+    def test_both_dt_and_dt_seconds_raises_type_error(self) -> None:
+        with self.assertRaises(TypeError):
+            WaveformQuaternion([], dt=PrecisionTimeInterval.ONE_SECOND, dt_seconds=1.0)
+
+    def test_both_t0_and_t0_seconds_raises_type_error(self) -> None:
+        with self.assertRaises(TypeError):
+            WaveformQuaternion([], t0=PrecisionTimestamp.EPOCH, t0_seconds=1.0)
+
+    def test_zero_dt_seconds_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            WaveformQuaternion([], dt_seconds=0.0)
+
+    def test_negative_dt_seconds_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            WaveformQuaternion([], dt_seconds=-1.0)
+
+    def test_default_dt_is_one_second(self) -> None:
+        w = WaveformQuaternion([Quaternion.from_components(1.0, 2.0, 3.0, 4.0)])
+        self.assertEqual(w.dt, PrecisionTimeInterval.from_seconds(1.0))
+        self.assertEqual(w.t0, PrecisionTimestamp.EPOCH)
+
+
+class TestTimeAxis(unittest.TestCase):
+    def test_duration_is_dt_times_n_minus_1(self) -> None:
+        w = _make(n=4, dt_seconds=0.5)
+        self.assertEqual(w.duration, PrecisionTimeInterval.from_seconds(1.5))
+
+    def test_duration_zero_for_single_sample(self) -> None:
+        w = _make(n=1, dt_seconds=0.5)
+        self.assertEqual(w.duration, PrecisionTimeInterval.ZERO)
+
+    def test_duration_zero_for_empty(self) -> None:
+        w = WaveformQuaternion([], dt_seconds=0.5)
+        self.assertEqual(w.duration, PrecisionTimeInterval.ZERO)
+
+    def test_duration_seconds(self) -> None:
+        w = _make(n=3, dt_seconds=2.0)
+        self.assertEqual(w.duration_seconds, 4.0)
+
+    def test_sampling_frequency_hz(self) -> None:
+        w = _make(n=2, dt_seconds=0.1)
+        self.assertAlmostEqual(w.sampling_frequency_hz, 10.0)
+
+    def test_nyquist_frequency_hz(self) -> None:
+        w = _make(n=2, dt_seconds=0.1)
+        self.assertAlmostEqual(w.nyquist_frequency_hz, 5.0)
+
+    def test_sample_count_and_len(self) -> None:
+        w = _make(n=3)
+        self.assertEqual(w.sample_count, 3)
+        self.assertEqual(len(w), 3)
+
+    def test_time_axis(self) -> None:
+        w = _make(n=4, dt_seconds=0.5)
+        np.testing.assert_allclose(w.time_axis(), [0.0, 0.5, 1.0, 1.5])
+
+
+class TestSpecCompliance8FromComponents(unittest.TestCase):
+    """§Compliance 8: component_waveforms -> from_components round-trips exactly,
+    with the w-first field order pinned by name access."""
+
+    def test_round_trip(self) -> None:
+        w = _make(n=5, dt_seconds=0.25, t0_seconds=3.0)
+        components = w.component_waveforms
+        rebuilt = WaveformQuaternion.from_components(
+            components.w, components.x, components.y, components.z
+        )
+        self.assertEqual(w, rebuilt)
+
+    def test_component_waveforms_share_dt_and_t0(self) -> None:
+        w = _make(n=3, dt_seconds=0.25, t0_seconds=3.0)
+        components = w.component_waveforms
+        for component in (components.w, components.x, components.y, components.z):
+            self.assertEqual(component.dt, w.dt)
+            self.assertEqual(component.t0, w.t0)
+
+    def test_component_waveforms_field_order_is_w_x_y_z(self) -> None:
+        w = WaveformQuaternion([Quaternion.from_components(1.0, 2.0, 3.0, 4.0)])
+        components = w.component_waveforms
+        self.assertEqual(components.w[0], 1.0)
+        self.assertEqual(components.x[0], 2.0)
+        self.assertEqual(components.y[0], 3.0)
+        self.assertEqual(components.z[0], 4.0)
+
+    def test_mismatched_length_raises_value_error(self) -> None:
+        w_wave = Waveform1D([1.0, 2.0], dt_seconds=1.0)
+        x = Waveform1D([1.0, 2.0, 3.0], dt_seconds=1.0)
+        y = Waveform1D([1.0, 2.0], dt_seconds=1.0)
+        z = Waveform1D([1.0, 2.0], dt_seconds=1.0)
+        with self.assertRaises(ValueError):
+            WaveformQuaternion.from_components(w_wave, x, y, z)
+
+    def test_mismatched_dt_raises_value_error(self) -> None:
+        w_wave = Waveform1D([1.0, 2.0], dt_seconds=1.0)
+        x = Waveform1D([1.0, 2.0], dt_seconds=2.0)
+        y = Waveform1D([1.0, 2.0], dt_seconds=1.0)
+        z = Waveform1D([1.0, 2.0], dt_seconds=1.0)
+        with self.assertRaises(ValueError):
+            WaveformQuaternion.from_components(w_wave, x, y, z)
+
+
+class TestElementAccess(unittest.TestCase):
+    def test_index_returns_quaternion_equal_to_stored_row(self) -> None:
+        w = _make(n=3)
+        self.assertEqual(w[1], Quaternion.from_components(1.0, 2.0, 3.0, 4.0))
+
+    def test_slice_returns_waveform_quaternion(self) -> None:
+        w = _make(n=5, dt_seconds=0.1)
+        sliced = w[1:3]
+        self.assertIsInstance(sliced, WaveformQuaternion)
+        self.assertEqual(len(sliced), 2)
+        self.assertEqual(sliced[0], Quaternion.from_components(1.0, 2.0, 3.0, 4.0))
+
+    def test_slice_t0_shift_is_attosecond_exact(self) -> None:
+        w = _make(n=5, dt_seconds=0.1)
+        sliced = w[2:4]
+        self.assertEqual(sliced.t0 - w.t0, w.dt * 2)
+
+    def test_slice_step_not_one_raises(self) -> None:
+        w = _make(n=4)
+        with self.assertRaises(ValueError):
+            _ = w[0:4:2]
+
+    def test_get_in_range(self) -> None:
+        w = _make(n=3)
+        self.assertEqual(w.get(1), Quaternion.from_components(1.0, 2.0, 3.0, 4.0))
+
+    def test_get_out_of_range_returns_none(self) -> None:
+        w = _make(n=3)
+        self.assertIsNone(w.get(10))
+        self.assertIsNone(w.get(-10))
+
+    def test_iteration_yields_quaternions(self) -> None:
+        w = _make(n=3)
+        materialized = list(w)
+        self.assertEqual(
+            materialized,
+            [
+                Quaternion.from_components(0.0, 0.0, 0.0, 0.0),
+                Quaternion.from_components(1.0, 2.0, 3.0, 4.0),
+                Quaternion.from_components(2.0, 4.0, 6.0, 8.0),
+            ],
+        )
+
+    def test_materialized_quaternions_are_fresh_objects(self) -> None:
+        w = _make(n=1)
+        q1 = w[0]
+        q2 = w[0]
+        self.assertEqual(q1, q2)
+        self.assertIsNot(q1, q2)
+
+
+class TestAreAllUnit(unittest.TestCase):
+    def test_all_unit_true(self) -> None:
+        w = WaveformQuaternion(
+            [
+                Quaternion.from_components(1.0, 0.0, 0.0, 0.0),
+                Quaternion.from_components(0.0, 1.0, 0.0, 0.0),
+            ]
+        )
+        self.assertTrue(w.are_all_unit)
+
+    def test_all_unit_false(self) -> None:
+        w = WaveformQuaternion(
+            [
+                Quaternion.from_components(1.0, 0.0, 0.0, 0.0),
+                Quaternion.from_components(2.0, 0.0, 0.0, 0.0),
+            ]
+        )
+        self.assertFalse(w.are_all_unit)
+
+    def test_all_unit_true_on_empty(self) -> None:
+        w = WaveformQuaternion([])
+        self.assertTrue(w.are_all_unit)
+
+    def test_are_all_unit_flips_after_appending_non_unit(self) -> None:
+        w = WaveformQuaternion(
+            [
+                Quaternion.from_components(1.0, 0.0, 0.0, 0.0),
+                Quaternion.from_components(0.0, 1.0, 0.0, 0.0),
+            ]
+        )
+        self.assertTrue(w.are_all_unit)
+        w.append(Quaternion.from_components(2.0, 0.0, 0.0, 0.0))
+        self.assertFalse(w.are_all_unit)
+
+
+class TestNormalize(unittest.TestCase):
+    def test_normalize_in_place(self) -> None:
+        w = WaveformQuaternion(
+            [
+                Quaternion.from_components(2.0, 0.0, 0.0, 0.0),
+                Quaternion.from_components(0.0, 3.0, 0.0, 0.0),
+            ]
+        )
+        w.normalize()
+        np.testing.assert_allclose(
+            w.quaternions_array, [[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]]
+        )
+
+    def test_normalized_returns_copy(self) -> None:
+        w = WaveformQuaternion([Quaternion.from_components(2.0, 0.0, 0.0, 0.0)])
+        result = w.normalized()
+        np.testing.assert_allclose(result.quaternions_array, [[1.0, 0.0, 0.0, 0.0]])
+        # original left unmodified
+        np.testing.assert_allclose(w.quaternions_array, [[2.0, 0.0, 0.0, 0.0]])
+
+    def test_normalize_zero_row_raises_value_error(self) -> None:
+        w = WaveformQuaternion(
+            [
+                Quaternion.from_components(1.0, 0.0, 0.0, 0.0),
+                Quaternion.from_components(0.0, 0.0, 0.0, 0.0),
+            ]
+        )
+        with self.assertRaises(ValueError):
+            w.normalize()
+
+    def test_normalized_zero_row_raises_value_error(self) -> None:
+        w = WaveformQuaternion([Quaternion.from_components(0.0, 0.0, 0.0, 0.0)])
+        with self.assertRaises(ValueError):
+            w.normalized()
+
+
+class TestSpecCompliance10VectorizedBulkOps(unittest.TestCase):
+    """§Compliance 10: bulk ops never construct per-element objects; smoke-test at scale."""
+
+    def test_normalize_smoke_test_large_n(self) -> None:
+        n = 1_000_000
+        rng = np.random.default_rng(0)
+        arr = rng.standard_normal((n, 4)) + 1.0  # avoid zero rows
+        w = WaveformQuaternion(arr)
+        start = time.monotonic()
+        w.normalize()
+        elapsed = time.monotonic() - start
+        self.assertLess(elapsed, 5.0)
+
+    def test_component_waveforms_smoke_test_large_n(self) -> None:
+        n = 1_000_000
+        rng = np.random.default_rng(0)
+        arr = rng.standard_normal((n, 4))
+        w = WaveformQuaternion(arr)
+        start = time.monotonic()
+        components = w.component_waveforms
+        elapsed = time.monotonic() - start
+        self.assertLess(elapsed, 5.0)
+        self.assertEqual(len(components.w), n)
+
+
+class TestMutation(unittest.TestCase):
+    def test_append(self) -> None:
+        w = WaveformQuaternion([Quaternion.from_components(1.0, 1.0, 1.0, 1.0)])
+        w.append(Quaternion.from_components(2.0, 2.0, 2.0, 2.0))
+        self.assertEqual(
+            list(w),
+            [
+                Quaternion.from_components(1.0, 1.0, 1.0, 1.0),
+                Quaternion.from_components(2.0, 2.0, 2.0, 2.0),
+            ],
+        )
+
+    def test_append_values(self) -> None:
+        w = WaveformQuaternion([Quaternion.from_components(1.0, 1.0, 1.0, 1.0)])
+        w.append_values(
+            [
+                Quaternion.from_components(2.0, 2.0, 2.0, 2.0),
+                Quaternion.from_components(3.0, 3.0, 3.0, 3.0),
+            ]
+        )
+        self.assertEqual(len(w), 3)
+
+    def test_prepend_shifts_t0_back_by_one_dt(self) -> None:
+        w = WaveformQuaternion([Quaternion.from_components(2.0, 2.0, 2.0, 2.0)], dt_seconds=1.0)
+        original_t0 = w.t0
+        w.prepend(Quaternion.from_components(1.0, 1.0, 1.0, 1.0))
+        self.assertEqual(
+            list(w),
+            [
+                Quaternion.from_components(1.0, 1.0, 1.0, 1.0),
+                Quaternion.from_components(2.0, 2.0, 2.0, 2.0),
+            ],
+        )
+        self.assertEqual(original_t0 - w.t0, w.dt)
+
+    def test_prepend_values_shifts_t0_back_by_k_dt(self) -> None:
+        w = WaveformQuaternion([Quaternion.from_components(3.0, 3.0, 3.0, 3.0)], dt_seconds=1.0)
+        original_t0 = w.t0
+        w.prepend_values(
+            [
+                Quaternion.from_components(1.0, 1.0, 1.0, 1.0),
+                Quaternion.from_components(2.0, 2.0, 2.0, 2.0),
+            ]
+        )
+        self.assertEqual(len(w), 3)
+        self.assertEqual(original_t0 - w.t0, w.dt * 2)
+
+    def test_insert(self) -> None:
+        w = WaveformQuaternion(
+            [
+                Quaternion.from_components(1.0, 1.0, 1.0, 1.0),
+                Quaternion.from_components(3.0, 3.0, 3.0, 3.0),
+            ]
+        )
+        w.insert(1, Quaternion.from_components(2.0, 2.0, 2.0, 2.0))
+        self.assertEqual(
+            list(w),
+            [
+                Quaternion.from_components(1.0, 1.0, 1.0, 1.0),
+                Quaternion.from_components(2.0, 2.0, 2.0, 2.0),
+                Quaternion.from_components(3.0, 3.0, 3.0, 3.0),
+            ],
+        )
+
+    def test_replace(self) -> None:
+        w = WaveformQuaternion(
+            [
+                Quaternion.from_components(1.0, 1.0, 1.0, 1.0),
+                Quaternion.from_components(2.0, 2.0, 2.0, 2.0),
+            ]
+        )
+        w.replace(1, Quaternion.from_components(99.0, 99.0, 99.0, 99.0))
+        self.assertEqual(w[1], Quaternion.from_components(99.0, 99.0, 99.0, 99.0))
+
+    def test_replace_range(self) -> None:
+        w = WaveformQuaternion(
+            [
+                Quaternion.from_components(1.0, 1.0, 1.0, 1.0),
+                Quaternion.from_components(2.0, 2.0, 2.0, 2.0),
+                Quaternion.from_components(3.0, 3.0, 3.0, 3.0),
+            ]
+        )
+        w.replace_range(
+            slice(1, 3),
+            [
+                Quaternion.from_components(8.0, 8.0, 8.0, 8.0),
+                Quaternion.from_components(9.0, 9.0, 9.0, 9.0),
+            ],
+        )
+        self.assertEqual(
+            list(w)[1:],
+            [
+                Quaternion.from_components(8.0, 8.0, 8.0, 8.0),
+                Quaternion.from_components(9.0, 9.0, 9.0, 9.0),
+            ],
+        )
+
+    def test_pop_default_removes_last(self) -> None:
+        w = WaveformQuaternion(
+            [
+                Quaternion.from_components(1.0, 1.0, 1.0, 1.0),
+                Quaternion.from_components(2.0, 2.0, 2.0, 2.0),
+            ]
+        )
+        value = w.pop()
+        self.assertEqual(value, Quaternion.from_components(2.0, 2.0, 2.0, 2.0))
+        self.assertEqual(len(w), 1)
+
+    def test_pop_with_index(self) -> None:
+        w = WaveformQuaternion(
+            [
+                Quaternion.from_components(1.0, 1.0, 1.0, 1.0),
+                Quaternion.from_components(2.0, 2.0, 2.0, 2.0),
+            ]
+        )
+        value = w.pop(0)
+        self.assertEqual(value, Quaternion.from_components(1.0, 1.0, 1.0, 1.0))
+
+    def test_pop_on_empty_raises_index_error(self) -> None:
+        w = WaveformQuaternion([])
+        with self.assertRaises(IndexError):
+            w.pop()
+
+    def test_pop_out_of_range_raises_index_error(self) -> None:
+        """C-14: only the empty case was previously pinned."""
+        w = WaveformQuaternion(
+            [
+                Quaternion.from_components(1.0, 1.0, 1.0, 1.0),
+                Quaternion.from_components(2.0, 2.0, 2.0, 2.0),
+            ]
+        )
+        with self.assertRaises(IndexError):
+            w.pop(5)
+
+    def test_clear_empties(self) -> None:
+        w = WaveformQuaternion([Quaternion.from_components(1.0, 1.0, 1.0, 1.0)])
+        w.clear()
+        self.assertEqual(len(w), 0)
+
+
+class TestSpecCompliance2ExtendConcatenate(unittest.TestCase):
+    """§Compliance 2: dt mismatch on extend/concatenate raises WaveformCompatibilityError."""
+
+    def test_extend_equal_dt_appends(self) -> None:
+        w1 = _make(n=2, dt_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=1.0)
+        w1.extend(w2)
+        self.assertEqual(len(w1), 4)
+
+    def test_extend_dt_mismatch_raises(self) -> None:
+        w1 = _make(n=2, dt_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=2.0)
+        with self.assertRaises(WaveformCompatibilityError):
+            w1.extend(w2)
+
+    def test_concatenate_equal_dt(self) -> None:
+        w1 = _make(n=2, dt_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=1.0)
+        result = w1.concatenate(w2)
+        self.assertEqual(len(result), 4)
+        self.assertEqual(len(w1), 2)  # original unmodified
+
+    def test_concatenate_dt_mismatch_raises(self) -> None:
+        w1 = _make(n=2, dt_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=2.0)
+        with self.assertRaises(WaveformCompatibilityError):
+            w1.concatenate(w2)
+
+
+class TestEquality(unittest.TestCase):
+    def test_equal_quaternions_dt_t0(self) -> None:
+        w1 = _make(n=2, dt_seconds=0.5, t0_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=0.5, t0_seconds=1.0)
+        self.assertEqual(w1, w2)
+
+    def test_unequal_quaternions(self) -> None:
+        w1 = WaveformQuaternion([Quaternion.from_components(1.0, 1.0, 1.0, 1.0)])
+        w2 = WaveformQuaternion([Quaternion.from_components(2.0, 2.0, 2.0, 2.0)])
+        self.assertNotEqual(w1, w2)
+
+    def test_unequal_dt(self) -> None:
+        w1 = _make(n=2, dt_seconds=0.5)
+        w2 = _make(n=2, dt_seconds=1.0)
+        self.assertNotEqual(w1, w2)
+
+    def test_unequal_t0(self) -> None:
+        w1 = _make(n=2, t0_seconds=0.0)
+        w2 = _make(n=2, t0_seconds=1.0)
+        self.assertNotEqual(w1, w2)
+
+    def test_not_equal_to_other_type(self) -> None:
+        w = _make(n=2)
+        self.assertNotEqual(w, "not a waveform")
+
+    def test_unhashable(self) -> None:
+        w = _make(n=2)
+        with self.assertRaises(TypeError):
+            hash(w)
+
+
+class TestRepr(unittest.TestCase):
+    def test_repr_contains_sample_count(self) -> None:
+        w = _make(n=3)
+        self.assertIn("3", repr(w))
+        self.assertIn("WaveformQuaternion", repr(w))
+
+
+def _make_unit(n: int = 3, dt_seconds: float = 1.0, t0_seconds: float = 0.0) -> WaveformQuaternion:
+    quaternions = [
+        Quaternion.from_components(1.0, float(i) * 0.01, 0.0, 0.0).normalized() for i in range(n)
+    ]
+    return WaveformQuaternion(quaternions, dt_seconds=dt_seconds, t0_seconds=t0_seconds)
+
+
+class TestArrayInterop(unittest.TestCase):
+    """mathToolsArchitecture.md §API idioms: ``__array__`` so ``np.asarray(w)`` works."""
+
+    def test_asarray_matches_quaternions_array(self) -> None:
+        w = _make_unit(n=4)
+        np.testing.assert_array_equal(np.asarray(w), w.quaternions_array)
+
+    def test_asarray_shape_is_sample_count_by_4(self) -> None:
+        w = _make_unit(n=4)
+        self.assertEqual(np.asarray(w).shape, (4, 4))
+
+    def test_asarray_returns_a_copy(self) -> None:
+        w = _make_unit(n=2)
+        arr = np.asarray(w)
+        arr[0, 0] = 99.0
+        self.assertNotEqual(w[0].w, 99.0)
+
+    def test_array_copy_false_raises_value_error(self) -> None:
+        w = _make_unit(n=2)
+        with self.assertRaises(ValueError):
+            np.array(w, copy=False)
+
+
+class TestIsClose(unittest.TestCase):
+    def test_true_within_tolerance(self) -> None:
+        w1 = _make_unit(n=3)
+        arr = w1.quaternions_array
+        arr[0, 0] += 1e-12
+        w2 = WaveformQuaternion(arr, dt=w1.dt, t0=w1.t0)
+        self.assertTrue(w1.isclose(w2))
+
+    def test_false_outside_tolerance(self) -> None:
+        w1 = _make_unit(n=3)
+        arr = w1.quaternions_array
+        arr[0, 0] += 1.0
+        w2 = WaveformQuaternion(arr, dt=w1.dt, t0=w1.t0)
+        self.assertFalse(w1.isclose(w2))
+
+    def test_false_on_differing_sample_count(self) -> None:
+        w1 = _make_unit(n=3)
+        w2 = _make_unit(n=4)
+        self.assertFalse(w1.isclose(w2))
+
+    def test_false_on_differing_dt(self) -> None:
+        w1 = _make_unit(n=3, dt_seconds=1.0)
+        w2 = _make_unit(n=3, dt_seconds=2.0)
+        self.assertFalse(w1.isclose(w2))
+
+    def test_double_cover_negated_waveform_is_close(self) -> None:
+        w = _make_unit(n=3)
+        negated = WaveformQuaternion(-w.quaternions_array, dt=w.dt, t0=w.t0)
+        self.assertTrue(w.isclose(negated))
+
+    def test_true_for_identical_waveform(self) -> None:
+        w1 = _make_unit(n=3)
+        w2 = _make_unit(n=3)
+        self.assertTrue(w1.isclose(w2))
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/waveforms/test_waveform_spatial_pose.py b/tests/waveforms/test_waveform_spatial_pose.py
new file mode 100644
index 0000000..fbe0d8f
--- /dev/null
+++ b/tests/waveforms/test_waveform_spatial_pose.py
@@ -0,0 +1,787 @@
+"""Unit tests for ``WaveformSpatialPose`` (the 6-DOF pose time-series container).
+
+Covers waveformCore.md §Aggregate containers with ``Element = SpatialPose``,
+and §Compliance requirements 1, 2, 8, 9 (see 17-waveform-spatial-pose.md for
+the governing chunk).
+"""
+
+import time
+import unittest
+
+import numpy as np
+from foundation_abc.math.waveformABCs import WaveformSpatialABC
+from foundationTypes.mathTypes.MathTypes import SpatialTransformWaveformType
+
+from math_tools.errors import WaveformCompatibilityError
+from math_tools.precision_time.precision_time_interval import PrecisionTimeInterval
+from math_tools.precision_time.precision_timestamp import PrecisionTimestamp
+from math_tools.spatial.position import Position
+from math_tools.spatial.quaternion import Quaternion
+from math_tools.spatial.spatial_pose import SpatialPose
+from math_tools.waveforms.waveform_position import WaveformPosition
+from math_tools.waveforms.waveform_quaternion import WaveformQuaternion
+from math_tools.waveforms.waveform_spatial_pose import WaveformSpatialPose
+
+
+def _pose(i: int) -> SpatialPose:
+    return SpatialPose(
+        Position(float(i), float(i) * 2.0, float(i) * 3.0),
+        Quaternion.from_components(1.0, 0.0, 0.0, 0.0)
+        if i == 0
+        else Quaternion.from_components(0.0, 1.0, 0.0, 0.0),
+    )
+
+
+def _make_poses(n: int = 3) -> list[SpatialPose]:
+    return [_pose(i) for i in range(n)]
+
+
+def _make(n: int = 3, dt_seconds: float = 1.0, t0_seconds: float = 0.0) -> WaveformSpatialPose:
+    return WaveformSpatialPose.from_poses(
+        _make_poses(n), dt_seconds=dt_seconds, t0_seconds=t0_seconds
+    )
+
+
+class TestSpecCompliance1SerializationRoundTrip(unittest.TestCase):
+    """§Compliance 1: to_dict round-trips through SpatialTransformWaveformType."""
+
+    def test_round_trip_equal(self) -> None:
+        w = _make(n=3, dt_seconds=0.5, t0_seconds=10.0)
+        wire = SpatialTransformWaveformType.from_dict(w.to_dict())
+        self.assertEqual(w.to_dict(), wire.to_dict())
+
+    def test_from_dict_reconstructs_equal_waveform(self) -> None:
+        w = _make(n=3, dt_seconds=0.5, t0_seconds=10.0)
+        w2 = WaveformSpatialPose.from_dict(w.to_dict())
+        self.assertEqual(w, w2)
+
+    def test_isinstance_of_abc(self) -> None:
+        self.assertIsInstance(_make(), WaveformSpatialABC)
+
+    def test_no_abstract_methods_remain(self) -> None:
+        self.assertEqual(WaveformSpatialPose.__abstractmethods__, frozenset())
+
+
+class TestConstruction(unittest.TestCase):
+    def test_from_parallel_arrays(self) -> None:
+        positions = np.array([[1.0, 2.0, 3.0], [4.0, 5.0, 6.0]])
+        quaternions = np.array([[1.0, 0.0, 0.0, 0.0], [0.0, 1.0, 0.0, 0.0]])
+        w = WaveformSpatialPose(positions, quaternions)
+        np.testing.assert_array_equal(w.positions_array, positions)
+        np.testing.assert_array_equal(w.quaternions_array, quaternions)
+
+    def test_from_element_lists(self) -> None:
+        positions = [Position(1.0, 2.0, 3.0), Position(4.0, 5.0, 6.0)]
+        quaternions = [
+            Quaternion.from_components(1.0, 0.0, 0.0, 0.0),
+            Quaternion.from_components(0.0, 1.0, 0.0, 0.0),
+        ]
+        w = WaveformSpatialPose(positions, quaternions)
+        self.assertEqual(len(w), 2)
+
+    def test_empty_construction(self) -> None:
+        w = WaveformSpatialPose([], [])
+        self.assertEqual(len(w), 0)
+        self.assertEqual(w.positions_array.shape, (0, 3))
+        self.assertEqual(w.quaternions_array.shape, (0, 4))
+
+    def test_wrong_position_shape_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            WaveformSpatialPose(np.array([[1.0, 2.0], [3.0, 4.0]]), np.zeros((2, 4)))
+
+    def test_wrong_quaternion_shape_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            WaveformSpatialPose(np.zeros((2, 3)), np.array([[1.0, 2.0], [3.0, 4.0]]))
+
+    def test_both_dt_and_dt_seconds_raises_type_error(self) -> None:
+        with self.assertRaises(TypeError):
+            WaveformSpatialPose([], [], dt=PrecisionTimeInterval.ONE_SECOND, dt_seconds=1.0)
+
+    def test_both_t0_and_t0_seconds_raises_type_error(self) -> None:
+        with self.assertRaises(TypeError):
+            WaveformSpatialPose([], [], t0=PrecisionTimestamp.EPOCH, t0_seconds=1.0)
+
+    def test_zero_dt_seconds_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            WaveformSpatialPose([], [], dt_seconds=0.0)
+
+    def test_negative_dt_seconds_raises_value_error(self) -> None:
+        with self.assertRaises(ValueError):
+            WaveformSpatialPose([], [], dt_seconds=-1.0)
+
+    def test_default_dt_is_one_second(self) -> None:
+        w = WaveformSpatialPose([Position(1.0, 2.0, 3.0)], [Quaternion.identity()])
+        self.assertEqual(w.dt, PrecisionTimeInterval.from_seconds(1.0))
+        self.assertEqual(w.t0, PrecisionTimestamp.EPOCH)
+
+    def test_primary_constructor_allows_unequal_length_arrays(self) -> None:
+        """Unlike from_waveforms/from_poses, the primary constructor does not validate
+        equal length (design constraint 3)."""
+        positions = np.zeros((3, 3))
+        quaternions = np.zeros((5, 4))
+        w = WaveformSpatialPose(positions, quaternions)
+        self.assertEqual(len(w.positions_array), 3)
+        self.assertEqual(len(w.quaternions_array), 5)
+
+
+class TestTimeAxis(unittest.TestCase):
+    def test_duration_is_dt_times_n_minus_1(self) -> None:
+        w = _make(n=4, dt_seconds=0.5)
+        self.assertEqual(w.duration, PrecisionTimeInterval.from_seconds(1.5))
+
+    def test_duration_zero_for_single_sample(self) -> None:
+        w = _make(n=1, dt_seconds=0.5)
+        self.assertEqual(w.duration, PrecisionTimeInterval.ZERO)
+
+    def test_duration_zero_for_empty(self) -> None:
+        w = WaveformSpatialPose([], [], dt_seconds=0.5)
+        self.assertEqual(w.duration, PrecisionTimeInterval.ZERO)
+
+    def test_duration_seconds(self) -> None:
+        w = _make(n=3, dt_seconds=2.0)
+        self.assertEqual(w.duration_seconds, 4.0)
+
+    def test_sampling_frequency_hz(self) -> None:
+        w = _make(n=2, dt_seconds=0.1)
+        self.assertAlmostEqual(w.sampling_frequency_hz, 10.0)
+
+    def test_nyquist_frequency_hz(self) -> None:
+        w = _make(n=2, dt_seconds=0.1)
+        self.assertAlmostEqual(w.nyquist_frequency_hz, 5.0)
+
+    def test_sample_count_and_len(self) -> None:
+        w = _make(n=3)
+        self.assertEqual(w.sample_count, 3)
+        self.assertEqual(len(w), 3)
+
+    def test_time_axis(self) -> None:
+        w = _make(n=4, dt_seconds=0.5)
+        np.testing.assert_allclose(w.time_axis(), [0.0, 0.5, 1.0, 1.5])
+
+
+class TestSpecCompliance8FromComponentsAndPoseRoundTrip(unittest.TestCase):
+    """§Compliance 8: component_waveforms nested tuple round-trips; from_poses -> w[i]
+    recovers an equal SpatialPose for each i."""
+
+    def test_component_waveforms_field_order(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(1.0, 2.0, 3.0)], [Quaternion.from_components(0.5, 0.5, 0.5, 0.5)]
+        )
+        components = w.component_waveforms
+        self.assertEqual(components.position.x[0], 1.0)
+        self.assertEqual(components.position.y[0], 2.0)
+        self.assertEqual(components.position.z[0], 3.0)
+        self.assertEqual(components.quaternion.w[0], 0.5)
+        self.assertEqual(components.quaternion.x[0], 0.5)
+        self.assertEqual(components.quaternion.y[0], 0.5)
+        self.assertEqual(components.quaternion.z[0], 0.5)
+
+    def test_component_waveforms_share_dt_and_t0(self) -> None:
+        w = _make(n=3, dt_seconds=0.25, t0_seconds=3.0)
+        components = w.component_waveforms
+        for component in (
+            components.position.x,
+            components.position.y,
+            components.position.z,
+            components.quaternion.w,
+            components.quaternion.x,
+            components.quaternion.y,
+            components.quaternion.z,
+        ):
+            self.assertEqual(component.dt, w.dt)
+            self.assertEqual(component.t0, w.t0)
+
+    def test_pose_round_trip_from_poses_then_index(self) -> None:
+        poses = _make_poses(n=5)
+        w = WaveformSpatialPose.from_poses(poses, dt_seconds=0.1, t0_seconds=1.0)
+        for i, pose in enumerate(poses):
+            self.assertEqual(w[i], pose)
+
+    def test_position_waveform_matches_positions_array(self) -> None:
+        w = _make(n=3, dt_seconds=0.5, t0_seconds=1.0)
+        pw = w.position_waveform
+        self.assertIsInstance(pw, WaveformPosition)
+        np.testing.assert_array_equal(pw.positions_array, w.positions_array)
+        self.assertEqual(pw.dt, w.dt)
+        self.assertEqual(pw.t0, w.t0)
+
+    def test_quaternion_waveform_matches_quaternions_array(self) -> None:
+        w = _make(n=3, dt_seconds=0.5, t0_seconds=1.0)
+        qw = w.quaternion_waveform
+        self.assertIsInstance(qw, WaveformQuaternion)
+        np.testing.assert_array_equal(qw.quaternions_array, w.quaternions_array)
+        self.assertEqual(qw.dt, w.dt)
+        self.assertEqual(qw.t0, w.t0)
+
+    def test_from_waveforms_of_own_slices_recovers_equal_waveform(self) -> None:
+        """Acceptance criterion: from_waveforms(w.position_waveform, w.quaternion_waveform) == w."""
+        w = _make(n=4, dt_seconds=0.2, t0_seconds=5.0)
+        rebuilt = WaveformSpatialPose.from_waveforms(w.position_waveform, w.quaternion_waveform)
+        self.assertEqual(rebuilt, w)
+
+    def test_from_components_round_trips_against_from_poses(self) -> None:
+        w = _make(n=5, dt_seconds=0.25, t0_seconds=3.0)
+        components = w.component_waveforms
+        rebuilt = WaveformSpatialPose.from_components(
+            components.position.x,
+            components.position.y,
+            components.position.z,
+            components.quaternion.w,
+            components.quaternion.x,
+            components.quaternion.y,
+            components.quaternion.z,
+        )
+        self.assertEqual(rebuilt, w)
+
+    def test_from_components_mismatched_length_raises_value_error(self) -> None:
+        short = WaveformPosition([Position(1.0, 2.0, 3.0)]).component_waveforms
+        w = _make(n=3)
+        components = w.component_waveforms
+        with self.assertRaises(ValueError):
+            WaveformSpatialPose.from_components(
+                short.x,
+                short.y,
+                short.z,
+                components.quaternion.w,
+                components.quaternion.x,
+                components.quaternion.y,
+                components.quaternion.z,
+            )
+
+    def test_from_components_mismatched_dt_raises_value_error(self) -> None:
+        w1 = _make(n=3, dt_seconds=1.0)
+        w2 = _make(n=3, dt_seconds=2.0)
+        c1 = w1.component_waveforms
+        c2 = w2.component_waveforms
+        with self.assertRaises(ValueError):
+            WaveformSpatialPose.from_components(
+                c1.position.x,
+                c1.position.y,
+                c1.position.z,
+                c2.quaternion.w,
+                c2.quaternion.x,
+                c2.quaternion.y,
+                c2.quaternion.z,
+            )
+
+
+class TestSpecCompliance9UnequalArrays(unittest.TestCase):
+    """§Compliance 9: unequal parallel arrays -> is_valid False, sample_count = min."""
+
+    def test_is_valid_true_for_equal_length(self) -> None:
+        w = _make(n=3)
+        self.assertTrue(w.is_valid)
+
+    def test_is_valid_false_for_unequal_length(self) -> None:
+        w = WaveformSpatialPose(np.zeros((3, 3)), np.zeros((5, 4)))
+        self.assertFalse(w.is_valid)
+
+    def test_sample_count_is_min_positions_longer(self) -> None:
+        w = WaveformSpatialPose(np.zeros((7, 3)), np.zeros((4, 4)))
+        self.assertEqual(w.sample_count, 4)
+        self.assertEqual(len(w), 4)
+
+    def test_sample_count_is_min_quaternions_longer(self) -> None:
+        w = WaveformSpatialPose(np.zeros((2, 3)), np.zeros((9, 4)))
+        self.assertEqual(w.sample_count, 2)
+        self.assertEqual(len(w), 2)
+
+    def test_direct_array_manipulation_produces_unequal_state(self) -> None:
+        """Directly mutating the private arrays (as the chunk doc anticipates) also
+        exercises is_valid/sample_count."""
+        w = _make(n=5)
+        w._positions = w._positions[:2]  # noqa: SLF001
+        self.assertFalse(w.is_valid)
+        self.assertEqual(w.sample_count, 2)
+        self.assertEqual(len(w), 2)
+
+    def test_from_poses_produces_valid_instance(self) -> None:
+        w = WaveformSpatialPose.from_poses(_make_poses(n=4))
+        self.assertTrue(w.is_valid)
+
+    def test_from_waveforms_produces_valid_instance(self) -> None:
+        w = _make(n=4)
+        rebuilt = WaveformSpatialPose.from_waveforms(w.position_waveform, w.quaternion_waveform)
+        self.assertTrue(rebuilt.is_valid)
+
+
+class TestSpecCompliance9IndexingRespectsSampleCount(unittest.TestCase):
+    """Post-audit C-4/C-5: negative indexing, ``get``, and ``pop`` must resolve
+    against ``sample_count`` (the valid prefix), not each raw array's own
+    length, on a deliberately unequal-length instance (3 positions, 2
+    quaternions, ``sample_count == 2``)."""
+
+    def _make_unequal(self) -> WaveformSpatialPose:
+        positions = [Position(0.0, 0.0, 0.0), Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0)]
+        quaternions = [Quaternion.identity(), Quaternion.from_components(0.0, 1.0, 0.0, 0.0)]
+        return WaveformSpatialPose(positions, quaternions)
+
+    def test_negative_index_agrees_with_sample_count_bound_positive_index(self) -> None:
+        w = self._make_unequal()
+        self.assertEqual(w.sample_count, 2)
+        self.assertEqual(w[-1], w[1])
+
+    def test_negative_index_agrees_with_get(self) -> None:
+        w = self._make_unequal()
+        self.assertEqual(w[-1], w.get(-1))
+
+    def test_index_past_sample_count_raises_index_error_even_if_longer_array_has_it(
+        self,
+    ) -> None:
+        w = self._make_unequal()
+        with self.assertRaises(IndexError):
+            _ = w[2]
+
+    def test_pop_negative_removes_sample_count_bound_sample_from_both_arrays(self) -> None:
+        w = self._make_unequal()
+        popped = w.pop(-1)
+        self.assertEqual(
+            popped,
+            SpatialPose(
+                Position(1.0, 1.0, 1.0), Quaternion.from_components(0.0, 1.0, 0.0, 0.0)
+            ),
+        )
+        self.assertEqual(w.sample_count, 1)
+        self.assertEqual(len(w.positions_array), 2)
+        self.assertEqual(len(w.quaternions_array), 1)
+
+
+class TestElementAccess(unittest.TestCase):
+    def test_index_returns_spatial_pose_equal_to_stored_row(self) -> None:
+        w = _make(n=3)
+        self.assertEqual(w[1], _pose(1))
+
+    def test_slice_returns_waveform_spatial_pose(self) -> None:
+        w = _make(n=5, dt_seconds=0.1)
+        sliced = w[1:3]
+        self.assertIsInstance(sliced, WaveformSpatialPose)
+        self.assertEqual(len(sliced), 2)
+        self.assertEqual(sliced[0], _pose(1))
+
+    def test_slice_t0_shift_is_attosecond_exact(self) -> None:
+        w = _make(n=5, dt_seconds=0.1)
+        sliced = w[2:4]
+        self.assertEqual(sliced.t0 - w.t0, w.dt * 2)
+
+    def test_slice_step_not_one_raises(self) -> None:
+        w = _make(n=4)
+        with self.assertRaises(ValueError):
+            _ = w[0:4:2]
+
+    def test_get_in_range(self) -> None:
+        w = _make(n=3)
+        self.assertEqual(w.get(1), _pose(1))
+
+    def test_get_out_of_range_returns_none(self) -> None:
+        w = _make(n=3)
+        self.assertIsNone(w.get(10))
+        self.assertIsNone(w.get(-10))
+
+    def test_iteration_yields_spatial_poses(self) -> None:
+        w = _make(n=3)
+        materialized = list(w)
+        self.assertEqual(materialized, _make_poses(n=3))
+
+    def test_materialized_poses_are_independent_objects(self) -> None:
+        w = _make(n=1)
+        p1 = w[0]
+        p1.position.x = 99.0
+        p2 = w[0]
+        self.assertEqual(p2.position.x, 0.0)
+
+
+class TestAreAllUnit(unittest.TestCase):
+    def test_all_positions_unit_true(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(1.0, 0.0, 0.0), Position(0.0, 1.0, 0.0)],
+            [Quaternion.identity(), Quaternion.identity()],
+        )
+        self.assertTrue(w.are_all_positions_unit)
+
+    def test_all_positions_unit_false(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(1.0, 0.0, 0.0), Position(2.0, 0.0, 0.0)],
+            [Quaternion.identity(), Quaternion.identity()],
+        )
+        self.assertFalse(w.are_all_positions_unit)
+
+    def test_all_quaternions_unit_true(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(1.0, 0.0, 0.0), Position(0.0, 1.0, 0.0)],
+            [Quaternion.identity(), Quaternion.identity()],
+        )
+        self.assertTrue(w.are_all_quaternions_unit)
+
+    def test_all_quaternions_unit_false(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(1.0, 0.0, 0.0)], [Quaternion.from_components(2.0, 0.0, 0.0, 0.0)]
+        )
+        self.assertFalse(w.are_all_quaternions_unit)
+
+    def test_all_unit_true_on_empty(self) -> None:
+        w = WaveformSpatialPose([], [])
+        self.assertTrue(w.are_all_positions_unit)
+        self.assertTrue(w.are_all_quaternions_unit)
+
+
+class TestNormalize(unittest.TestCase):
+    def test_normalize_in_place_normalizes_both_arrays(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(2.0, 0.0, 0.0)], [Quaternion.from_components(2.0, 0.0, 0.0, 0.0)]
+        )
+        w.normalize()
+        np.testing.assert_allclose(w.positions_array, [[1.0, 0.0, 0.0]])
+        np.testing.assert_allclose(w.quaternions_array, [[1.0, 0.0, 0.0, 0.0]])
+
+    def test_normalized_returns_copy(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(2.0, 0.0, 0.0)], [Quaternion.from_components(2.0, 0.0, 0.0, 0.0)]
+        )
+        result = w.normalized()
+        np.testing.assert_allclose(result.positions_array, [[1.0, 0.0, 0.0]])
+        np.testing.assert_allclose(w.positions_array, [[2.0, 0.0, 0.0]])
+
+    def test_normalize_zero_position_raises_value_error(self) -> None:
+        w = WaveformSpatialPose([Position(0.0, 0.0, 0.0)], [Quaternion.identity()])
+        with self.assertRaises(ValueError):
+            w.normalize()
+
+    def test_normalize_zero_quaternion_raises_value_error(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(1.0, 0.0, 0.0)], [Quaternion.from_components(0.0, 0.0, 0.0, 0.0)]
+        )
+        with self.assertRaises(ValueError):
+            w.normalize()
+
+    def test_normalize_zero_position_leaves_quaternions_unmodified(self) -> None:
+        """Position is checked first; a failure there must not mutate quaternions."""
+        w = WaveformSpatialPose(
+            [Position(0.0, 0.0, 0.0)], [Quaternion.from_components(2.0, 0.0, 0.0, 0.0)]
+        )
+        with self.assertRaises(ValueError):
+            w.normalize()
+        np.testing.assert_allclose(w.quaternions_array, [[2.0, 0.0, 0.0, 0.0]])
+
+
+class TestSpecCompliance10VectorizedBulkOps(unittest.TestCase):
+    """§Compliance 10: bulk ops never construct per-element objects; smoke-test at scale."""
+
+    def test_normalize_smoke_test_large_n(self) -> None:
+        n = 1_000_000
+        rng = np.random.default_rng(0)
+        positions = rng.standard_normal((n, 3)) + 1.0
+        quaternions = rng.standard_normal((n, 4)) + 1.0
+        w = WaveformSpatialPose(positions, quaternions)
+        start = time.monotonic()
+        w.normalize()
+        elapsed = time.monotonic() - start
+        self.assertLess(elapsed, 5.0)
+
+    def test_component_waveforms_smoke_test_large_n(self) -> None:
+        n = 1_000_000
+        rng = np.random.default_rng(0)
+        positions = rng.standard_normal((n, 3))
+        quaternions = rng.standard_normal((n, 4))
+        w = WaveformSpatialPose(positions, quaternions)
+        start = time.monotonic()
+        components = w.component_waveforms
+        elapsed = time.monotonic() - start
+        self.assertLess(elapsed, 5.0)
+        self.assertEqual(len(components.position.x), n)
+
+
+class TestMutation(unittest.TestCase):
+    def test_append(self) -> None:
+        w = WaveformSpatialPose([Position(1.0, 1.0, 1.0)], [Quaternion.identity()])
+        w.append(SpatialPose(Position(2.0, 2.0, 2.0), Quaternion.identity()))
+        self.assertEqual(len(w), 2)
+        self.assertEqual(w[1], SpatialPose(Position(2.0, 2.0, 2.0), Quaternion.identity()))
+
+    def test_append_values(self) -> None:
+        w = WaveformSpatialPose([Position(1.0, 1.0, 1.0)], [Quaternion.identity()])
+        w.append_values(
+            [
+                SpatialPose(Position(2.0, 2.0, 2.0), Quaternion.identity()),
+                SpatialPose(Position(3.0, 3.0, 3.0), Quaternion.identity()),
+            ]
+        )
+        self.assertEqual(len(w), 3)
+
+    def test_prepend_shifts_t0_back_by_one_dt(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(2.0, 2.0, 2.0)], [Quaternion.identity()], dt_seconds=1.0
+        )
+        original_t0 = w.t0
+        w.prepend(SpatialPose(Position(1.0, 1.0, 1.0), Quaternion.identity()))
+        self.assertEqual(len(w), 2)
+        self.assertEqual(w[0], SpatialPose(Position(1.0, 1.0, 1.0), Quaternion.identity()))
+        self.assertEqual(original_t0 - w.t0, w.dt)
+
+    def test_prepend_values_shifts_t0_back_by_k_dt(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(3.0, 3.0, 3.0)], [Quaternion.identity()], dt_seconds=1.0
+        )
+        original_t0 = w.t0
+        w.prepend_values(
+            [
+                SpatialPose(Position(1.0, 1.0, 1.0), Quaternion.identity()),
+                SpatialPose(Position(2.0, 2.0, 2.0), Quaternion.identity()),
+            ]
+        )
+        self.assertEqual(len(w), 3)
+        self.assertEqual(original_t0 - w.t0, w.dt * 2)
+
+    def test_insert(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(1.0, 1.0, 1.0), Position(3.0, 3.0, 3.0)],
+            [Quaternion.identity(), Quaternion.identity()],
+        )
+        w.insert(1, SpatialPose(Position(2.0, 2.0, 2.0), Quaternion.identity()))
+        self.assertEqual(len(w), 3)
+        self.assertEqual(w[1], SpatialPose(Position(2.0, 2.0, 2.0), Quaternion.identity()))
+
+    def test_replace(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0)],
+            [Quaternion.identity(), Quaternion.identity()],
+        )
+        w.replace(1, SpatialPose(Position(99.0, 99.0, 99.0), Quaternion.identity()))
+        self.assertEqual(w[1], SpatialPose(Position(99.0, 99.0, 99.0), Quaternion.identity()))
+
+    def test_replace_range(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0), Position(3.0, 3.0, 3.0)],
+            [Quaternion.identity(), Quaternion.identity(), Quaternion.identity()],
+        )
+        w.replace_range(
+            slice(1, 3),
+            [
+                SpatialPose(Position(8.0, 8.0, 8.0), Quaternion.identity()),
+                SpatialPose(Position(9.0, 9.0, 9.0), Quaternion.identity()),
+            ],
+        )
+        self.assertEqual(w[1], SpatialPose(Position(8.0, 8.0, 8.0), Quaternion.identity()))
+        self.assertEqual(w[2], SpatialPose(Position(9.0, 9.0, 9.0), Quaternion.identity()))
+
+    def test_pop_default_removes_last(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0)],
+            [Quaternion.identity(), Quaternion.identity()],
+        )
+        value = w.pop()
+        self.assertEqual(value, SpatialPose(Position(2.0, 2.0, 2.0), Quaternion.identity()))
+        self.assertEqual(len(w), 1)
+
+    def test_pop_with_index(self) -> None:
+        w = WaveformSpatialPose(
+            [Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0)],
+            [Quaternion.identity(), Quaternion.identity()],
+        )
+        value = w.pop(0)
+        self.assertEqual(value, SpatialPose(Position(1.0, 1.0, 1.0), Quaternion.identity()))
+
+    def test_pop_on_empty_raises_index_error(self) -> None:
+        w = WaveformSpatialPose([], [])
+        with self.assertRaises(IndexError):
+            w.pop()
+
+    def test_pop_out_of_range_raises_index_error(self) -> None:
+        """C-14: only the empty case was previously pinned."""
+        w = WaveformSpatialPose(
+            [Position(1.0, 1.0, 1.0), Position(2.0, 2.0, 2.0)],
+            [Quaternion.identity(), Quaternion.identity()],
+        )
+        with self.assertRaises(IndexError):
+            w.pop(5)
+
+    def test_clear_empties_both_arrays(self) -> None:
+        w = WaveformSpatialPose([Position(1.0, 1.0, 1.0)], [Quaternion.identity()])
+        w.clear()
+        self.assertEqual(len(w), 0)
+        self.assertEqual(w.positions_array.shape, (0, 3))
+        self.assertEqual(w.quaternions_array.shape, (0, 4))
+
+
+class TestSpecCompliance2ExtendConcatenateAndFromWaveforms(unittest.TestCase):
+    """§Compliance 2: dt mismatch on extend/concatenate raises WaveformCompatibilityError;
+    dt/count mismatch on from_waveforms raises ValueError."""
+
+    def test_extend_equal_dt_appends(self) -> None:
+        w1 = _make(n=2, dt_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=1.0)
+        w1.extend(w2)
+        self.assertEqual(len(w1), 4)
+
+    def test_extend_dt_mismatch_raises(self) -> None:
+        w1 = _make(n=2, dt_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=2.0)
+        with self.assertRaises(WaveformCompatibilityError):
+            w1.extend(w2)
+
+    def test_concatenate_equal_dt(self) -> None:
+        w1 = _make(n=2, dt_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=1.0)
+        result = w1.concatenate(w2)
+        self.assertEqual(len(result), 4)
+        self.assertEqual(len(w1), 2)  # original unmodified
+
+    def test_concatenate_dt_mismatch_raises(self) -> None:
+        w1 = _make(n=2, dt_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=2.0)
+        with self.assertRaises(WaveformCompatibilityError):
+            w1.concatenate(w2)
+
+    def test_from_waveforms_count_mismatch_raises_value_error(self) -> None:
+        position_waveform = WaveformPosition([Position(1.0, 1.0, 1.0)], dt_seconds=1.0)
+        quaternion_waveform = WaveformQuaternion(
+            [Quaternion.identity(), Quaternion.identity()], dt_seconds=1.0
+        )
+        with self.assertRaises(ValueError):
+            WaveformSpatialPose.from_waveforms(position_waveform, quaternion_waveform)
+
+    def test_from_waveforms_dt_mismatch_raises_value_error(self) -> None:
+        position_waveform = WaveformPosition([Position(1.0, 1.0, 1.0)], dt_seconds=1.0)
+        quaternion_waveform = WaveformQuaternion([Quaternion.identity()], dt_seconds=2.0)
+        with self.assertRaises(ValueError):
+            WaveformSpatialPose.from_waveforms(position_waveform, quaternion_waveform)
+
+    def test_from_waveforms_dt_mismatch_is_not_compatibility_error(self) -> None:
+        """Design constraint 2: from_waveforms raises plain ValueError, not
+        WaveformCompatibilityError (unlike extend/concatenate)."""
+        position_waveform = WaveformPosition([Position(1.0, 1.0, 1.0)], dt_seconds=1.0)
+        quaternion_waveform = WaveformQuaternion([Quaternion.identity()], dt_seconds=2.0)
+        try:
+            WaveformSpatialPose.from_waveforms(position_waveform, quaternion_waveform)
+        except WaveformCompatibilityError:
+            self.fail("from_waveforms raised WaveformCompatibilityError, expected plain ValueError")
+        except ValueError:
+            pass
+
+
+class TestEquality(unittest.TestCase):
+    def test_equal_positions_quaternions_dt_t0(self) -> None:
+        w1 = _make(n=2, dt_seconds=0.5, t0_seconds=1.0)
+        w2 = _make(n=2, dt_seconds=0.5, t0_seconds=1.0)
+        self.assertEqual(w1, w2)
+
+    def test_unequal_positions(self) -> None:
+        w1 = WaveformSpatialPose([Position(1.0, 1.0, 1.0)], [Quaternion.identity()])
+        w2 = WaveformSpatialPose([Position(2.0, 2.0, 2.0)], [Quaternion.identity()])
+        self.assertNotEqual(w1, w2)
+
+    def test_unequal_quaternions(self) -> None:
+        w1 = WaveformSpatialPose([Position(1.0, 1.0, 1.0)], [Quaternion.identity()])
+        w2 = WaveformSpatialPose(
+            [Position(1.0, 1.0, 1.0)], [Quaternion.from_components(0.0, 1.0, 0.0, 0.0)]
+        )
+        self.assertNotEqual(w1, w2)
+
+    def test_unequal_dt(self) -> None:
+        w1 = _make(n=2, dt_seconds=0.5)
+        w2 = _make(n=2, dt_seconds=1.0)
+        self.assertNotEqual(w1, w2)
+
+    def test_unequal_t0(self) -> None:
+        w1 = _make(n=2, t0_seconds=0.0)
+        w2 = _make(n=2, t0_seconds=1.0)
+        self.assertNotEqual(w1, w2)
+
+    def test_not_equal_to_other_type(self) -> None:
+        w = _make(n=2)
+        self.assertNotEqual(w, "not a waveform")
+
+    def test_unhashable(self) -> None:
+        w = _make(n=2)
+        with self.assertRaises(TypeError):
+            hash(w)
+
+
+class TestArrayInterop(unittest.TestCase):
+    """mathToolsArchitecture.md §API idioms: ``__array__`` so ``np.asarray(w)`` works.
+
+    waveformCore.md §Array shape contract: ``(sample_count, 7)``, columns
+    ``[x, y, z, w, i, j, k]``.
+    """
+
+    def test_asarray_shape_is_sample_count_by_7(self) -> None:
+        w = _make(n=4)
+        self.assertEqual(np.asarray(w).shape, (4, 7))
+
+    def test_asarray_columns_are_position_then_quaternion(self) -> None:
+        w = _make(n=3)
+        arr = np.asarray(w)
+        np.testing.assert_array_equal(arr[:, :3], w.positions_array)
+        np.testing.assert_array_equal(arr[:, 3:], w.quaternions_array)
+
+    def test_asarray_reads_the_sample_count_prefix_for_unequal_arrays(self) -> None:
+        """Depends on chunk 49: sample_count is min(len(positions), len(quaternions))."""
+        w = WaveformSpatialPose(np.zeros((5, 3)), np.zeros((2, 4)))
+        arr = np.asarray(w)
+        self.assertEqual(arr.shape, (2, 7))
+
+    def test_asarray_returns_a_copy(self) -> None:
+        w = _make(n=2)
+        arr = np.asarray(w)
+        arr[0, 0] = 99.0
+        self.assertNotEqual(w[0].position.x, 99.0)
+
+    def test_array_copy_false_raises_value_error(self) -> None:
+        w = _make(n=2)
+        with self.assertRaises(ValueError):
+            np.array(w, copy=False)
+
+
+class TestIsClose(unittest.TestCase):
+    def test_true_within_tolerance(self) -> None:
+        # index 1's x-component is nonzero (_pose(1) = Position(1, 2, 3)); atol
+        # defaults to 0.0 (mirroring Position.isclose), so a perturbation at an
+        # exact-zero component would not be "close" -- perturb a nonzero one.
+        w1 = _make(n=3)
+        positions = w1.positions_array
+        positions[1, 0] += 1e-10
+        w2 = WaveformSpatialPose(positions, w1.quaternions_array, dt=w1.dt, t0=w1.t0)
+        self.assertTrue(w1.isclose(w2))
+
+    def test_false_outside_tolerance(self) -> None:
+        w1 = _make(n=3)
+        positions = w1.positions_array
+        positions[1, 0] += 1.0
+        w2 = WaveformSpatialPose(positions, w1.quaternions_array, dt=w1.dt, t0=w1.t0)
+        self.assertFalse(w1.isclose(w2))
+
+    def test_false_on_differing_sample_count(self) -> None:
+        w1 = _make(n=3)
+        w2 = _make(n=4)
+        self.assertFalse(w1.isclose(w2))
+
+    def test_false_on_differing_dt(self) -> None:
+        w1 = _make(n=3, dt_seconds=1.0)
+        w2 = _make(n=3, dt_seconds=2.0)
+        self.assertFalse(w1.isclose(w2))
+
+    def test_double_cover_negated_quaternions_is_close(self) -> None:
+        w = _make(n=3)
+        negated = WaveformSpatialPose(
+            w.positions_array, -w.quaternions_array, dt=w.dt, t0=w.t0
+        )
+        self.assertTrue(w.isclose(negated))
+
+    def test_true_for_identical_waveform(self) -> None:
+        w1 = _make(n=3)
+        w2 = _make(n=3)
+        self.assertTrue(w1.isclose(w2))
+
+
+class TestRepr(unittest.TestCase):
+    def test_repr_contains_sample_count(self) -> None:
+        w = _make(n=3)
+        self.assertIn("3", repr(w))
+        self.assertIn("WaveformSpatialPose", repr(w))
+
+    def test_repr_uses_min_sample_count_for_unequal_arrays(self) -> None:
+        w = WaveformSpatialPose(np.zeros((5, 3)), np.zeros((2, 4)))
+        self.assertIn("2", repr(w))
+
+
+if __name__ == "__main__":
+    unittest.main()