@willcgage/module-schematic 0.48.0 → 0.49.0

package/dist/index.d.cts

@@ -253,6 +253,10 @@ interface ModuleSchematicDoc {
      * +y up). Stored as an open ring; renderers close it. Absent = derive an
      * approximate band from the endplate widths. */
     outline?: BenchworkPoint[];
+    /** Benchwork HOLE — an inner boundary punched out of `outline`, making the
+     * board a DONUT (a return loop's open middle). Same frame as `outline`; stored
+     * as an open ring, renderers close it. Absent = a solid board. */
+    outlineInner?: BenchworkPoint[];
     /** Internal section joints — inches from endplate A where the module's boards
      * split into sections. Operationally one unit; these mark construction/transport
      * seams (exempt from the end-interface standards). Empty/absent = one section.
@@ -405,6 +409,9 @@ interface ModuleFootprintInput {
     endplateTrackOffsets?: Record<string, number>;
     /** Authored benchwork outline (module-local inches), or absent for the band. */
     outline?: BenchworkPoint[] | null;
+    /** Authored benchwork HOLE — the inner boundary punched out of `outline` to
+     * make a donut. Absent/short = a solid board. */
+    outlineInner?: BenchworkPoint[] | null;
     /** The module's sections (#96 phase 2). When any carries an outline, the
      * module's footprint is the union of those — `outline` is then ignored. */
     sections?: SchematicSection[] | null;
@@ -432,6 +439,9 @@ interface ModuleFootprint {
     /** Authored outline (arc-sampled closed ring) or null → render the band.
      * Null too when `sectionOutlines` is non-empty — the sections ARE the shape. */
     outline: BenchworkPoint[] | null;
+    /** Authored HOLE (arc-sampled closed ring) punched out of `outline` → a donut
+     * board. Null = solid. Renderers fill `outline` with `outlineInner` cut out. */
+    outlineInner: BenchworkPoint[] | null;
     /** Per-section footprints, arc-sampled (#96 phase 2b). Draw every one: together
      * they are the module's footprint. Empty = this module doesn't use sections,
      * so fall back to `outline ?? band` exactly as before. */
@@ -793,6 +803,9 @@ interface EditorState {
      * (endplate A's track point at the origin, mainline +x, perpendicular +y up).
      * Empty = no authored outline (fall back to the endplate-width band). */
     outline: BenchworkPoint[];
+    /** Benchwork HOLE (donut inner boundary), module-local inches. Empty = a solid
+     * board. Set by the return-loop generator; punched out of `outline`. */
+    outlineInner: BenchworkPoint[];
     /** Internal section joints — inches from endplate A where the boards split
      * into sections. Empty = a single section (#48). */
     sectionBreaks: number[];

package/dist/index.d.ts

@@ -253,6 +253,10 @@ interface ModuleSchematicDoc {
      * +y up). Stored as an open ring; renderers close it. Absent = derive an
      * approximate band from the endplate widths. */
     outline?: BenchworkPoint[];
+    /** Benchwork HOLE — an inner boundary punched out of `outline`, making the
+     * board a DONUT (a return loop's open middle). Same frame as `outline`; stored
+     * as an open ring, renderers close it. Absent = a solid board. */
+    outlineInner?: BenchworkPoint[];
     /** Internal section joints — inches from endplate A where the module's boards
      * split into sections. Operationally one unit; these mark construction/transport
      * seams (exempt from the end-interface standards). Empty/absent = one section.
@@ -405,6 +409,9 @@ interface ModuleFootprintInput {
     endplateTrackOffsets?: Record<string, number>;
     /** Authored benchwork outline (module-local inches), or absent for the band. */
     outline?: BenchworkPoint[] | null;
+    /** Authored benchwork HOLE — the inner boundary punched out of `outline` to
+     * make a donut. Absent/short = a solid board. */
+    outlineInner?: BenchworkPoint[] | null;
     /** The module's sections (#96 phase 2). When any carries an outline, the
      * module's footprint is the union of those — `outline` is then ignored. */
     sections?: SchematicSection[] | null;
@@ -432,6 +439,9 @@ interface ModuleFootprint {
     /** Authored outline (arc-sampled closed ring) or null → render the band.
      * Null too when `sectionOutlines` is non-empty — the sections ARE the shape. */
     outline: BenchworkPoint[] | null;
+    /** Authored HOLE (arc-sampled closed ring) punched out of `outline` → a donut
+     * board. Null = solid. Renderers fill `outline` with `outlineInner` cut out. */
+    outlineInner: BenchworkPoint[] | null;
     /** Per-section footprints, arc-sampled (#96 phase 2b). Draw every one: together
      * they are the module's footprint. Empty = this module doesn't use sections,
      * so fall back to `outline ?? band` exactly as before. */
@@ -793,6 +803,9 @@ interface EditorState {
      * (endplate A's track point at the origin, mainline +x, perpendicular +y up).
      * Empty = no authored outline (fall back to the endplate-width band). */
     outline: BenchworkPoint[];
+    /** Benchwork HOLE (donut inner boundary), module-local inches. Empty = a solid
+     * board. Set by the return-loop generator; punched out of `outline`. */
+    outlineInner: BenchworkPoint[];
     /** Internal section joints — inches from endplate A where the boards split
      * into sections. Empty = a single section (#48). */
     sectionBreaks: number[];

package/dist/index.js

@@ -476,6 +476,9 @@ function moduleFootprint(input) {
     // endplate A's face (the far face would be a spurious plate at the throat).
     endplateFaces: input.loop ? endplateFaceSegments(centerline, widthA, widthB, offA, offB).slice(0, 1) : endplateFaceSegments(centerline, widthA, widthB, offA, offB),
     outline: sectionOutlines.length || !authored ? null : sampleBenchworkOutline(authored),
+    // The donut hole, arc-sampled — only when there's a solid outline to punch it
+    // out of (a sectioned module isn't a donut). Renderers cut it from `outline`.
+    outlineInner: sectionOutlines.length || !authored || !input.outlineInner || input.outlineInner.length < 3 ? null : sampleBenchworkOutline(input.outlineInner),
     sectionOutlines
   };
 }
@@ -557,6 +560,7 @@ function emptyEditorState(lengthInches) {
     endplateWidths: {},
     endplateTrackOffsets: {},
     outline: [],
+    outlineInner: [],
     sectionBreaks: [],
     sections: [],
     controlPoints: [],
@@ -793,6 +797,8 @@ function stateToDoc(state, recordNumber) {
     // Benchwork footprint outline (module-local inches); only when it's a real
     // ring (≥ 3 vertices).
     ...state.outline.length >= 3 ? { outline: state.outline } : {},
+    // Benchwork hole (donut inner boundary), when it's a real ring.
+    ...state.outlineInner.length >= 3 ? { outlineInner: state.outlineInner } : {},
     // Internal section joints (inches from A), when the module has more than one.
     ...state.sectionBreaks.length ? { sectionBreaks: state.sectionBreaks } : {},
     // Sections as objects — emitted only once the owner has some, so a module
@@ -884,6 +890,11 @@ function docToState(doc, fallbackLength, moduleTracks = []) {
     y: p.y,
     ...Number.isFinite(p.bulge) && p.bulge ? { bulge: p.bulge } : {}
   }));
+  const outlineInner = (d.outlineInner ?? []).filter((p) => p && Number.isFinite(p.x) && Number.isFinite(p.y)).map((p) => ({
+    x: p.x,
+    y: p.y,
+    ...Number.isFinite(p.bulge) && p.bulge ? { bulge: p.bulge } : {}
+  }));
   const mainPath = trackPath(d.mainPath) ?? [];
   const main2Track_ = (d.tracks ?? []).find((t) => t.id === MAIN2_TRACK_ID);
   const main2Path = trackPath(d.main2Path ?? main2Track_?.path) ?? [];
@@ -907,6 +918,7 @@ function docToState(doc, fallbackLength, moduleTracks = []) {
     endplateWidths,
     endplateTrackOffsets,
     outline,
+    outlineInner,
     sectionBreaks: (d.sectionBreaks ?? []).filter((n) => Number.isFinite(n)).map((n) => sc(n)),
     sections: moduleSections(d),
     mainPath,
@@ -1332,36 +1344,7 @@ function returnLoop(shape, opts) {
     for (let i = 0; i <= steps; i++) out.push({ x: cx + r * Math.cos(a0 + (a12 - a0) * i / steps), y: cy + r * Math.sin(a0 + (a12 - a0) * i / steps) });
     return out;
   };
-  if (shape === "square") {
-    const s = 2 * R;
-    const loop2 = [
-      { x: L, y: 0 },
-      { x: L, y: R },
-      { x: L + s, y: R },
-      { x: L + s, y: -R },
-      { x: L, y: -R },
-      { x: L, y: 0 }
-    ];
-    return {
-      throat: T,
-      loop: rd(loop2),
-      wyeLegs: [rd([T, { x: L, y: R }]), rd([T, { x: L, y: -R }])],
-      wyeHalfAngleDeg: 90,
-      outlineOuter: rd([
-        { x: 0, y: hw },
-        { x: L + s + hw, y: hw },
-        { x: L + s + hw, y: -R - hw },
-        { x: 0, y: -R - hw }
-      ]),
-      outlineInner: rd([
-        { x: L + hw, y: R - hw },
-        { x: L + s - hw, y: R - hw },
-        { x: L + s - hw, y: -R + hw },
-        { x: L + hw, y: -R + hw }
-      ])
-    };
-  }
-  const D = shape === "circle" ? R * 1.15 : R * 1.6;
+  const D = shape === "circle" || shape === "square" ? R * 1.15 : R * 1.6;
   const offY = shape === "offset-teardrop" ? R * 0.7 : 0;
   const C = { x: L + D, y: offY };
   const dist = Math.hypot(C.x - T.x, C.y - T.y);
@@ -1388,6 +1371,36 @@ function returnLoop(shape, opts) {
     ];
   };
   const Ri = R - hw;
+  if (shape === "square") {
+    const xL = C.x - R - hw;
+    const xR = C.x + R + hw;
+    const yT = R + hw;
+    const outerSquare = [
+      { x: 0, y: hw },
+      { x: xL, y: hw },
+      { x: xL, y: yT },
+      { x: xR, y: yT },
+      { x: xR, y: -yT },
+      { x: xL, y: -yT },
+      { x: xL, y: -hw },
+      { x: 0, y: -hw }
+    ];
+    const iHalf = (R - hw) / Math.SQRT2;
+    const holeSquare = iHalf > 2 ? [
+      { x: C.x - iHalf, y: iHalf },
+      { x: C.x + iHalf, y: iHalf },
+      { x: C.x + iHalf, y: -iHalf },
+      { x: C.x - iHalf, y: -iHalf }
+    ] : [];
+    return {
+      throat: T,
+      loop: rd(loop),
+      wyeLegs: [rd([T, P1]), rd([T, P2])],
+      wyeHalfAngleDeg: r2(half * 180 / Math.PI),
+      outlineOuter: rd(outerSquare),
+      outlineInner: rd(holeSquare)
+    };
+  }
   return {
     throat: T,
     loop: rd(loop),