diff --git a/.github/COPILOT_INSTRUCTIONS.md b/.github/COPILOT_INSTRUCTIONS.md
index cfbaf3a..86980a4 100644
--- a/.github/COPILOT_INSTRUCTIONS.md
+++ b/.github/COPILOT_INSTRUCTIONS.md
@@ -1,348 +1,348 @@
-# Copilot Instructions: Clean Architecture guidance for ncplot7py
-
-Purpose
--------
-This document tells Copilot (or other AI assistants) how to produce code aligned with a clean, maintainable architecture for a large Python project. It also includes notes for TypeScript when the repo grows into multi-language or monorepo setups.
-
-High-level contract for suggestions
-----------------------------------
-- Inputs: existing code context and a concrete change request (file snippet, issue, or feature description).
-- Outputs: small, focused, well-typed code changes; updated tests; brief rationale in PR/commit message when behavior changes.
-- Error modes: when a suggestion breaks API, include a migration note and tests; prefer additive changes.
-
-Core architecture principles
----------------------------
-- Layering: keep Domain (core rules), Application (use-cases), Interfaces/Adapters, and Infrastructure separate.
-- Dependency rule: code dependencies point inward (outer layers depend on inner layers, inner layers know nothing about outer layers).
-- Dependency inversion: use abstractions (Protocols/Interfaces) so application code depends on contracts, not concrete implementations.
-- Side-effects at the edges: I/O (DB, network, filesystem, plotting libraries) belong only in infrastructure/adapters.
-
-Recommended repository layout (scalable)
-----------------------------------------
-Use a src-style package layout. Example for a single large package:
-
-src/
-	ncplot7py/
-		domain/
-			models.py        # dataclasses, value objects, domain errors
-			services.py      # pure domain logic
-		application/
-			usecases.py      # orchestrators that use domain services & ports
-		adapters/
-			api.py           # controllers/entrypoints (FastAPI, CLI)
-			serializers.py   # mapping external <-> domain types
-		infrastructure/
-			netcdf_reader.py # concrete I/O implementations
-			persistence.py   # DB adapters
-			plotting_impl.py # plotting wrapper implementations
-		shared/
-			config.py
-			types.py
-		__init__.py
-tests/
-	unit/
-	integration/
-pyproject.toml
-README.md
-
-For monorepos or multi-package setups, apply the same layer boundaries inside each package.
-
-Typing & interfaces
--------------------
-- Python: use dataclasses for domain models, typing.Protocol for ports, and mypy/pyright in CI.
-- Keep Protocols near the consumer (application/usecase) — not buried in infrastructure.
-
-How to structure a new feature (recommended steps)
------------------------------------------------
-1. Design domain types (dataclasses) and pure validations in `domain/`.
-2. Implement a use-case in `application/` that depends on a small Protocol (port) for I/O.
-3. Provide concrete implementations in `infrastructure/`.
-4. Expose adapters in `adapters/` (HTTP/CLI) that translate external requests into domain inputs and call use-cases.
-5. Add unit tests for domain and application; add integration tests for infrastructure with small test assets.
-
-Small illustrative pattern (reader example)
------------------------------------------
-# domain/models.py
-from dataclasses import dataclass
-
-@dataclass
-class Metadata:
-		variable_names: list[str]
-		attributes: dict
-
-# application/usecases.py
-from typing import Protocol
-from ..domain.models import Metadata
-
-class MetadataReader(Protocol):
-		def read(self, path: str) -> Metadata: ...
-
-def extract_metadata(path: str, reader: MetadataReader) -> Metadata:
-		md = reader.read(path)
-		# domain validation or transformations
-		return md
-
-# infrastructure/netcdf_reader.py
-from ..domain.models import Metadata
-
-class NetCDFReader:
-		def read(self, path: str) -> Metadata:
-				# use xarray/netCDF4 to read and return domain.Metadata
-				...
-
-Testing strategy
-----------------
-- Unit tests: target `domain/` and `application/` only; mock ports. Fast and deterministic.
-- Integration tests: test `infrastructure/` + `adapters/` with small real assets (temporary files, fixtures).
-- Test pyramid: many unit tests, fewer integration tests, minimal end-to-end tests.
-
-Tooling & CI recommendations
----------------------------
-- Formatting: Black + isort. Linting: ruff/flake8. Type checks: mypy/pyright.
-- Testing: prefer the standard library (`unittest`, `doctest`, `unittest.mock`). Use third-party test runners only with explicit justification and PR rationale.
-- Packaging: `pyproject.toml` (PEP 621) with Poetry or pip-tools; keep `dependencies` minimal or empty unless runtime packages are justified.
-- CI: run format, lint, typecheck, and the stdlib unit tests on PRs; run integration tests on main branch or scheduled runs.
-
-CI / cocompiler test commands (PowerShell)
------------------------------------------
-When running tests in a Windows PowerShell environment (or in CI that emulates it), set the `PYTHONPATH` to the repository `src` directory so imports resolve correctly. The project uses the standard library `unittest` discovery for both unit and integration tests. Example commands to include in your CI job or cocompiler step:
-
-```powershell
-$env:PYTHONPATH = 'src'; python -m unittest discover -s tests/unit -p "test_*.py" -v
-$env:PYTHONPATH = 'src'; python -m unittest discover -s tests/integration -p "test_*.py" -v
-```
-
-Place these commands in the CI job that runs tests. If your CI runner uses bash or another shell, adapt the equivalent `PYTHONPATH=src python -m unittest ...` syntax for that shell.
-
-Dependencies policy
--------------------
-- Default: prefer Python standard library for runtime features. Do not add new third-party runtime dependencies unless there is a strong, documented justification.
-- If a third-party package is absolutely necessary, prefer small, well-maintained packages available on PyPI and add them explicitly to `pyproject.toml` or `requirements.txt` with a short rationale in the related PR.
-- Developer tooling (formatters, linters, type-checkers, test runners) are allowed as dev-dependencies, but should not be shipped as runtime requirements.
-- Avoid bringing in heavy, opaque dependencies for simple functionality that can be implemented with the standard library.
-
-Coding guidelines
------------------
-Follow these practical rules for readable, maintainable code across the codebase.
-
-- Style and formatting
-	- Use Black formatting and an 88-character line width. Run `isort` for import ordering.
-	- Prefer expressive, explicit code over clever one-liners.
-	- Use f-strings for string interpolation.
-
-- Naming
-	- Modules and packages: short, lowercase, underscore-separated if needed (snake_case).
-	- Functions and variables: snake_case.
-	- Classes: PascalCase.
-	- Constants: UPPER_SNAKE_CASE.
-
-- Types & typing
-	- Add type hints for public functions and methods (PEP 484). Prefer `typing` generics over `Any`.
-	- Use `dataclasses` for domain models and `typing.Protocol` for interfaces/ports.
-	- Run static type checks in CI (mypy or pyright). Keep strictness where practical.
-
-- Docstrings & documentation
-	- Document public functions, classes and modules with Google or NumPy style docstrings. Include Args, Returns, and Raises sections for public APIs.
-	- Document public functions, classes and modules with Google or NumPy style docstrings. Include Args, Returns, and Raises sections for public APIs.
-	- Add short examples when behavior is non-obvious.
-
-	Doctest guidelines
-	------------------
-	Follow these rules when adding doctest examples in docstrings so they run reliably with `python -m doctest` in CI.
-
-	- Keep examples terse and deterministic
-	  - Examples must run without interactive user input and produce the same output on every run.
-	  - Avoid printing memory addresses, timestamps, UUIDs, or platform-dependent output. If randomness is required, set a fixed seed inside the example.
-
-	- Importing in examples
-	  - Use full imports that will work when the module is executed from the project root. Example:
-	    >>> from ncplot7py.domain.models import Metadata
-
-	- Use exact, stable output
-	  - Show canonical string or repr output that is stable across Python versions when possible.
-	  - For floating-point examples, either round the result in the example or use doctest directives such as `# doctest: +ELLIPSIS` to match approximate output. Example:
-	    >>> round(0.1 + 0.2, 6)
-	    0.3
-	    >>> 0.1 + 0.2  # doctest: +ELLIPSIS
-	    0.3000000...
-
-	- Use doctest option flags when needed
-	  - Use `# doctest: +ELLIPSIS` to allow partial matching, or `# doctest: +NORMALIZE_WHITESPACE` if whitespace differs.
-	  - Avoid overusing flags; prefer making examples precise.
-
-	- Setup and long examples
-	  - Keep long examples out of function docstrings; put them in `examples/` or `README.md` and test them separately if needed.
-	  - If an example requires setup (creating temp files, sample NetCDF), show only the minimal reproducible snippet in the docstring and add a full integration example in `tests/integration/`.
-
-	- Avoid side effects
-	  - Do not perform destructive actions (deleting files, network calls) in doctest examples. If demonstrating I/O, use temporary files within the example or put the full scenario in integration tests.
-
-	- Running doctests in CI
-	  - CI should run: `python -m doctest -v src/ncplot7py/*.py` (or a narrower file list). The `pyproject.toml` includes a `doctest-command` showing the canonical command.
-
-	- Example of a good doctest
-	  def add(a, b):
-	      """
-	      Return the sum of two numbers.
-
-	      >>> add(1, 2)
-	      3
-	      >>> round(add(0.1, 0.2), 6)
-	      0.3
-	      """
-	      return a + b
-
-	- Notes for contributors
-	  - Keep doctest examples focused on documenting observable behavior, not internal implementation.
-	  - If you add or change doctest examples, run the doctest command locally before opening a PR.
-
-- Imports
-	- Use absolute imports within the package (from ncplot7py.xxx import Y).
-	- Group imports: stdlib, third-party, local (use isort to enforce).
-
-- Exceptions & error handling
-	- Prefer specific exceptions (ValueError, TypeError, etc.). Avoid bare except: clauses.
-	- Define domain-specific exception types in `domain/` when callers need to distinguish error classes.
-	- Fail fast and validate inputs early. Keep error messages clear and actionable.
-
-- Logging
-	- Use the standard `logging` module. Modules should get a logger via `logger = logging.getLogger(__name__)`.
-	- Do not use `print()` for production/logging; reserve `print()` only for quick debugging (remove before commit).
-
-- Resource management
-	- Use context managers for files, network connections and other resources (`with` statement).
-	- Avoid mutable default arguments. Use `None` and set defaults inside the function.
-
-- Concurrency
-	- Prefer simple solutions (threading, multiprocessing, asyncio) only when necessary. Encapsulate concurrency in infrastructure layer adapters and keep domain/use-cases synchronous unless the whole stack is async.
-
-	- Tests
-		- Follow Arrange-Act-Assert. Keep unit tests fast and deterministic.
-		- Use the standard library `unittest` for unit tests (TestCase classes, setUp/tearDown, subTest) and `unittest.mock` for mocking.
-		- For table-driven tests, prefer `subTest` or explicit loops inside a TestCase rather than adding test framework dependencies.
-		- Use `doctest` for executable examples embedded in docstrings when helpful.
-		- For integration tests, use temporary directories (`tempfile.TemporaryDirectory`) and small sample assets. Clean up after tests.
-
-- Commits & PRs
-	- Commit message: short title (<=72 chars), optional body with rationale and any migration notes.
-	- PR description: explain what changed, why, tests added/updated, and any migration steps for consumers.
-	- Keep PRs focused: each PR should implement a single logical change or narrowly related set of changes.
-
-- Code review checklist
-	- Does the change respect layer boundaries (domain vs adapters vs infra)?
-	- Are side-effects localized to infrastructure/adapters?
-	- Are types and docstrings present for public APIs?
-	- Are there unit tests for domain/application logic and integration tests for adapters where needed?
-	- Is the change small and well-commented (or does it include a rationale in the PR)?
-
-Current project structure
--------------------------
-The repository already follows the recommended clean-architecture layout. Use these locations when adding or editing files so Copilot suggestions target the correct layer.
-
-Top-level files
-- `LICENSE`, `README.md`, `pyproject.toml`, `dev-requirements.txt`
-- `.github/COPILOT_INSTRUCTIONS.md` (this file)
-
-Package layout (src-style)
-- `src/ncplot7py/` — main package root
-	- `cli/` — CLI entrypoint and command wiring
-		- `main.py` — CLI implementation (simulate, plot subcommands)
-	- `domain/` — pure domain dataclasses and exceptions
-		- `models.py` — NCNode, ToolpathPoint, MachineSpec, SimulationResult
-		- `exceptions.py` — domain-specific exception types
-	- `application/` — use-cases / orchestrators
-		- `simulate.py` — parse -> simulate orchestration utilities
-	- `interfaces/` — Protocols / interface definitions
-		- `parser.py` — `Parser` Protocol
-		- `machine.py` — `MachineDriver` Protocol
-		- `plotter.py` — `Plotter` Protocol
-		- (intended) `nc_control.py` — NC control Protocol / base class (interface for NC controllers)
-	- `infrastructure/` — concrete adapters and implementations (I/O, drivers, plotters)
-		- `parsers/gcode_parser.py` — minimal G-code parser (registers as `gcode`)
-		- `machines/generic_machine.py` — simple generic machine driver (registers as `generic`)
-		- `plotters/matplotlib_plotter.py` — optional matplotlib adapter (registers `matplotlib` plotter)
-		- `persistence/` — storage adapters (file-based persistence stubs)
-	- `shared/` — small shared helpers and registry
-		- `registry.py` — runtime registry resolving parsers/machines/plotters
-
-Tests and examples
-- `tests/unit/` — unit tests (e.g. `test_simulate_flow.py`)
-- `tests/integration/` — integration tests (parsing+simulate+plot if optional deps installed)
-- `examples/` and `data/nc-examples/` — sample NC files and fixtures for integration tests and demos
-
-Notes
-- Optional dependencies (plotting) are declared under `pyproject.toml` extras: `plotting = ["matplotlib>=3.0,<4.0"]`.
-- Concrete implementations register with the `shared.registry` so CLI and application code can resolve components by name (e.g. parser `gcode`, machine `generic`, plotter `matplotlib`).
-- When Copilot generates code that crosses layers, update or create files in the matching package path above.
-
-
-How Copilot should behave when editing code (updated)
-----------------------------------------------------
-- When implementing features, prefer stdlib solutions first (os, pathlib, csv, json, tempfile, subprocess, builtins, typing, dataclasses).
-- If a suggestion uses a third-party library, add a short justification comment and note that adding a dependency requires an explicit PR description and approval.
-- For packages that must be added, include an update to `pyproject.toml` or `requirements.txt` and a brief migration note in the PR description.
-
-How Copilot should behave when editing code
-------------------------------------------
-- Make minimal, well-scoped edits. If a feature crosses layers, create the smallest set of files required and update tests.
-- Prefer adding a Protocol and refactoring callers to depend on it rather than editing many concrete implementations.
-- Always include or update unit tests for any domain or application logic changes.
-
-Do / Don't (architecture-focused)
----------------------------------
-- Do: keep domain pure, add types and docstrings, add focused unit tests, and include migration notes for breaking changes.
-- Don't: put business logic in HTTP handlers, scatter I/O into domain modules, or introduce large runtime deps without justification.
-
-Security
---------
-- Never add secrets to the repo. Use environment variables or secrets managers and document required env vars in `.env.example`.
-
-Customization & next steps
---------------------------
-This file is a living guideline. To change rules:
-- Edit this file and commit.
-- Optionally add CI checks to enforce specific rules (typecheck, linter, format).
-
-I can also scaffold starter artifacts if you want:
-- `pyproject.toml` + minimal `src/` layout
-- Example `MetadataReader` Protocol + `NetCDFReader` implementation + unit/integration tests
-- A GitHub Actions workflow that runs Black, ruff/flake8, mypy, and the stdlib tests on PRs
-
-
-
-
-
-## Error handling (use the structured system)
-- Use `ExceptionNode` and `ExceptionTyps` from `ncplot7py.domain.exceptions`.
-- Prefer the helper `raise_nc_error(...)` to automatically populate trace and caret when possible.
-
-Example:
-```python
-from ncplot7py.domain.exceptions import ExceptionTyps, raise_nc_error
-
-if token not in allowed:
-    raise_nc_error(
-        ExceptionTyps.NCCodeErrors,
-        1001,  # see locales XML id "1:1001"
-        value=token,
-        file=filename,
-        line=lineno,
-        source_line=line_text,
-    )
-```
-
--## Localization of messages
-- Message templates are in `src/ncplot7py/locales/{lang}.xml`.
-- Keys are `{typ_value}:{code}`. Use placeholders `{value}`, `{line}`, `{code}`, `{typ}`.
-- To format for output:
-```python
-from ncplot7py.domain.i18n import MessageCatalog
-text = MessageCatalog().format_exception(exc, lang="en")
-```
-
-## Tracing
-- Provide `file`, `line`, `source_line` (and `value`) when raising errors to get a caret under the offending token.
-- If you know the exact `column`, pass it; otherwise `raise_nc_error` will try to infer it by searching `value` in `source_line`.
-
-
--- End of architecture-focused Copilot instructions --
+# Copilot Instructions: Clean Architecture guidance for ncplot7py
+
+Purpose
+-------
+This document tells Copilot (or other AI assistants) how to produce code aligned with a clean, maintainable architecture for a large Python project. It also includes notes for TypeScript when the repo grows into multi-language or monorepo setups.
+
+High-level contract for suggestions
+----------------------------------
+- Inputs: existing code context and a concrete change request (file snippet, issue, or feature description).
+- Outputs: small, focused, well-typed code changes; updated tests; brief rationale in PR/commit message when behavior changes.
+- Error modes: when a suggestion breaks API, include a migration note and tests; prefer additive changes.
+
+Core architecture principles
+---------------------------
+- Layering: keep Domain (core rules), Application (use-cases), Interfaces/Adapters, and Infrastructure separate.
+- Dependency rule: code dependencies point inward (outer layers depend on inner layers, inner layers know nothing about outer layers).
+- Dependency inversion: use abstractions (Protocols/Interfaces) so application code depends on contracts, not concrete implementations.
+- Side-effects at the edges: I/O (DB, network, filesystem, plotting libraries) belong only in infrastructure/adapters.
+
+Recommended repository layout (scalable)
+----------------------------------------
+Use a src-style package layout. Example for a single large package:
+
+src/
+	ncplot7py/
+		domain/
+			models.py        # dataclasses, value objects, domain errors
+			services.py      # pure domain logic
+		application/
+			usecases.py      # orchestrators that use domain services & ports
+		adapters/
+			api.py           # controllers/entrypoints (FastAPI, CLI)
+			serializers.py   # mapping external <-> domain types
+		infrastructure/
+			netcdf_reader.py # concrete I/O implementations
+			persistence.py   # DB adapters
+			plotting_impl.py # plotting wrapper implementations
+		shared/
+			config.py
+			types.py
+		__init__.py
+tests/
+	unit/
+	integration/
+pyproject.toml
+README.md
+
+For monorepos or multi-package setups, apply the same layer boundaries inside each package.
+
+Typing & interfaces
+-------------------
+- Python: use dataclasses for domain models, typing.Protocol for ports, and mypy/pyright in CI.
+- Keep Protocols near the consumer (application/usecase) — not buried in infrastructure.
+
+How to structure a new feature (recommended steps)
+-----------------------------------------------
+1. Design domain types (dataclasses) and pure validations in `domain/`.
+2. Implement a use-case in `application/` that depends on a small Protocol (port) for I/O.
+3. Provide concrete implementations in `infrastructure/`.
+4. Expose adapters in `adapters/` (HTTP/CLI) that translate external requests into domain inputs and call use-cases.
+5. Add unit tests for domain and application; add integration tests for infrastructure with small test assets.
+
+Small illustrative pattern (reader example)
+-----------------------------------------
+# domain/models.py
+from dataclasses import dataclass
+
+@dataclass
+class Metadata:
+		variable_names: list[str]
+		attributes: dict
+
+# application/usecases.py
+from typing import Protocol
+from ..domain.models import Metadata
+
+class MetadataReader(Protocol):
+		def read(self, path: str) -> Metadata: ...
+
+def extract_metadata(path: str, reader: MetadataReader) -> Metadata:
+		md = reader.read(path)
+		# domain validation or transformations
+		return md
+
+# infrastructure/netcdf_reader.py
+from ..domain.models import Metadata
+
+class NetCDFReader:
+		def read(self, path: str) -> Metadata:
+				# use xarray/netCDF4 to read and return domain.Metadata
+				...
+
+Testing strategy
+----------------
+- Unit tests: target `domain/` and `application/` only; mock ports. Fast and deterministic.
+- Integration tests: test `infrastructure/` + `adapters/` with small real assets (temporary files, fixtures).
+- Test pyramid: many unit tests, fewer integration tests, minimal end-to-end tests.
+
+Tooling & CI recommendations
+---------------------------
+- Formatting: Black + isort. Linting: ruff/flake8. Type checks: mypy/pyright.
+- Testing: prefer the standard library (`unittest`, `doctest`, `unittest.mock`). Use third-party test runners only with explicit justification and PR rationale.
+- Packaging: `pyproject.toml` (PEP 621) with Poetry or pip-tools; keep `dependencies` minimal or empty unless runtime packages are justified.
+- CI: run format, lint, typecheck, and the stdlib unit tests on PRs; run integration tests on main branch or scheduled runs.
+
+CI / cocompiler test commands (PowerShell)
+-----------------------------------------
+When running tests in a Windows PowerShell environment (or in CI that emulates it), set the `PYTHONPATH` to the repository `src` directory so imports resolve correctly. The project uses the standard library `unittest` discovery for both unit and integration tests. Example commands to include in your CI job or cocompiler step:
+
+```powershell
+$env:PYTHONPATH = 'src'; python -m unittest discover -s tests/unit -p "test_*.py" -v
+$env:PYTHONPATH = 'src'; python -m unittest discover -s tests/integration -p "test_*.py" -v
+```
+
+Place these commands in the CI job that runs tests. If your CI runner uses bash or another shell, adapt the equivalent `PYTHONPATH=src python -m unittest ...` syntax for that shell.
+
+Dependencies policy
+-------------------
+- Default: prefer Python standard library for runtime features. Do not add new third-party runtime dependencies unless there is a strong, documented justification.
+- If a third-party package is absolutely necessary, prefer small, well-maintained packages available on PyPI and add them explicitly to `pyproject.toml` or `requirements.txt` with a short rationale in the related PR.
+- Developer tooling (formatters, linters, type-checkers, test runners) are allowed as dev-dependencies, but should not be shipped as runtime requirements.
+- Avoid bringing in heavy, opaque dependencies for simple functionality that can be implemented with the standard library.
+
+Coding guidelines
+-----------------
+Follow these practical rules for readable, maintainable code across the codebase.
+
+- Style and formatting
+	- Use Black formatting and an 88-character line width. Run `isort` for import ordering.
+	- Prefer expressive, explicit code over clever one-liners.
+	- Use f-strings for string interpolation.
+
+- Naming
+	- Modules and packages: short, lowercase, underscore-separated if needed (snake_case).
+	- Functions and variables: snake_case.
+	- Classes: PascalCase.
+	- Constants: UPPER_SNAKE_CASE.
+
+- Types & typing
+	- Add type hints for public functions and methods (PEP 484). Prefer `typing` generics over `Any`.
+	- Use `dataclasses` for domain models and `typing.Protocol` for interfaces/ports.
+	- Run static type checks in CI (mypy or pyright). Keep strictness where practical.
+
+- Docstrings & documentation
+	- Document public functions, classes and modules with Google or NumPy style docstrings. Include Args, Returns, and Raises sections for public APIs.
+	- Document public functions, classes and modules with Google or NumPy style docstrings. Include Args, Returns, and Raises sections for public APIs.
+	- Add short examples when behavior is non-obvious.
+
+	Doctest guidelines
+	------------------
+	Follow these rules when adding doctest examples in docstrings so they run reliably with `python -m doctest` in CI.
+
+	- Keep examples terse and deterministic
+	  - Examples must run without interactive user input and produce the same output on every run.
+	  - Avoid printing memory addresses, timestamps, UUIDs, or platform-dependent output. If randomness is required, set a fixed seed inside the example.
+
+	- Importing in examples
+	  - Use full imports that will work when the module is executed from the project root. Example:
+	    >>> from ncplot7py.domain.models import Metadata
+
+	- Use exact, stable output
+	  - Show canonical string or repr output that is stable across Python versions when possible.
+	  - For floating-point examples, either round the result in the example or use doctest directives such as `# doctest: +ELLIPSIS` to match approximate output. Example:
+	    >>> round(0.1 + 0.2, 6)
+	    0.3
+	    >>> 0.1 + 0.2  # doctest: +ELLIPSIS
+	    0.3000000...
+
+	- Use doctest option flags when needed
+	  - Use `# doctest: +ELLIPSIS` to allow partial matching, or `# doctest: +NORMALIZE_WHITESPACE` if whitespace differs.
+	  - Avoid overusing flags; prefer making examples precise.
+
+	- Setup and long examples
+	  - Keep long examples out of function docstrings; put them in `examples/` or `README.md` and test them separately if needed.
+	  - If an example requires setup (creating temp files, sample NetCDF), show only the minimal reproducible snippet in the docstring and add a full integration example in `tests/integration/`.
+
+	- Avoid side effects
+	  - Do not perform destructive actions (deleting files, network calls) in doctest examples. If demonstrating I/O, use temporary files within the example or put the full scenario in integration tests.
+
+	- Running doctests in CI
+	  - CI should run: `python -m doctest -v src/ncplot7py/*.py` (or a narrower file list). The `pyproject.toml` includes a `doctest-command` showing the canonical command.
+
+	- Example of a good doctest
+	  def add(a, b):
+	      """
+	      Return the sum of two numbers.
+
+	      >>> add(1, 2)
+	      3
+	      >>> round(add(0.1, 0.2), 6)
+	      0.3
+	      """
+	      return a + b
+
+	- Notes for contributors
+	  - Keep doctest examples focused on documenting observable behavior, not internal implementation.
+	  - If you add or change doctest examples, run the doctest command locally before opening a PR.
+
+- Imports
+	- Use absolute imports within the package (from ncplot7py.xxx import Y).
+	- Group imports: stdlib, third-party, local (use isort to enforce).
+
+- Exceptions & error handling
+	- Prefer specific exceptions (ValueError, TypeError, etc.). Avoid bare except: clauses.
+	- Define domain-specific exception types in `domain/` when callers need to distinguish error classes.
+	- Fail fast and validate inputs early. Keep error messages clear and actionable.
+
+- Logging
+	- Use the standard `logging` module. Modules should get a logger via `logger = logging.getLogger(__name__)`.
+	- Do not use `print()` for production/logging; reserve `print()` only for quick debugging (remove before commit).
+
+- Resource management
+	- Use context managers for files, network connections and other resources (`with` statement).
+	- Avoid mutable default arguments. Use `None` and set defaults inside the function.
+
+- Concurrency
+	- Prefer simple solutions (threading, multiprocessing, asyncio) only when necessary. Encapsulate concurrency in infrastructure layer adapters and keep domain/use-cases synchronous unless the whole stack is async.
+
+	- Tests
+		- Follow Arrange-Act-Assert. Keep unit tests fast and deterministic.
+		- Use the standard library `unittest` for unit tests (TestCase classes, setUp/tearDown, subTest) and `unittest.mock` for mocking.
+		- For table-driven tests, prefer `subTest` or explicit loops inside a TestCase rather than adding test framework dependencies.
+		- Use `doctest` for executable examples embedded in docstrings when helpful.
+		- For integration tests, use temporary directories (`tempfile.TemporaryDirectory`) and small sample assets. Clean up after tests.
+
+- Commits & PRs
+	- Commit message: short title (<=72 chars), optional body with rationale and any migration notes.
+	- PR description: explain what changed, why, tests added/updated, and any migration steps for consumers.
+	- Keep PRs focused: each PR should implement a single logical change or narrowly related set of changes.
+
+- Code review checklist
+	- Does the change respect layer boundaries (domain vs adapters vs infra)?
+	- Are side-effects localized to infrastructure/adapters?
+	- Are types and docstrings present for public APIs?
+	- Are there unit tests for domain/application logic and integration tests for adapters where needed?
+	- Is the change small and well-commented (or does it include a rationale in the PR)?
+
+Current project structure
+-------------------------
+The repository already follows the recommended clean-architecture layout. Use these locations when adding or editing files so Copilot suggestions target the correct layer.
+
+Top-level files
+- `LICENSE`, `README.md`, `pyproject.toml`, `dev-requirements.txt`
+- `.github/COPILOT_INSTRUCTIONS.md` (this file)
+
+Package layout (src-style)
+- `src/ncplot7py/` — main package root
+	- `cli/` — CLI entrypoint and command wiring
+		- `main.py` — CLI implementation (simulate, plot subcommands)
+	- `domain/` — pure domain dataclasses and exceptions
+		- `models.py` — NCNode, ToolpathPoint, MachineSpec, SimulationResult
+		- `exceptions.py` — domain-specific exception types
+	- `application/` — use-cases / orchestrators
+		- `simulate.py` — parse -> simulate orchestration utilities
+	- `interfaces/` — Protocols / interface definitions
+		- `parser.py` — `Parser` Protocol
+		- `machine.py` — `MachineDriver` Protocol
+		- `plotter.py` — `Plotter` Protocol
+		- (intended) `nc_control.py` — NC control Protocol / base class (interface for NC controllers)
+	- `infrastructure/` — concrete adapters and implementations (I/O, drivers, plotters)
+		- `parsers/gcode_parser.py` — minimal G-code parser (registers as `gcode`)
+		- `machines/generic_machine.py` — simple generic machine driver (registers as `generic`)
+		- `plotters/matplotlib_plotter.py` — optional matplotlib adapter (registers `matplotlib` plotter)
+		- `persistence/` — storage adapters (file-based persistence stubs)
+	- `shared/` — small shared helpers and registry
+		- `registry.py` — runtime registry resolving parsers/machines/plotters
+
+Tests and examples
+- `tests/unit/` — unit tests (e.g. `test_simulate_flow.py`)
+- `tests/integration/` — integration tests (parsing+simulate+plot if optional deps installed)
+- `examples/` and `data/nc-examples/` — sample NC files and fixtures for integration tests and demos
+
+Notes
+- Optional dependencies (plotting) are declared under `pyproject.toml` extras: `plotting = ["matplotlib>=3.0,<4.0"]`.
+- Concrete implementations register with the `shared.registry` so CLI and application code can resolve components by name (e.g. parser `gcode`, machine `generic`, plotter `matplotlib`).
+- When Copilot generates code that crosses layers, update or create files in the matching package path above.
+
+
+How Copilot should behave when editing code (updated)
+----------------------------------------------------
+- When implementing features, prefer stdlib solutions first (os, pathlib, csv, json, tempfile, subprocess, builtins, typing, dataclasses).
+- If a suggestion uses a third-party library, add a short justification comment and note that adding a dependency requires an explicit PR description and approval.
+- For packages that must be added, include an update to `pyproject.toml` or `requirements.txt` and a brief migration note in the PR description.
+
+How Copilot should behave when editing code
+------------------------------------------
+- Make minimal, well-scoped edits. If a feature crosses layers, create the smallest set of files required and update tests.
+- Prefer adding a Protocol and refactoring callers to depend on it rather than editing many concrete implementations.
+- Always include or update unit tests for any domain or application logic changes.
+
+Do / Don't (architecture-focused)
+---------------------------------
+- Do: keep domain pure, add types and docstrings, add focused unit tests, and include migration notes for breaking changes.
+- Don't: put business logic in HTTP handlers, scatter I/O into domain modules, or introduce large runtime deps without justification.
+
+Security
+--------
+- Never add secrets to the repo. Use environment variables or secrets managers and document required env vars in `.env.example`.
+
+Customization & next steps
+--------------------------
+This file is a living guideline. To change rules:
+- Edit this file and commit.
+- Optionally add CI checks to enforce specific rules (typecheck, linter, format).
+
+I can also scaffold starter artifacts if you want:
+- `pyproject.toml` + minimal `src/` layout
+- Example `MetadataReader` Protocol + `NetCDFReader` implementation + unit/integration tests
+- A GitHub Actions workflow that runs Black, ruff/flake8, mypy, and the stdlib tests on PRs
+
+
+
+
+
+## Error handling (use the structured system)
+- Use `ExceptionNode` and `ExceptionTyps` from `ncplot7py.domain.exceptions`.
+- Prefer the helper `raise_nc_error(...)` to automatically populate trace and caret when possible.
+
+Example:
+```python
+from ncplot7py.domain.exceptions import ExceptionTyps, raise_nc_error
+
+if token not in allowed:
+    raise_nc_error(
+        ExceptionTyps.NCCodeErrors,
+        1001,  # see locales XML id "1:1001"
+        value=token,
+        file=filename,
+        line=lineno,
+        source_line=line_text,
+    )
+```
+
+-## Localization of messages
+- Message templates are in `src/ncplot7py/locales/{lang}.xml`.
+- Keys are `{typ_value}:{code}`. Use placeholders `{value}`, `{line}`, `{code}`, `{typ}`.
+- To format for output:
+```python
+from ncplot7py.domain.i18n import MessageCatalog
+text = MessageCatalog().format_exception(exc, lang="en")
+```
+
+## Tracing
+- Provide `file`, `line`, `source_line` (and `value`) when raising errors to get a caret under the offending token.
+- If you know the exact `column`, pass it; otherwise `raise_nc_error` will try to infer it by searching `value` in `source_line`.
+
+
+-- End of architecture-focused Copilot instructions --
diff --git a/.github/workflows/ci.yml b/.github/workflows/ci.yml
index b098a35..7aedcf1 100644
--- a/.github/workflows/ci.yml
+++ b/.github/workflows/ci.yml
@@ -1,41 +1,41 @@
-name: CI
-
-on:
-  push:
-    branches: [ master ]
-  pull_request:
-    branches: [ master ]
-
-jobs:
-  test:
-    name: Test on ${{ matrix.os }} / Python ${{ matrix.python-version }}
-    runs-on: ${{ matrix.os }}
-    strategy:
-      matrix:
-        os: [ubuntu-latest, windows-latest]
-        python-version: [3.10, 3.11]
-    env:
-      # Ensure imports can resolve package under src/
-      PYTHONPATH: src
-
-    steps:
-      - name: Checkout repository
-        uses: actions/checkout@v4
-
-      - name: Set up Python
-        uses: actions/setup-python@v4
-        with:
-          python-version: ${{ matrix.python-version }}
-
-      - name: Upgrade pip
-        run: python -m pip install --upgrade pip
-
-      - name: Install dev dependencies
-        run: |
-          if [ -f dev-requirements.txt ]; then pip install -r dev-requirements.txt; fi
-
-      - name: Run unit tests
-        run: python -m unittest discover -s tests -p "test_*.py"
-
-      - name: Run doctests
-        run: python -m doctest -v src/ncplot7py/*.py
+name: CI
+
+on:
+  push:
+    branches: [ master ]
+  pull_request:
+    branches: [ master ]
+
+jobs:
+  test:
+    name: Test on ${{ matrix.os }} / Python ${{ matrix.python-version }}
+    runs-on: ${{ matrix.os }}
+    strategy:
+      matrix:
+        os: [ubuntu-latest, windows-latest]
+        python-version: [3.10, 3.11]
+    env:
+      # Ensure imports can resolve package under src/
+      PYTHONPATH: src
+
+    steps:
+      - name: Checkout repository
+        uses: actions/checkout@v4
+
+      - name: Set up Python
+        uses: actions/setup-python@v4
+        with:
+          python-version: ${{ matrix.python-version }}
+
+      - name: Upgrade pip
+        run: python -m pip install --upgrade pip
+
+      - name: Install dev dependencies
+        run: |
+          if [ -f dev-requirements.txt ]; then pip install -r dev-requirements.txt; fi
+
+      - name: Run unit tests
+        run: python -m unittest discover -s tests -p "test_*.py"
+
+      - name: Run doctests
+        run: python -m doctest -v src/ncplot7py/*.py
diff --git a/.gitignore b/.gitignore
index 82ee2a8..b292d8a 100644
--- a/.gitignore
+++ b/.gitignore
@@ -1,209 +1,210 @@
-# Byte-compiled / optimized / DLL files
-__pycache__/
-*.py[codz]
-*$py.class
-*cgiserver.cgi
-
-
-# C extensions
-*.so
-
-# Distribution / packaging
-.Python
-build/
-develop-eggs/
-dist/
-downloads/
-eggs/
-.eggs/
-lib/
-lib64/
-parts/
-sdist/
-var/
-wheels/
-share/python-wheels/
-*.egg-info/
-.installed.cfg
-*.egg
-MANIFEST
-
-# PyInstaller
-#  Usually these files are written by a python script from a template
-#  before PyInstaller builds the exe, so as to inject date/other infos into it.
-*.manifest
-*.spec
-
-# Installer logs
-pip-log.txt
-pip-delete-this-directory.txt
-
-# Unit test / coverage reports
-htmlcov/
-.tox/
-.nox/
-.coverage
-.coverage.*
-.cache
-nosetests.xml
-coverage.xml
-*.cover
-*.py.cover
-.hypothesis/
-.pytest_cache/
-cover/
-
-# Translations
-*.mo
-*.pot
-
-# Django stuff:
-*.log
-local_settings.py
-db.sqlite3
-db.sqlite3-journal
-
-# Flask stuff:
-instance/
-.webassets-cache
-
-# Scrapy stuff:
-.scrapy
-
-# Sphinx documentation
-docs/_build/
-
-# PyBuilder
-.pybuilder/
-target/
-
-# Jupyter Notebook
-.ipynb_checkpoints
-
-# IPython
-profile_default/
-ipython_config.py
-
-# pyenv
-#   For a library or package, you might want to ignore these files since the code is
-#   intended to run in multiple environments; otherwise, check them in:
-# .python-version
-
-# pipenv
-#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
-#   However, in case of collaboration, if having platform-specific dependencies or dependencies
-#   having no cross-platform support, pipenv may install dependencies that don't work, or not
-#   install all needed dependencies.
-#Pipfile.lock
-
-# UV
-#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#uv.lock
-
-# poetry
-#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
-#   This is especially recommended for binary packages to ensure reproducibility, and is more
-#   commonly ignored for libraries.
-#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
-#poetry.lock
-#poetry.toml
-
-# pdm
-#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
-#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
-#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
-#pdm.lock
-#pdm.toml
-.pdm-python
-.pdm-build/
-
-# pixi
-#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
-#pixi.lock
-#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
-#   in the .venv directory. It is recommended not to include this directory in version control.
-.pixi
-
-# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
-__pypackages__/
-
-# Celery stuff
-celerybeat-schedule
-celerybeat.pid
-
-# SageMath parsed files
-*.sage.py
-
-# Environments
-.env
-.envrc
-.venv
-env/
-venv/
-ENV/
-env.bak/
-venv.bak/
-
-# Spyder project settings
-.spyderproject
-.spyproject
-
-# Rope project settings
-.ropeproject
-
-# mkdocs documentation
-/site
-
-# mypy
-.mypy_cache/
-.dmypy.json
-dmypy.json
-
-# Pyre type checker
-.pyre/
-
-# pytype static type analyzer
-.pytype/
-
-# Cython debug symbols
-cython_debug/
-
-# PyCharm
-#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
-#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
-#  and can be added to the global gitignore or merged into this file.  For a more nuclear
-#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
-#.idea/
-
-# Abstra
-# Abstra is an AI-powered process automation framework.
-# Ignore directories containing user credentials, local state, and settings.
-# Learn more at https://abstra.io/docs
-.abstra/
-
-# Visual Studio Code
-#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
-#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
-#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
-#  you could uncomment the following to ignore the entire vscode folder
-# .vscode/
-
-# Ruff stuff:
-.ruff_cache/
-
-# PyPI configuration file
-.pypirc
-
-# Cursor
-#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
-#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
-#  refer to https://docs.cursor.com/context/ignore-files
-.cursorignore
-.cursorindexingignore
-
-# Marimo
-marimo/_static/
-marimo/_lsp/
-__marimo__/
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$py.class
+
+
+
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py.cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.envrc
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/
diff --git a/.vscode/launch.json b/.vscode/launch.json
index 53694b9..e953c35 100644
--- a/.vscode/launch.json
+++ b/.vscode/launch.json
@@ -1,39 +1,39 @@
-{
-  "version": "0.2.0",
-  "configurations": [
-    {
-      "name": "Python: Current File (with PYTHONPATH)",
-      "type": "python",
-      "request": "launch",
-      "program": "${file}",
-      "console": "integratedTerminal",
-      "env": {
-        "PYTHONPATH": "${workspaceFolder}/src"
-      },
-      "envFile": "${workspaceFolder}/.env"
-    },
-    {
-      "name": "Python: Run example_O0004.py (with PYTHONPATH)",
-      "type": "python",
-      "request": "launch",
-      "program": "${workspaceFolder}/scripts/run_example_O0004.py",
-      "console": "integratedTerminal",
-      "env": {
-        "PYTHONPATH": "${workspaceFolder}/src"
-      },
-      "envFile": "${workspaceFolder}/.env"
-    },
-    {
-      "name": "Python: Unittest (discover, with PYTHONPATH)",
-      "type": "python",
-      "request": "launch",
-      "module": "unittest",
-      "args": ["discover", "-s", "tests", "-p", "test_*.py"],
-      "console": "integratedTerminal",
-      "env": {
-        "PYTHONPATH": "${workspaceFolder}/src"
-      },
-      "envFile": "${workspaceFolder}/.env"
-    }
-  ]
-}
+{
+  "version": "0.2.0",
+  "configurations": [
+    {
+      "name": "Python: Current File (with PYTHONPATH)",
+      "type": "python",
+      "request": "launch",
+      "program": "${file}",
+      "console": "integratedTerminal",
+      "env": {
+        "PYTHONPATH": "${workspaceFolder}/src"
+      },
+      "envFile": "${workspaceFolder}/.env"
+    },
+    {
+      "name": "Python: Run example_O0004.py (with PYTHONPATH)",
+      "type": "python",
+      "request": "launch",
+      "program": "${workspaceFolder}/scripts/run_example_O0004.py",
+      "console": "integratedTerminal",
+      "env": {
+        "PYTHONPATH": "${workspaceFolder}/src"
+      },
+      "envFile": "${workspaceFolder}/.env"
+    },
+    {
+      "name": "Python: Unittest (discover, with PYTHONPATH)",
+      "type": "python",
+      "request": "launch",
+      "module": "unittest",
+      "args": ["discover", "-s", "tests", "-p", "test_*.py"],
+      "console": "integratedTerminal",
+      "env": {
+        "PYTHONPATH": "${workspaceFolder}/src"
+      },
+      "envFile": "${workspaceFolder}/.env"
+    }
+  ]
+}
diff --git a/LICENSE b/LICENSE
index 0ad25db..ada1a81 100644
--- a/LICENSE
+++ b/LICENSE
@@ -1,661 +1,661 @@
-                    GNU AFFERO GENERAL PUBLIC LICENSE
-                       Version 3, 19 November 2007
-
- Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
- Everyone is permitted to copy and distribute verbatim copies
- of this license document, but changing it is not allowed.
-
-                            Preamble
-
-  The GNU Affero General Public License is a free, copyleft license for
-software and other kinds of works, specifically designed to ensure
-cooperation with the community in the case of network server software.
-
-  The licenses for most software and other practical works are designed
-to take away your freedom to share and change the works.  By contrast,
-our General Public Licenses are intended to guarantee your freedom to
-share and change all versions of a program--to make sure it remains free
-software for all its users.
-
-  When we speak of free software, we are referring to freedom, not
-price.  Our General Public Licenses are designed to make sure that you
-have the freedom to distribute copies of free software (and charge for
-them if you wish), that you receive source code or can get it if you
-want it, that you can change the software or use pieces of it in new
-free programs, and that you know you can do these things.
-
-  Developers that use our General Public Licenses protect your rights
-with two steps: (1) assert copyright on the software, and (2) offer
-you this License which gives you legal permission to copy, distribute
-and/or modify the software.
-
-  A secondary benefit of defending all users' freedom is that
-improvements made in alternate versions of the program, if they
-receive widespread use, become available for other developers to
-incorporate.  Many developers of free software are heartened and
-encouraged by the resulting cooperation.  However, in the case of
-software used on network servers, this result may fail to come about.
-The GNU General Public License permits making a modified version and
-letting the public access it on a server without ever releasing its
-source code to the public.
-
-  The GNU Affero General Public License is designed specifically to
-ensure that, in such cases, the modified source code becomes available
-to the community.  It requires the operator of a network server to
-provide the source code of the modified version running there to the
-users of that server.  Therefore, public use of a modified version, on
-a publicly accessible server, gives the public access to the source
-code of the modified version.
-
-  An older license, called the Affero General Public License and
-published by Affero, was designed to accomplish similar goals.  This is
-a different license, not a version of the Affero GPL, but Affero has
-released a new version of the Affero GPL which permits relicensing under
-this license.
-
-  The precise terms and conditions for copying, distribution and
-modification follow.
-
-                       TERMS AND CONDITIONS
-
-  0. Definitions.
-
-  "This License" refers to version 3 of the GNU Affero General Public License.
-
-  "Copyright" also means copyright-like laws that apply to other kinds of
-works, such as semiconductor masks.
-
-  "The Program" refers to any copyrightable work licensed under this
-License.  Each licensee is addressed as "you".  "Licensees" and
-"recipients" may be individuals or organizations.
-
-  To "modify" a work means to copy from or adapt all or part of the work
-in a fashion requiring copyright permission, other than the making of an
-exact copy.  The resulting work is called a "modified version" of the
-earlier work or a work "based on" the earlier work.
-
-  A "covered work" means either the unmodified Program or a work based
-on the Program.
-
-  To "propagate" a work means to do anything with it that, without
-permission, would make you directly or secondarily liable for
-infringement under applicable copyright law, except executing it on a
-computer or modifying a private copy.  Propagation includes copying,
-distribution (with or without modification), making available to the
-public, and in some countries other activities as well.
-
-  To "convey" a work means any kind of propagation that enables other
-parties to make or receive copies.  Mere interaction with a user through
-a computer network, with no transfer of a copy, is not conveying.
-
-  An interactive user interface displays "Appropriate Legal Notices"
-to the extent that it includes a convenient and prominently visible
-feature that (1) displays an appropriate copyright notice, and (2)
-tells the user that there is no warranty for the work (except to the
-extent that warranties are provided), that licensees may convey the
-work under this License, and how to view a copy of this License.  If
-the interface presents a list of user commands or options, such as a
-menu, a prominent item in the list meets this criterion.
-
-  1. Source Code.
-
-  The "source code" for a work means the preferred form of the work
-for making modifications to it.  "Object code" means any non-source
-form of a work.
-
-  A "Standard Interface" means an interface that either is an official
-standard defined by a recognized standards body, or, in the case of
-interfaces specified for a particular programming language, one that
-is widely used among developers working in that language.
-
-  The "System Libraries" of an executable work include anything, other
-than the work as a whole, that (a) is included in the normal form of
-packaging a Major Component, but which is not part of that Major
-Component, and (b) serves only to enable use of the work with that
-Major Component, or to implement a Standard Interface for which an
-implementation is available to the public in source code form.  A
-"Major Component", in this context, means a major essential component
-(kernel, window system, and so on) of the specific operating system
-(if any) on which the executable work runs, or a compiler used to
-produce the work, or an object code interpreter used to run it.
-
-  The "Corresponding Source" for a work in object code form means all
-the source code needed to generate, install, and (for an executable
-work) run the object code and to modify the work, including scripts to
-control those activities.  However, it does not include the work's
-System Libraries, or general-purpose tools or generally available free
-programs which are used unmodified in performing those activities but
-which are not part of the work.  For example, Corresponding Source
-includes interface definition files associated with source files for
-the work, and the source code for shared libraries and dynamically
-linked subprograms that the work is specifically designed to require,
-such as by intimate data communication or control flow between those
-subprograms and other parts of the work.
-
-  The Corresponding Source need not include anything that users
-can regenerate automatically from other parts of the Corresponding
-Source.
-
-  The Corresponding Source for a work in source code form is that
-same work.
-
-  2. Basic Permissions.
-
-  All rights granted under this License are granted for the term of
-copyright on the Program, and are irrevocable provided the stated
-conditions are met.  This License explicitly affirms your unlimited
-permission to run the unmodified Program.  The output from running a
-covered work is covered by this License only if the output, given its
-content, constitutes a covered work.  This License acknowledges your
-rights of fair use or other equivalent, as provided by copyright law.
-
-  You may make, run and propagate covered works that you do not
-convey, without conditions so long as your license otherwise remains
-in force.  You may convey covered works to others for the sole purpose
-of having them make modifications exclusively for you, or provide you
-with facilities for running those works, provided that you comply with
-the terms of this License in conveying all material for which you do
-not control copyright.  Those thus making or running the covered works
-for you must do so exclusively on your behalf, under your direction
-and control, on terms that prohibit them from making any copies of
-your copyrighted material outside their relationship with you.
-
-  Conveying under any other circumstances is permitted solely under
-the conditions stated below.  Sublicensing is not allowed; section 10
-makes it unnecessary.
-
-  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
-
-  No covered work shall be deemed part of an effective technological
-measure under any applicable law fulfilling obligations under article
-11 of the WIPO copyright treaty adopted on 20 December 1996, or
-similar laws prohibiting or restricting circumvention of such
-measures.
-
-  When you convey a covered work, you waive any legal power to forbid
-circumvention of technological measures to the extent such circumvention
-is effected by exercising rights under this License with respect to
-the covered work, and you disclaim any intention to limit operation or
-modification of the work as a means of enforcing, against the work's
-users, your or third parties' legal rights to forbid circumvention of
-technological measures.
-
-  4. Conveying Verbatim Copies.
-
-  You may convey verbatim copies of the Program's source code as you
-receive it, in any medium, provided that you conspicuously and
-appropriately publish on each copy an appropriate copyright notice;
-keep intact all notices stating that this License and any
-non-permissive terms added in accord with section 7 apply to the code;
-keep intact all notices of the absence of any warranty; and give all
-recipients a copy of this License along with the Program.
-
-  You may charge any price or no price for each copy that you convey,
-and you may offer support or warranty protection for a fee.
-
-  5. Conveying Modified Source Versions.
-
-  You may convey a work based on the Program, or the modifications to
-produce it from the Program, in the form of source code under the
-terms of section 4, provided that you also meet all of these conditions:
-
-    a) The work must carry prominent notices stating that you modified
-    it, and giving a relevant date.
-
-    b) The work must carry prominent notices stating that it is
-    released under this License and any conditions added under section
-    7.  This requirement modifies the requirement in section 4 to
-    "keep intact all notices".
-
-    c) You must license the entire work, as a whole, under this
-    License to anyone who comes into possession of a copy.  This
-    License will therefore apply, along with any applicable section 7
-    additional terms, to the whole of the work, and all its parts,
-    regardless of how they are packaged.  This License gives no
-    permission to license the work in any other way, but it does not
-    invalidate such permission if you have separately received it.
-
-    d) If the work has interactive user interfaces, each must display
-    Appropriate Legal Notices; however, if the Program has interactive
-    interfaces that do not display Appropriate Legal Notices, your
-    work need not make them do so.
-
-  A compilation of a covered work with other separate and independent
-works, which are not by their nature extensions of the covered work,
-and which are not combined with it such as to form a larger program,
-in or on a volume of a storage or distribution medium, is called an
-"aggregate" if the compilation and its resulting copyright are not
-used to limit the access or legal rights of the compilation's users
-beyond what the individual works permit.  Inclusion of a covered work
-in an aggregate does not cause this License to apply to the other
-parts of the aggregate.
-
-  6. Conveying Non-Source Forms.
-
-  You may convey a covered work in object code form under the terms
-of sections 4 and 5, provided that you also convey the
-machine-readable Corresponding Source under the terms of this License,
-in one of these ways:
-
-    a) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by the
-    Corresponding Source fixed on a durable physical medium
-    customarily used for software interchange.
-
-    b) Convey the object code in, or embodied in, a physical product
-    (including a physical distribution medium), accompanied by a
-    written offer, valid for at least three years and valid for as
-    long as you offer spare parts or customer support for that product
-    model, to give anyone who possesses the object code either (1) a
-    copy of the Corresponding Source for all the software in the
-    product that is covered by this License, on a durable physical
-    medium customarily used for software interchange, for a price no
-    more than your reasonable cost of physically performing this
-    conveying of source, or (2) access to copy the
-    Corresponding Source from a network server at no charge.
-
-    c) Convey individual copies of the object code with a copy of the
-    written offer to provide the Corresponding Source.  This
-    alternative is allowed only occasionally and noncommercially, and
-    only if you received the object code with such an offer, in accord
-    with subsection 6b.
-
-    d) Convey the object code by offering access from a designated
-    place (gratis or for a charge), and offer equivalent access to the
-    Corresponding Source in the same way through the same place at no
-    further charge.  You need not require recipients to copy the
-    Corresponding Source along with the object code.  If the place to
-    copy the object code is a network server, the Corresponding Source
-    may be on a different server (operated by you or a third party)
-    that supports equivalent copying facilities, provided you maintain
-    clear directions next to the object code saying where to find the
-    Corresponding Source.  Regardless of what server hosts the
-    Corresponding Source, you remain obligated to ensure that it is
-    available for as long as needed to satisfy these requirements.
-
-    e) Convey the object code using peer-to-peer transmission, provided
-    you inform other peers where the object code and Corresponding
-    Source of the work are being offered to the general public at no
-    charge under subsection 6d.
-
-  A separable portion of the object code, whose source code is excluded
-from the Corresponding Source as a System Library, need not be
-included in conveying the object code work.
-
-  A "User Product" is either (1) a "consumer product", which means any
-tangible personal property which is normally used for personal, family,
-or household purposes, or (2) anything designed or sold for incorporation
-into a dwelling.  In determining whether a product is a consumer product,
-doubtful cases shall be resolved in favor of coverage.  For a particular
-product received by a particular user, "normally used" refers to a
-typical or common use of that class of product, regardless of the status
-of the particular user or of the way in which the particular user
-actually uses, or expects or is expected to use, the product.  A product
-is a consumer product regardless of whether the product has substantial
-commercial, industrial or non-consumer uses, unless such uses represent
-the only significant mode of use of the product.
-
-  "Installation Information" for a User Product means any methods,
-procedures, authorization keys, or other information required to install
-and execute modified versions of a covered work in that User Product from
-a modified version of its Corresponding Source.  The information must
-suffice to ensure that the continued functioning of the modified object
-code is in no case prevented or interfered with solely because
-modification has been made.
-
-  If you convey an object code work under this section in, or with, or
-specifically for use in, a User Product, and the conveying occurs as
-part of a transaction in which the right of possession and use of the
-User Product is transferred to the recipient in perpetuity or for a
-fixed term (regardless of how the transaction is characterized), the
-Corresponding Source conveyed under this section must be accompanied
-by the Installation Information.  But this requirement does not apply
-if neither you nor any third party retains the ability to install
-modified object code on the User Product (for example, the work has
-been installed in ROM).
-
-  The requirement to provide Installation Information does not include a
-requirement to continue to provide support service, warranty, or updates
-for a work that has been modified or installed by the recipient, or for
-the User Product in which it has been modified or installed.  Access to a
-network may be denied when the modification itself materially and
-adversely affects the operation of the network or violates the rules and
-protocols for communication across the network.
-
-  Corresponding Source conveyed, and Installation Information provided,
-in accord with this section must be in a format that is publicly
-documented (and with an implementation available to the public in
-source code form), and must require no special password or key for
-unpacking, reading or copying.
-
-  7. Additional Terms.
-
-  "Additional permissions" are terms that supplement the terms of this
-License by making exceptions from one or more of its conditions.
-Additional permissions that are applicable to the entire Program shall
-be treated as though they were included in this License, to the extent
-that they are valid under applicable law.  If additional permissions
-apply only to part of the Program, that part may be used separately
-under those permissions, but the entire Program remains governed by
-this License without regard to the additional permissions.
-
-  When you convey a copy of a covered work, you may at your option
-remove any additional permissions from that copy, or from any part of
-it.  (Additional permissions may be written to require their own
-removal in certain cases when you modify the work.)  You may place
-additional permissions on material, added by you to a covered work,
-for which you have or can give appropriate copyright permission.
-
-  Notwithstanding any other provision of this License, for material you
-add to a covered work, you may (if authorized by the copyright holders of
-that material) supplement the terms of this License with terms:
-
-    a) Disclaiming warranty or limiting liability differently from the
-    terms of sections 15 and 16 of this License; or
-
-    b) Requiring preservation of specified reasonable legal notices or
-    author attributions in that material or in the Appropriate Legal
-    Notices displayed by works containing it; or
-
-    c) Prohibiting misrepresentation of the origin of that material, or
-    requiring that modified versions of such material be marked in
-    reasonable ways as different from the original version; or
-
-    d) Limiting the use for publicity purposes of names of licensors or
-    authors of the material; or
-
-    e) Declining to grant rights under trademark law for use of some
-    trade names, trademarks, or service marks; or
-
-    f) Requiring indemnification of licensors and authors of that
-    material by anyone who conveys the material (or modified versions of
-    it) with contractual assumptions of liability to the recipient, for
-    any liability that these contractual assumptions directly impose on
-    those licensors and authors.
-
-  All other non-permissive additional terms are considered "further
-restrictions" within the meaning of section 10.  If the Program as you
-received it, or any part of it, contains a notice stating that it is
-governed by this License along with a term that is a further
-restriction, you may remove that term.  If a license document contains
-a further restriction but permits relicensing or conveying under this
-License, you may add to a covered work material governed by the terms
-of that license document, provided that the further restriction does
-not survive such relicensing or conveying.
-
-  If you add terms to a covered work in accord with this section, you
-must place, in the relevant source files, a statement of the
-additional terms that apply to those files, or a notice indicating
-where to find the applicable terms.
-
-  Additional terms, permissive or non-permissive, may be stated in the
-form of a separately written license, or stated as exceptions;
-the above requirements apply either way.
-
-  8. Termination.
-
-  You may not propagate or modify a covered work except as expressly
-provided under this License.  Any attempt otherwise to propagate or
-modify it is void, and will automatically terminate your rights under
-this License (including any patent licenses granted under the third
-paragraph of section 11).
-
-  However, if you cease all violation of this License, then your
-license from a particular copyright holder is reinstated (a)
-provisionally, unless and until the copyright holder explicitly and
-finally terminates your license, and (b) permanently, if the copyright
-holder fails to notify you of the violation by some reasonable means
-prior to 60 days after the cessation.
-
-  Moreover, your license from a particular copyright holder is
-reinstated permanently if the copyright holder notifies you of the
-violation by some reasonable means, this is the first time you have
-received notice of violation of this License (for any work) from that
-copyright holder, and you cure the violation prior to 30 days after
-your receipt of the notice.
-
-  Termination of your rights under this section does not terminate the
-licenses of parties who have received copies or rights from you under
-this License.  If your rights have been terminated and not permanently
-reinstated, you do not qualify to receive new licenses for the same
-material under section 10.
-
-  9. Acceptance Not Required for Having Copies.
-
-  You are not required to accept this License in order to receive or
-run a copy of the Program.  Ancillary propagation of a covered work
-occurring solely as a consequence of using peer-to-peer transmission
-to receive a copy likewise does not require acceptance.  However,
-nothing other than this License grants you permission to propagate or
-modify any covered work.  These actions infringe copyright if you do
-not accept this License.  Therefore, by modifying or propagating a
-covered work, you indicate your acceptance of this License to do so.
-
-  10. Automatic Licensing of Downstream Recipients.
-
-  Each time you convey a covered work, the recipient automatically
-receives a license from the original licensors, to run, modify and
-propagate that work, subject to this License.  You are not responsible
-for enforcing compliance by third parties with this License.
-
-  An "entity transaction" is a transaction transferring control of an
-organization, or substantially all assets of one, or subdividing an
-organization, or merging organizations.  If propagation of a covered
-work results from an entity transaction, each party to that
-transaction who receives a copy of the work also receives whatever
-licenses to the work the party's predecessor in interest had or could
-give under the previous paragraph, plus a right to possession of the
-Corresponding Source of the work from the predecessor in interest, if
-the predecessor has it or can get it with reasonable efforts.
-
-  You may not impose any further restrictions on the exercise of the
-rights granted or affirmed under this License.  For example, you may
-not impose a license fee, royalty, or other charge for exercise of
-rights granted under this License, and you may not initiate litigation
-(including a cross-claim or counterclaim in a lawsuit) alleging that
-any patent claim is infringed by making, using, selling, offering for
-sale, or importing the Program or any portion of it.
-
-  11. Patents.
-
-  A "contributor" is a copyright holder who authorizes use under this
-License of the Program or a work on which the Program is based.  The
-work thus licensed is called the contributor's "contributor version".
-
-  A contributor's "essential patent claims" are all patent claims
-owned or controlled by the contributor, whether already acquired or
-hereafter acquired, that would be infringed by some manner, permitted
-by this License, of making, using, or selling its contributor version,
-but do not include claims that would be infringed only as a
-consequence of further modification of the contributor version.  For
-purposes of this definition, "control" includes the right to grant
-patent sublicenses in a manner consistent with the requirements of
-this License.
-
-  Each contributor grants you a non-exclusive, worldwide, royalty-free
-patent license under the contributor's essential patent claims, to
-make, use, sell, offer for sale, import and otherwise run, modify and
-propagate the contents of its contributor version.
-
-  In the following three paragraphs, a "patent license" is any express
-agreement or commitment, however denominated, not to enforce a patent
-(such as an express permission to practice a patent or covenant not to
-sue for patent infringement).  To "grant" such a patent license to a
-party means to make such an agreement or commitment not to enforce a
-patent against the party.
-
-  If you convey a covered work, knowingly relying on a patent license,
-and the Corresponding Source of the work is not available for anyone
-to copy, free of charge and under the terms of this License, through a
-publicly available network server or other readily accessible means,
-then you must either (1) cause the Corresponding Source to be so
-available, or (2) arrange to deprive yourself of the benefit of the
-patent license for this particular work, or (3) arrange, in a manner
-consistent with the requirements of this License, to extend the patent
-license to downstream recipients.  "Knowingly relying" means you have
-actual knowledge that, but for the patent license, your conveying the
-covered work in a country, or your recipient's use of the covered work
-in a country, would infringe one or more identifiable patents in that
-country that you have reason to believe are valid.
-
-  If, pursuant to or in connection with a single transaction or
-arrangement, you convey, or propagate by procuring conveyance of, a
-covered work, and grant a patent license to some of the parties
-receiving the covered work authorizing them to use, propagate, modify
-or convey a specific copy of the covered work, then the patent license
-you grant is automatically extended to all recipients of the covered
-work and works based on it.
-
-  A patent license is "discriminatory" if it does not include within
-the scope of its coverage, prohibits the exercise of, or is
-conditioned on the non-exercise of one or more of the rights that are
-specifically granted under this License.  You may not convey a covered
-work if you are a party to an arrangement with a third party that is
-in the business of distributing software, under which you make payment
-to the third party based on the extent of your activity of conveying
-the work, and under which the third party grants, to any of the
-parties who would receive the covered work from you, a discriminatory
-patent license (a) in connection with copies of the covered work
-conveyed by you (or copies made from those copies), or (b) primarily
-for and in connection with specific products or compilations that
-contain the covered work, unless you entered into that arrangement,
-or that patent license was granted, prior to 28 March 2007.
-
-  Nothing in this License shall be construed as excluding or limiting
-any implied license or other defenses to infringement that may
-otherwise be available to you under applicable patent law.
-
-  12. No Surrender of Others' Freedom.
-
-  If conditions are imposed on you (whether by court order, agreement or
-otherwise) that contradict the conditions of this License, they do not
-excuse you from the conditions of this License.  If you cannot convey a
-covered work so as to satisfy simultaneously your obligations under this
-License and any other pertinent obligations, then as a consequence you may
-not convey it at all.  For example, if you agree to terms that obligate you
-to collect a royalty for further conveying from those to whom you convey
-the Program, the only way you could satisfy both those terms and this
-License would be to refrain entirely from conveying the Program.
-
-  13. Remote Network Interaction; Use with the GNU General Public License.
-
-  Notwithstanding any other provision of this License, if you modify the
-Program, your modified version must prominently offer all users
-interacting with it remotely through a computer network (if your version
-supports such interaction) an opportunity to receive the Corresponding
-Source of your version by providing access to the Corresponding Source
-from a network server at no charge, through some standard or customary
-means of facilitating copying of software.  This Corresponding Source
-shall include the Corresponding Source for any work covered by version 3
-of the GNU General Public License that is incorporated pursuant to the
-following paragraph.
-
-  Notwithstanding any other provision of this License, you have
-permission to link or combine any covered work with a work licensed
-under version 3 of the GNU General Public License into a single
-combined work, and to convey the resulting work.  The terms of this
-License will continue to apply to the part which is the covered work,
-but the work with which it is combined will remain governed by version
-3 of the GNU General Public License.
-
-  14. Revised Versions of this License.
-
-  The Free Software Foundation may publish revised and/or new versions of
-the GNU Affero General Public License from time to time.  Such new versions
-will be similar in spirit to the present version, but may differ in detail to
-address new problems or concerns.
-
-  Each version is given a distinguishing version number.  If the
-Program specifies that a certain numbered version of the GNU Affero General
-Public License "or any later version" applies to it, you have the
-option of following the terms and conditions either of that numbered
-version or of any later version published by the Free Software
-Foundation.  If the Program does not specify a version number of the
-GNU Affero General Public License, you may choose any version ever published
-by the Free Software Foundation.
-
-  If the Program specifies that a proxy can decide which future
-versions of the GNU Affero General Public License can be used, that proxy's
-public statement of acceptance of a version permanently authorizes you
-to choose that version for the Program.
-
-  Later license versions may give you additional or different
-permissions.  However, no additional obligations are imposed on any
-author or copyright holder as a result of your choosing to follow a
-later version.
-
-  15. Disclaimer of Warranty.
-
-  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
-APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
-HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
-OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
-THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
-PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
-IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
-ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
-
-  16. Limitation of Liability.
-
-  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
-WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
-THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
-GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
-USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
-DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
-PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
-EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
-SUCH DAMAGES.
-
-  17. Interpretation of Sections 15 and 16.
-
-  If the disclaimer of warranty and limitation of liability provided
-above cannot be given local legal effect according to their terms,
-reviewing courts shall apply local law that most closely approximates
-an absolute waiver of all civil liability in connection with the
-Program, unless a warranty or assumption of liability accompanies a
-copy of the Program in return for a fee.
-
-                     END OF TERMS AND CONDITIONS
-
-            How to Apply These Terms to Your New Programs
-
-  If you develop a new program, and you want it to be of the greatest
-possible use to the public, the best way to achieve this is to make it
-free software which everyone can redistribute and change under these terms.
-
-  To do so, attach the following notices to the program.  It is safest
-to attach them to the start of each source file to most effectively
-state the exclusion of warranty; and each file should have at least
-the "copyright" line and a pointer to where the full notice is found.
-
-    <one line to give the program's name and a brief idea of what it does.>
-    Copyright (C) <year>  <name of author>
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as published
-    by the Free Software Foundation, either version 3 of the License, or
-    (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>.
-
-Also add information on how to contact you by electronic and paper mail.
-
-  If your software can interact with users remotely through a computer
-network, you should also make sure that it provides a way for users to
-get its source.  For example, if your program is a web application, its
-interface could display a "Source" link that leads users to an archive
-of the code.  There are many ways you could offer source, and different
-solutions will be better for different programs; see section 13 for the
-specific requirements.
-
-  You should also get your employer (if you work as a programmer) or school,
-if any, to sign a "copyright disclaimer" for the program, if necessary.
-For more information on this, and how to apply and follow the GNU AGPL, see
-<https://www.gnu.org/licenses/>.
+                    GNU AFFERO GENERAL PUBLIC LICENSE
+                       Version 3, 19 November 2007
+
+ Copyright (C) 2007 Free Software Foundation, Inc. <https://fsf.org/>
+ Everyone is permitted to copy and distribute verbatim copies
+ of this license document, but changing it is not allowed.
+
+                            Preamble
+
+  The GNU Affero General Public License is a free, copyleft license for
+software and other kinds of works, specifically designed to ensure
+cooperation with the community in the case of network server software.
+
+  The licenses for most software and other practical works are designed
+to take away your freedom to share and change the works.  By contrast,
+our General Public Licenses are intended to guarantee your freedom to
+share and change all versions of a program--to make sure it remains free
+software for all its users.
+
+  When we speak of free software, we are referring to freedom, not
+price.  Our General Public Licenses are designed to make sure that you
+have the freedom to distribute copies of free software (and charge for
+them if you wish), that you receive source code or can get it if you
+want it, that you can change the software or use pieces of it in new
+free programs, and that you know you can do these things.
+
+  Developers that use our General Public Licenses protect your rights
+with two steps: (1) assert copyright on the software, and (2) offer
+you this License which gives you legal permission to copy, distribute
+and/or modify the software.
+
+  A secondary benefit of defending all users' freedom is that
+improvements made in alternate versions of the program, if they
+receive widespread use, become available for other developers to
+incorporate.  Many developers of free software are heartened and
+encouraged by the resulting cooperation.  However, in the case of
+software used on network servers, this result may fail to come about.
+The GNU General Public License permits making a modified version and
+letting the public access it on a server without ever releasing its
+source code to the public.
+
+  The GNU Affero General Public License is designed specifically to
+ensure that, in such cases, the modified source code becomes available
+to the community.  It requires the operator of a network server to
+provide the source code of the modified version running there to the
+users of that server.  Therefore, public use of a modified version, on
+a publicly accessible server, gives the public access to the source
+code of the modified version.
+
+  An older license, called the Affero General Public License and
+published by Affero, was designed to accomplish similar goals.  This is
+a different license, not a version of the Affero GPL, but Affero has
+released a new version of the Affero GPL which permits relicensing under
+this license.
+
+  The precise terms and conditions for copying, distribution and
+modification follow.
+
+                       TERMS AND CONDITIONS
+
+  0. Definitions.
+
+  "This License" refers to version 3 of the GNU Affero General Public License.
+
+  "Copyright" also means copyright-like laws that apply to other kinds of
+works, such as semiconductor masks.
+
+  "The Program" refers to any copyrightable work licensed under this
+License.  Each licensee is addressed as "you".  "Licensees" and
+"recipients" may be individuals or organizations.
+
+  To "modify" a work means to copy from or adapt all or part of the work
+in a fashion requiring copyright permission, other than the making of an
+exact copy.  The resulting work is called a "modified version" of the
+earlier work or a work "based on" the earlier work.
+
+  A "covered work" means either the unmodified Program or a work based
+on the Program.
+
+  To "propagate" a work means to do anything with it that, without
+permission, would make you directly or secondarily liable for
+infringement under applicable copyright law, except executing it on a
+computer or modifying a private copy.  Propagation includes copying,
+distribution (with or without modification), making available to the
+public, and in some countries other activities as well.
+
+  To "convey" a work means any kind of propagation that enables other
+parties to make or receive copies.  Mere interaction with a user through
+a computer network, with no transfer of a copy, is not conveying.
+
+  An interactive user interface displays "Appropriate Legal Notices"
+to the extent that it includes a convenient and prominently visible
+feature that (1) displays an appropriate copyright notice, and (2)
+tells the user that there is no warranty for the work (except to the
+extent that warranties are provided), that licensees may convey the
+work under this License, and how to view a copy of this License.  If
+the interface presents a list of user commands or options, such as a
+menu, a prominent item in the list meets this criterion.
+
+  1. Source Code.
+
+  The "source code" for a work means the preferred form of the work
+for making modifications to it.  "Object code" means any non-source
+form of a work.
+
+  A "Standard Interface" means an interface that either is an official
+standard defined by a recognized standards body, or, in the case of
+interfaces specified for a particular programming language, one that
+is widely used among developers working in that language.
+
+  The "System Libraries" of an executable work include anything, other
+than the work as a whole, that (a) is included in the normal form of
+packaging a Major Component, but which is not part of that Major
+Component, and (b) serves only to enable use of the work with that
+Major Component, or to implement a Standard Interface for which an
+implementation is available to the public in source code form.  A
+"Major Component", in this context, means a major essential component
+(kernel, window system, and so on) of the specific operating system
+(if any) on which the executable work runs, or a compiler used to
+produce the work, or an object code interpreter used to run it.
+
+  The "Corresponding Source" for a work in object code form means all
+the source code needed to generate, install, and (for an executable
+work) run the object code and to modify the work, including scripts to
+control those activities.  However, it does not include the work's
+System Libraries, or general-purpose tools or generally available free
+programs which are used unmodified in performing those activities but
+which are not part of the work.  For example, Corresponding Source
+includes interface definition files associated with source files for
+the work, and the source code for shared libraries and dynamically
+linked subprograms that the work is specifically designed to require,
+such as by intimate data communication or control flow between those
+subprograms and other parts of the work.
+
+  The Corresponding Source need not include anything that users
+can regenerate automatically from other parts of the Corresponding
+Source.
+
+  The Corresponding Source for a work in source code form is that
+same work.
+
+  2. Basic Permissions.
+
+  All rights granted under this License are granted for the term of
+copyright on the Program, and are irrevocable provided the stated
+conditions are met.  This License explicitly affirms your unlimited
+permission to run the unmodified Program.  The output from running a
+covered work is covered by this License only if the output, given its
+content, constitutes a covered work.  This License acknowledges your
+rights of fair use or other equivalent, as provided by copyright law.
+
+  You may make, run and propagate covered works that you do not
+convey, without conditions so long as your license otherwise remains
+in force.  You may convey covered works to others for the sole purpose
+of having them make modifications exclusively for you, or provide you
+with facilities for running those works, provided that you comply with
+the terms of this License in conveying all material for which you do
+not control copyright.  Those thus making or running the covered works
+for you must do so exclusively on your behalf, under your direction
+and control, on terms that prohibit them from making any copies of
+your copyrighted material outside their relationship with you.
+
+  Conveying under any other circumstances is permitted solely under
+the conditions stated below.  Sublicensing is not allowed; section 10
+makes it unnecessary.
+
+  3. Protecting Users' Legal Rights From Anti-Circumvention Law.
+
+  No covered work shall be deemed part of an effective technological
+measure under any applicable law fulfilling obligations under article
+11 of the WIPO copyright treaty adopted on 20 December 1996, or
+similar laws prohibiting or restricting circumvention of such
+measures.
+
+  When you convey a covered work, you waive any legal power to forbid
+circumvention of technological measures to the extent such circumvention
+is effected by exercising rights under this License with respect to
+the covered work, and you disclaim any intention to limit operation or
+modification of the work as a means of enforcing, against the work's
+users, your or third parties' legal rights to forbid circumvention of
+technological measures.
+
+  4. Conveying Verbatim Copies.
+
+  You may convey verbatim copies of the Program's source code as you
+receive it, in any medium, provided that you conspicuously and
+appropriately publish on each copy an appropriate copyright notice;
+keep intact all notices stating that this License and any
+non-permissive terms added in accord with section 7 apply to the code;
+keep intact all notices of the absence of any warranty; and give all
+recipients a copy of this License along with the Program.
+
+  You may charge any price or no price for each copy that you convey,
+and you may offer support or warranty protection for a fee.
+
+  5. Conveying Modified Source Versions.
+
+  You may convey a work based on the Program, or the modifications to
+produce it from the Program, in the form of source code under the
+terms of section 4, provided that you also meet all of these conditions:
+
+    a) The work must carry prominent notices stating that you modified
+    it, and giving a relevant date.
+
+    b) The work must carry prominent notices stating that it is
+    released under this License and any conditions added under section
+    7.  This requirement modifies the requirement in section 4 to
+    "keep intact all notices".
+
+    c) You must license the entire work, as a whole, under this
+    License to anyone who comes into possession of a copy.  This
+    License will therefore apply, along with any applicable section 7
+    additional terms, to the whole of the work, and all its parts,
+    regardless of how they are packaged.  This License gives no
+    permission to license the work in any other way, but it does not
+    invalidate such permission if you have separately received it.
+
+    d) If the work has interactive user interfaces, each must display
+    Appropriate Legal Notices; however, if the Program has interactive
+    interfaces that do not display Appropriate Legal Notices, your
+    work need not make them do so.
+
+  A compilation of a covered work with other separate and independent
+works, which are not by their nature extensions of the covered work,
+and which are not combined with it such as to form a larger program,
+in or on a volume of a storage or distribution medium, is called an
+"aggregate" if the compilation and its resulting copyright are not
+used to limit the access or legal rights of the compilation's users
+beyond what the individual works permit.  Inclusion of a covered work
+in an aggregate does not cause this License to apply to the other
+parts of the aggregate.
+
+  6. Conveying Non-Source Forms.
+
+  You may convey a covered work in object code form under the terms
+of sections 4 and 5, provided that you also convey the
+machine-readable Corresponding Source under the terms of this License,
+in one of these ways:
+
+    a) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by the
+    Corresponding Source fixed on a durable physical medium
+    customarily used for software interchange.
+
+    b) Convey the object code in, or embodied in, a physical product
+    (including a physical distribution medium), accompanied by a
+    written offer, valid for at least three years and valid for as
+    long as you offer spare parts or customer support for that product
+    model, to give anyone who possesses the object code either (1) a
+    copy of the Corresponding Source for all the software in the
+    product that is covered by this License, on a durable physical
+    medium customarily used for software interchange, for a price no
+    more than your reasonable cost of physically performing this
+    conveying of source, or (2) access to copy the
+    Corresponding Source from a network server at no charge.
+
+    c) Convey individual copies of the object code with a copy of the
+    written offer to provide the Corresponding Source.  This
+    alternative is allowed only occasionally and noncommercially, and
+    only if you received the object code with such an offer, in accord
+    with subsection 6b.
+
+    d) Convey the object code by offering access from a designated
+    place (gratis or for a charge), and offer equivalent access to the
+    Corresponding Source in the same way through the same place at no
+    further charge.  You need not require recipients to copy the
+    Corresponding Source along with the object code.  If the place to
+    copy the object code is a network server, the Corresponding Source
+    may be on a different server (operated by you or a third party)
+    that supports equivalent copying facilities, provided you maintain
+    clear directions next to the object code saying where to find the
+    Corresponding Source.  Regardless of what server hosts the
+    Corresponding Source, you remain obligated to ensure that it is
+    available for as long as needed to satisfy these requirements.
+
+    e) Convey the object code using peer-to-peer transmission, provided
+    you inform other peers where the object code and Corresponding
+    Source of the work are being offered to the general public at no
+    charge under subsection 6d.
+
+  A separable portion of the object code, whose source code is excluded
+from the Corresponding Source as a System Library, need not be
+included in conveying the object code work.
+
+  A "User Product" is either (1) a "consumer product", which means any
+tangible personal property which is normally used for personal, family,
+or household purposes, or (2) anything designed or sold for incorporation
+into a dwelling.  In determining whether a product is a consumer product,
+doubtful cases shall be resolved in favor of coverage.  For a particular
+product received by a particular user, "normally used" refers to a
+typical or common use of that class of product, regardless of the status
+of the particular user or of the way in which the particular user
+actually uses, or expects or is expected to use, the product.  A product
+is a consumer product regardless of whether the product has substantial
+commercial, industrial or non-consumer uses, unless such uses represent
+the only significant mode of use of the product.
+
+  "Installation Information" for a User Product means any methods,
+procedures, authorization keys, or other information required to install
+and execute modified versions of a covered work in that User Product from
+a modified version of its Corresponding Source.  The information must
+suffice to ensure that the continued functioning of the modified object
+code is in no case prevented or interfered with solely because
+modification has been made.
+
+  If you convey an object code work under this section in, or with, or
+specifically for use in, a User Product, and the conveying occurs as
+part of a transaction in which the right of possession and use of the
+User Product is transferred to the recipient in perpetuity or for a
+fixed term (regardless of how the transaction is characterized), the
+Corresponding Source conveyed under this section must be accompanied
+by the Installation Information.  But this requirement does not apply
+if neither you nor any third party retains the ability to install
+modified object code on the User Product (for example, the work has
+been installed in ROM).
+
+  The requirement to provide Installation Information does not include a
+requirement to continue to provide support service, warranty, or updates
+for a work that has been modified or installed by the recipient, or for
+the User Product in which it has been modified or installed.  Access to a
+network may be denied when the modification itself materially and
+adversely affects the operation of the network or violates the rules and
+protocols for communication across the network.
+
+  Corresponding Source conveyed, and Installation Information provided,
+in accord with this section must be in a format that is publicly
+documented (and with an implementation available to the public in
+source code form), and must require no special password or key for
+unpacking, reading or copying.
+
+  7. Additional Terms.
+
+  "Additional permissions" are terms that supplement the terms of this
+License by making exceptions from one or more of its conditions.
+Additional permissions that are applicable to the entire Program shall
+be treated as though they were included in this License, to the extent
+that they are valid under applicable law.  If additional permissions
+apply only to part of the Program, that part may be used separately
+under those permissions, but the entire Program remains governed by
+this License without regard to the additional permissions.
+
+  When you convey a copy of a covered work, you may at your option
+remove any additional permissions from that copy, or from any part of
+it.  (Additional permissions may be written to require their own
+removal in certain cases when you modify the work.)  You may place
+additional permissions on material, added by you to a covered work,
+for which you have or can give appropriate copyright permission.
+
+  Notwithstanding any other provision of this License, for material you
+add to a covered work, you may (if authorized by the copyright holders of
+that material) supplement the terms of this License with terms:
+
+    a) Disclaiming warranty or limiting liability differently from the
+    terms of sections 15 and 16 of this License; or
+
+    b) Requiring preservation of specified reasonable legal notices or
+    author attributions in that material or in the Appropriate Legal
+    Notices displayed by works containing it; or
+
+    c) Prohibiting misrepresentation of the origin of that material, or
+    requiring that modified versions of such material be marked in
+    reasonable ways as different from the original version; or
+
+    d) Limiting the use for publicity purposes of names of licensors or
+    authors of the material; or
+
+    e) Declining to grant rights under trademark law for use of some
+    trade names, trademarks, or service marks; or
+
+    f) Requiring indemnification of licensors and authors of that
+    material by anyone who conveys the material (or modified versions of
+    it) with contractual assumptions of liability to the recipient, for
+    any liability that these contractual assumptions directly impose on
+    those licensors and authors.
+
+  All other non-permissive additional terms are considered "further
+restrictions" within the meaning of section 10.  If the Program as you
+received it, or any part of it, contains a notice stating that it is
+governed by this License along with a term that is a further
+restriction, you may remove that term.  If a license document contains
+a further restriction but permits relicensing or conveying under this
+License, you may add to a covered work material governed by the terms
+of that license document, provided that the further restriction does
+not survive such relicensing or conveying.
+
+  If you add terms to a covered work in accord with this section, you
+must place, in the relevant source files, a statement of the
+additional terms that apply to those files, or a notice indicating
+where to find the applicable terms.
+
+  Additional terms, permissive or non-permissive, may be stated in the
+form of a separately written license, or stated as exceptions;
+the above requirements apply either way.
+
+  8. Termination.
+
+  You may not propagate or modify a covered work except as expressly
+provided under this License.  Any attempt otherwise to propagate or
+modify it is void, and will automatically terminate your rights under
+this License (including any patent licenses granted under the third
+paragraph of section 11).
+
+  However, if you cease all violation of this License, then your
+license from a particular copyright holder is reinstated (a)
+provisionally, unless and until the copyright holder explicitly and
+finally terminates your license, and (b) permanently, if the copyright
+holder fails to notify you of the violation by some reasonable means
+prior to 60 days after the cessation.
+
+  Moreover, your license from a particular copyright holder is
+reinstated permanently if the copyright holder notifies you of the
+violation by some reasonable means, this is the first time you have
+received notice of violation of this License (for any work) from that
+copyright holder, and you cure the violation prior to 30 days after
+your receipt of the notice.
+
+  Termination of your rights under this section does not terminate the
+licenses of parties who have received copies or rights from you under
+this License.  If your rights have been terminated and not permanently
+reinstated, you do not qualify to receive new licenses for the same
+material under section 10.
+
+  9. Acceptance Not Required for Having Copies.
+
+  You are not required to accept this License in order to receive or
+run a copy of the Program.  Ancillary propagation of a covered work
+occurring solely as a consequence of using peer-to-peer transmission
+to receive a copy likewise does not require acceptance.  However,
+nothing other than this License grants you permission to propagate or
+modify any covered work.  These actions infringe copyright if you do
+not accept this License.  Therefore, by modifying or propagating a
+covered work, you indicate your acceptance of this License to do so.
+
+  10. Automatic Licensing of Downstream Recipients.
+
+  Each time you convey a covered work, the recipient automatically
+receives a license from the original licensors, to run, modify and
+propagate that work, subject to this License.  You are not responsible
+for enforcing compliance by third parties with this License.
+
+  An "entity transaction" is a transaction transferring control of an
+organization, or substantially all assets of one, or subdividing an
+organization, or merging organizations.  If propagation of a covered
+work results from an entity transaction, each party to that
+transaction who receives a copy of the work also receives whatever
+licenses to the work the party's predecessor in interest had or could
+give under the previous paragraph, plus a right to possession of the
+Corresponding Source of the work from the predecessor in interest, if
+the predecessor has it or can get it with reasonable efforts.
+
+  You may not impose any further restrictions on the exercise of the
+rights granted or affirmed under this License.  For example, you may
+not impose a license fee, royalty, or other charge for exercise of
+rights granted under this License, and you may not initiate litigation
+(including a cross-claim or counterclaim in a lawsuit) alleging that
+any patent claim is infringed by making, using, selling, offering for
+sale, or importing the Program or any portion of it.
+
+  11. Patents.
+
+  A "contributor" is a copyright holder who authorizes use under this
+License of the Program or a work on which the Program is based.  The
+work thus licensed is called the contributor's "contributor version".
+
+  A contributor's "essential patent claims" are all patent claims
+owned or controlled by the contributor, whether already acquired or
+hereafter acquired, that would be infringed by some manner, permitted
+by this License, of making, using, or selling its contributor version,
+but do not include claims that would be infringed only as a
+consequence of further modification of the contributor version.  For
+purposes of this definition, "control" includes the right to grant
+patent sublicenses in a manner consistent with the requirements of
+this License.
+
+  Each contributor grants you a non-exclusive, worldwide, royalty-free
+patent license under the contributor's essential patent claims, to
+make, use, sell, offer for sale, import and otherwise run, modify and
+propagate the contents of its contributor version.
+
+  In the following three paragraphs, a "patent license" is any express
+agreement or commitment, however denominated, not to enforce a patent
+(such as an express permission to practice a patent or covenant not to
+sue for patent infringement).  To "grant" such a patent license to a
+party means to make such an agreement or commitment not to enforce a
+patent against the party.
+
+  If you convey a covered work, knowingly relying on a patent license,
+and the Corresponding Source of the work is not available for anyone
+to copy, free of charge and under the terms of this License, through a
+publicly available network server or other readily accessible means,
+then you must either (1) cause the Corresponding Source to be so
+available, or (2) arrange to deprive yourself of the benefit of the
+patent license for this particular work, or (3) arrange, in a manner
+consistent with the requirements of this License, to extend the patent
+license to downstream recipients.  "Knowingly relying" means you have
+actual knowledge that, but for the patent license, your conveying the
+covered work in a country, or your recipient's use of the covered work
+in a country, would infringe one or more identifiable patents in that
+country that you have reason to believe are valid.
+
+  If, pursuant to or in connection with a single transaction or
+arrangement, you convey, or propagate by procuring conveyance of, a
+covered work, and grant a patent license to some of the parties
+receiving the covered work authorizing them to use, propagate, modify
+or convey a specific copy of the covered work, then the patent license
+you grant is automatically extended to all recipients of the covered
+work and works based on it.
+
+  A patent license is "discriminatory" if it does not include within
+the scope of its coverage, prohibits the exercise of, or is
+conditioned on the non-exercise of one or more of the rights that are
+specifically granted under this License.  You may not convey a covered
+work if you are a party to an arrangement with a third party that is
+in the business of distributing software, under which you make payment
+to the third party based on the extent of your activity of conveying
+the work, and under which the third party grants, to any of the
+parties who would receive the covered work from you, a discriminatory
+patent license (a) in connection with copies of the covered work
+conveyed by you (or copies made from those copies), or (b) primarily
+for and in connection with specific products or compilations that
+contain the covered work, unless you entered into that arrangement,
+or that patent license was granted, prior to 28 March 2007.
+
+  Nothing in this License shall be construed as excluding or limiting
+any implied license or other defenses to infringement that may
+otherwise be available to you under applicable patent law.
+
+  12. No Surrender of Others' Freedom.
+
+  If conditions are imposed on you (whether by court order, agreement or
+otherwise) that contradict the conditions of this License, they do not
+excuse you from the conditions of this License.  If you cannot convey a
+covered work so as to satisfy simultaneously your obligations under this
+License and any other pertinent obligations, then as a consequence you may
+not convey it at all.  For example, if you agree to terms that obligate you
+to collect a royalty for further conveying from those to whom you convey
+the Program, the only way you could satisfy both those terms and this
+License would be to refrain entirely from conveying the Program.
+
+  13. Remote Network Interaction; Use with the GNU General Public License.
+
+  Notwithstanding any other provision of this License, if you modify the
+Program, your modified version must prominently offer all users
+interacting with it remotely through a computer network (if your version
+supports such interaction) an opportunity to receive the Corresponding
+Source of your version by providing access to the Corresponding Source
+from a network server at no charge, through some standard or customary
+means of facilitating copying of software.  This Corresponding Source
+shall include the Corresponding Source for any work covered by version 3
+of the GNU General Public License that is incorporated pursuant to the
+following paragraph.
+
+  Notwithstanding any other provision of this License, you have
+permission to link or combine any covered work with a work licensed
+under version 3 of the GNU General Public License into a single
+combined work, and to convey the resulting work.  The terms of this
+License will continue to apply to the part which is the covered work,
+but the work with which it is combined will remain governed by version
+3 of the GNU General Public License.
+
+  14. Revised Versions of this License.
+
+  The Free Software Foundation may publish revised and/or new versions of
+the GNU Affero General Public License from time to time.  Such new versions
+will be similar in spirit to the present version, but may differ in detail to
+address new problems or concerns.
+
+  Each version is given a distinguishing version number.  If the
+Program specifies that a certain numbered version of the GNU Affero General
+Public License "or any later version" applies to it, you have the
+option of following the terms and conditions either of that numbered
+version or of any later version published by the Free Software
+Foundation.  If the Program does not specify a version number of the
+GNU Affero General Public License, you may choose any version ever published
+by the Free Software Foundation.
+
+  If the Program specifies that a proxy can decide which future
+versions of the GNU Affero General Public License can be used, that proxy's
+public statement of acceptance of a version permanently authorizes you
+to choose that version for the Program.
+
+  Later license versions may give you additional or different
+permissions.  However, no additional obligations are imposed on any
+author or copyright holder as a result of your choosing to follow a
+later version.
+
+  15. Disclaimer of Warranty.
+
+  THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
+APPLICABLE LAW.  EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
+HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
+OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
+THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
+PURPOSE.  THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
+IS WITH YOU.  SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
+ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
+
+  16. Limitation of Liability.
+
+  IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
+WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
+THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
+GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
+USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
+DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
+PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
+EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
+SUCH DAMAGES.
+
+  17. Interpretation of Sections 15 and 16.
+
+  If the disclaimer of warranty and limitation of liability provided
+above cannot be given local legal effect according to their terms,
+reviewing courts shall apply local law that most closely approximates
+an absolute waiver of all civil liability in connection with the
+Program, unless a warranty or assumption of liability accompanies a
+copy of the Program in return for a fee.
+
+                     END OF TERMS AND CONDITIONS
+
+            How to Apply These Terms to Your New Programs
+
+  If you develop a new program, and you want it to be of the greatest
+possible use to the public, the best way to achieve this is to make it
+free software which everyone can redistribute and change under these terms.
+
+  To do so, attach the following notices to the program.  It is safest
+to attach them to the start of each source file to most effectively
+state the exclusion of warranty; and each file should have at least
+the "copyright" line and a pointer to where the full notice is found.
+
+    <one line to give the program's name and a brief idea of what it does.>
+    Copyright (C) <year>  <name of author>
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as published
+    by the Free Software Foundation, either version 3 of the License, or
+    (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>.
+
+Also add information on how to contact you by electronic and paper mail.
+
+  If your software can interact with users remotely through a computer
+network, you should also make sure that it provides a way for users to
+get its source.  For example, if your program is a web application, its
+interface could display a "Source" link that leads users to an archive
+of the code.  There are many ways you could offer source, and different
+solutions will be better for different programs; see section 13 for the
+specific requirements.
+
+  You should also get your employer (if you work as a programmer) or school,
+if any, to sign a "copyright disclaimer" for the program, if necessary.
+For more information on this, and how to apply and follow the GNU AGPL, see
+<https://www.gnu.org/licenses/>.
diff --git a/README.md b/README.md
index 3c53573..db8d5d9 100644
--- a/README.md
+++ b/README.md
@@ -1,37 +1,156 @@
-# ncplot7py
-NC Code Plot for CNC Code
+# NC-Edit7 CGI Server
 
+This directory contains the CGI server script for handling plot requests from the NC-Edit7 frontend.
 
+## Overview
 
-# run Tests
-& C:/Users/Damian/Project/ncplot7py/ncplot7py/.venv/Scripts/Activate.ps1
+The `cgiserver.cgi` script is a Python CGI script that:
+- Lists available CNC machines
+- Processes NC programs and generates plot data
+- Returns execution results including toolpath segments, variables, and timing
 
- $env:PYTHONPATH = 'src'; python -m unittest discover -s tests/unit -p "test_*.py" -v
+## API Endpoints
 
- $env:PYTHONPATH='src'; python -m unittest discover -s tests/integration -p "test_*.py" -v
+### List Machines
 
-## Error handling and i18n
+**Request:**
+```json
+{
+  "action": "list_machines"
+}
+```
+
+**Response:**
+```json
+{
+  "machines": [
+    {"machineName": "ISO_MILL", "controlType": "MILL"},
+    {"machineName": "FANUC_T", "controlType": "TURN"},
+    ...
+  ],
+  "success": true
+}
+```
+
+### Execute Programs
+
+**Request:**
+```json
+{
+  "machinedata": [
+    {
+      "program": "G90 G54\nG0 X0 Y0 Z10\nG1 X50 Y0 F300\nM30",
+      "machineName": "ISO_MILL",
+      "canalNr": "channel-1"
+    }
+  ]
+}
+```
+
+**Response:**
+```json
+{
+  "canal": {
+    "channel-1": {
+      "segments": [
+        {
+          "type": "RAPID",
+          "lineNumber": 2,
+          "toolNumber": 1,
+          "points": [
+            {"x": 0, "y": 0, "z": 0},
+            {"x": 0, "y": 0, "z": 10}
+          ]
+        }
+      ],
+      "executedLines": [1, 2, 3, 4],
+      "variables": {},
+      "timing": [0.1, 0.1, 0.1, 0.1]
+    }
+  },
+  "message": ["Successfully processed ISO_MILL canal channel-1"],
+  "success": true
+}
+```
+
+## Supported Machines
+
+- `ISO_MILL` - ISO standard milling machine
+- `FANUC_T` - FANUC turning machine
+- `SB12RG_F` - SB12RG front spindle
+- `SB12RG_B` - SB12RG back spindle
+- `SR20JII_F` - SR20JII front spindle
+- `SR20JII_B` - SR20JII back spindle
+
+## Deployment
+
+### Apache Configuration
 
-This project provides structured, localized errors for CNC/NC parsing and runtime.
+1. Enable CGI module:
+   ```bash
+   sudo a2enmod cgi
+   ```
 
-- Use `ExceptionNode` and `ExceptionTyps` from `ncplot7py.domain.exceptions`.
-- Prefer `raise_nc_error(...)` to attach file/line/column/context and infer the caret position.
--- Localize via XML catalogs under `src/ncplot7py/locales/{lang}.xml` using keys `{typ_value}:{code}`.
+2. Configure virtual host:
+   ```apache
+   ScriptAlias /ncplot7py/scripts/ /var/www/NC-Edit7/ncplot7py/scripts/
+   
+   <Directory /var/www/NC-Edit7/ncplot7py/scripts>
+       Options +ExecCGI
+       AddHandler cgi-script .cgi
+       Require all granted
+   </Directory>
+   ```
 
-Quick example:
+3. Make script executable:
+   ```bash
+   chmod +x cgiserver.cgi
+   ```
 
-```python
-from ncplot7py.domain.exceptions import ExceptionTyps, raise_nc_error
-from ncplot7py.domain.i18n import MessageCatalog
+### Testing
 
-try:
-	raise_nc_error(
-		ExceptionTyps.NCCodeErrors, 1001,
-		value="M30", file="program.nc", line=12,
-		source_line="N12 G1 X10 Y10 M30",
-	)
-except Exception as exc:
-	print(MessageCatalog().format_exception(exc, lang="en"))
+Test the CGI script directly:
+
+```bash
+# List machines
+REQUEST_METHOD=POST CONTENT_LENGTH=30 python3 cgiserver.cgi <<EOF
+{"action": "list_machines"}
+EOF
+
+# Execute program
+cat > test.json <<'TESTEOF'
+{"machinedata": [{"program": "G0 X0 Y0\nG1 X50 Y0", "machineName": "ISO_MILL", "canalNr": "1"}]}
+TESTEOF
+
+REQUEST_METHOD=POST CONTENT_LENGTH=$(wc -c < test.json) python3 cgiserver.cgi < test.json
 ```
 
-See `docs/CODING_GUIDELINES.md` and `docs/COPILOT.md` for details.
\ No newline at end of file
+## Current Implementation
+
+The current implementation is a **mock/demo version** that:
+- Generates simple plot data from basic G-code parsing
+- Provides placeholder execution results
+- Does not require external dependencies
+
+## Production Implementation
+
+For production use, this script should be replaced with or extended to:
+- Use the actual NC parser from the Python backend
+- Integrate with the full CNC state machine
+- Support advanced features like tool change detection, synchronization codes, etc.
+- Connect to MariaDB for logging (see rebuild-plan.md for environment variables)
+
+## Development
+
+For local development with Vite dev server, the `dev-cgi-proxy.js` plugin handles CGI requests by spawning the Python script.
+
+## Error Handling
+
+The script returns error responses with `message_TEST` field:
+
+```json
+{
+  "error": "Error description",
+  "message_TEST": ["Detailed error message"]
+}
+```
diff --git a/READMEold.md b/READMEold.md
new file mode 100644
index 0000000..d0499dc
--- /dev/null
+++ b/READMEold.md
@@ -0,0 +1,37 @@
+# ncplot7py
+NC Code Plot for CNC Code
+
+
+
+# run Tests
+& C:/Users/Damian/Project/ncplot7py/ncplot7py/.venv/Scripts/Activate.ps1
+
+ $env:PYTHONPATH = 'src'; python -m unittest discover -s tests/unit -p "test_*.py" -v
+
+ $env:PYTHONPATH='src'; python -m unittest discover -s tests/integration -p "test_*.py" -v
+
+## Error handling and i18n
+
+This project provides structured, localized errors for CNC/NC parsing and runtime.
+
+- Use `ExceptionNode` and `ExceptionTyps` from `ncplot7py.domain.exceptions`.
+- Prefer `raise_nc_error(...)` to attach file/line/column/context and infer the caret position.
+-- Localize via XML catalogs under `src/ncplot7py/locales/{lang}.xml` using keys `{typ_value}:{code}`.
+
+Quick example:
+
+```python
+from ncplot7py.domain.exceptions import ExceptionTyps, raise_nc_error
+from ncplot7py.domain.i18n import MessageCatalog
+
+try:
+	raise_nc_error(
+		ExceptionTyps.NCCodeErrors, 1001,
+		value="M30", file="program.nc", line=12,
+		source_line="N12 G1 X10 Y10 M30",
+	)
+except Exception as exc:
+	print(MessageCatalog().format_exception(exc, lang="en"))
+```
+
+See `docs/CODING_GUIDELINES.md` and `docs/COPILOT.md` for details.
\ No newline at end of file
diff --git a/data/nc-examples/O0004 b/data/nc-examples/O0004
index d0734f0..8f4b95b 100644
--- a/data/nc-examples/O0004
+++ b/data/nc-examples/O0004
@@ -1,31 +1,31 @@
-%
-O8976(EXAMPLE)
-M81
-GOTO789
-M99
-X5
-#500 = 1
-#600 =[#500 / 3]
-#50 = -4
-U#600
-
-#500 = 1
-#600 = #500 - 3
-#50 = -4
-T#600
-G#50 / 4
-#70 = -4 + 4 * 2
-X#70 / 4
-
-%
-O8976(EXAMPLE)
-M200
-M20
-G98 G1  Z20.0 F100
-G2 X10 R40.0
-G1 C10.0
-G1 X0 
-G3 Z10 R1
-%
-G266A6.W13.S2000.X15.Z15.F0.02B2.0T100.
+%
+O8976(EXAMPLE)
+M81
+GOTO789
+M99
+X5
+#500 = 1
+#600 =[#500 / 3]
+#50 = -4
+U#600
+
+#500 = 1
+#600 = #500 - 3
+#50 = -4
+T#600
+G#50 / 4
+#70 = -4 + 4 * 2
+X#70 / 4
+
+%
+O8976(EXAMPLE)
+M200
+M20
+G98 G1  Z20.0 F100
+G2 X10 R40.0
+G1 C10.0
+G1 X0 
+G3 Z10 R1
+%
+G266A6.W13.S2000.X15.Z15.F0.02B2.0T100.
 %
\ No newline at end of file
diff --git a/data/nc-examples/O6POINT b/data/nc-examples/O6POINT
index 34e5ff8..fba1918 100644
--- a/data/nc-examples/O6POINT
+++ b/data/nc-examples/O6POINT
@@ -1,31 +1,31 @@
-O0001(SB12 RG FRONT)
-T1400
-M36S3000
-G99
-F200 G98
-
-G112
-(TEST)
-
-#100  =0
-#101 = 2
-WHILE[#100 LT #101]DO1
-#100 = #100 + 1
-G1 X0 C0
-G1 X-8.0 C0
-G1 X-8.0 C-1.73
-G3 X-7.0 C-2.66 R1.0
-G1 X-1.0 C-4.33
-G3 X1.0 C-4.33 R1.0
-G1 X7.0 C-2.66
-G3 X8.0 C-1.73 R1.0
-G1 X8.0 C1.73
-G3 X7.0 C2.66 R1.0
-G1 X1.0 C4.33
-G3 X-1.0 C4.33 R1.0
-G1 X-7.0 C2.66
-G3 X-8.0 C1.73 R1.0
-G1 X-8.0 C0
-G1W1.0
-END1
-G113
+O0001(SB12 RG FRONT)
+T1400
+M36S3000
+G99
+F200 G98
+
+G112
+(TEST)
+
+#100  =0
+#101 = 2
+WHILE[#100 LT #101]DO1
+#100 = #100 + 1
+G1 X0 C0
+G1 X-8.0 C0
+G1 X-8.0 C-1.73
+G3 X-7.0 C-2.66 R1.0
+G1 X-1.0 C-4.33
+G3 X1.0 C-4.33 R1.0
+G1 X7.0 C-2.66
+G3 X8.0 C-1.73 R1.0
+G1 X8.0 C1.73
+G3 X7.0 C2.66 R1.0
+G1 X1.0 C4.33
+G3 X-1.0 C4.33 R1.0
+G1 X-7.0 C2.66
+G3 X-8.0 C1.73 R1.0
+G1 X-8.0 C0
+G1W1.0
+END1
+G113
diff --git a/dev-requirements.txt b/dev-requirements.txt
index 43bf9cf..0112def 100644
--- a/dev-requirements.txt
+++ b/dev-requirements.txt
@@ -1,4 +1,4 @@
-# Development requirements (install with `pip install -r dev-requirements.txt`)
-# These are dev-only tools; runtime code should prefer the Python stdlib and keep
-# `dependencies` in `pyproject.toml` empty unless an explicit justification exists.
-
+# Development requirements (install with `pip install -r dev-requirements.txt`)
+# These are dev-only tools; runtime code should prefer the Python stdlib and keep
+# `dependencies` in `pyproject.toml` empty unless an explicit justification exists.
+
diff --git a/dist/ncplot7py-0.0.1-py3-none-any.whl b/dist/ncplot7py-0.0.1-py3-none-any.whl
new file mode 100644
index 0000000..e18abab
Binary files /dev/null and b/dist/ncplot7py-0.0.1-py3-none-any.whl differ
diff --git a/dist/ncplot7py-0.0.1.tar.gz b/dist/ncplot7py-0.0.1.tar.gz
new file mode 100644
index 0000000..15cb73a
Binary files /dev/null and b/dist/ncplot7py-0.0.1.tar.gz differ
diff --git a/docs/CGI_API.md b/docs/CGI_API.md
index 01ba18f..f943420 100644
--- a/docs/CGI_API.md
+++ b/docs/CGI_API.md
@@ -1,165 +1,165 @@
-# CGI API for `scripts/cgiserver.cgi`
-
-This document describes the CGI interface implemented by `scripts/cgiserver.cgi`.
-
-## Overview
-- The CGI script accepts a JSON POST and returns a JSON response.
-- The script logs the request into a MariaDB table (if DB credentials are configured).
-- The core processing runs the project's NC execution engine and returns syncro plot data.
-
-## Request payload shapes
-Two accepted shapes:
-
-1) Object with `machinedata` list:
-
-{
-  "machinedata": [
-    { "program": "<nc-program>", "machineName": "<machine>", "canalNr": <number-or-string> },
-    ...
-  ]
-}
-
-2) Direct list of machine-data objects:
-
-[
-  { "program": "<nc-program>", "machineName": "<machine>", "canalNr": "<canal>" },
-  ...
-]
-
-Each machine-data entry must include `program`, `machineName`, and `canalNr`.
-
-## Allowed machine names
-- SB12RG_F
-- FANUC_T
-- SR20JII_F
-- SB12RG_B
-- SR20JII_B
-- ISO_MILL
-
-## Validation rules
-- Top-level must be an object containing `machinedata` or a list.
-- Each entry must have `program`, `machineName`, and `canalNr`.
-- `machineName` must be one of the allowed names above.
-- `program` must NOT contain any of these characters: `(`, `)`, `{`, `}` — payloads containing them are rejected.
-
-## Server-side preprocessing
-- The script removes substrings matching `\(.*\)` from the program (comments in parentheses).
-- Newlines are converted to semicolons: `\n` -> `;`.
-- Spaces are removed from the program string.
-
-## Side effects / logging
-- The script attempts to insert a row into MariaDB `log.logNCR` with columns `IP` and `POST`.
-- IP is taken from `REMOTE_ADDR` environment variable (trimmed to 19 characters) or "NAN" if missing.
-- POST body is truncated when logged (approx 1000-1500 characters).
-- MariaDB credentials must be provided in the running environment or script.
-
-## Processing flow
-- Builds initial `CNCState` instances per machine name.
-- Sets X axis unit to `diameter` for lathe-style machines (SB12 and SR20, FANUC_T).
-- Creates a `StatefulIsoTurnNCControl` with `count_of_canals`, `canal_names`, and initial `CNCState` list.
-- Instantiates `NCExecutionEngine(control)` and calls `engine.get_Syncro_plot(programs, True)`.
-
-## Response format
-On success, a JSON object similar to:
-
-{
-  "canal": <engine_result>,
-  "message": <message_stack>
-}
-
-- `canal` contains the syncro plot data returned by the execution engine.
-- `message` is the project's message stack (diagnostics/info accumulated during processing).
-
-On error, the script returns a JSON-like error message such as:
-
-{"message_TEST": "<error>", "program": [ ... ]}
-
-or
-
-{"message_T": "<error>", "program": []}
-
-(Exact shape may vary depending on where the exception was raised.)
-
-## Example request (JSON body)
-
-Single program (object with `machinedata`):
-
-{
-  "machinedata": [
-    {
-      "program": "N10 G00 X0 Y0\nN20 G01 X10 Y0",
-      "machineName": "SB12RG_F",
-      "canalNr": 1
-    }
-  ]
-}
-
-Equivalent as a plain list:
-
-[
-  {
-    "program": "N10 G00 X0 Y0\nN20 G01 X10 Y0",
-    "machineName": "SB12RG_F",
-    "canalNr": "canal1"
-  }
-]
-
-## Example PowerShell POST (replace URL)
-
-```powershell
-$json = @'
-{
-  "machinedata": [
-    { "program": "N10 G00 X0 Y0\nN20 G01 X10 Y0", "machineName": "SB12RG_F", "canalNr": 1 }
-  ]
-}
-'@
-
-Invoke-RestMethod -Uri 'https://your-server/cgi-bin/cgiserver.cgi' -Method Post -Body $json -ContentType 'application/json'
-```
-
-## Example response (success)
-
-```json
-{
-  "canal": [ /* engine-specific syncro plot structure */ ],
-  "message": [ /* diagnostic messages */ ]
-}
-```
-
-## Notes / caveats
-- The script has two `request_precheck` blocks; the later one is authoritative for validation.
-- Ensure MariaDB credentials and connectivity are configured in the environment where the CGI runs.
-- Clients need not pre-normalize newlines or spaces; the server will remove spaces and convert newlines to semicolons, but clients must avoid forbidden characters.
-
-## Listing available machines (new)
-
-The CGI supports a lightweight request to retrieve the available machine names and a simple control type description.
-
-Request JSON body:
-
-{
-  "action": "list_machines"
-}
-
-or
-
-{
-  "action": "get_machines"
-}
-
-Response JSON body:
-
-{
-  "machines": [
-    { "machineName": "SB12RG_F", "controlType": "StatefulIsoTurnNCControl" },
-    { "machineName": "SB12RG_B", "controlType": "StatefulIsoTurnNCControl" },
-    ...
-  ]
-}
-
-This is useful for clients to discover supported machine names before sending processing requests.
-
----
-
+# CGI API for `scripts/cgiserver.cgi`
+
+This document describes the CGI interface implemented by `scripts/cgiserver.cgi`.
+
+## Overview
+- The CGI script accepts a JSON POST and returns a JSON response.
+- The script logs the request into a MariaDB table (if DB credentials are configured).
+- The core processing runs the project's NC execution engine and returns syncro plot data.
+
+## Request payload shapes
+Two accepted shapes:
+
+1) Object with `machinedata` list:
+
+{
+  "machinedata": [
+    { "program": "<nc-program>", "machineName": "<machine>", "canalNr": <number-or-string> },
+    ...
+  ]
+}
+
+2) Direct list of machine-data objects:
+
+[
+  { "program": "<nc-program>", "machineName": "<machine>", "canalNr": "<canal>" },
+  ...
+]
+
+Each machine-data entry must include `program`, `machineName`, and `canalNr`.
+
+## Allowed machine names
+- SB12RG_F
+- FANUC_T
+- SR20JII_F
+- SB12RG_B
+- SR20JII_B
+- ISO_MILL
+
+## Validation rules
+- Top-level must be an object containing `machinedata` or a list.
+- Each entry must have `program`, `machineName`, and `canalNr`.
+- `machineName` must be one of the allowed names above.
+- `program` must NOT contain any of these characters: `(`, `)`, `{`, `}` — payloads containing them are rejected.
+
+## Server-side preprocessing
+- The script removes substrings matching `\(.*\)` from the program (comments in parentheses).
+- Newlines are converted to semicolons: `\n` -> `;`.
+- Spaces are removed from the program string.
+
+## Side effects / logging
+- The script attempts to insert a row into MariaDB `log.logNCR` with columns `IP` and `POST`.
+- IP is taken from `REMOTE_ADDR` environment variable (trimmed to 19 characters) or "NAN" if missing.
+- POST body is truncated when logged (approx 1000-1500 characters).
+- MariaDB credentials must be provided in the running environment or script.
+
+## Processing flow
+- Builds initial `CNCState` instances per machine name.
+- Sets X axis unit to `diameter` for lathe-style machines (SB12 and SR20, FANUC_T).
+- Creates a `StatefulIsoTurnNCControl` with `count_of_canals`, `canal_names`, and initial `CNCState` list.
+- Instantiates `NCExecutionEngine(control)` and calls `engine.get_Syncro_plot(programs, True)`.
+
+## Response format
+On success, a JSON object similar to:
+
+{
+  "canal": <engine_result>,
+  "message": <message_stack>
+}
+
+- `canal` contains the syncro plot data returned by the execution engine.
+- `message` is the project's message stack (diagnostics/info accumulated during processing).
+
+On error, the script returns a JSON-like error message such as:
+
+{"message_TEST": "<error>", "program": [ ... ]}
+
+or
+
+{"message_T": "<error>", "program": []}
+
+(Exact shape may vary depending on where the exception was raised.)
+
+## Example request (JSON body)
+
+Single program (object with `machinedata`):
+
+{
+  "machinedata": [
+    {
+      "program": "N10 G00 X0 Y0\nN20 G01 X10 Y0",
+      "machineName": "SB12RG_F",
+      "canalNr": 1
+    }
+  ]
+}
+
+Equivalent as a plain list:
+
+[
+  {
+    "program": "N10 G00 X0 Y0\nN20 G01 X10 Y0",
+    "machineName": "SB12RG_F",
+    "canalNr": "canal1"
+  }
+]
+
+## Example PowerShell POST (replace URL)
+
+```powershell
+$json = @'
+{
+  "machinedata": [
+    { "program": "N10 G00 X0 Y0\nN20 G01 X10 Y0", "machineName": "SB12RG_F", "canalNr": 1 }
+  ]
+}
+'@
+
+Invoke-RestMethod -Uri 'https://your-server/cgi-bin/cgiserver.cgi' -Method Post -Body $json -ContentType 'application/json'
+```
+
+## Example response (success)
+
+```json
+{
+  "canal": [ /* engine-specific syncro plot structure */ ],
+  "message": [ /* diagnostic messages */ ]
+}
+```
+
+## Notes / caveats
+- The script has two `request_precheck` blocks; the later one is authoritative for validation.
+- Ensure MariaDB credentials and connectivity are configured in the environment where the CGI runs.
+- Clients need not pre-normalize newlines or spaces; the server will remove spaces and convert newlines to semicolons, but clients must avoid forbidden characters.
+
+## Listing available machines (new)
+
+The CGI supports a lightweight request to retrieve the available machine names and a simple control type description.
+
+Request JSON body:
+
+{
+  "action": "list_machines"
+}
+
+or
+
+{
+  "action": "get_machines"
+}
+
+Response JSON body:
+
+{
+  "machines": [
+    { "machineName": "SB12RG_F", "controlType": "StatefulIsoTurnNCControl" },
+    { "machineName": "SB12RG_B", "controlType": "StatefulIsoTurnNCControl" },
+    ...
+  ]
+}
+
+This is useful for clients to discover supported machine names before sending processing requests.
+
+---
+
 Generated from `scripts/cgiserver.cgi` in the repository. If you'd like, I can also add an automated test or a small example script under `scripts/` to POST a sample request and save the response.
\ No newline at end of file
diff --git a/docs/CODING_GUIDELINES.md b/docs/CODING_GUIDELINES.md
index d89948c..0cb89f2 100644
--- a/docs/CODING_GUIDELINES.md
+++ b/docs/CODING_GUIDELINES.md
@@ -1,120 +1,120 @@
-# Coding Guidelines
-
-This project favors clear, small, stdlib-first Python with helpful errors and tests. The key conventions are below.
-
-"""Contributor codeline examples.
-
-This module contains a minimal, stdlib-only example showing a write-only helper
-function. It includes documentation and doctest examples so CI can run
-`python -m doctest` against it.
-
-Guidelines followed:
-- Use only Python standard library.
-- Keep examples deterministic and self-cleaning (remove temporary files).
-- Provide a small doctest demonstrating usage.
-
-"""
-from __future__ import annotations
-
-from pathlib import Path
-from typing import Union
-
-
-def write_text(path: Union[str, Path], text: str, append: bool = False) -> None:
-    """Write text to a file using only standard library functions.
-
-    Args:
-        path: File path to write to. Can be a string or Path.
-        text: Text content to write.
-        append: If True, append to the file; otherwise overwrite.
-
-    Returns:
-        None
-
-    Doctest example (runs deterministically):
-
-    >>> # create a small file, read it back, then remove it
-    >>> write_text('tmp_test.txt', 'hello')
-    >>> open('tmp_test.txt', 'r', encoding='utf-8').read()
-    'hello'
-    >>> # clean up
-    >>> import os
-    >>> os.remove('tmp_test.txt')
-
-    """
-    mode = 'a' if append else 'w'
-    p = Path(path)
-    # Ensure parent directory exists when a Path with directories is provided
-    if p.parent and not p.parent.exists():
-        p.parent.mkdir(parents=True, exist_ok=True)
-
-    # Use explicit encoding for reproducible behavior across platforms
-    with p.open(mode, encoding='utf-8') as fh:
-        fh.write(text)
-
-
-__all__ = ["write_text"]
-
-
-## Error handling and i18n
-
-Use the structured exception `ExceptionNode` with localized messages.
-
-- Exception types: `ExceptionTyps` (IntEnum)
-  - NCCodeErrors = 1
-  - NCCanalStarErrors = 2
-  - CNCError = 3
-- Raise errors via helper `raise_nc_error` to include trace and infer column:
-
-  ```python
-  from ncplot7py.domain.exceptions import ExceptionTyps, raise_nc_error
-
-  raise_nc_error(
-      ExceptionTyps.NCCodeErrors,
-      1001,                      # maps to XML key "1:1001"
-      value="M30",              # offending token (used in message formatting)
-      file="program.nc",
-      line=12,
-      source_line="N12 G1 X10 Y10 M30",  # for caret positioning and context
-  )
-  ```
-
-- Exception fields available on `ExceptionNode`:
-  - `typ`, `code`, `line`, `message`, `value`
-  - Trace: `file`, `column`, `context`
-  - `localized(lang)` method returns a localized string with trace.
-
--### Message catalog (XML)
-- Messages live under `src/ncplot7py/locales/{lang}.xml`.
-- Each entry has id `{typ_value}:{code}`. Example (`en.xml`):
-
-  ```xml
-  <messages lang="en">
-    <message id="1:1001">Invalid NC code '{value}' at line {line}</message>
-  </messages>
-  ```
-
-- Avoid over-coupling to English: use placeholders `{value}`, `{line}`, `{code}`, `{typ}`.
-- Provide translations in other languages (e.g. `de.xml`).
-
-### Choosing codes
-- Codes are domain-specific. Reserve ranges per area if helpful:
-  - 1000–1999: NC code syntax/semantics
-  - 2000–2999: canal/synchronization
-  - 3000–3999: generic CNC runtime
-
-Document new codes by adding entries to XML and referencing them in code.
-
-### Displaying errors
-- For UI/CLI, prefer `MessageCatalog().format_exception(e, lang=...)`.
-- This appends trace info automatically (file, line, column) and prints context with a caret.
-
-## Tests
-- Add unit tests for new error conditions and for new message keys.
-- Keep tests deterministic and small; use the standard library `unittest`.
-
-## Style & structure
-- Prefer small modules and functions.
-- Standard library first; add dependencies only with justification.
-- Add type hints and keep public APIs stable.
-
+# Coding Guidelines
+
+This project favors clear, small, stdlib-first Python with helpful errors and tests. The key conventions are below.
+
+"""Contributor codeline examples.
+
+This module contains a minimal, stdlib-only example showing a write-only helper
+function. It includes documentation and doctest examples so CI can run
+`python -m doctest` against it.
+
+Guidelines followed:
+- Use only Python standard library.
+- Keep examples deterministic and self-cleaning (remove temporary files).
+- Provide a small doctest demonstrating usage.
+
+"""
+from __future__ import annotations
+
+from pathlib import Path
+from typing import Union
+
+
+def write_text(path: Union[str, Path], text: str, append: bool = False) -> None:
+    """Write text to a file using only standard library functions.
+
+    Args:
+        path: File path to write to. Can be a string or Path.
+        text: Text content to write.
+        append: If True, append to the file; otherwise overwrite.
+
+    Returns:
+        None
+
+    Doctest example (runs deterministically):
+
+    >>> # create a small file, read it back, then remove it
+    >>> write_text('tmp_test.txt', 'hello')
+    >>> open('tmp_test.txt', 'r', encoding='utf-8').read()
+    'hello'
+    >>> # clean up
+    >>> import os
+    >>> os.remove('tmp_test.txt')
+
+    """
+    mode = 'a' if append else 'w'
+    p = Path(path)
+    # Ensure parent directory exists when a Path with directories is provided
+    if p.parent and not p.parent.exists():
+        p.parent.mkdir(parents=True, exist_ok=True)
+
+    # Use explicit encoding for reproducible behavior across platforms
+    with p.open(mode, encoding='utf-8') as fh:
+        fh.write(text)
+
+
+__all__ = ["write_text"]
+
+
+## Error handling and i18n
+
+Use the structured exception `ExceptionNode` with localized messages.
+
+- Exception types: `ExceptionTyps` (IntEnum)
+  - NCCodeErrors = 1
+  - NCCanalStarErrors = 2
+  - CNCError = 3
+- Raise errors via helper `raise_nc_error` to include trace and infer column:
+
+  ```python
+  from ncplot7py.domain.exceptions import ExceptionTyps, raise_nc_error
+
+  raise_nc_error(
+      ExceptionTyps.NCCodeErrors,
+      1001,                      # maps to XML key "1:1001"
+      value="M30",              # offending token (used in message formatting)
+      file="program.nc",
+      line=12,
+      source_line="N12 G1 X10 Y10 M30",  # for caret positioning and context
+  )
+  ```
+
+- Exception fields available on `ExceptionNode`:
+  - `typ`, `code`, `line`, `message`, `value`
+  - Trace: `file`, `column`, `context`
+  - `localized(lang)` method returns a localized string with trace.
+
+-### Message catalog (XML)
+- Messages live under `src/ncplot7py/locales/{lang}.xml`.
+- Each entry has id `{typ_value}:{code}`. Example (`en.xml`):
+
+  ```xml
+  <messages lang="en">
+    <message id="1:1001">Invalid NC code '{value}' at line {line}</message>
+  </messages>
+  ```
+
+- Avoid over-coupling to English: use placeholders `{value}`, `{line}`, `{code}`, `{typ}`.
+- Provide translations in other languages (e.g. `de.xml`).
+
+### Choosing codes
+- Codes are domain-specific. Reserve ranges per area if helpful:
+  - 1000–1999: NC code syntax/semantics
+  - 2000–2999: canal/synchronization
+  - 3000–3999: generic CNC runtime
+
+Document new codes by adding entries to XML and referencing them in code.
+
+### Displaying errors
+- For UI/CLI, prefer `MessageCatalog().format_exception(e, lang=...)`.
+- This appends trace info automatically (file, line, column) and prints context with a caret.
+
+## Tests
+- Add unit tests for new error conditions and for new message keys.
+- Keep tests deterministic and small; use the standard library `unittest`.
+
+## Style & structure
+- Prefer small modules and functions.
+- Standard library first; add dependencies only with justification.
+- Add type hints and keep public APIs stable.
+
diff --git a/pyproject.toml b/pyproject.toml
index 1184fff..a730f64 100644
--- a/pyproject.toml
+++ b/pyproject.toml
@@ -1,26 +1,26 @@
-[build-system]
-requires = ["hatchling"]
-build-backend = "hatchling.build"
-
-[project]
-name = "ncplot7py"
-version = "0.0.1"
-description = "ncplot7py — plotting and utilities for NetCDF data"
-readme = "README.md"
-license = { text = "See LICENSE" }
-authors = [ { name = "d-creations" } ]
-requires-python = ">=3.8"
-dependencies = []
-
-
-[tool.testing]
-# Test policy: prefer the Python standard library test tools (unittest, doctest, unittest.mock).
-# Use third-party test runners only with explicit justification and PR rationale.
-test-command = "python -m unittest discover -s tests -p 'test_*.py'"
-doctest-command = "python -m doctest -v src/ncplot7py/*.py"
-# CI-run command (PowerShell friendly):
-# powershell: python -m unittest discover -s tests -p 'test_*.py'
-
-[project.optional-dependencies]
-plotting = ["matplotlib>=3.0,<4.0"]
-
+[build-system]
+requires = ["hatchling"]
+build-backend = "hatchling.build"
+
+[project]
+name = "ncplot7py"
+version = "0.0.1"
+description = "ncplot7py — plotting and utilities for NetCDF data"
+readme = "README.md"
+license = { text = "See LICENSE" }
+authors = [ { name = "d-creations" } ]
+requires-python = ">=3.8"
+dependencies = []
+
+
+[tool.testing]
+# Test policy: prefer the Python standard library test tools (unittest, doctest, unittest.mock).
+# Use third-party test runners only with explicit justification and PR rationale.
+test-command = "python -m unittest discover -s tests -p 'test_*.py'"
+doctest-command = "python -m doctest -v src/ncplot7py/*.py"
+# CI-run command (PowerShell friendly):
+# powershell: python -m unittest discover -s tests -p 'test_*.py'
+
+[project.optional-dependencies]
+plotting = ["matplotlib>=3.0,<4.0"]
+
diff --git a/scripts/cgiserver.cgi b/scripts/cgiserver.cgi
new file mode 100644
index 0000000..688234e
--- /dev/null
+++ b/scripts/cgiserver.cgi
@@ -0,0 +1,196 @@
+#!/usr/bin/env python3
+"""
+CGI Server for NC-Edit7 Plot Interface
+Handles machine data requests and returns plot data
+"""
+
+import sys
+import json
+import os
+from typing import Dict, List, Any, Optional
+
+# Set content type for CGI
+print("Content-Type: application/json")
+print()
+
+
+def get_mock_machines() -> List[Dict[str, str]]:
+    """Return list of available machines"""
+    return [
+        {"machineName": "ISO_MILL", "controlType": "MILL"},
+        {"machineName": "FANUC_T", "controlType": "TURN"},
+        {"machineName": "SB12RG_F", "controlType": "MILL"},
+        {"machineName": "SB12RG_B", "controlType": "MILL"},
+        {"machineName": "SR20JII_F", "controlType": "MILL"},
+        {"machineName": "SR20JII_B", "controlType": "MILL"},
+    ]
+
+
+def parse_nc_program(program: str, machine_name: str) -> Dict[str, Any]:
+    """
+    Parse NC program and generate mock plot data
+    In production, this would call the actual NC parser
+    """
+    lines = [line.strip() for line in program.split('\n') if line.strip()]
+    
+    # Generate mock plot segments
+    segments = []
+    current_pos = {"x": 0, "y": 0, "z": 0}
+    
+    for i, line in enumerate(lines):
+        # Simple G-code parsing for demo
+        if line.startswith('G0') or line.startswith('G1'):
+            # Extract coordinates
+            new_pos = current_pos.copy()
+            
+            parts = line.split()
+            for part in parts:
+                if part.startswith('X'):
+                    try:
+                        new_pos['x'] = float(part[1:])
+                    except ValueError:
+                        pass
+                elif part.startswith('Y'):
+                    try:
+                        new_pos['y'] = float(part[1:])
+                    except ValueError:
+                        pass
+                elif part.startswith('Z'):
+                    try:
+                        new_pos['z'] = float(part[1:])
+                    except ValueError:
+                        pass
+            
+            # Create segment
+            segment = {
+                "type": "RAPID" if line.startswith('G0') else "LINEAR",
+                "lineNumber": i + 1,
+                "toolNumber": 1,
+                "points": [
+                    current_pos.copy(),
+                    new_pos.copy()
+                ]
+            }
+            segments.append(segment)
+            current_pos = new_pos
+    
+    return {
+        "segments": segments,
+        "executedLines": list(range(1, len(lines) + 1)),
+        "variables": {},
+        "timing": [0.1] * len(lines)
+    }
+
+
+def handle_list_machines() -> Dict[str, Any]:
+    """Handle machine list request"""
+    return {
+        "machines": get_mock_machines(),
+        "success": True
+    }
+
+
+def handle_execute_programs(programs: List[Dict[str, Any]]) -> Dict[str, Any]:
+    """Handle program execution request"""
+    canal_results = {}
+    messages = []
+    
+    for program_entry in programs:
+        program = program_entry.get("program", "")
+        machine_name = program_entry.get("machineName", "ISO_MILL")
+        canal_nr = program_entry.get("canalNr", "1")
+        
+        # Validate machine name
+        valid_machines = ["SB12RG_F", "FANUC_T", "SR20JII_F", "SB12RG_B", "SR20JII_B", "ISO_MILL"]
+        if machine_name not in valid_machines:
+            messages.append(f"Invalid machine name: {machine_name}")
+            continue
+        
+        # Parse program
+        try:
+            result = parse_nc_program(program, machine_name)
+            canal_results[canal_nr] = result
+            messages.append(f"Successfully processed {machine_name} canal {canal_nr}")
+        except Exception as e:
+            messages.append(f"Error processing {machine_name} canal {canal_nr}: {str(e)}")
+    
+    return {
+        "canal": canal_results,
+        "message": messages,
+        "success": True
+    }
+
+
+def main():
+    """Main CGI entry point"""
+    try:
+        # Get request method
+        request_method = os.environ.get("REQUEST_METHOD", "GET")
+        
+        if request_method != "POST":
+            response = {
+                "error": "Only POST requests are supported",
+                "message_TEST": ["Method not allowed"]
+            }
+            print(json.dumps(response))
+            return
+        
+        # Read POST data
+        content_length = int(os.environ.get("CONTENT_LENGTH", 0))
+        if content_length == 0:
+            response = {
+                "error": "Empty request body",
+                "message_TEST": ["No data provided"]
+            }
+            print(json.dumps(response))
+            return
+        
+        post_data = sys.stdin.read(content_length)
+        request_data = json.loads(post_data)
+        
+        # Handle different request types
+        if "action" in request_data:
+            action = request_data["action"]
+            
+            if action in ["list_machines", "get_machines"]:
+                response = handle_list_machines()
+            else:
+                response = {
+                    "error": f"Unknown action: {action}",
+                    "message_TEST": [f"Invalid action: {action}"]
+                }
+        
+        elif "machinedata" in request_data:
+            programs = request_data["machinedata"]
+            response = handle_execute_programs(programs)
+        
+        elif isinstance(request_data, list):
+            # Direct array format
+            response = handle_execute_programs(request_data)
+        
+        else:
+            response = {
+                "error": "Invalid request format",
+                "message_TEST": ["Request must contain 'action' or 'machinedata'"]
+            }
+        
+        # Return response
+        print(json.dumps(response))
+    
+    except json.JSONDecodeError as e:
+        response = {
+            "error": "Invalid JSON",
+            "message_TEST": [f"JSON parse error: {str(e)}"]
+        }
+        print(json.dumps(response))
+    
+    except Exception as e:
+        response = {
+            "error": "Internal server error",
+            "message_TEST": [f"Server error: {str(e)}"]
+        }
+        print(json.dumps(response))
+
+
+if __name__ == "__main__":
+    main()
diff --git a/scripts/run_example_O0004.py b/scripts/run_example_O0004.py
index 21f2756..318eb6d 100644
--- a/scripts/run_example_O0004.py
+++ b/scripts/run_example_O0004.py
@@ -1,158 +1,158 @@
-"""
-TEST Function example how to use the NC Analyzer
-
-Copyright (C) <2024>  <Damian Roth Switzerland
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU Affero General Public License as
-published by the Free Software Foundation, either version 3 of the
-License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Affero General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program.  If not, see <https://www.gnu.org/licenses/>. 
-"""
-
-from pathlib import Path
-import sys
-from typing import List, Tuple, Any
-
-# Use package imports from the project
-from ncplot7py.application.nc_execution import NCExecutionEngine
-from ncplot7py.shared import configure_logging, get_message_stack, configure_i18n
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.shared.file_adapter import get_program
-
-
-class _Point:
-    def __init__(self, x: float, y: float, z: float):
-        self.x = x
-        self.y = y
-        self.z = z
-
-
-class FileBasedFakeControl:
-    """A minimal fake control that converts parsed NC nodes into simple toolpath points.
-
-    It doesn't perform kinematics — it simply reads X/Y/Z parameters (if present)
-    and creates 1-point lines with a fixed time per command so the engine can
-    produce a plot structure for demonstration and testing.
-    """
-
-    def __init__(self):
-        self._canal_nodes = {}
-
-    def get_canal_count(self) -> int:
-        return 1
-
-    def run_nc_code_list(self, node_list: List[NCCommandNode], canal: int) -> None:
-        # store the nodes for later retrieval
-        self._canal_nodes[canal] = list(node_list)
-
-    def get_tool_path(self, canal: int):
-        nodes = self._canal_nodes.get(canal, [])
-        path = []
-        for n in nodes:
-            params = getattr(n, "command_parameter", {})
-            try:
-                x = float(params.get("X", 0.0))
-            except Exception:
-                x = 0.0
-            try:
-                y = float(params.get("Y", 0.0))
-            except Exception:
-                y = 0.0
-            try:
-                z = float(params.get("Z", 0.0))
-            except Exception:
-                z = 0.0
-            # one-point line segment, time 0.1s
-            path.append(([_Point(x, y, z)], 0.1))
-        return path
-
-    def get_exected_nodes(self, canal: int):
-        return self._canal_nodes.get(canal, [])
-
-    def get_canal_name(self, idx: int) -> str:
-        return f"C{idx}"
-
-    def synchro_points(self, tool_paths, nodes):
-        # no-op for fake control
-        return None
-
-
-def read_program_from_file(path: Path) -> list:
-    """Read a file and return one or more program strings using the file adapter.
-
-    Returns a list of program strings (each string contains commands separated
-    by ';') suitable for passing directly to NCExecutionEngine.get_Syncro_plot.
-    """
-    # Delegate to the shared file_adapter which handles parentheses removal and
-    # splitting into multiple programs if blank lines are used as separators.
-    return get_program(path, split_on_blank_line=True)
-
-
-def main(plot: bool = False) -> int:
-    # Configure logging to capture messages in the in-memory web buffer so
-    # we can print them after the run.
-    configure_logging(console=True, web_buffer=True)
-    configure_i18n()
-
-    # Resolve path to data file (repo root / data / nc-examples / O0004)
-    repo_root = Path(__file__).resolve().parent.parent
-    data_file = repo_root / "data" / "nc-examples" / "O0004"
-
-    if not data_file.exists():
-        print(f"Data file not found: {data_file}")
-        return 2
-
-    programs = read_program_from_file(data_file)
-
-    control = FileBasedFakeControl()
-    engine = NCExecutionEngine(control)
-
-    # get_Syncro_plot expects a list of program strings; our adapter returns
-    # that directly, so pass it through.
-    plot_result = engine.get_Syncro_plot(programs, synch=False)
-
-    print("Returned structure type:", type(plot_result))
-    print("Number of canals:", len(plot_result) if isinstance(plot_result, list) else "n/a")
-    print("Calculated runtime (engine):", engine.get_cacluated_runtime())
-
-    print("Captured messages:")
-    print(get_message_stack())
-
-    # Optionally plot if matplotlib is available and a result was produced
-    if plot and isinstance(plot_result, list) and len(plot_result) > 0:
-        try:
-            import matplotlib.pyplot as plt
-            from mpl_toolkits.mplot3d import Axes3D  # noqa: F401
-
-            all_x, all_y, all_z = [], [], []
-            for canal in plot_result:
-                for line in canal.get("plot", []):
-                    all_x.extend(line.get("x", []))
-                    all_y.extend(line.get("y", []))
-                    all_z.extend(line.get("z", []))
-
-            if all_x and all_y and all_z:
-                fig = plt.figure(1)
-                ax = fig.add_subplot(111, projection='3d')
-                ax.plot(all_z, all_x, all_y, label='parametric curve')
-                ax.set_xlabel('z')
-                ax.set_ylabel('x')
-                ax.set_zlabel('y')
-                plt.title('NC example O0004')
-                plt.show()
-        except Exception as e:
-            print(f"Matplotlib plot failed: {e}")
-
-    return 0
-
-
-if __name__ == '__main__':
-    sys.exit(main(plot=True))
+"""
+TEST Function example how to use the NC Analyzer
+
+Copyright (C) <2024>  <Damian Roth Switzerland
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>. 
+"""
+
+from pathlib import Path
+import sys
+from typing import List, Tuple, Any
+
+# Use package imports from the project
+from ncplot7py.application.nc_execution import NCExecutionEngine
+from ncplot7py.shared import configure_logging, get_message_stack, configure_i18n
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.shared.file_adapter import get_program
+
+
+class _Point:
+    def __init__(self, x: float, y: float, z: float):
+        self.x = x
+        self.y = y
+        self.z = z
+
+
+class FileBasedFakeControl:
+    """A minimal fake control that converts parsed NC nodes into simple toolpath points.
+
+    It doesn't perform kinematics — it simply reads X/Y/Z parameters (if present)
+    and creates 1-point lines with a fixed time per command so the engine can
+    produce a plot structure for demonstration and testing.
+    """
+
+    def __init__(self):
+        self._canal_nodes = {}
+
+    def get_canal_count(self) -> int:
+        return 1
+
+    def run_nc_code_list(self, node_list: List[NCCommandNode], canal: int) -> None:
+        # store the nodes for later retrieval
+        self._canal_nodes[canal] = list(node_list)
+
+    def get_tool_path(self, canal: int):
+        nodes = self._canal_nodes.get(canal, [])
+        path = []
+        for n in nodes:
+            params = getattr(n, "command_parameter", {})
+            try:
+                x = float(params.get("X", 0.0))
+            except Exception:
+                x = 0.0
+            try:
+                y = float(params.get("Y", 0.0))
+            except Exception:
+                y = 0.0
+            try:
+                z = float(params.get("Z", 0.0))
+            except Exception:
+                z = 0.0
+            # one-point line segment, time 0.1s
+            path.append(([_Point(x, y, z)], 0.1))
+        return path
+
+    def get_exected_nodes(self, canal: int):
+        return self._canal_nodes.get(canal, [])
+
+    def get_canal_name(self, idx: int) -> str:
+        return f"C{idx}"
+
+    def synchro_points(self, tool_paths, nodes):
+        # no-op for fake control
+        return None
+
+
+def read_program_from_file(path: Path) -> list:
+    """Read a file and return one or more program strings using the file adapter.
+
+    Returns a list of program strings (each string contains commands separated
+    by ';') suitable for passing directly to NCExecutionEngine.get_Syncro_plot.
+    """
+    # Delegate to the shared file_adapter which handles parentheses removal and
+    # splitting into multiple programs if blank lines are used as separators.
+    return get_program(path, split_on_blank_line=True)
+
+
+def main(plot: bool = False) -> int:
+    # Configure logging to capture messages in the in-memory web buffer so
+    # we can print them after the run.
+    configure_logging(console=True, web_buffer=True)
+    configure_i18n()
+
+    # Resolve path to data file (repo root / data / nc-examples / O0004)
+    repo_root = Path(__file__).resolve().parent.parent
+    data_file = repo_root / "data" / "nc-examples" / "O0004"
+
+    if not data_file.exists():
+        print(f"Data file not found: {data_file}")
+        return 2
+
+    programs = read_program_from_file(data_file)
+
+    control = FileBasedFakeControl()
+    engine = NCExecutionEngine(control)
+
+    # get_Syncro_plot expects a list of program strings; our adapter returns
+    # that directly, so pass it through.
+    plot_result = engine.get_Syncro_plot(programs, synch=False)
+
+    print("Returned structure type:", type(plot_result))
+    print("Number of canals:", len(plot_result) if isinstance(plot_result, list) else "n/a")
+    print("Calculated runtime (engine):", engine.get_cacluated_runtime())
+
+    print("Captured messages:")
+    print(get_message_stack())
+
+    # Optionally plot if matplotlib is available and a result was produced
+    if plot and isinstance(plot_result, list) and len(plot_result) > 0:
+        try:
+            import matplotlib.pyplot as plt
+            from mpl_toolkits.mplot3d import Axes3D  # noqa: F401
+
+            all_x, all_y, all_z = [], [], []
+            for canal in plot_result:
+                for line in canal.get("plot", []):
+                    all_x.extend(line.get("x", []))
+                    all_y.extend(line.get("y", []))
+                    all_z.extend(line.get("z", []))
+
+            if all_x and all_y and all_z:
+                fig = plt.figure(1)
+                ax = fig.add_subplot(111, projection='3d')
+                ax.plot(all_z, all_x, all_y, label='parametric curve')
+                ax.set_xlabel('z')
+                ax.set_ylabel('x')
+                ax.set_zlabel('y')
+                plt.title('NC example O0004')
+                plt.show()
+        except Exception as e:
+            print(f"Matplotlib plot failed: {e}")
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main(plot=True))
diff --git a/scripts/run_example_O6POINT.py b/scripts/run_example_O6POINT.py
index d8975a8..b062fa7 100644
--- a/scripts/run_example_O6POINT.py
+++ b/scripts/run_example_O6POINT.py
@@ -1,269 +1,269 @@
-"""
-TEST Function example how to use the NC Analyzer
-
-Copyright (C) <2024>  <Damian Roth Switzerland
-
-This program is free software: you can redistribute it and/or modify
-it under the terms of the GNU Affero General Public License as
-published by the Free Software Foundation, either version 3 of the
-License, or (at your option) any later version.
-
-This program is distributed in the hope that it will be useful,
-but WITHOUT ANY WARRANTY; without even the implied warranty of
-MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-GNU Affero General Public License for more details.
-
-You should have received a copy of the GNU Affero General Public License
-along with this program.  If not, see <https://www.gnu.org/licenses/>. 
-"""
-
-from pathlib import Path
-import sys
-import os
-
-# Configuration: set to True to save the produced plot to a PNG file instead
-# of (or in addition to) showing it interactively. Adjust the path as needed.
-SAVE_PLOT_TO_PNG = False
-# Example: 'plots/O6POINT.png' (relative to repo root). Parent directories
-# will be created automatically when saving.
-PLOT_OUTPUT_PATH = Path("plots") / "O6POINT.png"
-from typing import List, Tuple, Any
-
-# Use package imports from the project
-from ncplot7py.application.nc_execution import NCExecutionEngine
-from ncplot7py.shared import configure_logging, get_message_stack, configure_i18n
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.shared.file_adapter import get_program
-from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
-
-
-class _Point:
-    def __init__(self, x: float, y: float, z: float):
-        self.x = x
-        self.y = y
-        self.z = z
-
-
-class FileBasedFakeControl:
-    """A minimal fake control that converts parsed NC nodes into simple toolpath points.
-
-    It doesn't perform kinematics — it simply reads X/Y/Z parameters (if present)
-    and creates 1-point lines with a fixed time per command so the engine can
-    produce a plot structure for demonstration and testing.
-    """
-
-    def __init__(self):
-        self._canal_nodes = {}
-
-    def get_canal_count(self) -> int:
-        return 1
-
-    def run_nc_code_list(self, node_list: List[NCCommandNode], canal: int) -> None:
-        # store the nodes for later retrieval
-        self._canal_nodes[canal] = list(node_list)
-
-    def get_tool_path(self, canal: int):
-        nodes = self._canal_nodes.get(canal, [])
-        path = []
-        for n in nodes:
-            params = getattr(n, "command_parameter", {})
-            try:
-                x = float(params.get("X", 0.0))
-            except Exception:
-                x = 0.0
-            try:
-                y = float(params.get("Y", 0.0))
-            except Exception:
-                y = 0.0
-            try:
-                z = float(params.get("Z", 0.0))
-            except Exception:
-                z = 0.0
-            # one-point line segment, time 0.1s
-            path.append(([_Point(x, y, z)], 0.1))
-        return path
-
-    def get_exected_nodes(self, canal: int):
-        return self._canal_nodes.get(canal, [])
-
-    def get_canal_name(self, idx: int) -> str:
-        return f"C{idx}"
-
-    def synchro_points(self, tool_paths, nodes):
-        # no-op for fake control
-        return None
-
-
-def read_program_from_file(path: Path) -> list:
-    """Read a file and return one or more program strings using the file adapter.
-
-    Returns a list of program strings (each string contains commands separated
-    by ';') suitable for passing directly to NCExecutionEngine.get_Syncro_plot.
-    """
-    # Delegate to the shared file_adapter which handles parentheses removal and
-    # splitting into multiple programs if blank lines are used as separators.
-    return get_program(path, split_on_blank_line=False)
-
-
-def main(plot: bool = False) -> int:
-    # Configure logging to capture messages in the in-memory web buffer so
-    # we can print them after the run.
-    configure_logging(console=True, web_buffer=True)
-    configure_i18n()
-
-    # Resolve path to data file (repo root / data / nc-examples / O0004)
-    repo_root = Path(__file__).resolve().parent.parent
-    data_file = repo_root / "data" / "nc-examples" / "O6POINT"
-
-    if not data_file.exists():
-        print(f"Data file not found: {data_file}")
-        return 2
-
-    programs = read_program_from_file(data_file)
-
-    # Use the stateful ISO-turn control implementation for execution.
-    # If the input file contains multiple programs (split on blank lines),
-    # create a control with the matching number of canals to avoid
-    # "Canal X not configured" errors when each program is intended for a
-    # separate canal.
-    control = StatefulIsoTurnNCControl(count_of_canals=max(1, len(programs)))
-    engine = NCExecutionEngine(control)
-
-    # get_Syncro_plot expects a list of program strings; our adapter returns
-    # that directly, so pass it through.
-    plot_result = engine.get_Syncro_plot(programs, synch=False)
-
-    print("Returned structure type:", type(plot_result))
-    print("Number of canals:", len(plot_result) if isinstance(plot_result, list) else "n/a")
-    print("Calculated runtime (engine):", engine.get_cacluated_runtime())
-
-    print("Captured messages:")
-    print(get_message_stack())
-
-    # Optionally plot if matplotlib is available and a result was produced
-    if plot and isinstance(plot_result, list) and len(plot_result) > 0:
-        try:
-            import matplotlib.pyplot as plt
-            from mpl_toolkits.mplot3d import Axes3D  # noqa: F401
-
-            all_x, all_y, all_z = [], [], []
-            for canal in plot_result:
-                # canal may be a dict with a 'plot' key (new API) or a plain list
-                # (legacy/alternate implementations). Handle both safely.
-                if isinstance(canal, dict):
-                    plot_lines = canal.get("plot", [])
-                elif isinstance(canal, (list, tuple)):
-                    plot_lines = canal
-                else:
-                    # unknown format, skip
-                    continue
-
-                for line in plot_lines:
-                    if isinstance(line, dict):
-                        # expected shape from NCExecutionEngine
-                        all_x.extend(line.get("x", []))
-                        all_y.extend(line.get("y", []))
-                        all_z.extend(line.get("z", []))
-                    else:
-                        # fallback: line may be a (points_list, time) tuple
-                        try:
-                            pts = line[0]
-                            for p in pts:
-                                all_x.append(getattr(p, "x", None))
-                                all_y.append(getattr(p, "y", None))
-                                all_z.append(getattr(p, "z", None))
-                        except Exception:
-                            # give up on this line
-                            continue
-
-            if all_x and all_y:
-                # decide whether to show 3D or 2D: if Z is essentially flat
-                # (all zeros or None) prefer a 2D X vs Y plot similar to the
-                # provided reference image.
-                z_vals = [v for v in all_z if v is not None] if all_z else []
-                z_range = (max(z_vals) - min(z_vals)) if z_vals else 0.0
-
-                if z_range > 1e-6:
-                    # 3D plot
-                    fig = plt.figure(1)
-                    ax = fig.add_subplot(111, projection='3d')
-                    ax.plot(all_x, all_y, all_z, label='parametric curve')
-                    ax.set_xlabel('x')
-                    ax.set_ylabel('y')
-                    ax.set_zlabel('z')
-                    plt.title('NC example O6POINT (3D)')
-                    # save if requested, otherwise show
-                    if SAVE_PLOT_TO_PNG:
-                        PLOT_OUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True)
-                        fig.savefig(str(PLOT_OUTPUT_PATH), bbox_inches='tight')
-                        print(f"Saved plot to {PLOT_OUTPUT_PATH}")
-                    else:
-                        plt.show()
-                else:
-                    # 2D plot (X horizontal, Y vertical) with red axis lines
-                    fig, ax = plt.subplots(figsize=(5, 6))
-
-                    # Prepare XY lists, filter out None values
-                    xs = [v for v in all_x if v is not None]
-                    ys = [v for v in all_y if v is not None]
-                    if not xs or not ys:
-                        # nothing to plot
-                        if SAVE_PLOT_TO_PNG:
-                            PLOT_OUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True)
-                            fig.savefig(str(PLOT_OUTPUT_PATH), bbox_inches='tight')
-                            print(f"Saved plot to {PLOT_OUTPUT_PATH}")
-                        else:
-                            plt.show()
-                    else:
-                        # Close the polygon path if not already closed
-                        if xs[0] != xs[-1] or ys[0] != ys[-1]:
-                            xs = xs + [xs[0]]
-                            ys = ys + [ys[0]]
-
-                        # Draw polygon with rounded joins to resemble the reference
-                        ax.plot(xs, ys, color='black', linewidth=2, solid_capstyle='round', solid_joinstyle='round')
-
-                        ax.set_xlabel('X')
-                        ax.set_ylabel('Y')
-                        ax.set_title('NC example O6POINT')
-                        ax.set_aspect('equal', adjustable='datalim')
-
-                        # Compute centroid and draw red axes through it (like reference)
-                        try:
-                            cx = sum(xs[:-1]) / (len(xs) - 1)
-                            cy = sum(ys[:-1]) / (len(ys) - 1)
-                        except Exception:
-                            cx, cy = 0.0, 0.0
-
-                        # draw red axes lines through centroid
-                        ax.axhline(cy, color='red', linewidth=1)
-                        ax.axvline(cx, color='red', linewidth=1)
-
-                        # annotate axis labels similar to reference image
-                        xlim = ax.get_xlim()
-                        ylim = ax.get_ylim()
-                        # place X label to the right, Y label on top
-                        ax.text(xlim[1], cy, 'X', color='red', verticalalignment='bottom', horizontalalignment='right')
-                        ax.text(cx, ylim[1], 'Y', color='red', verticalalignment='top', horizontalalignment='left')
-
-                        # tighten limits with small padding
-                        pad_x = (max(xs) - min(xs)) * 0.12 if (max(xs) - min(xs)) > 0 else 1.0
-                        pad_y = (max(ys) - min(ys)) * 0.12 if (max(ys) - min(ys)) > 0 else 1.0
-                        ax.set_xlim(min(xs) - pad_x, max(xs) + pad_x)
-                        ax.set_ylim(min(ys) - pad_y, max(ys) + pad_y)
-
-                        # save if requested, otherwise show
-                        if SAVE_PLOT_TO_PNG:
-                            PLOT_OUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True)
-                            fig.savefig(str(PLOT_OUTPUT_PATH), bbox_inches='tight')
-                            print(f"Saved plot to {PLOT_OUTPUT_PATH}")
-                        else:
-                            plt.show()
-        except Exception as e:
-            print(f"Matplotlib plot failed: {e}")
-
-    return 0
-
-
-if __name__ == '__main__':
-    sys.exit(main(plot=True))
+"""
+TEST Function example how to use the NC Analyzer
+
+Copyright (C) <2024>  <Damian Roth Switzerland
+
+This program is free software: you can redistribute it and/or modify
+it under the terms of the GNU Affero General Public License as
+published by the Free Software Foundation, either version 3 of the
+License, or (at your option) any later version.
+
+This program is distributed in the hope that it will be useful,
+but WITHOUT ANY WARRANTY; without even the implied warranty of
+MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+GNU Affero General Public License for more details.
+
+You should have received a copy of the GNU Affero General Public License
+along with this program.  If not, see <https://www.gnu.org/licenses/>. 
+"""
+
+from pathlib import Path
+import sys
+import os
+
+# Configuration: set to True to save the produced plot to a PNG file instead
+# of (or in addition to) showing it interactively. Adjust the path as needed.
+SAVE_PLOT_TO_PNG = False
+# Example: 'plots/O6POINT.png' (relative to repo root). Parent directories
+# will be created automatically when saving.
+PLOT_OUTPUT_PATH = Path("plots") / "O6POINT.png"
+from typing import List, Tuple, Any
+
+# Use package imports from the project
+from ncplot7py.application.nc_execution import NCExecutionEngine
+from ncplot7py.shared import configure_logging, get_message_stack, configure_i18n
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.shared.file_adapter import get_program
+from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
+
+
+class _Point:
+    def __init__(self, x: float, y: float, z: float):
+        self.x = x
+        self.y = y
+        self.z = z
+
+
+class FileBasedFakeControl:
+    """A minimal fake control that converts parsed NC nodes into simple toolpath points.
+
+    It doesn't perform kinematics — it simply reads X/Y/Z parameters (if present)
+    and creates 1-point lines with a fixed time per command so the engine can
+    produce a plot structure for demonstration and testing.
+    """
+
+    def __init__(self):
+        self._canal_nodes = {}
+
+    def get_canal_count(self) -> int:
+        return 1
+
+    def run_nc_code_list(self, node_list: List[NCCommandNode], canal: int) -> None:
+        # store the nodes for later retrieval
+        self._canal_nodes[canal] = list(node_list)
+
+    def get_tool_path(self, canal: int):
+        nodes = self._canal_nodes.get(canal, [])
+        path = []
+        for n in nodes:
+            params = getattr(n, "command_parameter", {})
+            try:
+                x = float(params.get("X", 0.0))
+            except Exception:
+                x = 0.0
+            try:
+                y = float(params.get("Y", 0.0))
+            except Exception:
+                y = 0.0
+            try:
+                z = float(params.get("Z", 0.0))
+            except Exception:
+                z = 0.0
+            # one-point line segment, time 0.1s
+            path.append(([_Point(x, y, z)], 0.1))
+        return path
+
+    def get_exected_nodes(self, canal: int):
+        return self._canal_nodes.get(canal, [])
+
+    def get_canal_name(self, idx: int) -> str:
+        return f"C{idx}"
+
+    def synchro_points(self, tool_paths, nodes):
+        # no-op for fake control
+        return None
+
+
+def read_program_from_file(path: Path) -> list:
+    """Read a file and return one or more program strings using the file adapter.
+
+    Returns a list of program strings (each string contains commands separated
+    by ';') suitable for passing directly to NCExecutionEngine.get_Syncro_plot.
+    """
+    # Delegate to the shared file_adapter which handles parentheses removal and
+    # splitting into multiple programs if blank lines are used as separators.
+    return get_program(path, split_on_blank_line=False)
+
+
+def main(plot: bool = False) -> int:
+    # Configure logging to capture messages in the in-memory web buffer so
+    # we can print them after the run.
+    configure_logging(console=True, web_buffer=True)
+    configure_i18n()
+
+    # Resolve path to data file (repo root / data / nc-examples / O0004)
+    repo_root = Path(__file__).resolve().parent.parent
+    data_file = repo_root / "data" / "nc-examples" / "O6POINT"
+
+    if not data_file.exists():
+        print(f"Data file not found: {data_file}")
+        return 2
+
+    programs = read_program_from_file(data_file)
+
+    # Use the stateful ISO-turn control implementation for execution.
+    # If the input file contains multiple programs (split on blank lines),
+    # create a control with the matching number of canals to avoid
+    # "Canal X not configured" errors when each program is intended for a
+    # separate canal.
+    control = StatefulIsoTurnNCControl(count_of_canals=max(1, len(programs)))
+    engine = NCExecutionEngine(control)
+
+    # get_Syncro_plot expects a list of program strings; our adapter returns
+    # that directly, so pass it through.
+    plot_result = engine.get_Syncro_plot(programs, synch=False)
+
+    print("Returned structure type:", type(plot_result))
+    print("Number of canals:", len(plot_result) if isinstance(plot_result, list) else "n/a")
+    print("Calculated runtime (engine):", engine.get_cacluated_runtime())
+
+    print("Captured messages:")
+    print(get_message_stack())
+
+    # Optionally plot if matplotlib is available and a result was produced
+    if plot and isinstance(plot_result, list) and len(plot_result) > 0:
+        try:
+            import matplotlib.pyplot as plt
+            from mpl_toolkits.mplot3d import Axes3D  # noqa: F401
+
+            all_x, all_y, all_z = [], [], []
+            for canal in plot_result:
+                # canal may be a dict with a 'plot' key (new API) or a plain list
+                # (legacy/alternate implementations). Handle both safely.
+                if isinstance(canal, dict):
+                    plot_lines = canal.get("plot", [])
+                elif isinstance(canal, (list, tuple)):
+                    plot_lines = canal
+                else:
+                    # unknown format, skip
+                    continue
+
+                for line in plot_lines:
+                    if isinstance(line, dict):
+                        # expected shape from NCExecutionEngine
+                        all_x.extend(line.get("x", []))
+                        all_y.extend(line.get("y", []))
+                        all_z.extend(line.get("z", []))
+                    else:
+                        # fallback: line may be a (points_list, time) tuple
+                        try:
+                            pts = line[0]
+                            for p in pts:
+                                all_x.append(getattr(p, "x", None))
+                                all_y.append(getattr(p, "y", None))
+                                all_z.append(getattr(p, "z", None))
+                        except Exception:
+                            # give up on this line
+                            continue
+
+            if all_x and all_y:
+                # decide whether to show 3D or 2D: if Z is essentially flat
+                # (all zeros or None) prefer a 2D X vs Y plot similar to the
+                # provided reference image.
+                z_vals = [v for v in all_z if v is not None] if all_z else []
+                z_range = (max(z_vals) - min(z_vals)) if z_vals else 0.0
+
+                if z_range > 1e-6:
+                    # 3D plot
+                    fig = plt.figure(1)
+                    ax = fig.add_subplot(111, projection='3d')
+                    ax.plot(all_x, all_y, all_z, label='parametric curve')
+                    ax.set_xlabel('x')
+                    ax.set_ylabel('y')
+                    ax.set_zlabel('z')
+                    plt.title('NC example O6POINT (3D)')
+                    # save if requested, otherwise show
+                    if SAVE_PLOT_TO_PNG:
+                        PLOT_OUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True)
+                        fig.savefig(str(PLOT_OUTPUT_PATH), bbox_inches='tight')
+                        print(f"Saved plot to {PLOT_OUTPUT_PATH}")
+                    else:
+                        plt.show()
+                else:
+                    # 2D plot (X horizontal, Y vertical) with red axis lines
+                    fig, ax = plt.subplots(figsize=(5, 6))
+
+                    # Prepare XY lists, filter out None values
+                    xs = [v for v in all_x if v is not None]
+                    ys = [v for v in all_y if v is not None]
+                    if not xs or not ys:
+                        # nothing to plot
+                        if SAVE_PLOT_TO_PNG:
+                            PLOT_OUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True)
+                            fig.savefig(str(PLOT_OUTPUT_PATH), bbox_inches='tight')
+                            print(f"Saved plot to {PLOT_OUTPUT_PATH}")
+                        else:
+                            plt.show()
+                    else:
+                        # Close the polygon path if not already closed
+                        if xs[0] != xs[-1] or ys[0] != ys[-1]:
+                            xs = xs + [xs[0]]
+                            ys = ys + [ys[0]]
+
+                        # Draw polygon with rounded joins to resemble the reference
+                        ax.plot(xs, ys, color='black', linewidth=2, solid_capstyle='round', solid_joinstyle='round')
+
+                        ax.set_xlabel('X')
+                        ax.set_ylabel('Y')
+                        ax.set_title('NC example O6POINT')
+                        ax.set_aspect('equal', adjustable='datalim')
+
+                        # Compute centroid and draw red axes through it (like reference)
+                        try:
+                            cx = sum(xs[:-1]) / (len(xs) - 1)
+                            cy = sum(ys[:-1]) / (len(ys) - 1)
+                        except Exception:
+                            cx, cy = 0.0, 0.0
+
+                        # draw red axes lines through centroid
+                        ax.axhline(cy, color='red', linewidth=1)
+                        ax.axvline(cx, color='red', linewidth=1)
+
+                        # annotate axis labels similar to reference image
+                        xlim = ax.get_xlim()
+                        ylim = ax.get_ylim()
+                        # place X label to the right, Y label on top
+                        ax.text(xlim[1], cy, 'X', color='red', verticalalignment='bottom', horizontalalignment='right')
+                        ax.text(cx, ylim[1], 'Y', color='red', verticalalignment='top', horizontalalignment='left')
+
+                        # tighten limits with small padding
+                        pad_x = (max(xs) - min(xs)) * 0.12 if (max(xs) - min(xs)) > 0 else 1.0
+                        pad_y = (max(ys) - min(ys)) * 0.12 if (max(ys) - min(ys)) > 0 else 1.0
+                        ax.set_xlim(min(xs) - pad_x, max(xs) + pad_x)
+                        ax.set_ylim(min(ys) - pad_y, max(ys) + pad_y)
+
+                        # save if requested, otherwise show
+                        if SAVE_PLOT_TO_PNG:
+                            PLOT_OUTPUT_PATH.parent.mkdir(parents=True, exist_ok=True)
+                            fig.savefig(str(PLOT_OUTPUT_PATH), bbox_inches='tight')
+                            print(f"Saved plot to {PLOT_OUTPUT_PATH}")
+                        else:
+                            plt.show()
+        except Exception as e:
+            print(f"Matplotlib plot failed: {e}")
+
+    return 0
+
+
+if __name__ == '__main__':
+    sys.exit(main(plot=True))
diff --git a/src/ncplot7py/__init__.py b/src/ncplot7py/__init__.py
index 5bf848f..52643d1 100644
--- a/src/ncplot7py/__init__.py
+++ b/src/ncplot7py/__init__.py
@@ -1,7 +1,7 @@
-"""ncplot7py package.
-
-Lightweight package initialiser. The package follows a clean architecture
-layout: domain, application, interfaces, infrastructure, shared, and cli.
-"""
-
-__all__ = ["cli", "domain", "application", "interfaces", "infrastructure", "shared"]
+"""ncplot7py package.
+
+Lightweight package initialiser. The package follows a clean architecture
+layout: domain, application, interfaces, infrastructure, shared, and cli.
+"""
+
+__all__ = ["cli", "domain", "application", "interfaces", "infrastructure", "shared"]
diff --git a/src/ncplot7py/__pycache__/__init__.cpython-313.pyc b/src/ncplot7py/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000..1dbcb28
Binary files /dev/null and b/src/ncplot7py/__pycache__/__init__.cpython-313.pyc differ
diff --git a/src/ncplot7py/application/__pycache__/nc_execution.cpython-313.pyc b/src/ncplot7py/application/__pycache__/nc_execution.cpython-313.pyc
new file mode 100644
index 0000000..128327c
Binary files /dev/null and b/src/ncplot7py/application/__pycache__/nc_execution.cpython-313.pyc differ
diff --git a/src/ncplot7py/application/nc_execution.py b/src/ncplot7py/application/nc_execution.py
index 81fd32e..baac224 100644
--- a/src/ncplot7py/application/nc_execution.py
+++ b/src/ncplot7py/application/nc_execution.py
@@ -1,221 +1,221 @@
-"""NC execution engine (renamed from `nc_analyzer`).
-
-Provides `NCExecutionEngine` which is the new name for the orchestrator that
-parses NC programs, delegates execution to an NC control implementation and
-produces toolpath plot data. This keeps the public return values compatible
-with the previous implementation.
-"""
-from __future__ import annotations
-
-import time
-from typing import List, Dict, Optional, Any
-
-from ncplot7py.shared import (
-    configure_logging,
-    print_error,
-    print_message,
-    print_translated_error,
-    get_message_stack,
-    configure_i18n,
-)
-from ncplot7py.shared.registry import registry
-
-
-class NCExecutionEngine:
-    """NC Execution Engine.
-
-    This class preserves the original `get_Syncro_plot` return structure
-    (a list of canal dictionaries, or `[[],[]]` on error) to avoid changing
-    the public API while improving internal structure and naming.
-    """
-
-    def __init__(
-        self,
-        cnc_control: Any,
-    ) -> None:
-        """Initialize the engine.
-
-        Parameters
-        ----------
-        cnc_control:
-            An object implementing the NC control interface (run_nc_code_list,
-            get_tool_path, get_exected_nodes, get_canal_name, get_canal_count,
-            synchro_points).
-        """
-        self.cnc_control = cnc_control
-        self.caclulatet_runtime: float = -1.0
-        # If control offers canal count, use it, otherwise default to 1
-        try:
-            self.count_of_canals = int(self.cnc_control.get_canal_count())
-        except Exception:
-            self.count_of_canals = 1
-
-        # Ensure logging and i18n are configured (caller can reconfigure)
-        configure_logging(console=True, web_buffer=False)
-        configure_i18n()
-
-    def get_cacluated_runtime(self) -> float:
-        return self.caclulatet_runtime
-
-    def _ensure_parser(self):
-        # Ensure a parser is registered (same strategy as cli.bootstrap)
-        if registry.get("parser", "nc_command") is None:
-            try:
-                from ncplot7py.infrastructure.parsers.nc_command_parser import register as _reg_p
-
-                _reg_p(registry)
-            except Exception:
-                # If parser registration fails, let parse attempts raise
-                pass
-
-    def _get_parser(self):
-        self._ensure_parser()
-        parser_cls = registry.get("parser", "nc_command")
-        if parser_cls is None:
-            # try by interface name
-            parser_cls = registry.get("parser", "BaseNCCommandParser")
-        if parser_cls is None:
-            raise RuntimeError("No NC command parser registered")
-        return parser_cls()
-
-    def get_Syncro_plot(self, programs: List[str], synch: bool) -> List[Dict]:
-        """Create the plot for the given NC `programs`.
-
-        Parameters
-        ----------
-        programs: list[str]
-            Each program is a string containing NC commands separated by ';'.
-        synch: bool
-            Whether to attempt synchronization across canals.
-
-        Returns
-        -------
-        list[dict]
-            A list of canal dictionaries in the same shape as the original
-            implementation. On error returns `[[],[]]` to match previous API.
-        """
-        parser = None
-        try:
-            parser = self._get_parser()
-        except Exception as e:
-            print_error(f"Parser setup failed: {e}")
-            return [[], []]
-
-        canal_number = 0
-        tool_paths: List[Any] = []
-        nodes: List[Any] = []
-        error = False
-
-        for program in programs:
-            # Parse program into a list of command nodes
-            node_list = []
-            i = 0
-            try:
-                for raw_line in [p for p in program.split(";") if p.strip()]:
-                    node = parser.parse(raw_line, i)
-                    node_list.append(node)
-                    i += 1
-
-                # Delegate execution to control; many controls accept an iterable
-                # of nodes. Keep canal numbering consistent with callers (+1).
-                self.cnc_control.run_nc_code_list(node_list, canal_number + 1)
-            except Exception as exc:
-                # Try to handle known control exception style (has log_route)
-                log_route = getattr(exc, "log_route", None)
-                if log_route:
-                    # Try to format exception nodes using MessageCatalog when available
-                    try:
-                        from ncplot7py.domain.i18n import MessageCatalog
-
-                        catalog = MessageCatalog()
-                        for node in log_route:
-                            msg = catalog.format_exception(node)
-                            print_error(msg)
-                    except Exception:
-                        print_error(f"NC PARSER/CONTROL ERROR AT LINE {i+1}: {exc}")
-                else:
-                    # generic parser/control error
-                    print_error(f"NC PARSER/CONTROL ERROR AT LINE {i+1}: {exc}")
-                error = True
-                break
-
-            # Try to collect results for this canal
-            try:
-                tool_paths.append(self.cnc_control.get_tool_path(canal_number + 1))
-                nodes.append(self.cnc_control.get_exected_nodes(canal_number + 1))
-            except Exception as exc:
-                print_error(f"Error creating tool path: {exc}")
-                error = True
-                break
-
-            canal_number += 1
-
-        # Synchronize across canals if requested
-        try:
-            if not error and self.count_of_canals > 1 and synch:
-                self.cnc_control.synchro_points(tool_paths, nodes)
-        except Exception as e:
-            log_route = getattr(e, "log_route", None)
-            if log_route:
-                try:
-                    from ncplot7py.domain.i18n import MessageCatalog
-
-                    catalog = MessageCatalog()
-                    for node in log_route:
-                        msg = catalog.format_exception(node)
-                        print_error(msg)
-                except Exception:
-                    print_error(f"Synchronization error: {e}")
-            else:
-                print_error(f"Synchronization error: {e}")
-            error = True
-
-        # Build plots if no error
-        if not error:
-            lines_list: List[Dict] = []
-            runtime = 0.0
-            canal_index = 0
-            for tool_path in tool_paths:
-                lines: List[Dict] = []
-                linesExec: List[int] = []
-                for line in tool_path:
-                    # each line expected to be (points_list, t)
-                    try:
-                        l, t = line
-                    except Exception:
-                        # unknown format, skip
-                        continue
-                    x = []
-                    y = []
-                    z = []
-                    for point in l:
-                        if point is not None:
-                            x.append(getattr(point, "x", None))
-                            y.append(getattr(point, "y", None))
-                            z.append(getattr(point, "z", None))
-                    lines.append({"x": x, "y": y, "z": z, "t": t})
-                    try:
-                        runtime += float(t)
-                    except Exception:
-                        pass
-
-                self.caclulatet_runtime = runtime
-
-                if len(tool_paths) == len(nodes):
-                    for node in nodes[canal_index]:
-                        linesExec.append(getattr(node, "nc_code_line_nr", None))
-
-                canal = {
-                    "plot": lines,
-                    "canalNr": self.cnc_control.get_canal_name(canal_index),
-                    "programExec": linesExec,
-                }
-                canal_index += 1
-                lines_list.append(canal)
-
-            return lines_list
-
-        # On error, preserve prior API return value
-        print_message("Error in NC Code")
-        print_message(get_message_stack())
-        return [[], []]
+"""NC execution engine (renamed from `nc_analyzer`).
+
+Provides `NCExecutionEngine` which is the new name for the orchestrator that
+parses NC programs, delegates execution to an NC control implementation and
+produces toolpath plot data. This keeps the public return values compatible
+with the previous implementation.
+"""
+from __future__ import annotations
+
+import time
+from typing import List, Dict, Optional, Any
+
+from ncplot7py.shared import (
+    configure_logging,
+    print_error,
+    print_message,
+    print_translated_error,
+    get_message_stack,
+    configure_i18n,
+)
+from ncplot7py.shared.registry import registry
+
+
+class NCExecutionEngine:
+    """NC Execution Engine.
+
+    This class preserves the original `get_Syncro_plot` return structure
+    (a list of canal dictionaries, or `[[],[]]` on error) to avoid changing
+    the public API while improving internal structure and naming.
+    """
+
+    def __init__(
+        self,
+        cnc_control: Any,
+    ) -> None:
+        """Initialize the engine.
+
+        Parameters
+        ----------
+        cnc_control:
+            An object implementing the NC control interface (run_nc_code_list,
+            get_tool_path, get_exected_nodes, get_canal_name, get_canal_count,
+            synchro_points).
+        """
+        self.cnc_control = cnc_control
+        self.caclulatet_runtime: float = -1.0
+        # If control offers canal count, use it, otherwise default to 1
+        try:
+            self.count_of_canals = int(self.cnc_control.get_canal_count())
+        except Exception:
+            self.count_of_canals = 1
+
+        # Ensure logging and i18n are configured (caller can reconfigure)
+        configure_logging(console=True, web_buffer=False)
+        configure_i18n()
+
+    def get_cacluated_runtime(self) -> float:
+        return self.caclulatet_runtime
+
+    def _ensure_parser(self):
+        # Ensure a parser is registered (same strategy as cli.bootstrap)
+        if registry.get("parser", "nc_command") is None:
+            try:
+                from ncplot7py.infrastructure.parsers.nc_command_parser import register as _reg_p
+
+                _reg_p(registry)
+            except Exception:
+                # If parser registration fails, let parse attempts raise
+                pass
+
+    def _get_parser(self):
+        self._ensure_parser()
+        parser_cls = registry.get("parser", "nc_command")
+        if parser_cls is None:
+            # try by interface name
+            parser_cls = registry.get("parser", "BaseNCCommandParser")
+        if parser_cls is None:
+            raise RuntimeError("No NC command parser registered")
+        return parser_cls()
+
+    def get_Syncro_plot(self, programs: List[str], synch: bool) -> List[Dict]:
+        """Create the plot for the given NC `programs`.
+
+        Parameters
+        ----------
+        programs: list[str]
+            Each program is a string containing NC commands separated by ';'.
+        synch: bool
+            Whether to attempt synchronization across canals.
+
+        Returns
+        -------
+        list[dict]
+            A list of canal dictionaries in the same shape as the original
+            implementation. On error returns `[[],[]]` to match previous API.
+        """
+        parser = None
+        try:
+            parser = self._get_parser()
+        except Exception as e:
+            print_error(f"Parser setup failed: {e}")
+            return [[], []]
+
+        canal_number = 0
+        tool_paths: List[Any] = []
+        nodes: List[Any] = []
+        error = False
+
+        for program in programs:
+            # Parse program into a list of command nodes
+            node_list = []
+            i = 0
+            try:
+                for raw_line in [p for p in program.split(";") if p.strip()]:
+                    node = parser.parse(raw_line, i)
+                    node_list.append(node)
+                    i += 1
+
+                # Delegate execution to control; many controls accept an iterable
+                # of nodes. Keep canal numbering consistent with callers (+1).
+                self.cnc_control.run_nc_code_list(node_list, canal_number + 1)
+            except Exception as exc:
+                # Try to handle known control exception style (has log_route)
+                log_route = getattr(exc, "log_route", None)
+                if log_route:
+                    # Try to format exception nodes using MessageCatalog when available
+                    try:
+                        from ncplot7py.domain.i18n import MessageCatalog
+
+                        catalog = MessageCatalog()
+                        for node in log_route:
+                            msg = catalog.format_exception(node)
+                            print_error(msg)
+                    except Exception:
+                        print_error(f"NC PARSER/CONTROL ERROR AT LINE {i+1}: {exc}")
+                else:
+                    # generic parser/control error
+                    print_error(f"NC PARSER/CONTROL ERROR AT LINE {i+1}: {exc}")
+                error = True
+                break
+
+            # Try to collect results for this canal
+            try:
+                tool_paths.append(self.cnc_control.get_tool_path(canal_number + 1))
+                nodes.append(self.cnc_control.get_exected_nodes(canal_number + 1))
+            except Exception as exc:
+                print_error(f"Error creating tool path: {exc}")
+                error = True
+                break
+
+            canal_number += 1
+
+        # Synchronize across canals if requested
+        try:
+            if not error and self.count_of_canals > 1 and synch:
+                self.cnc_control.synchro_points(tool_paths, nodes)
+        except Exception as e:
+            log_route = getattr(e, "log_route", None)
+            if log_route:
+                try:
+                    from ncplot7py.domain.i18n import MessageCatalog
+
+                    catalog = MessageCatalog()
+                    for node in log_route:
+                        msg = catalog.format_exception(node)
+                        print_error(msg)
+                except Exception:
+                    print_error(f"Synchronization error: {e}")
+            else:
+                print_error(f"Synchronization error: {e}")
+            error = True
+
+        # Build plots if no error
+        if not error:
+            lines_list: List[Dict] = []
+            runtime = 0.0
+            canal_index = 0
+            for tool_path in tool_paths:
+                lines: List[Dict] = []
+                linesExec: List[int] = []
+                for line in tool_path:
+                    # each line expected to be (points_list, t)
+                    try:
+                        l, t = line
+                    except Exception:
+                        # unknown format, skip
+                        continue
+                    x = []
+                    y = []
+                    z = []
+                    for point in l:
+                        if point is not None:
+                            x.append(getattr(point, "x", None))
+                            y.append(getattr(point, "y", None))
+                            z.append(getattr(point, "z", None))
+                    lines.append({"x": x, "y": y, "z": z, "t": t})
+                    try:
+                        runtime += float(t)
+                    except Exception:
+                        pass
+
+                self.caclulatet_runtime = runtime
+
+                if len(tool_paths) == len(nodes):
+                    for node in nodes[canal_index]:
+                        linesExec.append(getattr(node, "nc_code_line_nr", None))
+
+                canal = {
+                    "plot": lines,
+                    "canalNr": self.cnc_control.get_canal_name(canal_index),
+                    "programExec": linesExec,
+                }
+                canal_index += 1
+                lines_list.append(canal)
+
+            return lines_list
+
+        # On error, preserve prior API return value
+        print_message("Error in NC Code")
+        print_message(get_message_stack())
+        return [[], []]
diff --git a/src/ncplot7py/cli/__pycache__/__init__.cpython-313.pyc b/src/ncplot7py/cli/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000..a3e2457
Binary files /dev/null and b/src/ncplot7py/cli/__pycache__/__init__.cpython-313.pyc differ
diff --git a/src/ncplot7py/cli/__pycache__/main.cpython-313.pyc b/src/ncplot7py/cli/__pycache__/main.cpython-313.pyc
new file mode 100644
index 0000000..f3e8719
Binary files /dev/null and b/src/ncplot7py/cli/__pycache__/main.cpython-313.pyc differ
diff --git a/src/ncplot7py/cli/main.py b/src/ncplot7py/cli/main.py
index e14bb45..aa62abe 100644
--- a/src/ncplot7py/cli/main.py
+++ b/src/ncplot7py/cli/main.py
@@ -1,39 +1,39 @@
-"""CLI bootstrap helpers.
-
-Provide a small `bootstrap()` function that registers builtin adapters
-into the shared `registry`. This keeps import-time side-effects out of
-module import and makes tests deterministic.
-"""
-from __future__ import annotations
-
-from typing import Optional
-
-from ncplot7py.shared.registry import registry
-
-
-def bootstrap(reg: Optional[object] = None) -> None:
-	"""Register built-in adapters (idempotent).
-
-	Parameters:
-		reg: Optional registry object; if omitted the shared `registry` is used.
-	"""
-	reg = reg or registry
-
-	# Avoid repeated registration
-	if reg.get("parser", "nc_command") is None:
-		try:
-			from ncplot7py.infrastructure.parsers.nc_command_parser import register as _reg_p
-
-			_reg_p(reg)
-		except Exception:
-			# Keep bootstrap safe even if optional adapters fail
-			pass
-
-
-def main() -> None:  # pragma: no cover - CLI entrypoint
-	bootstrap()
-
-
-if __name__ == "__main__":
-	main()
-
+"""CLI bootstrap helpers.
+
+Provide a small `bootstrap()` function that registers builtin adapters
+into the shared `registry`. This keeps import-time side-effects out of
+module import and makes tests deterministic.
+"""
+from __future__ import annotations
+
+from typing import Optional
+
+from ncplot7py.shared.registry import registry
+
+
+def bootstrap(reg: Optional[object] = None) -> None:
+	"""Register built-in adapters (idempotent).
+
+	Parameters:
+		reg: Optional registry object; if omitted the shared `registry` is used.
+	"""
+	reg = reg or registry
+
+	# Avoid repeated registration
+	if reg.get("parser", "nc_command") is None:
+		try:
+			from ncplot7py.infrastructure.parsers.nc_command_parser import register as _reg_p
+
+			_reg_p(reg)
+		except Exception:
+			# Keep bootstrap safe even if optional adapters fail
+			pass
+
+
+def main() -> None:  # pragma: no cover - CLI entrypoint
+	bootstrap()
+
+
+if __name__ == "__main__":
+	main()
+
diff --git a/src/ncplot7py/domain/__pycache__/cnc_state.cpython-313.pyc b/src/ncplot7py/domain/__pycache__/cnc_state.cpython-313.pyc
new file mode 100644
index 0000000..c3d7ce0
Binary files /dev/null and b/src/ncplot7py/domain/__pycache__/cnc_state.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/__pycache__/exceptions.cpython-313.pyc b/src/ncplot7py/domain/__pycache__/exceptions.cpython-313.pyc
new file mode 100644
index 0000000..5c6f770
Binary files /dev/null and b/src/ncplot7py/domain/__pycache__/exceptions.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/__pycache__/exec_chain.cpython-313.pyc b/src/ncplot7py/domain/__pycache__/exec_chain.cpython-313.pyc
new file mode 100644
index 0000000..2ea0716
Binary files /dev/null and b/src/ncplot7py/domain/__pycache__/exec_chain.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/__pycache__/i18n.cpython-313.pyc b/src/ncplot7py/domain/__pycache__/i18n.cpython-313.pyc
new file mode 100644
index 0000000..a0cdb86
Binary files /dev/null and b/src/ncplot7py/domain/__pycache__/i18n.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/__pycache__/models.cpython-313.pyc b/src/ncplot7py/domain/__pycache__/models.cpython-313.pyc
new file mode 100644
index 0000000..c08f3d8
Binary files /dev/null and b/src/ncplot7py/domain/__pycache__/models.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/__pycache__/nc_nodes.cpython-313.pyc b/src/ncplot7py/domain/__pycache__/nc_nodes.cpython-313.pyc
new file mode 100644
index 0000000..9958f02
Binary files /dev/null and b/src/ncplot7py/domain/__pycache__/nc_nodes.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/cnc_state.py b/src/ncplot7py/domain/cnc_state.py
index 9a83f9b..cbe112a 100644
--- a/src/ncplot7py/domain/cnc_state.py
+++ b/src/ncplot7py/domain/cnc_state.py
@@ -1,195 +1,195 @@
-"""CNCState model moved into domain package.
-
-Same content as the previous `shared.cnc_state` but placed under domain to
-reflect that this is core domain model logic.
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass, field, asdict
-from copy import deepcopy
-from typing import Dict, List, Optional, Tuple
-
-
-AxisName = str
-Numeric = float
-
-
-@dataclass
-class CNCState:
-    """Represents the machine state during NC interpretation.
-
-    Key pieces of data:
-    - modal_groups: mapping of modal group name -> active code (e.g. 'G0', 'G1')
-    - axes: mapping axis name -> current coordinate (e.g. 'X': 0.0)
-    - offsets: tool/cs offsets applied to axes (same shape as `axes`)
-    - feed_rate: current feed value (units depend on `units` modal)
-    - spindle_speed: current spindle speed
-    - tool_radius: numeric tool radius (for compensation)
-    - parameters: generic user/parameter variables (#-style) stored as dict
-    - extra: place to store vendor-specific flags (e.g., polar mode axis name)
-
-    Methods on the state are intentionally small and side-effecting; callers
-    should control transactional behaviour (clone/restore) when needed.
-    """
-
-    # Modal groups — keys are group identifiers (string), values the active code
-    modal_groups: Dict[str, Optional[str]] = field(default_factory=dict)
-
-    # Axis positions — use dict to support arbitrary axis sets (X,Y,Z,A,B,C...)
-    axes: Dict[AxisName, Numeric] = field(default_factory=lambda: {"X": 0.0, "Y": 0.0, "Z": 0.0})
-
-    # Offset axes (tool length, coordinate system offsets, etc.)
-    offsets: Dict[AxisName, Numeric] = field(default_factory=dict)
-
-    # Multipliers and override feeds per axis (e.g., for scaling or axis-specific feed)
-    axis_multipliers: Dict[AxisName, Numeric] = field(default_factory=dict)
-    axis_override_feeds: Dict[AxisName, Numeric] = field(default_factory=dict)
-
-    # Per-axis unit interpretation: 'radius' or 'diameter'. Internally we
-    # prefer to work in radius (true distances). When an axis is marked as
-    # 'diameter' incoming values on that axis should be divided by 2.
-    axis_units: Dict[AxisName, str] = field(default_factory=lambda: {"X": "radius", "Y": "radius", "Z": "radius"})
-
-    # Motion & tooling fields
-    feed_rate: Optional[Numeric] = None
-    spindle_speed: Optional[Numeric] = None
-    tool_radius: Optional[Numeric] = None
-    tool_quadrant: Optional[int] = None
-
-    # Program parameters / variables (#500 style) and DDDP table if present
-    parameters: Dict[str, Numeric] = field(default_factory=dict)
-    dddp_set: Dict[str, Numeric] = field(default_factory=dict)
-
-    # Misc
-    line_number: int = 0
-    loop_command: List[str] = field(default_factory=list)
-    extra: Dict[str, object] = field(default_factory=dict)
-
-    def clone(self) -> "CNCState":
-        """Return a deep copy of the state for transactional updates."""
-        return deepcopy(self)
-
-    def as_dict(self) -> Dict:
-        """Serialize to a plain dict (helpful for debugging/tests)."""
-        return asdict(self)
-
-    # --- axis helpers -------------------------------------------------
-    def get_axis(self, name: AxisName) -> Numeric:
-        return self.axes.get(name, 0.0)
-
-    def set_axis(self, name: AxisName, value: Numeric) -> None:
-        self.axes[name] = float(value)
-
-    def update_axes(self, updates: Dict[AxisName, Numeric]) -> None:
-        for k, v in updates.items():
-            self.set_axis(k, float(v))
-
-    # --- axis unit helpers ------------------------------------------
-    def get_axis_unit(self, name: AxisName) -> str:
-        """Return the unit interpretation for an axis: 'radius' or 'diameter'."""
-        return str(self.axis_units.get(name, "radius"))
-
-    def set_axis_unit(self, name: AxisName, unit: str) -> None:
-        """Set the unit interpretation for an axis. Accepts 'radius' or 'diameter'."""
-        self.axis_units[name] = str(unit)
-
-    def is_axis_diameter(self, name: AxisName) -> bool:
-        return self.get_axis_unit(name).lower() == "diameter"
-
-    def normalize_axis_value(self, name: AxisName, value: Numeric) -> Numeric:
-        """Normalize a numeric value for the given axis to internal units (radius).
-
-        If the axis is marked as 'diameter' this divides the value by 2. Preserves
-        sign and numeric type.
-        """
-        try:
-            v = float(value)
-        except Exception:
-            return 0.0
-        return v / 2.0 if self.is_axis_diameter(name) else v
-
-    def normalize_target_spec(self, target_spec: Dict[AxisName, Numeric]) -> Dict[AxisName, Numeric]:
-        """Return a new target spec with per-axis normalization applied.
-
-        This does not mutate the original dict.
-        """
-        return {ax: self.normalize_axis_value(ax, val) for ax, val in target_spec.items()}
-
-    def normalize_arc_params(self, params: Dict[str, Numeric]) -> Dict[str, Numeric]:
-        """Normalize common arc parameters (I,J,K,R) into internal units.
-
-        - I -> X offset, J -> Y offset, K -> Z offset
-        - R is treated as a radial distance: if either X or Y is set to
-          'diameter' we assume R was provided in diameter units and divide by 2.
-          This is a reasonable heuristic for XY-plane arcs on lathes.
-        """
-        p = dict(params)
-        if "I" in p:
-            p["I"] = float(self.normalize_axis_value("X", p.get("I", 0.0)))
-        if "J" in p:
-            p["J"] = float(self.normalize_axis_value("Y", p.get("J", 0.0)))
-        if "K" in p:
-            p["K"] = float(self.normalize_axis_value("Z", p.get("K", 0.0)))
-        if "R" in p:
-            # Treat R as a true radial distance. Do not alter R based on
-            # per-axis 'diameter' interpretation — R is a geometric radius
-            # and should match the units of the provided coordinates.
-            p["R"] = float(p.get("R", 0.0))
-        return p
-
-    def apply_offsets(self) -> Dict[AxisName, Numeric]:
-        """Return axes with offsets applied (doesn't mutate state)."""
-        result = {}
-        for ax, pos in self.axes.items():
-            off = self.offsets.get(ax, 0.0)
-            result[ax] = pos + off
-        return result
-
-    # --- modal helpers -----------------------------------------------
-    def set_modal(self, group: str, code: Optional[str]) -> None:
-        """Set the active code for a modal group."""
-        self.modal_groups[group] = code
-
-    def get_modal(self, group: str) -> Optional[str]:
-        return self.modal_groups.get(group)
-
-    # --- parameter helpers -------------------------------------------
-    def set_parameter(self, name: str, value: Numeric) -> None:
-        self.parameters[name] = float(value)
-
-    def get_parameter(self, name: str, default: Optional[Numeric] = None) -> Optional[Numeric]:
-        return self.parameters.get(name, default)
-
-    # --- coordinate resolution ---------------------------------------
-    def resolve_target(self, target_spec: Dict[AxisName, Numeric], absolute: bool = True) -> Dict[AxisName, Numeric]:
-        """Given a target spec (possibly partial), return resolved absolute coords.
-
-        If `absolute` is False, the values in `target_spec` are treated as deltas
-        and applied to the current axis positions.
-        """
-        resolved: Dict[AxisName, Numeric] = {}
-        if absolute:
-            # start with current axes, then update with provided values
-            for ax in set(list(self.axes.keys()) + list(target_spec.keys())):
-                if ax in target_spec:
-                    resolved[ax] = float(target_spec[ax])
-                else:
-                    resolved[ax] = self.get_axis(ax)
-        else:
-            for ax in set(list(self.axes.keys()) + list(target_spec.keys())):
-                delta = float(target_spec.get(ax, 0.0))
-                resolved[ax] = self.get_axis(ax) + delta
-        return resolved
-
-    # --- small utility ------------------------------------------------
-    def compute_distance(self, a: Dict[AxisName, Numeric], b: Dict[AxisName, Numeric], axes: Optional[List[AxisName]] = None) -> float:
-        """Euclidean distance between two axis positions using given axes list."""
-        if axes is None:
-            axes = list(set(list(a.keys()) + list(b.keys())))
-        s = 0.0
-        for ax in axes:
-            s += (a.get(ax, 0.0) - b.get(ax, 0.0)) ** 2
-        return float(s ** 0.5)
-
-
-__all__ = ["CNCState"]
+"""CNCState model moved into domain package.
+
+Same content as the previous `shared.cnc_state` but placed under domain to
+reflect that this is core domain model logic.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass, field, asdict
+from copy import deepcopy
+from typing import Dict, List, Optional, Tuple
+
+
+AxisName = str
+Numeric = float
+
+
+@dataclass
+class CNCState:
+    """Represents the machine state during NC interpretation.
+
+    Key pieces of data:
+    - modal_groups: mapping of modal group name -> active code (e.g. 'G0', 'G1')
+    - axes: mapping axis name -> current coordinate (e.g. 'X': 0.0)
+    - offsets: tool/cs offsets applied to axes (same shape as `axes`)
+    - feed_rate: current feed value (units depend on `units` modal)
+    - spindle_speed: current spindle speed
+    - tool_radius: numeric tool radius (for compensation)
+    - parameters: generic user/parameter variables (#-style) stored as dict
+    - extra: place to store vendor-specific flags (e.g., polar mode axis name)
+
+    Methods on the state are intentionally small and side-effecting; callers
+    should control transactional behaviour (clone/restore) when needed.
+    """
+
+    # Modal groups — keys are group identifiers (string), values the active code
+    modal_groups: Dict[str, Optional[str]] = field(default_factory=dict)
+
+    # Axis positions — use dict to support arbitrary axis sets (X,Y,Z,A,B,C...)
+    axes: Dict[AxisName, Numeric] = field(default_factory=lambda: {"X": 0.0, "Y": 0.0, "Z": 0.0})
+
+    # Offset axes (tool length, coordinate system offsets, etc.)
+    offsets: Dict[AxisName, Numeric] = field(default_factory=dict)
+
+    # Multipliers and override feeds per axis (e.g., for scaling or axis-specific feed)
+    axis_multipliers: Dict[AxisName, Numeric] = field(default_factory=dict)
+    axis_override_feeds: Dict[AxisName, Numeric] = field(default_factory=dict)
+
+    # Per-axis unit interpretation: 'radius' or 'diameter'. Internally we
+    # prefer to work in radius (true distances). When an axis is marked as
+    # 'diameter' incoming values on that axis should be divided by 2.
+    axis_units: Dict[AxisName, str] = field(default_factory=lambda: {"X": "radius", "Y": "radius", "Z": "radius"})
+
+    # Motion & tooling fields
+    feed_rate: Optional[Numeric] = None
+    spindle_speed: Optional[Numeric] = None
+    tool_radius: Optional[Numeric] = None
+    tool_quadrant: Optional[int] = None
+
+    # Program parameters / variables (#500 style) and DDDP table if present
+    parameters: Dict[str, Numeric] = field(default_factory=dict)
+    dddp_set: Dict[str, Numeric] = field(default_factory=dict)
+
+    # Misc
+    line_number: int = 0
+    loop_command: List[str] = field(default_factory=list)
+    extra: Dict[str, object] = field(default_factory=dict)
+
+    def clone(self) -> "CNCState":
+        """Return a deep copy of the state for transactional updates."""
+        return deepcopy(self)
+
+    def as_dict(self) -> Dict:
+        """Serialize to a plain dict (helpful for debugging/tests)."""
+        return asdict(self)
+
+    # --- axis helpers -------------------------------------------------
+    def get_axis(self, name: AxisName) -> Numeric:
+        return self.axes.get(name, 0.0)
+
+    def set_axis(self, name: AxisName, value: Numeric) -> None:
+        self.axes[name] = float(value)
+
+    def update_axes(self, updates: Dict[AxisName, Numeric]) -> None:
+        for k, v in updates.items():
+            self.set_axis(k, float(v))
+
+    # --- axis unit helpers ------------------------------------------
+    def get_axis_unit(self, name: AxisName) -> str:
+        """Return the unit interpretation for an axis: 'radius' or 'diameter'."""
+        return str(self.axis_units.get(name, "radius"))
+
+    def set_axis_unit(self, name: AxisName, unit: str) -> None:
+        """Set the unit interpretation for an axis. Accepts 'radius' or 'diameter'."""
+        self.axis_units[name] = str(unit)
+
+    def is_axis_diameter(self, name: AxisName) -> bool:
+        return self.get_axis_unit(name).lower() == "diameter"
+
+    def normalize_axis_value(self, name: AxisName, value: Numeric) -> Numeric:
+        """Normalize a numeric value for the given axis to internal units (radius).
+
+        If the axis is marked as 'diameter' this divides the value by 2. Preserves
+        sign and numeric type.
+        """
+        try:
+            v = float(value)
+        except Exception:
+            return 0.0
+        return v / 2.0 if self.is_axis_diameter(name) else v
+
+    def normalize_target_spec(self, target_spec: Dict[AxisName, Numeric]) -> Dict[AxisName, Numeric]:
+        """Return a new target spec with per-axis normalization applied.
+
+        This does not mutate the original dict.
+        """
+        return {ax: self.normalize_axis_value(ax, val) for ax, val in target_spec.items()}
+
+    def normalize_arc_params(self, params: Dict[str, Numeric]) -> Dict[str, Numeric]:
+        """Normalize common arc parameters (I,J,K,R) into internal units.
+
+        - I -> X offset, J -> Y offset, K -> Z offset
+        - R is treated as a radial distance: if either X or Y is set to
+          'diameter' we assume R was provided in diameter units and divide by 2.
+          This is a reasonable heuristic for XY-plane arcs on lathes.
+        """
+        p = dict(params)
+        if "I" in p:
+            p["I"] = float(self.normalize_axis_value("X", p.get("I", 0.0)))
+        if "J" in p:
+            p["J"] = float(self.normalize_axis_value("Y", p.get("J", 0.0)))
+        if "K" in p:
+            p["K"] = float(self.normalize_axis_value("Z", p.get("K", 0.0)))
+        if "R" in p:
+            # Treat R as a true radial distance. Do not alter R based on
+            # per-axis 'diameter' interpretation — R is a geometric radius
+            # and should match the units of the provided coordinates.
+            p["R"] = float(p.get("R", 0.0))
+        return p
+
+    def apply_offsets(self) -> Dict[AxisName, Numeric]:
+        """Return axes with offsets applied (doesn't mutate state)."""
+        result = {}
+        for ax, pos in self.axes.items():
+            off = self.offsets.get(ax, 0.0)
+            result[ax] = pos + off
+        return result
+
+    # --- modal helpers -----------------------------------------------
+    def set_modal(self, group: str, code: Optional[str]) -> None:
+        """Set the active code for a modal group."""
+        self.modal_groups[group] = code
+
+    def get_modal(self, group: str) -> Optional[str]:
+        return self.modal_groups.get(group)
+
+    # --- parameter helpers -------------------------------------------
+    def set_parameter(self, name: str, value: Numeric) -> None:
+        self.parameters[name] = float(value)
+
+    def get_parameter(self, name: str, default: Optional[Numeric] = None) -> Optional[Numeric]:
+        return self.parameters.get(name, default)
+
+    # --- coordinate resolution ---------------------------------------
+    def resolve_target(self, target_spec: Dict[AxisName, Numeric], absolute: bool = True) -> Dict[AxisName, Numeric]:
+        """Given a target spec (possibly partial), return resolved absolute coords.
+
+        If `absolute` is False, the values in `target_spec` are treated as deltas
+        and applied to the current axis positions.
+        """
+        resolved: Dict[AxisName, Numeric] = {}
+        if absolute:
+            # start with current axes, then update with provided values
+            for ax in set(list(self.axes.keys()) + list(target_spec.keys())):
+                if ax in target_spec:
+                    resolved[ax] = float(target_spec[ax])
+                else:
+                    resolved[ax] = self.get_axis(ax)
+        else:
+            for ax in set(list(self.axes.keys()) + list(target_spec.keys())):
+                delta = float(target_spec.get(ax, 0.0))
+                resolved[ax] = self.get_axis(ax) + delta
+        return resolved
+
+    # --- small utility ------------------------------------------------
+    def compute_distance(self, a: Dict[AxisName, Numeric], b: Dict[AxisName, Numeric], axes: Optional[List[AxisName]] = None) -> float:
+        """Euclidean distance between two axis positions using given axes list."""
+        if axes is None:
+            axes = list(set(list(a.keys()) + list(b.keys())))
+        s = 0.0
+        for ax in axes:
+            s += (a.get(ax, 0.0) - b.get(ax, 0.0)) ** 2
+        return float(s ** 0.5)
+
+
+__all__ = ["CNCState"]
diff --git a/src/ncplot7py/domain/exceptions.py b/src/ncplot7py/domain/exceptions.py
index 3fa7fd3..288910c 100644
--- a/src/ncplot7py/domain/exceptions.py
+++ b/src/ncplot7py/domain/exceptions.py
@@ -1,139 +1,139 @@
-"""Domain-specific exceptions.
-
-This module provides a small, typed exception class suitable for tracing
-errors originating from CNC/NC code parsing and handling. The class is
-lightweight, serializable and has a pleasant string representation for
-consumers (CLI/IDE/web) so we can present clean error messages to users.
-"""
-
-from __future__ import annotations
-
-from enum import IntEnum
-from dataclasses import dataclass, asdict
-from typing import Any
-
-
-class ExceptionTyps(IntEnum):
-	"""Types of domain exceptions.
-
-	Values are small ints to make serialization compact where necessary.
-	"""
-
-	NCCodeErrors = 1
-	NCCanalStarErrors = 2
-	CNCError = 3
-
-
-@dataclass
-class ExceptionNode(Exception):
-	"""A structured exception carrying CNC error information.
-
-	Fields:
-	  typ: Which category of error (ExceptionTyps).
-	  code: Numeric error code (domain-specific).
-	  line: Source line number where the error occurred (1-based), 0 if unknown.
-	  message: Human readable message describing the error.
-	  value: Optional value/context (e.g. offending token or text).
-
-	The class inherits from Exception so it can be raised. It also provides
-	`to_dict()` and a friendly `__str__()` for user-facing output.
-	"""
-
-	typ: ExceptionTyps
-	code: int = 0
-	line: int = 0
-	message: str = ""
-	value: Any = ""
-	# Traceback-ish metadata for better diagnostics
-	file: str = ""
-	column: int = 0
-	context: str = ""
-
-	def __post_init__(self) -> None:
-		# Ensure base Exception gets the message so built-in tooling sees it.
-		Exception.__init__(self, self.message)
-
-	def to_dict(self) -> dict:
-		"""Return a plain-serializable representation of the exception."""
-		data = asdict(self)
-		# Represent enum as its name (and maybe value) for consumers.
-		data["typ"] = {"name": self.typ.name, "value": int(self.typ)}
-		return data
-
-	def __str__(self) -> str:  # pragma: no cover - simple formatting
-		parts = [f"{self.typ.name} (code={self.code})"]
-		if self.line:
-			parts.append(f"line={self.line}")
-		if self.message:
-			parts.append(f"message={self.message}")
-		if self.value not in ("", None):
-			parts.append(f"value={self.value}")
-		if self.file:
-			parts.append(f"file={self.file}")
-		if self.column:
-			parts.append(f"col={self.column}")
-		return "; ".join(parts)
-
-	def localized(self, lang: str = "en") -> str:
-		"""Return a localized message if a catalog is available.
-
-		This avoids importing i18n at module import time to keep domain slim.
-		"""
-		try:
-			from .i18n import MessageCatalog
-
-			catalog = MessageCatalog()
-			return catalog.format_exception(self, lang=lang, include_trace=True)
-		except Exception:
-			return str(self)
-
-
-def raise_nc_error(
-	typ: ExceptionTyps,
-	code: int,
-	*,
-	message: str = "",
-	value: Any = "",
-	file: str = "",
-	line: int = 0,
-	column: int = 0,
-	source_line: str = "",
-) -> None:
-	"""Raise an ExceptionNode with best-effort column/context extraction.
-
-	Parameters:
-		typ: Exception type (ExceptionTyps)
-		code: Numeric error code
-		message: Human readable fallback message if i18n template not found
-		value: Offending value/token
-		file: Source file name/path
-		line: 1-based line number
-		column: 1-based column number; if 0 and source_line+value are provided,
-				column will be inferred from the first match of value within
-				source_line.
-		source_line: The full line text to include as context (optional)
-	"""
-
-	inferred_col = column
-	ctx = source_line
-	if (not inferred_col) and value and source_line:
-		try:
-			idx = source_line.find(str(value))
-			if idx >= 0:
-				inferred_col = idx + 1  # 1-based
-		except Exception:
-			inferred_col = column or 0
-
-	exc = ExceptionNode(
-		typ=typ,
-		code=code,
-		line=line,
-		message=message,
-		value=value,
-		file=file,
-		column=inferred_col or column,
-		context=ctx,
-	)
-	raise exc
-
-
+"""Domain-specific exceptions.
+
+This module provides a small, typed exception class suitable for tracing
+errors originating from CNC/NC code parsing and handling. The class is
+lightweight, serializable and has a pleasant string representation for
+consumers (CLI/IDE/web) so we can present clean error messages to users.
+"""
+
+from __future__ import annotations
+
+from enum import IntEnum
+from dataclasses import dataclass, asdict
+from typing import Any
+
+
+class ExceptionTyps(IntEnum):
+	"""Types of domain exceptions.
+
+	Values are small ints to make serialization compact where necessary.
+	"""
+
+	NCCodeErrors = 1
+	NCCanalStarErrors = 2
+	CNCError = 3
+
+
+@dataclass
+class ExceptionNode(Exception):
+	"""A structured exception carrying CNC error information.
+
+	Fields:
+	  typ: Which category of error (ExceptionTyps).
+	  code: Numeric error code (domain-specific).
+	  line: Source line number where the error occurred (1-based), 0 if unknown.
+	  message: Human readable message describing the error.
+	  value: Optional value/context (e.g. offending token or text).
+
+	The class inherits from Exception so it can be raised. It also provides
+	`to_dict()` and a friendly `__str__()` for user-facing output.
+	"""
+
+	typ: ExceptionTyps
+	code: int = 0
+	line: int = 0
+	message: str = ""
+	value: Any = ""
+	# Traceback-ish metadata for better diagnostics
+	file: str = ""
+	column: int = 0
+	context: str = ""
+
+	def __post_init__(self) -> None:
+		# Ensure base Exception gets the message so built-in tooling sees it.
+		Exception.__init__(self, self.message)
+
+	def to_dict(self) -> dict:
+		"""Return a plain-serializable representation of the exception."""
+		data = asdict(self)
+		# Represent enum as its name (and maybe value) for consumers.
+		data["typ"] = {"name": self.typ.name, "value": int(self.typ)}
+		return data
+
+	def __str__(self) -> str:  # pragma: no cover - simple formatting
+		parts = [f"{self.typ.name} (code={self.code})"]
+		if self.line:
+			parts.append(f"line={self.line}")
+		if self.message:
+			parts.append(f"message={self.message}")
+		if self.value not in ("", None):
+			parts.append(f"value={self.value}")
+		if self.file:
+			parts.append(f"file={self.file}")
+		if self.column:
+			parts.append(f"col={self.column}")
+		return "; ".join(parts)
+
+	def localized(self, lang: str = "en") -> str:
+		"""Return a localized message if a catalog is available.
+
+		This avoids importing i18n at module import time to keep domain slim.
+		"""
+		try:
+			from .i18n import MessageCatalog
+
+			catalog = MessageCatalog()
+			return catalog.format_exception(self, lang=lang, include_trace=True)
+		except Exception:
+			return str(self)
+
+
+def raise_nc_error(
+	typ: ExceptionTyps,
+	code: int,
+	*,
+	message: str = "",
+	value: Any = "",
+	file: str = "",
+	line: int = 0,
+	column: int = 0,
+	source_line: str = "",
+) -> None:
+	"""Raise an ExceptionNode with best-effort column/context extraction.
+
+	Parameters:
+		typ: Exception type (ExceptionTyps)
+		code: Numeric error code
+		message: Human readable fallback message if i18n template not found
+		value: Offending value/token
+		file: Source file name/path
+		line: 1-based line number
+		column: 1-based column number; if 0 and source_line+value are provided,
+				column will be inferred from the first match of value within
+				source_line.
+		source_line: The full line text to include as context (optional)
+	"""
+
+	inferred_col = column
+	ctx = source_line
+	if (not inferred_col) and value and source_line:
+		try:
+			idx = source_line.find(str(value))
+			if idx >= 0:
+				inferred_col = idx + 1  # 1-based
+		except Exception:
+			inferred_col = column or 0
+
+	exc = ExceptionNode(
+		typ=typ,
+		code=code,
+		line=line,
+		message=message,
+		value=value,
+		file=file,
+		column=inferred_col or column,
+		context=ctx,
+	)
+	raise exc
+
+
diff --git a/src/ncplot7py/domain/exec_chain.py b/src/ncplot7py/domain/exec_chain.py
index 547b9ce..38b4e57 100644
--- a/src/ncplot7py/domain/exec_chain.py
+++ b/src/ncplot7py/domain/exec_chain.py
@@ -1,32 +1,32 @@
-"""Chain-of-Responsibility base Handler moved to domain.
-
-This module contains the Handler primitive; placing it in `domain` makes it
-the canonical location for execution primitives that operate on domain state.
-"""
-from __future__ import annotations
-
-from typing import Optional, Tuple, List, TYPE_CHECKING, Any
-
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.shared.state_protocol import StateProtocol
-
-if TYPE_CHECKING:
-    CNCStateType = StateProtocol
-else:
-    CNCStateType = Any
-
-
-class Handler:
-    """Base handler with optional next pointer."""
-
-    def __init__(self, next_handler: Optional["Handler"] = None):
-        self.next_handler = next_handler
-
-    def handle(self, node: NCCommandNode, state: CNCStateType) -> Tuple[Optional[List], Optional[float]]:
-        """Handle a node; return (points_list, duration) or delegate."""
-        if self.next_handler is not None:
-            return self.next_handler.handle(node, state)
-        return None, None
-
-
-__all__ = ["Handler"]
+"""Chain-of-Responsibility base Handler moved to domain.
+
+This module contains the Handler primitive; placing it in `domain` makes it
+the canonical location for execution primitives that operate on domain state.
+"""
+from __future__ import annotations
+
+from typing import Optional, Tuple, List, TYPE_CHECKING, Any
+
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.shared.state_protocol import StateProtocol
+
+if TYPE_CHECKING:
+    CNCStateType = StateProtocol
+else:
+    CNCStateType = Any
+
+
+class Handler:
+    """Base handler with optional next pointer."""
+
+    def __init__(self, next_handler: Optional["Handler"] = None):
+        self.next_handler = next_handler
+
+    def handle(self, node: NCCommandNode, state: CNCStateType) -> Tuple[Optional[List], Optional[float]]:
+        """Handle a node; return (points_list, duration) or delegate."""
+        if self.next_handler is not None:
+            return self.next_handler.handle(node, state)
+        return None, None
+
+
+__all__ = ["Handler"]
diff --git a/src/ncplot7py/domain/handlers/__pycache__/control_flow.cpython-313.pyc b/src/ncplot7py/domain/handlers/__pycache__/control_flow.cpython-313.pyc
new file mode 100644
index 0000000..74ba854
Binary files /dev/null and b/src/ncplot7py/domain/handlers/__pycache__/control_flow.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/__pycache__/gcode_group0.cpython-313.pyc b/src/ncplot7py/domain/handlers/__pycache__/gcode_group0.cpython-313.pyc
new file mode 100644
index 0000000..dcdc362
Binary files /dev/null and b/src/ncplot7py/domain/handlers/__pycache__/gcode_group0.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/__pycache__/gcode_group2.cpython-313.pyc b/src/ncplot7py/domain/handlers/__pycache__/gcode_group2.cpython-313.pyc
new file mode 100644
index 0000000..a78a568
Binary files /dev/null and b/src/ncplot7py/domain/handlers/__pycache__/gcode_group2.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/__pycache__/gcode_group5.cpython-313.pyc b/src/ncplot7py/domain/handlers/__pycache__/gcode_group5.cpython-313.pyc
new file mode 100644
index 0000000..1a90769
Binary files /dev/null and b/src/ncplot7py/domain/handlers/__pycache__/gcode_group5.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/__pycache__/modal.cpython-313.pyc b/src/ncplot7py/domain/handlers/__pycache__/modal.cpython-313.pyc
new file mode 100644
index 0000000..79d9ac7
Binary files /dev/null and b/src/ncplot7py/domain/handlers/__pycache__/modal.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/__pycache__/motion.cpython-313.pyc b/src/ncplot7py/domain/handlers/__pycache__/motion.cpython-313.pyc
new file mode 100644
index 0000000..ec202a4
Binary files /dev/null and b/src/ncplot7py/domain/handlers/__pycache__/motion.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/__pycache__/star_turn_handler.cpython-313.pyc b/src/ncplot7py/domain/handlers/__pycache__/star_turn_handler.cpython-313.pyc
new file mode 100644
index 0000000..60643ad
Binary files /dev/null and b/src/ncplot7py/domain/handlers/__pycache__/star_turn_handler.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/__pycache__/variable.cpython-313.pyc b/src/ncplot7py/domain/handlers/__pycache__/variable.cpython-313.pyc
new file mode 100644
index 0000000..2381d8a
Binary files /dev/null and b/src/ncplot7py/domain/handlers/__pycache__/variable.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/control_flow.py b/src/ncplot7py/domain/handlers/control_flow.py
index d2ef2b3..173ee1d 100644
--- a/src/ncplot7py/domain/handlers/control_flow.py
+++ b/src/ncplot7py/domain/handlers/control_flow.py
@@ -1,318 +1,318 @@
-"""Control-flow handler for simple loop constructs in NC programs.
-
-Supports a small subset of constructs found in some controllers:
-- GOTO<pos>
-- IF<cond> ... GOTO<pos>
-- WHILE<cond> DO<pos> / END<pos> (basic skip-if-false behaviour)
-
-This handler manipulates node linked pointers (`_next_ncCode`) so the
-canal execution loop can jump to the desired node. It expects nodes to be
-linked via `_next_ncCode` and `_before_ncCode` beforehand.
-"""
-from __future__ import annotations
-
-import re
-from typing import Optional, Tuple
-import os
-import logging
-
-from ncplot7py.domain.exec_chain import Handler
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.domain.handlers.variable import VariableHandler
-
-
-class ControlFlowHandler(Handler):
-    TOKEN_RE = re.compile(r"(GOTO|THEN|IF|END|DO|WHILE)")
-
-    def __init__(self, next_handler: Optional[Handler] = None):
-        super().__init__(next_handler=next_handler)
-        # use variable handler utilities for expression evaluation
-        self._eval_helper = VariableHandler()
-        # runtime maps (populated by canal before execution)
-        self._n_map = None
-        self._do_map = None
-        self._end_map = None
-        self._nodes = None
-        self._loop_counters = {}
-
-    def _find_node_with_N(self, start: NCCommandNode, pos: str) -> Optional[NCCommandNode]:
-        # Prefer lookup via precomputed map when available
-        try:
-            target = float(pos)
-        except Exception:
-            return None
-
-        if getattr(self, "_n_map", None) is not None:
-            return self._n_map.get(target)
-
-        # fallback: search forward then backward
-        node = start
-        # search forwards
-        while node is not None:
-            try:
-                nval = node.command_parameter.get("N")
-            except Exception:
-                nval = None
-            if nval is not None:
-                try:
-                    if float(nval) == target:
-                        return node
-                except Exception:
-                    pass
-            node = getattr(node, "_next_ncCode", None)
-
-        # search backwards
-        node = start
-        while node is not None:
-            try:
-                nval = node.command_parameter.get("N")
-            except Exception:
-                nval = None
-            if nval is not None:
-                try:
-                    if float(nval) == target:
-                        return node
-                except Exception:
-                    pass
-            node = getattr(node, "_before_ncCode", None)
-
-        return None
-
-    def _find_end_for_do(self, start: NCCommandNode, pos: str) -> Optional[NCCommandNode]:
-        # Prefer map lookup when available
-        if getattr(self, "_end_map", None) is not None:
-            lst = self._end_map.get(pos)
-            if lst:
-                # return first end node after start
-                if self._nodes is not None:
-                    try:
-                        start_idx = self._nodes.index(start)
-                    except ValueError:
-                        start_idx = -1
-                    for n in lst:
-                        try:
-                            idx = self._nodes.index(n)
-                            if idx > start_idx:
-                                return n
-                        except ValueError:
-                            continue
-                return lst[0]
-
-        node = start
-        while node is not None:
-            lc = node.loop_command
-            if lc and f"END{pos}" in lc:
-                return node
-            node = getattr(node, "_next_ncCode", None)
-        return None
-
-    def _is_true(self, cond_text: str, state: CNCState) -> bool:
-        logger = logging.getLogger(__name__)
-        # strip surrounding brackets which may come from parsed tokens
-        try:
-            cond_text = cond_text.strip()
-            if cond_text.startswith("[") and cond_text.endswith("]"):
-                cond_text = cond_text[1:-1]
-        except Exception:
-            pass
-        # detect operators GT, LT, GE, LE, EQ
-        for op in ("GE", "LE", "GT", "LT", "EQ"):
-            if op in cond_text:
-                left, right = cond_text.split(op, 1)
-                try:
-                    lv = self._eval_helper._eval_expression(left, state)
-                    rv = self._eval_helper._eval_expression(right, state)
-                except Exception:
-                    logger.debug("_is_true failed eval for cond=%s left=%s right=%s", cond_text, left, right, exc_info=True)
-                    try:
-                        logger.debug("_is_true state.parameters snapshot: %s", getattr(state, 'parameters', None))
-                    except Exception:
-                        pass
-                    return False
-                if op == "GT":
-                    result = float(lv) > float(rv)
-                    logger.debug("_is_true: %s GT %s -> %s", lv, rv, result)
-                    return result
-                if op == "LT":
-                    result = float(lv) < float(rv)
-                    logger.debug("_is_true: %s LT %s -> %s", lv, rv, result)
-                    return result
-                if op == "GE":
-                    result = float(lv) >= float(rv)
-                    logger.debug("_is_true: %s GE %s -> %s", lv, rv, result)
-                    return result
-                if op == "LE":
-                    result = float(lv) <= float(rv)
-                    logger.debug("_is_true: %s LE %s -> %s", lv, rv, result)
-                    return result
-                if op == "EQ":
-                    result = float(lv) == float(rv)
-                    logger.debug("_is_true: %s EQ %s -> %s", lv, rv, result)
-                    return result
-        return False
-
-    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[list], Optional[float]]:
-        lc = node.loop_command
-        if not lc:
-            return super().handle(node, state)
-
-        # Insert spaces before tokens to help splitting (parser removed spaces)
-        command = re.sub(self.TOKEN_RE, r" \1", lc)
-        tokens = [t for t in command.split(" ") if t]
-
-        # simple scan for IF...GOTO or plain GOTO
-        for token in tokens:
-            if token.startswith("IF"):
-                cond = token[2:]
-                if self._is_true(cond, state):
-                    # find GOTO token in same command
-                    for t2 in tokens:
-                        if t2.startswith("GOTO"):
-                            pos = t2.split("GOTO", 1)[1]
-                            target = self._find_node_with_N(node, pos)
-                            if target is None:
-                                # nothing we can do; fallthrough
-                                break
-                            node._next_ncCode = target
-                            break
-                # whether true or false, stop processing IF
-                break
-            elif token.startswith("GOTO"):
-                pos = token.split("GOTO", 1)[1]
-                # GOTO may reference a DO-label or an N label
-                target = None
-                try:
-                    key = float(pos)
-                except Exception:
-                    key = None
-                if key is not None and getattr(self, "_n_map", None) is not None:
-                    target = self._n_map.get(key)
-                if target is None and getattr(self, "_do_map", None) is not None:
-                    # do_map entries are lists; pick first
-                    lst = self._do_map.get(pos)
-                    if lst:
-                        target = lst[0]
-                if target is None:
-                    target = self._find_node_with_N(node, pos)
-                if target is not None:
-                    node._next_ncCode = target
-                break
-            elif token.startswith("WHILE"):
-                cond = token[5:]
-                # if condition is false, skip forward to matching END
-                if not self._is_true(cond, state):
-                    # find DO token to get pos
-                    for t2 in tokens:
-                        if t2.startswith("DO"):
-                            pos = t2.split("DO", 1)[1]
-                            end_node = self._find_end_for_do(node, pos)
-                            if end_node is not None:
-                                node._next_ncCode = getattr(end_node, "_next_ncCode", None)
-                            break
-                # otherwise, continue into loop (no change)
-                break
-            elif token.startswith("DO"):
-                # DO may be a label or start of a counted loop. If the DO node
-                # provides parameter 'L' we treat it as a loop counter.
-                label = token[2:]
-                # initialize loop counter if present on this node
-                try:
-                    lval = node.command_parameter.get("L")
-                except Exception:
-                    lval = None
-                if lval is not None:
-                    try:
-                        cnt = int(float(self._eval_helper._eval_expression(str(lval), state)))
-                    except Exception:
-                        try:
-                            cnt = int(float(lval))
-                        except Exception:
-                            cnt = None
-                    if cnt is not None:
-                        # store counter by label so END can find it
-                        self._loop_counters[label] = cnt
-                break
-            elif token.startswith("END"):
-                label = token[3:]
-                # find matching DO node (prefer map)
-                do_node = None
-                if getattr(self, "_do_map", None) is not None and label in self._do_map:
-                    # pick the nearest DO before this END
-                    candidates = self._do_map[label]
-                    if self._nodes is not None:
-                        try:
-                            end_idx = self._nodes.index(node)
-                        except ValueError:
-                            end_idx = -1
-                        best = None
-                        best_idx = -1
-                        for n in candidates:
-                            try:
-                                idx = self._nodes.index(n)
-                                if idx < end_idx and idx > best_idx:
-                                    best = n
-                                    best_idx = idx
-                            except ValueError:
-                                continue
-                        do_node = best or (candidates[0] if candidates else None)
-                    else:
-                        do_node = candidates[0] if candidates else None
-                else:
-                    # fallback: search backward for a DO with same label
-                    cur = getattr(node, "_before_ncCode", None)
-                    while cur is not None:
-                        lc = cur.loop_command
-                        if lc and f"DO{label}" in lc:
-                            do_node = cur
-                            break
-                        cur = getattr(cur, "_before_ncCode", None)
-
-                if do_node is not None:
-                    # if there's a loop counter for this label, decrement and jump
-                    cnt = self._loop_counters.get(label)
-                    if cnt is not None:
-                        if cnt > 1:
-                            self._loop_counters[label] = cnt - 1
-                            node._next_ncCode = getattr(do_node, "_next_ncCode", do_node)
-                        else:
-                            # completed loop
-                            del self._loop_counters[label]
-                    else:
-                        # If this DO was actually a WHILE (e.g. "WHILE[...]DO<label>"),
-                        # re-evaluate the condition here and jump back to the DO body
-                        # if the condition still holds.
-                        try:
-                            lc = do_node.loop_command
-                        except Exception:
-                            lc = None
-                        if lc and "WHILE" in lc:
-                            # extract WHILE token and condition similar to above
-                            command2 = re.sub(self.TOKEN_RE, r" \1", lc)
-                            tokens2 = [t for t in command2.split(" ") if t]
-                            for t3 in tokens2:
-                                if t3.startswith("WHILE"):
-                                    cond_text = t3[5:]
-                                    try:
-                                        if self._is_true(cond_text, state):
-                                            # condition still true -> jump back into loop body
-                                            node._next_ncCode = getattr(do_node, "_next_ncCode", do_node)
-                                        else:
-                                            # condition false -> ensure END falls through to next node
-                                            if self._nodes is not None:
-                                                try:
-                                                    end_idx = self._nodes.index(node)
-                                                    node._next_ncCode = self._nodes[end_idx + 1] if end_idx + 1 < len(self._nodes) else None
-                                                except Exception:
-                                                    # fallback: leave pointer as-is
-                                                    pass
-                                    except Exception:
-                                        # on error, fall through
-                                        pass
-                                    break
-                break
-
-        return super().handle(node, state)
-
-
-__all__ = ["ControlFlowHandler"]
+"""Control-flow handler for simple loop constructs in NC programs.
+
+Supports a small subset of constructs found in some controllers:
+- GOTO<pos>
+- IF<cond> ... GOTO<pos>
+- WHILE<cond> DO<pos> / END<pos> (basic skip-if-false behaviour)
+
+This handler manipulates node linked pointers (`_next_ncCode`) so the
+canal execution loop can jump to the desired node. It expects nodes to be
+linked via `_next_ncCode` and `_before_ncCode` beforehand.
+"""
+from __future__ import annotations
+
+import re
+from typing import Optional, Tuple
+import os
+import logging
+
+from ncplot7py.domain.exec_chain import Handler
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.domain.handlers.variable import VariableHandler
+
+
+class ControlFlowHandler(Handler):
+    TOKEN_RE = re.compile(r"(GOTO|THEN|IF|END|DO|WHILE)")
+
+    def __init__(self, next_handler: Optional[Handler] = None):
+        super().__init__(next_handler=next_handler)
+        # use variable handler utilities for expression evaluation
+        self._eval_helper = VariableHandler()
+        # runtime maps (populated by canal before execution)
+        self._n_map = None
+        self._do_map = None
+        self._end_map = None
+        self._nodes = None
+        self._loop_counters = {}
+
+    def _find_node_with_N(self, start: NCCommandNode, pos: str) -> Optional[NCCommandNode]:
+        # Prefer lookup via precomputed map when available
+        try:
+            target = float(pos)
+        except Exception:
+            return None
+
+        if getattr(self, "_n_map", None) is not None:
+            return self._n_map.get(target)
+
+        # fallback: search forward then backward
+        node = start
+        # search forwards
+        while node is not None:
+            try:
+                nval = node.command_parameter.get("N")
+            except Exception:
+                nval = None
+            if nval is not None:
+                try:
+                    if float(nval) == target:
+                        return node
+                except Exception:
+                    pass
+            node = getattr(node, "_next_ncCode", None)
+
+        # search backwards
+        node = start
+        while node is not None:
+            try:
+                nval = node.command_parameter.get("N")
+            except Exception:
+                nval = None
+            if nval is not None:
+                try:
+                    if float(nval) == target:
+                        return node
+                except Exception:
+                    pass
+            node = getattr(node, "_before_ncCode", None)
+
+        return None
+
+    def _find_end_for_do(self, start: NCCommandNode, pos: str) -> Optional[NCCommandNode]:
+        # Prefer map lookup when available
+        if getattr(self, "_end_map", None) is not None:
+            lst = self._end_map.get(pos)
+            if lst:
+                # return first end node after start
+                if self._nodes is not None:
+                    try:
+                        start_idx = self._nodes.index(start)
+                    except ValueError:
+                        start_idx = -1
+                    for n in lst:
+                        try:
+                            idx = self._nodes.index(n)
+                            if idx > start_idx:
+                                return n
+                        except ValueError:
+                            continue
+                return lst[0]
+
+        node = start
+        while node is not None:
+            lc = node.loop_command
+            if lc and f"END{pos}" in lc:
+                return node
+            node = getattr(node, "_next_ncCode", None)
+        return None
+
+    def _is_true(self, cond_text: str, state: CNCState) -> bool:
+        logger = logging.getLogger(__name__)
+        # strip surrounding brackets which may come from parsed tokens
+        try:
+            cond_text = cond_text.strip()
+            if cond_text.startswith("[") and cond_text.endswith("]"):
+                cond_text = cond_text[1:-1]
+        except Exception:
+            pass
+        # detect operators GT, LT, GE, LE, EQ
+        for op in ("GE", "LE", "GT", "LT", "EQ"):
+            if op in cond_text:
+                left, right = cond_text.split(op, 1)
+                try:
+                    lv = self._eval_helper._eval_expression(left, state)
+                    rv = self._eval_helper._eval_expression(right, state)
+                except Exception:
+                    logger.debug("_is_true failed eval for cond=%s left=%s right=%s", cond_text, left, right, exc_info=True)
+                    try:
+                        logger.debug("_is_true state.parameters snapshot: %s", getattr(state, 'parameters', None))
+                    except Exception:
+                        pass
+                    return False
+                if op == "GT":
+                    result = float(lv) > float(rv)
+                    logger.debug("_is_true: %s GT %s -> %s", lv, rv, result)
+                    return result
+                if op == "LT":
+                    result = float(lv) < float(rv)
+                    logger.debug("_is_true: %s LT %s -> %s", lv, rv, result)
+                    return result
+                if op == "GE":
+                    result = float(lv) >= float(rv)
+                    logger.debug("_is_true: %s GE %s -> %s", lv, rv, result)
+                    return result
+                if op == "LE":
+                    result = float(lv) <= float(rv)
+                    logger.debug("_is_true: %s LE %s -> %s", lv, rv, result)
+                    return result
+                if op == "EQ":
+                    result = float(lv) == float(rv)
+                    logger.debug("_is_true: %s EQ %s -> %s", lv, rv, result)
+                    return result
+        return False
+
+    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[list], Optional[float]]:
+        lc = node.loop_command
+        if not lc:
+            return super().handle(node, state)
+
+        # Insert spaces before tokens to help splitting (parser removed spaces)
+        command = re.sub(self.TOKEN_RE, r" \1", lc)
+        tokens = [t for t in command.split(" ") if t]
+
+        # simple scan for IF...GOTO or plain GOTO
+        for token in tokens:
+            if token.startswith("IF"):
+                cond = token[2:]
+                if self._is_true(cond, state):
+                    # find GOTO token in same command
+                    for t2 in tokens:
+                        if t2.startswith("GOTO"):
+                            pos = t2.split("GOTO", 1)[1]
+                            target = self._find_node_with_N(node, pos)
+                            if target is None:
+                                # nothing we can do; fallthrough
+                                break
+                            node._next_ncCode = target
+                            break
+                # whether true or false, stop processing IF
+                break
+            elif token.startswith("GOTO"):
+                pos = token.split("GOTO", 1)[1]
+                # GOTO may reference a DO-label or an N label
+                target = None
+                try:
+                    key = float(pos)
+                except Exception:
+                    key = None
+                if key is not None and getattr(self, "_n_map", None) is not None:
+                    target = self._n_map.get(key)
+                if target is None and getattr(self, "_do_map", None) is not None:
+                    # do_map entries are lists; pick first
+                    lst = self._do_map.get(pos)
+                    if lst:
+                        target = lst[0]
+                if target is None:
+                    target = self._find_node_with_N(node, pos)
+                if target is not None:
+                    node._next_ncCode = target
+                break
+            elif token.startswith("WHILE"):
+                cond = token[5:]
+                # if condition is false, skip forward to matching END
+                if not self._is_true(cond, state):
+                    # find DO token to get pos
+                    for t2 in tokens:
+                        if t2.startswith("DO"):
+                            pos = t2.split("DO", 1)[1]
+                            end_node = self._find_end_for_do(node, pos)
+                            if end_node is not None:
+                                node._next_ncCode = getattr(end_node, "_next_ncCode", None)
+                            break
+                # otherwise, continue into loop (no change)
+                break
+            elif token.startswith("DO"):
+                # DO may be a label or start of a counted loop. If the DO node
+                # provides parameter 'L' we treat it as a loop counter.
+                label = token[2:]
+                # initialize loop counter if present on this node
+                try:
+                    lval = node.command_parameter.get("L")
+                except Exception:
+                    lval = None
+                if lval is not None:
+                    try:
+                        cnt = int(float(self._eval_helper._eval_expression(str(lval), state)))
+                    except Exception:
+                        try:
+                            cnt = int(float(lval))
+                        except Exception:
+                            cnt = None
+                    if cnt is not None:
+                        # store counter by label so END can find it
+                        self._loop_counters[label] = cnt
+                break
+            elif token.startswith("END"):
+                label = token[3:]
+                # find matching DO node (prefer map)
+                do_node = None
+                if getattr(self, "_do_map", None) is not None and label in self._do_map:
+                    # pick the nearest DO before this END
+                    candidates = self._do_map[label]
+                    if self._nodes is not None:
+                        try:
+                            end_idx = self._nodes.index(node)
+                        except ValueError:
+                            end_idx = -1
+                        best = None
+                        best_idx = -1
+                        for n in candidates:
+                            try:
+                                idx = self._nodes.index(n)
+                                if idx < end_idx and idx > best_idx:
+                                    best = n
+                                    best_idx = idx
+                            except ValueError:
+                                continue
+                        do_node = best or (candidates[0] if candidates else None)
+                    else:
+                        do_node = candidates[0] if candidates else None
+                else:
+                    # fallback: search backward for a DO with same label
+                    cur = getattr(node, "_before_ncCode", None)
+                    while cur is not None:
+                        lc = cur.loop_command
+                        if lc and f"DO{label}" in lc:
+                            do_node = cur
+                            break
+                        cur = getattr(cur, "_before_ncCode", None)
+
+                if do_node is not None:
+                    # if there's a loop counter for this label, decrement and jump
+                    cnt = self._loop_counters.get(label)
+                    if cnt is not None:
+                        if cnt > 1:
+                            self._loop_counters[label] = cnt - 1
+                            node._next_ncCode = getattr(do_node, "_next_ncCode", do_node)
+                        else:
+                            # completed loop
+                            del self._loop_counters[label]
+                    else:
+                        # If this DO was actually a WHILE (e.g. "WHILE[...]DO<label>"),
+                        # re-evaluate the condition here and jump back to the DO body
+                        # if the condition still holds.
+                        try:
+                            lc = do_node.loop_command
+                        except Exception:
+                            lc = None
+                        if lc and "WHILE" in lc:
+                            # extract WHILE token and condition similar to above
+                            command2 = re.sub(self.TOKEN_RE, r" \1", lc)
+                            tokens2 = [t for t in command2.split(" ") if t]
+                            for t3 in tokens2:
+                                if t3.startswith("WHILE"):
+                                    cond_text = t3[5:]
+                                    try:
+                                        if self._is_true(cond_text, state):
+                                            # condition still true -> jump back into loop body
+                                            node._next_ncCode = getattr(do_node, "_next_ncCode", do_node)
+                                        else:
+                                            # condition false -> ensure END falls through to next node
+                                            if self._nodes is not None:
+                                                try:
+                                                    end_idx = self._nodes.index(node)
+                                                    node._next_ncCode = self._nodes[end_idx + 1] if end_idx + 1 < len(self._nodes) else None
+                                                except Exception:
+                                                    # fallback: leave pointer as-is
+                                                    pass
+                                    except Exception:
+                                        # on error, fall through
+                                        pass
+                                    break
+                break
+
+        return super().handle(node, state)
+
+
+__all__ = ["ControlFlowHandler"]
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group0.cpython-313.pyc b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group0.cpython-313.pyc
new file mode 100644
index 0000000..9d516b5
Binary files /dev/null and b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group0.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group0_coordinate_set.cpython-313.pyc b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group0_coordinate_set.cpython-313.pyc
new file mode 100644
index 0000000..5df71f0
Binary files /dev/null and b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group0_coordinate_set.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group16.cpython-313.pyc b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group16.cpython-313.pyc
new file mode 100644
index 0000000..164288d
Binary files /dev/null and b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group16.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group16_plane.cpython-313.pyc b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group16_plane.cpython-313.pyc
new file mode 100644
index 0000000..203562c
Binary files /dev/null and b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group16_plane.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group2.cpython-313.pyc b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group2.cpython-313.pyc
new file mode 100644
index 0000000..6d43cff
Binary files /dev/null and b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group2.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group21.cpython-313.pyc b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group21.cpython-313.pyc
new file mode 100644
index 0000000..ce1c576
Binary files /dev/null and b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group21.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group21_polar_co.cpython-313.pyc b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group21_polar_co.cpython-313.pyc
new file mode 100644
index 0000000..db1a7b6
Binary files /dev/null and b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group21_polar_co.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group2_speed_mode.cpython-313.pyc b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group2_speed_mode.cpython-313.pyc
new file mode 100644
index 0000000..5bc561e
Binary files /dev/null and b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group2_speed_mode.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group5.cpython-313.pyc b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group5.cpython-313.pyc
new file mode 100644
index 0000000..cb3ce24
Binary files /dev/null and b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group5.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group5_feed_mode.cpython-313.pyc b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group5_feed_mode.cpython-313.pyc
new file mode 100644
index 0000000..6752261
Binary files /dev/null and b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_group5_feed_mode.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_precheck.cpython-313.pyc b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_precheck.cpython-313.pyc
new file mode 100644
index 0000000..074468b
Binary files /dev/null and b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/__pycache__/gcode_precheck.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group0_coordinate_set.py b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group0_coordinate_set.py
index 705c0f5..d09d098 100644
--- a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group0_coordinate_set.py
+++ b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group0_coordinate_set.py
@@ -1,88 +1,88 @@
-from __future__ import annotations
-
-from typing import Optional, Tuple, List
-
-from ncplot7py.domain.exec_chain import Handler
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-
-
-class GCodeGroup0CoordinateSetExecChainLink(Handler):
-    """Handle G50 (set offsets) and G28 (go to reference) and small misc.
-
-    Behavior is adapted from the user example but uses `CNCState` storage
-    conventions (dicts for axes/offsets/multipliers).
-    """
-
-    AXIS_MAP = {"U": "X", "V": "Y", "W": "Z", "H": "C"}
-
-    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
-        # Defensive copy of g-codes to iterate safely
-        for g_code in set(node.g_code):
-            # normalize e.g. 'G50' -> 50
-            try:
-                if g_code.upper().startswith("G"):
-                    g_num = int(g_code[1:])
-                else:
-                    # not a G code, skip
-                    continue
-            except Exception:
-                continue
-
-            # --- G50: set offsets (store current pos into offsets and set new pos)
-            if g_num == 50:
-                for key in list(node.command_parameter.keys()):
-                    raw = node.command_parameter.pop(key, None)
-                    if raw is None:
-                        continue
-                    # map input letter to axis name (allow A,B,C,X,Y,Z)
-                    axis = key.upper()
-                    if axis in ("A", "B", "C", "X", "Y", "Z"):
-                        # add current axis pos to offset
-                        current = state.axes.get(axis, 0.0)
-                        state.offsets[axis] = state.offsets.get(axis, 0.0) + current
-                        mult = state.axis_multipliers.get(axis, 1.0) or 1.0
-                        # set new current axis pos from parameter (apply multiplier)
-                        try:
-                            val = float(raw)
-                        except Exception:
-                            val = 0.0
-                        state.axes[axis] = val / mult
-
-            # --- G28: move to reference/zero, convert U/V/W/H to X/Y/Z/C and
-            # adjust for offsets (we mutate parameters so downstream motion
-            # handlers see absolute coordinates after offset correction)
-            elif g_num == 28:
-                # ensure a rapid (G00) motion code is present
-                node.g_code.add("G00")
-                for key in list(node.command_parameter.keys()):
-                    mapped = self.AXIS_MAP.get(key.upper(), key.upper())
-                    try:
-                        raw = float(node.command_parameter.get(key))
-                    except Exception:
-                        # leave as-is when not numeric
-                        continue
-                    off = state.offsets.get(mapped, 0.0)
-                    mult = state.axis_multipliers.get(mapped, 1.0) or 1.0
-                    # subtract offset*multiplier (user example used that formula)
-                    corrected = raw - off * mult
-                    # update parameter using mapped axis letter
-                    node.command_parameter[mapped] = str(corrected)
-                    # remove original key if different (U/V/W/H)
-                    if mapped != key.upper():
-                        node.command_parameter.pop(key, None)
-
-            # --- G4: dwell — consume time parameters but no axis motion
-            elif g_num == 4:
-                # Example popped U/X in their code; we simply remove dwell params
-                for key in list(node.command_parameter.keys()):
-                    if key.upper() in ("U", "X"):
-                        node.command_parameter.pop(key, None)
-
-        # Delegate to next handler if present
-        if self.next_handler is not None:
-            return self.next_handler.handle(node, state)
-        return None, None
-
-
-__all__ = ["GCodeGroup0CoordinateSetExecChainLink"]
+from __future__ import annotations
+
+from typing import Optional, Tuple, List
+
+from ncplot7py.domain.exec_chain import Handler
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+
+
+class GCodeGroup0CoordinateSetExecChainLink(Handler):
+    """Handle G50 (set offsets) and G28 (go to reference) and small misc.
+
+    Behavior is adapted from the user example but uses `CNCState` storage
+    conventions (dicts for axes/offsets/multipliers).
+    """
+
+    AXIS_MAP = {"U": "X", "V": "Y", "W": "Z", "H": "C"}
+
+    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
+        # Defensive copy of g-codes to iterate safely
+        for g_code in set(node.g_code):
+            # normalize e.g. 'G50' -> 50
+            try:
+                if g_code.upper().startswith("G"):
+                    g_num = int(g_code[1:])
+                else:
+                    # not a G code, skip
+                    continue
+            except Exception:
+                continue
+
+            # --- G50: set offsets (store current pos into offsets and set new pos)
+            if g_num == 50:
+                for key in list(node.command_parameter.keys()):
+                    raw = node.command_parameter.pop(key, None)
+                    if raw is None:
+                        continue
+                    # map input letter to axis name (allow A,B,C,X,Y,Z)
+                    axis = key.upper()
+                    if axis in ("A", "B", "C", "X", "Y", "Z"):
+                        # add current axis pos to offset
+                        current = state.axes.get(axis, 0.0)
+                        state.offsets[axis] = state.offsets.get(axis, 0.0) + current
+                        mult = state.axis_multipliers.get(axis, 1.0) or 1.0
+                        # set new current axis pos from parameter (apply multiplier)
+                        try:
+                            val = float(raw)
+                        except Exception:
+                            val = 0.0
+                        state.axes[axis] = val / mult
+
+            # --- G28: move to reference/zero, convert U/V/W/H to X/Y/Z/C and
+            # adjust for offsets (we mutate parameters so downstream motion
+            # handlers see absolute coordinates after offset correction)
+            elif g_num == 28:
+                # ensure a rapid (G00) motion code is present
+                node.g_code.add("G00")
+                for key in list(node.command_parameter.keys()):
+                    mapped = self.AXIS_MAP.get(key.upper(), key.upper())
+                    try:
+                        raw = float(node.command_parameter.get(key))
+                    except Exception:
+                        # leave as-is when not numeric
+                        continue
+                    off = state.offsets.get(mapped, 0.0)
+                    mult = state.axis_multipliers.get(mapped, 1.0) or 1.0
+                    # subtract offset*multiplier (user example used that formula)
+                    corrected = raw - off * mult
+                    # update parameter using mapped axis letter
+                    node.command_parameter[mapped] = str(corrected)
+                    # remove original key if different (U/V/W/H)
+                    if mapped != key.upper():
+                        node.command_parameter.pop(key, None)
+
+            # --- G4: dwell — consume time parameters but no axis motion
+            elif g_num == 4:
+                # Example popped U/X in their code; we simply remove dwell params
+                for key in list(node.command_parameter.keys()):
+                    if key.upper() in ("U", "X"):
+                        node.command_parameter.pop(key, None)
+
+        # Delegate to next handler if present
+        if self.next_handler is not None:
+            return self.next_handler.handle(node, state)
+        return None, None
+
+
+__all__ = ["GCodeGroup0CoordinateSetExecChainLink"]
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group16_plane.py b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group16_plane.py
index 8461065..1458a37 100644
--- a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group16_plane.py
+++ b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group16_plane.py
@@ -1,83 +1,83 @@
-"""Handler for Fanuc-style plane selection (G17/G18/G19) -- Group 16.
-
-This handler sets the current working plane in the `CNCState` by writing
-into `state.extra['g_group_16_plane']`. It detects conflicting codes and
-raises an NC error when multiple plane codes are present in the same block.
-
-The values stored are simple strings matching the notation used elsewhere
-in the codebase: 'X_Y', 'X_Z', 'Y_Z'.
-"""
-from __future__ import annotations
-
-from typing import Optional, Tuple, List
-from enum import Enum
-
-from ncplot7py.domain.exec_chain import Handler
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
-
-
-class PlaneMode(Enum):
-    X_Y = "X_Y"  # G17
-    X_Z = "X_Z"  # G18
-    Y_Z = "Y_Z"  # G19
-
-
-class GCodeGroup16PlaneExecChainLink(Handler):
-    """Handle G17/G18/G19 plane selection codes.
-
-    - If more than one plane code is present in the same block, an NC error
-      is raised.
-    - Otherwise, update `state.extra['g_group_16_plane']` with the selected
-      plane mode (enum or its value).
-    """
-
-    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
-        has17 = False
-        has18 = False
-        has19 = False
-
-        for g in node.g_code:
-            if not isinstance(g, str):
-                continue
-            try:
-                if g.upper().startswith("G"):
-                    num = int(g[1:])
-                else:
-                    continue
-            except Exception:
-                continue
-            if num == 17:
-                has17 = True
-            elif num == 18:
-                has18 = True
-            elif num == 19:
-                has19 = True
-
-        # conflicting plane codes in same block
-        if (has17 and has18) or (has17 and has19) or (has18 and has19):
-            raise_nc_error(ExceptionTyps.NCCodeErrors, 120, message="Conflicting plane selection codes (G17/G18/G19)", value=str(node.g_code))
-
-        if has17:
-            try:
-                state.extra["g_group_16_plane"] = PlaneMode.X_Y
-            except Exception:
-                state.extra["g_group_16_plane"] = PlaneMode.X_Y.value
-        if has18:
-            try:
-                state.extra["g_group_16_plane"] = PlaneMode.X_Z
-            except Exception:
-                state.extra["g_group_16_plane"] = PlaneMode.X_Z.value
-        if has19:
-            try:
-                state.extra["g_group_16_plane"] = PlaneMode.Y_Z
-            except Exception:
-                state.extra["g_group_16_plane"] = PlaneMode.Y_Z.value
-
-        if self.next_handler is not None:
-            return self.next_handler.handle(node, state)
-        return None, None
-
-
-__all__ = ["GCodeGroup16PlaneExecChainLink", "PlaneMode"]
+"""Handler for Fanuc-style plane selection (G17/G18/G19) -- Group 16.
+
+This handler sets the current working plane in the `CNCState` by writing
+into `state.extra['g_group_16_plane']`. It detects conflicting codes and
+raises an NC error when multiple plane codes are present in the same block.
+
+The values stored are simple strings matching the notation used elsewhere
+in the codebase: 'X_Y', 'X_Z', 'Y_Z'.
+"""
+from __future__ import annotations
+
+from typing import Optional, Tuple, List
+from enum import Enum
+
+from ncplot7py.domain.exec_chain import Handler
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
+
+
+class PlaneMode(Enum):
+    X_Y = "X_Y"  # G17
+    X_Z = "X_Z"  # G18
+    Y_Z = "Y_Z"  # G19
+
+
+class GCodeGroup16PlaneExecChainLink(Handler):
+    """Handle G17/G18/G19 plane selection codes.
+
+    - If more than one plane code is present in the same block, an NC error
+      is raised.
+    - Otherwise, update `state.extra['g_group_16_plane']` with the selected
+      plane mode (enum or its value).
+    """
+
+    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
+        has17 = False
+        has18 = False
+        has19 = False
+
+        for g in node.g_code:
+            if not isinstance(g, str):
+                continue
+            try:
+                if g.upper().startswith("G"):
+                    num = int(g[1:])
+                else:
+                    continue
+            except Exception:
+                continue
+            if num == 17:
+                has17 = True
+            elif num == 18:
+                has18 = True
+            elif num == 19:
+                has19 = True
+
+        # conflicting plane codes in same block
+        if (has17 and has18) or (has17 and has19) or (has18 and has19):
+            raise_nc_error(ExceptionTyps.NCCodeErrors, 120, message="Conflicting plane selection codes (G17/G18/G19)", value=str(node.g_code))
+
+        if has17:
+            try:
+                state.extra["g_group_16_plane"] = PlaneMode.X_Y
+            except Exception:
+                state.extra["g_group_16_plane"] = PlaneMode.X_Y.value
+        if has18:
+            try:
+                state.extra["g_group_16_plane"] = PlaneMode.X_Z
+            except Exception:
+                state.extra["g_group_16_plane"] = PlaneMode.X_Z.value
+        if has19:
+            try:
+                state.extra["g_group_16_plane"] = PlaneMode.Y_Z
+            except Exception:
+                state.extra["g_group_16_plane"] = PlaneMode.Y_Z.value
+
+        if self.next_handler is not None:
+            return self.next_handler.handle(node, state)
+        return None, None
+
+
+__all__ = ["GCodeGroup16PlaneExecChainLink", "PlaneMode"]
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group21_polar_co.py b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group21_polar_co.py
index 9bb33c3..f4311f7 100644
--- a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group21_polar_co.py
+++ b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group21_polar_co.py
@@ -1,142 +1,142 @@
-"""Handler for Fanuc-style polar coordinate mode (G112/G113) — Group 21.
-
-This handler implements a lightweight version of G12.1 / polar-coordinate
-semantics used on some Fanuc controllers. It does not change the machine
-state shape; instead it stores flags under `state.extra` and remaps
-parameters on the node when polar interpolation is active.
-
-Behavior implemented:
-- G112 -> enable polar coordinates (store flag) and set plane to X_Y
-- G113 -> disable polar coordinates and set plane to X_Z
-- When polar is enabled, translate C/H parameters to the configured
-  `polar_interpolate_axis` (expected in `state.extra` as 'X' or 'Y') using
-  axis multipliers `x_axis_multiplication` / `y_axis_multiplication`.
-- When polar axis is X, swap G2/G3 directions (mirror behaviour used by
-  some controllers).
-
-This is conservative: missing state fields are treated with sensible
-defaults and errors are raised via the domain helper when conflicting
-modal codes are present.
-"""
-from __future__ import annotations
-
-from typing import Optional, Tuple, List
-
-from ncplot7py.domain.exec_chain import Handler
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
-
-
-class GCodeGroup21PolarCoExecChainLink(Handler):
-    """Handle G112/G113 (polar coordinate on/off) and remap parameters.
-
-    The handler stores small flags in `state.extra` instead of adding new
-    typed fields to `CNCState` to avoid changing the core dataclass here.
-    """
-
-    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
-        has112 = False
-        has113 = False
-        for g in node.g_code:
-            if not isinstance(g, str):
-                continue
-            try:
-                if g.upper().startswith("G"):
-                    gnum = int(g[1:])
-                else:
-                    continue
-            except Exception:
-                continue
-            if gnum == 112:
-                has112 = True
-            if gnum == 113:
-                has113 = True
-
-        if has112 and has113:
-            raise_nc_error(ExceptionTyps.NCCodeErrors, 110, message="Conflicting polar coordinate codes G112 and G113", value=str(node.g_code))
-
-        # set flags in state.extra
-        if has112:
-            # remember previous plane (if any) so disabling polar can
-            # restore it rather than forcing an arbitrary plane.
-            prev = state.extra.get("g_group_16_plane")
-            if prev is not None:
-                state.extra["g_group_21_prev_plane"] = prev
-            state.extra["g_group_21_star"] = "POLAR_COORDINATE_ON"
-            state.extra["g_group_16_plane"] = "X_Y"
-        if has113:
-            state.extra["g_group_21_star"] = "POLAR_COORDINATE_OFF"
-            # restore previous plane if we recorded one, otherwise default
-            # to X_Y (XY plane) which is the most common working plane.
-            prev = state.extra.pop("g_group_21_prev_plane", None)
-            if prev is not None:
-                state.extra["g_group_16_plane"] = prev
-            else:
-                state.extra["g_group_16_plane"] = "X_Y"
-
-        # If polar mode active, remap C/H -> axis and possibly swap arcs
-        if state.extra.get("g_group_21_star") == "POLAR_COORDINATE_ON":
-            # which axis is used for polar interpolation? default to 'Y'
-            polar_axis = state.extra.get("polar_interpolate_axis", "Y")
-            # multipliers (defaults to 1.0)
-            xmul = float(state.extra.get("x_axis_multiplication", 1.0))
-            ymul = float(state.extra.get("y_axis_multiplication", 1.0))
-
-            # C parameter -> axis displacement
-            if node.command_parameter and "C" in node.command_parameter:
-                try:
-                    raw = float(node.command_parameter.get("C", 0.0))
-                except Exception:
-                    raw = 0.0
-                if polar_axis == "Y":
-                    value = raw * ymul
-                elif polar_axis == "X":
-                    value = raw * xmul
-                else:
-                    raise_nc_error(ExceptionTyps.NCCodeErrors, 111, message="Polar interpolation axis not recognised", value=polar_axis)
-                node.command_parameter[polar_axis] = str(value)
-                node.command_parameter.pop("C", None)
-
-            # H parameter -> maps to V (when polar Y) or U (when polar X)
-            if node.command_parameter and "H" in node.command_parameter:
-                try:
-                    raw = float(node.command_parameter.get("H", 0.0))
-                except Exception:
-                    raw = 0.0
-                if polar_axis == "Y":
-                    value = raw * ymul
-                    node.command_parameter["V"] = str(value)
-                elif polar_axis == "X":
-                    value = raw * xmul
-                    node.command_parameter["U"] = str(value)
-                else:
-                    raise_nc_error(ExceptionTyps.NCCodeErrors, 111, message="Polar interpolation axis not recognised", value=polar_axis)
-                node.command_parameter.pop("H", None)
-
-            # swap G2/G3 if polar axis is X (mirror winding direction)
-            if polar_axis == "X":
-                # operate on a copy to avoid modifying the set during iteration
-                for g in list(node.g_code):
-                    if not isinstance(g, str):
-                        continue
-                    try:
-                        if not g.upper().startswith("G"):
-                            continue
-                        num = int(g[1:])
-                    except Exception:
-                        continue
-                    if num == 2:
-                        node.g_code.remove(g)
-                        node.g_code.add("G3")
-                    elif num == 3:
-                        node.g_code.remove(g)
-                        node.g_code.add("G2")
-
-        # Delegate
-        if self.next_handler is not None:
-            return self.next_handler.handle(node, state)
-        return None, None
-
-
-__all__ = ["GCodeGroup21PolarCoExecChainLink"]
+"""Handler for Fanuc-style polar coordinate mode (G112/G113) — Group 21.
+
+This handler implements a lightweight version of G12.1 / polar-coordinate
+semantics used on some Fanuc controllers. It does not change the machine
+state shape; instead it stores flags under `state.extra` and remaps
+parameters on the node when polar interpolation is active.
+
+Behavior implemented:
+- G112 -> enable polar coordinates (store flag) and set plane to X_Y
+- G113 -> disable polar coordinates and set plane to X_Z
+- When polar is enabled, translate C/H parameters to the configured
+  `polar_interpolate_axis` (expected in `state.extra` as 'X' or 'Y') using
+  axis multipliers `x_axis_multiplication` / `y_axis_multiplication`.
+- When polar axis is X, swap G2/G3 directions (mirror behaviour used by
+  some controllers).
+
+This is conservative: missing state fields are treated with sensible
+defaults and errors are raised via the domain helper when conflicting
+modal codes are present.
+"""
+from __future__ import annotations
+
+from typing import Optional, Tuple, List
+
+from ncplot7py.domain.exec_chain import Handler
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
+
+
+class GCodeGroup21PolarCoExecChainLink(Handler):
+    """Handle G112/G113 (polar coordinate on/off) and remap parameters.
+
+    The handler stores small flags in `state.extra` instead of adding new
+    typed fields to `CNCState` to avoid changing the core dataclass here.
+    """
+
+    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
+        has112 = False
+        has113 = False
+        for g in node.g_code:
+            if not isinstance(g, str):
+                continue
+            try:
+                if g.upper().startswith("G"):
+                    gnum = int(g[1:])
+                else:
+                    continue
+            except Exception:
+                continue
+            if gnum == 112:
+                has112 = True
+            if gnum == 113:
+                has113 = True
+
+        if has112 and has113:
+            raise_nc_error(ExceptionTyps.NCCodeErrors, 110, message="Conflicting polar coordinate codes G112 and G113", value=str(node.g_code))
+
+        # set flags in state.extra
+        if has112:
+            # remember previous plane (if any) so disabling polar can
+            # restore it rather than forcing an arbitrary plane.
+            prev = state.extra.get("g_group_16_plane")
+            if prev is not None:
+                state.extra["g_group_21_prev_plane"] = prev
+            state.extra["g_group_21_star"] = "POLAR_COORDINATE_ON"
+            state.extra["g_group_16_plane"] = "X_Y"
+        if has113:
+            state.extra["g_group_21_star"] = "POLAR_COORDINATE_OFF"
+            # restore previous plane if we recorded one, otherwise default
+            # to X_Y (XY plane) which is the most common working plane.
+            prev = state.extra.pop("g_group_21_prev_plane", None)
+            if prev is not None:
+                state.extra["g_group_16_plane"] = prev
+            else:
+                state.extra["g_group_16_plane"] = "X_Y"
+
+        # If polar mode active, remap C/H -> axis and possibly swap arcs
+        if state.extra.get("g_group_21_star") == "POLAR_COORDINATE_ON":
+            # which axis is used for polar interpolation? default to 'Y'
+            polar_axis = state.extra.get("polar_interpolate_axis", "Y")
+            # multipliers (defaults to 1.0)
+            xmul = float(state.extra.get("x_axis_multiplication", 1.0))
+            ymul = float(state.extra.get("y_axis_multiplication", 1.0))
+
+            # C parameter -> axis displacement
+            if node.command_parameter and "C" in node.command_parameter:
+                try:
+                    raw = float(node.command_parameter.get("C", 0.0))
+                except Exception:
+                    raw = 0.0
+                if polar_axis == "Y":
+                    value = raw * ymul
+                elif polar_axis == "X":
+                    value = raw * xmul
+                else:
+                    raise_nc_error(ExceptionTyps.NCCodeErrors, 111, message="Polar interpolation axis not recognised", value=polar_axis)
+                node.command_parameter[polar_axis] = str(value)
+                node.command_parameter.pop("C", None)
+
+            # H parameter -> maps to V (when polar Y) or U (when polar X)
+            if node.command_parameter and "H" in node.command_parameter:
+                try:
+                    raw = float(node.command_parameter.get("H", 0.0))
+                except Exception:
+                    raw = 0.0
+                if polar_axis == "Y":
+                    value = raw * ymul
+                    node.command_parameter["V"] = str(value)
+                elif polar_axis == "X":
+                    value = raw * xmul
+                    node.command_parameter["U"] = str(value)
+                else:
+                    raise_nc_error(ExceptionTyps.NCCodeErrors, 111, message="Polar interpolation axis not recognised", value=polar_axis)
+                node.command_parameter.pop("H", None)
+
+            # swap G2/G3 if polar axis is X (mirror winding direction)
+            if polar_axis == "X":
+                # operate on a copy to avoid modifying the set during iteration
+                for g in list(node.g_code):
+                    if not isinstance(g, str):
+                        continue
+                    try:
+                        if not g.upper().startswith("G"):
+                            continue
+                        num = int(g[1:])
+                    except Exception:
+                        continue
+                    if num == 2:
+                        node.g_code.remove(g)
+                        node.g_code.add("G3")
+                    elif num == 3:
+                        node.g_code.remove(g)
+                        node.g_code.add("G2")
+
+        # Delegate
+        if self.next_handler is not None:
+            return self.next_handler.handle(node, state)
+        return None, None
+
+
+__all__ = ["GCodeGroup21PolarCoExecChainLink"]
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group2_speed_mode.py b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group2_speed_mode.py
index a98c425..7da0c6f 100644
--- a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group2_speed_mode.py
+++ b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group2_speed_mode.py
@@ -1,72 +1,72 @@
-"""Handler for Fanuc-style surface speed mode (G96/G97).
-
-Sets a flag in the CNC state indicating whether surface speed or constant
-RPM mode is active. If both G96 and G97 are present in the same node an
-NC error is raised.
-"""
-from __future__ import annotations
-
-from typing import Optional, Tuple, List
-from enum import Enum
-
-from ncplot7py.domain.exec_chain import Handler
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
-
-
-class SpeedMode(Enum):
-    CONSTANT_CUTSPEED = "CONSTANT_CUTSPEED"  # G96
-    CONSTANT_REV = "CONSTANT_REV"  # G97
-
-
-class GCodeGroup2SpeedModeExecChainLink(Handler):
-    """Handle G96/G97 surface speed modal codes.
-
-    Behavior:
-    - If both G96 and G97 are present in the same node an NC error is raised.
-    - If G96 is present the state is marked with SpeedMode.CONSTANT_CUTSPEED.
-    - If G97 is present the state is marked with SpeedMode.CONSTANT_REV.
-    - Delegates to next handler afterwards.
-    """
-
-    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
-        has96 = False
-        has97 = False
-        for g in node.g_code:
-            if not isinstance(g, str):
-                continue
-            try:
-                if g.upper().startswith("G"):
-                    gnum = int(g[1:])
-                else:
-                    continue
-            except Exception:
-                continue
-            if gnum == 96:
-                has96 = True
-            if gnum == 97:
-                has97 = True
-
-        if has96 and has97:
-            # both G96 and G97 in same block -> duplication error
-            raise_nc_error(ExceptionTyps.NCCodeErrors, 100, message="Conflicting surface speed codes G96 and G97", value=str(node.g_code))
-
-        if has96:
-            try:
-                state.extra["surface_speed_mode"] = SpeedMode.CONSTANT_CUTSPEED
-            except Exception:
-                state.extra["surface_speed_mode"] = SpeedMode.CONSTANT_CUTSPEED.value
-
-        if has97:
-            try:
-                state.extra["surface_speed_mode"] = SpeedMode.CONSTANT_REV
-            except Exception:
-                state.extra["surface_speed_mode"] = SpeedMode.CONSTANT_REV.value
-
-        if self.next_handler is not None:
-            return self.next_handler.handle(node, state)
-        return None, None
-
-
-__all__ = ["GCodeGroup2SpeedModeExecChainLink", "SpeedMode"]
+"""Handler for Fanuc-style surface speed mode (G96/G97).
+
+Sets a flag in the CNC state indicating whether surface speed or constant
+RPM mode is active. If both G96 and G97 are present in the same node an
+NC error is raised.
+"""
+from __future__ import annotations
+
+from typing import Optional, Tuple, List
+from enum import Enum
+
+from ncplot7py.domain.exec_chain import Handler
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
+
+
+class SpeedMode(Enum):
+    CONSTANT_CUTSPEED = "CONSTANT_CUTSPEED"  # G96
+    CONSTANT_REV = "CONSTANT_REV"  # G97
+
+
+class GCodeGroup2SpeedModeExecChainLink(Handler):
+    """Handle G96/G97 surface speed modal codes.
+
+    Behavior:
+    - If both G96 and G97 are present in the same node an NC error is raised.
+    - If G96 is present the state is marked with SpeedMode.CONSTANT_CUTSPEED.
+    - If G97 is present the state is marked with SpeedMode.CONSTANT_REV.
+    - Delegates to next handler afterwards.
+    """
+
+    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
+        has96 = False
+        has97 = False
+        for g in node.g_code:
+            if not isinstance(g, str):
+                continue
+            try:
+                if g.upper().startswith("G"):
+                    gnum = int(g[1:])
+                else:
+                    continue
+            except Exception:
+                continue
+            if gnum == 96:
+                has96 = True
+            if gnum == 97:
+                has97 = True
+
+        if has96 and has97:
+            # both G96 and G97 in same block -> duplication error
+            raise_nc_error(ExceptionTyps.NCCodeErrors, 100, message="Conflicting surface speed codes G96 and G97", value=str(node.g_code))
+
+        if has96:
+            try:
+                state.extra["surface_speed_mode"] = SpeedMode.CONSTANT_CUTSPEED
+            except Exception:
+                state.extra["surface_speed_mode"] = SpeedMode.CONSTANT_CUTSPEED.value
+
+        if has97:
+            try:
+                state.extra["surface_speed_mode"] = SpeedMode.CONSTANT_REV
+            except Exception:
+                state.extra["surface_speed_mode"] = SpeedMode.CONSTANT_REV.value
+
+        if self.next_handler is not None:
+            return self.next_handler.handle(node, state)
+        return None, None
+
+
+__all__ = ["GCodeGroup2SpeedModeExecChainLink", "SpeedMode"]
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group5_feed_mode.py b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group5_feed_mode.py
index 57b03cd..c844977 100644
--- a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group5_feed_mode.py
+++ b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_group5_feed_mode.py
@@ -1,70 +1,70 @@
-"""Handler for Fanuc-style feed mode (G98/G99).
-
-G98 = feed per minute (FEED_PER_MIN)
-G99 = feed per revolution (FEED_PER_REV)
-
-This sets a simple flag in the CNC state under `extra['feed_mode']` so
-other parts of the system can react accordingly.
-"""
-from __future__ import annotations
-
-from typing import Optional, Tuple, List
-from enum import Enum
-
-from ncplot7py.domain.exec_chain import Handler
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
-
-
-class FeedMode(Enum):
-    FEED_PER_MIN = "FEED_PER_MIN"  # G98
-    FEED_PER_REV = "FEED_PER_REV"  # G99
-
-
-class GCodeGroup5FeedModeExecChainLink(Handler):
-    """Handle G98/G99 feed mode codes.
-
-    - If both G98 and G99 are present in the same node an NC error is raised.
-    - Sets `state.extra['feed_mode']` to the appropriate FeedMode.
-    """
-
-    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
-        has98 = False
-        has99 = False
-        for g in node.g_code:
-            if not isinstance(g, str):
-                continue
-            try:
-                if g.upper().startswith("G"):
-                    gnum = int(g[1:])
-                else:
-                    continue
-            except Exception:
-                continue
-            if gnum == 98:
-                has98 = True
-            if gnum == 99:
-                has99 = True
-
-        if has98 and has99:
-            raise_nc_error(ExceptionTyps.NCCodeErrors, 101, message="Conflicting feed mode codes G98 and G99", value=str(node.g_code))
-
-        if has98:
-            try:
-                state.extra["feed_mode"] = FeedMode.FEED_PER_MIN
-            except Exception:
-                state.extra["feed_mode"] = FeedMode.FEED_PER_MIN.value
-
-        if has99:
-            try:
-                state.extra["feed_mode"] = FeedMode.FEED_PER_REV
-            except Exception:
-                state.extra["feed_mode"] = FeedMode.FEED_PER_REV.value
-
-        if self.next_handler is not None:
-            return self.next_handler.handle(node, state)
-        return None, None
-
-
-__all__ = ["GCodeGroup5FeedModeExecChainLink", "FeedMode"]
+"""Handler for Fanuc-style feed mode (G98/G99).
+
+G98 = feed per minute (FEED_PER_MIN)
+G99 = feed per revolution (FEED_PER_REV)
+
+This sets a simple flag in the CNC state under `extra['feed_mode']` so
+other parts of the system can react accordingly.
+"""
+from __future__ import annotations
+
+from typing import Optional, Tuple, List
+from enum import Enum
+
+from ncplot7py.domain.exec_chain import Handler
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
+
+
+class FeedMode(Enum):
+    FEED_PER_MIN = "FEED_PER_MIN"  # G98
+    FEED_PER_REV = "FEED_PER_REV"  # G99
+
+
+class GCodeGroup5FeedModeExecChainLink(Handler):
+    """Handle G98/G99 feed mode codes.
+
+    - If both G98 and G99 are present in the same node an NC error is raised.
+    - Sets `state.extra['feed_mode']` to the appropriate FeedMode.
+    """
+
+    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
+        has98 = False
+        has99 = False
+        for g in node.g_code:
+            if not isinstance(g, str):
+                continue
+            try:
+                if g.upper().startswith("G"):
+                    gnum = int(g[1:])
+                else:
+                    continue
+            except Exception:
+                continue
+            if gnum == 98:
+                has98 = True
+            if gnum == 99:
+                has99 = True
+
+        if has98 and has99:
+            raise_nc_error(ExceptionTyps.NCCodeErrors, 101, message="Conflicting feed mode codes G98 and G99", value=str(node.g_code))
+
+        if has98:
+            try:
+                state.extra["feed_mode"] = FeedMode.FEED_PER_MIN
+            except Exception:
+                state.extra["feed_mode"] = FeedMode.FEED_PER_MIN.value
+
+        if has99:
+            try:
+                state.extra["feed_mode"] = FeedMode.FEED_PER_REV
+            except Exception:
+                state.extra["feed_mode"] = FeedMode.FEED_PER_REV.value
+
+        if self.next_handler is not None:
+            return self.next_handler.handle(node, state)
+        return None, None
+
+
+__all__ = ["GCodeGroup5FeedModeExecChainLink", "FeedMode"]
diff --git a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_precheck.py b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_precheck.py
index 135bae4..cdf7f0e 100644
--- a/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_precheck.py
+++ b/src/ncplot7py/domain/handlers/fanuc_turn_cnc/gcode_precheck.py
@@ -1,35 +1,35 @@
-from __future__ import annotations
-
-from typing import Optional, Tuple, List
-
-from ncplot7py.domain.exec_chain import Handler
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
-
-
-class GcodePreCheckExecChainLink(Handler):
-    """Pre-check handler for Fanuc-style NC commands.
-
-    Performs lightweight validation before other G-code handlers run.
-    Current checks:
-    - Parameter letter keys must be upper-case (raises NCCodeErrors if not)
-    """
-
-    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
-        # Inspect parameter keys and raise a domain error when keys are lower-case
-        for key in list(node.command_parameter.keys()):
-            try:
-                if isinstance(key, str) and key.islower():
-                    raise_nc_error(ExceptionTyps.NCCodeErrors, 130, message="Parameter letter must be upper-case", value=str(key))
-            except Exception:
-                # propagate structured ExceptionNode raised by raise_nc_error
-                raise
-
-        # Delegate to next handler
-        if self.next_handler is not None:
-            return self.next_handler.handle(node, state)
-        return None, None
-
-
-__all__ = ["GcodePreCheckExecChainLink"]
+from __future__ import annotations
+
+from typing import Optional, Tuple, List
+
+from ncplot7py.domain.exec_chain import Handler
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
+
+
+class GcodePreCheckExecChainLink(Handler):
+    """Pre-check handler for Fanuc-style NC commands.
+
+    Performs lightweight validation before other G-code handlers run.
+    Current checks:
+    - Parameter letter keys must be upper-case (raises NCCodeErrors if not)
+    """
+
+    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
+        # Inspect parameter keys and raise a domain error when keys are lower-case
+        for key in list(node.command_parameter.keys()):
+            try:
+                if isinstance(key, str) and key.islower():
+                    raise_nc_error(ExceptionTyps.NCCodeErrors, 130, message="Parameter letter must be upper-case", value=str(key))
+            except Exception:
+                # propagate structured ExceptionNode raised by raise_nc_error
+                raise
+
+        # Delegate to next handler
+        if self.next_handler is not None:
+            return self.next_handler.handle(node, state)
+        return None, None
+
+
+__all__ = ["GcodePreCheckExecChainLink"]
diff --git a/src/ncplot7py/domain/handlers/modal.py b/src/ncplot7py/domain/handlers/modal.py
index abd7aaa..f1dcd07 100644
--- a/src/ncplot7py/domain/handlers/modal.py
+++ b/src/ncplot7py/domain/handlers/modal.py
@@ -1,42 +1,42 @@
-from __future__ import annotations
-
-from typing import Optional, Tuple, List
-
-from ncplot7py.domain.exec_chain import Handler
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-
-
-class ModalHandler(Handler):
-    """Handler to update modal feed/spindle parameters from block parameters.
-
-    This centralizes updating `state.feed_rate` and `state.spindle_speed` so
-    motion handlers can rely on modal state being set earlier in the chain.
-    """
-
-    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
-        # Extract block parameters (keys are letters) and update modal state
-        try:
-            for k, v in node.command_parameter.items():
-                key = str(k).upper()
-                if key == "F":
-                    try:
-                        state.feed_rate = float(v)
-                    except Exception:
-                        # ignore invalid feed values
-                        pass
-                elif key == "S":
-                    try:
-                        state.spindle_speed = float(v)
-                    except Exception:
-                        pass
-        except Exception:
-            # be defensive: if node.command_parameter is unexpected, ignore
-            pass
-
-        if self.next_handler is not None:
-            return self.next_handler.handle(node, state)
-        return None, None
-
-
-__all__ = ["ModalHandler"]
+from __future__ import annotations
+
+from typing import Optional, Tuple, List
+
+from ncplot7py.domain.exec_chain import Handler
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+
+
+class ModalHandler(Handler):
+    """Handler to update modal feed/spindle parameters from block parameters.
+
+    This centralizes updating `state.feed_rate` and `state.spindle_speed` so
+    motion handlers can rely on modal state being set earlier in the chain.
+    """
+
+    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
+        # Extract block parameters (keys are letters) and update modal state
+        try:
+            for k, v in node.command_parameter.items():
+                key = str(k).upper()
+                if key == "F":
+                    try:
+                        state.feed_rate = float(v)
+                    except Exception:
+                        # ignore invalid feed values
+                        pass
+                elif key == "S":
+                    try:
+                        state.spindle_speed = float(v)
+                    except Exception:
+                        pass
+        except Exception:
+            # be defensive: if node.command_parameter is unexpected, ignore
+            pass
+
+        if self.next_handler is not None:
+            return self.next_handler.handle(node, state)
+        return None, None
+
+
+__all__ = ["ModalHandler"]
diff --git a/src/ncplot7py/domain/handlers/motion.py b/src/ncplot7py/domain/handlers/motion.py
index e9748aa..5fed34b 100644
--- a/src/ncplot7py/domain/handlers/motion.py
+++ b/src/ncplot7py/domain/handlers/motion.py
@@ -1,344 +1,344 @@
-"""Motion handler for G1/G2/G3 moves located in domain.handlers.
-
-This is the domain-located copy of the motion handler implementation.
-"""
-from __future__ import annotations
-
-import math
-from dataclasses import dataclass
-from typing import Dict, List, Optional, Tuple
-
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.exec_chain import Handler
-from ncplot7py.shared.point import Point
-
-
-def _to_float(v: Optional[str], default: float = 0.0) -> float:
-    try:
-        return float(v)
-    except Exception:
-        return default
-
-
-class MotionHandler(Handler):
-    """Handle G0/G1/G2/G3 interpolation.
-
-    Produces (list[Point], duration_seconds) when motion occurs, otherwise
-    delegates to next handler.
-    """
-
-    def __init__(self, next_handler: Optional[Handler] = None, max_segment: float = 0.5):
-        super().__init__(next_handler=next_handler)
-        self.max_segment = float(max_segment)
-
-    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List[Point]], Optional[float]]:
-        # detect motion codes
-        interp_mode = None  # 'G00','G01','G02','G03'
-        for g in node.g_code:
-            if g.upper() in ("G00", "G0", "G0 "):
-                interp_mode = "G00"
-            if g.upper() in ("G01", "G1"):
-                interp_mode = "G01"
-            if g.upper() in ("G02", "G2"):
-                interp_mode = "G02"
-            if g.upper() in ("G03", "G3"):
-                interp_mode = "G03"
-
-        if interp_mode is None:
-            return super().handle(node, state)
-
-        # Resolve start and end positions using state.resolve_target
-        start = state.axes.copy()
-        # build target spec from parameters: X,Y,Z or U,V,W for relative
-        target_spec: Dict[str, float] = {}
-        absolute_mode = True
-        # check distance mode modal (G90/G91)
-        dm = state.get_modal("distance")
-        if dm and dm.upper() == "G91":
-            absolute_mode = False
-
-        for k, v in node.command_parameter.items():
-            key = k.upper()
-            if key in ("X", "Y", "Z", "A", "B", "C"):
-                target_spec[key] = _to_float(v)
-            elif key in ("U", "V", "W"):
-                # relative axis spec; treat as delta
-                # map UVW to XYZ
-                mapped = {"U": "X", "V": "Y", "W": "Z"}[key]
-                target_spec[mapped] = _to_float(v)
-            # I,J,K,R,F handled later
-            # I,J,K,R,F handled later
-
-        # Normalize incoming axis values according to cnc_state axis_units
-        # (e.g. when X is interpreted as diameter the provided value should be
-        # divided by 2 to obtain internal radius coordinates).
-        normalized_target_spec = state.normalize_target_spec(target_spec)
-
-        # get resolved absolute targets
-        resolved = state.resolve_target(normalized_target_spec, absolute=absolute_mode)
-
-        # interpolation parameters
-        params = {k.upper(): _to_float(v) for k, v in node.command_parameter.items()}
-        # Normalize arc parameters (I/J/K offsets and R radius) to internal units
-        params = state.normalize_arc_params(params)
-
-        if interp_mode == "G01" or interp_mode == "G00":
-            points, duration = self._linear_interpolate(start, resolved, state)
-        elif interp_mode in ("G02", "G03"):
-            cw = interp_mode == "G02"
-            points, duration = self._circular_interpolate(start, resolved, params, state, cw)
-        else:
-            return super().handle(node, state)
-
-        # update state axes to endpoint
-        state.update_axes(resolved)
-
-        # Modal parameter handling has been moved to a dedicated handler
-        # (`ModalHandler`) earlier in the chain. MotionHandler should not
-        # mutate modal state; it only consumes values from `state` to
-        # compute durations.
-        return points, duration
-
-    def _linear_interpolate(self, start: Dict[str, float], end: Dict[str, float], state: CNCState) -> Tuple[List[Point], float]:
-        # compute distance in XYZ space
-        axes = ("X", "Y", "Z")
-        dist = state.compute_distance(start, end, axes=list(axes))
-        if dist <= 0.0:
-            # no motion
-            p = Point(x=end.get("X", 0.0), y=end.get("Y", 0.0), z=end.get("Z", 0.0),
-                      a=end.get("A", 0.0), b=end.get("B", 0.0), c=end.get("C", 0.0))
-            return [p], 0.0
-
-        # determine number of segments. Allow an optional per-state override
-        # so callers/tests can request higher resolution by setting
-        # `state.extra['max_segment']` to a smaller value (e.g. 0.05).
-        try:
-            eff_max_segment = float(getattr(state, "extra", {}).get("max_segment", self.max_segment) or self.max_segment)
-        except Exception:
-            eff_max_segment = float(self.max_segment)
-        # ensure sane lower bound
-        if eff_max_segment <= 0.0:
-            eff_max_segment = float(self.max_segment)
-        n = max(1, int(math.ceil(dist / eff_max_segment)))
-        # compute duration using feed rate. The state's `feed_rate` stores
-        # the raw F value which may be either "per minute" or "per
-        # revolution" depending on the feed mode. Convert to mm/s here.
-        feed = state.feed_rate or 1.0
-        # detect feed-per-revolution mode; FeedMode enum may be stored
-        # under state.extra['feed_mode'] either as Enum or its string value.
-        feed_mode = None
-        try:
-            feed_mode = getattr(state, "extra", {}).get("feed_mode", None)
-        except Exception:
-            feed_mode = None
-        # default: feed interpreted as mm/min
-        effective_feed_mm_per_min = float(feed)
-        try:
-            # try to import enum for a robust comparison; fall back to
-            # string compare if import fails.
-            from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group5_feed_mode import FeedMode
-
-            if feed_mode == FeedMode.FEED_PER_REV or feed_mode == FeedMode.FEED_PER_REV.value:
-                # convert mm/rev -> mm/min using spindle speed (rpm)
-                rpm = float(state.spindle_speed or 1.0)
-                effective_feed_mm_per_min = float(feed) * rpm
-        except Exception:
-            try:
-                if feed_mode == "FEED_PER_REV":
-                    rpm = float(state.spindle_speed or 1.0)
-                    effective_feed_mm_per_min = float(feed) * rpm
-            except Exception:
-                effective_feed_mm_per_min = float(feed)
-
-        # convert mm/min -> mm/s
-        feed_mm_s = effective_feed_mm_per_min / 60.0
-        duration = dist / feed_mm_s if feed_mm_s > 0 else 0.0
-
-        points: List[Point] = []
-        # include explicit start point so joins between segments preserve
-        # exact continuity when plotting consecutive motions
-        points.append(Point(x=start.get("X", 0.0), y=start.get("Y", 0.0), z=start.get("Z", 0.0),
-                             a=start.get("A", 0.0), b=start.get("B", 0.0), c=start.get("C", 0.0)))
-        for i in range(1, n + 1):
-            t = i / n
-            x = start.get("X", 0.0) + (end.get("X", start.get("X", 0.0)) - start.get("X", 0.0)) * t
-            y = start.get("Y", 0.0) + (end.get("Y", start.get("Y", 0.0)) - start.get("Y", 0.0)) * t
-            z = start.get("Z", 0.0) + (end.get("Z", start.get("Z", 0.0)) - start.get("Z", 0.0)) * t
-            a = end.get("A", start.get("A", 0.0))
-            b = end.get("B", start.get("B", 0.0))
-            c = end.get("C", start.get("C", 0.0))
-            points.append(Point(x=x, y=y, z=z, a=a, b=b, c=c))
-        return points, duration
-
-    def _circular_interpolate(self, start: Dict[str, float], end: Dict[str, float], params: Dict[str, float], state: CNCState, cw: bool) -> Tuple[List[Point], float]:
-        # Only implement XY-plane arcs for now (common case). Use I,J center offsets or R radius.
-        sx = start.get("X", 0.0)
-        sy = start.get("Y", 0.0)
-        ex = end.get("X", sx)
-        ey = end.get("Y", sy)
-
-        # center
-        if "I" in params or "J" in params:
-            ix = params.get("I", 0.0)
-            jy = params.get("J", 0.0)
-            cx = sx + ix
-            cy = sy + jy
-        elif "R" in params and params.get("R", 0.0) != 0.0:
-            # derive center from radius — choose the smaller arc by default
-            r = params.get("R", 0.0)
-            # compute midpoint
-            mx = (sx + ex) / 2.0
-            my = (sy + ey) / 2.0
-            dx = ex - sx
-            dy = ey - sy
-            d2 = dx * dx + dy * dy
-            if d2 == 0.0:
-                raise ValueError("Invalid arc with zero chord length")
-            h = math.sqrt(max(0.0, r * r - d2 / 4.0)) / math.sqrt(d2)
-            # two possible centers
-            cx1 = mx - h * dy
-            cy1 = my + h * dx
-            cx2 = mx + h * dy
-            cy2 = my - h * dx
-            # Determine which center yields the requested sweep direction
-            # and prefer the smaller absolute sweep (minor arc) when both
-            # satisfy the direction. Compute sweep angles for both centers
-            # and pick the best candidate.
-            def sweep_for_center(cx_c, cy_c):
-                a0_c = math.atan2(sy - cy_c, sx - cx_c)
-                a1_c = math.atan2(ey - cy_c, ex - cx_c)
-                da_c = a1_c - a0_c
-                # normalize to [-pi, pi]
-                if da_c > math.pi:
-                    da_c -= 2 * math.pi
-                if da_c < -math.pi:
-                    da_c += 2 * math.pi
-                return da_c
-
-            da1 = sweep_for_center(cx1, cy1)
-            da2 = sweep_for_center(cx2, cy2)
-
-            # For cw=True we want a negative sweep (clockwise), for cw=False
-            # we want a positive sweep (counter-clockwise). Prefer the center
-            # that matches the desired sign; if both match or neither match,
-            # pick the one with smaller absolute sweep (minor arc).
-            def matches_cw(da_val, cw_flag):
-                return (da_val < 0) if cw_flag else (da_val > 0)
-
-            if matches_cw(da1, cw) and not matches_cw(da2, cw):
-                cx, cy = cx1, cy1
-            elif matches_cw(da2, cw) and not matches_cw(da1, cw):
-                cx, cy = cx2, cy2
-            else:
-                # both match or both don't — choose the smaller absolute sweep
-                if abs(da1) <= abs(da2):
-                    cx, cy = cx1, cy1
-                else:
-                    cx, cy = cx2, cy2
-        else:
-            # cannot compute arc center
-            raise ValueError("Arc requires I/J or R parameter")
-
-        # compute start and end angles
-        a0 = math.atan2(sy - cy, sx - cx)
-        a1 = math.atan2(ey - cy, ex - cx)
-
-        # Robust sweep normalization:
-        # - normalize difference into (-pi, pi]
-        # - consider candidates da, da +/- 2pi and pick the candidate that
-        #   matches the requested direction (CW -> negative, CCW -> positive)
-        #   and has the smallest absolute magnitude. If no candidate matches
-        #   the requested sign (rare), pick the candidate with the smallest
-        #   absolute value (minor arc).
-        def _normalize_sweep(a_start: float, a_end: float, cw_flag: bool) -> float:
-            raw = a_end - a_start
-            # map to (-pi, pi]
-            da = (raw + math.pi) % (2 * math.pi) - math.pi
-            # consider equivalent representations
-            two_pi = 2 * math.pi
-            candidates = [da, da - two_pi, da + two_pi]
-
-            # desired sign: negative for cw (G02), positive for ccw (G03)
-            if cw_flag:
-                matching = [d for d in candidates if d < 0]
-            else:
-                matching = [d for d in candidates if d > 0]
-
-            if matching:
-                # pick the matching candidate with minimal absolute sweep
-                return min(matching, key=abs)
-            # fallback: choose the minor arc (smallest absolute value)
-            return min(candidates, key=abs)
-
-        da = _normalize_sweep(a0, a1, cw)
-
-        arc_length = abs(da) * math.hypot(sx - cx, sy - cy)
-        # n segments — allow per-state override like in linear interpolation
-        try:
-            eff_max_segment = float(getattr(state, "extra", {}).get("max_segment", self.max_segment) or self.max_segment)
-        except Exception:
-            eff_max_segment = float(self.max_segment)
-        if eff_max_segment <= 0.0:
-            eff_max_segment = float(self.max_segment)
-        n = max(2, int(math.ceil(arc_length / eff_max_segment)))
-        # Ensure a minimum angular resolution so small-radius arcs don't
-        # look like corners. Allow callers to override desired degrees per
-        # segment via state.extra['angle_per_segment_deg'] (smaller -> more
-        # segments). Default to 10 degrees per segment.
-        try:
-            desired_deg = float(getattr(state, "extra", {}).get("angle_per_segment_deg", 10.0) or 10.0)
-        except Exception:
-            desired_deg = 2.0
-        if desired_deg <= 0.0:
-            desired_deg = 2.0
-        min_n_by_angle = max(2, int(math.ceil(abs(da) / math.radians(desired_deg))))
-        if min_n_by_angle > n:
-            n = min_n_by_angle
-
-        # duration using feed rate (see linear routine for comments)
-        feed = state.feed_rate or 1.0
-        feed_mode = None
-        try:
-            feed_mode = getattr(state, "extra", {}).get("feed_mode", None)
-        except Exception:
-            feed_mode = None
-
-        effective_feed_mm_per_min = float(feed)
-        try:
-            from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group5_feed_mode import FeedMode
-            if feed_mode == FeedMode.FEED_PER_REV or feed_mode == FeedMode.FEED_PER_REV.value:
-                rpm = float(state.spindle_speed or 1.0)
-                effective_feed_mm_per_min = float(feed) * rpm
-        except Exception:
-            try:
-                if feed_mode == "FEED_PER_REV":
-                    rpm = float(state.spindle_speed or 1.0)
-                    effective_feed_mm_per_min = float(feed) * rpm
-            except Exception:
-                effective_feed_mm_per_min = float(feed)
-
-        feed_mm_s = effective_feed_mm_per_min / 60.0
-        duration = arc_length / feed_mm_s if feed_mm_s > 0 else 0.0
-
-        points: List[Point] = []
-        # include explicit start point (theta = a0)
-        start_x = cx + math.cos(a0) * math.hypot(sx - cx, sy - cy)
-        start_y = cy + math.sin(a0) * math.hypot(sx - cx, sy - cy)
-        points.append(Point(x=start_x, y=start_y, z=start.get("Z", 0.0),
-                             a=start.get("A", 0.0), b=start.get("B", 0.0), c=start.get("C", 0.0)))
-        for i in range(1, n + 1):
-            t = i / n
-            theta = a0 + da * t
-            x = cx + math.cos(theta) * math.hypot(sx - cx, sy - cy)
-            y = cy + math.sin(theta) * math.hypot(sx - cx, sy - cy)
-            z = start.get("Z", 0.0) + (end.get("Z", start.get("Z", 0.0)) - start.get("Z", 0.0)) * t
-            a = end.get("A", start.get("A", 0.0))
-            b = end.get("B", start.get("B", 0.0))
-            c = end.get("C", start.get("C", 0.0))
-            points.append(Point(x=x, y=y, z=z, a=a, b=b, c=c))
-
-        return points, duration
-
-
-__all__ = ["MotionHandler", "Point"]
+"""Motion handler for G1/G2/G3 moves located in domain.handlers.
+
+This is the domain-located copy of the motion handler implementation.
+"""
+from __future__ import annotations
+
+import math
+from dataclasses import dataclass
+from typing import Dict, List, Optional, Tuple
+
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.exec_chain import Handler
+from ncplot7py.shared.point import Point
+
+
+def _to_float(v: Optional[str], default: float = 0.0) -> float:
+    try:
+        return float(v)
+    except Exception:
+        return default
+
+
+class MotionHandler(Handler):
+    """Handle G0/G1/G2/G3 interpolation.
+
+    Produces (list[Point], duration_seconds) when motion occurs, otherwise
+    delegates to next handler.
+    """
+
+    def __init__(self, next_handler: Optional[Handler] = None, max_segment: float = 0.5):
+        super().__init__(next_handler=next_handler)
+        self.max_segment = float(max_segment)
+
+    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List[Point]], Optional[float]]:
+        # detect motion codes
+        interp_mode = None  # 'G00','G01','G02','G03'
+        for g in node.g_code:
+            if g.upper() in ("G00", "G0", "G0 "):
+                interp_mode = "G00"
+            if g.upper() in ("G01", "G1"):
+                interp_mode = "G01"
+            if g.upper() in ("G02", "G2"):
+                interp_mode = "G02"
+            if g.upper() in ("G03", "G3"):
+                interp_mode = "G03"
+
+        if interp_mode is None:
+            return super().handle(node, state)
+
+        # Resolve start and end positions using state.resolve_target
+        start = state.axes.copy()
+        # build target spec from parameters: X,Y,Z or U,V,W for relative
+        target_spec: Dict[str, float] = {}
+        absolute_mode = True
+        # check distance mode modal (G90/G91)
+        dm = state.get_modal("distance")
+        if dm and dm.upper() == "G91":
+            absolute_mode = False
+
+        for k, v in node.command_parameter.items():
+            key = k.upper()
+            if key in ("X", "Y", "Z", "A", "B", "C"):
+                target_spec[key] = _to_float(v)
+            elif key in ("U", "V", "W"):
+                # relative axis spec; treat as delta
+                # map UVW to XYZ
+                mapped = {"U": "X", "V": "Y", "W": "Z"}[key]
+                target_spec[mapped] = _to_float(v)
+            # I,J,K,R,F handled later
+            # I,J,K,R,F handled later
+
+        # Normalize incoming axis values according to cnc_state axis_units
+        # (e.g. when X is interpreted as diameter the provided value should be
+        # divided by 2 to obtain internal radius coordinates).
+        normalized_target_spec = state.normalize_target_spec(target_spec)
+
+        # get resolved absolute targets
+        resolved = state.resolve_target(normalized_target_spec, absolute=absolute_mode)
+
+        # interpolation parameters
+        params = {k.upper(): _to_float(v) for k, v in node.command_parameter.items()}
+        # Normalize arc parameters (I/J/K offsets and R radius) to internal units
+        params = state.normalize_arc_params(params)
+
+        if interp_mode == "G01" or interp_mode == "G00":
+            points, duration = self._linear_interpolate(start, resolved, state)
+        elif interp_mode in ("G02", "G03"):
+            cw = interp_mode == "G02"
+            points, duration = self._circular_interpolate(start, resolved, params, state, cw)
+        else:
+            return super().handle(node, state)
+
+        # update state axes to endpoint
+        state.update_axes(resolved)
+
+        # Modal parameter handling has been moved to a dedicated handler
+        # (`ModalHandler`) earlier in the chain. MotionHandler should not
+        # mutate modal state; it only consumes values from `state` to
+        # compute durations.
+        return points, duration
+
+    def _linear_interpolate(self, start: Dict[str, float], end: Dict[str, float], state: CNCState) -> Tuple[List[Point], float]:
+        # compute distance in XYZ space
+        axes = ("X", "Y", "Z")
+        dist = state.compute_distance(start, end, axes=list(axes))
+        if dist <= 0.0:
+            # no motion
+            p = Point(x=end.get("X", 0.0), y=end.get("Y", 0.0), z=end.get("Z", 0.0),
+                      a=end.get("A", 0.0), b=end.get("B", 0.0), c=end.get("C", 0.0))
+            return [p], 0.0
+
+        # determine number of segments. Allow an optional per-state override
+        # so callers/tests can request higher resolution by setting
+        # `state.extra['max_segment']` to a smaller value (e.g. 0.05).
+        try:
+            eff_max_segment = float(getattr(state, "extra", {}).get("max_segment", self.max_segment) or self.max_segment)
+        except Exception:
+            eff_max_segment = float(self.max_segment)
+        # ensure sane lower bound
+        if eff_max_segment <= 0.0:
+            eff_max_segment = float(self.max_segment)
+        n = max(1, int(math.ceil(dist / eff_max_segment)))
+        # compute duration using feed rate. The state's `feed_rate` stores
+        # the raw F value which may be either "per minute" or "per
+        # revolution" depending on the feed mode. Convert to mm/s here.
+        feed = state.feed_rate or 1.0
+        # detect feed-per-revolution mode; FeedMode enum may be stored
+        # under state.extra['feed_mode'] either as Enum or its string value.
+        feed_mode = None
+        try:
+            feed_mode = getattr(state, "extra", {}).get("feed_mode", None)
+        except Exception:
+            feed_mode = None
+        # default: feed interpreted as mm/min
+        effective_feed_mm_per_min = float(feed)
+        try:
+            # try to import enum for a robust comparison; fall back to
+            # string compare if import fails.
+            from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group5_feed_mode import FeedMode
+
+            if feed_mode == FeedMode.FEED_PER_REV or feed_mode == FeedMode.FEED_PER_REV.value:
+                # convert mm/rev -> mm/min using spindle speed (rpm)
+                rpm = float(state.spindle_speed or 1.0)
+                effective_feed_mm_per_min = float(feed) * rpm
+        except Exception:
+            try:
+                if feed_mode == "FEED_PER_REV":
+                    rpm = float(state.spindle_speed or 1.0)
+                    effective_feed_mm_per_min = float(feed) * rpm
+            except Exception:
+                effective_feed_mm_per_min = float(feed)
+
+        # convert mm/min -> mm/s
+        feed_mm_s = effective_feed_mm_per_min / 60.0
+        duration = dist / feed_mm_s if feed_mm_s > 0 else 0.0
+
+        points: List[Point] = []
+        # include explicit start point so joins between segments preserve
+        # exact continuity when plotting consecutive motions
+        points.append(Point(x=start.get("X", 0.0), y=start.get("Y", 0.0), z=start.get("Z", 0.0),
+                             a=start.get("A", 0.0), b=start.get("B", 0.0), c=start.get("C", 0.0)))
+        for i in range(1, n + 1):
+            t = i / n
+            x = start.get("X", 0.0) + (end.get("X", start.get("X", 0.0)) - start.get("X", 0.0)) * t
+            y = start.get("Y", 0.0) + (end.get("Y", start.get("Y", 0.0)) - start.get("Y", 0.0)) * t
+            z = start.get("Z", 0.0) + (end.get("Z", start.get("Z", 0.0)) - start.get("Z", 0.0)) * t
+            a = end.get("A", start.get("A", 0.0))
+            b = end.get("B", start.get("B", 0.0))
+            c = end.get("C", start.get("C", 0.0))
+            points.append(Point(x=x, y=y, z=z, a=a, b=b, c=c))
+        return points, duration
+
+    def _circular_interpolate(self, start: Dict[str, float], end: Dict[str, float], params: Dict[str, float], state: CNCState, cw: bool) -> Tuple[List[Point], float]:
+        # Only implement XY-plane arcs for now (common case). Use I,J center offsets or R radius.
+        sx = start.get("X", 0.0)
+        sy = start.get("Y", 0.0)
+        ex = end.get("X", sx)
+        ey = end.get("Y", sy)
+
+        # center
+        if "I" in params or "J" in params:
+            ix = params.get("I", 0.0)
+            jy = params.get("J", 0.0)
+            cx = sx + ix
+            cy = sy + jy
+        elif "R" in params and params.get("R", 0.0) != 0.0:
+            # derive center from radius — choose the smaller arc by default
+            r = params.get("R", 0.0)
+            # compute midpoint
+            mx = (sx + ex) / 2.0
+            my = (sy + ey) / 2.0
+            dx = ex - sx
+            dy = ey - sy
+            d2 = dx * dx + dy * dy
+            if d2 == 0.0:
+                raise ValueError("Invalid arc with zero chord length")
+            h = math.sqrt(max(0.0, r * r - d2 / 4.0)) / math.sqrt(d2)
+            # two possible centers
+            cx1 = mx - h * dy
+            cy1 = my + h * dx
+            cx2 = mx + h * dy
+            cy2 = my - h * dx
+            # Determine which center yields the requested sweep direction
+            # and prefer the smaller absolute sweep (minor arc) when both
+            # satisfy the direction. Compute sweep angles for both centers
+            # and pick the best candidate.
+            def sweep_for_center(cx_c, cy_c):
+                a0_c = math.atan2(sy - cy_c, sx - cx_c)
+                a1_c = math.atan2(ey - cy_c, ex - cx_c)
+                da_c = a1_c - a0_c
+                # normalize to [-pi, pi]
+                if da_c > math.pi:
+                    da_c -= 2 * math.pi
+                if da_c < -math.pi:
+                    da_c += 2 * math.pi
+                return da_c
+
+            da1 = sweep_for_center(cx1, cy1)
+            da2 = sweep_for_center(cx2, cy2)
+
+            # For cw=True we want a negative sweep (clockwise), for cw=False
+            # we want a positive sweep (counter-clockwise). Prefer the center
+            # that matches the desired sign; if both match or neither match,
+            # pick the one with smaller absolute sweep (minor arc).
+            def matches_cw(da_val, cw_flag):
+                return (da_val < 0) if cw_flag else (da_val > 0)
+
+            if matches_cw(da1, cw) and not matches_cw(da2, cw):
+                cx, cy = cx1, cy1
+            elif matches_cw(da2, cw) and not matches_cw(da1, cw):
+                cx, cy = cx2, cy2
+            else:
+                # both match or both don't — choose the smaller absolute sweep
+                if abs(da1) <= abs(da2):
+                    cx, cy = cx1, cy1
+                else:
+                    cx, cy = cx2, cy2
+        else:
+            # cannot compute arc center
+            raise ValueError("Arc requires I/J or R parameter")
+
+        # compute start and end angles
+        a0 = math.atan2(sy - cy, sx - cx)
+        a1 = math.atan2(ey - cy, ex - cx)
+
+        # Robust sweep normalization:
+        # - normalize difference into (-pi, pi]
+        # - consider candidates da, da +/- 2pi and pick the candidate that
+        #   matches the requested direction (CW -> negative, CCW -> positive)
+        #   and has the smallest absolute magnitude. If no candidate matches
+        #   the requested sign (rare), pick the candidate with the smallest
+        #   absolute value (minor arc).
+        def _normalize_sweep(a_start: float, a_end: float, cw_flag: bool) -> float:
+            raw = a_end - a_start
+            # map to (-pi, pi]
+            da = (raw + math.pi) % (2 * math.pi) - math.pi
+            # consider equivalent representations
+            two_pi = 2 * math.pi
+            candidates = [da, da - two_pi, da + two_pi]
+
+            # desired sign: negative for cw (G02), positive for ccw (G03)
+            if cw_flag:
+                matching = [d for d in candidates if d < 0]
+            else:
+                matching = [d for d in candidates if d > 0]
+
+            if matching:
+                # pick the matching candidate with minimal absolute sweep
+                return min(matching, key=abs)
+            # fallback: choose the minor arc (smallest absolute value)
+            return min(candidates, key=abs)
+
+        da = _normalize_sweep(a0, a1, cw)
+
+        arc_length = abs(da) * math.hypot(sx - cx, sy - cy)
+        # n segments — allow per-state override like in linear interpolation
+        try:
+            eff_max_segment = float(getattr(state, "extra", {}).get("max_segment", self.max_segment) or self.max_segment)
+        except Exception:
+            eff_max_segment = float(self.max_segment)
+        if eff_max_segment <= 0.0:
+            eff_max_segment = float(self.max_segment)
+        n = max(2, int(math.ceil(arc_length / eff_max_segment)))
+        # Ensure a minimum angular resolution so small-radius arcs don't
+        # look like corners. Allow callers to override desired degrees per
+        # segment via state.extra['angle_per_segment_deg'] (smaller -> more
+        # segments). Default to 10 degrees per segment.
+        try:
+            desired_deg = float(getattr(state, "extra", {}).get("angle_per_segment_deg", 10.0) or 10.0)
+        except Exception:
+            desired_deg = 2.0
+        if desired_deg <= 0.0:
+            desired_deg = 2.0
+        min_n_by_angle = max(2, int(math.ceil(abs(da) / math.radians(desired_deg))))
+        if min_n_by_angle > n:
+            n = min_n_by_angle
+
+        # duration using feed rate (see linear routine for comments)
+        feed = state.feed_rate or 1.0
+        feed_mode = None
+        try:
+            feed_mode = getattr(state, "extra", {}).get("feed_mode", None)
+        except Exception:
+            feed_mode = None
+
+        effective_feed_mm_per_min = float(feed)
+        try:
+            from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group5_feed_mode import FeedMode
+            if feed_mode == FeedMode.FEED_PER_REV or feed_mode == FeedMode.FEED_PER_REV.value:
+                rpm = float(state.spindle_speed or 1.0)
+                effective_feed_mm_per_min = float(feed) * rpm
+        except Exception:
+            try:
+                if feed_mode == "FEED_PER_REV":
+                    rpm = float(state.spindle_speed or 1.0)
+                    effective_feed_mm_per_min = float(feed) * rpm
+            except Exception:
+                effective_feed_mm_per_min = float(feed)
+
+        feed_mm_s = effective_feed_mm_per_min / 60.0
+        duration = arc_length / feed_mm_s if feed_mm_s > 0 else 0.0
+
+        points: List[Point] = []
+        # include explicit start point (theta = a0)
+        start_x = cx + math.cos(a0) * math.hypot(sx - cx, sy - cy)
+        start_y = cy + math.sin(a0) * math.hypot(sx - cx, sy - cy)
+        points.append(Point(x=start_x, y=start_y, z=start.get("Z", 0.0),
+                             a=start.get("A", 0.0), b=start.get("B", 0.0), c=start.get("C", 0.0)))
+        for i in range(1, n + 1):
+            t = i / n
+            theta = a0 + da * t
+            x = cx + math.cos(theta) * math.hypot(sx - cx, sy - cy)
+            y = cy + math.sin(theta) * math.hypot(sx - cx, sy - cy)
+            z = start.get("Z", 0.0) + (end.get("Z", start.get("Z", 0.0)) - start.get("Z", 0.0)) * t
+            a = end.get("A", start.get("A", 0.0))
+            b = end.get("B", start.get("B", 0.0))
+            c = end.get("C", start.get("C", 0.0))
+            points.append(Point(x=x, y=y, z=z, a=a, b=b, c=c))
+
+        return points, duration
+
+
+__all__ = ["MotionHandler", "Point"]
diff --git a/src/ncplot7py/domain/handlers/star_machine/__pycache__/star_turn_handler.cpython-313.pyc b/src/ncplot7py/domain/handlers/star_machine/__pycache__/star_turn_handler.cpython-313.pyc
new file mode 100644
index 0000000..b5b06bc
Binary files /dev/null and b/src/ncplot7py/domain/handlers/star_machine/__pycache__/star_turn_handler.cpython-313.pyc differ
diff --git a/src/ncplot7py/domain/handlers/star_machine/star_turn_handler.py b/src/ncplot7py/domain/handlers/star_machine/star_turn_handler.py
index c94c845..496a2fb 100644
--- a/src/ncplot7py/domain/handlers/star_machine/star_turn_handler.py
+++ b/src/ncplot7py/domain/handlers/star_machine/star_turn_handler.py
@@ -1,86 +1,86 @@
-from __future__ import annotations
-
-from typing import Optional, Tuple, List
-
-from ncplot7py.domain.exec_chain import Handler
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-
-
-class StarTurnHandler(Handler):
-    """Handler for Star Turn specific G-codes.
-
-    Implements a small subset of Star Turn macros:
-    - G125: removes Z parameter from the node
-    - G300: reserved (no-op)
-    - G266: macro that maps letter params to internal variable slots
-
-    The G266 implementation pops parameters from the node and stores
-    numeric values in `state.parameters` using the numeric variable
-    indices as string keys (e.g. '531'). This mirrors how other
-    handlers interact with `CNCState` variable storage.
-    """
-
-    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
-        # iterate defensive copy
-        for g_code in set(node.g_code):
-            try:
-                if g_code.upper().startswith("G"):
-                    g_num = int(g_code[1:])
-                else:
-                    continue
-            except Exception:
-                continue
-
-            if g_num == 125:
-                # remove Z parameter if present
-                for key in list(node.command_parameter.keys()):
-                    if key.upper() == "Z":
-                        node.command_parameter.pop(key, None)
-
-            elif g_num == 300:
-                # reserved / no-op for now
-                pass
-
-            elif g_num == 266:
-                # run star macro G266: map letters to variable slots
-                self._run_star_macro_g266(node, state)
-
-        if self.next_handler is not None:
-            return self.next_handler.handle(node, state)
-        return None, None
-
-    def _run_star_macro_g266(self, node: NCCommandNode, state: CNCState) -> None:
-        # mapping from letter param to internal variable index (as string)
-        mapping = {
-            "A": "531",
-            "W": "530",
-            "S": "529",
-            "F": "522",
-            "B": "528",
-            "X": "524",
-            "Z": "525",
-            "T": "523",
-        }
-
-        params = node.command_parameter
-        for letter, var_index in mapping.items():
-            if letter in params:
-                raw = params.pop(letter, None)
-                try:
-                    val = float(raw)
-                except Exception:
-                    # best-effort fallback to 0.0 on parse error
-                    try:
-                        val = float(str(raw))
-                    except Exception:
-                        val = 0.0
-                # store as string key to match VariableHandler conventions
-                try:
-                    state.parameters[var_index] = float(val)
-                except Exception:
-                    # ensure we always set a float
-                    state.parameters[var_index] = float(0.0)
-
-
-__all__ = ["StarTurnHandler"]
+from __future__ import annotations
+
+from typing import Optional, Tuple, List
+
+from ncplot7py.domain.exec_chain import Handler
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+
+
+class StarTurnHandler(Handler):
+    """Handler for Star Turn specific G-codes.
+
+    Implements a small subset of Star Turn macros:
+    - G125: removes Z parameter from the node
+    - G300: reserved (no-op)
+    - G266: macro that maps letter params to internal variable slots
+
+    The G266 implementation pops parameters from the node and stores
+    numeric values in `state.parameters` using the numeric variable
+    indices as string keys (e.g. '531'). This mirrors how other
+    handlers interact with `CNCState` variable storage.
+    """
+
+    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[List], Optional[float]]:
+        # iterate defensive copy
+        for g_code in set(node.g_code):
+            try:
+                if g_code.upper().startswith("G"):
+                    g_num = int(g_code[1:])
+                else:
+                    continue
+            except Exception:
+                continue
+
+            if g_num == 125:
+                # remove Z parameter if present
+                for key in list(node.command_parameter.keys()):
+                    if key.upper() == "Z":
+                        node.command_parameter.pop(key, None)
+
+            elif g_num == 300:
+                # reserved / no-op for now
+                pass
+
+            elif g_num == 266:
+                # run star macro G266: map letters to variable slots
+                self._run_star_macro_g266(node, state)
+
+        if self.next_handler is not None:
+            return self.next_handler.handle(node, state)
+        return None, None
+
+    def _run_star_macro_g266(self, node: NCCommandNode, state: CNCState) -> None:
+        # mapping from letter param to internal variable index (as string)
+        mapping = {
+            "A": "531",
+            "W": "530",
+            "S": "529",
+            "F": "522",
+            "B": "528",
+            "X": "524",
+            "Z": "525",
+            "T": "523",
+        }
+
+        params = node.command_parameter
+        for letter, var_index in mapping.items():
+            if letter in params:
+                raw = params.pop(letter, None)
+                try:
+                    val = float(raw)
+                except Exception:
+                    # best-effort fallback to 0.0 on parse error
+                    try:
+                        val = float(str(raw))
+                    except Exception:
+                        val = 0.0
+                # store as string key to match VariableHandler conventions
+                try:
+                    state.parameters[var_index] = float(val)
+                except Exception:
+                    # ensure we always set a float
+                    state.parameters[var_index] = float(0.0)
+
+
+__all__ = ["StarTurnHandler"]
diff --git a/src/ncplot7py/domain/handlers/variable.py b/src/ncplot7py/domain/handlers/variable.py
index 8d69a2e..f4f512d 100644
--- a/src/ncplot7py/domain/handlers/variable.py
+++ b/src/ncplot7py/domain/handlers/variable.py
@@ -1,227 +1,227 @@
-"""Variable / macro handler for NC commands.
-
-Provides a small, safe expression evaluator for bracketed expressions like
-G[10+#500] or parameters like X[100*#501] and supports simple variable
-assignments in `node.variable_command` of the form `#500=[expr]`.
-
-This is intentionally small and conservative compared to a full macro
-implementation; it should be extended where needed and unit-tested.
-"""
-from __future__ import annotations
-
-import ast
-import math
-import re
-from typing import Any, Dict, Optional, Tuple
-
-from ncplot7py.domain.exec_chain import Handler
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-
-
-def _sin_deg(x: float) -> float:
-    return math.sin(math.radians(x))
-
-
-def _cos_deg(x: float) -> float:
-    return math.cos(math.radians(x))
-
-
-def _tan_deg(x: float) -> float:
-    return math.tan(math.radians(x))
-
-
-def _asin_deg(x: float) -> float:
-    return math.degrees(math.asin(x))
-
-
-def _acos_deg(x: float) -> float:
-    return math.degrees(math.acos(x))
-
-
-def _atan_deg(x: float) -> float:
-    return math.degrees(math.atan(x))
-
-
-_ALLOWED_FUNCS = {
-    "sin": _sin_deg,
-    "cos": _cos_deg,
-    "tan": _tan_deg,
-    "asin": _asin_deg,
-    "acos": _acos_deg,
-    "atan": _atan_deg,
-    "sqrt": math.sqrt,
-    "pi": math.pi,
-}
-
-
-def _safe_eval(expr: str, variables: Dict[str, float]) -> float:
-    """Evaluate a restricted arithmetic expression safely.
-
-    - Supports binary ops +, -, *, /, **, %, // and unary +/-
-    - Allows names that are keys in `variables` or in `_ALLOWED_FUNCS`.
-    """
-    node = ast.parse(expr, mode="eval")
-
-    for n in ast.walk(node):
-        # allow safe node types
-        if isinstance(n, (ast.Expression, ast.BinOp, ast.UnaryOp, ast.Call, ast.Load, ast.Name, ast.Constant, ast.Pow, ast.Sub, ast.Add, ast.Mult, ast.Div, ast.Mod, ast.FloorDiv, ast.UAdd, ast.USub)):
-            continue
-        # allow operator nodes explicitly
-        if isinstance(n, (ast.Add, ast.Sub, ast.Mult, ast.Div, ast.Mod, ast.Pow, ast.FloorDiv, ast.UAdd, ast.USub)):
-            continue
-        raise ValueError(f"Unsafe expression element: {type(n).__name__}")
-
-    # build evaluation context
-    ctx: Dict[str, Any] = {}
-    ctx.update(_ALLOWED_FUNCS)
-    ctx.update(variables)
-
-    # evaluate with empty builtins
-    return float(eval(compile(node, "<expr>", "eval"), {"__builtins__": {}}, ctx))
-
-
-class VariableHandler(Handler):
-    """Handler that decodes variable assignments and bracketed expressions.
-
-    Behavior:
-    - If `node.variable_command` is like `#500=expression` the expression is
-      evaluated and stored in `state.parameters['500']`.
-    - Any bracketed expressions `[ ... ]` in g-code tokens or parameter
-      strings are evaluated and replaced (supports embedded `#NNN` variables).
-    - Delegates to the next handler afterwards.
-    """
-
-    # Match innermost bracket expressions (no nested '[' or ']' inside)
-    BRACKET_RE = re.compile(r"\[([^\[\]]+)\]")
-    VAR_RE = re.compile(r"#(\d+)")
-
-    def __init__(self, next_handler: Optional[Handler] = None):
-        super().__init__(next_handler=next_handler)
-
-    def _build_variable_map(self, state: CNCState) -> Dict[str, float]:
-        # map '#123' -> v123 identifier usable in Python expressions
-        vm: Dict[str, float] = {}
-        for k, v in (state.parameters or {}).items():
-            vm_key = f"v{k}"
-            try:
-                vm[vm_key] = float(v)
-            except Exception:
-                vm[vm_key] = 0.0
-        return vm
-
-    def _replace_vars_in_expr(self, expr: str) -> str:
-        # replace occurrences like #500 -> v500 so Python name lookup works
-        return self.VAR_RE.sub(lambda m: f"v{m.group(1)}", expr)
-
-    def _eval_expression(self, expr: str, state: CNCState) -> float:
-        expr = expr.strip()
-        # allow expressions like 10 or #500+5 or SIN(30)
-        # If the expression contains nested brackets evaluate them first so
-        # expressions like '2*[-1.73]' are reduced to '2*-1.73' before
-        # replacing variables and passing to the safe evaluator.
-        if "[" in expr and "]" in expr:
-            try:
-                expr = self._eval_and_replace_in_string(expr, state)
-            except Exception:
-                # fallback to original expr if replacement fails
-                pass
-        expr_py = self._replace_vars_in_expr(expr)
-        var_map = self._build_variable_map(state)
-        return _safe_eval(expr_py, var_map)
-
-    def _eval_and_replace_in_string(self, s: str, state: CNCState) -> str:
-        """Evaluate bracketed expressions, handling nested brackets.
-
-        The original implementation performed a single regex substitution which
-        failed for nested bracket expressions like '2*[-1.73]' inside an outer
-        '[ ... ]'. We fix this by repeatedly substituting the innermost
-        bracketed expressions until no brackets remain (or a safety limit is
-        reached).
-        """
-
-        def repl(m: re.Match) -> str:
-            inner = m.group(1)
-            val = self._eval_expression(inner, state)
-            # return string form, preserving ints when possible
-            if float(val).is_integer():
-                return str(int(val))
-            return str(val)
-
-        # Iteratively replace bracketed expressions from the inside out.
-        # This handles nested brackets by evaluating inner brackets first.
-        out = s
-        max_iters = 50
-        it = 0
-        while True:
-            if not self.BRACKET_RE.search(out):
-                break
-            new_out = self.BRACKET_RE.sub(repl, out)
-            # if nothing changed, stop to avoid infinite loops
-            if new_out == out:
-                break
-            out = new_out
-            it += 1
-            if it >= max_iters:
-                # stop after a sane limit; return current string
-                break
-        return out
-
-    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[list], Optional[float]]:
-        # 1) variable assignment via node.variable_command (e.g. "#500=[10+5]")
-        vc = node.variable_command
-        if vc:
-            vc = vc.strip()
-            if vc.startswith("#") and "=" in vc:
-                left, right = vc.split("=", 1)
-                var_index = left.strip()[1:]
-                try:
-                    # allow right side to be an expression (possibly bracketed)
-                    expr = right.strip()
-                    # if expression is wrapped in [] remove them
-                    if expr.startswith("[") and expr.endswith("]"):
-                        expr = expr[1:-1]
-                    val = self._eval_expression(expr, state)
-                    state.parameters[var_index] = float(val)
-                except Exception as e:
-                    # silent fallback to 0.0 to preserve current behaviour; in future
-                    # we could raise a domain-specific exception with a log_route.
-                    state.parameters[var_index] = 0.0
-
-        # 2) replace bracketed expressions in command parameters
-        if node.command_parameter:
-            new_params: Dict[str, str] = {}
-            for k, v in node.command_parameter.items():
-                try:
-                    new_v = self._eval_and_replace_in_string(str(v), state)
-                except Exception:
-                    new_v = str(v)
-                new_params[k] = new_v
-            # mutate node parameters so downstream handlers see decoded values
-            try:
-                node._command_parameter = new_params
-            except Exception:
-                # best-effort: if private attr is not present, ignore
-                pass
-
-        # 3) replace bracketed expressions in g-code tokens
-        if node.g_code:
-            new_g_codes = set()
-            for g in set(node.g_code):
-                try:
-                    new_g = self._eval_and_replace_in_string(g, state)
-                except Exception:
-                    new_g = g
-                new_g_codes.add(new_g)
-            try:
-                node._g_code = new_g_codes
-            except Exception:
-                pass
-
-        # Delegate
-        if self.next_handler is not None:
-            return self.next_handler.handle(node, state)
-        return None, None
-
-
-__all__ = ["VariableHandler"]
+"""Variable / macro handler for NC commands.
+
+Provides a small, safe expression evaluator for bracketed expressions like
+G[10+#500] or parameters like X[100*#501] and supports simple variable
+assignments in `node.variable_command` of the form `#500=[expr]`.
+
+This is intentionally small and conservative compared to a full macro
+implementation; it should be extended where needed and unit-tested.
+"""
+from __future__ import annotations
+
+import ast
+import math
+import re
+from typing import Any, Dict, Optional, Tuple
+
+from ncplot7py.domain.exec_chain import Handler
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+
+
+def _sin_deg(x: float) -> float:
+    return math.sin(math.radians(x))
+
+
+def _cos_deg(x: float) -> float:
+    return math.cos(math.radians(x))
+
+
+def _tan_deg(x: float) -> float:
+    return math.tan(math.radians(x))
+
+
+def _asin_deg(x: float) -> float:
+    return math.degrees(math.asin(x))
+
+
+def _acos_deg(x: float) -> float:
+    return math.degrees(math.acos(x))
+
+
+def _atan_deg(x: float) -> float:
+    return math.degrees(math.atan(x))
+
+
+_ALLOWED_FUNCS = {
+    "sin": _sin_deg,
+    "cos": _cos_deg,
+    "tan": _tan_deg,
+    "asin": _asin_deg,
+    "acos": _acos_deg,
+    "atan": _atan_deg,
+    "sqrt": math.sqrt,
+    "pi": math.pi,
+}
+
+
+def _safe_eval(expr: str, variables: Dict[str, float]) -> float:
+    """Evaluate a restricted arithmetic expression safely.
+
+    - Supports binary ops +, -, *, /, **, %, // and unary +/-
+    - Allows names that are keys in `variables` or in `_ALLOWED_FUNCS`.
+    """
+    node = ast.parse(expr, mode="eval")
+
+    for n in ast.walk(node):
+        # allow safe node types
+        if isinstance(n, (ast.Expression, ast.BinOp, ast.UnaryOp, ast.Call, ast.Load, ast.Name, ast.Constant, ast.Pow, ast.Sub, ast.Add, ast.Mult, ast.Div, ast.Mod, ast.FloorDiv, ast.UAdd, ast.USub)):
+            continue
+        # allow operator nodes explicitly
+        if isinstance(n, (ast.Add, ast.Sub, ast.Mult, ast.Div, ast.Mod, ast.Pow, ast.FloorDiv, ast.UAdd, ast.USub)):
+            continue
+        raise ValueError(f"Unsafe expression element: {type(n).__name__}")
+
+    # build evaluation context
+    ctx: Dict[str, Any] = {}
+    ctx.update(_ALLOWED_FUNCS)
+    ctx.update(variables)
+
+    # evaluate with empty builtins
+    return float(eval(compile(node, "<expr>", "eval"), {"__builtins__": {}}, ctx))
+
+
+class VariableHandler(Handler):
+    """Handler that decodes variable assignments and bracketed expressions.
+
+    Behavior:
+    - If `node.variable_command` is like `#500=expression` the expression is
+      evaluated and stored in `state.parameters['500']`.
+    - Any bracketed expressions `[ ... ]` in g-code tokens or parameter
+      strings are evaluated and replaced (supports embedded `#NNN` variables).
+    - Delegates to the next handler afterwards.
+    """
+
+    # Match innermost bracket expressions (no nested '[' or ']' inside)
+    BRACKET_RE = re.compile(r"\[([^\[\]]+)\]")
+    VAR_RE = re.compile(r"#(\d+)")
+
+    def __init__(self, next_handler: Optional[Handler] = None):
+        super().__init__(next_handler=next_handler)
+
+    def _build_variable_map(self, state: CNCState) -> Dict[str, float]:
+        # map '#123' -> v123 identifier usable in Python expressions
+        vm: Dict[str, float] = {}
+        for k, v in (state.parameters or {}).items():
+            vm_key = f"v{k}"
+            try:
+                vm[vm_key] = float(v)
+            except Exception:
+                vm[vm_key] = 0.0
+        return vm
+
+    def _replace_vars_in_expr(self, expr: str) -> str:
+        # replace occurrences like #500 -> v500 so Python name lookup works
+        return self.VAR_RE.sub(lambda m: f"v{m.group(1)}", expr)
+
+    def _eval_expression(self, expr: str, state: CNCState) -> float:
+        expr = expr.strip()
+        # allow expressions like 10 or #500+5 or SIN(30)
+        # If the expression contains nested brackets evaluate them first so
+        # expressions like '2*[-1.73]' are reduced to '2*-1.73' before
+        # replacing variables and passing to the safe evaluator.
+        if "[" in expr and "]" in expr:
+            try:
+                expr = self._eval_and_replace_in_string(expr, state)
+            except Exception:
+                # fallback to original expr if replacement fails
+                pass
+        expr_py = self._replace_vars_in_expr(expr)
+        var_map = self._build_variable_map(state)
+        return _safe_eval(expr_py, var_map)
+
+    def _eval_and_replace_in_string(self, s: str, state: CNCState) -> str:
+        """Evaluate bracketed expressions, handling nested brackets.
+
+        The original implementation performed a single regex substitution which
+        failed for nested bracket expressions like '2*[-1.73]' inside an outer
+        '[ ... ]'. We fix this by repeatedly substituting the innermost
+        bracketed expressions until no brackets remain (or a safety limit is
+        reached).
+        """
+
+        def repl(m: re.Match) -> str:
+            inner = m.group(1)
+            val = self._eval_expression(inner, state)
+            # return string form, preserving ints when possible
+            if float(val).is_integer():
+                return str(int(val))
+            return str(val)
+
+        # Iteratively replace bracketed expressions from the inside out.
+        # This handles nested brackets by evaluating inner brackets first.
+        out = s
+        max_iters = 50
+        it = 0
+        while True:
+            if not self.BRACKET_RE.search(out):
+                break
+            new_out = self.BRACKET_RE.sub(repl, out)
+            # if nothing changed, stop to avoid infinite loops
+            if new_out == out:
+                break
+            out = new_out
+            it += 1
+            if it >= max_iters:
+                # stop after a sane limit; return current string
+                break
+        return out
+
+    def handle(self, node: NCCommandNode, state: CNCState) -> Tuple[Optional[list], Optional[float]]:
+        # 1) variable assignment via node.variable_command (e.g. "#500=[10+5]")
+        vc = node.variable_command
+        if vc:
+            vc = vc.strip()
+            if vc.startswith("#") and "=" in vc:
+                left, right = vc.split("=", 1)
+                var_index = left.strip()[1:]
+                try:
+                    # allow right side to be an expression (possibly bracketed)
+                    expr = right.strip()
+                    # if expression is wrapped in [] remove them
+                    if expr.startswith("[") and expr.endswith("]"):
+                        expr = expr[1:-1]
+                    val = self._eval_expression(expr, state)
+                    state.parameters[var_index] = float(val)
+                except Exception as e:
+                    # silent fallback to 0.0 to preserve current behaviour; in future
+                    # we could raise a domain-specific exception with a log_route.
+                    state.parameters[var_index] = 0.0
+
+        # 2) replace bracketed expressions in command parameters
+        if node.command_parameter:
+            new_params: Dict[str, str] = {}
+            for k, v in node.command_parameter.items():
+                try:
+                    new_v = self._eval_and_replace_in_string(str(v), state)
+                except Exception:
+                    new_v = str(v)
+                new_params[k] = new_v
+            # mutate node parameters so downstream handlers see decoded values
+            try:
+                node._command_parameter = new_params
+            except Exception:
+                # best-effort: if private attr is not present, ignore
+                pass
+
+        # 3) replace bracketed expressions in g-code tokens
+        if node.g_code:
+            new_g_codes = set()
+            for g in set(node.g_code):
+                try:
+                    new_g = self._eval_and_replace_in_string(g, state)
+                except Exception:
+                    new_g = g
+                new_g_codes.add(new_g)
+            try:
+                node._g_code = new_g_codes
+            except Exception:
+                pass
+
+        # Delegate
+        if self.next_handler is not None:
+            return self.next_handler.handle(node, state)
+        return None, None
+
+
+__all__ = ["VariableHandler"]
diff --git a/src/ncplot7py/domain/i18n.py b/src/ncplot7py/domain/i18n.py
index c683755..77a69ce 100644
--- a/src/ncplot7py/domain/i18n.py
+++ b/src/ncplot7py/domain/i18n.py
@@ -1,115 +1,115 @@
-from __future__ import annotations
-
-import xml.etree.ElementTree as ET
-from dataclasses import dataclass
-from functools import lru_cache
-from typing import Dict, Mapping, Optional
-import importlib.resources as resources
-
-
-@dataclass(frozen=True)
-class MessageKey:
-    typ_value: int
-    code: int
-
-    @classmethod
-    def from_parts(cls, typ_value: int, code: int) -> "MessageKey":
-        return cls(typ_value=typ_value, code=code)
-
-    def to_id(self) -> str:
-        # Stable id format used in XML files
-        return f"{self.typ_value}:{self.code}"
-
-
-class MessageCatalog:
-    """Loads localized exception messages from XML files.
-
-    XML format (example):
-      <messages lang="en">
-        <message id="1:1001">Invalid NC code '{value}' at line {line}</message>
-      </messages>
-    Where id is "{typ_value}:{code}".
-    """
-
-    def __init__(self, package: str = "ncplot7py.locales") -> None:
-        self.package = package
-        self._cache: Dict[str, Dict[str, str]] = {}
-
-    def _load_lang(self, lang: str) -> Dict[str, str]:
-        if lang in self._cache:
-            return self._cache[lang]
-        data: Dict[str, str] = {}
-        try:
-            file = resources.files(self.package) / f"{lang}.xml"
-            with resources.as_file(file) as p:
-                tree = ET.parse(p)
-        except FileNotFoundError:
-            self._cache[lang] = data
-            return data
-        root = tree.getroot()
-        for msg in root.findall("message"):
-            mid = msg.get("id")
-            if not mid:
-                continue
-            text = (msg.text or "").strip()
-            data[mid] = text
-        self._cache[lang] = data
-        return data
-
-    def get_template(self, lang: str, key: MessageKey) -> Optional[str]:
-        table = self._load_lang(lang)
-        return table.get(key.to_id())
-
-    def format_exception(self, exc: "ExceptionNodeProtocol", lang: str = "en", *, include_trace: bool = True) -> str:
-        """Format an exception using a localized template when available.
-
-        Fallback order: localized template -> exc.message -> generic fallback.
-        """
-        key = MessageKey.from_parts(int(exc.typ), int(exc.code))
-        template = self.get_template(lang, key)
-        base = template or exc.message or f"{exc.typ.name} (code={exc.code})"
-        try:
-            text = base.format(
-                typ=exc.typ.name,
-                code=int(exc.code),
-                line=int(exc.line),
-                value=getattr(exc, "value", ""),
-            )
-        except Exception:
-            # If formatting failed, just use raw base
-            text = base
-
-        if not include_trace:
-            return text
-
-        # Trace details (file, line, column, context line)
-        parts = [text]
-        loc_bits = []
-        if getattr(exc, "file", ""):
-            loc_bits.append(f"file={exc.file}")
-        if getattr(exc, "line", 0):
-            loc_bits.append(f"line={exc.line}")
-        if getattr(exc, "column", 0):
-            loc_bits.append(f"col={exc.column}")
-        if loc_bits:
-            parts.append(" (" + ", ".join(loc_bits) + ")")
-        ctx = getattr(exc, "context", "")
-        if ctx:
-            parts.append(f"\n  -> {ctx}")
-            col = getattr(exc, "column", 0)
-            if col and col > 0:
-                caret = " " * (col - 1) + "^"
-                parts.append("\n     " + caret)
-        return "".join(parts)
-
-
-# Protocol-like typing to avoid circular imports at runtime
-class ExceptionNodeProtocol:
-    typ: any
-    code: int
-    line: int
-    message: str
-    value: str
-    file: str
-    column: int
-    context: str
+from __future__ import annotations
+
+import xml.etree.ElementTree as ET
+from dataclasses import dataclass
+from functools import lru_cache
+from typing import Dict, Mapping, Optional
+import importlib.resources as resources
+
+
+@dataclass(frozen=True)
+class MessageKey:
+    typ_value: int
+    code: int
+
+    @classmethod
+    def from_parts(cls, typ_value: int, code: int) -> "MessageKey":
+        return cls(typ_value=typ_value, code=code)
+
+    def to_id(self) -> str:
+        # Stable id format used in XML files
+        return f"{self.typ_value}:{self.code}"
+
+
+class MessageCatalog:
+    """Loads localized exception messages from XML files.
+
+    XML format (example):
+      <messages lang="en">
+        <message id="1:1001">Invalid NC code '{value}' at line {line}</message>
+      </messages>
+    Where id is "{typ_value}:{code}".
+    """
+
+    def __init__(self, package: str = "ncplot7py.locales") -> None:
+        self.package = package
+        self._cache: Dict[str, Dict[str, str]] = {}
+
+    def _load_lang(self, lang: str) -> Dict[str, str]:
+        if lang in self._cache:
+            return self._cache[lang]
+        data: Dict[str, str] = {}
+        try:
+            file = resources.files(self.package) / f"{lang}.xml"
+            with resources.as_file(file) as p:
+                tree = ET.parse(p)
+        except FileNotFoundError:
+            self._cache[lang] = data
+            return data
+        root = tree.getroot()
+        for msg in root.findall("message"):
+            mid = msg.get("id")
+            if not mid:
+                continue
+            text = (msg.text or "").strip()
+            data[mid] = text
+        self._cache[lang] = data
+        return data
+
+    def get_template(self, lang: str, key: MessageKey) -> Optional[str]:
+        table = self._load_lang(lang)
+        return table.get(key.to_id())
+
+    def format_exception(self, exc: "ExceptionNodeProtocol", lang: str = "en", *, include_trace: bool = True) -> str:
+        """Format an exception using a localized template when available.
+
+        Fallback order: localized template -> exc.message -> generic fallback.
+        """
+        key = MessageKey.from_parts(int(exc.typ), int(exc.code))
+        template = self.get_template(lang, key)
+        base = template or exc.message or f"{exc.typ.name} (code={exc.code})"
+        try:
+            text = base.format(
+                typ=exc.typ.name,
+                code=int(exc.code),
+                line=int(exc.line),
+                value=getattr(exc, "value", ""),
+            )
+        except Exception:
+            # If formatting failed, just use raw base
+            text = base
+
+        if not include_trace:
+            return text
+
+        # Trace details (file, line, column, context line)
+        parts = [text]
+        loc_bits = []
+        if getattr(exc, "file", ""):
+            loc_bits.append(f"file={exc.file}")
+        if getattr(exc, "line", 0):
+            loc_bits.append(f"line={exc.line}")
+        if getattr(exc, "column", 0):
+            loc_bits.append(f"col={exc.column}")
+        if loc_bits:
+            parts.append(" (" + ", ".join(loc_bits) + ")")
+        ctx = getattr(exc, "context", "")
+        if ctx:
+            parts.append(f"\n  -> {ctx}")
+            col = getattr(exc, "column", 0)
+            if col and col > 0:
+                caret = " " * (col - 1) + "^"
+                parts.append("\n     " + caret)
+        return "".join(parts)
+
+
+# Protocol-like typing to avoid circular imports at runtime
+class ExceptionNodeProtocol:
+    typ: any
+    code: int
+    line: int
+    message: str
+    value: str
+    file: str
+    column: int
+    context: str
diff --git a/src/ncplot7py/domain/models.py b/src/ncplot7py/domain/models.py
index 9d1fa69..6d3dd1b 100644
--- a/src/ncplot7py/domain/models.py
+++ b/src/ncplot7py/domain/models.py
@@ -1,20 +1,20 @@
-
-"""Domain models for ncplot7py.
-
-Keep a lightweight `NCNode` dataclass for simple use-cases and tests,
-and also expose a stronger-typed alias `NCNodeType` that points to the
-full `NCCommandNode` implementation in ``nc_nodes.py``. This preserves
-backwards compatibility while providing a path to the richer node
-implementation.
-"""
-from __future__ import annotations
-
-from dataclasses import dataclass
-from typing import Dict
-
-from ..shared.nc_nodes import NCCommandNode
-
-
-
-
-
+
+"""Domain models for ncplot7py.
+
+Keep a lightweight `NCNode` dataclass for simple use-cases and tests,
+and also expose a stronger-typed alias `NCNodeType` that points to the
+full `NCCommandNode` implementation in ``nc_nodes.py``. This preserves
+backwards compatibility while providing a path to the richer node
+implementation.
+"""
+from __future__ import annotations
+
+from dataclasses import dataclass
+from typing import Dict
+
+from ..shared.nc_nodes import NCCommandNode
+
+
+
+
+
diff --git a/src/ncplot7py/infrastructure/machines/__pycache__/star_canal_syncro.cpython-313.pyc b/src/ncplot7py/infrastructure/machines/__pycache__/star_canal_syncro.cpython-313.pyc
new file mode 100644
index 0000000..1f11daa
Binary files /dev/null and b/src/ncplot7py/infrastructure/machines/__pycache__/star_canal_syncro.cpython-313.pyc differ
diff --git a/src/ncplot7py/infrastructure/machines/__pycache__/stateful_iso_turn_control.cpython-313.pyc b/src/ncplot7py/infrastructure/machines/__pycache__/stateful_iso_turn_control.cpython-313.pyc
new file mode 100644
index 0000000..27b0aea
Binary files /dev/null and b/src/ncplot7py/infrastructure/machines/__pycache__/stateful_iso_turn_control.cpython-313.pyc differ
diff --git a/src/ncplot7py/infrastructure/machines/__pycache__/stateful_star_turn_control.cpython-313.pyc b/src/ncplot7py/infrastructure/machines/__pycache__/stateful_star_turn_control.cpython-313.pyc
new file mode 100644
index 0000000..d33b30a
Binary files /dev/null and b/src/ncplot7py/infrastructure/machines/__pycache__/stateful_star_turn_control.cpython-313.pyc differ
diff --git a/src/ncplot7py/infrastructure/machines/star_canal_syncro.py b/src/ncplot7py/infrastructure/machines/star_canal_syncro.py
index 9ecc126..507ecbd 100644
--- a/src/ncplot7py/infrastructure/machines/star_canal_syncro.py
+++ b/src/ncplot7py/infrastructure/machines/star_canal_syncro.py
@@ -1,236 +1,236 @@
-"""Star-machine specific canal synchronization logic.
-
-This module contains the CanalSynchro class which aligns wait-codes (M
-commands) across multiple canals by adjusting the durations in the
-tool-paths so waiting canals are synchronized. It mirrors the logic used
-by the original implementation but is extracted for clarity and testing.
-"""
-from __future__ import annotations
-
-from typing import List
-
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
-
-
-class CanalSynchro:
-    def __init__(self, tool_paths: list[list[tuple]], nodes: list[list[NCCommandNode]]):
-        self.tool_paths = tool_paths
-        self.nodes = nodes
-        self.max_iterator = 9999
-        if len(tool_paths) == len(nodes):
-            self.count_of_canals = len(tool_paths)
-        else:
-            raise_nc_error(ExceptionTyps.NCCanalStarErrors, 201, message="SELECTED_CANAL_DOES_NOT_EXIST")
-
-    def synchro_points(self):
-        # only implement 2- and 3-canal synchronization cases used by star machines
-        if self.count_of_canals == 2:
-            nodes1: list[NCCommandNode] = self.nodes[0].copy()
-            nodes2: list[NCCommandNode] = self.nodes[1].copy()
-            iterator = -1
-            iterator_wait1 = 0
-            iterator_wait2 = 0
-            time_delta_1 = 0.0
-            time_delta_2 = 0.0
-            while ((iterator_wait1 < len(nodes1) or iterator_wait2 < len(nodes2)) and iterator <= self.max_iterator):
-                iterator += 1
-                wait_c_1 = 0
-                wait_c_2 = 0
-                if iterator_wait1 < len(nodes1):
-                    nc_command_node1: NCCommandNode = nodes1[iterator_wait1]
-                    if 'M' in getattr(nc_command_node1, 'command_parameter', {}):
-                        try:
-                            code = int(nc_command_node1.command_parameter.get('M'))
-                        except Exception:
-                            code = 0
-                        if code < 999 and (code > 199 or code == 40 or code == 82 or code == 41 or code == 83):
-                            wait_c_1 = code
-                if iterator_wait2 < len(nodes2):
-                    nc_command_node2: NCCommandNode = nodes2[iterator_wait2]
-                    if 'M' in getattr(nc_command_node2, 'command_parameter', {}):
-                        try:
-                            code = int(nc_command_node2.command_parameter.get('M'))
-                        except Exception:
-                            code = 0
-                        if code < 999 and (code > 199 or code == 40 or code == 82 or code == 41 or code == 83):
-                            wait_c_2 = code
-                if iterator_wait1 < len(nodes1):
-                    time_delta_1 += float(self.tool_paths[0][iterator_wait1][1])
-                if iterator_wait2 < len(nodes2):
-                    time_delta_2 += float(self.tool_paths[1][iterator_wait2][1])
-
-                if wait_c_1 == 0:
-                    iterator_wait1 += 1
-                if wait_c_2 == 0:
-                    iterator_wait2 += 1
-
-                elif wait_c_1 == wait_c_2 and wait_c_1 != 0:
-                    # equal wait code -> adjust the shorter timing to match
-                    if time_delta_2 > time_delta_1:
-                        self.tool_paths[0][iterator_wait1] = (self.tool_paths[0][iterator_wait1][0], time_delta_2 - time_delta_1)
-                    else:
-                        self.tool_paths[1][iterator_wait2] = (self.tool_paths[1][iterator_wait2][0], time_delta_1 - time_delta_2)
-                    time_delta_2 = 0.0
-                    time_delta_1 = 0.0
-                    iterator_wait1 += 1
-                    iterator_wait2 += 1
-                if wait_c_1 != 0 and wait_c_2 != 0 and wait_c_2 != wait_c_1:
-                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 202, message="WAIT_CODE_NOT_MATCH")
-                if iterator >= self.max_iterator - 5:
-                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 203, message="WAIT_CODE_NOT_MATCH")
-
-        elif self.count_of_canals == 3:
-            nodes1: list[NCCommandNode] = self.nodes[0].copy()
-            nodes2: list[NCCommandNode] = self.nodes[1].copy()
-            nodes3: list[NCCommandNode] = self.nodes[2].copy()
-            iterator = -1
-            iterator_wait1 = 0
-            iterator_wait2 = 0
-            iterator_wait3 = 0
-            time_delta_1 = 0.0
-            time_delta_2 = 0.0
-            time_delta_3 = 0.0
-
-            while ((iterator_wait1 < len(nodes1) or iterator_wait2 < len(nodes2) or iterator_wait3 < len(nodes3)) and iterator <= self.max_iterator + 1):
-                iterator += 1
-                wait_c_1 = [0, 0]
-                wait_c_2 = [0, 0]
-                wait_c_3 = [0, 0]
-
-                if iterator_wait1 < len(nodes1):
-                    nc_command_node1: NCCommandNode = nodes1[iterator_wait1]
-                    if 'M' in getattr(nc_command_node1, 'command_parameter', {}):
-                        try:
-                            code = int(nc_command_node1.command_parameter.get('M'))
-                        except Exception:
-                            code = 0
-                        if code in (83, 82, 40, 41):
-                            wait_c_1 = [code, 12]
-                        if code in (131, 133):
-                            wait_c_1 = [code, 13]
-                        if code < 999 and code > 199:
-                            # P parameter may indicate grouping index
-                            if 'P' in getattr(nc_command_node1, 'command_parameter', {}):
-                                try:
-                                    wait_c_1 = [code, int(nc_command_node1.command_parameter.get('P'))]
-                                except Exception:
-                                    wait_c_1 = [code, 123]
-                            else:
-                                wait_c_1 = [code, 123]
-
-                if iterator_wait2 < len(nodes2):
-                    nc_command_node2: NCCommandNode = nodes2[iterator_wait2]
-                    if 'M' in getattr(nc_command_node2, 'command_parameter', {}):
-                        try:
-                            code = int(nc_command_node2.command_parameter.get('M'))
-                        except Exception:
-                            code = 0
-                        if code in (83, 82, 40, 41):
-                            wait_c_2 = [code, 12]
-                        if code in (131, 133):
-                            wait_c_2 = [code, 13]
-                        if code < 999 and code > 199:
-                            if 'P' in getattr(nc_command_node2, 'command_parameter', {}):
-                                try:
-                                    wait_c_2 = [code, int(nc_command_node2.command_parameter.get('P'))]
-                                except Exception:
-                                    wait_c_2 = [code, 123]
-                            else:
-                                wait_c_2 = [code, 123]
-
-                if iterator_wait3 < len(nodes3):
-                    nc_command_node3: NCCommandNode = nodes3[iterator_wait3]
-                    if 'M' in getattr(nc_command_node3, 'command_parameter', {}):
-                        try:
-                            code = int(nc_command_node3.command_parameter.get('M'))
-                        except Exception:
-                            code = 0
-                        if code in (131, 133):
-                            wait_c_3 = [code, 13]
-                        if code < 999 and code > 199:
-                            if 'P' in getattr(nc_command_node3, 'command_parameter', {}):
-                                try:
-                                    wait_c_3 = [code, int(nc_command_node3.command_parameter.get('P'))]
-                                except Exception:
-                                    wait_c_3 = [code, 123]
-                            else:
-                                wait_c_3 = [code, 123]
-
-                if iterator_wait1 < len(nodes1):
-                    time_delta_1 += float(self.tool_paths[0][iterator_wait1][1])
-                if iterator_wait2 < len(nodes2):
-                    time_delta_2 += float(self.tool_paths[1][iterator_wait2][1])
-                if iterator_wait3 < len(nodes3):
-                    time_delta_3 += float(self.tool_paths[2][iterator_wait3][1])
-
-                # pairwise syncs
-                if wait_c_2[1] == 12 and wait_c_2[0] == wait_c_1[0] and wait_c_2[0] != 0:
-                    if time_delta_2 > time_delta_1:
-                        self.tool_paths[0][iterator_wait1] = (self.tool_paths[0][iterator_wait1][0], time_delta_2 - time_delta_1)
-                    else:
-                        self.tool_paths[1][iterator_wait2] = (self.tool_paths[1][iterator_wait2][0], time_delta_1 - time_delta_2)
-                    time_delta_2 = 0.0
-                    time_delta_1 = 0.0
-                    iterator_wait1 += 1
-                    iterator_wait2 += 1
-                if wait_c_1[1] == 13 and wait_c_3[0] == wait_c_1[0] and wait_c_1[0] != 0:
-                    if time_delta_3 > time_delta_1:
-                        self.tool_paths[0][iterator_wait1] = (self.tool_paths[0][iterator_wait1][0], time_delta_3 - time_delta_1)
-                    else:
-                        self.tool_paths[2][iterator_wait3] = (self.tool_paths[2][iterator_wait3][0], time_delta_1 - time_delta_3)
-                    time_delta_3 = 0.0
-                    time_delta_1 = 0.0
-                    iterator_wait1 += 1
-                    iterator_wait3 += 1
-
-                if wait_c_2[1] == 23 and wait_c_3[0] == wait_c_2[0] and wait_c_2[0] != 0:
-                    if time_delta_3 > time_delta_2:
-                        self.tool_paths[1][iterator_wait2] = (self.tool_paths[1][iterator_wait2][0], time_delta_3 - time_delta_2)
-                    else:
-                        self.tool_paths[2][iterator_wait3] = (self.tool_paths[2][iterator_wait3][0], time_delta_2 - time_delta_3)
-                    time_delta_3 = 0.0
-                    time_delta_2 = 0.0
-                    iterator_wait2 += 1
-                    iterator_wait3 += 1
-
-                # three-way sync
-                if wait_c_1[1] == 123 and (wait_c_1[0] == wait_c_2[0] == wait_c_3[0]) and wait_c_1[0] != 0:
-                    if time_delta_3 > time_delta_1 and time_delta_3 > time_delta_2:
-                        self.tool_paths[0][iterator_wait1] = (self.tool_paths[0][iterator_wait1][0], time_delta_3 - time_delta_1)
-                        self.tool_paths[1][iterator_wait2] = (self.tool_paths[1][iterator_wait2][0], time_delta_3 - time_delta_2)
-                    elif time_delta_2 > time_delta_1 and time_delta_2 > time_delta_3:
-                        self.tool_paths[0][iterator_wait1] = (self.tool_paths[0][iterator_wait1][0], time_delta_2 - time_delta_1)
-                        self.tool_paths[2][iterator_wait3] = (self.tool_paths[2][iterator_wait3][0], time_delta_2 - time_delta_3)
-                    else:
-                        self.tool_paths[1][iterator_wait2] = (self.tool_paths[1][iterator_wait2][0], time_delta_1 - time_delta_2)
-                        self.tool_paths[2][iterator_wait3] = (self.tool_paths[2][iterator_wait3][0], time_delta_1 - time_delta_3)
-                    time_delta_3 = 0.0
-                    time_delta_2 = 0.0
-                    time_delta_1 = 0.0
-                    iterator_wait1 += 1
-                    iterator_wait2 += 1
-                    iterator_wait3 += 1
-
-                if wait_c_1[1] == 0:
-                    iterator_wait1 += 1
-                if wait_c_2[1] == 0:
-                    iterator_wait2 += 1
-                if wait_c_3[1] == 0:
-                    iterator_wait3 += 1
-
-                # mismatch checks
-                if wait_c_2[1] == 12 and wait_c_1[1] == 12 and wait_c_2[0] != wait_c_1[0]:
-                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 204, message="WAIT_CODE_NOT_MATCH")
-                if wait_c_3[1] == 13 and wait_c_1[1] == 13 and wait_c_3[0] != wait_c_1[0]:
-                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 205, message="WAIT_CODE_NOT_MATCH")
-                if wait_c_3[1] == 23 and wait_c_2[1] == 23 and wait_c_3[0] != wait_c_2[0]:
-                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 206, message="WAIT_CODE_NOT_MATCH")
-                if wait_c_3[1] == 123 and wait_c_1[1] == 123 and wait_c_2[1] == 123 and (wait_c_3[0] != wait_c_1[0] or wait_c_3[0] != wait_c_2[0]):
-                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 207, message="WAIT_CODE_NOT_MATCH")
-
-                if iterator >= self.max_iterator - 3:
-                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 208, message="WAIT_CODE_NOT_MATCH")
-
-
-__all__ = ["CanalSynchro"]
+"""Star-machine specific canal synchronization logic.
+
+This module contains the CanalSynchro class which aligns wait-codes (M
+commands) across multiple canals by adjusting the durations in the
+tool-paths so waiting canals are synchronized. It mirrors the logic used
+by the original implementation but is extracted for clarity and testing.
+"""
+from __future__ import annotations
+
+from typing import List
+
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
+
+
+class CanalSynchro:
+    def __init__(self, tool_paths: list[list[tuple]], nodes: list[list[NCCommandNode]]):
+        self.tool_paths = tool_paths
+        self.nodes = nodes
+        self.max_iterator = 9999
+        if len(tool_paths) == len(nodes):
+            self.count_of_canals = len(tool_paths)
+        else:
+            raise_nc_error(ExceptionTyps.NCCanalStarErrors, 201, message="SELECTED_CANAL_DOES_NOT_EXIST")
+
+    def synchro_points(self):
+        # only implement 2- and 3-canal synchronization cases used by star machines
+        if self.count_of_canals == 2:
+            nodes1: list[NCCommandNode] = self.nodes[0].copy()
+            nodes2: list[NCCommandNode] = self.nodes[1].copy()
+            iterator = -1
+            iterator_wait1 = 0
+            iterator_wait2 = 0
+            time_delta_1 = 0.0
+            time_delta_2 = 0.0
+            while ((iterator_wait1 < len(nodes1) or iterator_wait2 < len(nodes2)) and iterator <= self.max_iterator):
+                iterator += 1
+                wait_c_1 = 0
+                wait_c_2 = 0
+                if iterator_wait1 < len(nodes1):
+                    nc_command_node1: NCCommandNode = nodes1[iterator_wait1]
+                    if 'M' in getattr(nc_command_node1, 'command_parameter', {}):
+                        try:
+                            code = int(nc_command_node1.command_parameter.get('M'))
+                        except Exception:
+                            code = 0
+                        if code < 999 and (code > 199 or code == 40 or code == 82 or code == 41 or code == 83):
+                            wait_c_1 = code
+                if iterator_wait2 < len(nodes2):
+                    nc_command_node2: NCCommandNode = nodes2[iterator_wait2]
+                    if 'M' in getattr(nc_command_node2, 'command_parameter', {}):
+                        try:
+                            code = int(nc_command_node2.command_parameter.get('M'))
+                        except Exception:
+                            code = 0
+                        if code < 999 and (code > 199 or code == 40 or code == 82 or code == 41 or code == 83):
+                            wait_c_2 = code
+                if iterator_wait1 < len(nodes1):
+                    time_delta_1 += float(self.tool_paths[0][iterator_wait1][1])
+                if iterator_wait2 < len(nodes2):
+                    time_delta_2 += float(self.tool_paths[1][iterator_wait2][1])
+
+                if wait_c_1 == 0:
+                    iterator_wait1 += 1
+                if wait_c_2 == 0:
+                    iterator_wait2 += 1
+
+                elif wait_c_1 == wait_c_2 and wait_c_1 != 0:
+                    # equal wait code -> adjust the shorter timing to match
+                    if time_delta_2 > time_delta_1:
+                        self.tool_paths[0][iterator_wait1] = (self.tool_paths[0][iterator_wait1][0], time_delta_2 - time_delta_1)
+                    else:
+                        self.tool_paths[1][iterator_wait2] = (self.tool_paths[1][iterator_wait2][0], time_delta_1 - time_delta_2)
+                    time_delta_2 = 0.0
+                    time_delta_1 = 0.0
+                    iterator_wait1 += 1
+                    iterator_wait2 += 1
+                if wait_c_1 != 0 and wait_c_2 != 0 and wait_c_2 != wait_c_1:
+                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 202, message="WAIT_CODE_NOT_MATCH")
+                if iterator >= self.max_iterator - 5:
+                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 203, message="WAIT_CODE_NOT_MATCH")
+
+        elif self.count_of_canals == 3:
+            nodes1: list[NCCommandNode] = self.nodes[0].copy()
+            nodes2: list[NCCommandNode] = self.nodes[1].copy()
+            nodes3: list[NCCommandNode] = self.nodes[2].copy()
+            iterator = -1
+            iterator_wait1 = 0
+            iterator_wait2 = 0
+            iterator_wait3 = 0
+            time_delta_1 = 0.0
+            time_delta_2 = 0.0
+            time_delta_3 = 0.0
+
+            while ((iterator_wait1 < len(nodes1) or iterator_wait2 < len(nodes2) or iterator_wait3 < len(nodes3)) and iterator <= self.max_iterator + 1):
+                iterator += 1
+                wait_c_1 = [0, 0]
+                wait_c_2 = [0, 0]
+                wait_c_3 = [0, 0]
+
+                if iterator_wait1 < len(nodes1):
+                    nc_command_node1: NCCommandNode = nodes1[iterator_wait1]
+                    if 'M' in getattr(nc_command_node1, 'command_parameter', {}):
+                        try:
+                            code = int(nc_command_node1.command_parameter.get('M'))
+                        except Exception:
+                            code = 0
+                        if code in (83, 82, 40, 41):
+                            wait_c_1 = [code, 12]
+                        if code in (131, 133):
+                            wait_c_1 = [code, 13]
+                        if code < 999 and code > 199:
+                            # P parameter may indicate grouping index
+                            if 'P' in getattr(nc_command_node1, 'command_parameter', {}):
+                                try:
+                                    wait_c_1 = [code, int(nc_command_node1.command_parameter.get('P'))]
+                                except Exception:
+                                    wait_c_1 = [code, 123]
+                            else:
+                                wait_c_1 = [code, 123]
+
+                if iterator_wait2 < len(nodes2):
+                    nc_command_node2: NCCommandNode = nodes2[iterator_wait2]
+                    if 'M' in getattr(nc_command_node2, 'command_parameter', {}):
+                        try:
+                            code = int(nc_command_node2.command_parameter.get('M'))
+                        except Exception:
+                            code = 0
+                        if code in (83, 82, 40, 41):
+                            wait_c_2 = [code, 12]
+                        if code in (131, 133):
+                            wait_c_2 = [code, 13]
+                        if code < 999 and code > 199:
+                            if 'P' in getattr(nc_command_node2, 'command_parameter', {}):
+                                try:
+                                    wait_c_2 = [code, int(nc_command_node2.command_parameter.get('P'))]
+                                except Exception:
+                                    wait_c_2 = [code, 123]
+                            else:
+                                wait_c_2 = [code, 123]
+
+                if iterator_wait3 < len(nodes3):
+                    nc_command_node3: NCCommandNode = nodes3[iterator_wait3]
+                    if 'M' in getattr(nc_command_node3, 'command_parameter', {}):
+                        try:
+                            code = int(nc_command_node3.command_parameter.get('M'))
+                        except Exception:
+                            code = 0
+                        if code in (131, 133):
+                            wait_c_3 = [code, 13]
+                        if code < 999 and code > 199:
+                            if 'P' in getattr(nc_command_node3, 'command_parameter', {}):
+                                try:
+                                    wait_c_3 = [code, int(nc_command_node3.command_parameter.get('P'))]
+                                except Exception:
+                                    wait_c_3 = [code, 123]
+                            else:
+                                wait_c_3 = [code, 123]
+
+                if iterator_wait1 < len(nodes1):
+                    time_delta_1 += float(self.tool_paths[0][iterator_wait1][1])
+                if iterator_wait2 < len(nodes2):
+                    time_delta_2 += float(self.tool_paths[1][iterator_wait2][1])
+                if iterator_wait3 < len(nodes3):
+                    time_delta_3 += float(self.tool_paths[2][iterator_wait3][1])
+
+                # pairwise syncs
+                if wait_c_2[1] == 12 and wait_c_2[0] == wait_c_1[0] and wait_c_2[0] != 0:
+                    if time_delta_2 > time_delta_1:
+                        self.tool_paths[0][iterator_wait1] = (self.tool_paths[0][iterator_wait1][0], time_delta_2 - time_delta_1)
+                    else:
+                        self.tool_paths[1][iterator_wait2] = (self.tool_paths[1][iterator_wait2][0], time_delta_1 - time_delta_2)
+                    time_delta_2 = 0.0
+                    time_delta_1 = 0.0
+                    iterator_wait1 += 1
+                    iterator_wait2 += 1
+                if wait_c_1[1] == 13 and wait_c_3[0] == wait_c_1[0] and wait_c_1[0] != 0:
+                    if time_delta_3 > time_delta_1:
+                        self.tool_paths[0][iterator_wait1] = (self.tool_paths[0][iterator_wait1][0], time_delta_3 - time_delta_1)
+                    else:
+                        self.tool_paths[2][iterator_wait3] = (self.tool_paths[2][iterator_wait3][0], time_delta_1 - time_delta_3)
+                    time_delta_3 = 0.0
+                    time_delta_1 = 0.0
+                    iterator_wait1 += 1
+                    iterator_wait3 += 1
+
+                if wait_c_2[1] == 23 and wait_c_3[0] == wait_c_2[0] and wait_c_2[0] != 0:
+                    if time_delta_3 > time_delta_2:
+                        self.tool_paths[1][iterator_wait2] = (self.tool_paths[1][iterator_wait2][0], time_delta_3 - time_delta_2)
+                    else:
+                        self.tool_paths[2][iterator_wait3] = (self.tool_paths[2][iterator_wait3][0], time_delta_2 - time_delta_3)
+                    time_delta_3 = 0.0
+                    time_delta_2 = 0.0
+                    iterator_wait2 += 1
+                    iterator_wait3 += 1
+
+                # three-way sync
+                if wait_c_1[1] == 123 and (wait_c_1[0] == wait_c_2[0] == wait_c_3[0]) and wait_c_1[0] != 0:
+                    if time_delta_3 > time_delta_1 and time_delta_3 > time_delta_2:
+                        self.tool_paths[0][iterator_wait1] = (self.tool_paths[0][iterator_wait1][0], time_delta_3 - time_delta_1)
+                        self.tool_paths[1][iterator_wait2] = (self.tool_paths[1][iterator_wait2][0], time_delta_3 - time_delta_2)
+                    elif time_delta_2 > time_delta_1 and time_delta_2 > time_delta_3:
+                        self.tool_paths[0][iterator_wait1] = (self.tool_paths[0][iterator_wait1][0], time_delta_2 - time_delta_1)
+                        self.tool_paths[2][iterator_wait3] = (self.tool_paths[2][iterator_wait3][0], time_delta_2 - time_delta_3)
+                    else:
+                        self.tool_paths[1][iterator_wait2] = (self.tool_paths[1][iterator_wait2][0], time_delta_1 - time_delta_2)
+                        self.tool_paths[2][iterator_wait3] = (self.tool_paths[2][iterator_wait3][0], time_delta_1 - time_delta_3)
+                    time_delta_3 = 0.0
+                    time_delta_2 = 0.0
+                    time_delta_1 = 0.0
+                    iterator_wait1 += 1
+                    iterator_wait2 += 1
+                    iterator_wait3 += 1
+
+                if wait_c_1[1] == 0:
+                    iterator_wait1 += 1
+                if wait_c_2[1] == 0:
+                    iterator_wait2 += 1
+                if wait_c_3[1] == 0:
+                    iterator_wait3 += 1
+
+                # mismatch checks
+                if wait_c_2[1] == 12 and wait_c_1[1] == 12 and wait_c_2[0] != wait_c_1[0]:
+                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 204, message="WAIT_CODE_NOT_MATCH")
+                if wait_c_3[1] == 13 and wait_c_1[1] == 13 and wait_c_3[0] != wait_c_1[0]:
+                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 205, message="WAIT_CODE_NOT_MATCH")
+                if wait_c_3[1] == 23 and wait_c_2[1] == 23 and wait_c_3[0] != wait_c_2[0]:
+                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 206, message="WAIT_CODE_NOT_MATCH")
+                if wait_c_3[1] == 123 and wait_c_1[1] == 123 and wait_c_2[1] == 123 and (wait_c_3[0] != wait_c_1[0] or wait_c_3[0] != wait_c_2[0]):
+                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 207, message="WAIT_CODE_NOT_MATCH")
+
+                if iterator >= self.max_iterator - 3:
+                    raise_nc_error(ExceptionTyps.NCCanalStarErrors, 208, message="WAIT_CODE_NOT_MATCH")
+
+
+__all__ = ["CanalSynchro"]
diff --git a/src/ncplot7py/infrastructure/machines/stateful_iso_turn_control.py b/src/ncplot7py/infrastructure/machines/stateful_iso_turn_control.py
index 2ec66fb..a43ac3d 100644
--- a/src/ncplot7py/infrastructure/machines/stateful_iso_turn_control.py
+++ b/src/ncplot7py/infrastructure/machines/stateful_iso_turn_control.py
@@ -1,253 +1,253 @@
-"""A Stateful NC control implementation that wires the execution chain.
-
-This control composes the small Chain-of-Responsibility handlers (G50/G28
-handler and MotionHandler) and implements the control interface expected by
-`NCExecutionEngine` (`run_nc_code_list`, `get_tool_path`, etc.).
-"""
-from __future__ import annotations
-
-from typing import Dict, List, Optional, Tuple, Sequence
-import re
-import os
-import logging
-
-from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group16_plane import GCodeGroup16PlaneExecChainLink
-from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group21_polar_co import GCodeGroup21PolarCoExecChainLink
-from ncplot7py.interfaces.BaseNCCanal import NCControl as BaseNCControlInterface
-from ncplot7py.interfaces.BaseNCControl import NCCanal as BaseNCCanalInterface
-
-from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group0_coordinate_set import GCodeGroup0CoordinateSetExecChainLink
-from ncplot7py.domain.handlers.star_machine.star_turn_handler import StarTurnHandler
-from ncplot7py.domain.handlers.motion import MotionHandler
-from ncplot7py.domain.handlers.variable import VariableHandler
-from ncplot7py.domain.handlers.control_flow import ControlFlowHandler
-from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group2_speed_mode import GCodeGroup2SpeedModeExecChainLink
-from ncplot7py.shared.point import Point
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.shared.nc_nodes import NCCommandNode
-
-
-class StatefulIsoTurnCanal(BaseNCCanalInterface):
-    """Per-canal object implementing the `NCCanal` interface.
-
-    The canal owns its own CNCState and a short chain (G50/G28 -> Motion)
-    instance used to interpret NC nodes for that canal.
-    """
-
-    def __init__(self, name: str, init_state: Optional[CNCState] = None):
-        self._name = name
-        self._state = init_state or CNCState()
-        # Chain: variables -> control flow -> group2 (speed mode) -> group0 -> motion
-        motion = MotionHandler()
-        gcode0 = GCodeGroup0CoordinateSetExecChainLink(next_handler=motion)
-        # insert StarTurnHandler between group2 and group0 so machine-specific
-        # Star Turn macros (e.g. G266) are handled before group0 coordinate
-        # adjustments and motion handling.
-        gcode2 = GCodeGroup2SpeedModeExecChainLink(next_handler=None)
-        gcode16 = GCodeGroup16PlaneExecChainLink(next_handler=gcode2)
-
-        gcode21 = GCodeGroup21PolarCoExecChainLink(next_handler=gcode16)
-        # wire star handler so gcode2 -> star -> gcode0
-        star = StarTurnHandler(next_handler=gcode0)
-        # now set gcode2 next to star
-        try:
-            gcode2.next_handler = star
-        except Exception:
-            # fallback: if assignment fails, attempt to create gcode2 with star directly
-            gcode2 = GCodeGroup2SpeedModeExecChainLink(next_handler=star)
-        # Group5 handles feed mode (G98/G99) and sits between group2 and group0
-        # The handler implementation is located in the fanuc_turn_cnc subpackage.
-        try:
-            from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group5_feed_mode import GCodeGroup5FeedModeExecChainLink
-            from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_precheck import GcodePreCheckExecChainLink
-            gcode5 = GCodeGroup5FeedModeExecChainLink(next_handler=gcode21)
-            # insert precheck before group5 so we validate parameters early
-            precheck = GcodePreCheckExecChainLink(next_handler=gcode5)
-            control = ControlFlowHandler(next_handler=precheck)
-        except Exception:
-            # Fallback: if import fails, wire control directly to group2
-            control = ControlFlowHandler(next_handler=gcode2)
-        variable = VariableHandler(next_handler=control)
-        self._chain = variable
-        # keep reference to control handler so we can provide node maps per-run
-        self._control_handler = control
-        self._nodes: List[NCCommandNode] = []
-        self._tool_path: List[Tuple[List[Point], float]] = []
-        # nodes corresponding to each entry in _tool_path (parallel list)
-        self._tool_nodes: List[NCCommandNode] = []
-        # Default this canal to lathe-style behavior where X is interpreted as
-        # diameter when we created the canal without an explicit initial
-        # state. If the caller provided an `init_state` we must not override
-        # their axis unit choices (tests and callers may rely on a specific
-        # axis unit configuration).
-        try:
-            if init_state is None:
-                self._state.set_axis_unit('X', 'diameter')
-        except Exception:
-            # if state doesn't support the helper for any reason, ignore
-            pass
-
-    def get_name(self) -> str:
-        return self._name
-
-    def run_nc_code_list(self, linked_code_list: List[NCCommandNode]) -> None:
-        # convert to list and set up linked pointers so control flow handlers
-        # can jump between nodes by manipulating `_next_ncCode`.
-        self._nodes = list(linked_code_list)
-        # record actual execution order (may differ from _nodes when
-        # control flow handlers jump or loop). This list will contain the
-        # nodes in the order they were processed (including repeated
-        # visits) so callers can map executed program lines to tool path
-        # segments.
-        self._exec_sequence: List[NCCommandNode] = []
-        self._tool_path = []
-
-        # link nodes in forward/backward direction
-        for i in range(len(self._nodes) - 1):
-            self._nodes[i]._next_ncCode = self._nodes[i + 1]
-            self._nodes[i + 1]._before_ncCode = self._nodes[i]
-
-        # build lookup maps for labels and DO/END tokens to help control flow
-        n_map = {}
-        do_map = {}
-        end_map = {}
-        for nd in self._nodes:
-            try:
-                nval = nd.command_parameter.get("N")
-            except Exception:
-                nval = None
-            if nval is not None:
-                try:
-                    key = float(nval)
-                    n_map[key] = nd
-                except Exception:
-                    pass
-            # detect DO/END labels inside loop_command
-            lc = nd.loop_command
-            if lc:
-                # DO labels
-                for m in re.findall(r"DO(\d+)", lc):
-                    do_map.setdefault(m, []).append(nd)
-                for m in re.findall(r"END(\d+)", lc):
-                    end_map.setdefault(m, []).append(nd)
-
-        # provide maps to control handler (if present)
-        try:
-            self._control_handler._n_map = n_map
-            self._control_handler._do_map = do_map
-            self._control_handler._end_map = end_map
-            self._control_handler._nodes = self._nodes
-            # reset any existing loop counters for this run
-            self._control_handler._loop_counters = {}
-        except Exception:
-            pass
-
-        # execute following `_next_ncCode` pointers; bound iterations to
-        # avoid infinite loops. Handlers may update `_next_ncCode` to jump.
-        node = self._nodes[0] if len(self._nodes) > 0 else None
-        max_steps = max(10000, len(self._nodes) * 100)
-        steps = 0
-        logger = logging.getLogger(__name__)
-        while node is not None and steps < max_steps:
-            # record node as executed (captures loops/jumps)
-            try:
-                self._exec_sequence.append(node)
-            except Exception:
-                # defensive: if exec_sequence not writable, ignore
-                pass
-            pts, dur = self._chain.handle(node, self._state)
-            if logger.isEnabledFor(logging.DEBUG):
-                try:
-                    ln = getattr(node, 'nc_code_line_nr', None)
-                    g = getattr(node, 'g_code', None)
-                    logger.debug("node idx=%s line=%s g_code=%s -> pts=%s dur=%s", steps, ln, g, 'Y' if pts is not None else 'N', dur)
-                except Exception:
-                    logger.debug("node idx=%s -> pts=%s dur=%s", steps, 'Y' if pts is not None else 'N', dur)
-            if pts is not None:
-                self._tool_path.append((pts, dur or 0.0))
-                # record the node that produced this tool_path segment so
-                # callers (e.g. NCExecutionEngine) can align programExec
-                # entries with plotted segments.
-                try:
-                    self._tool_nodes.append(node)
-                except Exception:
-                    pass
-            # follow pointer (handlers may have updated it)
-            next_node = getattr(node, "_next_ncCode", None)
-            # if next_node is same as current, break to avoid tight loop
-            if next_node is node:
-                break
-            node = next_node
-            steps += 1
-
-    def get_tool_path(self) -> List[Tuple[List[Point], float]]:
-        return self._tool_path
-
-    def get_exec_nodes(self) -> List[NCCommandNode]:
-        # Prefer the recorded nodes that produced tool_path entries when
-        # available (ensures node/tool_path index alignment). Fall back to
-        # the execution sequence then to the original node list for
-        # compatibility.
-        if hasattr(self, "_tool_nodes") and self._tool_nodes:
-            return self._tool_nodes
-        return getattr(self, "_exec_sequence", self._nodes)
-
-
-class StatefulIsoTurnNCControl(BaseNCControlInterface):
-    """Control managing multiple `StatefulIsoTurnCanal` instances.
-
-    Implements the `NCControl` abstract interface while delegating per-canal
-    execution to `StatefulIsoTurnCanal` objects.
-    """
-
-    def __init__(self, count_of_canals: int = 1, canal_names: Optional[Sequence[str]] = None, init_nc_states: Optional[Sequence[CNCState]] = None) -> None:
-        # create canal objects
-        self.count_of_canals = int(count_of_canals)
-        names = []
-        if canal_names is None:
-            names = [f"C{i+1}" for i in range(self.count_of_canals)]
-        else:
-            if isinstance(canal_names, str):
-                # single name given -> expand
-                names = [canal_names for _ in range(self.count_of_canals)]
-            else:
-                names = list(canal_names)
-
-        init_states = list(init_nc_states) if init_nc_states is not None else [None] * self.count_of_canals
-
-        self._canals: Dict[int, StatefulIsoTurnCanal] = {}
-        for idx in range(self.count_of_canals):
-            init_state = init_states[idx] if idx < len(init_states) else None
-            self._canals[idx + 1] = StatefulIsoTurnCanal(names[idx], init_state)
-
-    def get_canal_name(self, canal: int) -> str:
-        c = self._canals.get(canal)
-        return c.get_name() if c is not None else f"C{canal}"
-
-    def run_nc_code_list(self, linked_code_list: List[NCCommandNode], canal: int) -> None:
-        c = self._canals.get(canal)
-        if c is None:
-            raise IndexError(f"Canal {canal} not configured")
-        c.run_nc_code_list(linked_code_list)
-
-    def get_tool_path(self, canal: int) -> List[Tuple[List[Point], float]]:
-        c = self._canals.get(canal)
-        if c is None:
-            return []
-        return c.get_tool_path()
-
-    def get_exected_nodes(self, canal: int) -> List[NCCommandNode]:
-        c = self._canals.get(canal)
-        if c is None:
-            return []
-        return c.get_exec_nodes()
-
-    def get_canal_count(self) -> int:
-        return self.count_of_canals
-
-    def synchro_points(self, tool_paths, nodes):
-        # placeholder: no synchronization in this simple control
-        return None
-
-
-__all__ = ["StatefulIsoTurnNCControl"]
+"""A Stateful NC control implementation that wires the execution chain.
+
+This control composes the small Chain-of-Responsibility handlers (G50/G28
+handler and MotionHandler) and implements the control interface expected by
+`NCExecutionEngine` (`run_nc_code_list`, `get_tool_path`, etc.).
+"""
+from __future__ import annotations
+
+from typing import Dict, List, Optional, Tuple, Sequence
+import re
+import os
+import logging
+
+from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group16_plane import GCodeGroup16PlaneExecChainLink
+from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group21_polar_co import GCodeGroup21PolarCoExecChainLink
+from ncplot7py.interfaces.BaseNCCanal import NCControl as BaseNCControlInterface
+from ncplot7py.interfaces.BaseNCControl import NCCanal as BaseNCCanalInterface
+
+from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group0_coordinate_set import GCodeGroup0CoordinateSetExecChainLink
+from ncplot7py.domain.handlers.star_machine.star_turn_handler import StarTurnHandler
+from ncplot7py.domain.handlers.motion import MotionHandler
+from ncplot7py.domain.handlers.variable import VariableHandler
+from ncplot7py.domain.handlers.control_flow import ControlFlowHandler
+from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group2_speed_mode import GCodeGroup2SpeedModeExecChainLink
+from ncplot7py.shared.point import Point
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.shared.nc_nodes import NCCommandNode
+
+
+class StatefulIsoTurnCanal(BaseNCCanalInterface):
+    """Per-canal object implementing the `NCCanal` interface.
+
+    The canal owns its own CNCState and a short chain (G50/G28 -> Motion)
+    instance used to interpret NC nodes for that canal.
+    """
+
+    def __init__(self, name: str, init_state: Optional[CNCState] = None):
+        self._name = name
+        self._state = init_state or CNCState()
+        # Chain: variables -> control flow -> group2 (speed mode) -> group0 -> motion
+        motion = MotionHandler()
+        gcode0 = GCodeGroup0CoordinateSetExecChainLink(next_handler=motion)
+        # insert StarTurnHandler between group2 and group0 so machine-specific
+        # Star Turn macros (e.g. G266) are handled before group0 coordinate
+        # adjustments and motion handling.
+        gcode2 = GCodeGroup2SpeedModeExecChainLink(next_handler=None)
+        gcode16 = GCodeGroup16PlaneExecChainLink(next_handler=gcode2)
+
+        gcode21 = GCodeGroup21PolarCoExecChainLink(next_handler=gcode16)
+        # wire star handler so gcode2 -> star -> gcode0
+        star = StarTurnHandler(next_handler=gcode0)
+        # now set gcode2 next to star
+        try:
+            gcode2.next_handler = star
+        except Exception:
+            # fallback: if assignment fails, attempt to create gcode2 with star directly
+            gcode2 = GCodeGroup2SpeedModeExecChainLink(next_handler=star)
+        # Group5 handles feed mode (G98/G99) and sits between group2 and group0
+        # The handler implementation is located in the fanuc_turn_cnc subpackage.
+        try:
+            from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group5_feed_mode import GCodeGroup5FeedModeExecChainLink
+            from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_precheck import GcodePreCheckExecChainLink
+            gcode5 = GCodeGroup5FeedModeExecChainLink(next_handler=gcode21)
+            # insert precheck before group5 so we validate parameters early
+            precheck = GcodePreCheckExecChainLink(next_handler=gcode5)
+            control = ControlFlowHandler(next_handler=precheck)
+        except Exception:
+            # Fallback: if import fails, wire control directly to group2
+            control = ControlFlowHandler(next_handler=gcode2)
+        variable = VariableHandler(next_handler=control)
+        self._chain = variable
+        # keep reference to control handler so we can provide node maps per-run
+        self._control_handler = control
+        self._nodes: List[NCCommandNode] = []
+        self._tool_path: List[Tuple[List[Point], float]] = []
+        # nodes corresponding to each entry in _tool_path (parallel list)
+        self._tool_nodes: List[NCCommandNode] = []
+        # Default this canal to lathe-style behavior where X is interpreted as
+        # diameter when we created the canal without an explicit initial
+        # state. If the caller provided an `init_state` we must not override
+        # their axis unit choices (tests and callers may rely on a specific
+        # axis unit configuration).
+        try:
+            if init_state is None:
+                self._state.set_axis_unit('X', 'diameter')
+        except Exception:
+            # if state doesn't support the helper for any reason, ignore
+            pass
+
+    def get_name(self) -> str:
+        return self._name
+
+    def run_nc_code_list(self, linked_code_list: List[NCCommandNode]) -> None:
+        # convert to list and set up linked pointers so control flow handlers
+        # can jump between nodes by manipulating `_next_ncCode`.
+        self._nodes = list(linked_code_list)
+        # record actual execution order (may differ from _nodes when
+        # control flow handlers jump or loop). This list will contain the
+        # nodes in the order they were processed (including repeated
+        # visits) so callers can map executed program lines to tool path
+        # segments.
+        self._exec_sequence: List[NCCommandNode] = []
+        self._tool_path = []
+
+        # link nodes in forward/backward direction
+        for i in range(len(self._nodes) - 1):
+            self._nodes[i]._next_ncCode = self._nodes[i + 1]
+            self._nodes[i + 1]._before_ncCode = self._nodes[i]
+
+        # build lookup maps for labels and DO/END tokens to help control flow
+        n_map = {}
+        do_map = {}
+        end_map = {}
+        for nd in self._nodes:
+            try:
+                nval = nd.command_parameter.get("N")
+            except Exception:
+                nval = None
+            if nval is not None:
+                try:
+                    key = float(nval)
+                    n_map[key] = nd
+                except Exception:
+                    pass
+            # detect DO/END labels inside loop_command
+            lc = nd.loop_command
+            if lc:
+                # DO labels
+                for m in re.findall(r"DO(\d+)", lc):
+                    do_map.setdefault(m, []).append(nd)
+                for m in re.findall(r"END(\d+)", lc):
+                    end_map.setdefault(m, []).append(nd)
+
+        # provide maps to control handler (if present)
+        try:
+            self._control_handler._n_map = n_map
+            self._control_handler._do_map = do_map
+            self._control_handler._end_map = end_map
+            self._control_handler._nodes = self._nodes
+            # reset any existing loop counters for this run
+            self._control_handler._loop_counters = {}
+        except Exception:
+            pass
+
+        # execute following `_next_ncCode` pointers; bound iterations to
+        # avoid infinite loops. Handlers may update `_next_ncCode` to jump.
+        node = self._nodes[0] if len(self._nodes) > 0 else None
+        max_steps = max(10000, len(self._nodes) * 100)
+        steps = 0
+        logger = logging.getLogger(__name__)
+        while node is not None and steps < max_steps:
+            # record node as executed (captures loops/jumps)
+            try:
+                self._exec_sequence.append(node)
+            except Exception:
+                # defensive: if exec_sequence not writable, ignore
+                pass
+            pts, dur = self._chain.handle(node, self._state)
+            if logger.isEnabledFor(logging.DEBUG):
+                try:
+                    ln = getattr(node, 'nc_code_line_nr', None)
+                    g = getattr(node, 'g_code', None)
+                    logger.debug("node idx=%s line=%s g_code=%s -> pts=%s dur=%s", steps, ln, g, 'Y' if pts is not None else 'N', dur)
+                except Exception:
+                    logger.debug("node idx=%s -> pts=%s dur=%s", steps, 'Y' if pts is not None else 'N', dur)
+            if pts is not None:
+                self._tool_path.append((pts, dur or 0.0))
+                # record the node that produced this tool_path segment so
+                # callers (e.g. NCExecutionEngine) can align programExec
+                # entries with plotted segments.
+                try:
+                    self._tool_nodes.append(node)
+                except Exception:
+                    pass
+            # follow pointer (handlers may have updated it)
+            next_node = getattr(node, "_next_ncCode", None)
+            # if next_node is same as current, break to avoid tight loop
+            if next_node is node:
+                break
+            node = next_node
+            steps += 1
+
+    def get_tool_path(self) -> List[Tuple[List[Point], float]]:
+        return self._tool_path
+
+    def get_exec_nodes(self) -> List[NCCommandNode]:
+        # Prefer the recorded nodes that produced tool_path entries when
+        # available (ensures node/tool_path index alignment). Fall back to
+        # the execution sequence then to the original node list for
+        # compatibility.
+        if hasattr(self, "_tool_nodes") and self._tool_nodes:
+            return self._tool_nodes
+        return getattr(self, "_exec_sequence", self._nodes)
+
+
+class StatefulIsoTurnNCControl(BaseNCControlInterface):
+    """Control managing multiple `StatefulIsoTurnCanal` instances.
+
+    Implements the `NCControl` abstract interface while delegating per-canal
+    execution to `StatefulIsoTurnCanal` objects.
+    """
+
+    def __init__(self, count_of_canals: int = 1, canal_names: Optional[Sequence[str]] = None, init_nc_states: Optional[Sequence[CNCState]] = None) -> None:
+        # create canal objects
+        self.count_of_canals = int(count_of_canals)
+        names = []
+        if canal_names is None:
+            names = [f"C{i+1}" for i in range(self.count_of_canals)]
+        else:
+            if isinstance(canal_names, str):
+                # single name given -> expand
+                names = [canal_names for _ in range(self.count_of_canals)]
+            else:
+                names = list(canal_names)
+
+        init_states = list(init_nc_states) if init_nc_states is not None else [None] * self.count_of_canals
+
+        self._canals: Dict[int, StatefulIsoTurnCanal] = {}
+        for idx in range(self.count_of_canals):
+            init_state = init_states[idx] if idx < len(init_states) else None
+            self._canals[idx + 1] = StatefulIsoTurnCanal(names[idx], init_state)
+
+    def get_canal_name(self, canal: int) -> str:
+        c = self._canals.get(canal)
+        return c.get_name() if c is not None else f"C{canal}"
+
+    def run_nc_code_list(self, linked_code_list: List[NCCommandNode], canal: int) -> None:
+        c = self._canals.get(canal)
+        if c is None:
+            raise IndexError(f"Canal {canal} not configured")
+        c.run_nc_code_list(linked_code_list)
+
+    def get_tool_path(self, canal: int) -> List[Tuple[List[Point], float]]:
+        c = self._canals.get(canal)
+        if c is None:
+            return []
+        return c.get_tool_path()
+
+    def get_exected_nodes(self, canal: int) -> List[NCCommandNode]:
+        c = self._canals.get(canal)
+        if c is None:
+            return []
+        return c.get_exec_nodes()
+
+    def get_canal_count(self) -> int:
+        return self.count_of_canals
+
+    def synchro_points(self, tool_paths, nodes):
+        # placeholder: no synchronization in this simple control
+        return None
+
+
+__all__ = ["StatefulIsoTurnNCControl"]
diff --git a/src/ncplot7py/infrastructure/machines/stateful_star_turn_control.py b/src/ncplot7py/infrastructure/machines/stateful_star_turn_control.py
index a4719b0..bb2c027 100644
--- a/src/ncplot7py/infrastructure/machines/stateful_star_turn_control.py
+++ b/src/ncplot7py/infrastructure/machines/stateful_star_turn_control.py
@@ -1,274 +1,274 @@
-"""A Stateful NC control implementation that wires the execution chain.
-
-This control composes the small Chain-of-Responsibility handlers (G50/G28
-handler and MotionHandler) and implements the control interface expected by
-`NCExecutionEngine` (`run_nc_code_list`, `get_tool_path`, etc.).
-"""
-from __future__ import annotations
-
-from typing import Dict, List, Optional, Tuple, Sequence
-import re
-import os
-import logging
-
-from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group16_plane import GCodeGroup16PlaneExecChainLink
-from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group21_polar_co import GCodeGroup21PolarCoExecChainLink
-from ncplot7py.interfaces.BaseNCCanal import NCControl as BaseNCControlInterface
-from ncplot7py.interfaces.BaseNCControl import NCCanal as BaseNCCanalInterface
-
-from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group0_coordinate_set import GCodeGroup0CoordinateSetExecChainLink
-from ncplot7py.domain.handlers.star_machine.star_turn_handler import StarTurnHandler
-from ncplot7py.domain.handlers.motion import MotionHandler
-from ncplot7py.domain.handlers.variable import VariableHandler
-from ncplot7py.domain.handlers.control_flow import ControlFlowHandler
-from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group2_speed_mode import GCodeGroup2SpeedModeExecChainLink
-from ncplot7py.shared.point import Point
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
-from ncplot7py.infrastructure.machines.star_canal_syncro import CanalSynchro
-
-
-class StatefulIsoTurnCanal(BaseNCCanalInterface):
-    """Per-canal object implementing the `NCCanal` interface.
-
-    The canal owns its own CNCState and a short chain (G50/G28 -> Motion)
-    instance used to interpret NC nodes for that canal.
-    """
-
-    def __init__(self, name: str, init_state: Optional[CNCState] = None):
-        self._name = name
-        self._state = init_state or CNCState()
-        # Chain: variables -> control flow -> group2 (speed mode) -> group0 -> motion
-        motion = MotionHandler()
-        # insert a small ModalHandler between group0 and motion so block
-        # parameters F and S are stored into the modal state before motion
-        # handling. This keeps modal updates centralized.
-        try:
-            from ncplot7py.domain.handlers.modal import ModalHandler
-            modal = ModalHandler(next_handler=motion)
-            gcode0 = GCodeGroup0CoordinateSetExecChainLink(next_handler=modal)
-        except Exception:
-            # fallback: if import fails for any reason, wire gcode0 directly
-            # to motion to preserve previous behaviour.
-            gcode0 = GCodeGroup0CoordinateSetExecChainLink(next_handler=motion)
-        # insert StarTurnHandler between group2 and group0 so machine-specific
-        # Star Turn macros (e.g. G266) are handled before group0 coordinate
-        # adjustments and motion handling.
-        gcode2 = GCodeGroup2SpeedModeExecChainLink(next_handler=None)
-        gcode16 = GCodeGroup16PlaneExecChainLink(next_handler=gcode2)
-
-        gcode21 = GCodeGroup21PolarCoExecChainLink(next_handler=gcode16)
-        # wire star handler so gcode2 -> star -> gcode0
-        star = StarTurnHandler(next_handler=gcode0)
-        # now set gcode2 next to star
-        try:
-            gcode2.next_handler = star
-        except Exception:
-            # fallback: if assignment fails, attempt to create gcode2 with star directly
-            gcode2 = GCodeGroup2SpeedModeExecChainLink(next_handler=star)
-        # Group5 handles feed mode (G98/G99) and sits between group2 and group0
-        # The handler implementation is located in the fanuc_turn_cnc subpackage.
-        try:
-            from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group5_feed_mode import GCodeGroup5FeedModeExecChainLink
-            from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_precheck import GcodePreCheckExecChainLink
-            gcode5 = GCodeGroup5FeedModeExecChainLink(next_handler=gcode21)
-            # insert precheck before group5 so we validate parameters early
-            precheck = GcodePreCheckExecChainLink(next_handler=gcode5)
-            control = ControlFlowHandler(next_handler=precheck)
-        except Exception:
-            # Fallback: if import fails, wire control directly to group2
-            control = ControlFlowHandler(next_handler=gcode2)
-        variable = VariableHandler(next_handler=control)
-        self._chain = variable
-        # keep reference to control handler so we can provide node maps per-run
-        self._control_handler = control
-        self._nodes: List[NCCommandNode] = []
-        self._tool_path: List[Tuple[List[Point], float]] = []
-        # nodes corresponding to each entry in _tool_path (parallel list)
-        self._tool_nodes: List[NCCommandNode] = []
-        # Default this canal to lathe-style behavior where X is interpreted as
-        # diameter when we created the canal without an explicit initial
-        # state. If the caller provided an `init_state` we must not override
-        # their axis unit choices (tests and callers may rely on a specific
-        # axis unit configuration).
-        try:
-            if init_state is None:
-                self._state.set_axis_unit('X', 'diameter')
-        except Exception:
-            # if state doesn't support the helper for any reason, ignore
-            pass
-
-    def get_name(self) -> str:
-        return self._name
-
-    def run_nc_code_list(self, linked_code_list: List[NCCommandNode]) -> None:
-        # convert to list and set up linked pointers so control flow handlers
-        # can jump between nodes by manipulating `_next_ncCode`.
-        self._nodes = list(linked_code_list)
-        # record actual execution order (may differ from _nodes when
-        # control flow handlers jump or loop). This list will contain the
-        # nodes in the order they were processed (including repeated
-        # visits) so callers can map executed program lines to tool path
-        # segments.
-        self._exec_sequence: List[NCCommandNode] = []
-        self._tool_path = []
-
-        # link nodes in forward/backward direction
-        for i in range(len(self._nodes) - 1):
-            self._nodes[i]._next_ncCode = self._nodes[i + 1]
-            self._nodes[i + 1]._before_ncCode = self._nodes[i]
-
-        # build lookup maps for labels and DO/END tokens to help control flow
-        n_map = {}
-        do_map = {}
-        end_map = {}
-        for nd in self._nodes:
-            try:
-                nval = nd.command_parameter.get("N")
-            except Exception:
-                nval = None
-            if nval is not None:
-                try:
-                    key = float(nval)
-                    n_map[key] = nd
-                except Exception:
-                    pass
-            # detect DO/END labels inside loop_command
-            lc = nd.loop_command
-            if lc:
-                # DO labels
-                for m in re.findall(r"DO(\d+)", lc):
-                    do_map.setdefault(m, []).append(nd)
-                for m in re.findall(r"END(\d+)", lc):
-                    end_map.setdefault(m, []).append(nd)
-
-        # provide maps to control handler (if present)
-        try:
-            self._control_handler._n_map = n_map
-            self._control_handler._do_map = do_map
-            self._control_handler._end_map = end_map
-            self._control_handler._nodes = self._nodes
-            # reset any existing loop counters for this run
-            self._control_handler._loop_counters = {}
-        except Exception:
-            pass
-
-        # execute following `_next_ncCode` pointers; bound iterations to
-        # avoid infinite loops. Handlers may update `_next_ncCode` to jump.
-        node = self._nodes[0] if len(self._nodes) > 0 else None
-        max_steps = max(10000, len(self._nodes) * 100)
-        steps = 0
-        logger = logging.getLogger(__name__)
-        while node is not None and steps < max_steps:
-            # record node as executed (captures loops/jumps)
-            try:
-                self._exec_sequence.append(node)
-            except Exception:
-                # defensive: if exec_sequence not writable, ignore
-                pass
-            pts, dur = self._chain.handle(node, self._state)
-            if logger.isEnabledFor(logging.DEBUG):
-                try:
-                    ln = getattr(node, 'nc_code_line_nr', None)
-                    g = getattr(node, 'g_code', None)
-                    logger.debug("node idx=%s line=%s g_code=%s -> pts=%s dur=%s", steps, ln, g, 'Y' if pts is not None else 'N', dur)
-                except Exception:
-                    logger.debug("node idx=%s -> pts=%s dur=%s", steps, 'Y' if pts is not None else 'N', dur)
-            if pts is not None:
-                self._tool_path.append((pts, dur or 0.0))
-                # record the node that produced this tool_path segment so
-                # callers (e.g. synchronization) can align nodes with
-                # tool_path indices.
-                try:
-                    self._tool_nodes.append(node)
-                except Exception:
-                    pass
-            # follow pointer (handlers may have updated it)
-            next_node = getattr(node, "_next_ncCode", None)
-            # if next_node is same as current, break to avoid tight loop
-            if next_node is node:
-                break
-            node = next_node
-            steps += 1
-
-    def get_tool_path(self) -> List[Tuple[List[Point], float]]:
-        return self._tool_path
-
-    def get_exec_nodes(self) -> List[NCCommandNode]:
-        # Prefer the recorded nodes that produced tool_path entries when
-        # available (ensures node/tool_path index alignment). Fall back to
-        # the execution sequence then to the original node list for
-        # compatibility.
-        if hasattr(self, "_tool_nodes") and self._tool_nodes:
-            return self._tool_nodes
-        return getattr(self, "_exec_sequence", self._nodes)
-
-
-class StatefulIsoTurnNCControl(BaseNCControlInterface):
-    """Control managing multiple `StatefulIsoTurnCanal` instances.
-
-    Implements the `NCControl` abstract interface while delegating per-canal
-    execution to `StatefulIsoTurnCanal` objects.
-    """
-
-    def __init__(self, count_of_canals: int = 1, canal_names: Optional[Sequence[str]] = None, init_nc_states: Optional[Sequence[CNCState]] = None) -> None:
-        # create canal objects
-        self.count_of_canals = int(count_of_canals)
-        names = []
-        if canal_names is None:
-            names = [f"C{i+1}" for i in range(self.count_of_canals)]
-        else:
-            if isinstance(canal_names, str):
-                # single name given -> expand
-                names = [canal_names for _ in range(self.count_of_canals)]
-            else:
-                names = list(canal_names)
-
-        init_states = list(init_nc_states) if init_nc_states is not None else [None] * self.count_of_canals
-
-        self._canals: Dict[int, StatefulIsoTurnCanal] = {}
-        for idx in range(self.count_of_canals):
-            init_state = init_states[idx] if idx < len(init_states) else None
-            self._canals[idx + 1] = StatefulIsoTurnCanal(names[idx], init_state)
-
-    def get_canal_name(self, canal: int) -> str:
-        c = self._canals.get(canal)
-        return c.get_name() if c is not None else f"C{canal}"
-
-    def run_nc_code_list(self, linked_code_list: List[NCCommandNode], canal: int) -> None:
-        c = self._canals.get(canal)
-        if c is None:
-            raise IndexError(f"Canal {canal} not configured")
-        c.run_nc_code_list(linked_code_list)
-
-    def get_tool_path(self, canal: int) -> List[Tuple[List[Point], float]]:
-        c = self._canals.get(canal)
-        if c is None:
-            return []
-        return c.get_tool_path()
-
-    def get_exected_nodes(self, canal: int) -> List[NCCommandNode]:
-        c = self._canals.get(canal)
-        if c is None:
-            return []
-        return c.get_exec_nodes()
-
-    def get_canal_count(self) -> int:
-        return self.count_of_canals
-
-    def synchro_points(self, tool_paths, nodes):
-        # perform synchronization of tool path timing across canals
-        # tool_paths: list of list of tuples (points_list, duration)
-        # nodes: list of list of NCCommandNode executed for each canal
-        # run synchronization handler
-        try:
-            syn = CanalSynchro(tool_paths, nodes)  # delegate to the star-machine specific synchronisation helper
-            syn.synchro_points()
-        except Exception:
-            # let domain exceptions propagate; unknown exceptions bubble up too
-            raise
-        return None
-
-
-__all__ = ["StatefulIsoTurnNCControl"]
+"""A Stateful NC control implementation that wires the execution chain.
+
+This control composes the small Chain-of-Responsibility handlers (G50/G28
+handler and MotionHandler) and implements the control interface expected by
+`NCExecutionEngine` (`run_nc_code_list`, `get_tool_path`, etc.).
+"""
+from __future__ import annotations
+
+from typing import Dict, List, Optional, Tuple, Sequence
+import re
+import os
+import logging
+
+from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group16_plane import GCodeGroup16PlaneExecChainLink
+from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group21_polar_co import GCodeGroup21PolarCoExecChainLink
+from ncplot7py.interfaces.BaseNCCanal import NCControl as BaseNCControlInterface
+from ncplot7py.interfaces.BaseNCControl import NCCanal as BaseNCCanalInterface
+
+from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group0_coordinate_set import GCodeGroup0CoordinateSetExecChainLink
+from ncplot7py.domain.handlers.star_machine.star_turn_handler import StarTurnHandler
+from ncplot7py.domain.handlers.motion import MotionHandler
+from ncplot7py.domain.handlers.variable import VariableHandler
+from ncplot7py.domain.handlers.control_flow import ControlFlowHandler
+from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group2_speed_mode import GCodeGroup2SpeedModeExecChainLink
+from ncplot7py.shared.point import Point
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.exceptions import raise_nc_error, ExceptionTyps
+from ncplot7py.infrastructure.machines.star_canal_syncro import CanalSynchro
+
+
+class StatefulIsoTurnCanal(BaseNCCanalInterface):
+    """Per-canal object implementing the `NCCanal` interface.
+
+    The canal owns its own CNCState and a short chain (G50/G28 -> Motion)
+    instance used to interpret NC nodes for that canal.
+    """
+
+    def __init__(self, name: str, init_state: Optional[CNCState] = None):
+        self._name = name
+        self._state = init_state or CNCState()
+        # Chain: variables -> control flow -> group2 (speed mode) -> group0 -> motion
+        motion = MotionHandler()
+        # insert a small ModalHandler between group0 and motion so block
+        # parameters F and S are stored into the modal state before motion
+        # handling. This keeps modal updates centralized.
+        try:
+            from ncplot7py.domain.handlers.modal import ModalHandler
+            modal = ModalHandler(next_handler=motion)
+            gcode0 = GCodeGroup0CoordinateSetExecChainLink(next_handler=modal)
+        except Exception:
+            # fallback: if import fails for any reason, wire gcode0 directly
+            # to motion to preserve previous behaviour.
+            gcode0 = GCodeGroup0CoordinateSetExecChainLink(next_handler=motion)
+        # insert StarTurnHandler between group2 and group0 so machine-specific
+        # Star Turn macros (e.g. G266) are handled before group0 coordinate
+        # adjustments and motion handling.
+        gcode2 = GCodeGroup2SpeedModeExecChainLink(next_handler=None)
+        gcode16 = GCodeGroup16PlaneExecChainLink(next_handler=gcode2)
+
+        gcode21 = GCodeGroup21PolarCoExecChainLink(next_handler=gcode16)
+        # wire star handler so gcode2 -> star -> gcode0
+        star = StarTurnHandler(next_handler=gcode0)
+        # now set gcode2 next to star
+        try:
+            gcode2.next_handler = star
+        except Exception:
+            # fallback: if assignment fails, attempt to create gcode2 with star directly
+            gcode2 = GCodeGroup2SpeedModeExecChainLink(next_handler=star)
+        # Group5 handles feed mode (G98/G99) and sits between group2 and group0
+        # The handler implementation is located in the fanuc_turn_cnc subpackage.
+        try:
+            from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group5_feed_mode import GCodeGroup5FeedModeExecChainLink
+            from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_precheck import GcodePreCheckExecChainLink
+            gcode5 = GCodeGroup5FeedModeExecChainLink(next_handler=gcode21)
+            # insert precheck before group5 so we validate parameters early
+            precheck = GcodePreCheckExecChainLink(next_handler=gcode5)
+            control = ControlFlowHandler(next_handler=precheck)
+        except Exception:
+            # Fallback: if import fails, wire control directly to group2
+            control = ControlFlowHandler(next_handler=gcode2)
+        variable = VariableHandler(next_handler=control)
+        self._chain = variable
+        # keep reference to control handler so we can provide node maps per-run
+        self._control_handler = control
+        self._nodes: List[NCCommandNode] = []
+        self._tool_path: List[Tuple[List[Point], float]] = []
+        # nodes corresponding to each entry in _tool_path (parallel list)
+        self._tool_nodes: List[NCCommandNode] = []
+        # Default this canal to lathe-style behavior where X is interpreted as
+        # diameter when we created the canal without an explicit initial
+        # state. If the caller provided an `init_state` we must not override
+        # their axis unit choices (tests and callers may rely on a specific
+        # axis unit configuration).
+        try:
+            if init_state is None:
+                self._state.set_axis_unit('X', 'diameter')
+        except Exception:
+            # if state doesn't support the helper for any reason, ignore
+            pass
+
+    def get_name(self) -> str:
+        return self._name
+
+    def run_nc_code_list(self, linked_code_list: List[NCCommandNode]) -> None:
+        # convert to list and set up linked pointers so control flow handlers
+        # can jump between nodes by manipulating `_next_ncCode`.
+        self._nodes = list(linked_code_list)
+        # record actual execution order (may differ from _nodes when
+        # control flow handlers jump or loop). This list will contain the
+        # nodes in the order they were processed (including repeated
+        # visits) so callers can map executed program lines to tool path
+        # segments.
+        self._exec_sequence: List[NCCommandNode] = []
+        self._tool_path = []
+
+        # link nodes in forward/backward direction
+        for i in range(len(self._nodes) - 1):
+            self._nodes[i]._next_ncCode = self._nodes[i + 1]
+            self._nodes[i + 1]._before_ncCode = self._nodes[i]
+
+        # build lookup maps for labels and DO/END tokens to help control flow
+        n_map = {}
+        do_map = {}
+        end_map = {}
+        for nd in self._nodes:
+            try:
+                nval = nd.command_parameter.get("N")
+            except Exception:
+                nval = None
+            if nval is not None:
+                try:
+                    key = float(nval)
+                    n_map[key] = nd
+                except Exception:
+                    pass
+            # detect DO/END labels inside loop_command
+            lc = nd.loop_command
+            if lc:
+                # DO labels
+                for m in re.findall(r"DO(\d+)", lc):
+                    do_map.setdefault(m, []).append(nd)
+                for m in re.findall(r"END(\d+)", lc):
+                    end_map.setdefault(m, []).append(nd)
+
+        # provide maps to control handler (if present)
+        try:
+            self._control_handler._n_map = n_map
+            self._control_handler._do_map = do_map
+            self._control_handler._end_map = end_map
+            self._control_handler._nodes = self._nodes
+            # reset any existing loop counters for this run
+            self._control_handler._loop_counters = {}
+        except Exception:
+            pass
+
+        # execute following `_next_ncCode` pointers; bound iterations to
+        # avoid infinite loops. Handlers may update `_next_ncCode` to jump.
+        node = self._nodes[0] if len(self._nodes) > 0 else None
+        max_steps = max(10000, len(self._nodes) * 100)
+        steps = 0
+        logger = logging.getLogger(__name__)
+        while node is not None and steps < max_steps:
+            # record node as executed (captures loops/jumps)
+            try:
+                self._exec_sequence.append(node)
+            except Exception:
+                # defensive: if exec_sequence not writable, ignore
+                pass
+            pts, dur = self._chain.handle(node, self._state)
+            if logger.isEnabledFor(logging.DEBUG):
+                try:
+                    ln = getattr(node, 'nc_code_line_nr', None)
+                    g = getattr(node, 'g_code', None)
+                    logger.debug("node idx=%s line=%s g_code=%s -> pts=%s dur=%s", steps, ln, g, 'Y' if pts is not None else 'N', dur)
+                except Exception:
+                    logger.debug("node idx=%s -> pts=%s dur=%s", steps, 'Y' if pts is not None else 'N', dur)
+            if pts is not None:
+                self._tool_path.append((pts, dur or 0.0))
+                # record the node that produced this tool_path segment so
+                # callers (e.g. synchronization) can align nodes with
+                # tool_path indices.
+                try:
+                    self._tool_nodes.append(node)
+                except Exception:
+                    pass
+            # follow pointer (handlers may have updated it)
+            next_node = getattr(node, "_next_ncCode", None)
+            # if next_node is same as current, break to avoid tight loop
+            if next_node is node:
+                break
+            node = next_node
+            steps += 1
+
+    def get_tool_path(self) -> List[Tuple[List[Point], float]]:
+        return self._tool_path
+
+    def get_exec_nodes(self) -> List[NCCommandNode]:
+        # Prefer the recorded nodes that produced tool_path entries when
+        # available (ensures node/tool_path index alignment). Fall back to
+        # the execution sequence then to the original node list for
+        # compatibility.
+        if hasattr(self, "_tool_nodes") and self._tool_nodes:
+            return self._tool_nodes
+        return getattr(self, "_exec_sequence", self._nodes)
+
+
+class StatefulIsoTurnNCControl(BaseNCControlInterface):
+    """Control managing multiple `StatefulIsoTurnCanal` instances.
+
+    Implements the `NCControl` abstract interface while delegating per-canal
+    execution to `StatefulIsoTurnCanal` objects.
+    """
+
+    def __init__(self, count_of_canals: int = 1, canal_names: Optional[Sequence[str]] = None, init_nc_states: Optional[Sequence[CNCState]] = None) -> None:
+        # create canal objects
+        self.count_of_canals = int(count_of_canals)
+        names = []
+        if canal_names is None:
+            names = [f"C{i+1}" for i in range(self.count_of_canals)]
+        else:
+            if isinstance(canal_names, str):
+                # single name given -> expand
+                names = [canal_names for _ in range(self.count_of_canals)]
+            else:
+                names = list(canal_names)
+
+        init_states = list(init_nc_states) if init_nc_states is not None else [None] * self.count_of_canals
+
+        self._canals: Dict[int, StatefulIsoTurnCanal] = {}
+        for idx in range(self.count_of_canals):
+            init_state = init_states[idx] if idx < len(init_states) else None
+            self._canals[idx + 1] = StatefulIsoTurnCanal(names[idx], init_state)
+
+    def get_canal_name(self, canal: int) -> str:
+        c = self._canals.get(canal)
+        return c.get_name() if c is not None else f"C{canal}"
+
+    def run_nc_code_list(self, linked_code_list: List[NCCommandNode], canal: int) -> None:
+        c = self._canals.get(canal)
+        if c is None:
+            raise IndexError(f"Canal {canal} not configured")
+        c.run_nc_code_list(linked_code_list)
+
+    def get_tool_path(self, canal: int) -> List[Tuple[List[Point], float]]:
+        c = self._canals.get(canal)
+        if c is None:
+            return []
+        return c.get_tool_path()
+
+    def get_exected_nodes(self, canal: int) -> List[NCCommandNode]:
+        c = self._canals.get(canal)
+        if c is None:
+            return []
+        return c.get_exec_nodes()
+
+    def get_canal_count(self) -> int:
+        return self.count_of_canals
+
+    def synchro_points(self, tool_paths, nodes):
+        # perform synchronization of tool path timing across canals
+        # tool_paths: list of list of tuples (points_list, duration)
+        # nodes: list of list of NCCommandNode executed for each canal
+        # run synchronization handler
+        try:
+            syn = CanalSynchro(tool_paths, nodes)  # delegate to the star-machine specific synchronisation helper
+            syn.synchro_points()
+        except Exception:
+            # let domain exceptions propagate; unknown exceptions bubble up too
+            raise
+        return None
+
+
+__all__ = ["StatefulIsoTurnNCControl"]
diff --git a/src/ncplot7py/infrastructure/parsers/__pycache__/nc_command_parser.cpython-313.pyc b/src/ncplot7py/infrastructure/parsers/__pycache__/nc_command_parser.cpython-313.pyc
new file mode 100644
index 0000000..5e4be0d
Binary files /dev/null and b/src/ncplot7py/infrastructure/parsers/__pycache__/nc_command_parser.cpython-313.pyc differ
diff --git a/src/ncplot7py/infrastructure/parsers/nc_command_parser.py b/src/ncplot7py/infrastructure/parsers/nc_command_parser.py
index 7a15da2..ea14f60 100644
--- a/src/ncplot7py/infrastructure/parsers/nc_command_parser.py
+++ b/src/ncplot7py/infrastructure/parsers/nc_command_parser.py
@@ -1,133 +1,133 @@
-"""Concrete parser: map NC/G-code string to an `NCCommandNode`.
-
-The implementation is a direct, slightly cleaned-up adaptation of the
-user-provided mapping logic. It returns the project's
-`ncplot7py.shared.nc_nodes.NCCommandNode` and raises
-`domain.exceptions.ExceptionNode` for detected error conditions.
-"""
-from __future__ import annotations
-
-import re
-import string
-from typing import Optional, Set, Dict
-
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.interfaces.BaseNCCommandParser import BaseNCCommandParser
-from ncplot7py.domain import exceptions as domain_exceptions
-
-
-class NCCommandParserError(domain_exceptions.ExceptionNode):
-    """Thin wrapper for parser errors (keeps ExceptionNode semantics)."""
-
-
-class NCCommandStringParser(BaseNCCommandParser):
-    """Parse a single NC/G-code string into an `NCCommandNode` instance.
-
-    The parser is intentionally permissive: it follows the original
-    heuristics (G-codes, single-letter parameters, macro/variable markers
-    starting with '#', DDDP tokens after commas, etc.). Where the original
-    raised a custom IntEnum-based exception, this implementation raises
-    `domain.exceptions.ExceptionNode` with a compact numeric code so calling
-    code can handle it.
-    """
-
-    def parse(self, nc_command_string: str, line_nr: Optional[int] = None) -> NCCommandNode:
-        g_code_set: Set[str] = set()
-        axis_coordinate_dict: Dict[str, str] = {}
-        dddp_ccr_set: Set[str] = set()
-        var_calculation_str = ""
-        loop_code = ""
-        is_dddp = False
-
-        if nc_command_string is None:
-            nc_command_string = ""
-
-        # remove spaces for initial trimming but keep some tokenization later
-        nc_line = re.sub(" ", "", nc_command_string)
-        if nc_line.startswith('/'):
-            nc_line = nc_line[1:]
-
-        # simple detection of control/loop statements
-        if 'GOTO' in nc_line or "IF" in nc_line or 'WHILE' in nc_line or "END" in nc_line or "DO" in nc_line:
-            loop_code = nc_line
-            nc_line = ""
-
-        # Insert spaces before tokens so we can split
-        nc_line = re.sub(r"(SQRT|ASIN|SIN|[A-Z,])", r" \1", nc_line)
-        # quickfix for the behaviour in the original snippet
-        nc_line = nc_line.replace(" SQRT", "SQRT")
-        nc_line = nc_line.replace(" ASIN", "ASIN")
-        nc_line = nc_line.replace(" SIN", "SIN")
-
-        codes = re.split(r"\s+", nc_line.strip()) if nc_line.strip() else []
-
-        for code in codes:
-            if not code:
-                continue
-            if is_dddp:
-                dddp_ccr_set.add(code)
-                is_dddp = False
-            elif code.startswith('G'):
-                g_code_set.add(code)
-            elif code.startswith('#'):
-                var_calculation_str = nc_line
-                if len(g_code_set) > 0 or len(axis_coordinate_dict) > 0:
-                    domain_exceptions.raise_nc_error(
-                        domain_exceptions.ExceptionTyps.NCCodeErrors,
-                        -3,
-                        message="Duplication of macro and NC command",
-                        value=nc_command_string,
-                        line=line_nr or 0,
-                        source_line=nc_command_string,
-                    )
-            elif code.startswith(','):
-                is_dddp = True
-            elif is_dddp is True and (code.startswith(',R') or code.startswith(',C') or code.startswith(',A')):
-                dddp_ccr_set.add(code)
-            elif code.startswith('M'):
-                # M codes treated as parameter-like (original code used code[:1])
-                axis_coordinate_dict.update({code[:1]: code[1:]})
-            elif code.startswith(('A', 'B', 'C', 'N', 'T', 'S', 'F', 'D', 'X', 'Y', 'Z', 'R', 'H', 'U', 'V', 'W', 'K', 'L', 'I',
-                                 'Q', 'x', 'y', 'z', 'u', 'v', 'w', 'r', 'g')):
-                key = code[:1]
-                if key in axis_coordinate_dict:
-                    domain_exceptions.raise_nc_error(
-                        domain_exceptions.ExceptionTyps.NCCodeErrors,
-                        -2,
-                        message="Duplication of parameter",
-                        value=code,
-                        line=line_nr or 0,
-                        source_line=nc_command_string,
-                    )
-                axis_coordinate_dict.update({key: code[1:]})
-
-        node = NCCommandNode(
-            g_code_command=g_code_set,
-            command_parameter=axis_coordinate_dict,
-            loop_command=loop_code or None,
-            variable_command=var_calculation_str or None,
-            dddp_command=dddp_ccr_set,
-            nc_code_line_nr=line_nr,
-        )
-
-        return node
-
-
-def register(registry) -> None:
-    """Register this parser implementation in the project's registry.
-
-    The registry uses string kinds (e.g. 'parser') and a textual name. We
-    use 'nc_command' as the name for this implementation.
-    """
-    # Friendly name registration
-    registry.register("parser", "nc_command", NCCommandStringParser)
-    # Also register under the interface name so callers that look up by
-    # interface can find this implementation.
-    try:
-        from ncplot7py.interfaces.BaseNCCommandParser import BaseNCCommandParser
-
-        registry.register("parser", BaseNCCommandParser.__name__, NCCommandStringParser)
-    except Exception:
-        # Keep registration best-effort and avoid hard failures on import
-        pass
-
+"""Concrete parser: map NC/G-code string to an `NCCommandNode`.
+
+The implementation is a direct, slightly cleaned-up adaptation of the
+user-provided mapping logic. It returns the project's
+`ncplot7py.shared.nc_nodes.NCCommandNode` and raises
+`domain.exceptions.ExceptionNode` for detected error conditions.
+"""
+from __future__ import annotations
+
+import re
+import string
+from typing import Optional, Set, Dict
+
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.interfaces.BaseNCCommandParser import BaseNCCommandParser
+from ncplot7py.domain import exceptions as domain_exceptions
+
+
+class NCCommandParserError(domain_exceptions.ExceptionNode):
+    """Thin wrapper for parser errors (keeps ExceptionNode semantics)."""
+
+
+class NCCommandStringParser(BaseNCCommandParser):
+    """Parse a single NC/G-code string into an `NCCommandNode` instance.
+
+    The parser is intentionally permissive: it follows the original
+    heuristics (G-codes, single-letter parameters, macro/variable markers
+    starting with '#', DDDP tokens after commas, etc.). Where the original
+    raised a custom IntEnum-based exception, this implementation raises
+    `domain.exceptions.ExceptionNode` with a compact numeric code so calling
+    code can handle it.
+    """
+
+    def parse(self, nc_command_string: str, line_nr: Optional[int] = None) -> NCCommandNode:
+        g_code_set: Set[str] = set()
+        axis_coordinate_dict: Dict[str, str] = {}
+        dddp_ccr_set: Set[str] = set()
+        var_calculation_str = ""
+        loop_code = ""
+        is_dddp = False
+
+        if nc_command_string is None:
+            nc_command_string = ""
+
+        # remove spaces for initial trimming but keep some tokenization later
+        nc_line = re.sub(" ", "", nc_command_string)
+        if nc_line.startswith('/'):
+            nc_line = nc_line[1:]
+
+        # simple detection of control/loop statements
+        if 'GOTO' in nc_line or "IF" in nc_line or 'WHILE' in nc_line or "END" in nc_line or "DO" in nc_line:
+            loop_code = nc_line
+            nc_line = ""
+
+        # Insert spaces before tokens so we can split
+        nc_line = re.sub(r"(SQRT|ASIN|SIN|[A-Z,])", r" \1", nc_line)
+        # quickfix for the behaviour in the original snippet
+        nc_line = nc_line.replace(" SQRT", "SQRT")
+        nc_line = nc_line.replace(" ASIN", "ASIN")
+        nc_line = nc_line.replace(" SIN", "SIN")
+
+        codes = re.split(r"\s+", nc_line.strip()) if nc_line.strip() else []
+
+        for code in codes:
+            if not code:
+                continue
+            if is_dddp:
+                dddp_ccr_set.add(code)
+                is_dddp = False
+            elif code.startswith('G'):
+                g_code_set.add(code)
+            elif code.startswith('#'):
+                var_calculation_str = nc_line
+                if len(g_code_set) > 0 or len(axis_coordinate_dict) > 0:
+                    domain_exceptions.raise_nc_error(
+                        domain_exceptions.ExceptionTyps.NCCodeErrors,
+                        -3,
+                        message="Duplication of macro and NC command",
+                        value=nc_command_string,
+                        line=line_nr or 0,
+                        source_line=nc_command_string,
+                    )
+            elif code.startswith(','):
+                is_dddp = True
+            elif is_dddp is True and (code.startswith(',R') or code.startswith(',C') or code.startswith(',A')):
+                dddp_ccr_set.add(code)
+            elif code.startswith('M'):
+                # M codes treated as parameter-like (original code used code[:1])
+                axis_coordinate_dict.update({code[:1]: code[1:]})
+            elif code.startswith(('A', 'B', 'C', 'N', 'T', 'S', 'F', 'D', 'X', 'Y', 'Z', 'R', 'H', 'U', 'V', 'W', 'K', 'L', 'I',
+                                 'Q', 'x', 'y', 'z', 'u', 'v', 'w', 'r', 'g')):
+                key = code[:1]
+                if key in axis_coordinate_dict:
+                    domain_exceptions.raise_nc_error(
+                        domain_exceptions.ExceptionTyps.NCCodeErrors,
+                        -2,
+                        message="Duplication of parameter",
+                        value=code,
+                        line=line_nr or 0,
+                        source_line=nc_command_string,
+                    )
+                axis_coordinate_dict.update({key: code[1:]})
+
+        node = NCCommandNode(
+            g_code_command=g_code_set,
+            command_parameter=axis_coordinate_dict,
+            loop_command=loop_code or None,
+            variable_command=var_calculation_str or None,
+            dddp_command=dddp_ccr_set,
+            nc_code_line_nr=line_nr,
+        )
+
+        return node
+
+
+def register(registry) -> None:
+    """Register this parser implementation in the project's registry.
+
+    The registry uses string kinds (e.g. 'parser') and a textual name. We
+    use 'nc_command' as the name for this implementation.
+    """
+    # Friendly name registration
+    registry.register("parser", "nc_command", NCCommandStringParser)
+    # Also register under the interface name so callers that look up by
+    # interface can find this implementation.
+    try:
+        from ncplot7py.interfaces.BaseNCCommandParser import BaseNCCommandParser
+
+        registry.register("parser", BaseNCCommandParser.__name__, NCCommandStringParser)
+    except Exception:
+        # Keep registration best-effort and avoid hard failures on import
+        pass
+
diff --git a/src/ncplot7py/interfaces/BaseLinkedListAsList.py b/src/ncplot7py/interfaces/BaseLinkedListAsList.py
index 912b783..fab2871 100644
--- a/src/ncplot7py/interfaces/BaseLinkedListAsList.py
+++ b/src/ncplot7py/interfaces/BaseLinkedListAsList.py
@@ -1,46 +1,46 @@
-"""Interface for LinkedListAsList implementations.
-
-Defines the minimal API used in tests and other modules so code can depend on
-an abstract behaviour rather than a specific implementation.
-"""
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Generic, Iterable, Iterator, List, TypeVar
-
-T = TypeVar("T")
-
-
-class BaseLinkedListAsList(ABC, Generic[T]):
-    @abstractmethod
-    def append(self, item: T) -> None:
-        pass
-
-    @abstractmethod
-    def insert_after(self, target: T, item: T) -> None:
-        pass
-
-    @abstractmethod
-    def remove(self, target: T) -> T:
-        pass
-
-    @abstractmethod
-    def remove_at_index(self, index: int) -> T:
-        pass
-
-    @abstractmethod
-    def get_node_from_index(self, index: int) -> T:
-        pass
-
-    @abstractmethod
-    def to_list(self) -> List[T]:
-        pass
-
-    @abstractmethod
-    def __len__(self) -> int:
-        pass
-
-    @abstractmethod
-    def __iter__(self) -> Iterator[T]:
-        pass
-
+"""Interface for LinkedListAsList implementations.
+
+Defines the minimal API used in tests and other modules so code can depend on
+an abstract behaviour rather than a specific implementation.
+"""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Generic, Iterable, Iterator, List, TypeVar
+
+T = TypeVar("T")
+
+
+class BaseLinkedListAsList(ABC, Generic[T]):
+    @abstractmethod
+    def append(self, item: T) -> None:
+        pass
+
+    @abstractmethod
+    def insert_after(self, target: T, item: T) -> None:
+        pass
+
+    @abstractmethod
+    def remove(self, target: T) -> T:
+        pass
+
+    @abstractmethod
+    def remove_at_index(self, index: int) -> T:
+        pass
+
+    @abstractmethod
+    def get_node_from_index(self, index: int) -> T:
+        pass
+
+    @abstractmethod
+    def to_list(self) -> List[T]:
+        pass
+
+    @abstractmethod
+    def __len__(self) -> int:
+        pass
+
+    @abstractmethod
+    def __iter__(self) -> Iterator[T]:
+        pass
+
diff --git a/src/ncplot7py/interfaces/BaseNCCanal.py b/src/ncplot7py/interfaces/BaseNCCanal.py
index c11f0d4..bb5904b 100644
--- a/src/ncplot7py/interfaces/BaseNCCanal.py
+++ b/src/ncplot7py/interfaces/BaseNCCanal.py
@@ -1,182 +1,182 @@
-"""     CNC NC-Code toolphat caculations for Plot
-    Copyright (C) <2024>  <Damian Roth Switzerland
-
-    This program is free software: you can redistribute it and/or modify
-    it under the terms of the GNU Affero General Public License as
-    published by the Free Software Foundation, either version 3 of the
-    License, or (at your option) any later version.
-
-    This program is distributed in the hope that it will be useful,
-    but WITHOUT ANY WARRANTY; without even the implied warranty of
-    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
-    GNU Affero General Public License for more details.
-
-    You should have received a copy of the GNU Affero General Public License
-    along with this program.  If not, see <https://www.gnu.org/licenses/>. 
-"""
-
-from __future__ import annotations
-from abc import ABC, abstractmethod
-
-
-class NCControl(ABC):
-    """
-    Header Class of the NCContol interface to uses a NC Controll
-    ...
-
-    Attributes
-    ----------
-
-    count_of_canals : int
-        The count of the Canals the NC should have
-    canal_names : string
-        name of the canals 
-    init_nc_states : list[NCState]
-        A list of the Init NC-State for each Canal
-
-    Methods
-    -------
-    __init__(self, count_of_canals, init_nc_states:list[NCState]) -> None:
-        Initalisation of the New Object
-    run_nc_code_list(self, linked_code_list: LinkedNCCodeList, canal: int) -> None:
-        runs the NC Program 
-
-    get_tool_path(self, canal: int) -> list[tuple[list[Point], int]]:  # list of Points
-        returns the Tool path stored in the object
-    
-    synchro_points(tool_paths,exec_nodes) -> None:
-        Synchronisation of the Time of the NC nodes while the Canals waits for each other
-
-    get_canal_count(self)-> int:
-        returns the count of canals 
-    get_exected_nodes(self, canal: int) -> list[NCNode]: 
-        returns the the List of Executed NC Nodes
-    """
-
-
-    @abstractmethod
-    def get_canal_name(self, canal : int) -> str:
-        """return the name of the canal
-        
-        Parameters:
-        ----------
-        canal: int
-            define in which Canal the name should be returned
-
-        Returns:
-        -------
-        str
-            the name
-        """
-        pass
-
-    @abstractmethod
-    def __init__(self, count_of_canals,canal_names:str, init_nc_states:list[NCState]) -> None:
-        """Initalisation of Object
-
-        Parameters:
-        ----------
-        count_of_canals : int
-            The count of the Canals the NC should have
-        canal_names : string
-            name of the canals 
-        init_nc_states : list[NCState]
-            A list of the Init NC-State for each Canal
-
-        Returns:
-        -------
-        None
-            Nothing
-       """
-        pass
-
-    @abstractmethod
-    def run_nc_code_list(self, linked_code_list: LinkedNCCodeList, canal: int) -> None:
-        """runs the NC Program 
-
-        Parameters:
-        ----------
-        linked_code_list: LinkedNCCodeList
-            A List of NCCode Nodes to be executetd
-        canal: int
-            define in which Canal of the NC Program the Program should be run
-
-        Returns:
-        -------
-        None
-
-        Raises
-        ------
-        NCCommandTONCCommandNodeMapperException
-            If the blank NC-Code could not be map in to NC Nodes       
-        NCControlException      
-            IF there was a problem with the values given
-        Execption
-            IF there was a problem while run the Program  CNC Errors 
-       """
-        pass
-
-    @abstractmethod
-    def get_tool_path(self, canal: int) -> list[tuple[list[Point], int]]:  # list of Points
-        """returns the Tool path stored in the object
-
-        Parameters:
-        ----------
-        canal: int
-            define in which Canal the tool path should be returned
-
-        Returns:
-        -------
-        list[tuple[list[Points], int]]
-            returns a list with a Tuple of each NC-Executed Node Line that contains 
-            a List of Point of the current Line and the Time
-
-        Raises
-        ------
-        NCControlException
-            If the selected Canal does not exist      
-        """
-        pass
-
-    @abstractmethod
-    def get_exected_nodes(self, canal: int) -> list[NCNode]: 
-        """returns the the List of Executed NC Nodes
-
-        Parameters:
-        ----------
-        canal: int
-            define in which Canal the tool path should be returned
-
-        Returns:
-        -------
-        list[NCNode]: 
-            List of Node executed
-
-        Raises
-        ------   
-        """
-        pass 
-
-    @abstractmethod       
-    def get_canal_count(self)-> int:
-        """
-        returns the count of canals 
-
-        Returns:
-        -------
-        int: 
-            count of Canals of this NC
-        """
-        pass
-
-    @abstractmethod  
-    def synchro_points(self,tool_paths,exec_nodes) -> None:
-        """
-        Synchronisation of the Time of the NC nodes while the Canals waits for each other
-
-        Returns:
-        -------
-        None: 
-            the change chould be made as a side effect
-        """
+"""     CNC NC-Code toolphat caculations for Plot
+    Copyright (C) <2024>  <Damian Roth Switzerland
+
+    This program is free software: you can redistribute it and/or modify
+    it under the terms of the GNU Affero General Public License as
+    published by the Free Software Foundation, either version 3 of the
+    License, or (at your option) any later version.
+
+    This program is distributed in the hope that it will be useful,
+    but WITHOUT ANY WARRANTY; without even the implied warranty of
+    MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE.  See the
+    GNU Affero General Public License for more details.
+
+    You should have received a copy of the GNU Affero General Public License
+    along with this program.  If not, see <https://www.gnu.org/licenses/>. 
+"""
+
+from __future__ import annotations
+from abc import ABC, abstractmethod
+
+
+class NCControl(ABC):
+    """
+    Header Class of the NCContol interface to uses a NC Controll
+    ...
+
+    Attributes
+    ----------
+
+    count_of_canals : int
+        The count of the Canals the NC should have
+    canal_names : string
+        name of the canals 
+    init_nc_states : list[NCState]
+        A list of the Init NC-State for each Canal
+
+    Methods
+    -------
+    __init__(self, count_of_canals, init_nc_states:list[NCState]) -> None:
+        Initalisation of the New Object
+    run_nc_code_list(self, linked_code_list: LinkedNCCodeList, canal: int) -> None:
+        runs the NC Program 
+
+    get_tool_path(self, canal: int) -> list[tuple[list[Point], int]]:  # list of Points
+        returns the Tool path stored in the object
+    
+    synchro_points(tool_paths,exec_nodes) -> None:
+        Synchronisation of the Time of the NC nodes while the Canals waits for each other
+
+    get_canal_count(self)-> int:
+        returns the count of canals 
+    get_exected_nodes(self, canal: int) -> list[NCNode]: 
+        returns the the List of Executed NC Nodes
+    """
+
+
+    @abstractmethod
+    def get_canal_name(self, canal : int) -> str:
+        """return the name of the canal
+        
+        Parameters:
+        ----------
+        canal: int
+            define in which Canal the name should be returned
+
+        Returns:
+        -------
+        str
+            the name
+        """
+        pass
+
+    @abstractmethod
+    def __init__(self, count_of_canals,canal_names:str, init_nc_states:list[NCState]) -> None:
+        """Initalisation of Object
+
+        Parameters:
+        ----------
+        count_of_canals : int
+            The count of the Canals the NC should have
+        canal_names : string
+            name of the canals 
+        init_nc_states : list[NCState]
+            A list of the Init NC-State for each Canal
+
+        Returns:
+        -------
+        None
+            Nothing
+       """
+        pass
+
+    @abstractmethod
+    def run_nc_code_list(self, linked_code_list: LinkedNCCodeList, canal: int) -> None:
+        """runs the NC Program 
+
+        Parameters:
+        ----------
+        linked_code_list: LinkedNCCodeList
+            A List of NCCode Nodes to be executetd
+        canal: int
+            define in which Canal of the NC Program the Program should be run
+
+        Returns:
+        -------
+        None
+
+        Raises
+        ------
+        NCCommandTONCCommandNodeMapperException
+            If the blank NC-Code could not be map in to NC Nodes       
+        NCControlException      
+            IF there was a problem with the values given
+        Execption
+            IF there was a problem while run the Program  CNC Errors 
+       """
+        pass
+
+    @abstractmethod
+    def get_tool_path(self, canal: int) -> list[tuple[list[Point], int]]:  # list of Points
+        """returns the Tool path stored in the object
+
+        Parameters:
+        ----------
+        canal: int
+            define in which Canal the tool path should be returned
+
+        Returns:
+        -------
+        list[tuple[list[Points], int]]
+            returns a list with a Tuple of each NC-Executed Node Line that contains 
+            a List of Point of the current Line and the Time
+
+        Raises
+        ------
+        NCControlException
+            If the selected Canal does not exist      
+        """
+        pass
+
+    @abstractmethod
+    def get_exected_nodes(self, canal: int) -> list[NCNode]: 
+        """returns the the List of Executed NC Nodes
+
+        Parameters:
+        ----------
+        canal: int
+            define in which Canal the tool path should be returned
+
+        Returns:
+        -------
+        list[NCNode]: 
+            List of Node executed
+
+        Raises
+        ------   
+        """
+        pass 
+
+    @abstractmethod       
+    def get_canal_count(self)-> int:
+        """
+        returns the count of canals 
+
+        Returns:
+        -------
+        int: 
+            count of Canals of this NC
+        """
+        pass
+
+    @abstractmethod  
+    def synchro_points(self,tool_paths,exec_nodes) -> None:
+        """
+        Synchronisation of the Time of the NC nodes while the Canals waits for each other
+
+        Returns:
+        -------
+        None: 
+            the change chould be made as a side effect
+        """
         pass
\ No newline at end of file
diff --git a/src/ncplot7py/interfaces/BaseNCCommandNode.py b/src/ncplot7py/interfaces/BaseNCCommandNode.py
index 1815d45..066e2b0 100644
--- a/src/ncplot7py/interfaces/BaseNCCommandNode.py
+++ b/src/ncplot7py/interfaces/BaseNCCommandNode.py
@@ -1,58 +1,58 @@
-"""Abstract interface for NC command node objects.
-
-Provides a minimal ABC representing the behaviour and shape required by
-consumers of `NCCommandNode`. Concrete implementations (for example
-`ncplot7py.shared.nc_nodes.NCCommandNode`) should subclass this so code can
-depend on the interface instead of a concrete class.
-"""
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Dict, Optional, Set
-
-
-class BaseNCCommandNode(ABC):
-    """Interface for an NC/G-code command node.
-
-    Attributes are documented as properties so implementations may use either
-    plain attributes or @property implementations.
-    """
-
-    @property
-    @abstractmethod
-    def g_code(self) -> Set[str]:
-        pass
-
-    @property
-    @abstractmethod
-    def command_parameter(self) -> Dict[str, str]:
-        pass
-
-    @property
-    @abstractmethod
-    def loop_command(self) -> Optional[str]:
-        pass
-
-    @property
-    @abstractmethod
-    def variable_command(self) -> Optional[str]:
-        pass
-
-    @property
-    @abstractmethod
-    def dddp_command(self) -> Set[str]:
-        pass
-
-    @property
-    @abstractmethod
-    def nc_code_line_nr(self) -> Optional[int]:
-        pass
-
-    @abstractmethod
-    def copy(self) -> "BaseNCCommandNode":
-        """Return a copy of this node. The exact copy semantics are
-        implementation-defined but callers expect a shallow copy of node
-        pointers and a deep copy of mutable attributes.
-        """
-        pass
-
+"""Abstract interface for NC command node objects.
+
+Provides a minimal ABC representing the behaviour and shape required by
+consumers of `NCCommandNode`. Concrete implementations (for example
+`ncplot7py.shared.nc_nodes.NCCommandNode`) should subclass this so code can
+depend on the interface instead of a concrete class.
+"""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Dict, Optional, Set
+
+
+class BaseNCCommandNode(ABC):
+    """Interface for an NC/G-code command node.
+
+    Attributes are documented as properties so implementations may use either
+    plain attributes or @property implementations.
+    """
+
+    @property
+    @abstractmethod
+    def g_code(self) -> Set[str]:
+        pass
+
+    @property
+    @abstractmethod
+    def command_parameter(self) -> Dict[str, str]:
+        pass
+
+    @property
+    @abstractmethod
+    def loop_command(self) -> Optional[str]:
+        pass
+
+    @property
+    @abstractmethod
+    def variable_command(self) -> Optional[str]:
+        pass
+
+    @property
+    @abstractmethod
+    def dddp_command(self) -> Set[str]:
+        pass
+
+    @property
+    @abstractmethod
+    def nc_code_line_nr(self) -> Optional[int]:
+        pass
+
+    @abstractmethod
+    def copy(self) -> "BaseNCCommandNode":
+        """Return a copy of this node. The exact copy semantics are
+        implementation-defined but callers expect a shallow copy of node
+        pointers and a deep copy of mutable attributes.
+        """
+        pass
+
diff --git a/src/ncplot7py/interfaces/BaseNCCommandParser.py b/src/ncplot7py/interfaces/BaseNCCommandParser.py
index be860c9..289122b 100644
--- a/src/ncplot7py/interfaces/BaseNCCommandParser.py
+++ b/src/ncplot7py/interfaces/BaseNCCommandParser.py
@@ -1,32 +1,32 @@
-"""Parser interface for mapping NC/G-code text to `BaseNCCommandNode`.
-
-This small interface defines a parser contract so different parser
-implementations can be swapped in tests or at runtime.
-"""
-from __future__ import annotations
-
-from abc import ABC, abstractmethod
-from typing import Optional
-
-from .BaseNCCommandNode import BaseNCCommandNode
-
-
-class BaseNCCommandParser(ABC):
-    """Abstract parser that converts an NC command string into a node.
-
-    Implementations must return an object implementing
-    :class:`BaseNCCommandNode`.
-    """
-
-    @abstractmethod
-    def parse(self, nc_command_string: str, line_nr: Optional[int] = None) -> BaseNCCommandNode:
-        """Parse a single line of NC/G-code and return a node representation.
-
-        Parameters:
-            nc_command_string: The raw NC text line to parse.
-            line_nr: Optional 1-based source line number to attach to the node.
-
-        Returns:
-            An instance implementing :class:`BaseNCCommandNode`.
-        """
-        raise NotImplementedError()
+"""Parser interface for mapping NC/G-code text to `BaseNCCommandNode`.
+
+This small interface defines a parser contract so different parser
+implementations can be swapped in tests or at runtime.
+"""
+from __future__ import annotations
+
+from abc import ABC, abstractmethod
+from typing import Optional
+
+from .BaseNCCommandNode import BaseNCCommandNode
+
+
+class BaseNCCommandParser(ABC):
+    """Abstract parser that converts an NC command string into a node.
+
+    Implementations must return an object implementing
+    :class:`BaseNCCommandNode`.
+    """
+
+    @abstractmethod
+    def parse(self, nc_command_string: str, line_nr: Optional[int] = None) -> BaseNCCommandNode:
+        """Parse a single line of NC/G-code and return a node representation.
+
+        Parameters:
+            nc_command_string: The raw NC text line to parse.
+            line_nr: Optional 1-based source line number to attach to the node.
+
+        Returns:
+            An instance implementing :class:`BaseNCCommandNode`.
+        """
+        raise NotImplementedError()
diff --git a/src/ncplot7py/interfaces/BaseNCControl.py b/src/ncplot7py/interfaces/BaseNCControl.py
index e36fe7f..240c12a 100644
--- a/src/ncplot7py/interfaces/BaseNCControl.py
+++ b/src/ncplot7py/interfaces/BaseNCControl.py
@@ -1,54 +1,54 @@
-from __future__ import annotations
-from abc import ABC, abstractmethod
-
-
-
-class NCCanal(ABC):
-    """
-    Header Class of the NCControl interface to use an NC Control.
-
-    This abstract base class defines the interface for NC control operations.
-    
-    Methods:
-    --------
-    get_name() -> str:
-        Returns the name of the canal.
-    
-    run_nc_code_list(linked_code_list: LinkedNCCodeList) -> None:
-        Runs the NC Program using the provided linked code list.
-    
-    get_tool_path() -> list:
-        Returns the tool path stored in the object as a list of points.
-    
-    get_exec_nodes() -> list:
-        Returns the list of executed NC nodes.
-    """
-
-
-
-    @abstractmethod    
-    def get_name(self) -> str:
-        """
-        return the name of the canal
-        """
-        pass
-
-    @abstractmethod
-    def run_nc_code_list(self, linked_code_list: LinkedNCCodeList) -> None:
-        """
-        runs the NC Program
-        """
-        pass
-    @abstractmethod
-    def get_tool_path(self) -> list:  # list of Points
-        """
-        returns the Tool path stored in the object
-        """
-        pass
-
-    @abstractmethod
-    def get_exec_nodes(self) -> list:  # list of Nodes Executed 
-        """
-        returns the the List of Executed NC Nodes
-        """
+from __future__ import annotations
+from abc import ABC, abstractmethod
+
+
+
+class NCCanal(ABC):
+    """
+    Header Class of the NCControl interface to use an NC Control.
+
+    This abstract base class defines the interface for NC control operations.
+    
+    Methods:
+    --------
+    get_name() -> str:
+        Returns the name of the canal.
+    
+    run_nc_code_list(linked_code_list: LinkedNCCodeList) -> None:
+        Runs the NC Program using the provided linked code list.
+    
+    get_tool_path() -> list:
+        Returns the tool path stored in the object as a list of points.
+    
+    get_exec_nodes() -> list:
+        Returns the list of executed NC nodes.
+    """
+
+
+
+    @abstractmethod    
+    def get_name(self) -> str:
+        """
+        return the name of the canal
+        """
+        pass
+
+    @abstractmethod
+    def run_nc_code_list(self, linked_code_list: LinkedNCCodeList) -> None:
+        """
+        runs the NC Program
+        """
+        pass
+    @abstractmethod
+    def get_tool_path(self) -> list:  # list of Points
+        """
+        returns the Tool path stored in the object
+        """
+        pass
+
+    @abstractmethod
+    def get_exec_nodes(self) -> list:  # list of Nodes Executed 
+        """
+        returns the the List of Executed NC Nodes
+        """
         pass
\ No newline at end of file
diff --git a/src/ncplot7py/interfaces/__pycache__/BaseLinkedListAsList.cpython-313.pyc b/src/ncplot7py/interfaces/__pycache__/BaseLinkedListAsList.cpython-313.pyc
new file mode 100644
index 0000000..dbbbaa6
Binary files /dev/null and b/src/ncplot7py/interfaces/__pycache__/BaseLinkedListAsList.cpython-313.pyc differ
diff --git a/src/ncplot7py/interfaces/__pycache__/BaseNCCanal.cpython-313.pyc b/src/ncplot7py/interfaces/__pycache__/BaseNCCanal.cpython-313.pyc
new file mode 100644
index 0000000..085a32b
Binary files /dev/null and b/src/ncplot7py/interfaces/__pycache__/BaseNCCanal.cpython-313.pyc differ
diff --git a/src/ncplot7py/interfaces/__pycache__/BaseNCCommandNode.cpython-313.pyc b/src/ncplot7py/interfaces/__pycache__/BaseNCCommandNode.cpython-313.pyc
new file mode 100644
index 0000000..c9e8c27
Binary files /dev/null and b/src/ncplot7py/interfaces/__pycache__/BaseNCCommandNode.cpython-313.pyc differ
diff --git a/src/ncplot7py/interfaces/__pycache__/BaseNCCommandParser.cpython-313.pyc b/src/ncplot7py/interfaces/__pycache__/BaseNCCommandParser.cpython-313.pyc
new file mode 100644
index 0000000..5eb5769
Binary files /dev/null and b/src/ncplot7py/interfaces/__pycache__/BaseNCCommandParser.cpython-313.pyc differ
diff --git a/src/ncplot7py/interfaces/__pycache__/BaseNCControl.cpython-313.pyc b/src/ncplot7py/interfaces/__pycache__/BaseNCControl.cpython-313.pyc
new file mode 100644
index 0000000..fa9ef2b
Binary files /dev/null and b/src/ncplot7py/interfaces/__pycache__/BaseNCControl.cpython-313.pyc differ
diff --git a/src/ncplot7py/locales/__init__.py b/src/ncplot7py/locales/__init__.py
index e8ac052..e7ecf53 100644
--- a/src/ncplot7py/locales/__init__.py
+++ b/src/ncplot7py/locales/__init__.py
@@ -1,8 +1,8 @@
-"""Package holding localization XML resources.
-
-This package contains message catalogs used by the i18n MessageCatalog.
-Keep only resource files (*.xml) here; code should use importlib.resources to
-access them so packaging can include them as package data.
-"""
-
-__all__ = []
+"""Package holding localization XML resources.
+
+This package contains message catalogs used by the i18n MessageCatalog.
+Keep only resource files (*.xml) here; code should use importlib.resources to
+access them so packaging can include them as package data.
+"""
+
+__all__ = []
diff --git a/src/ncplot7py/locales/__pycache__/__init__.cpython-313.pyc b/src/ncplot7py/locales/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000..f8f34f2
Binary files /dev/null and b/src/ncplot7py/locales/__pycache__/__init__.cpython-313.pyc differ
diff --git a/src/ncplot7py/locales/de.xml b/src/ncplot7py/locales/de.xml
index 9714359..45f55b3 100644
--- a/src/ncplot7py/locales/de.xml
+++ b/src/ncplot7py/locales/de.xml
@@ -1,35 +1,35 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<messages lang="de">
-  <!-- Schlüssel sind "{ExceptionTyps-Wert}:{Code}" -->
-  <message id="1:1001">Ungültiger NC-Code '{value}' in Zeile {line}</message>
-  <message id="2:2001">Canal Star wurde vor der Benutzung nicht gestartet</message>
-  <message id="3:3001">Allgemeiner CNC-Fehler (Code {code})</message>
-
-  <!-- NCCodeErrors (typ=1) -->
-  <message id="1:0">Keine</message>
-  <message id="1:-1">Beliebig</message>
-  <message id="1:-2">Duplikation eines Befehls derselben Gruppe</message>
-  <message id="1:-3">Vorschub ist Null</message>
-  <message id="1:-4">Spindeldrehzahl ist Null</message>
-  <message id="1:-5">Abstand des Durchmessers ist kleiner als der Weg</message>
-  <message id="1:-6">Polare Achse existiert nicht</message>
-  <message id="1:-7">Makroberechnungsfehler</message>
-  <message id="1:-8">Funktion nicht unterstützt</message>
-  <message id="1:-9">Buchstabe nicht groß geschrieben</message>
-  <message id="1:-10">Makroberechnungsfehler</message>
-  <message id="1:-11">Bogenwert ist zu groß</message>
-
-  <!-- CNCError (typ=3) -->
-  <message id="3:0">Keine</message>
-  <message id="3:-1">Zu viele G-Codes einer Gruppe</message>
-  <message id="3:-2">Code-Fehler</message>
-  <message id="3:-3">Ausgewählter Kanal existiert nicht</message>
-  <message id="3:-4">Fehler in einem Kanal</message>
-  <message id="3:-5">Wartecode stimmt nicht überein</message>
-
-  <!-- NCCanalStarErrors (typ=2) -->
-  <message id="2:0">Keine</message>
-  <message id="2:-1">Zu viele G-Codes einer Gruppe</message>
-  <message id="2:-2">Code-Fehler</message>
-  <message id="2:-3">Ausführung des Codes fehlgeschlagen</message>
-</messages>
+<?xml version="1.0" encoding="UTF-8"?>
+<messages lang="de">
+  <!-- Schlüssel sind "{ExceptionTyps-Wert}:{Code}" -->
+  <message id="1:1001">Ungültiger NC-Code '{value}' in Zeile {line}</message>
+  <message id="2:2001">Canal Star wurde vor der Benutzung nicht gestartet</message>
+  <message id="3:3001">Allgemeiner CNC-Fehler (Code {code})</message>
+
+  <!-- NCCodeErrors (typ=1) -->
+  <message id="1:0">Keine</message>
+  <message id="1:-1">Beliebig</message>
+  <message id="1:-2">Duplikation eines Befehls derselben Gruppe</message>
+  <message id="1:-3">Vorschub ist Null</message>
+  <message id="1:-4">Spindeldrehzahl ist Null</message>
+  <message id="1:-5">Abstand des Durchmessers ist kleiner als der Weg</message>
+  <message id="1:-6">Polare Achse existiert nicht</message>
+  <message id="1:-7">Makroberechnungsfehler</message>
+  <message id="1:-8">Funktion nicht unterstützt</message>
+  <message id="1:-9">Buchstabe nicht groß geschrieben</message>
+  <message id="1:-10">Makroberechnungsfehler</message>
+  <message id="1:-11">Bogenwert ist zu groß</message>
+
+  <!-- CNCError (typ=3) -->
+  <message id="3:0">Keine</message>
+  <message id="3:-1">Zu viele G-Codes einer Gruppe</message>
+  <message id="3:-2">Code-Fehler</message>
+  <message id="3:-3">Ausgewählter Kanal existiert nicht</message>
+  <message id="3:-4">Fehler in einem Kanal</message>
+  <message id="3:-5">Wartecode stimmt nicht überein</message>
+
+  <!-- NCCanalStarErrors (typ=2) -->
+  <message id="2:0">Keine</message>
+  <message id="2:-1">Zu viele G-Codes einer Gruppe</message>
+  <message id="2:-2">Code-Fehler</message>
+  <message id="2:-3">Ausführung des Codes fehlgeschlagen</message>
+</messages>
diff --git a/src/ncplot7py/locales/en.xml b/src/ncplot7py/locales/en.xml
index e3da878..3e69aef 100644
--- a/src/ncplot7py/locales/en.xml
+++ b/src/ncplot7py/locales/en.xml
@@ -1,35 +1,35 @@
-<?xml version="1.0" encoding="UTF-8"?>
-<messages lang="en">
-  <!-- Keys are "{ExceptionTyps value}:{code}" -->
-  <message id="1:1001">Invalid NC code '{value}' at line {line}</message>
-  <message id="2:2001">Canal star not started before use</message>
-  <message id="3:3001">Generic CNC error (code {code})</message>
-
-  <!-- NCCodeErrors (typ=1) -->
-  <message id="1:0">None</message>
-  <message id="1:-1">Any</message>
-  <message id="1:-2">Duplication of command of same group</message>
-  <message id="1:-3">Feed rate is zero</message>
-  <message id="1:-4">Spindle speed is zero</message>
-  <message id="1:-5">Distance of diameter is smaller than the way</message>
-  <message id="1:-6">Polar axis does not exist</message>
-  <message id="1:-7">Macro calculation error</message>
-  <message id="1:-8">Function not supported</message>
-  <message id="1:-9">Letter not upper-case</message>
-  <message id="1:-10">Macro calculation error</message>
-  <message id="1:-11">Arc value is too big</message>
-
-  <!-- CNCError (typ=3) -->
-  <message id="3:0">None</message>
-  <message id="3:-1">Too many G-codes of one group</message>
-  <message id="3:-2">Code error</message>
-  <message id="3:-3">Selected canal does not exist</message>
-  <message id="3:-4">Error in a channel</message>
-  <message id="3:-5">Wait code does not match</message>
-
-  <!-- NCCanalStarErrors (typ=2) -->
-  <message id="2:0">None</message>
-  <message id="2:-1">Too many G-codes of one group</message>
-  <message id="2:-2">Code error</message>
-  <message id="2:-3">Run code failed</message>
-</messages>
+<?xml version="1.0" encoding="UTF-8"?>
+<messages lang="en">
+  <!-- Keys are "{ExceptionTyps value}:{code}" -->
+  <message id="1:1001">Invalid NC code '{value}' at line {line}</message>
+  <message id="2:2001">Canal star not started before use</message>
+  <message id="3:3001">Generic CNC error (code {code})</message>
+
+  <!-- NCCodeErrors (typ=1) -->
+  <message id="1:0">None</message>
+  <message id="1:-1">Any</message>
+  <message id="1:-2">Duplication of command of same group</message>
+  <message id="1:-3">Feed rate is zero</message>
+  <message id="1:-4">Spindle speed is zero</message>
+  <message id="1:-5">Distance of diameter is smaller than the way</message>
+  <message id="1:-6">Polar axis does not exist</message>
+  <message id="1:-7">Macro calculation error</message>
+  <message id="1:-8">Function not supported</message>
+  <message id="1:-9">Letter not upper-case</message>
+  <message id="1:-10">Macro calculation error</message>
+  <message id="1:-11">Arc value is too big</message>
+
+  <!-- CNCError (typ=3) -->
+  <message id="3:0">None</message>
+  <message id="3:-1">Too many G-codes of one group</message>
+  <message id="3:-2">Code error</message>
+  <message id="3:-3">Selected canal does not exist</message>
+  <message id="3:-4">Error in a channel</message>
+  <message id="3:-5">Wait code does not match</message>
+
+  <!-- NCCanalStarErrors (typ=2) -->
+  <message id="2:0">None</message>
+  <message id="2:-1">Too many G-codes of one group</message>
+  <message id="2:-2">Code error</message>
+  <message id="2:-3">Run code failed</message>
+</messages>
diff --git a/src/ncplot7py/shared/__init__.py b/src/ncplot7py/shared/__init__.py
index c3148b2..46f7f01 100644
--- a/src/ncplot7py/shared/__init__.py
+++ b/src/ncplot7py/shared/__init__.py
@@ -1,33 +1,33 @@
-"""Shared utilities exports for ncplot7py.shared.
-
-This package exposes a small logging facade. The previous `OutputManager`
-implementation has been replaced by `logging_facade` which integrates with
-Python's `logging` module and provides an in-memory handler for web UIs.
-"""
-from .logging_facade import (
-	configure_logging,
-	get_logger,
-	print_message,
-	print_error,
-	print_translated_message,
-	print_translated_error,
-	configure_i18n,
-	translate_message,
-	get_message_stack,
-	clear_message_stack,
-	InMemoryLogHandler,
-)
-
-__all__ = [
-	"configure_logging",
-	"get_logger",
-	"print_message",
-	"print_error",
-	"print_translated_message",
-	"print_translated_error",
-	"configure_i18n",
-	"translate_message",
-	"get_message_stack",
-	"clear_message_stack",
-	"InMemoryLogHandler",
-]
+"""Shared utilities exports for ncplot7py.shared.
+
+This package exposes a small logging facade. The previous `OutputManager`
+implementation has been replaced by `logging_facade` which integrates with
+Python's `logging` module and provides an in-memory handler for web UIs.
+"""
+from .logging_facade import (
+	configure_logging,
+	get_logger,
+	print_message,
+	print_error,
+	print_translated_message,
+	print_translated_error,
+	configure_i18n,
+	translate_message,
+	get_message_stack,
+	clear_message_stack,
+	InMemoryLogHandler,
+)
+
+__all__ = [
+	"configure_logging",
+	"get_logger",
+	"print_message",
+	"print_error",
+	"print_translated_message",
+	"print_translated_error",
+	"configure_i18n",
+	"translate_message",
+	"get_message_stack",
+	"clear_message_stack",
+	"InMemoryLogHandler",
+]
diff --git a/src/ncplot7py/shared/__pycache__/__init__.cpython-313.pyc b/src/ncplot7py/shared/__pycache__/__init__.cpython-313.pyc
new file mode 100644
index 0000000..a309cfe
Binary files /dev/null and b/src/ncplot7py/shared/__pycache__/__init__.cpython-313.pyc differ
diff --git a/src/ncplot7py/shared/__pycache__/cnc_state.cpython-313.pyc b/src/ncplot7py/shared/__pycache__/cnc_state.cpython-313.pyc
new file mode 100644
index 0000000..5b237ea
Binary files /dev/null and b/src/ncplot7py/shared/__pycache__/cnc_state.cpython-313.pyc differ
diff --git a/src/ncplot7py/shared/__pycache__/exec_chain.cpython-313.pyc b/src/ncplot7py/shared/__pycache__/exec_chain.cpython-313.pyc
new file mode 100644
index 0000000..3152944
Binary files /dev/null and b/src/ncplot7py/shared/__pycache__/exec_chain.cpython-313.pyc differ
diff --git a/src/ncplot7py/shared/__pycache__/file_adapter.cpython-313.pyc b/src/ncplot7py/shared/__pycache__/file_adapter.cpython-313.pyc
new file mode 100644
index 0000000..33e18ca
Binary files /dev/null and b/src/ncplot7py/shared/__pycache__/file_adapter.cpython-313.pyc differ
diff --git a/src/ncplot7py/shared/__pycache__/linked_list_list.cpython-313.pyc b/src/ncplot7py/shared/__pycache__/linked_list_list.cpython-313.pyc
new file mode 100644
index 0000000..55db5dd
Binary files /dev/null and b/src/ncplot7py/shared/__pycache__/linked_list_list.cpython-313.pyc differ
diff --git a/src/ncplot7py/shared/__pycache__/logging_facade.cpython-313.pyc b/src/ncplot7py/shared/__pycache__/logging_facade.cpython-313.pyc
new file mode 100644
index 0000000..bc35a12
Binary files /dev/null and b/src/ncplot7py/shared/__pycache__/logging_facade.cpython-313.pyc differ
diff --git a/src/ncplot7py/shared/__pycache__/motion_chain.cpython-313.pyc b/src/ncplot7py/shared/__pycache__/motion_chain.cpython-313.pyc
new file mode 100644
index 0000000..0a178fd
Binary files /dev/null and b/src/ncplot7py/shared/__pycache__/motion_chain.cpython-313.pyc differ
diff --git a/src/ncplot7py/shared/__pycache__/nc_nodes.cpython-313.pyc b/src/ncplot7py/shared/__pycache__/nc_nodes.cpython-313.pyc
new file mode 100644
index 0000000..6c51560
Binary files /dev/null and b/src/ncplot7py/shared/__pycache__/nc_nodes.cpython-313.pyc differ
diff --git a/src/ncplot7py/shared/__pycache__/output_manager.cpython-313.pyc b/src/ncplot7py/shared/__pycache__/output_manager.cpython-313.pyc
new file mode 100644
index 0000000..e55cb08
Binary files /dev/null and b/src/ncplot7py/shared/__pycache__/output_manager.cpython-313.pyc differ
diff --git a/src/ncplot7py/shared/__pycache__/point.cpython-313.pyc b/src/ncplot7py/shared/__pycache__/point.cpython-313.pyc
new file mode 100644
index 0000000..15e0252
Binary files /dev/null and b/src/ncplot7py/shared/__pycache__/point.cpython-313.pyc differ
diff --git a/src/ncplot7py/shared/__pycache__/registry.cpython-313.pyc b/src/ncplot7py/shared/__pycache__/registry.cpython-313.pyc
new file mode 100644
index 0000000..4617cd3
Binary files /dev/null and b/src/ncplot7py/shared/__pycache__/registry.cpython-313.pyc differ
diff --git a/src/ncplot7py/shared/__pycache__/state_protocol.cpython-313.pyc b/src/ncplot7py/shared/__pycache__/state_protocol.cpython-313.pyc
new file mode 100644
index 0000000..40fe22a
Binary files /dev/null and b/src/ncplot7py/shared/__pycache__/state_protocol.cpython-313.pyc differ
diff --git a/src/ncplot7py/shared/file_adapter.py b/src/ncplot7py/shared/file_adapter.py
index ae1b518..7e12fbc 100644
--- a/src/ncplot7py/shared/file_adapter.py
+++ b/src/ncplot7py/shared/file_adapter.py
@@ -1,108 +1,108 @@
-"""
-File adapter utilities.
-
-Provides simple helpers to read file lines and build program strings while
-removing parenthesized content. This is a small, robust replacement for the
-snippet in the prompt.
-
-Functions
-- get_a_file(path, encoding='utf-8') -> list[str]
-- get_program(file_name_or_lines, split_on_blank_line=True) -> list[str]
-"""
-from __future__ import annotations
-
-import pathlib
-import re
-from typing import Iterable, List, Union
-
-
-def get_a_file(name: Union[str, pathlib.Path], encoding: str = "utf-8") -> List[str]:
-    """Read a text file and return its lines without trailing newlines.
-
-    Parameters
-    - name: path to the file (str or Path)
-    - encoding: file encoding
-
-    Returns
-    - list of lines (each line is a str, no trailing '\n')
-    """
-    path = pathlib.Path(name)
-    with path.open("r", encoding=encoding) as f:
-        # rstrip only the trailing newline characters, keep other whitespace
-        return [line.rstrip("\n\r") for line in f]
-
-
-def _remove_parentheses(text: str) -> str:
-    """Remove all parenthesized content, including nested parentheses.
-
-    Repeatedly removes occurrences of parenthesized chunks until none remain.
-    This handles nested parentheses by removing the innermost pairs first.
-    """
-    # quick bailout
-    if "(" not in text:
-        return text
-    # remove parentheses iteratively
-    pattern = re.compile(r"\([^()]*\)")
-    while True:
-        new = pattern.sub("", text)
-        if new == text:
-            break
-        text = new
-    return text
-
-
-def get_program(
-    file_name_or_lines: Union[str, pathlib.Path, Iterable[str]],
-    split_on_blank_line: bool = True,
-) -> List[str]:
-    """Build one or more program strings from a file or lines.
-
-    Behavior:
-    - If ``file_name_or_lines`` is a path (str/Path), the file is read as lines.
-    - Parenthesized content is removed from each line (handles nested).
-    - Lines that are empty after stripping are treated as blank separators when
-      ``split_on_blank_line`` is True; programs are split on these blank lines.
-    - Otherwise all non-empty processed lines are joined with ';' and returned
-      as a single-element list.
-
-    Returns a list of program strings (each program is a single string where
-    original lines are joined by ';'). Each program will not have a trailing
-    semicolon.
-    """
-    # accept either an iterable of lines or a filename
-    if isinstance(file_name_or_lines, (str, pathlib.Path)):
-        lines = get_a_file(file_name_or_lines)
-    else:
-        lines = list(file_name_or_lines)
-
-    processed_lines: List[str] = []
-    for raw in lines:
-        # remove newline already stripped by get_a_file; keep other whitespace
-        line = raw
-        # remove parenthesized segments
-        line = _remove_parentheses(line)
-        # collapse internal whitespace to single spaces (optional but helpful)
-        # preserve leading/trailing spaces for emptiness check
-        line = re.sub(r"\s+", " ", line)
-        processed_lines.append(line.strip())
-
-    if split_on_blank_line:
-        programs: List[str] = []
-        current: List[str] = []
-        for pline in processed_lines:
-            if pline == "":
-                if current:
-                    programs.append(";".join(current))
-                    current = []
-            else:
-                current.append(pline)
-        if current:
-            programs.append(";".join(current))
-        return programs
-    else:
-        # join all non-empty lines into a single program
-        all_lines = [l for l in processed_lines if l != ""]
-        return [";".join(all_lines)]
-
-
-__all__ = ["get_a_file", "get_program"]
+"""
+File adapter utilities.
+
+Provides simple helpers to read file lines and build program strings while
+removing parenthesized content. This is a small, robust replacement for the
+snippet in the prompt.
+
+Functions
+- get_a_file(path, encoding='utf-8') -> list[str]
+- get_program(file_name_or_lines, split_on_blank_line=True) -> list[str]
+"""
+from __future__ import annotations
+
+import pathlib
+import re
+from typing import Iterable, List, Union
+
+
+def get_a_file(name: Union[str, pathlib.Path], encoding: str = "utf-8") -> List[str]:
+    """Read a text file and return its lines without trailing newlines.
+
+    Parameters
+    - name: path to the file (str or Path)
+    - encoding: file encoding
+
+    Returns
+    - list of lines (each line is a str, no trailing '\n')
+    """
+    path = pathlib.Path(name)
+    with path.open("r", encoding=encoding) as f:
+        # rstrip only the trailing newline characters, keep other whitespace
+        return [line.rstrip("\n\r") for line in f]
+
+
+def _remove_parentheses(text: str) -> str:
+    """Remove all parenthesized content, including nested parentheses.
+
+    Repeatedly removes occurrences of parenthesized chunks until none remain.
+    This handles nested parentheses by removing the innermost pairs first.
+    """
+    # quick bailout
+    if "(" not in text:
+        return text
+    # remove parentheses iteratively
+    pattern = re.compile(r"\([^()]*\)")
+    while True:
+        new = pattern.sub("", text)
+        if new == text:
+            break
+        text = new
+    return text
+
+
+def get_program(
+    file_name_or_lines: Union[str, pathlib.Path, Iterable[str]],
+    split_on_blank_line: bool = True,
+) -> List[str]:
+    """Build one or more program strings from a file or lines.
+
+    Behavior:
+    - If ``file_name_or_lines`` is a path (str/Path), the file is read as lines.
+    - Parenthesized content is removed from each line (handles nested).
+    - Lines that are empty after stripping are treated as blank separators when
+      ``split_on_blank_line`` is True; programs are split on these blank lines.
+    - Otherwise all non-empty processed lines are joined with ';' and returned
+      as a single-element list.
+
+    Returns a list of program strings (each program is a single string where
+    original lines are joined by ';'). Each program will not have a trailing
+    semicolon.
+    """
+    # accept either an iterable of lines or a filename
+    if isinstance(file_name_or_lines, (str, pathlib.Path)):
+        lines = get_a_file(file_name_or_lines)
+    else:
+        lines = list(file_name_or_lines)
+
+    processed_lines: List[str] = []
+    for raw in lines:
+        # remove newline already stripped by get_a_file; keep other whitespace
+        line = raw
+        # remove parenthesized segments
+        line = _remove_parentheses(line)
+        # collapse internal whitespace to single spaces (optional but helpful)
+        # preserve leading/trailing spaces for emptiness check
+        line = re.sub(r"\s+", " ", line)
+        processed_lines.append(line.strip())
+
+    if split_on_blank_line:
+        programs: List[str] = []
+        current: List[str] = []
+        for pline in processed_lines:
+            if pline == "":
+                if current:
+                    programs.append(";".join(current))
+                    current = []
+            else:
+                current.append(pline)
+        if current:
+            programs.append(";".join(current))
+        return programs
+    else:
+        # join all non-empty lines into a single program
+        all_lines = [l for l in processed_lines if l != ""]
+        return [";".join(all_lines)]
+
+
+__all__ = ["get_a_file", "get_program"]
diff --git a/src/ncplot7py/shared/linked_list_list.py b/src/ncplot7py/shared/linked_list_list.py
index 7b51d5f..1deaae4 100644
--- a/src/ncplot7py/shared/linked_list_list.py
+++ b/src/ncplot7py/shared/linked_list_list.py
@@ -1,77 +1,77 @@
-"""Linked-list-like wrapper implemented with a Python built-in list.
-
-This provides a small API similar to a doubly-linked list (append, insert_after,
-remove, get_node_from_index) but implemented on top of Python's list. Operations
-that require finding a node by reference are O(n) because the underlying list
-must be searched. Use this when you want linked-list semantics but prefer to
-avoid per-node Python objects or explicit linked pointers.
-
-Notes:
-- append: O(1) amortized
-- insert_after: O(n) to find the target + O(n) to shift elements -> O(n)
-- remove: O(n)
-
-This is a pragmatic compromise: for many NC-code workloads the list approach
-is simpler and fast enough. If you need many O(1) arbitrary inserts/removes by
-node reference, prefer a true linked list implementation.
-"""
-from __future__ import annotations
-
-from typing import Generic, Iterable, Iterator, List, TypeVar
-
-T = TypeVar("T")
-
-from ..interfaces.BaseLinkedListAsList import BaseLinkedListAsList
-
-
-class LinkedListAsList(BaseLinkedListAsList[T], Generic[T]):
-    """A thin wrapper exposing linked-list-like operations backed by a list.
-
-    Example:
-        nodes = LinkedListAsList[NCNode]()
-        nodes.append(node_a)
-        nodes.append(node_b)
-        nodes.insert_after(node_a, node_x)
-    """
-
-    def __init__(self, items: Iterable[T] | None = None) -> None:
-        self._data: List[T] = list(items) if items is not None else []
-
-    def append(self, item: T) -> None:
-        """Append item to the end (amortized O(1))."""
-        self._data.append(item)
-
-    def insert_after(self, target: T, item: T) -> None:
-        """Insert `item` immediately after `target`.
-
-        Raises ValueError if target is not present.
-        Complexity: O(n) to find + O(n) to insert (shifting) => O(n)
-        """
-        idx = self._data.index(target)  # raises ValueError if not found
-        self._data.insert(idx + 1, item)
-
-    def remove(self, target: T) -> T:
-        """Remove `target` from the list and return it.
-
-        Raises ValueError if target is not present.
-        """
-        idx = self._data.index(target)
-        return self._data.pop(idx)
-
-    def remove_at_index(self, index: int) -> T:
-        return self._data.pop(index)
-
-    def get_node_from_index(self, index: int) -> T:
-        return self._data[index]
-
-    def __len__(self) -> int:
-        return len(self._data)
-
-    def __iter__(self) -> Iterator[T]:
-        return iter(self._data)
-
-    def to_list(self) -> List[T]:
-        return list(self._data)
-
-    def __repr__(self) -> str:  # pragma: no cover - convenience
-        return f"LinkedListAsList({self._data!r})"
+"""Linked-list-like wrapper implemented with a Python built-in list.
+
+This provides a small API similar to a doubly-linked list (append, insert_after,
+remove, get_node_from_index) but implemented on top of Python's list. Operations
+that require finding a node by reference are O(n) because the underlying list
+must be searched. Use this when you want linked-list semantics but prefer to
+avoid per-node Python objects or explicit linked pointers.
+
+Notes:
+- append: O(1) amortized
+- insert_after: O(n) to find the target + O(n) to shift elements -> O(n)
+- remove: O(n)
+
+This is a pragmatic compromise: for many NC-code workloads the list approach
+is simpler and fast enough. If you need many O(1) arbitrary inserts/removes by
+node reference, prefer a true linked list implementation.
+"""
+from __future__ import annotations
+
+from typing import Generic, Iterable, Iterator, List, TypeVar
+
+T = TypeVar("T")
+
+from ..interfaces.BaseLinkedListAsList import BaseLinkedListAsList
+
+
+class LinkedListAsList(BaseLinkedListAsList[T], Generic[T]):
+    """A thin wrapper exposing linked-list-like operations backed by a list.
+
+    Example:
+        nodes = LinkedListAsList[NCNode]()
+        nodes.append(node_a)
+        nodes.append(node_b)
+        nodes.insert_after(node_a, node_x)
+    """
+
+    def __init__(self, items: Iterable[T] | None = None) -> None:
+        self._data: List[T] = list(items) if items is not None else []
+
+    def append(self, item: T) -> None:
+        """Append item to the end (amortized O(1))."""
+        self._data.append(item)
+
+    def insert_after(self, target: T, item: T) -> None:
+        """Insert `item` immediately after `target`.
+
+        Raises ValueError if target is not present.
+        Complexity: O(n) to find + O(n) to insert (shifting) => O(n)
+        """
+        idx = self._data.index(target)  # raises ValueError if not found
+        self._data.insert(idx + 1, item)
+
+    def remove(self, target: T) -> T:
+        """Remove `target` from the list and return it.
+
+        Raises ValueError if target is not present.
+        """
+        idx = self._data.index(target)
+        return self._data.pop(idx)
+
+    def remove_at_index(self, index: int) -> T:
+        return self._data.pop(index)
+
+    def get_node_from_index(self, index: int) -> T:
+        return self._data[index]
+
+    def __len__(self) -> int:
+        return len(self._data)
+
+    def __iter__(self) -> Iterator[T]:
+        return iter(self._data)
+
+    def to_list(self) -> List[T]:
+        return list(self._data)
+
+    def __repr__(self) -> str:  # pragma: no cover - convenience
+        return f"LinkedListAsList({self._data!r})"
diff --git a/src/ncplot7py/shared/logging_facade.py b/src/ncplot7py/shared/logging_facade.py
index e653d30..ee5775b 100644
--- a/src/ncplot7py/shared/logging_facade.py
+++ b/src/ncplot7py/shared/logging_facade.py
@@ -1,198 +1,198 @@
-"""Logging facade for ncplot7py.
-
-Provides a small wrapper around Python's `logging` module that keeps the
-callers' API small (print_message, print_error) and also supplies an
-in-memory handler suitable for web UIs to collect recent log messages.
-
-Usage:
-    from ncplot7py.shared.logging_facade import configure_logging, print_message
-    configure_logging(console=True, web_buffer=True)
-    print_message("hello")
-
-The facade exposes `get_message_stack()` which returns the collected web
-messages when `web_buffer=True` was used during configuration.
-"""
-from __future__ import annotations
-
-import logging
-from collections import deque
-from typing import Deque, List, Optional
-from typing import Any
-
-
-# i18n support (lazy import to avoid import cycles when package is imported)
-_catalog: Optional[Any] = None
-_default_lang: str = "en"
-
-
-def configure_i18n(catalog: Optional[Any] = None, default_lang: str = "en") -> None:
-    """Configure a MessageCatalog instance for translations.
-
-    If `catalog` is None the function will create a default
-    `ncplot7py.domain.i18n.MessageCatalog` instance.
-    """
-    global _catalog, _default_lang
-    _default_lang = default_lang
-    if catalog is None:
-        try:
-            from ncplot7py.domain.i18n import MessageCatalog  # type: ignore
-
-            _catalog = MessageCatalog()
-        except Exception:
-            _catalog = None
-    else:
-        _catalog = catalog
-
-
-def translate_message(key: Any, lang: Optional[str] = None, **params: Any) -> str:
-    """Translate a message `key` via the configured MessageCatalog.
-
-    `key` is expected to be a `MessageKey` instance from
-    `ncplot7py.domain.i18n`. If translation fails or no catalog is
-    configured, falls back to formatting `str(key)` with params.
-    """
-    if lang is None:
-        lang = _default_lang
-    if _catalog is None:
-        # No catalog configured, fall back
-        try:
-            return str(key).format(**params)
-        except Exception:
-            return str(key)
-    try:
-        # MessageCatalog.get_template expects a MessageKey-like object
-        template = _catalog.get_template(lang, key)
-        if template:
-            try:
-                return template.format(**params)
-            except Exception:
-                return template
-        # fallback: format the key or use provided params
-        try:
-            return str(key).format(**params)
-        except Exception:
-            return str(key)
-    except Exception:
-        try:
-            return str(key).format(**params)
-        except Exception:
-            return str(key)
-
-
-class InMemoryLogHandler(logging.Handler):
-    """A simple bounded in-memory log handler.
-
-    Stores formatted log records in a deque with a configurable maximum
-    length. Call `get_messages()` to retrieve the stored messages (most
-    recent last).
-    """
-
-    def __init__(self, maxlen: int = 1000):
-        super().__init__()
-        self._buffer: Deque[str] = deque(maxlen=maxlen)
-
-    def emit(self, record: logging.LogRecord) -> None:
-        try:
-            msg = self.format(record)
-        except Exception:
-            msg = record.getMessage()
-        self._buffer.append(msg)
-
-    def get_messages(self) -> List[str]:
-        return list(self._buffer)
-
-    def clear(self) -> None:
-        self._buffer.clear()
-
-
-# Module-level state
-_logger_name = "ncplot7py"
-_logger: logging.Logger = logging.getLogger(_logger_name)
-_in_memory_handler: Optional[InMemoryLogHandler] = None
-
-
-def configure_logging(*, console: bool = True, web_buffer: bool = False,
-                      level: int = logging.INFO, buffer_maxlen: int = 1000) -> None:
-    """Configure the `ncplot7py` logger.
-
-    - console: attach a StreamHandler to stdout/stderr
-    - web_buffer: attach an in-memory handler for later retrieval
-    - level: logging level for the logger and handlers
-    - buffer_maxlen: max messages kept by the in-memory handler
-    """
-
-    global _logger, _in_memory_handler
-
-    # Remove existing handlers to allow reconfiguration
-    _logger = logging.getLogger(_logger_name)
-    _logger.setLevel(level)
-    for h in list(_logger.handlers):
-        _logger.removeHandler(h)
-
-    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
-
-    if console:
-        ch = logging.StreamHandler()
-        ch.setLevel(level)
-        ch.setFormatter(formatter)
-        _logger.addHandler(ch)
-
-    if web_buffer:
-        _in_memory_handler = InMemoryLogHandler(maxlen=buffer_maxlen)
-        _in_memory_handler.setLevel(level)
-        _in_memory_handler.setFormatter(formatter)
-        _logger.addHandler(_in_memory_handler)
-    else:
-        _in_memory_handler = None
-
-
-def get_logger() -> logging.Logger:
-    return _logger
-
-
-def print_message(msg: str) -> None:
-    _logger.info(msg)
-
-
-def print_error(msg: str) -> None:
-    _logger.error(msg)
-
-
-def print_translated_message(key: Any, lang: Optional[str] = None, **params: Any) -> None:
-    text = translate_message(key, lang=lang, **params)
-    _logger.info(text)
-
-
-def print_translated_error(key: Any, lang: Optional[str] = None, **params: Any) -> None:
-    text = translate_message(key, lang=lang, **params)
-    _logger.error(text)
-
-
-def get_message_stack() -> str:
-    """Return the collected web messages joined with newlines.
-
-    If the in-memory handler is not configured, returns an empty string.
-    """
-    if _in_memory_handler is None:
-        return ""
-    return "\n".join(_in_memory_handler.get_messages())
-
-
-def clear_message_stack() -> None:
-    if _in_memory_handler is not None:
-        _in_memory_handler.clear()
-
-
-__all__ = [
-    "configure_logging",
-    "get_logger",
-    "print_message",
-    "print_error",
-    "print_translated_message",
-    "print_translated_error",
-    "configure_i18n",
-    "translate_message",
-    "get_message_stack",
-    "clear_message_stack",
-    "InMemoryLogHandler",
-]
+"""Logging facade for ncplot7py.
+
+Provides a small wrapper around Python's `logging` module that keeps the
+callers' API small (print_message, print_error) and also supplies an
+in-memory handler suitable for web UIs to collect recent log messages.
+
+Usage:
+    from ncplot7py.shared.logging_facade import configure_logging, print_message
+    configure_logging(console=True, web_buffer=True)
+    print_message("hello")
+
+The facade exposes `get_message_stack()` which returns the collected web
+messages when `web_buffer=True` was used during configuration.
+"""
+from __future__ import annotations
+
+import logging
+from collections import deque
+from typing import Deque, List, Optional
+from typing import Any
+
+
+# i18n support (lazy import to avoid import cycles when package is imported)
+_catalog: Optional[Any] = None
+_default_lang: str = "en"
+
+
+def configure_i18n(catalog: Optional[Any] = None, default_lang: str = "en") -> None:
+    """Configure a MessageCatalog instance for translations.
+
+    If `catalog` is None the function will create a default
+    `ncplot7py.domain.i18n.MessageCatalog` instance.
+    """
+    global _catalog, _default_lang
+    _default_lang = default_lang
+    if catalog is None:
+        try:
+            from ncplot7py.domain.i18n import MessageCatalog  # type: ignore
+
+            _catalog = MessageCatalog()
+        except Exception:
+            _catalog = None
+    else:
+        _catalog = catalog
+
+
+def translate_message(key: Any, lang: Optional[str] = None, **params: Any) -> str:
+    """Translate a message `key` via the configured MessageCatalog.
+
+    `key` is expected to be a `MessageKey` instance from
+    `ncplot7py.domain.i18n`. If translation fails or no catalog is
+    configured, falls back to formatting `str(key)` with params.
+    """
+    if lang is None:
+        lang = _default_lang
+    if _catalog is None:
+        # No catalog configured, fall back
+        try:
+            return str(key).format(**params)
+        except Exception:
+            return str(key)
+    try:
+        # MessageCatalog.get_template expects a MessageKey-like object
+        template = _catalog.get_template(lang, key)
+        if template:
+            try:
+                return template.format(**params)
+            except Exception:
+                return template
+        # fallback: format the key or use provided params
+        try:
+            return str(key).format(**params)
+        except Exception:
+            return str(key)
+    except Exception:
+        try:
+            return str(key).format(**params)
+        except Exception:
+            return str(key)
+
+
+class InMemoryLogHandler(logging.Handler):
+    """A simple bounded in-memory log handler.
+
+    Stores formatted log records in a deque with a configurable maximum
+    length. Call `get_messages()` to retrieve the stored messages (most
+    recent last).
+    """
+
+    def __init__(self, maxlen: int = 1000):
+        super().__init__()
+        self._buffer: Deque[str] = deque(maxlen=maxlen)
+
+    def emit(self, record: logging.LogRecord) -> None:
+        try:
+            msg = self.format(record)
+        except Exception:
+            msg = record.getMessage()
+        self._buffer.append(msg)
+
+    def get_messages(self) -> List[str]:
+        return list(self._buffer)
+
+    def clear(self) -> None:
+        self._buffer.clear()
+
+
+# Module-level state
+_logger_name = "ncplot7py"
+_logger: logging.Logger = logging.getLogger(_logger_name)
+_in_memory_handler: Optional[InMemoryLogHandler] = None
+
+
+def configure_logging(*, console: bool = True, web_buffer: bool = False,
+                      level: int = logging.INFO, buffer_maxlen: int = 1000) -> None:
+    """Configure the `ncplot7py` logger.
+
+    - console: attach a StreamHandler to stdout/stderr
+    - web_buffer: attach an in-memory handler for later retrieval
+    - level: logging level for the logger and handlers
+    - buffer_maxlen: max messages kept by the in-memory handler
+    """
+
+    global _logger, _in_memory_handler
+
+    # Remove existing handlers to allow reconfiguration
+    _logger = logging.getLogger(_logger_name)
+    _logger.setLevel(level)
+    for h in list(_logger.handlers):
+        _logger.removeHandler(h)
+
+    formatter = logging.Formatter("%(asctime)s - %(levelname)s - %(message)s")
+
+    if console:
+        ch = logging.StreamHandler()
+        ch.setLevel(level)
+        ch.setFormatter(formatter)
+        _logger.addHandler(ch)
+
+    if web_buffer:
+        _in_memory_handler = InMemoryLogHandler(maxlen=buffer_maxlen)
+        _in_memory_handler.setLevel(level)
+        _in_memory_handler.setFormatter(formatter)
+        _logger.addHandler(_in_memory_handler)
+    else:
+        _in_memory_handler = None
+
+
+def get_logger() -> logging.Logger:
+    return _logger
+
+
+def print_message(msg: str) -> None:
+    _logger.info(msg)
+
+
+def print_error(msg: str) -> None:
+    _logger.error(msg)
+
+
+def print_translated_message(key: Any, lang: Optional[str] = None, **params: Any) -> None:
+    text = translate_message(key, lang=lang, **params)
+    _logger.info(text)
+
+
+def print_translated_error(key: Any, lang: Optional[str] = None, **params: Any) -> None:
+    text = translate_message(key, lang=lang, **params)
+    _logger.error(text)
+
+
+def get_message_stack() -> str:
+    """Return the collected web messages joined with newlines.
+
+    If the in-memory handler is not configured, returns an empty string.
+    """
+    if _in_memory_handler is None:
+        return ""
+    return "\n".join(_in_memory_handler.get_messages())
+
+
+def clear_message_stack() -> None:
+    if _in_memory_handler is not None:
+        _in_memory_handler.clear()
+
+
+__all__ = [
+    "configure_logging",
+    "get_logger",
+    "print_message",
+    "print_error",
+    "print_translated_message",
+    "print_translated_error",
+    "configure_i18n",
+    "translate_message",
+    "get_message_stack",
+    "clear_message_stack",
+    "InMemoryLogHandler",
+]
diff --git a/src/ncplot7py/shared/nc_nodes.py b/src/ncplot7py/shared/nc_nodes.py
index 88a4ee6..feeacc7 100644
--- a/src/ncplot7py/shared/nc_nodes.py
+++ b/src/ncplot7py/shared/nc_nodes.py
@@ -1,110 +1,110 @@
-"""NC command node definitions used to represent parsed NC/G-code commands.
-
-This module provides an `NCCommandNode` class following the shape of the
-user-provided example but adapted to the project's style and typing. The
-node keeps optional `_next_ncCode` and `_before_ncCode` attributes for
-interop with linked-list implementations that expect those fields.
-"""
-from __future__ import annotations
-
-from copy import deepcopy
-from typing import Dict, Optional, Set
-
-from ..interfaces.BaseNCCommandNode import BaseNCCommandNode
-
-
-class NCCommandNode(BaseNCCommandNode):
-    """A node representing a single NC command.
-
-    Attributes are kept intentionally simple and use standard Python types.
-    _next_ncCode and _before_ncCode are provided for compatibility with
-    linked-list implementations that expect those attributes.
-    """
-
-    def __init__(
-        self,
-        g_code_command: Optional[Set[str]] = None,
-        command_parameter: Optional[Dict[str, str]] = None,
-        loop_command: Optional[str] = None,
-        variable_command: Optional[str] = None,
-        dddp_command: Optional[Set[str]] = None,
-        nc_code_line_nr: Optional[int] = None,
-    ) -> None:
-        # store data in private attributes to avoid colliding with the
-        # abstract-property names exposed by the interface
-        self._g_code: Set[str] = set(g_code_command or [])
-        self._command_parameter: Dict[str, str] = dict(command_parameter or {})
-        self._loop_command = loop_command
-        self._variable_command = variable_command
-        self._dddp_command: Set[str] = set(dddp_command or [])
-        self._nc_code_line_nr: Optional[int] = nc_code_line_nr
-
-        # Optional pointers for linked-list style containers
-        self._next_ncCode: Optional["NCCommandNode"] = None
-        self._before_ncCode: Optional["NCCommandNode"] = None
-
-    # Implement abstract properties from BaseNCCommandNode
-    @property
-    def g_code(self) -> Set[str]:
-        return self._g_code
-
-    @property
-    def command_parameter(self) -> Dict[str, str]:
-        return self._command_parameter
-
-    @property
-    def loop_command(self) -> Optional[str]:
-        return self._loop_command
-
-    @property
-    def variable_command(self) -> Optional[str]:
-        return self._variable_command
-
-    @property
-    def dddp_command(self) -> Set[str]:
-        return self._dddp_command
-
-    @property
-    def nc_code_line_nr(self) -> Optional[int]:
-        return self._nc_code_line_nr
-
-    def __str__(self) -> str:
-        parts = ["NC COMMAND: "]
-        if self.g_code:
-            parts.append("G,codes=")
-            parts.append(",".join(sorted(self.g_code)))
-        if self.command_parameter:
-            parts.append(" params=")
-            parts.append(",".join(f"{k}={v}" for k, v in self.command_parameter.items()))
-        if self.nc_code_line_nr is not None:
-            parts.append(f" line={self.nc_code_line_nr}")
-        return "".join(parts)
-
-    def copy(self) -> "NCCommandNode":
-        """Return a deep copy of the node (pointers are not deeply copied).
-
-        The original example copied next pointers shallowly; here we copy
-        node attributes deeply but keep `_next_ncCode` as a shallow reference
-        to avoid copying an entire list structure.
-        """
-        node = NCCommandNode(
-            g_code_command=set(self.g_code),
-            command_parameter=deepcopy(self.command_parameter),
-            loop_command=self.loop_command,
-            variable_command=self.variable_command,
-            dddp_command=set(self.dddp_command),
-            nc_code_line_nr=self.nc_code_line_nr,
-        )
-        node._next_ncCode = self._next_ncCode
-        node._before_ncCode = self._before_ncCode
-        return node
-
-    def __del__(self) -> None:
-        # Break pointers to help garbage collection in long-lived lists.
-        self._next_ncCode = None
-        self._before_ncCode = None
-
-    def __iter__(self):
-        # Return an iterator for convenience; by default just yield this node.
-        yield self
-
+"""NC command node definitions used to represent parsed NC/G-code commands.
+
+This module provides an `NCCommandNode` class following the shape of the
+user-provided example but adapted to the project's style and typing. The
+node keeps optional `_next_ncCode` and `_before_ncCode` attributes for
+interop with linked-list implementations that expect those fields.
+"""
+from __future__ import annotations
+
+from copy import deepcopy
+from typing import Dict, Optional, Set
+
+from ..interfaces.BaseNCCommandNode import BaseNCCommandNode
+
+
+class NCCommandNode(BaseNCCommandNode):
+    """A node representing a single NC command.
+
+    Attributes are kept intentionally simple and use standard Python types.
+    _next_ncCode and _before_ncCode are provided for compatibility with
+    linked-list implementations that expect those attributes.
+    """
+
+    def __init__(
+        self,
+        g_code_command: Optional[Set[str]] = None,
+        command_parameter: Optional[Dict[str, str]] = None,
+        loop_command: Optional[str] = None,
+        variable_command: Optional[str] = None,
+        dddp_command: Optional[Set[str]] = None,
+        nc_code_line_nr: Optional[int] = None,
+    ) -> None:
+        # store data in private attributes to avoid colliding with the
+        # abstract-property names exposed by the interface
+        self._g_code: Set[str] = set(g_code_command or [])
+        self._command_parameter: Dict[str, str] = dict(command_parameter or {})
+        self._loop_command = loop_command
+        self._variable_command = variable_command
+        self._dddp_command: Set[str] = set(dddp_command or [])
+        self._nc_code_line_nr: Optional[int] = nc_code_line_nr
+
+        # Optional pointers for linked-list style containers
+        self._next_ncCode: Optional["NCCommandNode"] = None
+        self._before_ncCode: Optional["NCCommandNode"] = None
+
+    # Implement abstract properties from BaseNCCommandNode
+    @property
+    def g_code(self) -> Set[str]:
+        return self._g_code
+
+    @property
+    def command_parameter(self) -> Dict[str, str]:
+        return self._command_parameter
+
+    @property
+    def loop_command(self) -> Optional[str]:
+        return self._loop_command
+
+    @property
+    def variable_command(self) -> Optional[str]:
+        return self._variable_command
+
+    @property
+    def dddp_command(self) -> Set[str]:
+        return self._dddp_command
+
+    @property
+    def nc_code_line_nr(self) -> Optional[int]:
+        return self._nc_code_line_nr
+
+    def __str__(self) -> str:
+        parts = ["NC COMMAND: "]
+        if self.g_code:
+            parts.append("G,codes=")
+            parts.append(",".join(sorted(self.g_code)))
+        if self.command_parameter:
+            parts.append(" params=")
+            parts.append(",".join(f"{k}={v}" for k, v in self.command_parameter.items()))
+        if self.nc_code_line_nr is not None:
+            parts.append(f" line={self.nc_code_line_nr}")
+        return "".join(parts)
+
+    def copy(self) -> "NCCommandNode":
+        """Return a deep copy of the node (pointers are not deeply copied).
+
+        The original example copied next pointers shallowly; here we copy
+        node attributes deeply but keep `_next_ncCode` as a shallow reference
+        to avoid copying an entire list structure.
+        """
+        node = NCCommandNode(
+            g_code_command=set(self.g_code),
+            command_parameter=deepcopy(self.command_parameter),
+            loop_command=self.loop_command,
+            variable_command=self.variable_command,
+            dddp_command=set(self.dddp_command),
+            nc_code_line_nr=self.nc_code_line_nr,
+        )
+        node._next_ncCode = self._next_ncCode
+        node._before_ncCode = self._before_ncCode
+        return node
+
+    def __del__(self) -> None:
+        # Break pointers to help garbage collection in long-lived lists.
+        self._next_ncCode = None
+        self._before_ncCode = None
+
+    def __iter__(self):
+        # Return an iterator for convenience; by default just yield this node.
+        yield self
+
diff --git a/src/ncplot7py/shared/point.py b/src/ncplot7py/shared/point.py
index 860d579..2442eb8 100644
--- a/src/ncplot7py/shared/point.py
+++ b/src/ncplot7py/shared/point.py
@@ -1,21 +1,21 @@
-from __future__ import annotations
-
-from dataclasses import dataclass
-
-
-@dataclass
-class Point:
-    """Simple point / toolpath vertex used across the codebase.
-
-    Placing this in `shared` ensures the small data shape is available to
-    infrastructure and application layers without importing domain handlers.
-    """
-    x: float
-    y: float
-    z: float
-    a: float = 0.0
-    b: float = 0.0
-    c: float = 0.0
-
-
-__all__ = ["Point"]
+from __future__ import annotations
+
+from dataclasses import dataclass
+
+
+@dataclass
+class Point:
+    """Simple point / toolpath vertex used across the codebase.
+
+    Placing this in `shared` ensures the small data shape is available to
+    infrastructure and application layers without importing domain handlers.
+    """
+    x: float
+    y: float
+    z: float
+    a: float = 0.0
+    b: float = 0.0
+    c: float = 0.0
+
+
+__all__ = ["Point"]
diff --git a/src/ncplot7py/shared/registry.py b/src/ncplot7py/shared/registry.py
index 14a038b..713ad3e 100644
--- a/src/ncplot7py/shared/registry.py
+++ b/src/ncplot7py/shared/registry.py
@@ -1,24 +1,24 @@
-"""Simple registry for parsers, machines and plotters.
-
-This keeps the example small; for production consider entry_points or a plugin
-system via importlib.metadata.
-"""
-from __future__ import annotations
-
-from typing import Dict, Type
-
-
-class Registry:
-    def __init__(self):
-        self._data: Dict[str, Dict[str, Type]] = {}
-
-    def register(self, kind: str, name: str, cls: Type) -> None:
-        self._data.setdefault(kind, {})[name] = cls
-
-    def get(self, kind: str, name: str):
-        return self._data.get(kind, {}).get(name)
-
-
-registry = Registry()
-
-
+"""Simple registry for parsers, machines and plotters.
+
+This keeps the example small; for production consider entry_points or a plugin
+system via importlib.metadata.
+"""
+from __future__ import annotations
+
+from typing import Dict, Type
+
+
+class Registry:
+    def __init__(self):
+        self._data: Dict[str, Dict[str, Type]] = {}
+
+    def register(self, kind: str, name: str, cls: Type) -> None:
+        self._data.setdefault(kind, {})[name] = cls
+
+    def get(self, kind: str, name: str):
+        return self._data.get(kind, {}).get(name)
+
+
+registry = Registry()
+
+
diff --git a/src/ncplot7py/shared/state_protocol.py b/src/ncplot7py/shared/state_protocol.py
index 9fde7ea..06b9c40 100644
--- a/src/ncplot7py/shared/state_protocol.py
+++ b/src/ncplot7py/shared/state_protocol.py
@@ -1,33 +1,33 @@
-"""Lightweight protocol describing the parts of CNCState handlers use.
-
-Placed under `shared` so other layers can depend on this contract without
-importing the full domain model.
-"""
-from __future__ import annotations
-
-from typing import Protocol, Dict, Any, Optional
-
-
-class StateProtocol(Protocol):
-    """Subset of CNCState used by handlers and the exec chain.
-
-    Keep this minimal — handlers should not rely on the full implementation.
-    """
-
-    axes: Dict[str, float]
-    feed_rate: Optional[float]
-
-    def resolve_target(self, target_spec: Dict[str, float], absolute: bool = True) -> Dict[str, float]:
-        ...
-
-    def update_axes(self, updates: Dict[str, float]) -> None:
-        ...
-
-    def get_modal(self, group: str) -> Optional[str]:
-        ...
-
-    def compute_distance(self, a: Dict[str, float], b: Dict[str, float], axes: Optional[list[str]] = None) -> float:
-        ...
-
-
-__all__ = ["StateProtocol"]
+"""Lightweight protocol describing the parts of CNCState handlers use.
+
+Placed under `shared` so other layers can depend on this contract without
+importing the full domain model.
+"""
+from __future__ import annotations
+
+from typing import Protocol, Dict, Any, Optional
+
+
+class StateProtocol(Protocol):
+    """Subset of CNCState used by handlers and the exec chain.
+
+    Keep this minimal — handlers should not rely on the full implementation.
+    """
+
+    axes: Dict[str, float]
+    feed_rate: Optional[float]
+
+    def resolve_target(self, target_spec: Dict[str, float], absolute: bool = True) -> Dict[str, float]:
+        ...
+
+    def update_axes(self, updates: Dict[str, float]) -> None:
+        ...
+
+    def get_modal(self, group: str) -> Optional[str]:
+        ...
+
+    def compute_distance(self, a: Dict[str, float], b: Dict[str, float], axes: Optional[list[str]] = None) -> float:
+        ...
+
+
+__all__ = ["StateProtocol"]
diff --git a/tests/integration/__pycache__/test_example_O0004.cpython-313.pyc b/tests/integration/__pycache__/test_example_O0004.cpython-313.pyc
new file mode 100644
index 0000000..2d2a7f3
Binary files /dev/null and b/tests/integration/__pycache__/test_example_O0004.cpython-313.pyc differ
diff --git a/tests/integration/__pycache__/test_hexagon_O6POINT.cpython-313.pyc b/tests/integration/__pycache__/test_hexagon_O6POINT.cpython-313.pyc
new file mode 100644
index 0000000..ebd96f8
Binary files /dev/null and b/tests/integration/__pycache__/test_hexagon_O6POINT.cpython-313.pyc differ
diff --git a/tests/integration/__pycache__/test_lathe_diameter_mode.cpython-313.pyc b/tests/integration/__pycache__/test_lathe_diameter_mode.cpython-313.pyc
new file mode 100644
index 0000000..d10b1a5
Binary files /dev/null and b/tests/integration/__pycache__/test_lathe_diameter_mode.cpython-313.pyc differ
diff --git a/tests/integration/__pycache__/test_o6point_while_loop.cpython-313-pytest-8.4.2.pyc b/tests/integration/__pycache__/test_o6point_while_loop.cpython-313-pytest-8.4.2.pyc
new file mode 100644
index 0000000..92a526c
Binary files /dev/null and b/tests/integration/__pycache__/test_o6point_while_loop.cpython-313-pytest-8.4.2.pyc differ
diff --git a/tests/integration/__pycache__/test_o6point_while_loop.cpython-313.pyc b/tests/integration/__pycache__/test_o6point_while_loop.cpython-313.pyc
new file mode 100644
index 0000000..3e643ba
Binary files /dev/null and b/tests/integration/__pycache__/test_o6point_while_loop.cpython-313.pyc differ
diff --git a/tests/integration/__pycache__/test_polar_plane_restore.cpython-313.pyc b/tests/integration/__pycache__/test_polar_plane_restore.cpython-313.pyc
new file mode 100644
index 0000000..9894d9c
Binary files /dev/null and b/tests/integration/__pycache__/test_polar_plane_restore.cpython-313.pyc differ
diff --git a/tests/integration/__pycache__/test_simple_program.cpython-313.pyc b/tests/integration/__pycache__/test_simple_program.cpython-313.pyc
new file mode 100644
index 0000000..83b36e7
Binary files /dev/null and b/tests/integration/__pycache__/test_simple_program.cpython-313.pyc differ
diff --git a/tests/integration/__pycache__/test_star_canal_syncro_integration.cpython-313.pyc b/tests/integration/__pycache__/test_star_canal_syncro_integration.cpython-313.pyc
new file mode 100644
index 0000000..6059d5d
Binary files /dev/null and b/tests/integration/__pycache__/test_star_canal_syncro_integration.cpython-313.pyc differ
diff --git a/tests/integration/__pycache__/test_stateful_iso_turn_control.cpython-313.pyc b/tests/integration/__pycache__/test_stateful_iso_turn_control.cpython-313.pyc
new file mode 100644
index 0000000..bbb3ff1
Binary files /dev/null and b/tests/integration/__pycache__/test_stateful_iso_turn_control.cpython-313.pyc differ
diff --git a/tests/integration/__pycache__/test_while_do_end.cpython-313.pyc b/tests/integration/__pycache__/test_while_do_end.cpython-313.pyc
new file mode 100644
index 0000000..7302898
Binary files /dev/null and b/tests/integration/__pycache__/test_while_do_end.cpython-313.pyc differ
diff --git a/tests/integration/test_example_O0004.py b/tests/integration/test_example_O0004.py
index 111562f..d8250a7 100644
--- a/tests/integration/test_example_O0004.py
+++ b/tests/integration/test_example_O0004.py
@@ -1,88 +1,88 @@
-import os
-import sys
-import unittest
-from pathlib import Path
-
-# Ensure package imports from src are resolvable when running tests directly
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
-
-from ncplot7py.application.nc_execution import NCExecutionEngine
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.shared import configure_logging, get_message_stack, configure_i18n
-
-
-class _Point:
-    def __init__(self, x, y, z):
-        self.x = x
-        self.y = y
-        self.z = z
-
-
-class SimpleFakeControl:
-    def __init__(self):
-        self._canal_nodes = {}
-
-    def get_canal_count(self):
-        return 1
-
-    def run_nc_code_list(self, node_list, canal):
-        self._canal_nodes[canal] = list(node_list)
-
-    def get_tool_path(self, canal: int):
-        nodes = self._canal_nodes.get(canal, [])
-        path = []
-        for n in nodes:
-            params = getattr(n, 'command_parameter', {})
-            try:
-                x = float(params.get('X', 0.0))
-            except Exception:
-                x = 0.0
-            try:
-                y = float(params.get('Y', 0.0))
-            except Exception:
-                y = 0.0
-            try:
-                z = float(params.get('Z', 0.0))
-            except Exception:
-                z = 0.0
-            path.append(([ _Point(x, y, z) ], 0.1))
-        return path
-
-    def get_exected_nodes(self, canal: int):
-        return self._canal_nodes.get(canal, [])
-
-    def get_canal_name(self, idx: int):
-        return f"C{idx}"
-
-    def synchro_points(self, tool_paths, nodes):
-        return None
-
-
-class TestExampleFile(unittest.TestCase):
-    def test_run_example_o0004(self):
-        # Configure logging to web buffer so get_message_stack works
-        configure_logging(console=False, web_buffer=True)
-        configure_i18n()
-
-        # Resolve to repository root: tests/integration -> tests -> <repo root>
-        repo_root = Path(__file__).resolve().parents[2]
-        data_file = repo_root / 'data' / 'nc-examples' / 'O0004'
-        self.assertTrue(data_file.exists(), f"Data file missing: {data_file}")
-
-        program = data_file.read_text(encoding='utf-8', errors='replace')
-
-        ctrl = SimpleFakeControl()
-        engine = NCExecutionEngine(ctrl)
-        result = engine.get_Syncro_plot([program], synch=False)
-
-        self.assertIsInstance(result, list)
-        # either a real set of canals or the legacy error return
-        self.assertTrue(result == [[], []] or isinstance(result, list))
-
-        # messages captured in buffer (may be empty) should be a list-like
-        msgs = get_message_stack()
-        self.assertIsNotNone(msgs)
-
-
-if __name__ == '__main__':
-    unittest.main()
+import os
+import sys
+import unittest
+from pathlib import Path
+
+# Ensure package imports from src are resolvable when running tests directly
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
+
+from ncplot7py.application.nc_execution import NCExecutionEngine
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.shared import configure_logging, get_message_stack, configure_i18n
+
+
+class _Point:
+    def __init__(self, x, y, z):
+        self.x = x
+        self.y = y
+        self.z = z
+
+
+class SimpleFakeControl:
+    def __init__(self):
+        self._canal_nodes = {}
+
+    def get_canal_count(self):
+        return 1
+
+    def run_nc_code_list(self, node_list, canal):
+        self._canal_nodes[canal] = list(node_list)
+
+    def get_tool_path(self, canal: int):
+        nodes = self._canal_nodes.get(canal, [])
+        path = []
+        for n in nodes:
+            params = getattr(n, 'command_parameter', {})
+            try:
+                x = float(params.get('X', 0.0))
+            except Exception:
+                x = 0.0
+            try:
+                y = float(params.get('Y', 0.0))
+            except Exception:
+                y = 0.0
+            try:
+                z = float(params.get('Z', 0.0))
+            except Exception:
+                z = 0.0
+            path.append(([ _Point(x, y, z) ], 0.1))
+        return path
+
+    def get_exected_nodes(self, canal: int):
+        return self._canal_nodes.get(canal, [])
+
+    def get_canal_name(self, idx: int):
+        return f"C{idx}"
+
+    def synchro_points(self, tool_paths, nodes):
+        return None
+
+
+class TestExampleFile(unittest.TestCase):
+    def test_run_example_o0004(self):
+        # Configure logging to web buffer so get_message_stack works
+        configure_logging(console=False, web_buffer=True)
+        configure_i18n()
+
+        # Resolve to repository root: tests/integration -> tests -> <repo root>
+        repo_root = Path(__file__).resolve().parents[2]
+        data_file = repo_root / 'data' / 'nc-examples' / 'O0004'
+        self.assertTrue(data_file.exists(), f"Data file missing: {data_file}")
+
+        program = data_file.read_text(encoding='utf-8', errors='replace')
+
+        ctrl = SimpleFakeControl()
+        engine = NCExecutionEngine(ctrl)
+        result = engine.get_Syncro_plot([program], synch=False)
+
+        self.assertIsInstance(result, list)
+        # either a real set of canals or the legacy error return
+        self.assertTrue(result == [[], []] or isinstance(result, list))
+
+        # messages captured in buffer (may be empty) should be a list-like
+        msgs = get_message_stack()
+        self.assertIsNotNone(msgs)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/integration/test_hexagon_O6POINT.py b/tests/integration/test_hexagon_O6POINT.py
index 1a138ed..d289241 100644
--- a/tests/integration/test_hexagon_O6POINT.py
+++ b/tests/integration/test_hexagon_O6POINT.py
@@ -1,101 +1,101 @@
-import os
-import sys
-import unittest
-from pathlib import Path
-
-# Ensure package imports from src are resolvable when running tests directly
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
-
-from ncplot7py.application.nc_execution import NCExecutionEngine
-from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
-from ncplot7py.shared import configure_logging, configure_i18n
-
-
-class TestHexagonO6PointIntegration(unittest.TestCase):
-    def test_hexagon_o6point_shape(self):
-        # configure logging minimally
-        configure_logging(console=False, web_buffer=True)
-        configure_i18n()
-
-        # Construct the program inline (hexagon with fillets similar to O6POINT).
-        # Commands are separated by ';' per NCExecutionEngine expectations.
-        program = (
-            "G17;"  # XY plane
-            "F200;"  # feed
-            "G1 X0 Y0;"
-            "G1 X-8.0 Y0;"
-            "G1 X-8.0 Y-1.73;"
-            "G3 X-7.0 Y-2.66 R1.0;"
-            "G1 X-1.0 Y-4.33;"
-            "G3 X1.0 Y-4.33 R1.0;"
-            "G1 X7.0 Y-2.66;"
-            "G3 X8.0 Y-1.73 R1.0;"
-            "G1 X8.0 Y1.73;"
-            "G3 X7.0 Y2.66 R1.0;"
-            "G1 X1.0 Y4.33;"
-            "G3 X-1.0 Y4.33 R1.0;"
-            "G1 X-7.0 Y2.66;"
-            "G3 X-8.0 Y1.73 R1.0;"
-            "G1 X-8.0 Y0;"
-        )
-
-        ctrl = StatefulIsoTurnNCControl(count_of_canals=1)
-        engine = NCExecutionEngine(ctrl)
-        result = engine.get_Syncro_plot([program], synch=False)
-
-        # Basic structure
-        self.assertIsInstance(result, list)
-        self.assertGreater(len(result), 0)
-
-        canal = result[0]
-        self.assertIsInstance(canal, dict)
-        plot_lines = canal.get('plot', [])
-
-        # If engine produced no plot lines for some environment reasons,
-        # try to obtain the raw tool_path from the control directly as a
-        # fallback (mirrors how the debug helper collects points).
-        xs = []
-        ys = []
-        if not plot_lines:
-            tool_path = ctrl.get_tool_path(1)
-            for line in tool_path:
-                try:
-                    pts = line[0]
-                except Exception:
-                    continue
-                for p in pts:
-                    x = getattr(p, 'x', None)
-                    y = getattr(p, 'y', None)
-                    if x is not None and y is not None:
-                        xs.append(x)
-                        ys.append(y)
-        else:
-            for line in plot_lines:
-                xs.extend(line.get('x', []))
-                ys.extend(line.get('y', []))
-
-        # Must have numeric points; if none produced in this environment,
-        # skip the shape assertions (some CI/runtime setups may not run the
-        # full control chain). When points are present, assert extents.
-        xs = [x for x in xs if x is not None]
-        ys = [y for y in ys if y is not None]
-        if not xs:
-            self.skipTest("No toolpath points produced in this environment; skipping hexagon shape assertions")
-        self.assertGreater(len(xs), 10)
-        self.assertEqual(len(xs), len(ys))
-
-        min_x = min(xs)
-        max_x = max(xs)
-        min_y = min(ys)
-        max_y = max(ys)
-
-        # Hexagon in example spans roughly -4..4 in X and about +-4.8 in Y
-        self.assertLess(min_x, -3.5)
-        self.assertGreater(max_x, 3.5)
-        # check that the Y extent reaches approximately the expected fillet apex (~4.8)
-        self.assertGreater(max_y, 4.0)
-        self.assertLess(max_y, 7.0)
-
-
-if __name__ == '__main__':
-    unittest.main()
+import os
+import sys
+import unittest
+from pathlib import Path
+
+# Ensure package imports from src are resolvable when running tests directly
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
+
+from ncplot7py.application.nc_execution import NCExecutionEngine
+from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
+from ncplot7py.shared import configure_logging, configure_i18n
+
+
+class TestHexagonO6PointIntegration(unittest.TestCase):
+    def test_hexagon_o6point_shape(self):
+        # configure logging minimally
+        configure_logging(console=False, web_buffer=True)
+        configure_i18n()
+
+        # Construct the program inline (hexagon with fillets similar to O6POINT).
+        # Commands are separated by ';' per NCExecutionEngine expectations.
+        program = (
+            "G17;"  # XY plane
+            "F200;"  # feed
+            "G1 X0 Y0;"
+            "G1 X-8.0 Y0;"
+            "G1 X-8.0 Y-1.73;"
+            "G3 X-7.0 Y-2.66 R1.0;"
+            "G1 X-1.0 Y-4.33;"
+            "G3 X1.0 Y-4.33 R1.0;"
+            "G1 X7.0 Y-2.66;"
+            "G3 X8.0 Y-1.73 R1.0;"
+            "G1 X8.0 Y1.73;"
+            "G3 X7.0 Y2.66 R1.0;"
+            "G1 X1.0 Y4.33;"
+            "G3 X-1.0 Y4.33 R1.0;"
+            "G1 X-7.0 Y2.66;"
+            "G3 X-8.0 Y1.73 R1.0;"
+            "G1 X-8.0 Y0;"
+        )
+
+        ctrl = StatefulIsoTurnNCControl(count_of_canals=1)
+        engine = NCExecutionEngine(ctrl)
+        result = engine.get_Syncro_plot([program], synch=False)
+
+        # Basic structure
+        self.assertIsInstance(result, list)
+        self.assertGreater(len(result), 0)
+
+        canal = result[0]
+        self.assertIsInstance(canal, dict)
+        plot_lines = canal.get('plot', [])
+
+        # If engine produced no plot lines for some environment reasons,
+        # try to obtain the raw tool_path from the control directly as a
+        # fallback (mirrors how the debug helper collects points).
+        xs = []
+        ys = []
+        if not plot_lines:
+            tool_path = ctrl.get_tool_path(1)
+            for line in tool_path:
+                try:
+                    pts = line[0]
+                except Exception:
+                    continue
+                for p in pts:
+                    x = getattr(p, 'x', None)
+                    y = getattr(p, 'y', None)
+                    if x is not None and y is not None:
+                        xs.append(x)
+                        ys.append(y)
+        else:
+            for line in plot_lines:
+                xs.extend(line.get('x', []))
+                ys.extend(line.get('y', []))
+
+        # Must have numeric points; if none produced in this environment,
+        # skip the shape assertions (some CI/runtime setups may not run the
+        # full control chain). When points are present, assert extents.
+        xs = [x for x in xs if x is not None]
+        ys = [y for y in ys if y is not None]
+        if not xs:
+            self.skipTest("No toolpath points produced in this environment; skipping hexagon shape assertions")
+        self.assertGreater(len(xs), 10)
+        self.assertEqual(len(xs), len(ys))
+
+        min_x = min(xs)
+        max_x = max(xs)
+        min_y = min(ys)
+        max_y = max(ys)
+
+        # Hexagon in example spans roughly -4..4 in X and about +-4.8 in Y
+        self.assertLess(min_x, -3.5)
+        self.assertGreater(max_x, 3.5)
+        # check that the Y extent reaches approximately the expected fillet apex (~4.8)
+        self.assertGreater(max_y, 4.0)
+        self.assertLess(max_y, 7.0)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/integration/test_lathe_diameter_mode.py b/tests/integration/test_lathe_diameter_mode.py
index bff5149..b7d8fc7 100644
--- a/tests/integration/test_lathe_diameter_mode.py
+++ b/tests/integration/test_lathe_diameter_mode.py
@@ -1,50 +1,50 @@
-import os
-import sys
-import unittest
-from pathlib import Path
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
-
-from ncplot7py.application.nc_execution import NCExecutionEngine
-from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.shared import configure_logging, configure_i18n, get_message_stack
-
-
-class TestLatheDiameterModeIntegration(unittest.TestCase):
-    def test_lathe_diameter_interprets_x_as_diameter(self):
-        configure_logging(console=False, web_buffer=True)
-        configure_i18n()
-
-        # prepare initial state where X axis is interpreted as a diameter
-        init_state = CNCState()
-        init_state.set_axis('X', 0.0)
-        init_state.set_axis_unit('X', 'diameter')
-
-        # create control with this initial state
-        ctrl = StatefulIsoTurnNCControl(init_nc_states=[init_state])
-        engine = NCExecutionEngine(ctrl)
-
-        # simple program: move X to 10 (interpreted as diameter -> radius 5)
-        program = "G1 X10"
-        result = engine.get_Syncro_plot([program], synch=False)
-
-        # Verify engine produced a plot structure
-        self.assertIsInstance(result, list)
-        # Check the canal's CNCState got updated to radius value (5.0)
-        state_after = ctrl._canals[1]._state
-        self.assertAlmostEqual(state_after.get_axis('X'), 5.0)
-
-        # Also ensure tool path contains final point with x==5.0
-        tool_path = ctrl.get_tool_path(1)
-        # find last point in last segment
-        last_x = None
-        if tool_path and len(tool_path) > 0:
-            seg_pts, _ = tool_path[-1]
-            if seg_pts:
-                last_x = getattr(seg_pts[-1], 'x', None)
-        self.assertAlmostEqual(last_x, 5.0)
-
-
-if __name__ == '__main__':
-    unittest.main()
+import os
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
+
+from ncplot7py.application.nc_execution import NCExecutionEngine
+from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.shared import configure_logging, configure_i18n, get_message_stack
+
+
+class TestLatheDiameterModeIntegration(unittest.TestCase):
+    def test_lathe_diameter_interprets_x_as_diameter(self):
+        configure_logging(console=False, web_buffer=True)
+        configure_i18n()
+
+        # prepare initial state where X axis is interpreted as a diameter
+        init_state = CNCState()
+        init_state.set_axis('X', 0.0)
+        init_state.set_axis_unit('X', 'diameter')
+
+        # create control with this initial state
+        ctrl = StatefulIsoTurnNCControl(init_nc_states=[init_state])
+        engine = NCExecutionEngine(ctrl)
+
+        # simple program: move X to 10 (interpreted as diameter -> radius 5)
+        program = "G1 X10"
+        result = engine.get_Syncro_plot([program], synch=False)
+
+        # Verify engine produced a plot structure
+        self.assertIsInstance(result, list)
+        # Check the canal's CNCState got updated to radius value (5.0)
+        state_after = ctrl._canals[1]._state
+        self.assertAlmostEqual(state_after.get_axis('X'), 5.0)
+
+        # Also ensure tool path contains final point with x==5.0
+        tool_path = ctrl.get_tool_path(1)
+        # find last point in last segment
+        last_x = None
+        if tool_path and len(tool_path) > 0:
+            seg_pts, _ = tool_path[-1]
+            if seg_pts:
+                last_x = getattr(seg_pts[-1], 'x', None)
+        self.assertAlmostEqual(last_x, 5.0)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/integration/test_o6point_while_loop.py b/tests/integration/test_o6point_while_loop.py
index da13083..dd644b4 100644
--- a/tests/integration/test_o6point_while_loop.py
+++ b/tests/integration/test_o6point_while_loop.py
@@ -1,79 +1,79 @@
-import os
-import sys
-import unittest
-from pathlib import Path
-
-# Ensure package imports from src are resolvable when running tests directly
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
-
-from ncplot7py.application.nc_execution import NCExecutionEngine
-from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
-from ncplot7py.shared import configure_logging, configure_i18n
-from ncplot7py.shared.file_adapter import get_program
-
-
-class TestO6PointWhileLoopIntegration(unittest.TestCase):
-    def test_o6point_while_runs_expected_iterations_and_produces_toolpath(self):
-        # Minimal logging configuration for tests
-        configure_logging(console=False, web_buffer=True)
-        configure_i18n()
-
-        # Inline O6POINT program (equivalent to data/nc-examples/O6POINT)
-        program_lines = [
-            "O0001(SB12 RG FRONT)",
-            "T1400",
-            "M36S3000",
-            "G99",
-            "F200 G98",
-            "G112",
-            "#100 =0",
-            "#101 = 2",
-            "WHILE[#100 LT #101]DO1",
-            "#100 = #100 + 1",
-            "G1 X0 C0",
-            "G1 X-8.0 C0",
-            "G1 X-8.0 C-1.73",
-            "G3 X-7.0 C-2.66 R1.0",
-            "G1 X-1.0 C-4.33",
-            "G3 X1.0 C-4.33 R1.0",
-            "G1 X7.0 C-2.66",
-            "G3 X8.0 C-1.73 R1.0",
-            "G1 X8.0 C1.73",
-            "G3 X7.0 C2.66 R1.0",
-            "G1 X1.0 C4.33",
-            "G3 X-1.0 C4.33 R1.0",
-            "G1 X-7.0 C2.66",
-            "G3 X-8.0 C1.73 R1.0",
-            "G1 X-8.0 C0",
-            "G1W1.0",
-            "END1",
-            "G113",
-        ]
-        # Use the project's file adapter helper to perform the same
-        # preprocessing (remove parentheses, normalize whitespace).
-        programs = get_program(program_lines, split_on_blank_line=True)
-        # create control with same number of canals as programs
-        ctrl = StatefulIsoTurnNCControl(count_of_canals=max(1, len(programs)))
-        engine = NCExecutionEngine(ctrl)
-
-        result = engine.get_Syncro_plot(programs, synch=False)
-
-        # result should be a list with at least one canal
-        self.assertIsInstance(result, list)
-        self.assertGreater(len(result), 0)
-
-        # Check that variable #100 was incremented twice (final value == 2)
-        # Variable store keys are strings without the leading '#'
-        state_params = ctrl._canals[1]._state.parameters
-        # ensure parameter exists
-        self.assertIn('100', state_params)
-        self.assertAlmostEqual(float(state_params.get('100')), 2.0)
-
-        # Ensure tool path was produced for canal 1
-        tp = ctrl.get_tool_path(1)
-        self.assertIsInstance(tp, list)
-        self.assertGreater(len(tp), 0)
-
-
-if __name__ == '__main__':
-    unittest.main()
+import os
+import sys
+import unittest
+from pathlib import Path
+
+# Ensure package imports from src are resolvable when running tests directly
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
+
+from ncplot7py.application.nc_execution import NCExecutionEngine
+from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
+from ncplot7py.shared import configure_logging, configure_i18n
+from ncplot7py.shared.file_adapter import get_program
+
+
+class TestO6PointWhileLoopIntegration(unittest.TestCase):
+    def test_o6point_while_runs_expected_iterations_and_produces_toolpath(self):
+        # Minimal logging configuration for tests
+        configure_logging(console=False, web_buffer=True)
+        configure_i18n()
+
+        # Inline O6POINT program (equivalent to data/nc-examples/O6POINT)
+        program_lines = [
+            "O0001(SB12 RG FRONT)",
+            "T1400",
+            "M36S3000",
+            "G99",
+            "F200 G98",
+            "G112",
+            "#100 =0",
+            "#101 = 2",
+            "WHILE[#100 LT #101]DO1",
+            "#100 = #100 + 1",
+            "G1 X0 C0",
+            "G1 X-8.0 C0",
+            "G1 X-8.0 C-1.73",
+            "G3 X-7.0 C-2.66 R1.0",
+            "G1 X-1.0 C-4.33",
+            "G3 X1.0 C-4.33 R1.0",
+            "G1 X7.0 C-2.66",
+            "G3 X8.0 C-1.73 R1.0",
+            "G1 X8.0 C1.73",
+            "G3 X7.0 C2.66 R1.0",
+            "G1 X1.0 C4.33",
+            "G3 X-1.0 C4.33 R1.0",
+            "G1 X-7.0 C2.66",
+            "G3 X-8.0 C1.73 R1.0",
+            "G1 X-8.0 C0",
+            "G1W1.0",
+            "END1",
+            "G113",
+        ]
+        # Use the project's file adapter helper to perform the same
+        # preprocessing (remove parentheses, normalize whitespace).
+        programs = get_program(program_lines, split_on_blank_line=True)
+        # create control with same number of canals as programs
+        ctrl = StatefulIsoTurnNCControl(count_of_canals=max(1, len(programs)))
+        engine = NCExecutionEngine(ctrl)
+
+        result = engine.get_Syncro_plot(programs, synch=False)
+
+        # result should be a list with at least one canal
+        self.assertIsInstance(result, list)
+        self.assertGreater(len(result), 0)
+
+        # Check that variable #100 was incremented twice (final value == 2)
+        # Variable store keys are strings without the leading '#'
+        state_params = ctrl._canals[1]._state.parameters
+        # ensure parameter exists
+        self.assertIn('100', state_params)
+        self.assertAlmostEqual(float(state_params.get('100')), 2.0)
+
+        # Ensure tool path was produced for canal 1
+        tp = ctrl.get_tool_path(1)
+        self.assertIsInstance(tp, list)
+        self.assertGreater(len(tp), 0)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/integration/test_polar_plane_restore.py b/tests/integration/test_polar_plane_restore.py
index ee809ce..c150ed3 100644
--- a/tests/integration/test_polar_plane_restore.py
+++ b/tests/integration/test_polar_plane_restore.py
@@ -1,45 +1,45 @@
-import os
-import sys
-import unittest
-from pathlib import Path
-
-# ensure imports from src are available
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
-
-from ncplot7py.application.nc_execution import NCExecutionEngine
-from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
-from ncplot7py.shared import configure_logging, configure_i18n
-
-
-class TestPolarPlaneRestoreIntegration(unittest.TestCase):
-    def test_polar_enable_disable_restores_plane(self):
-        configure_logging(console=False, web_buffer=True)
-        configure_i18n()
-
-        # Construct a small program that sets plane to G18 (X_Z), then enables
-        # polar (G112) which forces X_Y, and then disables polar (G113).
-        # After G113 we expect the original plane (X_Z) to be restored.
-        program = (
-            "G18;"  # set plane X_Z
-            "G112;"  # polar on (should set X_Y and remember previous)
-            "G1 X0 Y0;"  # simple motion while polar active
-            "G113;"  # polar off (should restore previous plane X_Z)
-        )
-
-        ctrl = StatefulIsoTurnNCControl(count_of_canals=1)
-        engine = NCExecutionEngine(ctrl)
-        result = engine.get_Syncro_plot([program], synch=False)
-
-        # basic execution sanity
-        self.assertIsInstance(result, list)
-
-        # inspect canal state to verify plane was restored
-        canal_state = ctrl._canals[1]._state
-        final_plane = canal_state.extra.get('g_group_16_plane')
-
-        # Expect the final plane to be X_Z (string or enum value accepted)
-        self.assertTrue(final_plane == 'X_Z' or str(final_plane).endswith('X_Z'))
-
-
-if __name__ == '__main__':
-    unittest.main()
+import os
+import sys
+import unittest
+from pathlib import Path
+
+# ensure imports from src are available
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
+
+from ncplot7py.application.nc_execution import NCExecutionEngine
+from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
+from ncplot7py.shared import configure_logging, configure_i18n
+
+
+class TestPolarPlaneRestoreIntegration(unittest.TestCase):
+    def test_polar_enable_disable_restores_plane(self):
+        configure_logging(console=False, web_buffer=True)
+        configure_i18n()
+
+        # Construct a small program that sets plane to G18 (X_Z), then enables
+        # polar (G112) which forces X_Y, and then disables polar (G113).
+        # After G113 we expect the original plane (X_Z) to be restored.
+        program = (
+            "G18;"  # set plane X_Z
+            "G112;"  # polar on (should set X_Y and remember previous)
+            "G1 X0 Y0;"  # simple motion while polar active
+            "G113;"  # polar off (should restore previous plane X_Z)
+        )
+
+        ctrl = StatefulIsoTurnNCControl(count_of_canals=1)
+        engine = NCExecutionEngine(ctrl)
+        result = engine.get_Syncro_plot([program], synch=False)
+
+        # basic execution sanity
+        self.assertIsInstance(result, list)
+
+        # inspect canal state to verify plane was restored
+        canal_state = ctrl._canals[1]._state
+        final_plane = canal_state.extra.get('g_group_16_plane')
+
+        # Expect the final plane to be X_Z (string or enum value accepted)
+        self.assertTrue(final_plane == 'X_Z' or str(final_plane).endswith('X_Z'))
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/integration/test_star_canal_syncro_integration.py b/tests/integration/test_star_canal_syncro_integration.py
index a8ccff6..7378e6d 100644
--- a/tests/integration/test_star_canal_syncro_integration.py
+++ b/tests/integration/test_star_canal_syncro_integration.py
@@ -1,91 +1,91 @@
-import os
-import sys
-import unittest
-from pathlib import Path
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
-
-from ncplot7py.application.nc_execution import NCExecutionEngine
-from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
-from ncplot7py.shared import configure_logging, configure_i18n
-
-
-class TestStarCanalSynchroIntegration(unittest.TestCase):
-    def test_two_canal_program_sync(self):
-        configure_logging(console=False, web_buffer=True)
-        configure_i18n()
-
-        # Simple two-canal programs embedded here.
-        # Put the M wait code on the same motion line so the motion node
-        # includes the M parameter and produces a tool-path entry that
-        # aligns with the node list used by the synchroniser.
-        # add a startup code and an extra motion line to exercise parser and timing
-        prog1 = "G98; G1 X0; G1 X10 F60 M300; G1 X12;"
-        prog2 = "G98; G1 X0; G1 X5 F60 M300; G1 X6;"
-
-        ctrl = StatefulIsoTurnNCControl(count_of_canals=2)
-        engine = NCExecutionEngine(ctrl)
-
-        result = engine.get_Syncro_plot([prog1, prog2], synch=True)
-
-        # Should return a list with two canal dicts when successful
-        self.assertIsInstance(result, list)
-        self.assertEqual(len(result), 2)
-        for canal in result:
-            # each canal should include a 'plot' key with at least one line
-            self.assertIn('plot', canal)
-            self.assertIsInstance(canal['plot'], list)
-            self.assertGreaterEqual(len(canal['plot']), 1)
-            # each plot entry should include a non-negative numeric time
-            for entry in canal['plot']:
-                self.assertIn('t', entry)
-                self.assertIsInstance(entry['t'], float)
-                self.assertGreaterEqual(entry['t'], 0.0)
-
-    def test_three_canal_program_sync(self):
-        configure_logging(console=False, web_buffer=True)
-        configure_i18n()
-
-        # Three-canal programs with M on the motion lines (same rationale)
-        # ensure each NC statement is terminated by ';' so the parser sees
-        # separate command lines (avoid duplicate parameter tokens in one line)
-        # make programs slightly longer and add a P parameter on canal2's M
-        prog1 = "G98;M250P12; G1 X0; G1 X10; G1 X8 F120 M500; M310;"
-        prog2 = "G98;M250P12;M260 P23; G1 X0; G1 X4 F120 M500 P12; G1 X2; G1 X4; M310;"
-        prog3 = "G98;M260P23; G1 X0; G1 X10; G1 X10; G1 X12 F120 M500; M80; M310;"
-
-        ctrl = StatefulIsoTurnNCControl(count_of_canals=3)
-        engine = NCExecutionEngine(ctrl)
-
-        result = engine.get_Syncro_plot([prog1, prog2, prog3], synch=True)
-
-        self.assertIsInstance(result, list)
-        self.assertEqual(len(result), 3)
-        for canal in result:
-            self.assertIn('plot', canal)
-            self.assertIsInstance(canal['plot'], list)
-            self.assertGreaterEqual(len(canal['plot']), 1)
-            for entry in canal['plot']:
-                self.assertIn('t', entry)
-                self.assertIsInstance(entry['t'], float)
-                self.assertGreaterEqual(entry['t'], 0.0)
-
-    def test_two_canal_mismatch_returns_error(self):
-        configure_logging(console=False, web_buffer=True)
-        configure_i18n()
-
-        # same motions but different M wait codes -> should trigger mismatch
-        prog1 = "G1 X10; G1 X10 F60 M300; G1 X12;"
-        prog2 = "G1 X10; G1 X5 F60 M301; G1 X6;"
-
-        ctrl = StatefulIsoTurnNCControl(count_of_canals=2)
-        engine = NCExecutionEngine(ctrl)
-
-        result = engine.get_Syncro_plot([prog1, prog2], synch=True)
-
-        # On synchronization error the engine returns the legacy error value
-        self.assertEqual(result, [[], []])
-
-
-if __name__ == '__main__':
-    unittest.main()
+import os
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
+
+from ncplot7py.application.nc_execution import NCExecutionEngine
+from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
+from ncplot7py.shared import configure_logging, configure_i18n
+
+
+class TestStarCanalSynchroIntegration(unittest.TestCase):
+    def test_two_canal_program_sync(self):
+        configure_logging(console=False, web_buffer=True)
+        configure_i18n()
+
+        # Simple two-canal programs embedded here.
+        # Put the M wait code on the same motion line so the motion node
+        # includes the M parameter and produces a tool-path entry that
+        # aligns with the node list used by the synchroniser.
+        # add a startup code and an extra motion line to exercise parser and timing
+        prog1 = "G98; G1 X0; G1 X10 F60 M300; G1 X12;"
+        prog2 = "G98; G1 X0; G1 X5 F60 M300; G1 X6;"
+
+        ctrl = StatefulIsoTurnNCControl(count_of_canals=2)
+        engine = NCExecutionEngine(ctrl)
+
+        result = engine.get_Syncro_plot([prog1, prog2], synch=True)
+
+        # Should return a list with two canal dicts when successful
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 2)
+        for canal in result:
+            # each canal should include a 'plot' key with at least one line
+            self.assertIn('plot', canal)
+            self.assertIsInstance(canal['plot'], list)
+            self.assertGreaterEqual(len(canal['plot']), 1)
+            # each plot entry should include a non-negative numeric time
+            for entry in canal['plot']:
+                self.assertIn('t', entry)
+                self.assertIsInstance(entry['t'], float)
+                self.assertGreaterEqual(entry['t'], 0.0)
+
+    def test_three_canal_program_sync(self):
+        configure_logging(console=False, web_buffer=True)
+        configure_i18n()
+
+        # Three-canal programs with M on the motion lines (same rationale)
+        # ensure each NC statement is terminated by ';' so the parser sees
+        # separate command lines (avoid duplicate parameter tokens in one line)
+        # make programs slightly longer and add a P parameter on canal2's M
+        prog1 = "G98;M250P12; G1 X0; G1 X10; G1 X8 F120 M500; M310;"
+        prog2 = "G98;M250P12;M260 P23; G1 X0; G1 X4 F120 M500 P12; G1 X2; G1 X4; M310;"
+        prog3 = "G98;M260P23; G1 X0; G1 X10; G1 X10; G1 X12 F120 M500; M80; M310;"
+
+        ctrl = StatefulIsoTurnNCControl(count_of_canals=3)
+        engine = NCExecutionEngine(ctrl)
+
+        result = engine.get_Syncro_plot([prog1, prog2, prog3], synch=True)
+
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 3)
+        for canal in result:
+            self.assertIn('plot', canal)
+            self.assertIsInstance(canal['plot'], list)
+            self.assertGreaterEqual(len(canal['plot']), 1)
+            for entry in canal['plot']:
+                self.assertIn('t', entry)
+                self.assertIsInstance(entry['t'], float)
+                self.assertGreaterEqual(entry['t'], 0.0)
+
+    def test_two_canal_mismatch_returns_error(self):
+        configure_logging(console=False, web_buffer=True)
+        configure_i18n()
+
+        # same motions but different M wait codes -> should trigger mismatch
+        prog1 = "G1 X10; G1 X10 F60 M300; G1 X12;"
+        prog2 = "G1 X10; G1 X5 F60 M301; G1 X6;"
+
+        ctrl = StatefulIsoTurnNCControl(count_of_canals=2)
+        engine = NCExecutionEngine(ctrl)
+
+        result = engine.get_Syncro_plot([prog1, prog2], synch=True)
+
+        # On synchronization error the engine returns the legacy error value
+        self.assertEqual(result, [[], []])
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/integration/test_stateful_iso_turn_control.py b/tests/integration/test_stateful_iso_turn_control.py
index de2887a..f9cad85 100644
--- a/tests/integration/test_stateful_iso_turn_control.py
+++ b/tests/integration/test_stateful_iso_turn_control.py
@@ -1,35 +1,35 @@
-import os
-import sys
-import unittest
-from pathlib import Path
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
-
-from ncplot7py.application.nc_execution import NCExecutionEngine
-from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
-from ncplot7py.shared import configure_logging, configure_i18n, get_message_stack
-
-
-class TestStatefulControlIntegration(unittest.TestCase):
-    def test_stateful_control_runs_example(self):
-        configure_logging(console=False, web_buffer=True)
-        configure_i18n()
-
-        repo_root = Path(__file__).resolve().parents[2]
-        data_file = repo_root / 'data' / 'nc-examples' / 'O0004'
-        self.assertTrue(data_file.exists())
-
-        program = data_file.read_text(encoding='utf-8', errors='replace')
-
-        ctrl = StatefulIsoTurnNCControl()
-        engine = NCExecutionEngine(ctrl)
-        result = engine.get_Syncro_plot([program], synch=False)
-
-        self.assertIsInstance(result, list)
-        # ensure tool paths produced (control may produce empty paths for some commands)
-        msgs = get_message_stack()
-        self.assertIsNotNone(msgs)
-
-
-if __name__ == '__main__':
-    unittest.main()
+import os
+import sys
+import unittest
+from pathlib import Path
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
+
+from ncplot7py.application.nc_execution import NCExecutionEngine
+from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
+from ncplot7py.shared import configure_logging, configure_i18n, get_message_stack
+
+
+class TestStatefulControlIntegration(unittest.TestCase):
+    def test_stateful_control_runs_example(self):
+        configure_logging(console=False, web_buffer=True)
+        configure_i18n()
+
+        repo_root = Path(__file__).resolve().parents[2]
+        data_file = repo_root / 'data' / 'nc-examples' / 'O0004'
+        self.assertTrue(data_file.exists())
+
+        program = data_file.read_text(encoding='utf-8', errors='replace')
+
+        ctrl = StatefulIsoTurnNCControl()
+        engine = NCExecutionEngine(ctrl)
+        result = engine.get_Syncro_plot([program], synch=False)
+
+        self.assertIsInstance(result, list)
+        # ensure tool paths produced (control may produce empty paths for some commands)
+        msgs = get_message_stack()
+        self.assertIsNotNone(msgs)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/integration/test_while_do_end.py b/tests/integration/test_while_do_end.py
index 93cd6a6..c0ddcd6 100644
--- a/tests/integration/test_while_do_end.py
+++ b/tests/integration/test_while_do_end.py
@@ -1,67 +1,67 @@
-import os
-import sys
-import unittest
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
-
-from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
-from ncplot7py.shared import configure_logging, configure_i18n
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-
-
-class TestWhileDoEndIntegration(unittest.TestCase):
-    def test_while_do_end_loop(self):
-        configure_logging(console=False, web_buffer=True)
-        configure_i18n()
-
-        # Program:
-        # 1) set counter #1 to 3
-        # 2) use rapid/absolute motion (G00)
-        # 3) WHILE #1 GT 0 DO1 -> begin loop
-        # 4) N10 G01 X1 F60 -> move +1 in X each iteration (incremental mode)
-        # 5) #1=[#1-1] -> decrement counter
-        # 6) IF#1GT0GOTO10 -> if still >0 jump back to N10
-        # 7) END1 -> loop end
-        program = "#1=[3]; WHILE#1GT0DO1; N10 G00 X1; #1=[#1-1]; END1"
-
-        # We'll construct nodes directly and run them through the canal to
-        # exercise DO/END with a loop counter (L). This bypasses parsing so we
-        # can attach 'L' in command_parameter as expected by the control flow
-        # handler.
-
-        ctrl = StatefulIsoTurnNCControl()
-        # Ensure this test uses radius interpretation for X (not diameter)
-        # to preserve the original expectation that G00 X1 results in X==1.0
-        try:
-            ctrl._canals[1]._state.set_axis_unit('X', 'radius')
-        except Exception:
-            pass
-        # prepare nodes
-        # initialize variable #1 = 3
-        node_var = NCCommandNode(g_code_command=set(), command_parameter={}, variable_command="#1=[3]", nc_code_line_nr=1)
-        # DO1 with loop counter L=3 (label 1, loop three times)
-        node_do = NCCommandNode(g_code_command=set(), command_parameter={"N": "10", "L": "3"}, loop_command="DO1", nc_code_line_nr=2)
-        # set rapid move G00
-        node_g0 = NCCommandNode(g_code_command={"G00"}, command_parameter={}, nc_code_line_nr=3)
-        # motion: increment X by 1 each iteration (N=11)
-        node_move = NCCommandNode(g_code_command={"G01"}, command_parameter={"X": "1", "F": "60", "N": "11"}, nc_code_line_nr=4)
-        # END1 closes DO1
-        node_end = NCCommandNode(g_code_command=set(), command_parameter={"N": "20"}, loop_command="END1", nc_code_line_nr=5)
-
-        # run nodes through control (canal 1)
-        ctrl.run_nc_code_list([node_var, node_do, node_g0, node_move, node_end], 1)
-
-        # Control should have produced a tool path for canal 1
-        tp = ctrl.get_tool_path(1)
-        self.assertTrue(len(tp) >= 1)
-
-        # final point X should be 1.0 (absolute G00 X1 executed, not incremental)
-        last_line = tp[-1]
-        pts = last_line[0]
-        self.assertTrue(len(pts) >= 1)
-        self.assertAlmostEqual(getattr(pts[-1], 'x', None), 1.0)
-
-
-if __name__ == '__main__':
-    unittest.main()
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
+
+from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnNCControl
+from ncplot7py.shared import configure_logging, configure_i18n
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+
+
+class TestWhileDoEndIntegration(unittest.TestCase):
+    def test_while_do_end_loop(self):
+        configure_logging(console=False, web_buffer=True)
+        configure_i18n()
+
+        # Program:
+        # 1) set counter #1 to 3
+        # 2) use rapid/absolute motion (G00)
+        # 3) WHILE #1 GT 0 DO1 -> begin loop
+        # 4) N10 G01 X1 F60 -> move +1 in X each iteration (incremental mode)
+        # 5) #1=[#1-1] -> decrement counter
+        # 6) IF#1GT0GOTO10 -> if still >0 jump back to N10
+        # 7) END1 -> loop end
+        program = "#1=[3]; WHILE#1GT0DO1; N10 G00 X1; #1=[#1-1]; END1"
+
+        # We'll construct nodes directly and run them through the canal to
+        # exercise DO/END with a loop counter (L). This bypasses parsing so we
+        # can attach 'L' in command_parameter as expected by the control flow
+        # handler.
+
+        ctrl = StatefulIsoTurnNCControl()
+        # Ensure this test uses radius interpretation for X (not diameter)
+        # to preserve the original expectation that G00 X1 results in X==1.0
+        try:
+            ctrl._canals[1]._state.set_axis_unit('X', 'radius')
+        except Exception:
+            pass
+        # prepare nodes
+        # initialize variable #1 = 3
+        node_var = NCCommandNode(g_code_command=set(), command_parameter={}, variable_command="#1=[3]", nc_code_line_nr=1)
+        # DO1 with loop counter L=3 (label 1, loop three times)
+        node_do = NCCommandNode(g_code_command=set(), command_parameter={"N": "10", "L": "3"}, loop_command="DO1", nc_code_line_nr=2)
+        # set rapid move G00
+        node_g0 = NCCommandNode(g_code_command={"G00"}, command_parameter={}, nc_code_line_nr=3)
+        # motion: increment X by 1 each iteration (N=11)
+        node_move = NCCommandNode(g_code_command={"G01"}, command_parameter={"X": "1", "F": "60", "N": "11"}, nc_code_line_nr=4)
+        # END1 closes DO1
+        node_end = NCCommandNode(g_code_command=set(), command_parameter={"N": "20"}, loop_command="END1", nc_code_line_nr=5)
+
+        # run nodes through control (canal 1)
+        ctrl.run_nc_code_list([node_var, node_do, node_g0, node_move, node_end], 1)
+
+        # Control should have produced a tool path for canal 1
+        tp = ctrl.get_tool_path(1)
+        self.assertTrue(len(tp) >= 1)
+
+        # final point X should be 1.0 (absolute G00 X1 executed, not incremental)
+        last_line = tp[-1]
+        pts = last_line[0]
+        self.assertTrue(len(pts) >= 1)
+        self.assertAlmostEqual(getattr(pts[-1], 'x', None), 1.0)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/unit/__pycache__/test_axis_units.cpython-313.pyc b/tests/unit/__pycache__/test_axis_units.cpython-313.pyc
new file mode 100644
index 0000000..88446ab
Binary files /dev/null and b/tests/unit/__pycache__/test_axis_units.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_control_flow_more.cpython-313.pyc b/tests/unit/__pycache__/test_control_flow_more.cpython-313.pyc
new file mode 100644
index 0000000..b3c91e5
Binary files /dev/null and b/tests/unit/__pycache__/test_control_flow_more.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_control_flow_variable.cpython-313.pyc b/tests/unit/__pycache__/test_control_flow_variable.cpython-313.pyc
new file mode 100644
index 0000000..9a47495
Binary files /dev/null and b/tests/unit/__pycache__/test_control_flow_variable.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_error_helper.cpython-313.pyc b/tests/unit/__pycache__/test_error_helper.cpython-313.pyc
new file mode 100644
index 0000000..adc71db
Binary files /dev/null and b/tests/unit/__pycache__/test_error_helper.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_exceptions.cpython-313.pyc b/tests/unit/__pycache__/test_exceptions.cpython-313.pyc
new file mode 100644
index 0000000..ccb8a1e
Binary files /dev/null and b/tests/unit/__pycache__/test_exceptions.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_fanuc_modals.cpython-313.pyc b/tests/unit/__pycache__/test_fanuc_modals.cpython-313.pyc
new file mode 100644
index 0000000..dfa9d69
Binary files /dev/null and b/tests/unit/__pycache__/test_fanuc_modals.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_file_adapter.cpython-313.pyc b/tests/unit/__pycache__/test_file_adapter.cpython-313.pyc
new file mode 100644
index 0000000..ec33482
Binary files /dev/null and b/tests/unit/__pycache__/test_file_adapter.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_gcode_group21.cpython-313.pyc b/tests/unit/__pycache__/test_gcode_group21.cpython-313.pyc
new file mode 100644
index 0000000..c7bcf7a
Binary files /dev/null and b/tests/unit/__pycache__/test_gcode_group21.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_gcode_precheck.cpython-313.pyc b/tests/unit/__pycache__/test_gcode_precheck.cpython-313.pyc
new file mode 100644
index 0000000..546e08a
Binary files /dev/null and b/tests/unit/__pycache__/test_gcode_precheck.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_i18n_exceptions.cpython-313.pyc b/tests/unit/__pycache__/test_i18n_exceptions.cpython-313.pyc
new file mode 100644
index 0000000..fb229c2
Binary files /dev/null and b/tests/unit/__pycache__/test_i18n_exceptions.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_linked_list_list.cpython-313.pyc b/tests/unit/__pycache__/test_linked_list_list.cpython-313.pyc
new file mode 100644
index 0000000..3483b51
Binary files /dev/null and b/tests/unit/__pycache__/test_linked_list_list.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_logging_facade.cpython-313.pyc b/tests/unit/__pycache__/test_logging_facade.cpython-313.pyc
new file mode 100644
index 0000000..4beec27
Binary files /dev/null and b/tests/unit/__pycache__/test_logging_facade.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_nc_command_node.cpython-313.pyc b/tests/unit/__pycache__/test_nc_command_node.cpython-313.pyc
new file mode 100644
index 0000000..b704d9b
Binary files /dev/null and b/tests/unit/__pycache__/test_nc_command_node.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_nc_command_parser.cpython-313.pyc b/tests/unit/__pycache__/test_nc_command_parser.cpython-313.pyc
new file mode 100644
index 0000000..4f2f92f
Binary files /dev/null and b/tests/unit/__pycache__/test_nc_command_parser.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_nc_execution.cpython-313.pyc b/tests/unit/__pycache__/test_nc_execution.cpython-313.pyc
new file mode 100644
index 0000000..efd39bc
Binary files /dev/null and b/tests/unit/__pycache__/test_nc_execution.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_registry.cpython-313.pyc b/tests/unit/__pycache__/test_registry.cpython-313.pyc
new file mode 100644
index 0000000..5a25b9f
Binary files /dev/null and b/tests/unit/__pycache__/test_registry.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_star_canal_syncro.cpython-313.pyc b/tests/unit/__pycache__/test_star_canal_syncro.cpython-313.pyc
new file mode 100644
index 0000000..cb14f19
Binary files /dev/null and b/tests/unit/__pycache__/test_star_canal_syncro.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_star_turn_handler.cpython-313.pyc b/tests/unit/__pycache__/test_star_turn_handler.cpython-313.pyc
new file mode 100644
index 0000000..0d14a9e
Binary files /dev/null and b/tests/unit/__pycache__/test_star_turn_handler.cpython-313.pyc differ
diff --git a/tests/unit/__pycache__/test_variable_nested.cpython-313.pyc b/tests/unit/__pycache__/test_variable_nested.cpython-313.pyc
new file mode 100644
index 0000000..a1d6d64
Binary files /dev/null and b/tests/unit/__pycache__/test_variable_nested.cpython-313.pyc differ
diff --git a/tests/unit/test_axis_units.py b/tests/unit/test_axis_units.py
index 03d6911..aac3da0 100644
--- a/tests/unit/test_axis_units.py
+++ b/tests/unit/test_axis_units.py
@@ -1,29 +1,29 @@
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.domain.handlers.motion import MotionHandler
-from ncplot7py.shared.nc_nodes import NCCommandNode
-
-
-def test_linear_conversion_diameter_x():
-    state = CNCState()
-    state.set_axis("X", 0.0)
-    state.set_axis_unit("X", "diameter")
-
-    node = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "10"})
-    mh = MotionHandler()
-    points, duration = mh.handle(node, state)
-
-    assert state.get_axis("X") == 5.0
-    assert points[-1].x == 5.0
-
-
-def test_negative_diameter_conversion():
-    state = CNCState()
-    state.set_axis("X", 0.0)
-    state.set_axis_unit("X", "diameter")
-
-    node = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "-8"})
-    mh = MotionHandler()
-    points, duration = mh.handle(node, state)
-
-    assert state.get_axis("X") == -4.0
-    assert points[-1].x == -4.0
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.domain.handlers.motion import MotionHandler
+from ncplot7py.shared.nc_nodes import NCCommandNode
+
+
+def test_linear_conversion_diameter_x():
+    state = CNCState()
+    state.set_axis("X", 0.0)
+    state.set_axis_unit("X", "diameter")
+
+    node = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "10"})
+    mh = MotionHandler()
+    points, duration = mh.handle(node, state)
+
+    assert state.get_axis("X") == 5.0
+    assert points[-1].x == 5.0
+
+
+def test_negative_diameter_conversion():
+    state = CNCState()
+    state.set_axis("X", 0.0)
+    state.set_axis_unit("X", "diameter")
+
+    node = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "-8"})
+    mh = MotionHandler()
+    points, duration = mh.handle(node, state)
+
+    assert state.get_axis("X") == -4.0
+    assert points[-1].x == -4.0
diff --git a/tests/unit/test_control_flow_more.py b/tests/unit/test_control_flow_more.py
index d6b50d6..3a60122 100644
--- a/tests/unit/test_control_flow_more.py
+++ b/tests/unit/test_control_flow_more.py
@@ -1,67 +1,67 @@
-import unittest
-
-from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnCanal
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-
-
-class TestControlFlowMore(unittest.TestCase):
-    def test_if_goto_with_variable(self):
-        state = CNCState()
-        canal = StatefulIsoTurnCanal("C1", init_state=state)
-
-        # set variable #500 to 5 using VariableHandler via canal
-        node_set = NCCommandNode(g_code_command=set(), command_parameter={}, variable_command="#500=[5]", nc_code_line_nr=1)
-        # IF#500GT3GOTO20 should jump to node with N=20
-        node_if = NCCommandNode(g_code_command=set(), command_parameter={}, loop_command="IF#500GT3GOTO20", nc_code_line_nr=2)
-        # target node
-        node_target = NCCommandNode(g_code_command={"G01"}, command_parameter={"X": "7", "F": "60", "N": "20"}, nc_code_line_nr=3)
-
-        canal.run_nc_code_list([node_set, node_if, node_target])
-
-        # move should have executed because IF condition true
-        tp = canal.get_tool_path()
-        self.assertTrue(len(tp) >= 1)
-        self.assertAlmostEqual(state.get_axis("X"), 7.0)
-
-    def test_goto_to_do_label(self):
-        state = CNCState()
-        state.feed_rate = 60.0
-        canal = StatefulIsoTurnCanal("C1", init_state=state)
-
-        # GOTO1 should jump to DO1
-        node_goto = NCCommandNode(g_code_command=set(), command_parameter={}, loop_command="GOTO1", nc_code_line_nr=1)
-        node_before = NCCommandNode(g_code_command=set(), command_parameter={}, nc_code_line_nr=2)
-        node_do = NCCommandNode(g_code_command=set(), command_parameter={"N": "10"}, loop_command="DO1", nc_code_line_nr=3)
-        node_move = NCCommandNode(g_code_command={"G01"}, command_parameter={"X": "3", "F": "60", "N": "11"}, nc_code_line_nr=4)
-
-        canal.run_nc_code_list([node_goto, node_before, node_do, node_move])
-
-        tp = canal.get_tool_path()
-        self.assertTrue(len(tp) >= 1)
-        self.assertAlmostEqual(state.get_axis("X"), 3.0)
-
-    def test_nested_do_end_loops(self):
-        state = CNCState()
-        state.feed_rate = 60.0
-        canal = StatefulIsoTurnCanal("C1", init_state=state)
-
-        # outer DO1 L2
-        node_do1 = NCCommandNode(g_code_command=set(), command_parameter={"N": "10", "L": "2"}, loop_command="DO1", nc_code_line_nr=1)
-        # inner DO2 L3
-        node_do2 = NCCommandNode(g_code_command=set(), command_parameter={"N": "11", "L": "3"}, loop_command="DO2", nc_code_line_nr=2)
-        # move inside inner loop
-        node_move = NCCommandNode(g_code_command={"G01"}, command_parameter={"X": "5", "F": "60", "N": "12"}, nc_code_line_nr=3)
-        node_end2 = NCCommandNode(g_code_command=set(), command_parameter={"N": "13"}, loop_command="END2", nc_code_line_nr=4)
-        node_end1 = NCCommandNode(g_code_command=set(), command_parameter={"N": "14"}, loop_command="END1", nc_code_line_nr=5)
-
-        canal.run_nc_code_list([node_do1, node_do2, node_move, node_end2, node_end1])
-
-        tp = canal.get_tool_path()
-        # expected: inner loop 3 times per outer loop, outer loops 2 times => 6 moves
-        self.assertTrue(len(tp) >= 6)
-        self.assertAlmostEqual(state.get_axis("X"), 5.0)
-
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+
+from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnCanal
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+
+
+class TestControlFlowMore(unittest.TestCase):
+    def test_if_goto_with_variable(self):
+        state = CNCState()
+        canal = StatefulIsoTurnCanal("C1", init_state=state)
+
+        # set variable #500 to 5 using VariableHandler via canal
+        node_set = NCCommandNode(g_code_command=set(), command_parameter={}, variable_command="#500=[5]", nc_code_line_nr=1)
+        # IF#500GT3GOTO20 should jump to node with N=20
+        node_if = NCCommandNode(g_code_command=set(), command_parameter={}, loop_command="IF#500GT3GOTO20", nc_code_line_nr=2)
+        # target node
+        node_target = NCCommandNode(g_code_command={"G01"}, command_parameter={"X": "7", "F": "60", "N": "20"}, nc_code_line_nr=3)
+
+        canal.run_nc_code_list([node_set, node_if, node_target])
+
+        # move should have executed because IF condition true
+        tp = canal.get_tool_path()
+        self.assertTrue(len(tp) >= 1)
+        self.assertAlmostEqual(state.get_axis("X"), 7.0)
+
+    def test_goto_to_do_label(self):
+        state = CNCState()
+        state.feed_rate = 60.0
+        canal = StatefulIsoTurnCanal("C1", init_state=state)
+
+        # GOTO1 should jump to DO1
+        node_goto = NCCommandNode(g_code_command=set(), command_parameter={}, loop_command="GOTO1", nc_code_line_nr=1)
+        node_before = NCCommandNode(g_code_command=set(), command_parameter={}, nc_code_line_nr=2)
+        node_do = NCCommandNode(g_code_command=set(), command_parameter={"N": "10"}, loop_command="DO1", nc_code_line_nr=3)
+        node_move = NCCommandNode(g_code_command={"G01"}, command_parameter={"X": "3", "F": "60", "N": "11"}, nc_code_line_nr=4)
+
+        canal.run_nc_code_list([node_goto, node_before, node_do, node_move])
+
+        tp = canal.get_tool_path()
+        self.assertTrue(len(tp) >= 1)
+        self.assertAlmostEqual(state.get_axis("X"), 3.0)
+
+    def test_nested_do_end_loops(self):
+        state = CNCState()
+        state.feed_rate = 60.0
+        canal = StatefulIsoTurnCanal("C1", init_state=state)
+
+        # outer DO1 L2
+        node_do1 = NCCommandNode(g_code_command=set(), command_parameter={"N": "10", "L": "2"}, loop_command="DO1", nc_code_line_nr=1)
+        # inner DO2 L3
+        node_do2 = NCCommandNode(g_code_command=set(), command_parameter={"N": "11", "L": "3"}, loop_command="DO2", nc_code_line_nr=2)
+        # move inside inner loop
+        node_move = NCCommandNode(g_code_command={"G01"}, command_parameter={"X": "5", "F": "60", "N": "12"}, nc_code_line_nr=3)
+        node_end2 = NCCommandNode(g_code_command=set(), command_parameter={"N": "13"}, loop_command="END2", nc_code_line_nr=4)
+        node_end1 = NCCommandNode(g_code_command=set(), command_parameter={"N": "14"}, loop_command="END1", nc_code_line_nr=5)
+
+        canal.run_nc_code_list([node_do1, node_do2, node_move, node_end2, node_end1])
+
+        tp = canal.get_tool_path()
+        # expected: inner loop 3 times per outer loop, outer loops 2 times => 6 moves
+        self.assertTrue(len(tp) >= 6)
+        self.assertAlmostEqual(state.get_axis("X"), 5.0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/unit/test_control_flow_variable.py b/tests/unit/test_control_flow_variable.py
index 0785ac8..c025c9d 100644
--- a/tests/unit/test_control_flow_variable.py
+++ b/tests/unit/test_control_flow_variable.py
@@ -1,51 +1,51 @@
-import unittest
-
-from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnCanal
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-
-
-class TestVariableAndControlFlow(unittest.TestCase):
-    def test_variable_assignment_and_substitution(self):
-        # Test VariableHandler directly (deterministic unit test)
-        state = CNCState()
-        from ncplot7py.domain.handlers.variable import VariableHandler
-        vh = VariableHandler()
-
-        # variable assignment: #500 = [10+5]
-        node_var = NCCommandNode(g_code_command=set(), command_parameter={}, variable_command="#500=[10+5]", nc_code_line_nr=1)
-        vh.handle(node_var, state)
-        # variable should be set in state
-        self.assertIn("500", state.parameters)
-        self.assertEqual(float(state.parameters["500"]), 15.0)
-
-        # parameter using bracketed expression referencing #500 -> evaluate
-        node_move = NCCommandNode(g_code_command={"G01"}, command_parameter={"X": "[#500+2]", "F": "60"}, nc_code_line_nr=2)
-        vh.handle(node_move, state)
-        # parameter should have been replaced to numeric string
-        self.assertIn("X", node_move.command_parameter)
-        self.assertIn("60", node_move.command_parameter.values())
-
-    def test_do_end_loop_counter(self):
-        state = CNCState()
-        # set a reasonable feed rate so duration not zero
-        state.feed_rate = 60.0
-        canal = StatefulIsoTurnCanal("C1", init_state=state)
-
-        # DO1 L2 (label 1, loop 2 times)
-        node_do = NCCommandNode(g_code_command=set(), command_parameter={"N": "10", "L": "2"}, loop_command="DO1", nc_code_line_nr=1)
-        # motion node
-        node_move = NCCommandNode(g_code_command={"G01"}, command_parameter={"X": "10", "F": "60", "N": "20"}, nc_code_line_nr=2)
-        # END1
-        node_end = NCCommandNode(g_code_command=set(), command_parameter={"N": "30"}, loop_command="END1", nc_code_line_nr=3)
-
-        canal.run_nc_code_list([node_do, node_move, node_end])
-        tp = canal.get_tool_path()
-        # move should have been executed at least once due to L=2
-        self.assertTrue(len(tp) >= 1)
-        # final state X should be 10
-        self.assertAlmostEqual(state.get_axis("X"), 10.0)
-
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+
+from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnCanal
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+
+
+class TestVariableAndControlFlow(unittest.TestCase):
+    def test_variable_assignment_and_substitution(self):
+        # Test VariableHandler directly (deterministic unit test)
+        state = CNCState()
+        from ncplot7py.domain.handlers.variable import VariableHandler
+        vh = VariableHandler()
+
+        # variable assignment: #500 = [10+5]
+        node_var = NCCommandNode(g_code_command=set(), command_parameter={}, variable_command="#500=[10+5]", nc_code_line_nr=1)
+        vh.handle(node_var, state)
+        # variable should be set in state
+        self.assertIn("500", state.parameters)
+        self.assertEqual(float(state.parameters["500"]), 15.0)
+
+        # parameter using bracketed expression referencing #500 -> evaluate
+        node_move = NCCommandNode(g_code_command={"G01"}, command_parameter={"X": "[#500+2]", "F": "60"}, nc_code_line_nr=2)
+        vh.handle(node_move, state)
+        # parameter should have been replaced to numeric string
+        self.assertIn("X", node_move.command_parameter)
+        self.assertIn("60", node_move.command_parameter.values())
+
+    def test_do_end_loop_counter(self):
+        state = CNCState()
+        # set a reasonable feed rate so duration not zero
+        state.feed_rate = 60.0
+        canal = StatefulIsoTurnCanal("C1", init_state=state)
+
+        # DO1 L2 (label 1, loop 2 times)
+        node_do = NCCommandNode(g_code_command=set(), command_parameter={"N": "10", "L": "2"}, loop_command="DO1", nc_code_line_nr=1)
+        # motion node
+        node_move = NCCommandNode(g_code_command={"G01"}, command_parameter={"X": "10", "F": "60", "N": "20"}, nc_code_line_nr=2)
+        # END1
+        node_end = NCCommandNode(g_code_command=set(), command_parameter={"N": "30"}, loop_command="END1", nc_code_line_nr=3)
+
+        canal.run_nc_code_list([node_do, node_move, node_end])
+        tp = canal.get_tool_path()
+        # move should have been executed at least once due to L=2
+        self.assertTrue(len(tp) >= 1)
+        # final state X should be 10
+        self.assertAlmostEqual(state.get_axis("X"), 10.0)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/unit/test_error_helper.py b/tests/unit/test_error_helper.py
index 23f49dd..50eebb1 100644
--- a/tests/unit/test_error_helper.py
+++ b/tests/unit/test_error_helper.py
@@ -1,33 +1,33 @@
-import unittest
-
-from ncplot7py.domain.exceptions import ExceptionTyps, raise_nc_error, ExceptionNode
-from ncplot7py.domain.i18n import MessageCatalog
-
-
-class TestRaiseNCError(unittest.TestCase):
-    def test_raise_with_inferred_column_and_context(self):
-        try:
-            raise_nc_error(
-                ExceptionTyps.NCCodeErrors,
-                1001,
-                value="M30",
-                file="program.nc",
-                line=7,
-                source_line="N7 G1 X10 Y10 M30",
-            )
-        except ExceptionNode as e:
-            # Ensure fields populated
-            self.assertEqual(e.line, 7)
-            self.assertEqual(e.file, "program.nc")
-            self.assertGreater(e.column, 0)
-            self.assertIn("M30", e.context)
-            # Localized formatting contains caret/trace
-            s = MessageCatalog().format_exception(e, lang="en")
-            self.assertIn("Invalid NC code", s)
-            self.assertIn("->", s)
-        else:
-            self.fail("ExceptionNode was not raised")
-
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+
+from ncplot7py.domain.exceptions import ExceptionTyps, raise_nc_error, ExceptionNode
+from ncplot7py.domain.i18n import MessageCatalog
+
+
+class TestRaiseNCError(unittest.TestCase):
+    def test_raise_with_inferred_column_and_context(self):
+        try:
+            raise_nc_error(
+                ExceptionTyps.NCCodeErrors,
+                1001,
+                value="M30",
+                file="program.nc",
+                line=7,
+                source_line="N7 G1 X10 Y10 M30",
+            )
+        except ExceptionNode as e:
+            # Ensure fields populated
+            self.assertEqual(e.line, 7)
+            self.assertEqual(e.file, "program.nc")
+            self.assertGreater(e.column, 0)
+            self.assertIn("M30", e.context)
+            # Localized formatting contains caret/trace
+            s = MessageCatalog().format_exception(e, lang="en")
+            self.assertIn("Invalid NC code", s)
+            self.assertIn("->", s)
+        else:
+            self.fail("ExceptionNode was not raised")
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/unit/test_exceptions.py b/tests/unit/test_exceptions.py
index 020289e..b19fd6a 100644
--- a/tests/unit/test_exceptions.py
+++ b/tests/unit/test_exceptions.py
@@ -1,32 +1,32 @@
-import unittest
-
-from ncplot7py.domain.exceptions import ExceptionNode, ExceptionTyps
-
-
-class TestExceptionNode(unittest.TestCase):
-    def test_basic_fields_and_str(self):
-        e = ExceptionNode(ExceptionTyps.NCCodeErrors, code=42, line=10, message="bad token", value="G1 X")
-        s = str(e)
-        self.assertIn("NCCodeErrors", s)
-        self.assertIn("code=42", s)
-        self.assertIn("line=10", s)
-        self.assertIn("message=bad token", s)
-        self.assertIn("value=G1 X", s)
-
-    def test_to_dict(self):
-        e = ExceptionNode(ExceptionTyps.CNCError, code=7, line=0, message="oops")
-        d = e.to_dict()
-        self.assertEqual(d["code"], 7)
-        self.assertEqual(d["line"], 0)
-        self.assertEqual(d["message"], "oops")
-        self.assertEqual(d["typ"]["name"], "CNCError")
-        self.assertEqual(d["typ"]["value"], int(ExceptionTyps.CNCError))
-
-    def test_raises_like_exception(self):
-        e = ExceptionNode(ExceptionTyps.NCCanalStarErrors, code=1, message="boom")
-        with self.assertRaises(ExceptionNode):
-            raise e
-
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+
+from ncplot7py.domain.exceptions import ExceptionNode, ExceptionTyps
+
+
+class TestExceptionNode(unittest.TestCase):
+    def test_basic_fields_and_str(self):
+        e = ExceptionNode(ExceptionTyps.NCCodeErrors, code=42, line=10, message="bad token", value="G1 X")
+        s = str(e)
+        self.assertIn("NCCodeErrors", s)
+        self.assertIn("code=42", s)
+        self.assertIn("line=10", s)
+        self.assertIn("message=bad token", s)
+        self.assertIn("value=G1 X", s)
+
+    def test_to_dict(self):
+        e = ExceptionNode(ExceptionTyps.CNCError, code=7, line=0, message="oops")
+        d = e.to_dict()
+        self.assertEqual(d["code"], 7)
+        self.assertEqual(d["line"], 0)
+        self.assertEqual(d["message"], "oops")
+        self.assertEqual(d["typ"]["name"], "CNCError")
+        self.assertEqual(d["typ"]["value"], int(ExceptionTyps.CNCError))
+
+    def test_raises_like_exception(self):
+        e = ExceptionNode(ExceptionTyps.NCCanalStarErrors, code=1, message="boom")
+        with self.assertRaises(ExceptionNode):
+            raise e
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/unit/test_fanuc_modals.py b/tests/unit/test_fanuc_modals.py
index 0c703c5..ad08cd3 100644
--- a/tests/unit/test_fanuc_modals.py
+++ b/tests/unit/test_fanuc_modals.py
@@ -1,58 +1,58 @@
-import unittest
-
-from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnCanal
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group2_speed_mode import SpeedMode
-from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group5_feed_mode import FeedMode
-
-
-class TestFanucModals(unittest.TestCase):
-    def test_g96_sets_surface_speed_mode(self):
-        cstate = CNCState()
-        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
-        node = NCCommandNode(g_code_command={'G96'}, command_parameter={})
-        canal.run_nc_code_list([node])
-        self.assertIn('surface_speed_mode', cstate.extra)
-        val = cstate.extra['surface_speed_mode']
-        # Accept both Enum and string values
-        self.assertTrue(val == SpeedMode.CONSTANT_CUTSPEED or val == SpeedMode.CONSTANT_CUTSPEED.value)
-
-    def test_g97_sets_constant_rev(self):
-        cstate = CNCState()
-        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
-        node = NCCommandNode(g_code_command={'G97'}, command_parameter={})
-        canal.run_nc_code_list([node])
-        self.assertIn('surface_speed_mode', cstate.extra)
-        val = cstate.extra['surface_speed_mode']
-        self.assertTrue(val == SpeedMode.CONSTANT_REV or val == SpeedMode.CONSTANT_REV.value)
-
-    def test_g98_and_g99_conflict_raises(self):
-        cstate = CNCState()
-        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
-        node = NCCommandNode(g_code_command={'G98','G99'}, command_parameter={})
-        # Running should raise an exception from the handler; capture via unittest
-        with self.assertRaises(Exception):
-            canal.run_nc_code_list([node])
-
-    def test_g98_sets_feed_per_min(self):
-        cstate = CNCState()
-        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
-        node = NCCommandNode(g_code_command={'G98'}, command_parameter={})
-        canal.run_nc_code_list([node])
-        self.assertIn('feed_mode', cstate.extra)
-        val = cstate.extra['feed_mode']
-        self.assertTrue(val == FeedMode.FEED_PER_MIN or val == FeedMode.FEED_PER_MIN.value)
-
-    def test_g99_sets_feed_per_rev(self):
-        cstate = CNCState()
-        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
-        node = NCCommandNode(g_code_command={'G99'}, command_parameter={})
-        canal.run_nc_code_list([node])
-        self.assertIn('feed_mode', cstate.extra)
-        val = cstate.extra['feed_mode']
-        self.assertTrue(val == FeedMode.FEED_PER_REV or val == FeedMode.FEED_PER_REV.value)
-
-
-if __name__ == '__main__':
-    unittest.main()
+import unittest
+
+from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnCanal
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group2_speed_mode import SpeedMode
+from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_group5_feed_mode import FeedMode
+
+
+class TestFanucModals(unittest.TestCase):
+    def test_g96_sets_surface_speed_mode(self):
+        cstate = CNCState()
+        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
+        node = NCCommandNode(g_code_command={'G96'}, command_parameter={})
+        canal.run_nc_code_list([node])
+        self.assertIn('surface_speed_mode', cstate.extra)
+        val = cstate.extra['surface_speed_mode']
+        # Accept both Enum and string values
+        self.assertTrue(val == SpeedMode.CONSTANT_CUTSPEED or val == SpeedMode.CONSTANT_CUTSPEED.value)
+
+    def test_g97_sets_constant_rev(self):
+        cstate = CNCState()
+        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
+        node = NCCommandNode(g_code_command={'G97'}, command_parameter={})
+        canal.run_nc_code_list([node])
+        self.assertIn('surface_speed_mode', cstate.extra)
+        val = cstate.extra['surface_speed_mode']
+        self.assertTrue(val == SpeedMode.CONSTANT_REV or val == SpeedMode.CONSTANT_REV.value)
+
+    def test_g98_and_g99_conflict_raises(self):
+        cstate = CNCState()
+        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
+        node = NCCommandNode(g_code_command={'G98','G99'}, command_parameter={})
+        # Running should raise an exception from the handler; capture via unittest
+        with self.assertRaises(Exception):
+            canal.run_nc_code_list([node])
+
+    def test_g98_sets_feed_per_min(self):
+        cstate = CNCState()
+        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
+        node = NCCommandNode(g_code_command={'G98'}, command_parameter={})
+        canal.run_nc_code_list([node])
+        self.assertIn('feed_mode', cstate.extra)
+        val = cstate.extra['feed_mode']
+        self.assertTrue(val == FeedMode.FEED_PER_MIN or val == FeedMode.FEED_PER_MIN.value)
+
+    def test_g99_sets_feed_per_rev(self):
+        cstate = CNCState()
+        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
+        node = NCCommandNode(g_code_command={'G99'}, command_parameter={})
+        canal.run_nc_code_list([node])
+        self.assertIn('feed_mode', cstate.extra)
+        val = cstate.extra['feed_mode']
+        self.assertTrue(val == FeedMode.FEED_PER_REV or val == FeedMode.FEED_PER_REV.value)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/unit/test_file_adapter.py b/tests/unit/test_file_adapter.py
index 7b1e203..2e71bcc 100644
--- a/tests/unit/test_file_adapter.py
+++ b/tests/unit/test_file_adapter.py
@@ -1,48 +1,48 @@
-import os
-import tempfile
-import unittest
-
-from ncplot7py.shared.file_adapter import get_a_file, get_program
-
-
-class TestFileAdapter(unittest.TestCase):
-    def test_get_a_file_reads_lines(self):
-        content = "line1\nline2\n"
-        with tempfile.NamedTemporaryFile(mode="w", delete=False, encoding="utf-8") as t:
-            t.write(content)
-            fname = t.name
-        try:
-            lines = get_a_file(fname)
-            self.assertEqual(lines, ["line1", "line2"])
-        finally:
-            os.remove(fname)
-
-    def test_remove_parentheses_and_join_single_program(self):
-        lines = [
-            "G01 X10 (this is a comment)",
-            "Y20 (nested (inner) comment)",
-            "Z30",
-        ]
-        progs = get_program(lines, split_on_blank_line=False)
-        # parentheses content removed, lines joined with ';'
-        self.assertEqual(len(progs), 1)
-        self.assertEqual(progs[0], "G01 X10;Y20;Z30")
-
-    def test_split_on_blank_lines(self):
-        lines = [
-            "M01 (skip)",
-            "",
-            "G00 X0 Y0",
-            "G01 X1",
-            "",
-            "(full comment)",
-            "G02 X2 Y2",
-        ]
-        progs = get_program(lines, split_on_blank_line=True)
-        # expected 3 programs (first, second, third) but the middle blank-only
-        # group should be skipped if empty after stripping
-        self.assertEqual(progs, ["M01", "G00 X0 Y0;G01 X1", "G02 X2 Y2"]) 
-
-
-if __name__ == "__main__":
-    unittest.main()
+import os
+import tempfile
+import unittest
+
+from ncplot7py.shared.file_adapter import get_a_file, get_program
+
+
+class TestFileAdapter(unittest.TestCase):
+    def test_get_a_file_reads_lines(self):
+        content = "line1\nline2\n"
+        with tempfile.NamedTemporaryFile(mode="w", delete=False, encoding="utf-8") as t:
+            t.write(content)
+            fname = t.name
+        try:
+            lines = get_a_file(fname)
+            self.assertEqual(lines, ["line1", "line2"])
+        finally:
+            os.remove(fname)
+
+    def test_remove_parentheses_and_join_single_program(self):
+        lines = [
+            "G01 X10 (this is a comment)",
+            "Y20 (nested (inner) comment)",
+            "Z30",
+        ]
+        progs = get_program(lines, split_on_blank_line=False)
+        # parentheses content removed, lines joined with ';'
+        self.assertEqual(len(progs), 1)
+        self.assertEqual(progs[0], "G01 X10;Y20;Z30")
+
+    def test_split_on_blank_lines(self):
+        lines = [
+            "M01 (skip)",
+            "",
+            "G00 X0 Y0",
+            "G01 X1",
+            "",
+            "(full comment)",
+            "G02 X2 Y2",
+        ]
+        progs = get_program(lines, split_on_blank_line=True)
+        # expected 3 programs (first, second, third) but the middle blank-only
+        # group should be skipped if empty after stripping
+        self.assertEqual(progs, ["M01", "G00 X0 Y0;G01 X1", "G02 X2 Y2"]) 
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/unit/test_gcode_group21.py b/tests/unit/test_gcode_group21.py
index 8414b71..87ae0bd 100644
--- a/tests/unit/test_gcode_group21.py
+++ b/tests/unit/test_gcode_group21.py
@@ -1,54 +1,54 @@
-import unittest
-
-from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnCanal
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.cnc_state import CNCState
-
-
-class TestGCodeGroup21Polar(unittest.TestCase):
-    def test_polar_remap_c_to_v_and_h_to_u_with_axis_y(self):
-        # Setup canal and state with polar axis Y
-        cstate = CNCState()
-        cstate.extra['polar_interpolate_axis'] = 'Y'
-        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
-
-        # Node enabling polar (G112) and specifying C and H
-        node_enable = NCCommandNode(g_code_command={'G112'}, command_parameter={})
-        node_motion = NCCommandNode(g_code_command={'G1'}, command_parameter={'C': '10.0', 'H': '2.5'})
-        # link
-        node_enable._next_ncCode = node_motion
-        node_motion._before_ncCode = node_enable
-
-        canal.run_nc_code_list([node_enable, node_motion])
-
-        # After execution, the motion node should have V and not H, and Y (polar axis)
-        self.assertIn('V', node_motion.command_parameter)
-        self.assertEqual(float(node_motion.command_parameter['V']), 2.5)
-        # C should be remapped into Y axis displacement
-        self.assertIn('Y', node_motion.command_parameter)
-        self.assertAlmostEqual(float(node_motion.command_parameter['Y']), 10.0)
-        self.assertNotIn('C', node_motion.command_parameter)
-        self.assertNotIn('H', node_motion.command_parameter)
-
-    def test_arc_direction_swap_when_axis_x(self):
-        # Setup state with polar axis X
-        cstate = CNCState()
-        cstate.extra['polar_interpolate_axis'] = 'X'
-        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
-        # Node enabling polar and an arc G2 (provide an R param so motion
-        # handler has sufficient information for interpolation)
-        node_enable = NCCommandNode(g_code_command={'G112'}, command_parameter={})
-        node_arc = NCCommandNode(g_code_command={'G2'}, command_parameter={'C': '5.0', 'R': '5.0'})
-        node_enable._next_ncCode = node_arc
-        node_arc._before_ncCode = node_enable
-
-        canal.run_nc_code_list([node_enable, node_arc])
-
-        # Arc direction should be swapped: G2 -> G3
-        # Note: sets are unordered, check presence of G3 and absence of G2
-        self.assertIn('G3', node_arc.g_code)
-        self.assertNotIn('G2', node_arc.g_code)
-
-
-if __name__ == '__main__':
-    unittest.main()
+import unittest
+
+from ncplot7py.infrastructure.machines.stateful_star_turn_control import StatefulIsoTurnCanal
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.cnc_state import CNCState
+
+
+class TestGCodeGroup21Polar(unittest.TestCase):
+    def test_polar_remap_c_to_v_and_h_to_u_with_axis_y(self):
+        # Setup canal and state with polar axis Y
+        cstate = CNCState()
+        cstate.extra['polar_interpolate_axis'] = 'Y'
+        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
+
+        # Node enabling polar (G112) and specifying C and H
+        node_enable = NCCommandNode(g_code_command={'G112'}, command_parameter={})
+        node_motion = NCCommandNode(g_code_command={'G1'}, command_parameter={'C': '10.0', 'H': '2.5'})
+        # link
+        node_enable._next_ncCode = node_motion
+        node_motion._before_ncCode = node_enable
+
+        canal.run_nc_code_list([node_enable, node_motion])
+
+        # After execution, the motion node should have V and not H, and Y (polar axis)
+        self.assertIn('V', node_motion.command_parameter)
+        self.assertEqual(float(node_motion.command_parameter['V']), 2.5)
+        # C should be remapped into Y axis displacement
+        self.assertIn('Y', node_motion.command_parameter)
+        self.assertAlmostEqual(float(node_motion.command_parameter['Y']), 10.0)
+        self.assertNotIn('C', node_motion.command_parameter)
+        self.assertNotIn('H', node_motion.command_parameter)
+
+    def test_arc_direction_swap_when_axis_x(self):
+        # Setup state with polar axis X
+        cstate = CNCState()
+        cstate.extra['polar_interpolate_axis'] = 'X'
+        canal = StatefulIsoTurnCanal('C1', init_state=cstate)
+        # Node enabling polar and an arc G2 (provide an R param so motion
+        # handler has sufficient information for interpolation)
+        node_enable = NCCommandNode(g_code_command={'G112'}, command_parameter={})
+        node_arc = NCCommandNode(g_code_command={'G2'}, command_parameter={'C': '5.0', 'R': '5.0'})
+        node_enable._next_ncCode = node_arc
+        node_arc._before_ncCode = node_enable
+
+        canal.run_nc_code_list([node_enable, node_arc])
+
+        # Arc direction should be swapped: G2 -> G3
+        # Note: sets are unordered, check presence of G3 and absence of G2
+        self.assertIn('G3', node_arc.g_code)
+        self.assertNotIn('G2', node_arc.g_code)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/unit/test_gcode_precheck.py b/tests/unit/test_gcode_precheck.py
index 27c4aa6..d900803 100644
--- a/tests/unit/test_gcode_precheck.py
+++ b/tests/unit/test_gcode_precheck.py
@@ -1,37 +1,37 @@
-import unittest
-
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_precheck import GcodePreCheckExecChainLink
-from ncplot7py.domain.exceptions import ExceptionNode, ExceptionTyps
-
-
-class TestGcodePreCheck(unittest.TestCase):
-    def test_uppercase_parameters_pass(self):
-        handler = GcodePreCheckExecChainLink()
-        state = CNCState()
-
-        node = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "10.0", "Z": "5.0"})
-
-        pts, dur = handler.handle(node, state)
-
-        # Should delegate and not raise; returns None, None by default
-        self.assertIsNone(pts)
-        self.assertIsNone(dur)
-
-    def test_lowercase_parameter_raises_exceptionnode(self):
-        handler = GcodePreCheckExecChainLink()
-        state = CNCState()
-
-        node = NCCommandNode(g_code_command={"G1"}, command_parameter={"x": "10.0"})
-
-        with self.assertRaises(ExceptionNode) as cm:
-            handler.handle(node, state)
-
-        exc = cm.exception
-        self.assertEqual(exc.typ, ExceptionTyps.NCCodeErrors)
-        self.assertEqual(exc.code, 130)
-
-
-if __name__ == '__main__':
-    unittest.main()
+import unittest
+
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.handlers.fanuc_turn_cnc.gcode_precheck import GcodePreCheckExecChainLink
+from ncplot7py.domain.exceptions import ExceptionNode, ExceptionTyps
+
+
+class TestGcodePreCheck(unittest.TestCase):
+    def test_uppercase_parameters_pass(self):
+        handler = GcodePreCheckExecChainLink()
+        state = CNCState()
+
+        node = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "10.0", "Z": "5.0"})
+
+        pts, dur = handler.handle(node, state)
+
+        # Should delegate and not raise; returns None, None by default
+        self.assertIsNone(pts)
+        self.assertIsNone(dur)
+
+    def test_lowercase_parameter_raises_exceptionnode(self):
+        handler = GcodePreCheckExecChainLink()
+        state = CNCState()
+
+        node = NCCommandNode(g_code_command={"G1"}, command_parameter={"x": "10.0"})
+
+        with self.assertRaises(ExceptionNode) as cm:
+            handler.handle(node, state)
+
+        exc = cm.exception
+        self.assertEqual(exc.typ, ExceptionTyps.NCCodeErrors)
+        self.assertEqual(exc.code, 130)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/unit/test_i18n_exceptions.py b/tests/unit/test_i18n_exceptions.py
index ef6bba7..20b7249 100644
--- a/tests/unit/test_i18n_exceptions.py
+++ b/tests/unit/test_i18n_exceptions.py
@@ -1,31 +1,31 @@
-import unittest
-
-from ncplot7py.domain.exceptions import ExceptionNode, ExceptionTyps
-from ncplot7py.domain.i18n import MessageCatalog
-
-
-class TestI18nExceptions(unittest.TestCase):
-    def test_localized_message_en(self):
-        e = ExceptionNode(ExceptionTyps.NCCodeErrors, code=1001, line=12, value="M30", file="program.nc", column=6, context="N10 M30")
-        cat = MessageCatalog()
-        s = cat.format_exception(e, lang="en")
-        self.assertIn("Invalid NC code 'M30'", s)
-        self.assertIn("line 12", s)  # either in message or trace
-        self.assertIn("program.nc", s)
-        self.assertIn("-> N10 M30", s)
-
-    def test_localized_message_de(self):
-        e = ExceptionNode(ExceptionTyps.NCCodeErrors, code=1001, line=3, value="G1")
-        s = MessageCatalog().format_exception(e, lang="de", include_trace=False)
-        self.assertIn("Ungültiger NC-Code 'G1'", s)
-        self.assertIn("Zeile 3", s)
-
-    def test_fallback_when_missing(self):
-        # Code not in the catalog -> fallback to message or generic
-        e = ExceptionNode(ExceptionTyps.CNCError, code=9999, line=1, message="fallback message")
-        s = MessageCatalog().format_exception(e, lang="en", include_trace=False)
-        self.assertIn("fallback message", s)
-
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+
+from ncplot7py.domain.exceptions import ExceptionNode, ExceptionTyps
+from ncplot7py.domain.i18n import MessageCatalog
+
+
+class TestI18nExceptions(unittest.TestCase):
+    def test_localized_message_en(self):
+        e = ExceptionNode(ExceptionTyps.NCCodeErrors, code=1001, line=12, value="M30", file="program.nc", column=6, context="N10 M30")
+        cat = MessageCatalog()
+        s = cat.format_exception(e, lang="en")
+        self.assertIn("Invalid NC code 'M30'", s)
+        self.assertIn("line 12", s)  # either in message or trace
+        self.assertIn("program.nc", s)
+        self.assertIn("-> N10 M30", s)
+
+    def test_localized_message_de(self):
+        e = ExceptionNode(ExceptionTyps.NCCodeErrors, code=1001, line=3, value="G1")
+        s = MessageCatalog().format_exception(e, lang="de", include_trace=False)
+        self.assertIn("Ungültiger NC-Code 'G1'", s)
+        self.assertIn("Zeile 3", s)
+
+    def test_fallback_when_missing(self):
+        # Code not in the catalog -> fallback to message or generic
+        e = ExceptionNode(ExceptionTyps.CNCError, code=9999, line=1, message="fallback message")
+        s = MessageCatalog().format_exception(e, lang="en", include_trace=False)
+        self.assertIn("fallback message", s)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/unit/test_linked_list_list.py b/tests/unit/test_linked_list_list.py
index 1fab299..e477dad 100644
--- a/tests/unit/test_linked_list_list.py
+++ b/tests/unit/test_linked_list_list.py
@@ -1,51 +1,51 @@
-import unittest
-from ncplot7py.shared.linked_list_list import LinkedListAsList
-from typing import Dict
-
-
-class NCNode:
-	line: int
-	cmd: str
-	params: Dict[str, str]
-
-class DummyNode(NCNode):
-    def __init__(self, line: int, cmd: str, params: dict | None = None):
-        # NCNode is a simple annotated class with no __init__, so set attributes
-        # directly instead of calling super().__init__()
-        self.line = line
-        self.cmd = cmd
-        self.params = params or {}
-
-
-class TestLinkedListAsList(unittest.TestCase):
-    def test_append_and_len(self):
-        ll = LinkedListAsList[DummyNode]()
-        a = DummyNode(1, "G1")
-        b = DummyNode(2, "G1")
-        ll.append(a)
-        ll.append(b)
-        self.assertEqual(len(ll), 2)
-
-    def test_insert_after(self):
-        ll = LinkedListAsList[DummyNode]()
-        a = DummyNode(1, "G1")
-        b = DummyNode(2, "G1")
-        x = DummyNode(3, "G1")
-        ll.append(a)
-        ll.append(b)
-        ll.insert_after(a, x)
-        self.assertEqual(ll.get_node_from_index(1), x)
-
-    def test_remove(self):
-        ll = LinkedListAsList[DummyNode]()
-        a = DummyNode(1, "G1")
-        b = DummyNode(2, "G1")
-        ll.append(a)
-        ll.append(b)
-        removed = ll.remove(a)
-        self.assertIs(removed, a)
-        self.assertEqual(len(ll), 1)
-
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+from ncplot7py.shared.linked_list_list import LinkedListAsList
+from typing import Dict
+
+
+class NCNode:
+	line: int
+	cmd: str
+	params: Dict[str, str]
+
+class DummyNode(NCNode):
+    def __init__(self, line: int, cmd: str, params: dict | None = None):
+        # NCNode is a simple annotated class with no __init__, so set attributes
+        # directly instead of calling super().__init__()
+        self.line = line
+        self.cmd = cmd
+        self.params = params or {}
+
+
+class TestLinkedListAsList(unittest.TestCase):
+    def test_append_and_len(self):
+        ll = LinkedListAsList[DummyNode]()
+        a = DummyNode(1, "G1")
+        b = DummyNode(2, "G1")
+        ll.append(a)
+        ll.append(b)
+        self.assertEqual(len(ll), 2)
+
+    def test_insert_after(self):
+        ll = LinkedListAsList[DummyNode]()
+        a = DummyNode(1, "G1")
+        b = DummyNode(2, "G1")
+        x = DummyNode(3, "G1")
+        ll.append(a)
+        ll.append(b)
+        ll.insert_after(a, x)
+        self.assertEqual(ll.get_node_from_index(1), x)
+
+    def test_remove(self):
+        ll = LinkedListAsList[DummyNode]()
+        a = DummyNode(1, "G1")
+        b = DummyNode(2, "G1")
+        ll.append(a)
+        ll.append(b)
+        removed = ll.remove(a)
+        self.assertIs(removed, a)
+        self.assertEqual(len(ll), 1)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/unit/test_logging_facade.py b/tests/unit/test_logging_facade.py
index c0110b0..012d003 100644
--- a/tests/unit/test_logging_facade.py
+++ b/tests/unit/test_logging_facade.py
@@ -1,76 +1,76 @@
-import os
-import sys
-import unittest
-
-# Ensure the package is importable when tests are run from the repo root
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
-
-
-class LoggingFacadeTests(unittest.TestCase):
-    def setUp(self) -> None:
-        from ncplot7py.shared.logging_facade import configure_logging, clear_message_stack
-
-        # Small buffer for deterministic tests
-        configure_logging(console=False, web_buffer=True, buffer_maxlen=3)
-        clear_message_stack()
-
-    def test_inmemory_buffer_and_truncation(self):
-        from ncplot7py.shared.logging_facade import (
-            print_message,
-            print_error,
-            get_message_stack,
-        )
-
-        print_message('alpha')
-        print_error('beta')
-        print_message('gamma')
-
-        stack = get_message_stack()
-        lines = [l for l in stack.split('\n') if l.strip()]
-        self.assertEqual(len(lines), 3)
-        self.assertTrue(any('INFO' in l and 'alpha' in l for l in lines))
-        self.assertTrue(any('ERROR' in l and 'beta' in l for l in lines))
-
-        # add another message to force truncation (maxlen=3)
-        print_message('delta')
-        lines2 = [l for l in get_message_stack().split('\n') if l.strip()]
-        self.assertEqual(len(lines2), 3)
-        self.assertTrue(any('delta' in l for l in lines2))
-
-    def test_clear_message_stack(self):
-        from ncplot7py.shared.logging_facade import (
-            print_message,
-            get_message_stack,
-            clear_message_stack,
-        )
-
-        print_message('one')
-        self.assertTrue(get_message_stack().strip() != '')
-        clear_message_stack()
-        self.assertEqual(get_message_stack().strip(), '')
-
-
-class I18nIntegrationTests(unittest.TestCase):
-    def setUp(self) -> None:
-        from ncplot7py.shared.logging_facade import configure_logging, clear_message_stack, configure_i18n
-
-        # enable web buffer
-        configure_logging(console=False, web_buffer=True, buffer_maxlen=10)
-        clear_message_stack()
-        # configure i18n to use bundled locales
-        configure_i18n()
-
-    def test_translate_and_log_messagekey(self):
-        from ncplot7py.domain.i18n import MessageKey
-        from ncplot7py.shared.logging_facade import print_translated_message, get_message_stack
-
-        # Use a key present in locales/en.xml
-        key = MessageKey.from_parts(1, 1001)
-        print_translated_message(key, lang='en', value='X', line=42)
-        stack = get_message_stack()
-        self.assertIn('Invalid NC code', stack)
-        self.assertIn('X', stack)
-
-
-if __name__ == '__main__':
-    unittest.main()
+import os
+import sys
+import unittest
+
+# Ensure the package is importable when tests are run from the repo root
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
+
+
+class LoggingFacadeTests(unittest.TestCase):
+    def setUp(self) -> None:
+        from ncplot7py.shared.logging_facade import configure_logging, clear_message_stack
+
+        # Small buffer for deterministic tests
+        configure_logging(console=False, web_buffer=True, buffer_maxlen=3)
+        clear_message_stack()
+
+    def test_inmemory_buffer_and_truncation(self):
+        from ncplot7py.shared.logging_facade import (
+            print_message,
+            print_error,
+            get_message_stack,
+        )
+
+        print_message('alpha')
+        print_error('beta')
+        print_message('gamma')
+
+        stack = get_message_stack()
+        lines = [l for l in stack.split('\n') if l.strip()]
+        self.assertEqual(len(lines), 3)
+        self.assertTrue(any('INFO' in l and 'alpha' in l for l in lines))
+        self.assertTrue(any('ERROR' in l and 'beta' in l for l in lines))
+
+        # add another message to force truncation (maxlen=3)
+        print_message('delta')
+        lines2 = [l for l in get_message_stack().split('\n') if l.strip()]
+        self.assertEqual(len(lines2), 3)
+        self.assertTrue(any('delta' in l for l in lines2))
+
+    def test_clear_message_stack(self):
+        from ncplot7py.shared.logging_facade import (
+            print_message,
+            get_message_stack,
+            clear_message_stack,
+        )
+
+        print_message('one')
+        self.assertTrue(get_message_stack().strip() != '')
+        clear_message_stack()
+        self.assertEqual(get_message_stack().strip(), '')
+
+
+class I18nIntegrationTests(unittest.TestCase):
+    def setUp(self) -> None:
+        from ncplot7py.shared.logging_facade import configure_logging, clear_message_stack, configure_i18n
+
+        # enable web buffer
+        configure_logging(console=False, web_buffer=True, buffer_maxlen=10)
+        clear_message_stack()
+        # configure i18n to use bundled locales
+        configure_i18n()
+
+    def test_translate_and_log_messagekey(self):
+        from ncplot7py.domain.i18n import MessageKey
+        from ncplot7py.shared.logging_facade import print_translated_message, get_message_stack
+
+        # Use a key present in locales/en.xml
+        key = MessageKey.from_parts(1, 1001)
+        print_translated_message(key, lang='en', value='X', line=42)
+        stack = get_message_stack()
+        self.assertIn('Invalid NC code', stack)
+        self.assertIn('X', stack)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/unit/test_nc_command_node.py b/tests/unit/test_nc_command_node.py
index 55950c2..784b19e 100644
--- a/tests/unit/test_nc_command_node.py
+++ b/tests/unit/test_nc_command_node.py
@@ -1,33 +1,33 @@
-import unittest
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.shared.linked_list_list import LinkedListAsList
-
-
-class TestNCCommandNode(unittest.TestCase):
-    def test_creation_and_str(self):
-        node = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "1.0"}, nc_code_line_nr=10)
-        s = str(node)
-        self.assertIn("G1", s)
-        self.assertIn("X=1.0", s)
-
-    def test_copy_independence(self):
-        node = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "1.0"}, nc_code_line_nr=5)
-        node_copy = node.copy()
-        self.assertIsNot(node, node_copy)
-        self.assertEqual(node.g_code, node_copy.g_code)
-        self.assertEqual(node.command_parameter, node_copy.command_parameter)
-
-    def test_linked_list_usage(self):
-        ll = LinkedListAsList[NCCommandNode]()
-        a = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "0"}, nc_code_line_nr=1)
-        b = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "10"}, nc_code_line_nr=2)
-        ll.append(a)
-        ll.append(b)
-        # insert after a
-        x = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "5"}, nc_code_line_nr=3)
-        ll.insert_after(a, x)
-        self.assertEqual(ll.get_node_from_index(1), x)
-
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.shared.linked_list_list import LinkedListAsList
+
+
+class TestNCCommandNode(unittest.TestCase):
+    def test_creation_and_str(self):
+        node = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "1.0"}, nc_code_line_nr=10)
+        s = str(node)
+        self.assertIn("G1", s)
+        self.assertIn("X=1.0", s)
+
+    def test_copy_independence(self):
+        node = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "1.0"}, nc_code_line_nr=5)
+        node_copy = node.copy()
+        self.assertIsNot(node, node_copy)
+        self.assertEqual(node.g_code, node_copy.g_code)
+        self.assertEqual(node.command_parameter, node_copy.command_parameter)
+
+    def test_linked_list_usage(self):
+        ll = LinkedListAsList[NCCommandNode]()
+        a = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "0"}, nc_code_line_nr=1)
+        b = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "10"}, nc_code_line_nr=2)
+        ll.append(a)
+        ll.append(b)
+        # insert after a
+        x = NCCommandNode(g_code_command={"G1"}, command_parameter={"X": "5"}, nc_code_line_nr=3)
+        ll.insert_after(a, x)
+        self.assertEqual(ll.get_node_from_index(1), x)
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/unit/test_nc_command_parser.py b/tests/unit/test_nc_command_parser.py
index 7d05fb0..537e50a 100644
--- a/tests/unit/test_nc_command_parser.py
+++ b/tests/unit/test_nc_command_parser.py
@@ -1,41 +1,41 @@
-import unittest
-
-from ncplot7py.infrastructure.parsers.nc_command_parser import NCCommandStringParser
-from ncplot7py.domain.exceptions import ExceptionNode
-
-
-class TestNCCommandParser(unittest.TestCase):
-    def setUp(self) -> None:
-        self.parser = NCCommandStringParser()
-
-    def test_basic_g_and_params(self):
-        node = self.parser.parse("G1 X10 Y5", line_nr=7)
-        self.assertIn("G1", node.g_code)
-        self.assertEqual(node.command_parameter.get("X"), "10")
-        self.assertEqual(node.command_parameter.get("Y"), "5")
-        self.assertEqual(node.nc_code_line_nr, 7)
-
-    def test_duplicate_parameter_raises(self):
-        # Two X parameters should trigger a duplication error
-        with self.assertRaises(ExceptionNode):
-            self.parser.parse("X10 X20")
-
-    def test_variable_command_capture(self):
-        node = self.parser.parse("#100", line_nr=1)
-        self.assertEqual(node.variable_command, "#100")
-        self.assertEqual(node.g_code, set())
-        self.assertEqual(node.command_parameter, {})
-
-    def test_dddp_parsing_after_comma(self):
-        node = self.parser.parse(",R10")
-        # the parser places the token following the comma into dddp_command
-        self.assertIn("R10", node.dddp_command)
-
-    def test_loop_detection(self):
-        node = self.parser.parse("GOTO100", line_nr=3)
-        self.assertEqual(node.loop_command, "GOTO100")
-        self.assertEqual(node.g_code, set())
-
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+
+from ncplot7py.infrastructure.parsers.nc_command_parser import NCCommandStringParser
+from ncplot7py.domain.exceptions import ExceptionNode
+
+
+class TestNCCommandParser(unittest.TestCase):
+    def setUp(self) -> None:
+        self.parser = NCCommandStringParser()
+
+    def test_basic_g_and_params(self):
+        node = self.parser.parse("G1 X10 Y5", line_nr=7)
+        self.assertIn("G1", node.g_code)
+        self.assertEqual(node.command_parameter.get("X"), "10")
+        self.assertEqual(node.command_parameter.get("Y"), "5")
+        self.assertEqual(node.nc_code_line_nr, 7)
+
+    def test_duplicate_parameter_raises(self):
+        # Two X parameters should trigger a duplication error
+        with self.assertRaises(ExceptionNode):
+            self.parser.parse("X10 X20")
+
+    def test_variable_command_capture(self):
+        node = self.parser.parse("#100", line_nr=1)
+        self.assertEqual(node.variable_command, "#100")
+        self.assertEqual(node.g_code, set())
+        self.assertEqual(node.command_parameter, {})
+
+    def test_dddp_parsing_after_comma(self):
+        node = self.parser.parse(",R10")
+        # the parser places the token following the comma into dddp_command
+        self.assertIn("R10", node.dddp_command)
+
+    def test_loop_detection(self):
+        node = self.parser.parse("GOTO100", line_nr=3)
+        self.assertEqual(node.loop_command, "GOTO100")
+        self.assertEqual(node.g_code, set())
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/unit/test_nc_execution.py b/tests/unit/test_nc_execution.py
index e423706..dfe9a49 100644
--- a/tests/unit/test_nc_execution.py
+++ b/tests/unit/test_nc_execution.py
@@ -1,87 +1,87 @@
-import os
-import sys
-import unittest
-
-sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
-
-from ncplot7py.application.nc_execution import NCExecutionEngine
-
-
-class _Point:
-    def __init__(self, x, y, z):
-        self.x = x
-        self.y = y
-        self.z = z
-
-
-class _Node:
-    def __init__(self, nr):
-        self.nc_code_line_nr = nr
-
-
-class FakeControlHappy:
-    def __init__(self):
-        self._ran = []
-
-    def get_canal_count(self):
-        return 1
-
-    def run_nc_code_list(self, node_list, canal):
-        # accept list of nodes
-        self._ran.append((list(node_list), canal))
-
-    def get_tool_path(self, canal: int):
-        # return two lines: first with one point and time 0.5, second with one point and time 1.0
-        return [([_Point(1, 1, 1)], 0.5), ([_Point(2, 2, 2)], 1.0)]
-
-    def get_exected_nodes(self, canal: int):
-        return [_Node(0), _Node(1)]
-
-    def get_canal_name(self, idx: int):
-        return f"C{idx}"
-
-    def synchro_points(self, tool_paths, nodes):
-        # no-op
-        return None
-
-
-class FakeControlError:
-    def get_canal_count(self):
-        return 1
-
-    def run_nc_code_list(self, node_list, canal):
-        # raise a generic error
-        raise RuntimeError("control failed")
-
-
-class TestNCExecutionEngine(unittest.TestCase):
-    def test_happy_path_returns_plot_structure(self):
-        ctrl = FakeControlHappy()
-        engine = NCExecutionEngine(ctrl)
-        programs = ["G1 X1 Y1 Z1;G1 X2 Y2 Z2"]
-        result = engine.get_Syncro_plot(programs, synch=False)
-        # one canal
-        self.assertIsInstance(result, list)
-        self.assertEqual(len(result), 1)
-        canal = result[0]
-        self.assertIn("plot", canal)
-        self.assertEqual(canal["canalNr"], "C0")
-        plot = canal["plot"]
-        self.assertEqual(len(plot), 2)
-        self.assertEqual(plot[0]["x"], [1])
-        self.assertEqual(plot[0]["y"], [1])
-        self.assertEqual(plot[0]["z"], [1])
-        self.assertEqual(plot[0]["t"], 0.5)
-        self.assertEqual(plot[1]["x"], [2])
-        self.assertEqual(canal["programExec"], [0, 1])
-
-    def test_control_error_returns_empty_lists(self):
-        ctrl = FakeControlError()
-        engine = NCExecutionEngine(ctrl)
-        programs = ["G1 X1 Y1 Z1"]
-        result = engine.get_Syncro_plot(programs, synch=False)
-        self.assertEqual(result, [[], []])
-
-
-if __name__ == "__main__":
-    unittest.main()
+import os
+import sys
+import unittest
+
+sys.path.insert(0, os.path.join(os.path.dirname(__file__), '..', '..', 'src'))
+
+from ncplot7py.application.nc_execution import NCExecutionEngine
+
+
+class _Point:
+    def __init__(self, x, y, z):
+        self.x = x
+        self.y = y
+        self.z = z
+
+
+class _Node:
+    def __init__(self, nr):
+        self.nc_code_line_nr = nr
+
+
+class FakeControlHappy:
+    def __init__(self):
+        self._ran = []
+
+    def get_canal_count(self):
+        return 1
+
+    def run_nc_code_list(self, node_list, canal):
+        # accept list of nodes
+        self._ran.append((list(node_list), canal))
+
+    def get_tool_path(self, canal: int):
+        # return two lines: first with one point and time 0.5, second with one point and time 1.0
+        return [([_Point(1, 1, 1)], 0.5), ([_Point(2, 2, 2)], 1.0)]
+
+    def get_exected_nodes(self, canal: int):
+        return [_Node(0), _Node(1)]
+
+    def get_canal_name(self, idx: int):
+        return f"C{idx}"
+
+    def synchro_points(self, tool_paths, nodes):
+        # no-op
+        return None
+
+
+class FakeControlError:
+    def get_canal_count(self):
+        return 1
+
+    def run_nc_code_list(self, node_list, canal):
+        # raise a generic error
+        raise RuntimeError("control failed")
+
+
+class TestNCExecutionEngine(unittest.TestCase):
+    def test_happy_path_returns_plot_structure(self):
+        ctrl = FakeControlHappy()
+        engine = NCExecutionEngine(ctrl)
+        programs = ["G1 X1 Y1 Z1;G1 X2 Y2 Z2"]
+        result = engine.get_Syncro_plot(programs, synch=False)
+        # one canal
+        self.assertIsInstance(result, list)
+        self.assertEqual(len(result), 1)
+        canal = result[0]
+        self.assertIn("plot", canal)
+        self.assertEqual(canal["canalNr"], "C0")
+        plot = canal["plot"]
+        self.assertEqual(len(plot), 2)
+        self.assertEqual(plot[0]["x"], [1])
+        self.assertEqual(plot[0]["y"], [1])
+        self.assertEqual(plot[0]["z"], [1])
+        self.assertEqual(plot[0]["t"], 0.5)
+        self.assertEqual(plot[1]["x"], [2])
+        self.assertEqual(canal["programExec"], [0, 1])
+
+    def test_control_error_returns_empty_lists(self):
+        ctrl = FakeControlError()
+        engine = NCExecutionEngine(ctrl)
+        programs = ["G1 X1 Y1 Z1"]
+        result = engine.get_Syncro_plot(programs, synch=False)
+        self.assertEqual(result, [[], []])
+
+
+if __name__ == "__main__":
+    unittest.main()
diff --git a/tests/unit/test_registry.py b/tests/unit/test_registry.py
index b42a4b7..a31aba9 100644
--- a/tests/unit/test_registry.py
+++ b/tests/unit/test_registry.py
@@ -1,28 +1,28 @@
-
-from ncplot7py.shared.registry import registry
-from ncplot7py.cli.main import bootstrap
-from ncplot7py.infrastructure.parsers.nc_command_parser import NCCommandStringParser
-
-
-def test_register_and_get_parser():
-    # Bootstrap registers builtin adapters and is safe to call multiple times
-    bootstrap(registry)
-    cls = registry.get("parser", "nc_command")
-    assert cls is NCCommandStringParser
-
-    # Instantiate and run parse on a simple G-code line
-    parser = cls()
-    node = parser.parse("G1 X10 Y5", line_nr=7)
-    assert "G1" in node.g_code
-    assert node.command_parameter.get("X") == "10"
-    assert node.command_parameter.get("Y") == "5"
-
-
-def test_register_custom_class():
-    # Ensure registry can store arbitrary classes and retrieve them
-    class Dummy:
-        pass
-
-    registry.register("test-kind", "dummy", Dummy)
-    got = registry.get("test-kind", "dummy")
-    assert got is Dummy
+
+from ncplot7py.shared.registry import registry
+from ncplot7py.cli.main import bootstrap
+from ncplot7py.infrastructure.parsers.nc_command_parser import NCCommandStringParser
+
+
+def test_register_and_get_parser():
+    # Bootstrap registers builtin adapters and is safe to call multiple times
+    bootstrap(registry)
+    cls = registry.get("parser", "nc_command")
+    assert cls is NCCommandStringParser
+
+    # Instantiate and run parse on a simple G-code line
+    parser = cls()
+    node = parser.parse("G1 X10 Y5", line_nr=7)
+    assert "G1" in node.g_code
+    assert node.command_parameter.get("X") == "10"
+    assert node.command_parameter.get("Y") == "5"
+
+
+def test_register_custom_class():
+    # Ensure registry can store arbitrary classes and retrieve them
+    class Dummy:
+        pass
+
+    registry.register("test-kind", "dummy", Dummy)
+    got = registry.get("test-kind", "dummy")
+    assert got is Dummy
diff --git a/tests/unit/test_star_canal_syncro.py b/tests/unit/test_star_canal_syncro.py
index 3051735..e99f14d 100644
--- a/tests/unit/test_star_canal_syncro.py
+++ b/tests/unit/test_star_canal_syncro.py
@@ -1,87 +1,87 @@
-import unittest
-
-from ncplot7py.infrastructure.machines.star_canal_syncro import CanalSynchro
-from ncplot7py.shared.nc_nodes import NCCommandNode
-
-
-class TestStarCanalSynchro(unittest.TestCase):
-    def test_two_canals_basic(self):
-        # canal 0: durations [0.5, 1.0, 0.2]
-        # canal 1: durations [0.6, 0.8, 0.3]
-        tool_paths = [
-            [([], 0.5), ([], 1.0), ([], 0.2)],
-            [([], 0.6), ([], 0.8), ([], 0.3)],
-        ]
-
-        # nodes: wait at index 1 for both canals (M=300)
-        nodes0 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "300"}), NCCommandNode(None, {})]
-        nodes1 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "300"}), NCCommandNode(None, {})]
-
-        syn = CanalSynchro(tool_paths, [nodes0, nodes1])
-        syn.synchro_points()
-
-        # expected: canal1 index1 duration becomes time_delta_1 - time_delta_2 = 1.5 - 1.4 = 0.1
-        self.assertAlmostEqual(tool_paths[1][1][1], 0.1, places=6)
-
-    def test_three_canals_three_way(self):
-        # durations chosen so canal2 is the slowest up to the wait point
-        tool_paths = [
-            [([], 0.2), ([], 0.7), ([], 0.3)],
-            [([], 0.3), ([], 0.4), ([], 0.2)],
-            [([], 0.1), ([], 1.5), ([], 0.1)],
-        ]
-
-        # nodes: wait at index 1 for all canals with same M (500)
-        nodes0 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "500"}), NCCommandNode(None, {})]
-        nodes1 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "500"}), NCCommandNode(None, {})]
-        nodes2 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "500"}), NCCommandNode(None, {})]
-
-        syn = CanalSynchro(tool_paths, [nodes0, nodes1, nodes2])
-        syn.synchro_points()
-
-        # After sync, canal2 is the slowest (time_delta_3 = 1.6), so
-        # canal0[1] should be 1.6 - 0.9 = 0.7
-        # canal1[1] should be 1.6 - 0.7 = 0.9
-        self.assertAlmostEqual(tool_paths[0][1][1], 0.7, places=6)
-        self.assertAlmostEqual(tool_paths[1][1][1], 0.9, places=6)
-
-    def test_three_canals_with_P_pairwise_sync(self):
-        # Test that M codes with a 'P' parameter (grouping index) lead to
-        # pairwise synchronization when the code and P indicate a pair.
-        tool_paths = [
-            [([], 0.2), ([], 0.7), ([], 0.3)],
-            [([], 0.3), ([], 1.0), ([], 0.2)],
-            [([], 0.1), ([], 0.4), ([], 0.1)],
-        ]
-
-        # canal0: wait without P
-        nodes0 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "500"}), NCCommandNode(None, {})]
-        # canal1: same M but with P=12 -> should pairwise-sync with canal0 when
-        # pairwise condition is met (wait_c_2[1] == 12)
-        nodes1 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "500", "P": "12"}), NCCommandNode(None, {})]
-        # canal2: no wait
-        nodes2 = [NCCommandNode(None, {}), NCCommandNode(None, {}), NCCommandNode(None, {})]
-
-        # keep a copy of original durations to assert that an adjustment occurred
-        orig = [[t[1] for t in tp] for tp in tool_paths]
-
-        syn = CanalSynchro(tool_paths, [nodes0, nodes1, nodes2])
-        syn.synchro_points()
-
-        # At least one of the wait durations in canal0/canal1 should have changed
-        after = [[t[1] for t in tp] for tp in tool_paths]
-        changed = False
-        for i in range(len(orig)):
-            for j in range(len(orig[i])):
-                if abs(orig[i][j] - after[i][j]) > 1e-9:
-                    changed = True
-                    break
-            if changed:
-                break
-
-        self.assertTrue(changed, "Expected at least one duration to be adjusted for P-based pairwise sync")
-
-
-if __name__ == "__main__":
-    unittest.main()
-
+import unittest
+
+from ncplot7py.infrastructure.machines.star_canal_syncro import CanalSynchro
+from ncplot7py.shared.nc_nodes import NCCommandNode
+
+
+class TestStarCanalSynchro(unittest.TestCase):
+    def test_two_canals_basic(self):
+        # canal 0: durations [0.5, 1.0, 0.2]
+        # canal 1: durations [0.6, 0.8, 0.3]
+        tool_paths = [
+            [([], 0.5), ([], 1.0), ([], 0.2)],
+            [([], 0.6), ([], 0.8), ([], 0.3)],
+        ]
+
+        # nodes: wait at index 1 for both canals (M=300)
+        nodes0 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "300"}), NCCommandNode(None, {})]
+        nodes1 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "300"}), NCCommandNode(None, {})]
+
+        syn = CanalSynchro(tool_paths, [nodes0, nodes1])
+        syn.synchro_points()
+
+        # expected: canal1 index1 duration becomes time_delta_1 - time_delta_2 = 1.5 - 1.4 = 0.1
+        self.assertAlmostEqual(tool_paths[1][1][1], 0.1, places=6)
+
+    def test_three_canals_three_way(self):
+        # durations chosen so canal2 is the slowest up to the wait point
+        tool_paths = [
+            [([], 0.2), ([], 0.7), ([], 0.3)],
+            [([], 0.3), ([], 0.4), ([], 0.2)],
+            [([], 0.1), ([], 1.5), ([], 0.1)],
+        ]
+
+        # nodes: wait at index 1 for all canals with same M (500)
+        nodes0 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "500"}), NCCommandNode(None, {})]
+        nodes1 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "500"}), NCCommandNode(None, {})]
+        nodes2 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "500"}), NCCommandNode(None, {})]
+
+        syn = CanalSynchro(tool_paths, [nodes0, nodes1, nodes2])
+        syn.synchro_points()
+
+        # After sync, canal2 is the slowest (time_delta_3 = 1.6), so
+        # canal0[1] should be 1.6 - 0.9 = 0.7
+        # canal1[1] should be 1.6 - 0.7 = 0.9
+        self.assertAlmostEqual(tool_paths[0][1][1], 0.7, places=6)
+        self.assertAlmostEqual(tool_paths[1][1][1], 0.9, places=6)
+
+    def test_three_canals_with_P_pairwise_sync(self):
+        # Test that M codes with a 'P' parameter (grouping index) lead to
+        # pairwise synchronization when the code and P indicate a pair.
+        tool_paths = [
+            [([], 0.2), ([], 0.7), ([], 0.3)],
+            [([], 0.3), ([], 1.0), ([], 0.2)],
+            [([], 0.1), ([], 0.4), ([], 0.1)],
+        ]
+
+        # canal0: wait without P
+        nodes0 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "500"}), NCCommandNode(None, {})]
+        # canal1: same M but with P=12 -> should pairwise-sync with canal0 when
+        # pairwise condition is met (wait_c_2[1] == 12)
+        nodes1 = [NCCommandNode(None, {}), NCCommandNode(None, {"M": "500", "P": "12"}), NCCommandNode(None, {})]
+        # canal2: no wait
+        nodes2 = [NCCommandNode(None, {}), NCCommandNode(None, {}), NCCommandNode(None, {})]
+
+        # keep a copy of original durations to assert that an adjustment occurred
+        orig = [[t[1] for t in tp] for tp in tool_paths]
+
+        syn = CanalSynchro(tool_paths, [nodes0, nodes1, nodes2])
+        syn.synchro_points()
+
+        # At least one of the wait durations in canal0/canal1 should have changed
+        after = [[t[1] for t in tp] for tp in tool_paths]
+        changed = False
+        for i in range(len(orig)):
+            for j in range(len(orig[i])):
+                if abs(orig[i][j] - after[i][j]) > 1e-9:
+                    changed = True
+                    break
+            if changed:
+                break
+
+        self.assertTrue(changed, "Expected at least one duration to be adjusted for P-based pairwise sync")
+
+
+if __name__ == "__main__":
+    unittest.main()
+
diff --git a/tests/unit/test_star_turn_handler.py b/tests/unit/test_star_turn_handler.py
index 6cc6e21..2008b8d 100644
--- a/tests/unit/test_star_turn_handler.py
+++ b/tests/unit/test_star_turn_handler.py
@@ -1,79 +1,79 @@
-import unittest
-
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.shared.nc_nodes import NCCommandNode
-from ncplot7py.domain.handlers.star_machine.star_turn_handler import StarTurnHandler
-
-
-class TestStarTurnHandler(unittest.TestCase):
-    def test_g125_removes_z_parameter(self):
-        handler = StarTurnHandler()
-        state = CNCState()
-
-        node = NCCommandNode(g_code_command={"G125"}, command_parameter={"Z": "10.0", "X": "5.0"})
-
-        pts, dur = handler.handle(node, state)
-
-        # handler should have removed Z but left X intact
-        self.assertNotIn("Z", node.command_parameter)
-        self.assertIn("X", node.command_parameter)
-        self.assertIsNone(pts)
-        self.assertIsNone(dur)
-
-    def test_g266_maps_parameters_to_state_variables_and_pops(self):
-        handler = StarTurnHandler()
-        state = CNCState()
-
-        params = {
-            "A": "1.5",
-            "W": "2.0",
-            "S": "300",
-            "F": "120.0",
-            "B": "2.0",
-            "X": "15.0",
-            "Z": "15.0",
-            "T": "100",
-        }
-        node = NCCommandNode(g_code_command={"G266"}, command_parameter=dict(params))
-
-        pts, dur = handler.handle(node, state)
-
-        # parameters should be removed from the node
-        for k in params.keys():
-            self.assertNotIn(k, node.command_parameter)
-
-        # state.parameters should contain mapped numeric entries as floats
-        expected = {
-            "531": 1.5,  # A
-            "530": 2.0,  # W
-            "529": 300.0,  # S
-            "522": 120.0,  # F
-            "528": 2.0,  # B
-            "524": 15.0,  # X
-            "525": 15.0,  # Z
-            "523": 100.0,  # T
-        }
-        for k, v in expected.items():
-            self.assertIn(k, state.parameters)
-            self.assertAlmostEqual(float(state.parameters[k]), float(v))
-
-        self.assertIsNone(pts)
-        self.assertIsNone(dur)
-
-    def test_g300_is_noop(self):
-        handler = StarTurnHandler()
-        state = CNCState()
-
-        node = NCCommandNode(g_code_command={"G300"}, command_parameter={"Z": "5.0"})
-
-        pts, dur = handler.handle(node, state)
-
-        # G300 should be a no-op: Z remains
-        self.assertIn("Z", node.command_parameter)
-        self.assertEqual(node.command_parameter["Z"], "5.0")
-        self.assertIsNone(pts)
-        self.assertIsNone(dur)
-
-
-if __name__ == '__main__':
-    unittest.main()
+import unittest
+
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.shared.nc_nodes import NCCommandNode
+from ncplot7py.domain.handlers.star_machine.star_turn_handler import StarTurnHandler
+
+
+class TestStarTurnHandler(unittest.TestCase):
+    def test_g125_removes_z_parameter(self):
+        handler = StarTurnHandler()
+        state = CNCState()
+
+        node = NCCommandNode(g_code_command={"G125"}, command_parameter={"Z": "10.0", "X": "5.0"})
+
+        pts, dur = handler.handle(node, state)
+
+        # handler should have removed Z but left X intact
+        self.assertNotIn("Z", node.command_parameter)
+        self.assertIn("X", node.command_parameter)
+        self.assertIsNone(pts)
+        self.assertIsNone(dur)
+
+    def test_g266_maps_parameters_to_state_variables_and_pops(self):
+        handler = StarTurnHandler()
+        state = CNCState()
+
+        params = {
+            "A": "1.5",
+            "W": "2.0",
+            "S": "300",
+            "F": "120.0",
+            "B": "2.0",
+            "X": "15.0",
+            "Z": "15.0",
+            "T": "100",
+        }
+        node = NCCommandNode(g_code_command={"G266"}, command_parameter=dict(params))
+
+        pts, dur = handler.handle(node, state)
+
+        # parameters should be removed from the node
+        for k in params.keys():
+            self.assertNotIn(k, node.command_parameter)
+
+        # state.parameters should contain mapped numeric entries as floats
+        expected = {
+            "531": 1.5,  # A
+            "530": 2.0,  # W
+            "529": 300.0,  # S
+            "522": 120.0,  # F
+            "528": 2.0,  # B
+            "524": 15.0,  # X
+            "525": 15.0,  # Z
+            "523": 100.0,  # T
+        }
+        for k, v in expected.items():
+            self.assertIn(k, state.parameters)
+            self.assertAlmostEqual(float(state.parameters[k]), float(v))
+
+        self.assertIsNone(pts)
+        self.assertIsNone(dur)
+
+    def test_g300_is_noop(self):
+        handler = StarTurnHandler()
+        state = CNCState()
+
+        node = NCCommandNode(g_code_command={"G300"}, command_parameter={"Z": "5.0"})
+
+        pts, dur = handler.handle(node, state)
+
+        # G300 should be a no-op: Z remains
+        self.assertIn("Z", node.command_parameter)
+        self.assertEqual(node.command_parameter["Z"], "5.0")
+        self.assertIsNone(pts)
+        self.assertIsNone(dur)
+
+
+if __name__ == '__main__':
+    unittest.main()
diff --git a/tests/unit/test_variable_nested.py b/tests/unit/test_variable_nested.py
index 8611e01..5051644 100644
--- a/tests/unit/test_variable_nested.py
+++ b/tests/unit/test_variable_nested.py
@@ -1,37 +1,37 @@
-import unittest
-
-from ncplot7py.domain.cnc_state import CNCState
-from ncplot7py.shared.nc_nodes import NCCommandNode
-
-
-class TestVariableNestedExpressions(unittest.TestCase):
-    def test_nested_bracket_expression_in_parameter(self):
-        from ncplot7py.domain.handlers.variable import VariableHandler
-
-        state = CNCState()
-        vh = VariableHandler()
-
-        # parameter with nested bracket expression
-        node = NCCommandNode(g_code_command=set(), command_parameter={"Y": "[2*[-1.73]]"}, nc_code_line_nr=1)
-        vh.handle(node, state)
-
-        self.assertIn("Y", node.command_parameter)
-        # numeric value should be replaced and parseable as float
-        val = float(node.command_parameter["Y"])
-        self.assertAlmostEqual(val, -3.46, places=6)
-
-    def test_nested_bracket_expression_in_variable_assignment(self):
-        from ncplot7py.domain.handlers.variable import VariableHandler
-
-        state = CNCState()
-        vh = VariableHandler()
-
-        node_var = NCCommandNode(g_code_command=set(), command_parameter={}, variable_command="#100=[2*[-1.73]]", nc_code_line_nr=2)
-        vh.handle(node_var, state)
-
-        self.assertIn("100", state.parameters)
-        self.assertAlmostEqual(float(state.parameters["100"]), -3.46, places=6)
-
-
-if __name__ == "__main__":
-    unittest.main()
+import unittest
+
+from ncplot7py.domain.cnc_state import CNCState
+from ncplot7py.shared.nc_nodes import NCCommandNode
+
+
+class TestVariableNestedExpressions(unittest.TestCase):
+    def test_nested_bracket_expression_in_parameter(self):
+        from ncplot7py.domain.handlers.variable import VariableHandler
+
+        state = CNCState()
+        vh = VariableHandler()
+
+        # parameter with nested bracket expression
+        node = NCCommandNode(g_code_command=set(), command_parameter={"Y": "[2*[-1.73]]"}, nc_code_line_nr=1)
+        vh.handle(node, state)
+
+        self.assertIn("Y", node.command_parameter)
+        # numeric value should be replaced and parseable as float
+        val = float(node.command_parameter["Y"])
+        self.assertAlmostEqual(val, -3.46, places=6)
+
+    def test_nested_bracket_expression_in_variable_assignment(self):
+        from ncplot7py.domain.handlers.variable import VariableHandler
+
+        state = CNCState()
+        vh = VariableHandler()
+
+        node_var = NCCommandNode(g_code_command=set(), command_parameter={}, variable_command="#100=[2*[-1.73]]", nc_code_line_nr=2)
+        vh.handle(node_var, state)
+
+        self.assertIn("100", state.parameters)
+        self.assertAlmostEqual(float(state.parameters["100"]), -3.46, places=6)
+
+
+if __name__ == "__main__":
+    unittest.main()