@bobfrankston/wallplater 1.0.2 → 1.0.4

package/{scad.ts → scad.js}

@@ -4,18 +4,14 @@
  * one STL per colour part, and reads STLs back into the common Mesh shape.
  * Note: rocker/header labels are manifold-engine only and are not emitted here.
  */
-
 import { readFileSync } from "fs";
 import { execFileSync } from "child_process";
 import { basename } from "path";
-import { type Resolved, gangType } from "./config.ts";
-import type { Mesh } from "./threemf.ts";
-
-function num(n: number): string {
+import { gangType } from "./config.js";
+function num(n) {
     return Number.isInteger(n) ? String(n) : n.toFixed(4).replace(/0+$/, "").replace(/\.$/, "");
 }
-
-export function generateScad(cfg: Resolved): string {
+export function generateScad(cfg) {
     const d = cfg.dims;
     const gangs = "[" + cfg.gangs.map((g) => `"${gangType(g)}"`).join(", ") + "]";
     const legend = "[" + cfg.gangs.map((g) => `"${g.legend ?? ""}"`).join(", ") + "]";
@@ -60,7 +56,6 @@ PRINT_READY   = ${cfg.printReady};
 `;
     return params + SCAD_BODY;
 }
-
 const SCAD_BODY = `
 $fn = 96;
 CSK_DEPTH = (SCREW_HEAD_D - SCREW_CLEAR_D) / 2 / tan(CSK_ANGLE / 2);
@@ -145,24 +140,25 @@ if (MODE == "preview") {
 else if (MODE == "legend")    oriented() legend_solids(LABEL_DEPTH);
 else if (MODE == "breaker")   oriented() breaker_solid(LABEL_DEPTH);
 `;
-
-export function runOpenscad(exe: string, scadPath: string, outPath: string, mode: string): void {
-    const fmt: string = outPath.endsWith(".3mf") ? "3mf" : outPath.endsWith(".png") ? "png" : "binstl";
-    execFileSync(exe, [`-D`, `MODE="${mode}"`, "--export-format", fmt, "-o", outPath, scadPath],
-        { stdio: ["ignore", "ignore", "inherit"] });
+export function runOpenscad(exe, scadPath, outPath, mode) {
+    const fmt = outPath.endsWith(".3mf") ? "3mf" : outPath.endsWith(".png") ? "png" : "binstl";
+    execFileSync(exe, [`-D`, `MODE="${mode}"`, "--export-format", fmt, "-o", outPath, scadPath], { stdio: ["ignore", "ignore", "inherit"] });
     console.log("  wrote", basename(outPath));
 }
-
-export function readStl(path: string): Mesh {
-    const buf: Buffer = readFileSync(path);
-    const n: number = buf.readUInt32LE(80);
-    const map = new Map<string, number>();
-    const verts: number[][] = [];
-    const tris: number[][] = [];
-    const vid = (x: number, y: number, z: number): number => {
+export function readStl(path) {
+    const buf = readFileSync(path);
+    const n = buf.readUInt32LE(80);
+    const map = new Map();
+    const verts = [];
+    const tris = [];
+    const vid = (x, y, z) => {
         const k = `${x.toFixed(4)},${y.toFixed(4)},${z.toFixed(4)}`;
         let i = map.get(k);
-        if (i === undefined) { i = verts.length; verts.push([x, y, z]); map.set(k, i); }
+        if (i === undefined) {
+            i = verts.length;
+            verts.push([x, y, z]);
+            map.set(k, i);
+        }
         return i;
     };
     let o = 84;
@@ -170,8 +166,10 @@ export function readStl(path: string): Mesh {
         const a = vid(buf.readFloatLE(o + 12), buf.readFloatLE(o + 16), buf.readFloatLE(o + 20));
         const b = vid(buf.readFloatLE(o + 24), buf.readFloatLE(o + 28), buf.readFloatLE(o + 32));
         const c = vid(buf.readFloatLE(o + 36), buf.readFloatLE(o + 40), buf.readFloatLE(o + 44));
-        if (a !== b && b !== c && a !== c) tris.push([a, b, c]);
+        if (a !== b && b !== c && a !== c)
+            tris.push([a, b, c]);
         o += 50;
     }
     return { verts, tris };
 }
+//# sourceMappingURL=scad.js.map

package/text.d.ts

@@ -0,0 +1,11 @@
+import opentype from "opentype.js";
+export type Contours = [number, number][][];
+export type HAlign = "left" | "center" | "right";
+export declare function loadFont(path: string): opentype.Font;
+/**
+ * Build aligned, model-space (y-up) filled contours for `text`.
+ * halign positions the bounding box horizontally relative to the origin;
+ * vertically it is always centred. Returns [] for empty text.
+ */
+export declare function textToContours(font: opentype.Font, text: string, sizeMm: number, halign: HAlign): Contours;
+//# sourceMappingURL=text.d.ts.map

package/{text.ts → text.js}

@@ -7,25 +7,18 @@
  * CrossSection with a NonZero fill rule, which resolves the holes — so no
  * separate triangulation step is needed.
  */
-
 import opentype from "opentype.js";
-
-export type Contours = [number, number][][];
-export type HAlign = "left" | "center" | "right";
-
-const CURVE_SEGS = 12;   // polyline segments per bezier
-
+const CURVE_SEGS = 12; // polyline segments per bezier
 let cachedPath = "";
-let cachedFont: opentype.Font | null = null;
-
-export function loadFont(path: string): opentype.Font {
-    if (cachedFont && cachedPath === path) return cachedFont;
+let cachedFont = null;
+export function loadFont(path) {
+    if (cachedFont && cachedPath === path)
+        return cachedFont;
     cachedFont = opentype.loadSync(path);
     cachedPath = path;
     return cachedFont;
 }
-
-function quad(p0: [number, number], c: [number, number], p1: [number, number], out: [number, number][]): void {
+function quad(p0, c, p1, out) {
     for (let i = 1; i <= CURVE_SEGS; i++) {
         const t = i / CURVE_SEGS, u = 1 - t;
         out.push([
@@ -34,8 +27,7 @@ function quad(p0: [number, number], c: [number, number], p1: [number, number], o
         ]);
     }
 }
-
-function cubic(p0: [number, number], c1: [number, number], c2: [number, number], p1: [number, number], out: [number, number][]): void {
+function cubic(p0, c1, c2, p1, out) {
     for (let i = 1; i <= CURVE_SEGS; i++) {
         const t = i / CURVE_SEGS, u = 1 - t;
         out.push([
@@ -44,54 +36,78 @@ function cubic(p0: [number, number], c1: [number, number], c2: [number, number],
         ]);
     }
 }
-
 /**
  * Build aligned, model-space (y-up) filled contours for `text`.
  * halign positions the bounding box horizontally relative to the origin;
  * vertically it is always centred. Returns [] for empty text.
  */
-export function textToContours(font: opentype.Font, text: string, sizeMm: number, halign: HAlign): Contours {
-    if (text === "") return [];
-    const path = font.getPath(text, 0, 0, sizeMm);     // opentype y points DOWN
-    const contours: Contours = [];
-    let cur: [number, number][] = [];
-    let px = 0, py = 0;                                  // current point (opentype space)
-    const flip = (x: number, y: number): [number, number] => [x, -y];   // -> model y-up
-
+export function textToContours(font, text, sizeMm, halign) {
+    if (text === "")
+        return [];
+    const path = font.getPath(text, 0, 0, sizeMm); // opentype y points DOWN
+    const contours = [];
+    let cur = [];
+    let px = 0, py = 0; // current point (opentype space)
+    const flip = (x, y) => [x, -y]; // -> model y-up
     for (const cmd of path.commands) {
         if (cmd.type === "M") {
-            if (cur.length) contours.push(cur);
+            if (cur.length)
+                contours.push(cur);
             cur = [flip(cmd.x, cmd.y)];
-            px = cmd.x; py = cmd.y;
-        } else if (cmd.type === "L") {
+            px = cmd.x;
+            py = cmd.y;
+        }
+        else if (cmd.type === "L") {
             cur.push(flip(cmd.x, cmd.y));
-            px = cmd.x; py = cmd.y;
-        } else if (cmd.type === "Q") {
-            const pts: [number, number][] = [];
+            px = cmd.x;
+            py = cmd.y;
+        }
+        else if (cmd.type === "Q") {
+            const pts = [];
             quad([px, py], [cmd.x1, cmd.y1], [cmd.x, cmd.y], pts);
-            for (const p of pts) cur.push(flip(p[0], p[1]));
-            px = cmd.x; py = cmd.y;
-        } else if (cmd.type === "C") {
-            const pts: [number, number][] = [];
+            for (const p of pts)
+                cur.push(flip(p[0], p[1]));
+            px = cmd.x;
+            py = cmd.y;
+        }
+        else if (cmd.type === "C") {
+            const pts = [];
             cubic([px, py], [cmd.x1, cmd.y1], [cmd.x2, cmd.y2], [cmd.x, cmd.y], pts);
-            for (const p of pts) cur.push(flip(p[0], p[1]));
-            px = cmd.x; py = cmd.y;
-        } else if (cmd.type === "Z") {
-            if (cur.length) contours.push(cur);
+            for (const p of pts)
+                cur.push(flip(p[0], p[1]));
+            px = cmd.x;
+            py = cmd.y;
+        }
+        else if (cmd.type === "Z") {
+            if (cur.length)
+                contours.push(cur);
             cur = [];
         }
     }
-    if (cur.length) contours.push(cur);
-    if (contours.length === 0) return [];
-
+    if (cur.length)
+        contours.push(cur);
+    if (contours.length === 0)
+        return [];
     // bounding box over all (already flipped) points
     let minX = Infinity, maxX = -Infinity, minY = Infinity, maxY = -Infinity;
-    for (const c of contours) for (const [x, y] of c) {
-        if (x < minX) minX = x; if (x > maxX) maxX = x;
-        if (y < minY) minY = y; if (y > maxY) maxY = y;
-    }
+    for (const c of contours)
+        for (const [x, y] of c) {
+            if (x < minX)
+                minX = x;
+            if (x > maxX)
+                maxX = x;
+            if (y < minY)
+                minY = y;
+            if (y > maxY)
+                maxY = y;
+        }
     const dx = halign === "center" ? -(minX + maxX) / 2 : halign === "right" ? -maxX : -minX;
     const dy = -(minY + maxY) / 2;
-    for (const c of contours) for (const p of c) { p[0] += dx; p[1] += dy; }
+    for (const c of contours)
+        for (const p of c) {
+            p[0] += dx;
+            p[1] += dy;
+        }
     return contours;
 }
+//# sourceMappingURL=text.js.map

package/threemf.d.ts

@@ -0,0 +1,11 @@
+export interface Mesh {
+    verts: number[][];
+    tris: number[][];
+}
+export interface Object3mf {
+    name: string;
+    mesh: Mesh;
+}
+export declare function build3mf(objects: Object3mf[]): Buffer;
+export declare function writeBinaryStl(mesh: Mesh): Buffer;
+//# sourceMappingURL=threemf.d.ts.map

package/{threemf.ts → threemf.js}

@@ -5,22 +5,23 @@
  *     individually colourable objects), packed into the OPC zip by hand.
  *   - writeBinaryStl(): a single binary STL (used for the manifold STL path).
  */
-
 import { deflateRawSync } from "zlib";
-
-export interface Mesh { verts: number[][]; tris: number[][]; }
-
+function xmlEscape(s) {
+    return s.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;").replace(/"/g, "&quot;");
+}
 // ---------- multi-object 3MF (core spec, no slicer settings) ----------
-export function build3mf(meshes: Mesh[]): Buffer {
-    // separate top-level objects (each individually colourable in Bambu), all
-    // at the same transform so the labels stay seated in the plate's pockets.
+export function build3mf(objects) {
+    // separate, named top-level objects (each individually selectable/colourable
+    // in Bambu), all at the same transform so the labels stay seated in the
+    // plate's pockets.
     let objs = "";
     let items = "";
-    meshes.forEach((m, i) => {
+    objects.forEach((o, i) => {
+        const m = o.mesh;
         const id = i + 1;
         const vs = m.verts.map((v) => `<vertex x="${v[0]}" y="${v[1]}" z="${v[2]}"/>`).join("");
         const ts = m.tris.map((t) => `<triangle v1="${t[0]}" v2="${t[1]}" v3="${t[2]}"/>`).join("");
-        objs += `  <object id="${id}" type="model"><mesh><vertices>${vs}</vertices><triangles>${ts}</triangles></mesh></object>\n`;
+        objs += `  <object id="${id}" type="model" name="${xmlEscape(o.name)}"><mesh><vertices>${vs}</vertices><triangles>${ts}</triangles></mesh></object>\n`;
         items += `  <item objectid="${id}" transform="1 0 0 0 1 0 0 0 1 128 128 0"/>\n`;
     });
     const model = `<?xml version="1.0" encoding="UTF-8"?>
@@ -48,9 +49,8 @@ ${items} </build>
         { name: "3D/3dmodel.model", data: Buffer.from(model) },
     ]);
 }
-
 // ---------- binary STL (single object) ----------
-export function writeBinaryStl(mesh: Mesh): Buffer {
+export function writeBinaryStl(mesh) {
     const buf = Buffer.alloc(84 + mesh.tris.length * 50);
     buf.writeUInt32LE(mesh.tris.length, 80);
     let o = 84;
@@ -60,58 +60,86 @@ export function writeBinaryStl(mesh: Mesh): Buffer {
         const vx = c[0] - a[0], vy = c[1] - a[1], vz = c[2] - a[2];
         let nx = uy * vz - uz * vy, ny = uz * vx - ux * vz, nz = ux * vy - uy * vx;
         const len = Math.hypot(nx, ny, nz) || 1;
-        nx /= len; ny /= len; nz /= len;
-        buf.writeFloatLE(nx, o); buf.writeFloatLE(ny, o + 4); buf.writeFloatLE(nz, o + 8);
-        buf.writeFloatLE(a[0], o + 12); buf.writeFloatLE(a[1], o + 16); buf.writeFloatLE(a[2], o + 20);
-        buf.writeFloatLE(b[0], o + 24); buf.writeFloatLE(b[1], o + 28); buf.writeFloatLE(b[2], o + 32);
-        buf.writeFloatLE(c[0], o + 36); buf.writeFloatLE(c[1], o + 40); buf.writeFloatLE(c[2], o + 44);
+        nx /= len;
+        ny /= len;
+        nz /= len;
+        buf.writeFloatLE(nx, o);
+        buf.writeFloatLE(ny, o + 4);
+        buf.writeFloatLE(nz, o + 8);
+        buf.writeFloatLE(a[0], o + 12);
+        buf.writeFloatLE(a[1], o + 16);
+        buf.writeFloatLE(a[2], o + 20);
+        buf.writeFloatLE(b[0], o + 24);
+        buf.writeFloatLE(b[1], o + 28);
+        buf.writeFloatLE(b[2], o + 32);
+        buf.writeFloatLE(c[0], o + 36);
+        buf.writeFloatLE(c[1], o + 40);
+        buf.writeFloatLE(c[2], o + 44);
         o += 50;
     }
     return buf;
 }
-
-const CRC_TABLE: number[] = (() => {
-    const t: number[] = [];
+const CRC_TABLE = (() => {
+    const t = [];
     for (let n = 0; n < 256; n++) {
         let c = n;
-        for (let k = 0; k < 8; k++) c = (c & 1) ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
+        for (let k = 0; k < 8; k++)
+            c = (c & 1) ? (0xedb88320 ^ (c >>> 1)) : (c >>> 1);
         t[n] = c >>> 0;
     }
     return t;
 })();
-function crc32(buf: Buffer): number {
+function crc32(buf) {
     let c = 0xffffffff;
-    for (let i = 0; i < buf.length; i++) c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
+    for (let i = 0; i < buf.length; i++)
+        c = CRC_TABLE[(c ^ buf[i]) & 0xff] ^ (c >>> 8);
     return (c ^ 0xffffffff) >>> 0;
 }
-
-function zip(files: { name: string; data: Buffer }[]): Buffer {
-    const parts: Buffer[] = [];
-    const central: Buffer[] = [];
+function zip(files) {
+    const parts = [];
+    const central = [];
     let offset = 0;
     for (const f of files) {
         const name = Buffer.from(f.name);
         const comp = deflateRawSync(f.data);
         const crc = crc32(f.data);
         const lh = Buffer.alloc(30);
-        lh.writeUInt32LE(0x04034b50, 0); lh.writeUInt16LE(20, 4); lh.writeUInt16LE(0, 6);
-        lh.writeUInt16LE(8, 8); lh.writeUInt32LE(0, 10); lh.writeUInt32LE(crc, 14);
-        lh.writeUInt32LE(comp.length, 18); lh.writeUInt32LE(f.data.length, 22);
-        lh.writeUInt16LE(name.length, 26); lh.writeUInt16LE(0, 28);
+        lh.writeUInt32LE(0x04034b50, 0);
+        lh.writeUInt16LE(20, 4);
+        lh.writeUInt16LE(0, 6);
+        lh.writeUInt16LE(8, 8);
+        lh.writeUInt32LE(0, 10);
+        lh.writeUInt32LE(crc, 14);
+        lh.writeUInt32LE(comp.length, 18);
+        lh.writeUInt32LE(f.data.length, 22);
+        lh.writeUInt16LE(name.length, 26);
+        lh.writeUInt16LE(0, 28);
         parts.push(lh, name, comp);
         const ch = Buffer.alloc(46);
-        ch.writeUInt32LE(0x02014b50, 0); ch.writeUInt16LE(20, 4); ch.writeUInt16LE(20, 6);
-        ch.writeUInt16LE(0, 8); ch.writeUInt16LE(8, 10); ch.writeUInt32LE(0, 12);
-        ch.writeUInt32LE(crc, 16); ch.writeUInt32LE(comp.length, 20); ch.writeUInt32LE(f.data.length, 24);
-        ch.writeUInt16LE(name.length, 28); ch.writeUInt32LE(0, 30); ch.writeUInt32LE(0, 34);
-        ch.writeUInt32LE(0, 38); ch.writeUInt32LE(offset, 42);
+        ch.writeUInt32LE(0x02014b50, 0);
+        ch.writeUInt16LE(20, 4);
+        ch.writeUInt16LE(20, 6);
+        ch.writeUInt16LE(0, 8);
+        ch.writeUInt16LE(8, 10);
+        ch.writeUInt32LE(0, 12);
+        ch.writeUInt32LE(crc, 16);
+        ch.writeUInt32LE(comp.length, 20);
+        ch.writeUInt32LE(f.data.length, 24);
+        ch.writeUInt16LE(name.length, 28);
+        ch.writeUInt32LE(0, 30);
+        ch.writeUInt32LE(0, 34);
+        ch.writeUInt32LE(0, 38);
+        ch.writeUInt32LE(offset, 42);
         central.push(ch, name);
         offset += lh.length + name.length + comp.length;
     }
     const cd = Buffer.concat(central);
     const eocd = Buffer.alloc(22);
-    eocd.writeUInt32LE(0x06054b50, 0); eocd.writeUInt16LE(files.length, 8);
-    eocd.writeUInt16LE(files.length, 10); eocd.writeUInt32LE(cd.length, 12);
+    eocd.writeUInt32LE(0x06054b50, 0);
+    eocd.writeUInt16LE(files.length, 8);
+    eocd.writeUInt16LE(files.length, 10);
+    eocd.writeUInt32LE(cd.length, 12);
     eocd.writeUInt32LE(offset, 16);
     return Buffer.concat([...parts, cd, eocd]);
 }
+//# sourceMappingURL=threemf.js.map

package/config.ts

@@ -1,171 +0,0 @@
-/*
- * config.ts — config schema, defaults, and loading.
- *
- * A specific config (e.g. KitchenBack.json) is deep-merged over defaults.json
- * (in this directory), so a specific file need only carry what differs — often
- * just `name`, `gangs`, and a `breaker.switch`.
- *
- * Lengths are written CSS-style with a unit suffix: "0.375in", "5mm", "-42mm".
- * A bare number is treated as millimetres. Angles are plain numbers (degrees).
- */
-
-import { readFileSync } from "fs";
-import { join } from "path";
-
-export const IN = 25.4;
-
-export type GangType = "blank" | "decora" | "duplex";
-export type Engine = "manifold" | "scad";
-
-/** A length: CSS-style unit string ("0.375in" / "5mm") or a bare number (mm). */
-export type Len = string | number;
-
-/** Parse a length to millimetres. */
-export function mm(v: Len): number {
-    if (typeof v === "number") return v;
-    const m = /^\s*(-?[\d.]+)\s*(mm|in)?\s*$/i.exec(v);
-    if (!m) throw new Error(`invalid length "${v}" (use e.g. "0.375in" or "5mm")`);
-    const n = parseFloat(m[1]);
-    return m[2] && m[2].toLowerCase() === "in" ? n * IN : n;
-}
-
-export interface RockerCfg {
-    left?: string;          // label in the left margin, beside this rocker
-    right?: string;         // label in the right margin, beside this rocker
-}
-
-export interface GangCfg {
-    type?: GangType;        // "blank" | "decora" | "duplex"
-    opening?: boolean;      // legacy: true->decora, false->blank
-    legend?: string;        // small label under this gang
-    filler?: boolean;       // blank gang backed by a filler/insert plate ->
-                            // cover screws sit on the Decora line, not the box-ear line
-    screws?: boolean;       // default true; set false to omit this gang's screw holes
-    rockers?: RockerCfg[];  // top -> bottom, for stacked multi-rocker devices (e.g. Leviton 1755
-                            // triple rocker). Labels sit beside each rocker; the opening is unchanged.
-    header?: string;        // text centred above this gang's opening, e.g. "ON / OFF" / "OFF / ON"
-}
-
-export interface BreakerCfg {
-    switch?: string;        // breaker/circuit label in the lower-right corner, e.g. "A8"
-    size?: Len;             // text size
-    inset?: Len;            // inset from the right and bottom edges
-}
-
-export interface DimsCfg {
-    gangPitch?: Len; oneGangWidth?: Len; height?: Len; depth?: Len;
-    faceT?: Len; rimW?: Len; cornerR?: Len;
-    openW?: Len; openH?: Len; openR?: Len;
-    duplexW?: Len; duplexH?: Len; duplexSpacing?: Len;
-    screwSpacing?: Len; blankScrewSpacing?: Len;
-    screwClearD?: Len; screwHeadD?: Len; cskAngle?: number;
-}
-
-export interface Config {
-    name?: string;
-    gangs: GangCfg[];                  // left -> right; length = number of gangs
-    breaker?: BreakerCfg;
-    legendSize?: Len; legendY?: Len;   // per-gang legend (below the opening)
-    rockerSize?: Len; rockerGap?: Len; // per-rocker side labels
-    headerSize?: Len; headerGap?: Len; // per-gang on/off header
-    bevel?: Len; labelDepth?: Len;
-    blankScrews?: boolean;             // blank gangs get a screw pair on the Decora line
-    font?: string;                     // OpenSCAD fontconfig name (scad engine)
-    fontFile?: string;                 // path to a .ttf/.otf (manifold engine)
-    plateColor?: string;
-    accentColor?: string;
-    printReady?: boolean;
-    dims?: DimsCfg;
-    output?: "scad" | "stl" | "3mf";
-    engine?: Engine;                   // "manifold" (direct) | "scad" (OpenSCAD)
-    openscad?: string;
-}
-
-/** Resolved breaker: lengths reduced to millimetres. */
-export interface Breaker { switch: string; size: number; inset: number; }
-
-/** Resolved dimensions, all in millimetres (cskAngle in degrees). */
-export interface Dims {
-    gangPitch: number; oneGangWidth: number; height: number; depth: number;
-    faceT: number; rimW: number; cornerR: number;
-    openW: number; openH: number; openR: number;
-    duplexW: number; duplexH: number; duplexSpacing: number;
-    screwSpacing: number; blankScrewSpacing: number;
-    screwClearD: number; screwHeadD: number; cskAngle: number;
-}
-
-/** Fully resolved config: every length reduced to millimetres. */
-export interface Resolved {
-    name: string;
-    gangs: GangCfg[];
-    breaker: Breaker;
-    legendSize: number; legendY: number;
-    rockerSize: number; rockerGap: number;
-    headerSize: number; headerGap: number;
-    bevel: number; labelDepth: number;
-    blankScrews: boolean;
-    font: string; fontFile: string;
-    plateColor: string; accentColor: string;
-    printReady: boolean;
-    dims: Dims;
-    output: "scad" | "stl" | "3mf";
-    engine: Engine;
-    openscad: string;
-}
-
-// JSON.parse returns dynamic shape; merged then validated below.
-function readJson(path: string): any {
-    return JSON.parse(readFileSync(path, "utf8"));
-}
-
-/** Deep-merge plain objects; arrays and scalars from `over` replace `base`. */
-function deepMerge(base: any, over: any): any {
-    if (over === null || typeof over !== "object" || Array.isArray(over)) return over;
-    const isObj = (v: any): boolean => v !== null && typeof v === "object" && !Array.isArray(v);
-    const out: any = { ...base };
-    for (const k of Object.keys(over))
-        out[k] = isObj(base?.[k]) && isObj(over[k]) ? deepMerge(base[k], over[k]) : over[k];
-    return out;
-}
-
-export function loadConfig(path: string): Resolved {
-    const defaults = readJson(join(import.meta.dirname, "defaults.json"));
-    const raw = readJson(path) as Config & { code?: unknown };
-    if (raw.code !== undefined)             // renamed 2026-06-08; don't silently ignore old configs
-        console.warn("  ! config field 'code' is now 'breaker': { switch }. The 'code' value is ignored.");
-    // every default lives in defaults.json; the merge guarantees presence
-    const c = deepMerge(defaults, raw) as Config;
-    if (!c.gangs || c.gangs.length === 0) throw new Error("config needs a non-empty 'gangs' array");
-
-    const d = c.dims;
-    const dims: Dims = {
-        gangPitch: mm(d.gangPitch), oneGangWidth: mm(d.oneGangWidth), height: mm(d.height), depth: mm(d.depth),
-        faceT: mm(d.faceT), rimW: mm(d.rimW), cornerR: mm(d.cornerR),
-        openW: mm(d.openW), openH: mm(d.openH), openR: mm(d.openR),
-        duplexW: mm(d.duplexW), duplexH: mm(d.duplexH), duplexSpacing: mm(d.duplexSpacing),
-        screwSpacing: mm(d.screwSpacing), blankScrewSpacing: mm(d.blankScrewSpacing),
-        screwClearD: mm(d.screwClearD), screwHeadD: mm(d.screwHeadD), cskAngle: d.cskAngle,
-    };
-    const b = c.breaker;
-    return {
-        name: c.name,
-        gangs: c.gangs,
-        breaker: { switch: b.switch ?? "", size: mm(b.size), inset: mm(b.inset) },
-        legendSize: mm(c.legendSize), legendY: mm(c.legendY),
-        rockerSize: mm(c.rockerSize), rockerGap: mm(c.rockerGap),
-        headerSize: mm(c.headerSize), headerGap: mm(c.headerGap),
-        bevel: mm(c.bevel), labelDepth: mm(c.labelDepth),
-        blankScrews: c.blankScrews,
-        font: c.font, fontFile: c.fontFile,
-        plateColor: c.plateColor, accentColor: c.accentColor,
-        printReady: c.printReady,
-        dims,
-        output: c.output, engine: c.engine, openscad: c.openscad,
-    };
-}
-
-export function gangType(g: GangCfg): GangType {
-    if (g.type) return g.type;
-    if (g.opening === true) return "decora";
-    return "blank";
-}