partforge 0.63.0 → 0.64.1

package/src/testing/step-mesh-thread.js

@@ -0,0 +1,15 @@
+// src/testing/step-mesh-thread.js — runs INSIDE the worker_thread only.
+import { parentPort, workerData } from "node:worker_threads";
+import { bootOcctKernel } from "./occt.js";
+
+const kernel = await bootOcctKernel();
+const out = [];
+const transfer = [];
+for (const { name, bytes, digest } of workerData) {
+  await kernel._registerImport({ name, digest, step: bytes });
+  const { positions, indices } = kernel.import(name).toIndexedMesh({ quality: "print" });
+  out.push({ name, digest, positions, indices });
+  transfer.push(positions.buffer, indices.buffer);
+}
+parentPort.postMessage(out, transfer);
+process.exit(0);

package/src/testing/step-mesh.js

@@ -0,0 +1,17 @@
+// STEP → triangle mesh for the Node crossover (Manifold part importing STEP).
+// OCCT boots in a worker_thread — a separate isolate is a separate WASM world,
+// so the "never both kernels in one process" invariant holds by construction.
+import { Worker } from "node:worker_threads";
+
+export function tessellateStepAssets(entries) {
+  return new Promise((resolve, reject) => {
+    const w = new Worker(new URL("./step-mesh-thread.js", import.meta.url),
+      { workerData: entries.map(({ name, bytes, digest }) => ({ name, bytes, digest })) });
+    w.once("message", (out) => {
+      resolve(new Map(out.map((m) => [m.name, { digest: m.digest, positions: m.positions, indices: m.indices }])));
+      w.terminate();
+    });
+    w.once("error", reject);
+    w.once("exit", (code) => { if (code !== 0) reject(new Error(`step tessellation thread exited ${code}`)); });
+  });
+}

package/types/kernel.d.ts

@@ -477,6 +477,12 @@ export interface GeometryKernel {
   hullChain(inputs: HullInput[]): Shape2D;
   /** STEP bytes — OCCT only (Manifold throws `KernelCapabilityError`). */
   toSTEP(named: Array<{ name: string; solid: Solid }>): Promise<ArrayBuffer>;
+  /**
+   * Imported geometry declared in the part's `imports` field, registered
+   * pre-build by the framework via the underscore-prefixed `_registerImport`
+   * side-channel (not a part author's calling surface).
+   */
+  import(name: string): Solid;
 
   // Backend-optional: the sub-part cache brackets and WASM lifetime hooks. Every
   // framework caller reaches these through `?.`, so a third-party backend may

package/types/part.d.ts

@@ -300,6 +300,14 @@ export interface SubPartDefinition<P = ResolvedParams, D = Derived> {
   enabled?: (p: P) => unknown;
   /** `false` = reference/preview-only: shown in the viewer, never exported. */
   exportable?: boolean;
+  /**
+   * Name of a declared `imports` entry this sub-part is held to. When set,
+   * `measure()` computes a `deviation` fact (symmetric-difference volume,
+   * volume delta %, bbox-corner drift) against that import's posed solid, and
+   * `verify.expect.<subpart>` may use the `refXorVolume` / `refVolumeDeltaPct`
+   * / `refBboxDelta` gate metrics.
+   */
+  reference?: string;
   /** Viewer-only override — `color` is `0xRRGGBB`, `opacity` is 0..1. */
   display?: { color?: number; opacity?: number };
   /** Filename / object name on export; defaults to the key. */
@@ -362,6 +370,12 @@ export interface SubPartExpectations {
   boundsMin?: Expectation;
   boundsMax?: Expectation;
   minWall?: Expectation;
+  /** Symmetric-difference volume vs. the sub-part's declared `reference` import. */
+  refXorVolume?: Expectation;
+  /** Percent volume delta vs. the sub-part's declared `reference` import. */
+  refVolumeDeltaPct?: Expectation;
+  /** Bounding-box corner drift `[dx, dy, dz]` vs. the sub-part's declared `reference` import. */
+  refBboxDelta?: Expectation;
 }
 
 /**