partforge 0.79.0 → 0.81.0

package/types/testing.d.ts

@@ -186,6 +186,21 @@ export function meshVolume(positions: ArrayLike<number>, indices?: ArrayLike<num
 /** `[dx, dy, dz]` extent of a flat position array. */
 export function bboxSize(positions: ArrayLike<number>): [number, number, number];
 
+/** World-frame axis-aligned bounds of a flat position array. */
+export function bounds(positions: ArrayLike<number>): { min: [number, number, number]; max: [number, number, number] };
+
+/** Total surface area of an indexed (or soup, when `indices` is omitted) triangle mesh, mm². */
+export function meshArea(positions: ArrayLike<number>, indices?: ArrayLike<number>): number;
+
+/** Triangles as `[v0, v1, v2]` coordinate triples, from an indexed mesh or a soup. */
+export function meshTriangles(mesh: Mesh): [number, number, number][][];
+
+/** Parse a binary or ASCII STL into a welded, indexed mesh. */
+export function parseStl(bytes: Uint8Array | ArrayBuffer): { positions: Float32Array; indices: Uint32Array };
+
+/** Parse a 3MF archive's first mesh object into a welded, indexed mesh. */
+export function parse3MF(bytes: Uint8Array | ArrayBuffer): { positions: Float32Array; indices: Uint32Array };
+
 // --- the BVH ----------------------------------------------------------------
 
 /** A triangle BVH over one mesh — nearest ray hit, nearest point, exact mesh distance. */
@@ -454,183 +469,6 @@ export function matchViews(
   opts?: { scaleAware?: boolean },
 ): { best: ({ view: string } & MatchScores) | null; views: Record<string, number> };
 
-// --- describe (the semantic mesh oracle) ------------------------------------
-
-/** A raw measurement snapped to intent — never destroys the measurement. */
-export interface Snapped {
-  raw: number;
-  to: number;
-  note: string | null;
-}
-
-/** One fitted surface patch. `fit` is the raw per-type fit record (fit.js). */
-export interface DescribeSurface {
-  id: string;
-  type: string;
-  area: number;
-  triangles: number;
-  rms: number;
-  maxDev: number;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- shape varies by surface type (plane/cylinder/cone/torus/sphere)
-  fit: Record<string, any>;
-}
-
-/** One fitted edge between two surfaces. */
-export interface DescribeArc {
-  between: [string, string];
-  convexity: "convex" | "concave" | "flat";
-  kind: string;
-  radius: number | null;
-  axis: unknown;
-  length: number;
-}
-
-/**
- * One recognised feature. Shape varies by `type` (a hole carries `diameter`/
- * `axis`, a fillet carries `radius`/`between`, …) — the fields every family
- * shares are pulled out here; the rest is read by `type`. Every field here
- * must be something a rebuilding agent would want (round 4 review) —
- * `surfaces`/`evidence` are; nothing per-triangle belongs here. describe.js
- * strips any such internal-plumbing field (`faceScope`, a prismatic
- * candidate builder's own per-triangle index map) before a feature reaches
- * this shape, so this catch-all is not a substitute for that discipline.
- */
-export interface DescribeFeature {
-  id: string;
-  key: string;
-  type: string;
-  /** The marginal xor-volume reduction that admitted this feature, normalised
-   * to the source volume — the fraction of the PART'S VOLUME this feature
-   * accounts for, not a certainty rating (see `DescribeScore`'s own note): a
-   * small-but-certain feature legitimately reports a small share. `null` for
-   * a type acceptCandidates never proposes (fillet, chamfer, revolve, shell). */
-  volumeShare: number | null;
-  /** Snapped values for whichever of diameter/depth/radius/width/thickness this feature carries. */
-  snapped: Record<string, Snapped>;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- per-type facts (axis, profile, evidence, …)
-  [key: string]: any;
-}
-
-/** A repetition (grid/linear/circular) or a detected mirror plane over the feature list. */
-export interface DescribePattern {
-  id: string;
-  type: "grid" | "linear" | "circular";
-  members: string[];
-  axis: number[] | null;
-  // eslint-disable-next-line @typescript-eslint/no-explicit-any -- per-type spacing/count facts
-  [key: string]: any;
-}
-
-/** One connected island of mesh area no surface fit claimed. */
-export interface DescribeResidualRegion {
-  triangles: number;
-  centroid: number[];
-  bounds: { min: number[]; max: number[] };
-}
-
-/** One proposed rebuild step, in the order acceptCandidates actually admitted it. */
-export interface DescribeSuggestionStep {
-  op: string;
-  explains: string[];
-  pattern: string | null;
-  score: number;
-  args: Record<string, unknown>;
-}
-
-/** A proposed reconstruction — an interpretation, not a measurement (see `disclaimer`). */
-export interface DescribeSuggestion {
-  disclaimer: string;
-  params: Array<{ name: string; value: number; from: string }>;
-  steps: DescribeSuggestionStep[];
-}
-
-/** Which of the report's capped arrays actually hit their ceiling (`DESCRIBE_LIMITS`). */
-export interface DescribeTruncated {
-  surfaces: boolean;
-  edges: boolean;
-  features: boolean;
-  patterns: boolean;
-  residualRegions: boolean;
-  suggestionSteps: boolean;
-}
-
-export interface DescribeScore {
-  /** Surface coverage from segmentation: fraction of the mesh's area fitted to some surface type. */
-  explainedArea: number;
-  /** Shape coverage from reconstruction: fraction of the part's volume the accepted features rebuild. */
-  explainedVolumeFraction: number;
-  xorFraction: number;
-  xorVolume: number;
-  note: string;
-}
-
-/** A full `describe()` report — everything measured, meant for archival/`--json`. */
-export interface DescribeReport {
-  source: { name: string | null; digest: string | null; triangles: number; watertight: boolean | null; units: "mm" };
-  frame: { up: "+Z"; note: string };
-  bounds: { min: number[]; max: number[]; size: number[] };
-  counts: { surfaces: number; edges: number };
-  surfaces: DescribeSurface[];
-  edges: DescribeArc[];
-  features: DescribeFeature[];
-  patterns: DescribePattern[];
-  symmetry: unknown[];
-  residual: { areaFraction: number; regions: DescribeResidualRegion[] };
-  score: DescribeScore;
-  suggestion: DescribeSuggestion | null;
-  truncated: DescribeTruncated;
-  /** Present only when the acceptance loop hit its boolean budget before converging. */
-  warning?: "budget-exceeded";
-}
-
-/** The model-facing view: capped arrays elided to counts, a coverage banner first when low. */
-export type DescribeCompactReport = Omit<DescribeReport, "surfaces" | "edges"> & {
-  /** Present, and serialized FIRST, only when coverage is below `LOW_COVERAGE`. */
-  warning?: string;
-};
-
-/** A closed-set failure, returned rather than thrown (spec §5's diagnostic triple). */
-export interface DescribeFailure {
-  error: "not-manifold" | "too-large" | "empty" | "budget-exceeded" | "unreadable";
-  detail: string;
-  diagnostic: { cause: string; location: string; correctiveAction: string };
-  source: { name: string | null; digest: string | null; [key: string]: unknown };
-}
-
-/** The closed set of error codes `describe()` can return. */
-export const DESCRIBE_ERRORS: readonly string[];
-
-/** Report array ceilings (`MAX_SURFACES`, `MAX_FEATURES`, …) — a plain-data module, no imports. */
-export const DESCRIBE_LIMITS: {
-  MAX_SURFACES: number;
-  MAX_EDGES: number;
-  MAX_FEATURES: number;
-  MAX_PATTERNS: number;
-  MAX_RESIDUAL_REGIONS: number;
-  MAX_SUGGESTION_STEPS: number;
-};
-
-/** Below this fraction (the worse of `explainedArea`/`explainedVolumeFraction`) `compactDescribe` prepends a warning. */
-export const LOW_COVERAGE: number;
-
-/** A fresh, caller-owned digest memo — scope one per worker, or per test. */
-export function describeMemo(): Map<string, DescribeReport>;
-
-/**
- * Mesh in, semantic feature report out. `solid` is a LIVE kernel `Solid` — the
- * kernel has no public mesh->solid constructor, so a caller reads one back via
- * `kernel.import(name)`. Keyed by `opts.digest` in `opts.memo` (when both are
- * given): the report depends on nothing but the mesh bytes, so an edit to the
- * part that produced the mesh can never invalidate it.
- */
-export function describe(
-  kernel: GeometryKernel,
-  solid: Solid,
-  opts?: { name?: string; digest?: string; budget?: number; memo?: Map<string, DescribeReport> },
-): DescribeReport | DescribeFailure;
-
-/** The full report, reduced to what a model should read: capped arrays elided to counts, low-coverage banner first. */
-export function compactDescribe(full: DescribeReport): DescribeCompactReport;
 
 // --- rendering --------------------------------------------------------------
 

package/types/worker.d.ts

@@ -17,5 +17,13 @@ export interface WorkerHandle {
   setPart(newPart: PartDefinition): void;
 }
 
-/** Run the worker job loop for `part`. Call once, at worker module top level. */
-export function runWorker(part: PartDefinition): WorkerHandle;
+/**
+ * Run the worker job loop for `part`. Call once, at worker module top level.
+ * `opts.loadOracle` injects the closed semantic-mesh-oracle package (a thunk
+ * resolving its barrel: `describe`, `describeMemo`, `compactDescribe`); omitted,
+ * describe jobs answer with a structured `oracle-unavailable` report.
+ */
+export function runWorker(
+  part: PartDefinition,
+  opts?: { loadOracle?: () => Promise<{ describe: Function; describeMemo: () => Map<string, unknown>; compactDescribe: Function }> },
+): WorkerHandle;

package/src/framework/oracle/describe/accept.js

@@ -1,188 +0,0 @@
-// The confirm half of propose-then-confirm (spec §2.8). Segmentation and the feature
-// rules produce CANDIDATES; this decides which are real, in what order, and how sure
-// we are — by building each one and measuring it against the source mesh.
-//
-// Three properties are load-bearing.
-//
-// ONE CACHE BRACKET. geometry/solid-cache.js scopes retention to the current build's
-// graph: each begin()/end() pair rebuilds the retained set and DISPOSES anything not
-// re-used that round. A search loop that opened a bracket per candidate would evict its
-// own shared subtrees on every iteration — quadratic rebuilds and WASM churn on a part
-// that should be nearly free. So the whole loop runs inside exactly one bracket, and
-// every candidate's geometry stays warm and shared for its duration.
-//
-// HARD BUDGET. Booleans are the cost centre and the candidate list is attacker-shaped
-// (it grows with mesh complexity, not with anything we control). The budget counts
-// CANDIDATE ATTEMPTS, not raw boolean calls — see the loop's own comment below for
-// exactly what one attempt costs in real booleans, which varies by case — and running
-// out DEGRADES INTO RESIDUAL rather than throwing: an over-budget describe returns a
-// partial, honestly-scored report, which is exactly what a caller can act on.
-//
-// CONFIDENCE IS THE GAIN. A feature's confidence is the marginal xor reduction that
-// admitted it, not a separate estimate invented afterwards. That is what makes the
-// number falsifiable — it is a measurement of how much of the part that feature
-// explains.
-//
-// The ONLY kernel-touching file in describe/.
-
-// Named for what it actually counts (see the loop's own comment): CANDIDATE ATTEMPTS,
-// not boolean operations. One attempt costs 0-2 real booleans depending on the
-// candidate's op and whether a base body exists yet, so this is a bound on search
-// WORK, not a boolean-op budget a caller could size against a WASM-call cost model.
-export const DEFAULT_ATTEMPT_BUDGET = 48;
-// A candidate must explain at least this fraction of the source volume to be worth a
-// line in the report. Below it, the "feature" is tessellation noise.
-const MIN_GAIN_FRACTION = 1e-4;
-
-// Symmetric-difference volume — the same measure measure.js uses for the `reference`
-// deviation fact, so a describe score and a verify ref-gate are directly comparable.
-// One boolean and two volume reads; no meshing, no rasterisation. `cut`/`union`/
-// `intersect` are binary methods ON A SOLID (`a.intersect(b)`), not kernel-level free
-// functions — kernel.js's own JSDoc has the full Solid method table; there is no
-// `kernel.intersect(a, b)`. Neither operand needs `.clone()` first: unlike the OCCT
-// backend (whose replicad shapes ARE consumed by a transform — see AGENTS.md),
-// Manifold's boolean methods return a new solid and leave both operands live and
-// reusable, exactly as measure.js's own `solid.intersect(ref).volume()` and
-// assembly.js's pairwise overlap check already rely on.
-function xorVolume(a, b) {
-  const inter = a.intersect(b).volume();
-  return a.volume() + b.volume() - 2 * inter;
-}
-
-export function acceptCandidates(kernel, source, candidates, opts = {}) {
-  const budget = opts.budget ?? DEFAULT_ATTEMPT_BUDGET;
-  const sourceVolume = source.volume();
-  const accepted = [];
-  // Counts CANDIDATE ATTEMPTS (one per pass through the `for` loop below), not real
-  // boolean calls — see that loop's own comment for the exact per-attempt cost, which
-  // is 0, 1, or 2 real booleans depending on the candidate's op and whether `current`
-  // is null. Reported back as `budgetSpent` (name kept as-is — see that field's own
-  // comment on why) rather than renamed to `attemptsSpent`.
-  let attempts = 0;
-  // Every candidate object that reached the loop body at least once — keyed by
-  // reference, not by `cand.key`/`cand.featureKey`, since this file never assumes a
-  // candidate carries either (test/describe-accept.test.js's own fixtures only give
-  // theirs a bare `key`, and other callers may give none at all). This is what lets a
-  // caller (describe.js) tell "budget ran out before this candidate ever got a turn"
-  // apart from "this candidate got a turn — every round it was in — and never won
-  // one" for whatever's left in `pending` at the end (fix round 2, IMPORTANT 2): a
-  // rejected feature and a budget-starved one both report `volumeShare: null` and
-  // are otherwise indistinguishable, which matters to a rebuilder deciding whether to
-  // retry with a bigger `--budget` or accept that a feature genuinely doesn't fit.
-  // NOTE on the one case this deliberately does NOT collapse (round 3 CRITICAL fix): a
-  // `cut` candidate that gets a turn while `current === null` (`"nothing to cut from
-  // yet"`, below) never has a gain computed for it, so it is NOT added here — only a
-  // candidate that actually ran a boolean (a real gain measurement) or whose `.build()`
-  // genuinely threw counts as attempted. Earlier this Set included the no-base-yet case
-  // too, which made a starved `--budget` report `"rejected"` for a feature the search
-  // simply never reached with a base to cut from — provably wrong, since raising the
-  // budget alone (no code change) turned that same feature into a real, positive share.
-  const attempted = new Set();
-
-  // The single bracket. `describe:accept` is deliberately its own partition name, not a
-  // display sub-part's: the cross-partition hash index still lets it ADOPT geometry the
-  // viewer already built, while its own eviction at end() cannot throw away what the
-  // viewer is showing. Same reasoning as oracle/build.js's `oracle:view:` naming.
-  kernel.beginSubPart?.("describe:accept");
-  try {
-    let current = null;                  // the reconstruction so far
-    let currentXor = sourceVolume;       // an empty reconstruction differs by the whole part
-    const pending = [...candidates];
-
-    while (pending.length && attempts < budget) {
-      let best = null;
-      for (const cand of pending) {
-        if (attempts >= budget) break;
-        // Real boolean cost of THIS attempt, not the `attempts` counter below (that
-        // counts the attempt itself, always by 1, regardless of how many WASM
-        // booleans it took) — spelled out here because it is not uniform and a
-        // reader sizing the budget against boolean-call cost needs the real number:
-        //   • op "cut",   current === null → 0 booleans (trial is set to null with
-        //     no kernel call at all — "nothing to cut from yet" — and skipped below)
-        //   • op "union", current === null → 1 boolean (no union call needed either,
-        //     trial IS piece; the only boolean is xorVolume's own intersect below)
-        //   • either op,  current !== null → 2 booleans (the cut/union that builds
-        //     `trial`, plus xorVolume's intersect)
-        // So budget=N bounds attempts, and — once any candidate has been accepted,
-        // which is the common case for a multi-feature part — real boolean work at
-        // roughly 2N, not N. Verified directly: a 4-candidate, 2-op-type search
-        // (1 accepted union then 1 accepted cut) reports `budgetSpent: 9` against
-        // 12 real boolean calls counted by wrapping the kernel.
-        let trial;
-        let noBaseYet = false;               // "nothing to cut from yet" — no gain measured
-        try {
-          const piece = cand.build();
-          if (current === null && cand.op === "cut") {
-            trial = null;
-            noBaseYet = true;
-          } else {
-            trial = current === null ? piece
-              : cand.op === "cut" ? current.cut(piece)
-              : current.union(piece);
-          }
-        } catch {
-          // A candidate whose geometry will not build is not an error — it is simply
-          // not a description of this mesh. Drop it and keep going.
-          trial = null;
-        }
-        attempts++;
-        // Only count this as a real attempt (accept.js's own contract with describe.js
-        // — see the Set's declaration comment) when a gain was actually measured or the
-        // candidate's own geometry genuinely failed to build. `noBaseYet` is neither: no
-        // boolean ever ran and no verdict was reached, so leaving it out of `attempted`
-        // is what lets describe.js report `"budget"` instead of `"rejected"` for a cut
-        // candidate that only ever got a turn before any base body existed — round 3's
-        // CRITICAL finding: with the old blanket `attempted.add(cand)` above, THIS is
-        // exactly the case that reported `"rejected"` (`--budget 2`, the washer fixture)
-        // for a feature that becomes a real 19% share at `--budget 3` — the search never
-        // rejected it, it just never got there.
-        if (!noBaseYet) attempted.add(cand);
-        if (!trial) continue;
-        const xor = xorVolume(trial, source);
-        const gain = currentXor - xor;
-        if (gain > sourceVolume * MIN_GAIN_FRACTION && (!best || gain > best.gain)) {
-          best = { cand, trial, xor, gain };
-        }
-      }
-      if (!best) break;                  // nothing left improves the reconstruction
-
-      current = best.trial;
-      currentXor = best.xor;
-      accepted.push({
-        candidate: best.cand,
-        gain: best.gain / sourceVolume,          // normalised: comparable across parts
-        cumulativeXor: currentXor,
-        order: accepted.length,
-      });
-      pending.splice(pending.indexOf(best.cand), 1);
-    }
-
-    const xorFraction = sourceVolume > 0 ? currentXor / sourceVolume : 1;
-    return {
-      accepted,
-      residual: { xorVolume: currentXor, xorFraction },
-      score: {
-        explainedVolumeFraction: Math.max(0, 1 - xorFraction),
-        xorFraction,
-        xorVolume: currentXor,
-      },
-      // Candidate attempts, not real boolean calls — see `attempts`'s own comment
-      // above and the per-attempt cost breakdown in the loop. Kept as `budgetSpent`
-      // (not renamed to `attemptsSpent`) because it is a documented cross-task
-      // interface field T12's orchestrator consumes by this exact name (SDD
-      // progress ledger, T10→T12 interface row); the field's MEANING is what moved,
-      // not its shape, so a rename here would be a breaking, undocumented surprise
-      // for that consumer rather than a fix.
-      budgetSpent: attempts,
-      budgetExceeded: attempts >= budget && pending.length > 0,
-      // Candidate OBJECTS (not keys) that reached at least one build+evaluate attempt
-      // — see this Set's own declaration comment above for why by-reference and what
-      // it does and doesn't distinguish. Every accepted candidate is trivially a
-      // member too (it can't have been accepted without at least one attempt); the
-      // caller only needs to consult this for candidates NOT in `accepted`.
-      attempted,
-    };
-  } finally {
-    kernel.endSubPart?.();
-  }
-}

package/src/framework/oracle/describe/features/dressups.js

@@ -1,173 +0,0 @@
-// Fillet and chamfer rules.
-//
-// Both are TRANSITION surfaces: narrow strips whose job is to soften the meeting of
-// two larger neighbours. That is what distinguishes them from a small functional
-// face, and it is why the rules test the strip's relationship to its neighbours
-// rather than its size alone. A 2mm-wide plane between two walls is a chamfer; a
-// 2mm-wide plane bounded by four other 2mm planes is just a small face.
-//
-// Fillet:  cylinder or torus, tangent to both of two PRIMARY neighbours (the arc
-//          convexity gives inside vs outside rounding).
-// Chamfer: plane OR cone (a countersink is a revolved chamfer), meeting each
-//          primary neighbour at a consistent angle that is neither ~0 nor ~90
-//          degrees.
-//
-// PRIMARY neighbours are the two LONGEST-shared-boundary arcs, not "however many
-// arcs this surface has total" (round 1 review: the original premise required
-// `arcs.length === 2`, which no finite straight chamfer/fillet can ever satisfy —
-// a chamfer cut along a box edge of finite length necessarily terminates against
-// two more end faces besides the two walls it actually blends, giving FOUR arcs,
-// not two; verified directly against a chamfered box, whose bevel plane has arcs
-// of length ~30mm to the two walls it blends and ~4.2mm to the two end caps it
-// merely runs into). Selecting by length picks out the two it actually blends and
-// treats the incidental end walls as exactly that: incidental, not disqualifying.
-//
-// TANGENCY, for a cylinder candidate, means its two PRIMARY arcs are STRAIGHT
-// (`kind === "line"`): a constant-radius fillet run along a straight edge is
-// tangent to its neighbours along a line parallel to its own axis. A CIRCULAR
-// primary arc between a cylinder and a plane means the opposite: the cylinder's
-// axis runs perpendicular to that plane, punching straight through it — a bore's
-// or a boss's mouth, not a tangent blend (verified directly against
-// annulusPlate(10,4,3,48): its bore is a plain cylinder with exactly two circular
-// arcs to the two larger cap planes, and without this check it satisfies every
-// other test here and gets reported as a fillet). A doubly-curved torus fillet's
-// own tangent arcs ARE genuinely circular (it blends a curved edge), so this
-// guard is cylinder-only.
-//
-// WIDTH is compared against the primary neighbours' own EXTENT as a length, not
-// an area (round 1 review: the original area-ratio test — this surface's area
-// against each neighbour's — silently drops an ordinary torus fillet as it grows,
-// because the neighbouring end cap shrinks by 2x the fillet radius as the fillet
-// widens, which erodes the AREA ratio far faster than the actual geometry
-// justifies; measured directly: r/R = 0.125 and 0.25 fillets, both completely
-// normal roundovers, missed entirely under the old area test). A dress-up is
-// narrow in ONE dimension, so the comparison is a length against a length: this
-// surface's own width (a fillet's radius; a chamfer's or countersink's area
-// divided by its longest primary arc) against the LARGER of the two primary
-// arcs' own measured radius (circular arcs — the natural "how big is the thing
-// this blends" reference; e.g. a fillet's tangent seam to its shaft lands almost
-// exactly on the shaft's own radius) or length (straight arcs, which have no
-// radius). Reusing the larger of the two, rather than requiring both
-// individually, matters because a fillet's two neighbours differ in this exact
-// reference by very close to the fillet's own radius (a torus fillet's tangent
-// circle on the flat-cap side is smaller than on the shaft side by ~r) — testing
-// against the smaller one would make the threshold tighter than the geometry
-// warrants.
-//
-// Pure leaf. See spec §2.5.
-import { arcsOf } from "../surface-graph.js";
-
-// A dress-up must be materially narrower than what it joins, or it is a face in
-// its own right. Ratio, not an absolute size, so it scales with the part.
-// Verified against a torus fillet sweep at r/R = 0.0625, 0.125 and 0.25 (all
-// pass with this threshold; the largest, r=2 against a shaft radius R=8, checks
-// 2 <= 8*0.34 = 2.72) while the washer bore (rejected by the tangency guard
-// above, not by this ratio) stays rejected regardless.
-const MAX_WIDTH_RATIO = 0.34;
-// Chamfer angle band: outside this it is a tangent continuation or a square corner.
-const MIN_CHAMFER_RAD = 0.15, MAX_CHAMFER_RAD = Math.PI / 2 - 0.15;
-const round3 = (v) => Math.round(v * 1000) / 1000;
-
-const byId = (graph) => new Map(graph.surfaces.map((s) => [s.id, s]));
-const other = (arc, id) => (arc.between[0] === id ? arc.between[1] : arc.between[0]);
-const dot = (a, b) => a[0]*b[0] + a[1]*b[1] + a[2]*b[2];
-// A primary arc's own reference length: its measured circle radius when curved,
-// or its own run length when straight (a straight arc has no radius to offer).
-const arcExtent = (arc) => arc.radius ?? arc.length;
-
-// A neighbour's own fitted geometry, not its segmentation surface id (round 2
-// review: `s0`/`s1` are assigned in triangle-DISCOVERY order — the same defect
-// prismatic.js's key had — so they renumber under a triangle-order permutation
-// of the same geometry, which must never change what a fillet/chamfer's own
-// key is). Covers every surface type a dress-up's primary neighbour can be;
-// `round3` absorbs the float-associativity noise a permuted summation/fit
-// order introduces (Task 4's own ruling, R29) — real geometry never differs at
-// 3-decimal precision, only float dust does.
-const vec3 = (a) => a.map(round3).join(",");
-function surfaceSignature(s) {
-  if (s.type === "plane") return `plane:${round3(s.fit.offset)}:${vec3(s.fit.normal)}`;
-  if (s.type === "cylinder") return `cylinder:${round3(s.fit.radius)}:${vec3(s.fit.axis.direction)}:${vec3(s.fit.axis.origin)}`;
-  if (s.type === "cone") return `cone:${round3(s.fit.halfAngle)}:${vec3(s.fit.apex)}:${vec3(s.fit.direction)}`;
-  if (s.type === "torus") return `torus:${round3(s.fit.majorRadius)}:${round3(s.fit.minorRadius)}:${vec3(s.fit.center)}`;
-  return `${s.type}:${round3(s.area)}`;   // any future surface type
-}
-// "|", not "-": a signature can itself contain "-" (a negative coordinate), and
-// this only ever needs to be a stable SORT key, never parsed back apart.
-const sortSignatures = (nbrs) => nbrs.map(surfaceSignature).sort().join("|");
-
-export function detectDressups(graph) {
-  const surfaces = byId(graph);
-  const out = [];
-
-  for (const s of graph.surfaces) {
-    const arcs = arcsOf(graph, s.id);
-    if (arcs.length < 2) continue;
-
-    // The two PRIMARY neighbours: the longest-shared-boundary arcs. Any other
-    // arcs (a finite chamfer/fillet's incidental end walls) are ignored below.
-    const primary = [...arcs].sort((a, b) => b.length - a.length).slice(0, 2);
-    const nbrs = primary.map((a) => surfaces.get(other(a, s.id)));
-    if (nbrs.some((n) => !n)) continue;
-
-    if (s.type === "cylinder" && !primary.every((a) => a.kind === "line")) continue;
-
-    const extent = Math.max(...primary.map(arcExtent));
-    const fitsAsStrip = (width) => width <= extent * MAX_WIDTH_RATIO;
-
-    if (s.type === "cylinder" || s.type === "torus") {
-      const radius = s.type === "cylinder" ? s.fit.radius : s.fit.minorRadius;
-      if (!fitsAsStrip(radius)) continue;
-      out.push({
-        id: null,
-        key: `fillet:${round3(radius)}:${sortSignatures(nbrs)}`,
-        type: "fillet", radius,
-        between: nbrs.map((n) => n.id),
-        convexity: primary[0].convexity,
-        surfaces: [s.id],
-        evidence: { arcs: arcs.length, widthRatio: round3(radius / extent), fitRms: s.fit.rms },
-      });
-      continue;
-    }
-
-    if (s.type === "plane" && nbrs.every((n) => n.type === "plane")) {
-      const angles = nbrs.map((n) => Math.acos(Math.max(-1, Math.min(1, Math.abs(dot(s.fit.normal, n.fit.normal))))));
-      if (!angles.every((a) => a > MIN_CHAMFER_RAD && a < MAX_CHAMFER_RAD)) continue;
-      // Strip width from the area and the longer of the two arcs — a chamfer is a
-      // ribbon, so area/length is its width.
-      const width = s.area / Math.max(primary[0].length, primary[1].length, 1e-9);
-      if (!fitsAsStrip(width)) continue;
-      out.push({
-        id: null,
-        key: `chamfer:${round3(width)}:${sortSignatures(nbrs)}`,
-        type: "chamfer", width, angle: (angles[0] + angles[1]) / 2,
-        between: nbrs.map((n) => n.id),
-        convexity: primary[0].convexity,
-        surfaces: [s.id],
-        evidence: { arcs: arcs.length, angles: angles.map(round3), fitRms: s.fit.rms },
-      });
-      continue;
-    }
-
-    // A countersink is a REVOLVED chamfer: a cone blending a bore into a face
-    // (or another cone) instead of a plane blending two walls. Its own conical
-    // half-angle already IS its blend angle (fit.js's fitCone recovers it
-    // directly), so unlike the plane branch above there's no pair of face
-    // normals to average — the cone's `halfAngle` cashes out to the same
-    // "angle from the material" the plane branch measures.
-    if (s.type === "cone") {
-      const width = s.area / Math.max(primary[0].length, primary[1].length, 1e-9);
-      if (!fitsAsStrip(width)) continue;
-      out.push({
-        id: null,
-        key: `chamfer:${round3(width)}:${sortSignatures(nbrs)}`,
-        type: "chamfer", width, angle: s.fit.halfAngle,
-        between: nbrs.map((n) => n.id),
-        convexity: primary[0].convexity,
-        surfaces: [s.id],
-        evidence: { arcs: arcs.length, halfAngle: round3(s.fit.halfAngle), fitRms: s.fit.rms },
-      });
-    }
-  }
-
-  return out.sort((a, b) => (a.key < b.key ? -1 : a.key > b.key ? 1 : 0));
-}