@bobfrankston/wallplater 1.0.1 → 1.0.3

package/README.md

@@ -54,9 +54,13 @@ Lengths are written **CSS-style with a unit suffix**: `"0.375in"`, `"5mm"`,
 - `gangs[].type`: `"decora"` | `"duplex"` | `"blank"`.
 - `gangs[].screws`: `false` to omit that gang's screw holes (default true).
 - `gangs[].legend`: single label centred below the gang.
+- `gangs[].breaker`: per-gang breaker/circuit label, centred just below that
+  gang's legend (size/position from `gangBreakerSize` / `gangBreakerY`).
 - `breaker`: `{ "switch": "A8", "size": "0.375in", "inset": "0.25in" }` — the
-  lower-right breaker/circuit label. `switch` is the text; `size`/`inset` come
-  from `defaults.json`, so a config usually sets only `breaker.switch`.
+  panel-wide breaker label in the lower-right corner. `switch` is the text;
+  `size`/`inset` come from `defaults.json`, so a config usually sets only
+  `breaker.switch`. Per-gang (`gangs[].breaker`) and panel-wide (`breaker`)
+  labels are independent — use either or both.
 
 ### Stacked rocker labels (Leviton 1755 triple rocker, etc.)
 

package/config.d.ts

@@ -0,0 +1,127 @@
+export declare 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 declare function mm(v: Len): number;
+export interface RockerCfg {
+    left?: string;
+    right?: string;
+}
+export interface GangCfg {
+    type?: GangType;
+    opening?: boolean;
+    legend?: string;
+    filler?: boolean;
+    screws?: boolean;
+    rockers?: RockerCfg[];
+    header?: string;
+    breaker?: string;
+}
+export interface BreakerCfg {
+    switch?: string;
+    size?: Len;
+    inset?: Len;
+}
+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[];
+    breaker?: BreakerCfg;
+    legendSize?: Len;
+    legendY?: Len;
+    gangBreakerSize?: Len;
+    gangBreakerY?: Len;
+    rockerSize?: Len;
+    rockerGap?: Len;
+    headerSize?: Len;
+    headerGap?: Len;
+    bevel?: Len;
+    labelDepth?: Len;
+    blankScrews?: boolean;
+    font?: string;
+    fontFile?: string;
+    plateColor?: string;
+    accentColor?: string;
+    printReady?: boolean;
+    dims?: DimsCfg;
+    output?: "scad" | "stl" | "3mf";
+    engine?: Engine;
+    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;
+    gangBreakerSize: number;
+    gangBreakerY: 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;
+}
+export declare function loadConfig(path: string): Resolved;
+export declare function gangType(g: GangCfg): GangType;
+//# sourceMappingURL=config.d.ts.map

package/config.js

@@ -0,0 +1,81 @@
+/*
+ * 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;
+/** Parse a length to millimetres. */
+export function mm(v) {
+    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;
+}
+// JSON.parse returns dynamic shape; merged then validated below.
+function readJson(path) {
+    return JSON.parse(readFileSync(path, "utf8"));
+}
+/** Deep-merge plain objects; arrays and scalars from `over` replace `base`. */
+function deepMerge(base, over) {
+    if (over === null || typeof over !== "object" || Array.isArray(over))
+        return over;
+    const isObj = (v) => v !== null && typeof v === "object" && !Array.isArray(v);
+    const out = { ...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) {
+    const defaults = readJson(join(import.meta.dirname, "defaults.json"));
+    const raw = readJson(path);
+    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);
+    if (!c.gangs || c.gangs.length === 0)
+        throw new Error("config needs a non-empty 'gangs' array");
+    const d = c.dims;
+    const 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),
+        gangBreakerSize: mm(c.gangBreakerSize), gangBreakerY: mm(c.gangBreakerY),
+        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) {
+    if (g.type)
+        return g.type;
+    if (g.opening === true)
+        return "decora";
+    return "blank";
+}
+//# sourceMappingURL=config.js.map

package/defaults.json

@@ -3,6 +3,8 @@
   "breaker": { "switch": "", "size": "0.375in", "inset": "0.25in" },
   "legendSize": "5mm",
   "legendY": "-42mm",
+  "gangBreakerSize": "4mm",
+  "gangBreakerY": "-50mm",
   "rockerSize": "3.5mm",
   "rockerGap": "1.5mm",
   "headerSize": "4mm",

package/geometry.d.ts

@@ -0,0 +1,8 @@
+import { type Resolved } from "./config.js";
+import type { Mesh } from "./threemf.js";
+export interface LabeledMesh {
+    label: string;
+    mesh: Mesh;
+}
+export declare function buildMeshes(cfg: Resolved): Promise<LabeledMesh[]>;
+//# sourceMappingURL=geometry.d.ts.map

package/{geometry.ts → geometry.js}

@@ -5,17 +5,12 @@
  * 3D). Produces one Mesh per colour part (plate / legend / code), already
  * print-oriented, ready for build3mf() or writeBinaryStl().
  */
-
 import Module from "manifold-3d";
-import type { ManifoldToplevel, Manifold } from "manifold-3d";
-import { type Resolved, gangType } from "./config.ts";
-import type { Mesh } from "./threemf.ts";
-import { loadFont, textToContours, type Contours, type HAlign } from "./text.ts";
-
-const SEG = 96;   // circular segments (matches the SCAD $fn = 96)
-
-let wasm: ManifoldToplevel | null = null;
-async function getWasm(): Promise<ManifoldToplevel> {
+import { gangType } from "./config.js";
+import { loadFont, textToContours } from "./text.js";
+const SEG = 96; // circular segments (matches the SCAD $fn = 96)
+let wasm = null;
+async function getWasm() {
     if (!wasm) {
         wasm = await Module();
         wasm.setup();
@@ -23,40 +18,34 @@ async function getWasm(): Promise<ManifoldToplevel> {
     }
     return wasm;
 }
-
-export interface LabeledMesh { label: string; mesh: Mesh; }
-
-function toMesh(m: Manifold): Mesh {
+function toMesh(m) {
     const g = m.getMesh();
     const np = g.numProp;
     const vp = g.vertProperties;
     const nv = vp.length / np;
-    const verts: number[][] = new Array(nv);
-    for (let i = 0; i < nv; i++) verts[i] = [vp[i * np], vp[i * np + 1], vp[i * np + 2]];
+    const verts = new Array(nv);
+    for (let i = 0; i < nv; i++)
+        verts[i] = [vp[i * np], vp[i * np + 1], vp[i * np + 2]];
     const tv = g.triVerts;
     const nt = tv.length / 3;
-    const tris: number[][] = new Array(nt);
-    for (let t = 0; t < nt; t++) tris[t] = [tv[t * 3], tv[t * 3 + 1], tv[t * 3 + 2]];
+    const tris = new Array(nt);
+    for (let t = 0; t < nt; t++)
+        tris[t] = [tv[t * 3], tv[t * 3 + 1], tv[t * 3 + 2]];
     return { verts, tris };
 }
-
-export async function buildMeshes(cfg: Resolved): Promise<LabeledMesh[]> {
+export async function buildMeshes(cfg) {
     const w = await getWasm();
     const { Manifold, CrossSection } = w;
     const d = cfg.dims;
-
     const CSK_DEPTH = (d.screwHeadD - d.screwClearD) / 2 / Math.tan((d.cskAngle / 2) * Math.PI / 180);
     const N = cfg.gangs.length;
     const PLATE_W = d.oneGangWidth + (N - 1) * d.gangPitch;
     const PLATE_H = d.height;
     const DEPTH = d.depth, FACE_T = d.faceT, RIM_W = d.rimW, CORNER_R = d.cornerR, BEVEL = cfg.bevel;
     const LABEL_DEPTH = cfg.labelDepth;
-    const gangX = (i: number): number => (i - (N - 1) / 2) * d.gangPitch;
-
+    const gangX = (i) => (i - (N - 1) / 2) * d.gangPitch;
     // rounded rectangle: square inset by r, inflated by r with round corners
-    const rrect = (wd: number, ht: number, r: number) =>
-        CrossSection.square([wd - 2 * r, ht - 2 * r], true).offset(r, "Round", 2, SEG);
-
+    const rrect = (wd, ht, r) => CrossSection.square([wd - 2 * r, ht - 2 * r], true).offset(r, "Round", 2, SEG);
     // ----- plate body: rim frame + face slab + front bevel -----
     const outline = () => rrect(PLATE_W, PLATE_H, CORNER_R);
     const frame = rrect(PLATE_W, PLATE_H, CORNER_R)
@@ -66,96 +55,104 @@ export async function buildMeshes(cfg: Resolved): Promise<LabeledMesh[]> {
     if (BEVEL > 0) {
         // SCAD does a hull(offset(-BEVEL)); a top-scale extrude is the close,
         // robust manifold equivalent for a thin perimeter chamfer.
-        const topScale: [number, number] = [(PLATE_W - 2 * BEVEL) / PLATE_W, (PLATE_H - 2 * BEVEL) / PLATE_H];
+        const topScale = [(PLATE_W - 2 * BEVEL) / PLATE_W, (PLATE_H - 2 * BEVEL) / PLATE_H];
         body = body.add(outline().extrude(BEVEL, 0, 0, topScale).translate([0, 0, DEPTH - BEVEL]));
     }
-
     // ----- cutters: openings + screw holes -----
-    const cutters: Manifold[] = [];
-    const screw = (x: number, y: number): Manifold => {
+    const cutters = [];
+    const screw = (x, y) => {
         const shaft = Manifold.cylinder(DEPTH + 2, d.screwClearD / 2, d.screwClearD / 2, SEG).translate([x, y, -1]);
         const csk = Manifold.cylinder(CSK_DEPTH + 0.01, d.screwClearD / 2, d.screwHeadD / 2, SEG).translate([x, y, DEPTH - CSK_DEPTH]);
         return shaft.add(csk);
     };
-    const screwsPair = (x: number, sp: number): void => { cutters.push(screw(x, sp / 2), screw(x, -sp / 2)); };
-
+    const screwsPair = (x, sp) => { cutters.push(screw(x, sp / 2), screw(x, -sp / 2)); };
     for (let i = 0; i < N; i++) {
         const x = gangX(i);
         const g = cfg.gangs[i];
         const t = gangType(g);
-        const sc = g.screws !== false;                 // place screws on this gang?
+        const sc = g.screws !== false; // place screws on this gang?
         if (t === "decora") {
             cutters.push(rrect(d.openW, d.openH, d.openR).extrude(DEPTH + 2).translate([x, 0, -1]));
-            if (sc) screwsPair(x, d.screwSpacing);
-        } else if (t === "duplex") {
+            if (sc)
+                screwsPair(x, d.screwSpacing);
+        }
+        else if (t === "duplex") {
             const cs = CrossSection.circle(d.duplexW / 2, SEG).intersect(CrossSection.square([d.duplexW, d.duplexH], true));
-            for (const s of [-1, 1]) cutters.push(cs.extrude(DEPTH + 2).translate([x, s * d.duplexSpacing / 2, -1]));
-            if (sc) cutters.push(screw(x, 0));          // single centre screw
-        } else if (cfg.blankScrews && sc) {             // blank: box-ear line, or Decora line if a filler plate
+            for (const s of [-1, 1])
+                cutters.push(cs.extrude(DEPTH + 2).translate([x, s * d.duplexSpacing / 2, -1]));
+            if (sc)
+                cutters.push(screw(x, 0)); // single centre screw
+        }
+        else if (cfg.blankScrews && sc) { // blank: box-ear line, or Decora line if a filler plate
             screwsPair(x, g.filler ? d.screwSpacing : d.blankScrewSpacing);
         }
     }
-
-    // ----- labels: collect every accent-colour text placement -----
-    // gang legend (below), per-gang header (above), and per-rocker side labels
-    // all share the accent colour, so they fold into one "legend" object.
-    interface Place { txt: string; size: number; halign: HAlign; x: number; y: number; }
     const openHalf = d.openW / 2, openTop = d.openH / 2;
-    const accent: Place[] = [];
+    const accent = [];
     for (let i = 0; i < N; i++) {
         const g = cfg.gangs[i];
         const gx = gangX(i);
         if ((g.legend ?? "") !== "")
             accent.push({ txt: g.legend, size: cfg.legendSize, halign: "center", x: gx, y: cfg.legendY });
+        if ((g.breaker ?? "") !== "") // per-gang breaker, below the legend
+            accent.push({ txt: g.breaker, size: cfg.gangBreakerSize, halign: "center", x: gx, y: cfg.gangBreakerY });
         if ((g.header ?? "") !== "")
             accent.push({ txt: g.header, size: cfg.headerSize, halign: "center", x: gx, y: openTop + cfg.headerGap });
         const rk = g.rockers ?? [];
         for (let j = 0; j < rk.length; j++) {
-            const yr = openTop - (j + 0.5) * (d.openH / rk.length);     // rockers top -> bottom
-            if ((rk[j].left ?? "") !== "")                              // right-aligned, snug to opening
+            const yr = openTop - (j + 0.5) * (d.openH / rk.length); // rockers top -> bottom
+            if ((rk[j].left ?? "") !== "") // right-aligned, snug to opening
                 accent.push({ txt: rk[j].left, size: cfg.rockerSize, halign: "right", x: gx - openHalf - cfg.rockerGap, y: yr });
-            if ((rk[j].right ?? "") !== "")                            // left-aligned, snug to opening
+            if ((rk[j].right ?? "") !== "") // left-aligned, snug to opening
                 accent.push({ txt: rk[j].right, size: cfg.rockerSize, halign: "left", x: gx + openHalf + cfg.rockerGap, y: yr });
         }
     }
     const hasAccent = accent.length > 0;
     const hasBreaker = cfg.breaker.switch !== "";
     const font = (hasAccent || hasBreaker) ? loadFont(cfg.fontFile) : null;
-
-    const textManifold = (txt: string, size: number, halign: HAlign, height: number): Manifold | null => {
-        const contours: Contours = textToContours(font, txt, size, halign);
-        if (contours.length === 0) return null;
+    const textManifold = (txt, size, halign, height) => {
+        const contours = textToContours(font, txt, size, halign);
+        if (contours.length === 0)
+            return null;
         return new CrossSection(contours, "NonZero").extrude(height);
     };
-    const accentManifold = (height: number): Manifold | null => {
-        let acc: Manifold | null = null;
+    const accentManifold = (height) => {
+        let acc = null;
         for (const p of accent) {
             const m = textManifold(p.txt, p.size, p.halign, height);
-            if (!m) continue;
+            if (!m)
+                continue;
             const placed = m.translate([p.x, p.y, DEPTH - LABEL_DEPTH]);
             acc = acc ? acc.add(placed) : placed;
         }
         return acc;
     };
-    const breakerManifold = (height: number): Manifold | null => {
+    const breakerManifold = (height) => {
         const m = textManifold(cfg.breaker.switch, cfg.breaker.size, "right", height);
-        if (!m) return null;
+        if (!m)
+            return null;
         return m.translate([PLATE_W / 2 - cfg.breaker.inset, -PLATE_H / 2 + cfg.breaker.inset, DEPTH - LABEL_DEPTH]);
     };
-
     // ----- subtract cutters + label pockets from the plate -----
-    let cutAll: Manifold | null = cutters.length ? Manifold.union(cutters) : null;
+    let cutAll = cutters.length ? Manifold.union(cutters) : null;
     for (const p of [accentManifold(LABEL_DEPTH + 0.02), breakerManifold(LABEL_DEPTH + 0.02)]) {
-        if (p) cutAll = cutAll ? cutAll.add(p) : p;
+        if (p)
+            cutAll = cutAll ? cutAll.add(p) : p;
     }
     const plate = cutAll ? body.subtract(cutAll) : body;
-
     // print-orientation: flip front-face-down (rotation, not mirror) so left stays left
-    const orient = (m: Manifold): Manifold =>
-        cfg.printReady ? m.rotate([180, 0, 0]).translate([0, 0, DEPTH]) : m;
-
-    const out: LabeledMesh[] = [{ label: "plate", mesh: toMesh(orient(plate)) }];
-    if (hasAccent) { const m = accentManifold(LABEL_DEPTH); if (m) out.push({ label: "legend", mesh: toMesh(orient(m)) }); }
-    if (hasBreaker) { const m = breakerManifold(LABEL_DEPTH); if (m) out.push({ label: "breaker", mesh: toMesh(orient(m)) }); }
+    const orient = (m) => cfg.printReady ? m.rotate([180, 0, 0]).translate([0, 0, DEPTH]) : m;
+    const out = [{ label: "plate", mesh: toMesh(orient(plate)) }];
+    if (hasAccent) {
+        const m = accentManifold(LABEL_DEPTH);
+        if (m)
+            out.push({ label: "legend", mesh: toMesh(orient(m)) });
+    }
+    if (hasBreaker) {
+        const m = breakerManifold(LABEL_DEPTH);
+        if (m)
+            out.push({ label: "breaker", mesh: toMesh(orient(m)) });
+    }
     return out;
 }
+//# sourceMappingURL=geometry.js.map

package/index.d.ts

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+export {};
+//# sourceMappingURL=index.d.ts.map

package/{index.ts → index.js}

@@ -12,68 +12,69 @@
  *     node index.ts ../KitchenBack.json
  *     node index.ts ../KitchenBack.json -scad
  */
-
 import { writeFileSync, unlinkSync } from "fs";
 import { basename, dirname, join } from "path";
-import { loadConfig, type Resolved } from "./config.ts";
-import { generateScad, runOpenscad, readStl } from "./scad.ts";
-import { buildMeshes } from "./geometry.ts";
-import { build3mf, writeBinaryStl, type Mesh } from "./threemf.ts";
-
-interface ModePart { mode: string; label: string; }
-
-function partList(cfg: Resolved): ModePart[] {
-    const parts: ModePart[] = [{ mode: "plate", label: "plate" }];
-    if (cfg.gangs.some((g) => (g.legend ?? "") !== "")) parts.push({ mode: "legend", label: "legend" });
-    if (cfg.breaker.switch !== "") parts.push({ mode: "breaker", label: "breaker" });
+import { loadConfig } from "./config.js";
+import { generateScad, runOpenscad, readStl } from "./scad.js";
+import { buildMeshes } from "./geometry.js";
+import { build3mf, writeBinaryStl } from "./threemf.js";
+function partList(cfg) {
+    const parts = [{ mode: "plate", label: "plate" }];
+    if (cfg.gangs.some((g) => (g.legend ?? "") !== ""))
+        parts.push({ mode: "legend", label: "legend" });
+    if (cfg.breaker.switch !== "")
+        parts.push({ mode: "breaker", label: "breaker" });
     return parts;
 }
-
-function runScadEngine(cfg: Resolved, dir: string): void {
-    if (cfg.gangs.some((g) => (g.rockers?.length ?? 0) > 0 || (g.header ?? "") !== ""))
-        console.warn("  ! rocker/header labels are only rendered by the manifold engine; the -scad engine ignores them.");
+function runScadEngine(cfg, dir) {
+    if (cfg.gangs.some((g) => (g.rockers?.length ?? 0) > 0 || (g.header ?? "") !== "" || (g.breaker ?? "") !== ""))
+        console.warn("  ! per-gang rocker/header/breaker labels are only rendered by the manifold engine; the -scad engine ignores them.");
     const scadPath = join(dir, `${cfg.name}.scad`);
     writeFileSync(scadPath, generateScad(cfg));
     console.log("wrote", basename(scadPath));
-    if (cfg.output === "scad") return;
-
+    if (cfg.output === "scad")
+        return;
     const parts = partList(cfg);
     if (cfg.output === "stl") {
-        for (const p of parts) runOpenscad(cfg.openscad, scadPath, join(dir, `${cfg.name}_${p.label}.stl`), p.mode);
-    } else {
-        const tmp: string[] = [];
-        const meshes: Mesh[] = parts.map((p) => {
+        for (const p of parts)
+            runOpenscad(cfg.openscad, scadPath, join(dir, `${cfg.name}_${p.label}.stl`), p.mode);
+    }
+    else {
+        const tmp = [];
+        const meshes = parts.map((p) => {
             const stl = join(dir, `_${cfg.name}_${p.label}.stl`);
             runOpenscad(cfg.openscad, scadPath, stl, p.mode);
             tmp.push(stl);
             return readStl(stl);
         });
         writeFileSync(join(dir, `${cfg.name}.3mf`), build3mf(meshes));
-        for (const t of tmp) unlinkSync(t);
+        for (const t of tmp)
+            unlinkSync(t);
         console.log("  wrote", `${cfg.name}.3mf`, `(${meshes.length} objects: ${parts.map((p) => p.label).join(", ")})`);
     }
 }
-
-async function runManifoldEngine(cfg: Resolved, dir: string): Promise<void> {
-    if (cfg.output === "scad") {                          // scad output always needs the scad engine
+async function runManifoldEngine(cfg, dir) {
+    if (cfg.output === "scad") { // scad output always needs the scad engine
         runScadEngine(cfg, dir);
         return;
     }
     const meshes = await buildMeshes(cfg);
-    for (const m of meshes) console.log("  built", m.label, `(${m.mesh.tris.length} tris)`);
+    for (const m of meshes)
+        console.log("  built", m.label, `(${m.mesh.tris.length} tris)`);
     if (cfg.output === "stl") {
-        for (const m of meshes) writeFileSync(join(dir, `${cfg.name}_${m.label}.stl`), writeBinaryStl(m.mesh));
-    } else {
+        for (const m of meshes)
+            writeFileSync(join(dir, `${cfg.name}_${m.label}.stl`), writeBinaryStl(m.mesh));
+    }
+    else {
         writeFileSync(join(dir, `${cfg.name}.3mf`), build3mf(meshes.map((m) => m.mesh)));
         console.log("  wrote", `${cfg.name}.3mf`, `(${meshes.length} objects: ${meshes.map((m) => m.label).join(", ")})`);
     }
 }
-
-async function main(): Promise<void> {
+async function main() {
     const args = process.argv.slice(2);
     const flags = args.filter((a) => a.startsWith("-"));
     const positional = args.filter((a) => !a.startsWith("-"));
-    const isScad = (f: string): boolean => f.toLowerCase() === "-scad" || f.toLowerCase() === "--scad";
+    const isScad = (f) => f.toLowerCase() === "-scad" || f.toLowerCase() === "--scad";
     const unknown = flags.filter((f) => !isScad(f));
     if (unknown.length) {
         console.error(`unknown option(s): ${unknown.join(" ")}\nusage: node index.ts <config.json> [-scad]`);
@@ -85,10 +86,11 @@ async function main(): Promise<void> {
     const dir = dirname(cfgPath);
     const engine = useScad || cfg.engine === "scad" ? "scad" : "manifold";
     console.log(`engine: ${engine}, output: ${cfg.output}`);
-
-    if (engine === "scad") runScadEngine(cfg, dir);
-    else await runManifoldEngine(cfg, dir);
+    if (engine === "scad")
+        runScadEngine(cfg, dir);
+    else
+        await runManifoldEngine(cfg, dir);
     console.log("done");
 }
-
 main().catch((e) => { console.error(e); process.exit(1); });
+//# sourceMappingURL=index.js.map

package/package.json

@@ -1,16 +1,20 @@
 {
   "name": "@bobfrankston/wallplater",
-  "version": "1.0.1",
+  "version": "1.0.3",
   "type": "module",
   "description": "JSON-driven wall-plate generator (Decora / duplex / blank). Direct-to-3MF via manifold-3d, with an optional OpenSCAD engine.",
+  "main": "index.js",
+  "types": "index.d.ts",
   "bin": {
-    "wallplater": "index.ts"
+    "wallplater": "index.js"
   },
   "engines": {
     "node": ">=24"
   },
   "scripts": {
-    "gen": "node index.ts",
+    "build": "tsc",
+    "watch": "tsc -w",
+    "gen": "node index.js",
     "typecheck": "tsc --noEmit",
     "release": "npmglobalize"
   },
@@ -25,5 +29,8 @@
   "repository": {
     "type": "git",
     "url": "git@github.com:BobFrankston/wallplater.git"
+  },
+  "publishConfig": {
+    "access": "public"
   }
 }

package/scad.d.ts

@@ -0,0 +1,6 @@
+import { type Resolved } from "./config.js";
+import type { Mesh } from "./threemf.js";
+export declare function generateScad(cfg: Resolved): string;
+export declare function runOpenscad(exe: string, scadPath: string, outPath: string, mode: string): void;
+export declare function readStl(path: string): Mesh;
+//# sourceMappingURL=scad.d.ts.map

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,7 @@
+export interface Mesh {
+    verts: number[][];
+    tris: number[][];
+}
+export declare function build3mf(meshes: Mesh[]): Buffer;
+export declare function writeBinaryStl(mesh: Mesh): Buffer;
+//# sourceMappingURL=threemf.d.ts.map

package/{threemf.ts → threemf.js}

@@ -5,13 +5,9 @@
  *     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[][]; }
-
 // ---------- multi-object 3MF (core spec, no slicer settings) ----------
-export function build3mf(meshes: Mesh[]): Buffer {
+export function build3mf(meshes) {
     // separate top-level objects (each individually colourable in Bambu), all
     // at the same transform so the labels stay seated in the plate's pockets.
     let objs = "";
@@ -48,9 +44,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 +55,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";
-}

package/tsconfig.json

@@ -1,20 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "esnext",
-    "module": "NodeNext",
-    "moduleResolution": "nodenext",
-    "allowImportingTsExtensions": true,
-    "noEmit": true,
-    "esModuleInterop": true,
-    "allowSyntheticDefaultImports": true,
-    "strict": true,
-    "strictNullChecks": false,
-    "noImplicitAny": true,
-    "skipLibCheck": true,
-    "forceConsistentCasingInFileNames": true,
-    "types": ["node"],
-    "newLine": "lf"
-  },
-  "include": ["*.ts"],
-  "exclude": ["node_modules", "cruft", ".git", "tests", "prev"]
-}