fiberpath 0.7.3__tar.gz → 0.7.4__tar.gz

{fiberpath-0.7.3 → fiberpath-0.7.4}/.github/workflows/gui-ci.yml

@@ -89,3 +89,6 @@ jobs:
 
       - name: Run Clippy (Rust linter)
         run: npm run clippy
+
+      - name: Run Rust tests
+        run: npm run test:rust

{fiberpath-0.7.3 → fiberpath-0.7.4}/.github/workflows/release.yml

@@ -135,16 +135,19 @@ jobs:
 
             let notes = '';
 
-            // Desktop installers section
+            // Desktop installers section. Asset names match Tauri's bundle
+            // output: the productName "FiberPath GUI" yields a space that
+            // GitHub renders as `.` in the release asset filename, and the
+            // macOS dmg is built for Apple Silicon (aarch64) on macos-latest.
             notes += `## Desktop Installers\n\n`;
             notes += `**Windows:**\n`;
-            notes += `- \`FiberPath_${version}_x64_en-US.msi\` (recommended)\n`;
-            notes += `- \`FiberPath_${version}_x64-setup.exe\`\n\n`;
-            notes += `**macOS:**\n`;
-            notes += `- \`FiberPath_${version}_universal.dmg\`\n\n`;
+            notes += `- \`FiberPath.GUI_${version}_x64_en-US.msi\` (recommended)\n`;
+            notes += `- \`FiberPath.GUI_${version}_x64-setup.exe\`\n\n`;
+            notes += `**macOS (Apple Silicon):**\n`;
+            notes += `- \`FiberPath.GUI_${version}_aarch64.dmg\`\n\n`;
             notes += `**Linux:**\n`;
-            notes += `- \`fiberpath_${version}_amd64.deb\`\n`;
-            notes += `- \`fiberpath_${version}_amd64.AppImage\`\n\n`;
+            notes += `- \`FiberPath.GUI_${version}_amd64.deb\`\n`;
+            notes += `- \`FiberPath.GUI_${version}_amd64.AppImage\`\n\n`;
             notes += `📚 [Installation Guide](https://fiberpath.org/fiberpath/getting-started/) | `;
             notes += `🆘 [Troubleshooting](https://fiberpath.org/fiberpath/troubleshooting/)\n\n`;
 
@@ -165,11 +168,11 @@ jobs:
         run: |
           VERSION="${{ inputs.version }}"
           echo "Expected release assets for v$VERSION:"
-          echo "  - FiberPath_${VERSION}_x64_en-US.msi"
-          echo "  - FiberPath_${VERSION}_x64-setup.exe"
-          echo "  - FiberPath_${VERSION}_universal.dmg"
-          echo "  - fiberpath_${VERSION}_amd64.deb"
-          echo "  - fiberpath_${VERSION}_amd64.AppImage"
+          echo "  - FiberPath.GUI_${VERSION}_x64_en-US.msi"
+          echo "  - FiberPath.GUI_${VERSION}_x64-setup.exe"
+          echo "  - FiberPath.GUI_${VERSION}_aarch64.dmg"
+          echo "  - FiberPath.GUI_${VERSION}_amd64.deb"
+          echo "  - FiberPath.GUI_${VERSION}_amd64.AppImage"
           echo "Assets will be uploaded by build-gui-installers workflow"
 
       - name: Create GitHub Release

{fiberpath-0.7.3 → fiberpath-0.7.4}/CHANGELOG.md

@@ -8,6 +8,23 @@ The format is based on Keep a Changelog, and this project follows semantic versi
 
 ## [Unreleased]
 
+## [0.7.4] - 2026-06-25
+
+### Fixed
+
+- Marlin desktop commands no longer hang forever if the underlying CLI subprocess dies or emits a non-JSON line: when the response reader stops, in-flight requests are failed (the command returns an error) instead of leaving the UI spinner stuck permanently.
+- Desktop preview/validate temp files now use process- and counter-unique names, fixing rare collisions when commands fired in the same millisecond could delete or clobber each other's temp file (intermittent "file not found" / corrupted preview).
+- The Marlin desktop integration now recovers if its helper subprocess dies: a dead process is detected and respawned on the next command instead of reusing it forever, and the subprocess is killed on app shutdown so it no longer lingers as an orphan holding the serial port open.
+- Helical layer editor and save-gate validation now match the planner's bounds, so the editor no longer accepts values the backend rejects with a 422: `lockDegrees`, `leadInMM`, and `leadOutDegrees` must be positive (were allowed to be `0`), `skipIndex` must be a positive integer (the save gate allowed `0`), and the wind angle is constrained to `[1°, 89°]` (was `(0°, 90°)`; the engine clamps to `[1, 89]` because `90°` gives `cos = 0`).
+- Helical layer geometry hint no longer renders "not divisible by pattern number (NaN)" while the Pattern Number field is mid-edit (emptied to `NaN`); no hint is shown until the field holds a valid positive integer.
+- The streaming API (`POST /stream/`) now returns 400 for empty/whitespace-only G-code instead of 502; an empty program is a client error, not an upstream device failure (502 is reserved for genuine transport errors).
+- Simulating a G-code path that is a directory or non-UTF-8/binary file now returns a 4xx (API `/simulate/from-file`) or a clean usage error (CLI `simulate`/`plot`/`stream` reject directories) instead of an HTTP 500 / raw `IsADirectoryError`/`UnicodeDecodeError` traceback.
+- Loading a wind definition that is a directory, an unreadable file, or non-UTF-8/binary content now reports a clean error instead of crashing. Previously these raised an unmapped `IsADirectoryError`/`UnicodeDecodeError`, surfacing as an HTTP 500 from the API (`/plan/from-file`, `/validate/from-file`) or a raw traceback from the CLI; they are now mapped to the standard `WindFileError` (4xx / clean CLI message).
+- `fiberpath plan --output <dir>/<file>.gcode` into a directory that does not exist now creates the parent directories instead of crashing with a `FileNotFoundError` traceback (matching the existing `plot` behavior). `write_gcode` creates the destination's parent directory.
+- A helical layer whose `leadInMM` is greater than or equal to the mandrel `windLength` is now rejected during planning. Previously it passed validation and generated G-code that drove the carriage off the end of the mandrel into negative coordinates (inverting the main-pass rotation), risking an end-stop collision.
+- Non-finite numeric inputs (`NaN`, `Infinity`) in a `.wind` file are now rejected at load instead of being silently accepted. Previously a `NaN` value could be emitted into generated G-code as a literal `Anan` axis word, and an `Infinity` geometry value crashed the planner with an uncaught `OverflowError` (HTTP 500 / CLI traceback).
+- Helical layer editor no longer crashes the app ("Maximum call stack size exceeded") when the Pattern Number or Skip Index field is emptied. The emptied field became `NaN`, and the cross-field coprime check recursed forever in `gcd()`; the check now skips non-integer values and the field reports its own validation error instead.
+
 ## [0.7.3] - 2026-06-25
 
 ### Changed

{fiberpath-0.7.3 → fiberpath-0.7.4}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: fiberpath
-Version: 0.7.3
+Version: 0.7.4
 Summary: Modern filament winding planner, simulator, and G-code toolkit.
 Author: Cameron K. Brooks
 License:                     GNU AFFERO GENERAL PUBLIC LICENSE
@@ -705,7 +705,7 @@ Description-Content-Type: text/markdown
 
 **Plan, simulate, and manufacture composite parts with precision fiber winding.**
 
-[![Version](https://img.shields.io/badge/version-0.7.3-4c7284)](https://github.com/fiberpath/fiberpath/releases)
+[![Version](https://img.shields.io/badge/version-0.7.4-4c7284)](https://github.com/fiberpath/fiberpath/releases)
 [![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-00695C.svg)](LICENSE)
 [![Backend CI](https://img.shields.io/github/actions/workflow/status/fiberpath/fiberpath/backend-ci.yml?branch=main&label=Backend%20CI&logo=python&logoColor=white)](https://github.com/fiberpath/fiberpath/actions/workflows/backend-ci.yml)
 [![GUI CI](https://img.shields.io/github/actions/workflow/status/fiberpath/fiberpath/gui-ci.yml?branch=main&label=GUI%20CI&logo=react&logoColor=white)](https://github.com/fiberpath/fiberpath/actions/workflows/gui-ci.yml)

{fiberpath-0.7.3 → fiberpath-0.7.4}/README.md

@@ -4,7 +4,7 @@
 
 **Plan, simulate, and manufacture composite parts with precision fiber winding.**
 
-[![Version](https://img.shields.io/badge/version-0.7.3-4c7284)](https://github.com/fiberpath/fiberpath/releases)
+[![Version](https://img.shields.io/badge/version-0.7.4-4c7284)](https://github.com/fiberpath/fiberpath/releases)
 [![License: AGPL-3.0](https://img.shields.io/badge/License-AGPL--3.0-00695C.svg)](LICENSE)
 [![Backend CI](https://img.shields.io/github/actions/workflow/status/fiberpath/fiberpath/backend-ci.yml?branch=main&label=Backend%20CI&logo=python&logoColor=white)](https://github.com/fiberpath/fiberpath/actions/workflows/backend-ci.yml)
 [![GUI CI](https://img.shields.io/github/actions/workflow/status/fiberpath/fiberpath/gui-ci.yml?branch=main&label=GUI%20CI&logo=react&logoColor=white)](https://github.com/fiberpath/fiberpath/actions/workflows/gui-ci.yml)

{fiberpath-0.7.3 → fiberpath-0.7.4}/docs/index.md

@@ -36,7 +36,7 @@ hide:
 
     ---
 
-    **Latest Release:** [v0.7.3](https://github.com/fiberpath/fiberpath/releases/latest){ target=_blank }
+    **Latest Release:** [v0.7.4](https://github.com/fiberpath/fiberpath/releases/latest){ target=_blank }
 
     - **Desktop GUI** – Windows, macOS, Linux installers (no Python required)
     - **Python Package** – `pip install fiberpath`
@@ -44,16 +44,16 @@ hide:
 
     [:octicons-arrow-right-24: Installation Guide](getting-started.md)
 
--   :material-new-box:{ .lg .middle } **What's New in v0.7.3**
+-   :material-new-box:{ .lg .middle } **What's New in v0.7.4**
 
     ---
 
-    Project moved to the [`fiberpath` GitHub organization](https://github.com/fiberpath):
+    Bug-fix release hardening input validation and the desktop integration:
 
-    - Repository, issue tracker, and PyPI trusted publisher now live under `fiberpath/fiberpath` (`pip install fiberpath` is unchanged)
-    - Documentation moved to [fiberpath.org](https://fiberpath.org), built from the `fiberpath.github.io` hub; this repo is now docs-content-only
-    - Dependency automation switched from Dependabot to org-shared Renovate
-    - `CI Check` now runs on every PR so the required status never stalls
+    - Reject non-finite (`NaN`/`Infinity`) inputs and a lead-in longer than the mandrel (which produced unsafe negative-coordinate G-code)
+    - Cleaner errors (4xx, not 500/tracebacks) for directory/binary file inputs across the API and CLI
+    - Marlin desktop commands no longer hang if the helper process dies, and recover by respawning
+    - Helical editor validation now matches the planner's bounds; fixed a crash and a "(NaN)" hint while editing
 
     Builds on the v0.7 baseline; no runtime API changes.
 

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath/config/schemas.py

@@ -11,7 +11,15 @@ from pydantic import BaseModel, ConfigDict, Field, PositiveFloat, PositiveInt
 class BaseFiberPathModel(BaseModel):
     """Base class that applies shared Pydantic configuration."""
 
-    model_config = ConfigDict(populate_by_name=True, str_strip_whitespace=True)
+    # allow_inf_nan=False rejects NaN/Infinity on every float field. JSON
+    # permits the NaN/Infinity literals, and unguarded non-finite values
+    # otherwise propagate into the generated G-code (a literal "Anan" axis word)
+    # or overflow math.ceil in the planner (uncaught OverflowError).
+    model_config = ConfigDict(
+        populate_by_name=True,
+        str_strip_whitespace=True,
+        allow_inf_nan=False,
+    )
 
 
 class MandrelParameters(BaseFiberPathModel):

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath/config/validator.py

@@ -21,8 +21,15 @@ def load_wind_definition(path: str | Path) -> WindDefinition:
     if not location.exists():
         raise WindFileError(f"No wind definition found at {location}")
     try:
-        payload = json.loads(location.read_text(encoding="utf-8"))
-    except json.JSONDecodeError as exc:  # pragma: no cover - extremely rare
+        raw = location.read_text(encoding="utf-8")
+    except (OSError, UnicodeDecodeError) as exc:
+        # Directory, unreadable file, or non-UTF-8/binary content. Surface as a
+        # WindFileError so callers map it to a 4xx / clean CLI error instead of
+        # leaking a raw IsADirectoryError / UnicodeDecodeError (HTTP 500).
+        raise WindFileError(f"Could not read wind definition at {location}: {exc}") from exc
+    try:
+        payload = json.loads(raw)
+    except json.JSONDecodeError as exc:
         raise WindFileError(f"Invalid JSON in {location}: {exc}") from exc
 
     try:

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath/gcode/generator.py

@@ -22,5 +22,6 @@ def sanitize_program(commands: Iterable[str]) -> list[str]:
 def write_gcode(program: GCodeProgram | Sequence[str], destination: str | Path) -> Path:
     target = Path(destination)
     lines = program.commands if isinstance(program, GCodeProgram) else list(program)
+    target.parent.mkdir(parents=True, exist_ok=True)
     target.write_text("\n".join(lines) + "\n", encoding="utf-8")
     return target

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath/planning/validators.py

@@ -77,6 +77,16 @@ def validate_helical_layer(
             "skipIndex and patternNumber must be coprime for full coverage",
         )
 
+    if layer.lead_in_mm >= mandrel.wind_length:
+        raise LayerValidationError(
+            layer_index,
+            (
+                f"leadInMM ({layer.lead_in_mm}mm) must be less than the mandrel "
+                f"windLength ({mandrel.wind_length}mm); a longer lead-in drives the "
+                "carriage off the mandrel into negative coordinates"
+            ),
+        )
+
     kinematics = compute_helical_kinematics(layer, mandrel, tow)
     if kinematics.num_circuits % layer.pattern_number != 0:
         raise LayerValidationError(

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_api/routes/simulate.py

@@ -16,7 +16,14 @@ def simulate_from_file(payload: FilePathRequest) -> SimulationResponse:
     target = enforce_input_path_policy(payload.path)
     if not target.exists():
         raise HTTPException(status_code=404, detail=f"No file found at {payload.path}")
-    commands = target.read_text(encoding="utf-8").splitlines()
+    if not target.is_file():
+        raise HTTPException(status_code=400, detail=f"Not a file: {payload.path}")
+    try:
+        commands = target.read_text(encoding="utf-8").splitlines()
+    except (OSError, UnicodeDecodeError) as exc:
+        raise HTTPException(
+            status_code=400, detail=f"Could not read {payload.path}: {exc}"
+        ) from exc
     result = simulate_program(commands)
     return SimulationResponse(
         commands=result.commands_executed,

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_api/routes/stream.py

@@ -35,6 +35,12 @@ def start_stream(payload: StreamRequest) -> StreamResponse:
         raise HTTPException(status_code=400, detail="port is required when dry_run is false")
 
     commands = payload.gcode.splitlines()
+    if not any(line.strip() for line in commands):
+        # Empty/whitespace-only input is a client error, not an upstream device
+        # failure — return 400 rather than letting the streamer raise a
+        # StreamError that maps to 502.
+        raise HTTPException(status_code=400, detail="gcode contained no commands")
+
     streamer = MarlinStreamer(port=payload.port, baud_rate=payload.baud_rate)
 
     try:

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_cli/plot.py

@@ -10,7 +10,9 @@ from rich.console import Console
 
 console = Console()
 
-GCODE_ARGUMENT = typer.Argument(..., exists=True, readable=True, help="Input G-code file")
+GCODE_ARGUMENT = typer.Argument(
+    ..., exists=True, readable=True, file_okay=True, dir_okay=False, help="Input G-code file"
+)
 OUTPUT_OPTION = typer.Option(Path("plot.png"), "--output", "-o", help="PNG destination")
 SCALE_OPTION = typer.Option(
     1.0, "--scale", help="Pixels per millimeter along carriage axis", min=0.1, max=5.0

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_cli/simulate.py

@@ -10,7 +10,7 @@ from fiberpath.simulation import SimulationError, simulate_program
 
 from .output import echo_json
 
-GCODE_ARGUMENT = typer.Argument(..., exists=True, readable=True)
+GCODE_ARGUMENT = typer.Argument(..., exists=True, readable=True, file_okay=True, dir_okay=False)
 JSON_OPTION = typer.Option(False, "--json", help="Emit machine-readable JSON summary")
 
 

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_cli/stream.py

@@ -9,7 +9,7 @@ from fiberpath.execution import MarlinStreamer, StreamError, StreamProgress
 
 from .output import echo_json
 
-GCODE_ARGUMENT = typer.Argument(..., exists=True, readable=True)
+GCODE_ARGUMENT = typer.Argument(..., exists=True, readable=True, file_okay=True, dir_okay=False)
 PROGRESS_INTERVAL = 25
 
 

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_gui/package-lock.json

@@ -1,12 +1,12 @@
 {
   "name": "fiberpath-gui",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "lockfileVersion": 3,
   "requires": true,
   "packages": {
     "": {
       "name": "fiberpath-gui",
-      "version": "0.7.3",
+      "version": "0.7.4",
       "dependencies": {
         "@hello-pangea/dnd": "^18.0.1",
         "@tauri-apps/api": "^2.11.1",

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_gui/package.json

@@ -1,6 +1,6 @@
 {
   "name": "fiberpath-gui",
-  "version": "0.7.3",
+  "version": "0.7.4",
   "private": true,
   "type": "module",
   "engines": {
@@ -19,6 +19,7 @@
     "format:check": "cd src-tauri && cargo fmt --check",
     "format:fix": "cd src-tauri && cargo fmt",
     "clippy": "cd src-tauri && cargo clippy -- -D warnings",
+    "test:rust": "cd src-tauri && cargo test",
     "check:all": "npm run lint && npm run lint:css && npm run lint:css:vars && npm run format:check && npm run clippy",
     "test": "vitest",
     "test:ui": "vitest --ui",

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_gui/src/lib/helicalValidation.test.ts

@@ -29,6 +29,14 @@ describe("helicalValidation", () => {
           validateHelicalField("wind_angle", 91, defaultHelical),
         ).toBeDefined();
       });
+
+      it("rejects 90 and sub-1 angles, accepts the [1, 89] bounds", () => {
+        // The planner enforces [1, 89] (90° -> cos = 0). The editor must match.
+        expect(validateHelicalField("wind_angle", 90, defaultHelical)).toBeDefined();
+        expect(validateHelicalField("wind_angle", 0.5, defaultHelical)).toBeDefined();
+        expect(validateHelicalField("wind_angle", 1, defaultHelical)).toBeUndefined();
+        expect(validateHelicalField("wind_angle", 89, defaultHelical)).toBeUndefined();
+      });
     });
 
     describe("pattern_number", () => {
@@ -75,11 +83,49 @@ describe("helicalValidation", () => {
       });
     });
 
+    // Regression: emptying a numeric input yields NaN. Re-validating the
+    // sibling field then ran the coprime check (gcd) against the NaN value,
+    // which recursed forever and crashed the app with
+    // "RangeError: Maximum call stack size exceeded".
+    describe("does not crash when a pattern/skip field is mid-edit", () => {
+      it("returns a range error (not a stack overflow) for a NaN skip index", () => {
+        expect(() =>
+          validateHelicalField("skip_index", NaN, defaultHelical),
+        ).not.toThrow();
+        expect(validateHelicalField("skip_index", NaN, defaultHelical)).toBeDefined();
+      });
+
+      it("does not crash validating pattern_number when skip_index is NaN", () => {
+        const layer: HelicalLayer = { ...defaultHelical, skip_index: NaN };
+        expect(() =>
+          validateHelicalField("pattern_number", 3, layer),
+        ).not.toThrow();
+        // pattern itself is valid; the coprime check is skipped while the
+        // sibling is invalid, so no spurious error is reported here.
+        expect(validateHelicalField("pattern_number", 3, layer)).toBeUndefined();
+      });
+
+      it("does not crash validating skip_index when pattern_number is NaN", () => {
+        const layer: HelicalLayer = { ...defaultHelical, pattern_number: NaN };
+        expect(() =>
+          validateHelicalField("skip_index", 2, layer),
+        ).not.toThrow();
+        expect(validateHelicalField("skip_index", 2, layer)).toBeUndefined();
+      });
+
+      it("does not crash on non-integer pattern/skip values", () => {
+        const layer: HelicalLayer = { ...defaultHelical, skip_index: 2.5 };
+        expect(() =>
+          validateHelicalField("pattern_number", 3, layer),
+        ).not.toThrow();
+      });
+    });
+
     describe("lock_degrees", () => {
-      it("accepts zero", () => {
+      it("rejects zero (planner requires a positive value)", () => {
         expect(
           validateHelicalField("lock_degrees", 0, defaultHelical),
-        ).toBeUndefined();
+        ).toBeDefined();
       });
 
       it("accepts positive value", () => {
@@ -96,9 +142,15 @@ describe("helicalValidation", () => {
     });
 
     describe("lead_out_degrees", () => {
-      it("accepts zero", () => {
+      it("rejects zero (planner requires a positive value)", () => {
         expect(
           validateHelicalField("lead_out_degrees", 0, defaultHelical),
+        ).toBeDefined();
+      });
+
+      it("accepts positive value", () => {
+        expect(
+          validateHelicalField("lead_out_degrees", 30, defaultHelical),
         ).toBeUndefined();
       });
 
@@ -110,9 +162,15 @@ describe("helicalValidation", () => {
     });
 
     describe("lead_in_mm", () => {
-      it("accepts zero", () => {
+      it("rejects zero (planner requires a positive value)", () => {
         expect(
           validateHelicalField("lead_in_mm", 0, defaultHelical),
+        ).toBeDefined();
+      });
+
+      it("accepts positive value", () => {
+        expect(
+          validateHelicalField("lead_in_mm", 10, defaultHelical),
         ).toBeUndefined();
       });
 
@@ -134,6 +192,14 @@ describe("helicalValidation", () => {
       expect(getHelicalGeometryHint(layer, 150, 12.7)).toMatch(/skip index/i);
     });
 
+    it("does not emit a '(NaN)' hint while pattern_number is mid-edit", () => {
+      // Emptying the Pattern Number input makes it NaN; circuitCount % NaN is
+      // NaN (!== 0), which previously rendered "not divisible by pattern
+      // number (NaN)". A non-integer pattern means the hint is undefined.
+      const layer: HelicalLayer = { ...defaultHelical, pattern_number: NaN };
+      expect(getHelicalGeometryHint(layer, 150, 50)).toBeUndefined();
+    });
+
     it("returns undefined when mandrel diameter is zero", () => {
       expect(
         getHelicalGeometryHint(defaultHelical, 0, 12.7),

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_gui/src/lib/helicalValidation.ts

@@ -16,6 +16,15 @@ const gcd = (a: number, b: number): number => {
 };
 
 const validateCoprime = (pattern: number, skip: number): string | undefined => {
+  // Coprimality is only defined for two positive integers. While a sibling
+  // field is mid-edit it can be NaN (an emptied input) or a non-integer; in
+  // that case skip the cross-field check — the offending field reports its own
+  // range error. This guard also prevents gcd() from infinite-recursing on
+  // NaN (Math.abs(NaN) is NaN, NaN === 0 is false, and NaN % NaN is NaN, so it
+  // never terminates), which previously crashed the app with a stack overflow.
+  if (!Number.isInteger(pattern) || !Number.isInteger(skip)) {
+    return undefined;
+  }
   if (gcd(pattern, skip) !== 1) {
     return "Pattern and skip must be coprime (GCD = 1)";
   }
@@ -79,12 +88,14 @@ export function validateHelicalField(
 
     case "lock_degrees":
     case "lead_out_degrees":
-      return value < 0
-        ? `${field.replace("_", " ")} must be non-negative`
+      // The planner requires these to be strictly positive (PositiveFloat);
+      // accepting 0 here only defers a 422 from the backend.
+      return value <= 0
+        ? `${field.replace("_", " ")} must be positive`
         : undefined;
 
     case "lead_in_mm":
-      return value < 0 ? "Lead-in must be non-negative" : undefined;
+      return value <= 0 ? "Lead-in must be positive" : undefined;
   }
 }
 
@@ -97,6 +108,13 @@ export function getHelicalGeometryHint(
     return "Skip index should be less than pattern number to avoid invalid routing.";
   }
 
+  // While the field is mid-edit pattern_number can be NaN/0/non-integer; the
+  // divisibility check below would compute `% NaN` and render a "(NaN)" hint.
+  // The field surfaces its own validation error, so emit no geometry hint here.
+  if (!Number.isInteger(helical.pattern_number) || helical.pattern_number <= 0) {
+    return undefined;
+  }
+
   const circuitCount = computeCircuitCount(helical, mandrelDiameter, towWidth);
   if (!circuitCount) {
     return undefined;

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_gui/src/lib/schemas.ts

@@ -105,12 +105,15 @@ export const WindHoopLayerSchema = z.object({
  */
 export const WindHelicalLayerSchema = z.object({
   windType: z.literal("helical"),
-  windAngle: z.number().min(0).max(90),
+  // Bounds match the planner contract (PositiveFloat/PositiveInt; wind angle
+  // is enforced to [1, 89]). Keeping these in sync avoids the save gate
+  // accepting values the engine later rejects with a 422.
+  windAngle: z.number().min(1).max(89),
   patternNumber: z.number().int().positive(),
-  skipIndex: z.number().int().nonnegative(),
-  lockDegrees: z.number().nonnegative(),
-  leadInMM: z.number().nonnegative(),
-  leadOutDegrees: z.number().nonnegative(),
+  skipIndex: z.number().int().positive(),
+  lockDegrees: z.number().positive(),
+  leadInMM: z.number().positive(),
+  leadOutDegrees: z.number().positive(),
   skipInitialNearLock: z.boolean().optional(),
 });
 

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_gui/src/types/components.ts

@@ -81,11 +81,12 @@ export interface NumericRange {
  * These constants ensure consistency in validation across components.
  */
 export const NUMERIC_RANGES = {
-  /** Wind angle: 0° to 90° (exclusive) */
+  /** Wind angle: 1° to 89° (inclusive), matching the planner's enforced bounds
+   * (90° gives cos = 0; the engine clamps to [1, 89]). */
   WIND_ANGLE: {
-    min: 0,
-    max: 90,
-    inclusive: { min: false, max: false },
+    min: 1,
+    max: 89,
+    inclusive: { min: true, max: true },
   } as NumericRange,
 
   /** Feed rate: 1 to 10000 mm/min */

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_gui/src-tauri/Cargo.lock

@@ -782,7 +782,7 @@ dependencies = [
 
 [[package]]
 name = "fiberpath_gui"
-version = "0.7.3"
+version = "0.7.4"
 dependencies = [
  "base64 0.22.1",
  "log",

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_gui/src-tauri/Cargo.toml

@@ -1,6 +1,6 @@
 [package]
 name = "fiberpath_gui"
-version = "0.7.3"
+version = "0.7.4"
 edition = "2021"
 
 [dependencies]

{fiberpath-0.7.3 → fiberpath-0.7.4}/fiberpath_gui/src-tauri/src/main.rs

@@ -9,6 +9,7 @@ use marlin::MarlinState;
 use serde_json::Value;
 use std::fs;
 use std::process::Output;
+use std::sync::atomic::{AtomicU64, Ordering};
 use std::sync::{Arc, Mutex};
 use std::time::{SystemTime, UNIX_EPOCH};
 use tauri::{AppHandle, Manager};
@@ -208,13 +209,23 @@ async fn plot_definition(
     })
 }
 
+/// Monotonic counter ensuring temp file names are unique within the process
+/// even when several are created in the same millisecond.
+static TEMP_COUNTER: AtomicU64 = AtomicU64::new(0);
+
 fn temp_path(extension: &str) -> String {
     let mut path = std::env::temp_dir();
     let millis = SystemTime::now()
         .duration_since(UNIX_EPOCH)
         .unwrap_or_default()
         .as_millis();
-    path.push(format!("fiberpath-{millis}.{extension}"));
+    // A millisecond-only name collides when rapid commands (e.g. validate /
+    // preview firing on edits) create temp files in the same millisecond — one
+    // call's TempFile::Drop then deletes another's file. The PID plus a
+    // monotonic counter make every name unique within and across processes.
+    let pid = std::process::id();
+    let seq = TEMP_COUNTER.fetch_add(1, Ordering::Relaxed);
+    path.push(format!("fiberpath-{pid}-{millis}-{seq}.{extension}"));
     path.to_string_lossy().into_owned()
 }
 
@@ -520,10 +531,20 @@ fn main() {
 
 #[cfg(test)]
 mod tests {
-    use super::TempFile;
+    use super::{temp_path, TempFile};
+    use std::collections::HashSet;
     use std::fs;
     use std::path::Path;
 
+    // Regression: a millisecond-only temp name collided when many temp files
+    // were created in the same millisecond, so one call's TempFile::Drop could
+    // delete another's file. Rapidly generated paths must all be unique.
+    #[test]
+    fn temp_path_is_unique_under_rapid_calls() {
+        let paths: HashSet<String> = (0..1000).map(|_| temp_path("gcode")).collect();
+        assert_eq!(paths.len(), 1000, "temp_path produced duplicate names");
+    }
+
     #[test]
     fn temp_file_is_removed_on_drop() {
         let path = {