@pcbjs/step 0.0.0 → 0.0.1-next.9029beb783788cfbb471cc9d57e1b47864c6eaa6

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 Yuxuan Zhang
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/align.d.ts

@@ -0,0 +1,49 @@
+import { type StepModel } from './mesh.js';
+import { type Rect, type StepTransform } from './place.js';
+/** A pad in the footprint frame: centre and size in mm, x right and y down; `drill` for a through-hole pad. */
+export interface AlignPad {
+    x: number;
+    y: number;
+    w: number;
+    h: number;
+    drill?: number;
+}
+/** The footprint's pads, its courtyard and its declared body height, which tells a standing model from one lying down. */
+export interface AlignTarget {
+    pads: AlignPad[];
+    courtyard?: Rect;
+    height?: number;
+}
+/** Transforms kept when they already fit, such as the part's current one; the file's own frame is always tried. */
+export interface AlignOptions {
+    keep?: StepTransform[];
+}
+/** The unit a file seems to be drawn in: the factor to millimetres and its name. */
+export interface UnitGuess {
+    scale: number;
+    name: string;
+}
+export interface AlignResult {
+    /** KiCad's model transform to use, offset in mm and rotate in degrees */
+    transform: StepTransform;
+    /** 0 to 1: the share of pins on pads times the share of pads with a pin, lower when another orientation fits as well */
+    confidence: number;
+    unit: UnitGuess;
+    /** the model axis that ends up pointing up, such as +z, and the turn about z in degrees */
+    up: string;
+    turn: number;
+    /** pins found, pins on a pad, pads the pins were matched against */
+    pins: number;
+    matched: number;
+    pads: number;
+    /** the mean distance in mm from a matched pin to its pad centre */
+    error: number;
+    /** a remark for the user, such as another orientation fitting equally well */
+    note?: string;
+    /** set when a transform to keep already fitted: 'current' for the part's own, 'file' for the file's own frame */
+    kept?: 'current' | 'file';
+}
+/** A model's unit from its largest extent against the footprint's size: mm within a factor of three, else the closest unit. */
+export declare function guessUnit(extent: number, target?: number): UnitGuess;
+/** Fit a model to a footprint: by its pins on the pads, else by its box in the courtyard. */
+export declare function alignModel(model: StepModel, target: AlignTarget, opts?: AlignOptions): AlignResult;

package/dist/align.js

@@ -0,0 +1,348 @@
+// Fits KiCad's model transform so the model's pins, read from a height map seen from below, land on the footprint's pads.
+import { bounds } from './mesh.js';
+import { apply, heightAgrees, modelMatrix, mul, rotX, rotY, rotZ } from './place.js';
+const UNITS = [
+    { scale: 1, name: 'mm' }, { scale: 25.4, name: 'inches' }, { scale: 1000, name: 'metres' }, { scale: 2.54, name: 'tenths of an inch' },
+    { scale: 10, name: 'centimetres' }, { scale: 0.001, name: 'micrometres' }, { scale: 0.0254, name: 'mils' }, { scale: 1 / 25.4, name: 'mm read as inches' },
+];
+/** A model's unit from its largest extent against the footprint's size: mm within a factor of three, else the closest unit. */
+export function guessUnit(extent, target) {
+    if (!(extent > 0))
+        return UNITS[0];
+    if (!target || !(target > 0))
+        return extent < 0.2 ? UNITS[2] : extent > 300 ? UNITS[5] : UNITS[0];
+    const ratio = extent / target;
+    if (ratio >= 0.33 && ratio <= 3)
+        return UNITS[0];
+    return UNITS.reduce((a, u) => (Math.abs(Math.log(u.scale * ratio / 1.1)) < Math.abs(Math.log(a.scale * ratio / 1.1)) ? u : a));
+}
+const DEG = Math.PI / 180;
+const UPS = [
+    { name: '+z', m: rotX(0) }, { name: '-z', m: rotX(Math.PI) }, { name: '+y', m: rotX(Math.PI / 2) },
+    { name: '-y', m: rotX(-Math.PI / 2) }, { name: '+x', m: rotY(-Math.PI / 2) }, { name: '-x', m: rotY(Math.PI / 2) },
+];
+/** The model seen from below after `m`: its seat, its XY box and the pin islands, each as a centre and a cell count. */
+function viewFromBelow(model, m, tht) {
+    const tris = [];
+    const box = { x0: Infinity, y0: Infinity, x1: -Infinity, y1: -Infinity };
+    let zlo = Infinity, zhi = -Infinity;
+    const meshes = model.meshes.map(me => {
+        const p = new Float64Array(me.positions.length);
+        for (let i = 0; i < p.length; i += 3) {
+            const q = apply(m, [me.positions[i], me.positions[i + 1], me.positions[i + 2]]);
+            p[i] = q[0];
+            p[i + 1] = q[1];
+            p[i + 2] = q[2];
+            box.x0 = Math.min(box.x0, q[0]);
+            box.x1 = Math.max(box.x1, q[0]);
+            box.y0 = Math.min(box.y0, q[1]);
+            box.y1 = Math.max(box.y1, q[1]);
+            zlo = Math.min(zlo, q[2]);
+            zhi = Math.max(zhi, q[2]);
+        }
+        return { p, ix: me.indices };
+    });
+    if (!Number.isFinite(zlo))
+        return null;
+    const size = Math.max(box.x1 - box.x0, box.y1 - box.y0, 1e-3);
+    const cell = Math.min(0.2, Math.max(0.03, size / 250));
+    const nx = Math.ceil((box.x1 - box.x0) / cell) + 1, ny = Math.ceil((box.y1 - box.y0) / cell) + 1;
+    const z = new Float32Array(nx * ny).fill(Infinity);
+    for (const { p, ix } of meshes)
+        for (let t = 0; t < ix.length; t += 3) {
+            const a = ix[t] * 3, b = ix[t + 1] * 3, c = ix[t + 2] * 3;
+            const ax = p[a], ay = p[a + 1], bx = p[b], by = p[b + 1], cx = p[c], cy = p[c + 1];
+            const d = (by - cy) * (ax - cx) + (cx - bx) * (ay - cy);
+            if (Math.abs(d) < 1e-12)
+                continue;
+            const i0 = Math.max(0, Math.floor((Math.min(ax, bx, cx) - box.x0) / cell)), i1 = Math.min(nx - 1, Math.ceil((Math.max(ax, bx, cx) - box.x0) / cell));
+            const j0 = Math.max(0, Math.floor((Math.min(ay, by, cy) - box.y0) / cell)), j1 = Math.min(ny - 1, Math.ceil((Math.max(ay, by, cy) - box.y0) / cell));
+            for (let j = j0; j <= j1; j++)
+                for (let i = i0; i <= i1; i++) {
+                    const x = box.x0 + (i + 0.5) * cell, y = box.y0 + (j + 0.5) * cell;
+                    const l1 = ((by - cy) * (x - cx) + (cx - bx) * (y - cy)) / d, l2 = ((cy - ay) * (x - cx) + (ax - cx) * (y - cy)) / d, l3 = 1 - l1 - l2;
+                    if (l1 < -1e-6 || l2 < -1e-6 || l3 < -1e-6)
+                        continue;
+                    const zz = l1 * p[a + 2] + l2 * p[b + 2] + l3 * p[c + 2];
+                    if (zz < z[j * nx + i])
+                        z[j * nx + i] = zz;
+                }
+        }
+    const covered = [...z].filter(Number.isFinite).sort((p, q) => p - q);
+    if (!covered.length)
+        return null;
+    const lowest = covered[0], height = zhi - zlo;
+    // THT pins hang over 0.3 mm below the lowest tenth of the underside and the part sits on the rest; SMD sits on its pins
+    const limit = tht ? covered[Math.floor(covered.length * 0.1)] - 0.3 : lowest + Math.max(0.03, 0.02 * height);
+    const seat = tht ? covered.find(v => v >= limit) ?? lowest : lowest;
+    const isPin = (k) => z[k] < limit;
+    const seen = new Uint8Array(nx * ny);
+    const pins = [];
+    for (let k = 0; k < z.length; k++) {
+        if (seen[k] || !isPin(k))
+            continue;
+        let sx = 0, sy = 0, n = 0;
+        const stack = [k];
+        seen[k] = 1;
+        while (stack.length) {
+            const q = stack.pop(), i = q % nx, j = (q - i) / nx;
+            sx += i;
+            sy += j;
+            n++;
+            for (let dj = -1; dj <= 1; dj++)
+                for (let di = -1; di <= 1; di++) {
+                    const ii = i + di, jj = j + dj;
+                    if (ii < 0 || jj < 0 || ii >= nx || jj >= ny)
+                        continue;
+                    const r = jj * nx + ii;
+                    if (!seen[r] && isPin(r)) {
+                        seen[r] = 1;
+                        stack.push(r);
+                    }
+                }
+        }
+        if (n >= 2)
+            pins.push({ x: box.x0 + (sx / n + 0.5) * cell, y: box.y0 + (sy / n + 0.5) * cell, n });
+    }
+    // one island over most of the underside is a flat bottom, not pins
+    const area = covered.length;
+    return { pins: pins.filter(p => p.n < area * 0.5), seat, lowest, top: zhi, box };
+}
+/** How close the two point sets come, 0 to 1, with a millimetre of grace: for a footprint drawn near but not on the real part. */
+function softFit(pins, pads, t) {
+    const near = (x, y, set, dx, dy) => Math.exp(-Math.min(...set.map(q => (q.x + dx - x) ** 2 + (q.y + dy - y) ** 2)) / 2);
+    const a = pads.reduce((s, q) => s + near(q.x, q.y, pins, t[0], t[1]), 0) / pads.length;
+    const b = pins.reduce((s, p) => s + near(p.x + t[0], p.y + t[1], pads, 0, 0), 0) / pins.length;
+    return (a + b) / 2;
+}
+/** How well pins moved by t land on the pads: the share of pins on a pad times the share of pads with a pin. */
+function fitAt(pins, pads, t) {
+    let matched = 0, err = 0;
+    const hit = new Uint8Array(pads.length);
+    for (const p of pins) {
+        const x = p.x + t[0], y = p.y + t[1];
+        let best = -1, bd = Infinity;
+        pads.forEach((q, k) => { const d = Math.hypot(q.x - x, q.y - y); if (d < bd) {
+            bd = d;
+            best = k;
+        } });
+        if (best >= 0 && bd <= pads[best].tol) {
+            matched++;
+            err += bd;
+            hit[best] = 1;
+        }
+    }
+    const padsHit = hit.reduce((a, v) => a + v, 0);
+    const score = pins.length && pads.length ? (matched / pins.length) * (padsHit / pads.length) : 0;
+    return { score, soft: pins.length && pads.length ? softFit(pins, pads, t) : 0, t, matched, error: matched ? err / matched : 0 };
+}
+/** Move t so matched pins sit on their pads on average, weighted by area so a sliver of a contact counts little. */
+function refine(pins, pads, t) {
+    for (let round = 0; round < 4; round++) {
+        let dx = 0, dy = 0, n = 0;
+        for (const p of pins) {
+            const x = p.x + t[0], y = p.y + t[1];
+            let best = -1, bd = Infinity;
+            pads.forEach((q, k) => { const d = Math.hypot(q.x - x, q.y - y); if (d < bd) {
+                bd = d;
+                best = k;
+            } });
+            if (best >= 0 && bd <= pads[best].tol) {
+                dx += (pads[best].x - x) * p.n;
+                dy += (pads[best].y - y) * p.n;
+                n += p.n;
+            }
+        }
+        if (!n)
+            break;
+        t = [t[0] + dx / n, t[1] + dy / n];
+    }
+    return t;
+}
+/** KiCad rotate angles, each a multiple of 90, whose model matrix is m; the one with the fewest turns. */
+function kicadAngles(m) {
+    const A = [0, 90, 180, -90];
+    let best = [0, 0, 0], bestN = 4;
+    for (const rx of A)
+        for (const ry of A)
+            for (const rz of A) {
+                const k = modelMatrix({ offset: [0, 0, 0], rotate: [rx, ry, rz], scale: [1, 1, 1] });
+                if (k.some((v, i) => Math.abs(v - m[i]) > 1e-6))
+                    continue;
+                const n = [rx, ry, rz].filter(Boolean).length;
+                if (n < bestN) {
+                    best = [rx, ry, rz];
+                    bestN = n;
+                }
+            }
+    return best;
+}
+const round2 = (v) => { const r = Math.round(v * 100) / 100; return Math.abs(r) < 0.015 ? 0 : r; };
+/** The smallest spacing of the pad centres along one axis, 0 when they all share it. */
+function pitchOf(pads, k) {
+    const v = [...new Set(pads.map(p => Math.round(p[k] * 1000) / 1000))].sort((a, b) => a - b);
+    let best = 0;
+    for (let i = 1; i < v.length; i++) {
+        const d = v[i] - v[i - 1];
+        if (d > 0.05 && (!best || d < best))
+            best = d;
+    }
+    return best;
+}
+/** An offset snapped to 0, else to a multiple of the pad pitch or of half of it, when one is within 0.1 mm. */
+function snap(v, pitch) {
+    if (Math.abs(v) <= 0.1)
+        return 0;
+    for (const step of pitch ? [pitch, pitch / 2] : []) {
+        const k = Math.round(v / step) * step;
+        if (Math.abs(k - v) <= 0.1)
+            return k;
+    }
+    return v;
+}
+/** Whether every pin that lands on a pad at t sits on that pad's copper, with 0.1 mm to spare. */
+function onCopper(pins, pads, t) {
+    for (const p of pins) {
+        const x = p.x + t[0], y = p.y + t[1];
+        let best = -1, bd = Infinity;
+        pads.forEach((q, k) => { const d = Math.hypot(q.x - x, q.y - y); if (d < bd) {
+            bd = d;
+            best = k;
+        } });
+        if (best < 0 || bd > pads[best].tol)
+            continue;
+        const q = pads[best];
+        if (Math.abs(q.x - x) > q.w / 2 + 0.1 || Math.abs(q.y - y) > q.h / 2 + 0.1)
+            return false;
+    }
+    return true;
+}
+/** Fit a model to a footprint: by its pins on the pads, else by its box in the courtyard. */
+export function alignModel(model, target, opts = {}) {
+    const b = bounds(model);
+    const extent = Math.max(b.max[0] - b.min[0], b.max[1] - b.min[1], b.max[2] - b.min[2]);
+    const pb = target.pads.reduce((a, p) => ({ x0: Math.min(a.x0, p.x - p.w / 2), y0: Math.min(a.y0, p.y - p.h / 2), x1: Math.max(a.x1, p.x + p.w / 2), y1: Math.max(a.y1, p.y + p.h / 2) }), { x0: Infinity, y0: Infinity, x1: -Infinity, y1: -Infinity });
+    const footBox = target.courtyard ?? (target.pads.length ? pb : undefined);
+    const unit = guessUnit(extent, footBox ? Math.max(footBox.x1 - footBox.x0, footBox.y1 - footBox.y0) : undefined);
+    const s = unit.scale;
+    const tht = target.pads.some(p => p.drill);
+    // pads in the model frame, y up; a through-hole part is matched on its drilled pads only
+    const pads = target.pads.filter(p => !tht || p.drill).map(p => ({ x: p.x, y: -p.y, w: p.w, h: p.h, tol: Math.max(0.35, 0.5 * Math.max(p.w, p.h)) }));
+    const padBox = pads.length ? { x: (pb.x0 + pb.x1) / 2, y: -(pb.y0 + pb.y1) / 2 } : { x: 0, y: 0 };
+    const court = footBox ? { x0: footBox.x0, x1: footBox.x1, y0: -footBox.y1, y1: -footBox.y0 } : undefined;
+    const height = target.height !== undefined && target.height > 0 ? target.height : undefined;
+    const key = (f) => f.score + 0.25 * f.soft;
+    const scoreOf = (pins, fit, box, t) => {
+        // pins near pads, in about the right number, count for a footprint drawn from a guess
+        const count = pins.length && pads.length ? Math.min(pins.length, pads.length) / Math.max(pins.length, pads.length) : 0;
+        let score = 0.75 * fit.score + 0.25 * fit.soft * count;
+        if (court) {
+            const over = Math.max(0, court.x0 - (box.x0 + t[0]), box.x1 + t[0] - court.x1, court.y0 - (box.y0 + t[1]), box.y1 + t[1] - court.y1);
+            const fill = Math.exp(-(Math.abs(Math.log((box.x1 - box.x0 + 1e-3) / (court.x1 - court.x0 + 1e-3))) + Math.abs(Math.log((box.y1 - box.y0 + 1e-3) / (court.y1 - court.y0 + 1e-3)))));
+            // pins decide when there are any; the courtyard breaks ties and decides alone without pins
+            score = score > 0 ? score * (0.8 + 0.2 / (1 + Math.max(0, over - 1))) + 0.05 * fill : 0.2 * fill / (1 + over);
+        }
+        else if (score === 0)
+            score = 0.1;
+        return score;
+    };
+    const cands = [];
+    for (const [ui, up] of UPS.entries()) {
+        const base = mul(up.m, [s, 0, 0, 0, 0, s, 0, 0, 0, 0, s, 0, 0, 0, 0, 1]);
+        const view = viewFromBelow(model, base, tht);
+        if (!view)
+            continue;
+        for (const turn of [0, 90, 180, 270]) {
+            const r = rotZ(turn * DEG);
+            const pins = view.pins.map(p => { const q = apply(r, [p.x, p.y, 0]); return { x: q[0], y: q[1], n: p.n }; });
+            const corners = [[view.box.x0, view.box.y0], [view.box.x1, view.box.y1]].map(([x, y]) => apply(r, [x, y, 0]));
+            const box = { x0: Math.min(corners[0][0], corners[1][0]), x1: Math.max(corners[0][0], corners[1][0]), y0: Math.min(corners[0][1], corners[1][1]), y1: Math.max(corners[0][1], corners[1][1]) };
+            const centre = [padBox.x - (box.x0 + box.x1) / 2, padBox.y - (box.y0 + box.y1) / 2];
+            let fit = { score: 0, soft: 0, t: centre, matched: 0, error: 0 };
+            if (pins.length && pads.length) {
+                const starts = [centre];
+                const pinBox = pins.reduce((a, p) => ({ x0: Math.min(a.x0, p.x), x1: Math.max(a.x1, p.x), y0: Math.min(a.y0, p.y), y1: Math.max(a.y1, p.y) }), { x0: Infinity, y0: Infinity, x1: -Infinity, y1: -Infinity });
+                const padPts = pads.reduce((a, p) => ({ x0: Math.min(a.x0, p.x), x1: Math.max(a.x1, p.x), y0: Math.min(a.y0, p.y), y1: Math.max(a.y1, p.y) }), { x0: Infinity, y0: Infinity, x1: -Infinity, y1: -Infinity });
+                starts.push([(padPts.x0 + padPts.x1 - pinBox.x0 - pinBox.x1) / 2, (padPts.y0 + padPts.y1 - pinBox.y0 - pinBox.y1) / 2]);
+                for (const p of pins.slice(0, 3))
+                    for (const q of pads)
+                        starts.push([q.x - p.x, q.y - p.y]);
+                for (const st of starts) {
+                    const f = fitAt(pins, pads, st);
+                    if (key(f) > key(fit) + 1e-9)
+                        fit = f;
+                }
+                if (fit.score > 0)
+                    fit = fitAt(pins, pads, refine(pins, pads, fit.t));
+            }
+            let score = scoreOf(pins, fit, box, fit.score > 0 || fit.soft > 0 ? fit.t : centre);
+            const t = score > 0 && (fit.score > 0 || fit.soft > 0) ? fit.t : centre;
+            // the file's own orientation first when two fit alike
+            score -= (ui * 4 + turn / 90) * 1e-6;
+            cands.push({ score, up: up.name, turn, m: mul(r, up.m), t, view, fit, pins: pins.length, box: { x0: box.x0 + t[0], x1: box.x1 + t[0], y0: box.y0 + t[1], y1: box.y1 + t[1] } });
+        }
+    }
+    if (!cands.length)
+        throw new Error('the model has no geometry to align');
+    cands.sort((p, q) => q.score - p.score);
+    // the file as drawn wins unless most pins land on pads well ahead of any upright fit; without pins the height decides
+    const tall = (c) => c.view.top - c.view.seat;
+    const upright = cands.filter(c => c.up === '+z');
+    const clear = (c) => c.fit.score >= 0.5 && c.fit.score >= (upright[0]?.fit.score ?? 0) + 0.3;
+    let best = cands[0];
+    if (best.up !== '+z' && upright.length && !clear(best)) {
+        best = upright[0];
+        if (height !== undefined && !heightAgrees(tall(best), height))
+            best = cands.find(c => heightAgrees(tall(c), height) && c.score >= upright[0].score * 0.8) ?? best;
+    }
+    // offsets within 0.1 mm of 0, or of the pad pitch, are that
+    const px = pitchOf(pads, 'x'), py = pitchOf(pads, 'y');
+    let t = [snap(best.t[0], px), snap(best.t[1], py)];
+    // keep the file's z = 0 when it is on the board, or when THT pins pass through it under a standoff body such as a TO-220
+    let z = -best.view.seat;
+    if (best.up === '+z' && s === 1 && (Math.abs(best.view.seat) <= 0.1 || (tht && best.view.lowest < -0.3 && best.view.seat >= -0.1)))
+        z = 0;
+    // another orientation that fits as well but puts the body elsewhere is worth a look
+    const rival = cands.find(c => c !== best && c.up === best.up && c.score >= best.score * 0.97 && Math.max(Math.abs(c.box.x0 - best.box.x0), Math.abs(c.box.x1 - best.box.x1), Math.abs(c.box.y0 - best.box.y0), Math.abs(c.box.y1 - best.box.y1)) > 0.5);
+    let confidence = Math.max(0, Math.min(1, best.score));
+    if (rival)
+        confidence *= 0.6;
+    const found = {
+        transform: { offset: [round2(t[0]), round2(t[1]), round2(z)], rotate: kicadAngles(best.m), scale: [s, s, s] },
+        confidence: Math.round(confidence * 100) / 100, unit, up: best.up, turn: best.turn,
+        pins: best.pins, matched: best.fit.matched, pads: pads.length, error: Math.round(fitAt(best.view.pins.map(p => { const q = apply(rotZ(best.turn * DEG), [p.x, p.y, 0]); return { x: q[0], y: q[1], n: p.n }; }), pads, t).error * 100) / 100,
+        ...(rival ? { note: `turned ${(rival.turn - best.turn + 360) % 360} degrees about z fits as well: check pin 1 in the shot` } : {}),
+    };
+    // a kept transform stays when it fits as well as the search: as many pins on pad copper, or without pins its box on the pads
+    const ident = { offset: [0, 0, 0], rotate: [0, 0, 0], scale: [1, 1, 1] };
+    const keeps = [...(opts.keep ?? []).map(k => [k, 'current']), [ident, 'file']];
+    for (const [k, kind] of keeps) {
+        const view = viewFromBelow(model, modelMatrix(k), tht);
+        if (!view)
+            continue;
+        const seated = Math.abs(view.seat) <= 0.1 || (tht && view.lowest < -0.3 && view.seat >= -0.1);
+        if (!seated || (height !== undefined && !heightAgrees(view.top - Math.max(0, view.seat), height) && heightAgrees(tall(best), height)))
+            continue;
+        let fit = { score: 0, soft: 0, t: [0, 0], matched: 0, error: 0 };
+        if (best.fit.matched > 0) {
+            if (!view.pins.length)
+                continue;
+            fit = fitAt(view.pins, pads, [0, 0]);
+            if (fit.matched < Math.ceil(0.85 * best.fit.matched) || fit.score < 0.85 * best.fit.score || !onCopper(view.pins, pads, [0, 0]))
+                continue;
+        }
+        else {
+            const c = { x: (view.box.x0 + view.box.x1) / 2, y: (view.box.y0 + view.box.y1) / 2 };
+            if (pads.length && (Math.abs(c.x - padBox.x) > 0.5 || Math.abs(c.y - padBox.y) > 0.5))
+                continue;
+        }
+        const score = Math.max(0, Math.min(1, scoreOf(view.pins, fit, view.box, [0, 0])));
+        return {
+            transform: { offset: [...k.offset], rotate: [...k.rotate], scale: [...k.scale] },
+            confidence: Math.round(score * (rival ? 0.6 : 1) * 100) / 100, unit: kind === 'file' ? UNITS[0] : unit, up: '+z', turn: 0,
+            pins: view.pins.length, matched: fit.matched, pads: pads.length, error: Math.round(fit.error * 100) / 100, kept: kind,
+            ...(rival ? { note: found.note } : {}),
+        };
+    }
+    return found;
+}

package/dist/binary.d.ts

@@ -0,0 +1,4 @@
+import type { StepModel } from './mesh.js';
+export declare function meshToBinary(model: StepModel): Uint8Array;
+/** Decode the binary of meshToBinary; normals come back unit length to a byte's precision. */
+export declare function meshFromBinary(data: ArrayBuffer | ArrayBufferView): StepModel;

package/dist/binary.js

@@ -0,0 +1,83 @@
+const MAGIC = 0x4d424350; // "PCBM" read as a little-endian u32
+const VERSION = 1;
+const pad4 = (n) => (n + 3) & ~3;
+export function meshToBinary(model) {
+    let size = 12;
+    for (const m of model.meshes) {
+        const n = m.positions.length / 3, wide = n > 0xffff;
+        size += 24 + n * 12 + pad4(n * 3) + pad4(m.indices.length * (wide ? 4 : 2));
+    }
+    const buf = new ArrayBuffer(size);
+    const dv = new DataView(buf);
+    dv.setUint32(0, MAGIC, true);
+    dv.setUint16(4, VERSION, true);
+    dv.setUint16(6, 0, true);
+    dv.setUint32(8, model.meshes.length, true);
+    let off = 12;
+    for (const m of model.meshes) {
+        const n = m.positions.length / 3, wide = n > 0xffff;
+        dv.setFloat32(off, m.color[0], true);
+        dv.setFloat32(off + 4, m.color[1], true);
+        dv.setFloat32(off + 8, m.color[2], true);
+        dv.setUint32(off + 12, n, true);
+        dv.setUint32(off + 16, m.indices.length, true);
+        dv.setUint32(off + 20, wide ? 4 : 2, true);
+        off += 24;
+        for (let i = 0; i < n * 3; i++)
+            dv.setFloat32(off + i * 4, m.positions[i], true);
+        off += n * 12;
+        for (let i = 0; i < n * 3; i++)
+            dv.setInt8(off + i, Math.max(-127, Math.min(127, Math.round((m.normals[i] ?? 0) * 127))));
+        off += pad4(n * 3);
+        if (wide)
+            for (let i = 0; i < m.indices.length; i++)
+                dv.setUint32(off + i * 4, m.indices[i], true);
+        else
+            for (let i = 0; i < m.indices.length; i++)
+                dv.setUint16(off + i * 2, m.indices[i], true);
+        off += pad4(m.indices.length * (wide ? 4 : 2));
+    }
+    return new Uint8Array(buf);
+}
+/** Decode the binary of meshToBinary; normals come back unit length to a byte's precision. */
+export function meshFromBinary(data) {
+    const view = data instanceof ArrayBuffer ? new DataView(data) : new DataView(data.buffer, data.byteOffset, data.byteLength);
+    if (view.byteLength < 12 || view.getUint32(0, true) !== MAGIC)
+        throw new Error('not a pcbjs mesh: the header is missing');
+    const version = view.getUint16(4, true);
+    if (version !== VERSION)
+        throw new Error(`pcbjs mesh version ${version}, this reader knows ${VERSION}`);
+    const count = view.getUint32(8, true);
+    const meshes = [];
+    let off = 12;
+    const need = (n) => { if (off + n > view.byteLength)
+        throw new Error('pcbjs mesh is truncated'); };
+    for (let k = 0; k < count; k++) {
+        need(24);
+        const color = [view.getFloat32(off, true), view.getFloat32(off + 4, true), view.getFloat32(off + 8, true)];
+        const n = view.getUint32(off + 12, true), ni = view.getUint32(off + 16, true), indexSize = view.getUint32(off + 20, true);
+        if (indexSize !== 2 && indexSize !== 4)
+            throw new Error(`pcbjs mesh has an index size of ${indexSize}`);
+        off += 24;
+        need(n * 12 + pad4(n * 3) + pad4(ni * indexSize));
+        const positions = new Float32Array(n * 3);
+        for (let i = 0; i < n * 3; i++)
+            positions[i] = view.getFloat32(off + i * 4, true);
+        off += n * 12;
+        const normals = new Float32Array(n * 3);
+        for (let i = 0; i < n; i++) {
+            const x = view.getInt8(off + i * 3), y = view.getInt8(off + i * 3 + 1), z = view.getInt8(off + i * 3 + 2);
+            const l = Math.hypot(x, y, z) || 1;
+            normals[i * 3] = x / l;
+            normals[i * 3 + 1] = y / l;
+            normals[i * 3 + 2] = z / l;
+        }
+        off += pad4(n * 3);
+        const indices = new Uint32Array(ni);
+        for (let i = 0; i < ni; i++)
+            indices[i] = indexSize === 4 ? view.getUint32(off + i * 4, true) : view.getUint16(off + i * 2, true);
+        off += pad4(ni * indexSize);
+        meshes.push({ positions, normals, indices, color });
+    }
+    return { meshes };
+}

package/dist/format.d.ts

@@ -0,0 +1,7 @@
+/** A model file format: STEP, glTF as JSON or binary, or VRML 2 as KiCad's packages3D library ships it. */
+export type ModelFormat = 'step' | 'gltf' | 'glb' | 'wrl';
+export declare const MODEL_EXTENSIONS: Record<ModelFormat, string[]>;
+export declare function formatOfName(name: string): ModelFormat | null;
+/** The format by the first bytes; a gzipped file is VRML, as `.wrz` is. */
+export declare function formatOfContent(b: Uint8Array): ModelFormat | null;
+export declare function modelFormat(name: string | undefined, content?: Uint8Array): ModelFormat | null;

package/dist/format.js

@@ -0,0 +1,30 @@
+export const MODEL_EXTENSIONS = { step: ['.step', '.stp'], gltf: ['.gltf'], glb: ['.glb'], wrl: ['.wrl', '.vrml'] };
+export function formatOfName(name) {
+    const m = /\.[a-z0-9]+$/i.exec(name.split(/[?#]/)[0]);
+    if (!m)
+        return null;
+    const ext = m[0].toLowerCase();
+    for (const [f, exts] of Object.entries(MODEL_EXTENSIONS))
+        if (exts.includes(ext))
+            return f;
+    return null;
+}
+const text = (b, n) => String.fromCharCode(...b.subarray(0, Math.min(n, b.length)));
+/** The format by the first bytes; a gzipped file is VRML, as `.wrz` is. */
+export function formatOfContent(b) {
+    if (b.length >= 4 && text(b, 4) === 'glTF')
+        return 'glb';
+    if (b.length >= 2 && b[0] === 0x1f && b[1] === 0x8b)
+        return 'wrl';
+    const head = text(b, 256).replace(/^/, '').trimStart();
+    if (head.startsWith('ISO-10303-21'))
+        return 'step';
+    if (head.startsWith('#VRML'))
+        return 'wrl';
+    if (head.startsWith('{') && /"asset"|"meshes"|"accessors"/.test(text(b, 4096)))
+        return 'gltf';
+    return null;
+}
+export function modelFormat(name, content) {
+    return (name ? formatOfName(name) : null) ?? (content ? formatOfContent(content) : null);
+}

package/dist/gltf.d.ts

@@ -0,0 +1,7 @@
+import { type StepModel } from './mesh.js';
+/** `readFile` loads a buffer stored in a file beside the model, by its URI. */
+export interface GltfOptions {
+    readFile?: (uri: string) => Uint8Array;
+}
+/** Read a glTF or GLB file's content into meshes in millimetres, z up. */
+export declare function gltfToMesh(content: Uint8Array, opts?: GltfOptions): StepModel;