@bobfrankston/wallplater 1.0.1

package/README.md

@@ -0,0 +1,101 @@
+# @bobfrankston/wallplater
+
+JSON-driven wall-plate generator (Decora / duplex / blank gangs). Reads a small
+JSON config and emits a multi-object 3MF (plate + labels as separate,
+individually colourable objects) or per-part STLs.
+
+## Engines
+
+| Engine | Flag | Needs OpenSCAD? | Speed | Notes |
+|---|---|---|---|---|
+| **manifold** (default) | — | no | ~1 s | Direct geometry via [manifold-3d](https://github.com/elalish/manifold) (Clipper2 + robust CSG). Text via [opentype.js](https://github.com/opentypejs/opentype.js). |
+| **scad** (legacy) | `-scad` or `"engine":"scad"` | yes | ~30 s | Writes a `.scad` and shells out to OpenSCAD. Reference / fallback. Does **not** render rocker/header labels. |
+
+The manifold engine has no system dependency beyond Node and is the path
+forward; `-scad` is kept for parity/verification.
+
+## 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`).
+
+```sh
+node index.ts ../KitchenBack.json            # manifold engine -> KitchenBack.3mf
+node index.ts ../KitchenBack.json -scad      # OpenSCAD engine (same result)
+```
+
+- 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.
+
+## Config
+
+Each specific config is **deep-merged over `defaults.json`** (in this
+directory), so a specific file carries only what differs — often just `name`,
+`gangs`, and a `breaker.switch`. Every default lives in `defaults.json`, not in
+code.
+
+Lengths are written **CSS-style with a unit suffix**: `"0.375in"`, `"5mm"`,
+`"-42mm"`. A bare number is treated as millimetres. Angles are plain numbers.
+
+```jsonc
+// KitchenBack.json — only what differs from defaults.json
+{
+  "name": "KitchenBack",
+  "gangs": [
+    { "type": "decora", "legend": "Disposal" },
+    { "type": "blank", "screws": false },     // middle blank, no screw holes
+    { "type": "decora" }
+  ]
+  // add later: "breaker": { "switch": "A8" }
+}
+```
+
+- `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.
+- `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`.
+
+### Stacked rocker labels (Leviton 1755 triple rocker, etc.)
+
+The 1755 is three rockers stacked in one **standard Decora opening**, so the
+opening is unchanged — only the labelling differs. Per gang:
+
+```jsonc
+{
+  "type": "decora",
+  "header": "ON / OFF",                       // centred above the opening
+  "rockers": [                                // top -> bottom (1-3+ entries)
+    { "left": "1", "right": "FAN" },          // a label each side of every rocker
+    { "left": "2", "right": "LIGHT" },
+    { "left": "3", "right": "HEAT" }
+  ]
+}
+```
+
+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:
+`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
+overflow. See `../triple_demo.json` for a worked single-gang example.
+
+> Rocker/header labels are rendered by the **manifold engine only**. The
+> `-scad` engine ignores them (it warns).
+
+See `../decora_wallplate_spec.md` for the dimensional reference and print notes
+(print front-face-down; PETG/ASA recommended for heat near devices; keep plate
+and labels the same material family — see the chat note on ABS+PLA).
+
+## Files
+
+- `index.ts` — CLI entry / engine dispatch / arg validation
+- `config.ts` — schema, unit parsing, defaults.json merge, loader
+- `defaults.json` — all default values (merged under each specific config)
+- `geometry.ts` — manifold engine (direct geometry)
+- `text.ts` — glyph outlines -> filled contours (opentype.js)
+- `scad.ts` — legacy OpenSCAD engine (`.scad` generation + STL readback)
+- `threemf.ts` — multi-object 3MF writer, binary STL writer

package/config.ts

@@ -0,0 +1,171 @@
+/*
+ * 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/defaults.json

@@ -0,0 +1,41 @@
+{
+  "name": "wallplate",
+  "breaker": { "switch": "", "size": "0.375in", "inset": "0.25in" },
+  "legendSize": "5mm",
+  "legendY": "-42mm",
+  "rockerSize": "3.5mm",
+  "rockerGap": "1.5mm",
+  "headerSize": "4mm",
+  "headerGap": "5mm",
+  "bevel": "1.2mm",
+  "labelDepth": "0.6mm",
+  "blankScrews": true,
+  "font": "Liberation Sans:style=Bold",
+  "fontFile": "C:/Windows/Fonts/arialbd.ttf",
+  "plateColor": "#35589f",
+  "accentColor": "#101010",
+  "printReady": true,
+  "output": "3mf",
+  "engine": "manifold",
+  "openscad": "C:/Program Files/OpenSCAD/openscad.exe",
+  "dims": {
+    "gangPitch": "1.8125in",
+    "oneGangWidth": "2.75in",
+    "height": "4.5in",
+    "depth": "4mm",
+    "faceT": "2.2mm",
+    "rimW": "3mm",
+    "cornerR": "5mm",
+    "openW": "1.3125in",
+    "openH": "2.625in",
+    "openR": "3mm",
+    "duplexW": "1.34375in",
+    "duplexH": "1.125in",
+    "duplexSpacing": "1.5in",
+    "screwSpacing": "3.8125in",
+    "blankScrewSpacing": "3.281in",
+    "screwClearD": "4mm",
+    "screwHeadD": "0.3125in",
+    "cskAngle": 82
+  }
+}

package/geometry.ts

@@ -0,0 +1,161 @@
+/*
+ * geometry.ts — the manifold engine (direct, no OpenSCAD).
+ *
+ * Rebuilds the SCAD model with manifold-3d (Clipper2 for 2D, robust CSG for
+ * 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> {
+    if (!wasm) {
+        wasm = await Module();
+        wasm.setup();
+        wasm.setCircularSegments(SEG);
+    }
+    return wasm;
+}
+
+export interface LabeledMesh { label: string; mesh: Mesh; }
+
+function toMesh(m: Manifold): Mesh {
+    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 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]];
+    return { verts, tris };
+}
+
+export async function buildMeshes(cfg: Resolved): Promise<LabeledMesh[]> {
+    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;
+
+    // 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);
+
+    // ----- 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)
+        .subtract(rrect(PLATE_W - 2 * RIM_W, PLATE_H - 2 * RIM_W, CORNER_R - RIM_W));
+    let body = frame.extrude(DEPTH - FACE_T);
+    body = body.add(outline().extrude(FACE_T - BEVEL + 0.001).translate([0, 0, DEPTH - FACE_T]));
+    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];
+        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 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)); };
+
+    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?
+        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") {
+            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
+            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[] = [];
+    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.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
+                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
+                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;
+        return new CrossSection(contours, "NonZero").extrude(height);
+    };
+    const accentManifold = (height: number): Manifold | null => {
+        let acc: Manifold | null = null;
+        for (const p of accent) {
+            const m = textManifold(p.txt, p.size, p.halign, height);
+            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 m = textManifold(cfg.breaker.switch, cfg.breaker.size, "right", height);
+        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;
+    for (const p of [accentManifold(LABEL_DEPTH + 0.02), breakerManifold(LABEL_DEPTH + 0.02)]) {
+        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)) }); }
+    return out;
+}

package/index.ts

@@ -0,0 +1,94 @@
+#!/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, 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" });
+    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.");
+    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: string[] = [];
+        const meshes: Mesh[] = 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);
+        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
+        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 {
+        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> {
+    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 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); });

package/package.json

@@ -0,0 +1,29 @@
+{
+  "name": "@bobfrankston/wallplater",
+  "version": "1.0.1",
+  "type": "module",
+  "description": "JSON-driven wall-plate generator (Decora / duplex / blank). Direct-to-3MF via manifold-3d, with an optional OpenSCAD engine.",
+  "bin": {
+    "wallplater": "index.ts"
+  },
+  "engines": {
+    "node": ">=24"
+  },
+  "scripts": {
+    "gen": "node index.ts",
+    "typecheck": "tsc --noEmit",
+    "release": "npmglobalize"
+  },
+  "dependencies": {
+    "manifold-3d": "^3.0.0",
+    "opentype.js": "^1.3.4"
+  },
+  "devDependencies": {
+    "@types/node": "^25.9.2",
+    "@types/opentype.js": "^1.3.8"
+  },
+  "repository": {
+    "type": "git",
+    "url": "git@github.com:BobFrankston/wallplater.git"
+  }
+}

package/scad.ts

@@ -0,0 +1,177 @@
+/*
+ * scad.ts — the legacy OpenSCAD engine (kept as the `-scad` / engine:"scad"
+ * option). Writes a complete parametric .scad, shells out to OpenSCAD to export
+ * 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 {
+    return Number.isInteger(n) ? String(n) : n.toFixed(4).replace(/0+$/, "").replace(/\.$/, "");
+}
+
+export function generateScad(cfg: Resolved): string {
+    const d = cfg.dims;
+    const gangs = "[" + cfg.gangs.map((g) => `"${gangType(g)}"`).join(", ") + "]";
+    const legend = "[" + cfg.gangs.map((g) => `"${g.legend ?? ""}"`).join(", ") + "]";
+    const filler = "[" + cfg.gangs.map((g) => (g.filler ? "true" : "false")).join(", ") + "]";
+    const screws = "[" + cfg.gangs.map((g) => (g.screws === false ? "false" : "true")).join(", ") + "]";
+    const params = `// ===== Auto-generated by wallplater from ${cfg.name}.json — do not hand-edit =====
+GANGS         = ${gangs};   // per gang: "blank" | "decora" | "duplex"
+LEGEND        = ${legend};
+FILLER        = ${filler};   // blank gang has a filler/insert plate -> screws on Decora line
+SCREWS        = ${screws};   // per gang: place screw holes? (false = omit)
+GANG_PITCH    = ${num(d.gangPitch)};
+ONE_GANG_W    = ${num(d.oneGangWidth)};
+PLATE_H       = ${num(d.height)};
+DEPTH         = ${num(d.depth)};
+FACE_T        = ${num(d.faceT)};
+RIM_W         = ${num(d.rimW)};
+CORNER_R      = ${num(d.cornerR)};
+BEVEL         = ${num(cfg.bevel)};
+OPEN_W        = ${num(d.openW)};
+OPEN_H        = ${num(d.openH)};
+OPEN_R        = ${num(d.openR)};
+DUPLEX_W      = ${num(d.duplexW)};
+DUPLEX_H      = ${num(d.duplexH)};
+DUPLEX_SPACING= ${num(d.duplexSpacing)};
+SCREW_SPACING = ${num(d.screwSpacing)};
+BLANK_SCREW_SPACING = ${num(d.blankScrewSpacing)};
+BLANK_SCREWS  = ${cfg.blankScrews};
+SCREW_CLEAR_D = ${num(d.screwClearD)};
+SCREW_HEAD_D  = ${num(d.screwHeadD)};
+CSK_ANGLE     = ${num(d.cskAngle)};
+LEGEND_SIZE   = ${num(cfg.legendSize)};
+LEGEND_Y      = ${num(cfg.legendY)};
+BREAKER       = "${cfg.breaker.switch}";
+BREAKER_SIZE  = ${num(cfg.breaker.size)};
+BREAKER_INSET = [${num(cfg.breaker.inset)}, ${num(cfg.breaker.inset)}];
+LABEL_DEPTH   = ${num(cfg.labelDepth)};
+LABEL_FONT    = "${cfg.font}";
+PLATE_COLOR   = "${cfg.plateColor}";
+ACCENT_COLOR  = "${cfg.accentColor}";
+MODE          = "preview";   // overridden via -D by wallplater
+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);
+N       = len(GANGS);
+PLATE_W = ONE_GANG_W + (N - 1) * GANG_PITCH;
+function gang_x(i) = (i - (N - 1) / 2) * GANG_PITCH;
+
+module rrect(w, h, r)
+    hull() for (sx = [-1, 1], sy = [-1, 1])
+        translate([sx * (w/2 - r), sy * (h/2 - r)]) circle(r = max(0.1, r));
+
+module screw(x, y) {
+    translate([x, y, -1]) cylinder(d = SCREW_CLEAR_D, h = DEPTH + 2);
+    translate([x, y, DEPTH - CSK_DEPTH])
+        cylinder(d1 = SCREW_CLEAR_D, d2 = SCREW_HEAD_D, h = CSK_DEPTH + 0.01);
+}
+module screws_pair(x, sp) { screw(x, sp/2); screw(x, -sp/2); }
+
+module decora_opening(x)
+    translate([x, 0, -1]) linear_extrude(DEPTH + 2) rrect(OPEN_W, OPEN_H, OPEN_R);
+
+module duplex_opening(x)
+    for (s = [-1, 1])
+        translate([x, s * DUPLEX_SPACING/2, -1]) linear_extrude(DEPTH + 2)
+            intersection() { circle(d = DUPLEX_W); square([DUPLEX_W, DUPLEX_H], center = true); }
+
+module outline() rrect(PLATE_W, PLATE_H, CORNER_R);
+
+module plate_body() {
+    linear_extrude(DEPTH - FACE_T) difference() {
+        outline();
+        rrect(PLATE_W - 2*RIM_W, PLATE_H - 2*RIM_W, CORNER_R - RIM_W);
+    }
+    translate([0, 0, DEPTH - FACE_T]) linear_extrude(FACE_T - BEVEL + 0.001) outline();
+    if (BEVEL > 0)
+        hull() {
+            translate([0, 0, DEPTH - BEVEL]) linear_extrude(0.001) outline();
+            translate([0, 0, DEPTH - 0.001]) linear_extrude(0.001) offset(r = -BEVEL) outline();
+        }
+}
+
+module label_text(txt, sz, h, halign = "center")
+    if (txt != "")
+        linear_extrude(h)
+            text(txt, size = sz, font = LABEL_FONT, halign = halign, valign = "center");
+
+module legend_solids(h)
+    for (i = [0 : N - 1])
+        translate([gang_x(i), LEGEND_Y, DEPTH - LABEL_DEPTH])
+            label_text((i < len(LEGEND)) ? LEGEND[i] : "", LEGEND_SIZE, h);
+
+module breaker_solid(h)
+    translate([PLATE_W/2 - BREAKER_INSET[0], -PLATE_H/2 + BREAKER_INSET[1], DEPTH - LABEL_DEPTH])
+        label_text(BREAKER, BREAKER_SIZE, h, halign = "right");
+
+module plate() {
+    difference() {
+        plate_body();
+        for (i = [0 : N - 1]) {
+            x = gang_x(i);
+            t = GANGS[i];
+            sc = (i >= len(SCREWS)) || SCREWS[i];                         // place screws on this gang?
+            if (t == "decora")      { decora_opening(x); if (sc) screws_pair(x, SCREW_SPACING); }
+            else if (t == "duplex") { duplex_opening(x); if (sc) screw(x, 0); }   // single centre screw
+            else if (BLANK_SCREWS && sc)                                  // blank: box-ear line, or Decora line if a filler plate
+                screws_pair(x, (i < len(FILLER) && FILLER[i]) ? SCREW_SPACING : BLANK_SCREW_SPACING);
+        }
+        legend_solids(LABEL_DEPTH + 0.02);
+        breaker_solid(LABEL_DEPTH + 0.02);
+    }
+}
+
+module oriented()
+    if (PRINT_READY) translate([0, 0, DEPTH]) rotate([180, 0, 0]) children();
+    else children();
+
+if (MODE == "preview") {
+    color(PLATE_COLOR)  plate();
+    color(ACCENT_COLOR) legend_solids(LABEL_DEPTH);
+    color(ACCENT_COLOR) breaker_solid(LABEL_DEPTH);
+} else if (MODE == "plate")   oriented() plate();
+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"] });
+    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 => {
+        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); }
+        return i;
+    };
+    let o = 84;
+    for (let t = 0; t < n; t++) {
+        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]);
+        o += 50;
+    }
+    return { verts, tris };
+}

package/text.ts

@@ -0,0 +1,97 @@
+/*
+ * text.ts — glyph outlines -> filled 2D contours for the manifold engine.
+ *
+ * opentype.js gives us vector glyph outlines (TrueType quadratics / CFF
+ * cubics). We flatten the curves to polylines, flip to model-space (y-up),
+ * and align. The resulting contours (outer + holes) are handed to manifold's
+ * 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
+
+let cachedPath = "";
+let cachedFont: opentype.Font | null = null;
+
+export function loadFont(path: string): opentype.Font {
+    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 {
+    for (let i = 1; i <= CURVE_SEGS; i++) {
+        const t = i / CURVE_SEGS, u = 1 - t;
+        out.push([
+            u * u * p0[0] + 2 * u * t * c[0] + t * t * p1[0],
+            u * u * p0[1] + 2 * u * t * c[1] + t * t * p1[1],
+        ]);
+    }
+}
+
+function cubic(p0: [number, number], c1: [number, number], c2: [number, number], p1: [number, number], out: [number, number][]): void {
+    for (let i = 1; i <= CURVE_SEGS; i++) {
+        const t = i / CURVE_SEGS, u = 1 - t;
+        out.push([
+            u * u * u * p0[0] + 3 * u * u * t * c1[0] + 3 * u * t * t * c2[0] + t * t * t * p1[0],
+            u * u * u * p0[1] + 3 * u * u * t * c1[1] + 3 * u * t * t * c2[1] + t * t * t * p1[1],
+        ]);
+    }
+}
+
+/**
+ * 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
+
+    for (const cmd of path.commands) {
+        if (cmd.type === "M") {
+            if (cur.length) contours.push(cur);
+            cur = [flip(cmd.x, cmd.y)];
+            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][] = [];
+            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][] = [];
+            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);
+            cur = [];
+        }
+    }
+    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;
+    }
+    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; }
+    return contours;
+}

package/threemf.ts

@@ -0,0 +1,117 @@
+/*
+ * threemf.ts — minimal, dependency-free writers for output geometry:
+ *   - Mesh: the common interchange shape used by every engine.
+ *   - build3mf(): a multi-object core-spec 3MF (plate + labels as separate,
+ *     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 {
+    // 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 = "";
+    let items = "";
+    meshes.forEach((m, i) => {
+        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`;
+        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"?>
+<model unit="millimeter" xml:lang="en-US" xmlns="http://schemas.microsoft.com/3dmanufacturing/core/2015/02">
+ <resources>
+${objs} </resources>
+ <build>
+${items} </build>
+</model>
+`;
+    const ct = `<?xml version="1.0" encoding="UTF-8"?>
+<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types">
+ <Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/>
+ <Default Extension="model" ContentType="application/vnd.ms-package.3dmanufacturing-3dmodel+xml"/>
+</Types>
+`;
+    const rels = `<?xml version="1.0" encoding="UTF-8"?>
+<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships">
+ <Relationship Target="/3D/3dmodel.model" Id="rel0" Type="http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel"/>
+</Relationships>
+`;
+    return zip([
+        { name: "[Content_Types].xml", data: Buffer.from(ct) },
+        { name: "_rels/.rels", data: Buffer.from(rels) },
+        { name: "3D/3dmodel.model", data: Buffer.from(model) },
+    ]);
+}
+
+// ---------- binary STL (single object) ----------
+export function writeBinaryStl(mesh: Mesh): Buffer {
+    const buf = Buffer.alloc(84 + mesh.tris.length * 50);
+    buf.writeUInt32LE(mesh.tris.length, 80);
+    let o = 84;
+    for (const t of mesh.tris) {
+        const a = mesh.verts[t[0]], b = mesh.verts[t[1]], c = mesh.verts[t[2]];
+        const ux = b[0] - a[0], uy = b[1] - a[1], uz = b[2] - a[2];
+        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);
+        o += 50;
+    }
+    return buf;
+}
+
+const CRC_TABLE: number[] = (() => {
+    const t: number[] = [];
+    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);
+        t[n] = c >>> 0;
+    }
+    return t;
+})();
+function crc32(buf: Buffer): number {
+    let c = 0xffffffff;
+    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[] = [];
+    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);
+        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);
+        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(offset, 16);
+    return Buffer.concat([...parts, cd, eocd]);
+}

package/tsconfig.json

@@ -0,0 +1,20 @@
+{
+  "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"]
+}