partforge 0.108.0 → 0.109.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "partforge",
-  "version": "0.108.0",
+  "version": "0.109.1",
   "description": "Turn a declarative part definition into a parametric-CAD web app (three.js + Manifold/Replicad). Requires a Vite-based consumer.",
   "type": "module",
   "license": "MIT",
@@ -96,6 +96,8 @@
     "test": "vitest run",
     "test:watch": "vitest",
     "typecheck": "tsc -p tsconfig.json",
+    "lint": "eslint .",
+    "lint:dead": "knip",
     "check": "node scripts/check-app.mjs",
     "offset-rates": "node scripts/offset-rates.mjs"
   },
@@ -120,9 +122,13 @@
     "three": "^0.184.0"
   },
   "devDependencies": {
+    "@eslint/js": "^10.0.1",
     "@fontsource-variable/geist": "^5.3.0",
     "@fontsource-variable/geist-mono": "^5.3.0",
+    "eslint": "^10.10.0",
+    "globals": "^17.12.0",
     "happy-dom": "^20.10.6",
+    "knip": "^6.35.1",
     "playwright": "^1.49.0",
     "typescript": "^5.9.3",
     "vite": "^8.0.16",

package/src/framework/jobs.js

@@ -108,7 +108,17 @@ async function scoreMatchTargets(built, targets, onProgress) {
         // this is the caller: rings are mm and the mesh masks carry mmPerPx, so a
         // profile target gets the absolute-size score (`iouScale`, contourDist in mm)
         // while an image target gets the pose-normalized one.
-        const scoreOpts = { scaleAware: target.kind === "profile" };
+        //
+        // fillHoles splits the same way, for a reason read off the other side. An image
+        // reference is a photograph, and it arrives HOLE-FILLED: its segmenter closes
+        // interior openings so a highlight inside the object does not read as
+        // background. The mesh silhouette fills nothing, so compared as they come a
+        // spoked face scores BELOW a solid disc against its own photo, and the delta
+        // paints every window "missing" — pointing whoever reads it at filling in the
+        // openings that were the point of the part. So an image target is compared as
+        // outer outlines, both sides filled. A profile's rings are authored geometry
+        // whose inner rings mean a real hole, so a profile target keeps scoring them.
+        const scoreOpts = { scaleAware: target.kind === "profile", fillHoles: target.kind === "image" };
         const { best, views } = matchViews(viewMasks, reference, scoreOpts);
         if (!best) continue; // nothing scoreable — a dropped target, never a zero score
         const { delta, ...scores } = best;

package/src/framework/oracle/match.js

@@ -15,6 +15,12 @@
 // `contourDist` is then a real millimetre distance instead of a fraction of the
 // reference's bbox diagonal.
 //
+// `{fillHoles: true}` asks a different question again: BOTH masks have their enclosed
+// openings closed before anything is measured, so every score compares OUTER OUTLINES and
+// a through-window costs nothing either way. It is for a reference whose own openings are
+// already gone — a segmented photograph, whose segmenter fills them so a highlight inside
+// the object does not read as background. See fillHoles.
+//
 // A mask with no foreground pixels — or no mask at all — is UNSCOREABLE, not
 // zero-scoring: matchMasks returns null and matchViews leaves the view out. 0/0 is
 // never a score.
@@ -27,9 +33,15 @@ const BAND_PX = 2;        // boundary band thickness, per the Boundary IoU defin
 const BIG = 1e20;         // "unreachable" seed for the distance transform's lower envelope
 const MAX_MM_FRAME = 2048; // px ceiling on the scale-aware grid; see mmFrame
 
-// candidate/reference: Task 1 masks. opts: {scaleAware}. → null when either is unscoreable.
+// candidate/reference: Task 1 masks. opts: {scaleAware, fillHoles}. → null when either is
+// unscoreable. `fillHoles` is applied to both masks first, so every score below — iou,
+// boundaryIoU, contourDist, iouScale and delta — is a comparison of outer outlines.
 export function matchMasks(candidate, reference, opts = {}) {
-  const cs = stats(candidate), rs = stats(reference);
+  const fill = opts.fillHoles === true;
+  const cand = fill ? fillHoles(candidate) : candidate;
+  const ref = fill ? fillHoles(reference) : reference;
+
+  const cs = stats(cand), rs = stats(ref);
   if (!cs || !rs) return null;
 
   const nc = normalize(cs), nr = normalize(rs);
@@ -37,10 +49,10 @@ export function matchMasks(candidate, reference, opts = {}) {
   const boundaryIoU = maskIoU(band(nc), band(nr));
   const delta = deltaMap(nc, nr);
 
-  const scaleAware = opts.scaleAware === true && scaled(candidate) && scaled(reference);
+  const scaleAware = opts.scaleAware === true && scaled(cand) && scaled(ref);
   let contourDist, contourUnit, iouScale;
   if (scaleAware) {
-    const [sc, sr, pitch] = mmFrame(cs, candidate.mmPerPx, rs, reference.mmPerPx);
+    const [sc, sr, pitch] = mmFrame(cs, cand.mmPerPx, rs, ref.mmPerPx);
     iouScale = maskIoU(sc, sr);
     contourDist = contourDistance(sc, sr) * pitch;
     contourUnit = "mm";
@@ -70,6 +82,41 @@ export function matchViews(viewMasks, reference, opts = {}) {
   return { best, views };
 }
 
+// A copy of `mask` with its enclosed openings closed: background that cannot reach the
+// image border by 4-connected steps becomes foreground, which is a flood fill of the
+// background inward from the border and then an invert. So a bore or a spoke window fills
+// and a notch cut in from the rim — background still reachable from outside — does not.
+//
+// Works at the mask's own resolution, before any normalization, so what the rest of this
+// file measures is the filled shape itself rather than a resampled approximation of it.
+// The frame (`mmPerPx`, `minX`, `minY`) rides through untouched, and the caller's mask is
+// never mutated.
+export function fillHoles(mask) {
+  const data = mask?.data, w = mask?.width | 0, h = mask?.height | 0;
+  if (!data || !(w > 0) || !(h > 0) || data.length < w * h) return mask;
+
+  const n = w * h;
+  const outside = new Uint8Array(n);
+  const stack = new Int32Array(n);
+  let top = 0;
+  const visit = (i) => { if (!data[i] && !outside[i]) { outside[i] = 1; stack[top++] = i; } };
+
+  for (let c = 0; c < w; c++) { visit(c); visit((h - 1) * w + c); }
+  for (let r = 0; r < h; r++) { visit(r * w); visit(r * w + w - 1); }
+  while (top > 0) {
+    const i = stack[--top];
+    const r = (i / w) | 0, c = i - r * w;
+    if (c > 0) visit(i - 1);
+    if (c < w - 1) visit(i + 1);
+    if (r > 0) visit(i - w);
+    if (r < h - 1) visit(i + w);
+  }
+
+  const out = new Uint8Array(n);
+  for (let i = 0; i < n; i++) if (!outside[i]) out[i] = 255;
+  return { ...mask, data: out, width: w, height: h };
+}
+
 // Squared-then-rooted Euclidean distance (in px) from every pixel to the nearest non-zero
 // pixel of `data`, by Felzenszwalb–Huttenlocher: a 1D lower-envelope pass over rows, then
 // over columns. With no non-zero pixel at all every entry comes back astronomically large

package/src/framework/panel/declared-source.js

@@ -13,8 +13,6 @@
 // Main-thread only, and deliberately import-free beyond what a lookup needs: it
 // runs during panel construction, on every rebuild.
 
-const arr = (v) => (Array.isArray(v) ? v : []);
-
 // `images`/`vectors`/`fonts` may each be a plain map or a function of params —
 // the function form is what a control drives. Resolving it can throw (it is
 // author code running on every panel build), and a broken declaration must not

package/src/framework/param-deps.js

@@ -5,7 +5,6 @@
 import { createProbeKernel } from "./geometry/probe.js";
 import { byteAwareReplacer } from "./geometry/solid-hash.js";
 import { viewSubParts } from "./part-model.js";
-import { resolveDerived } from "./derive.js";
 
 export const RELEVANT_ALL = Symbol("relevant-all");
 

package/src/framework/pick-request/server.js

@@ -22,10 +22,7 @@ import {
   isLoopbackOrigin, isLoopbackHost,
 } from "./endpoint.js";
 
-export {
-  PICK_SERVER_DEFAULT_PORT, PICK_SERVER_DEFAULT_TIMEOUT_MS, PICK_SERVER_DEFAULT_HOST,
-  PICK_SERVER_DEFAULT_URL,
-} from "./endpoint.js";
+export { PICK_SERVER_DEFAULT_PORT, PICK_SERVER_DEFAULT_TIMEOUT_MS } from "./endpoint.js";
 
 const MAX_BODY_BYTES = 256 * 1024;   // no route needs more; anything bigger is abuse
 const MAX_SELECTION_CHARS = 16 * 1024;

package/src/parts/faceted-vase.js

@@ -3,7 +3,6 @@
 // running twist plus an alternating half-facet offset, so the facets zig-zag into a
 // woven look. A second, wall-inset loft is cut from the body to hollow it (Manifold
 // backend, so it stays fast — no OCCT). See docs/AUTHORING-PARTS.md for the conventions.
-import { regularPolygon } from "partforge/geometry";
 
 const RINGS = 28; // silhouette resolution (ring count up the height)