@bobfrankston/wallplater 1.0.2 → 1.0.4

package/README.md

@@ -14,20 +14,39 @@ individually colourable objects) or per-part STLs.
 The manifold engine has no system dependency beyond Node and is the path
 forward; `-scad` is kept for parity/verification.
 
+## Build / install
+
+TypeScript compiled to co-located `.js` / `.d.ts` / `.map` (no `src`/`dist`
+split). `tsc` is the global install.
+
+```sh
+npm install
+npm run build        # tsc  (or: npm run watch  for tsc -w)
+```
+
+Installed globally (`npm i -g @bobfrankston/wallplater`) it exposes a
+`wallplater` command. `defaults.json` is resolved relative to the module, so it
+runs correctly from any working directory.
+
 ## Usage
 
-Requires Node 24+ (native TypeScript + ESM — run `.ts` directly). `tsc` is the
-global install; `npm run typecheck` runs `tsc --noEmit` (type-check only — this
-project runs `.ts` and never emits `.js`).
+Requires Node 24+ (ESM). Run the compiled entry:
 
 ```sh
-node index.ts ../KitchenBack.json            # manifold engine -> KitchenBack.3mf
-node index.ts ../KitchenBack.json -scad      # OpenSCAD engine (same result)
+node index.js ../KitchenBack.json          # manifold engine -> KitchenBack.3mf
+node index.js ../KitchenBack.json -scad    # OpenSCAD engine (same result)
+wallplater   ../KitchenBack.json           # if installed globally
 ```
 
 - Outputs are written next to the **config file**, named after the config's `name`.
 - Unknown flags are rejected. `-scad` (or `--scad`) selects the OpenSCAD engine.
 
+The 3MF holds up to three named, individually-selectable objects — `<name> plate`,
+`<name> labels` (all accent text), `<name> breaker` — so each is easy to find in
+Bambu Studio's object list and assign to a filament. The label objects sit flush
+in the plate's front-face pockets (the plate prints front-face-down), so they
+look hidden until you give them a second colour.
+
 ## Config
 
 Each specific config is **deep-merged over `defaults.json`** (in this
@@ -54,9 +73,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.)
 
@@ -76,8 +99,8 @@ opening is unchanged — only the labelling differs. Per gang:
 ```
 
 Rockers are spaced evenly down the opening; `left` labels are right-aligned snug
-to the opening, `right` labels left-aligned. `legend` / `header` / `rockers`
-all print in the accent colour (the `legend` object). Relevant defaults:
+to the opening, `right` labels left-aligned. `legend` / `header` / `rockers` /
+per-gang `breaker` all print in the accent colour (the **labels** object). Relevant defaults:
 `rockerSize` (3.5mm), `rockerGap` (1.5mm), `headerSize` (4mm), `headerGap`
 (5mm). Keep side labels short on multi-gang plates — the side margin is ~18 mm
 on an end/single gang but only ~6 mm between interior gangs; long labels can

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.js

@@ -0,0 +1,101 @@
+#!/usr/bin/env node
+/*
+ * wallplater — JSON-driven wall-plate generator (Decora / duplex / blank).
+ *
+ * Reads a small JSON config (deep-merged over defaults.json) and emits an
+ * STL/3MF. Two engines:
+ *   - manifold (default): builds geometry directly via manifold-3d. No OpenSCAD.
+ *   - scad (-scad or engine:"scad"): writes a .scad and shells out to OpenSCAD.
+ *
+ * The 3MF is multi-object (plate + labels as separate, individually colourable
+ * objects). Run (Node 24+, native TS):
+ *     node index.ts ../KitchenBack.json
+ *     node index.ts ../KitchenBack.json -scad
+ */
+import { writeFileSync, unlinkSync } from "fs";
+import { basename, dirname, join } from "path";
+import { loadConfig } from "./config.js";
+import { generateScad, runOpenscad, readStl } from "./scad.js";
+import { buildMeshes } from "./geometry.js";
+import { build3mf, writeBinaryStl } from "./threemf.js";
+// Bambu object-list name: "<config> <part>"; the accent text object reads "labels".
+function partName(cfgName, label) {
+    return `${cfgName} ${label === "legend" ? "labels" : label}`;
+}
+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, 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;
+    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 = [];
+        const objects = parts.map((p) => {
+            const stl = join(dir, `_${cfg.name}_${p.label}.stl`);
+            runOpenscad(cfg.openscad, scadPath, stl, p.mode);
+            tmp.push(stl);
+            return { name: partName(cfg.name, p.label), mesh: readStl(stl) };
+        });
+        writeFileSync(join(dir, `${cfg.name}.3mf`), build3mf(objects));
+        for (const t of tmp)
+            unlinkSync(t);
+        console.log("  wrote", `${cfg.name}.3mf`, `(${objects.length} objects: ${objects.map((o) => o.name).join(", ")})`);
+    }
+}
+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)`);
+    if (cfg.output === "stl") {
+        for (const m of meshes)
+            writeFileSync(join(dir, `${cfg.name}_${m.label}.stl`), writeBinaryStl(m.mesh));
+    }
+    else {
+        const objects = meshes.map((m) => ({ name: partName(cfg.name, m.label), mesh: m.mesh }));
+        writeFileSync(join(dir, `${cfg.name}.3mf`), build3mf(objects));
+        console.log("  wrote", `${cfg.name}.3mf`, `(${objects.length} objects: ${objects.map((o) => o.name).join(", ")})`);
+    }
+}
+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) => 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]`);
+        process.exit(2);
+    }
+    const useScad = flags.some(isScad);
+    const cfgPath = positional[0] ?? "wallplate.json";
+    const cfg = loadConfig(cfgPath);
+    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);
+    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.2",
+  "version": "1.0.4",
   "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