@faicad/faijs 0.13.0

package/dist/vendored/brepjs/topology/meshFns.js

@@ -0,0 +1,393 @@
+/**
+ * Meshing and export functions — functional replacements for Shape mesh/export methods.
+ */
+import { getKernel } from '../kernel/index.js';
+import { qualityDeflection } from '../kernel/quality.js';
+import { ok, err } from '../core/result.js';
+import { ioError } from '../core/errors.js';
+import { buildMeshCacheKey, getMeshForShape, setMeshForShape, buildEdgeMeshCacheKey, getEdgeMeshForShape, setEdgeMeshForShape, } from './meshCache.js';
+import { getFaceOrigins } from './shapeFns.js';
+import { getBounds, getSolids } from './topologyQueryFns.js';
+// Beyond this bounding-box diagonal (model units) the default deflection grows
+// linearly with size, keeping default meshes scale-invariant; below it the
+// absolute tier default applies unchanged. Quality deflections are absolute
+// model units tuned for ~unit-scale parts: adopting them unscaled at BIM
+// (mm) scale explodes a curved surface into 10^5-10^6 triangles and can
+// exhaust the WASM heap.
+const SCALE_INVARIANT_DIAGONAL = 10;
+export function scaleDefaultTolerance(base, shape) {
+    let diagonal;
+    try {
+        const b = getBounds(shape);
+        const dx = b.xMax - b.xMin;
+        const dy = b.yMax - b.yMin;
+        const dz = b.zMax - b.zMin;
+        diagonal = Math.sqrt(dx * dx + dy * dy + dz * dz);
+    }
+    catch {
+        return base;
+    }
+    return base * Math.max(1, diagonal / SCALE_INVARIANT_DIAGONAL);
+}
+// ---------------------------------------------------------------------------
+// Triangle mesh
+// ---------------------------------------------------------------------------
+/**
+ * Mesh a shape as a set of triangles for rendering.
+ *
+ * Results are cached by default (keyed by shape identity + tolerance parameters).
+ * Delegates to the kernel adapter's bulk C++ mesh extraction for performance.
+ *
+ * @returns A ShapeMesh containing typed arrays ready for GPU upload.
+ * @see toBufferGeometryData — convert to Three.js BufferGeometry format
+ */
+export function mesh(shape, opts = {}) {
+    // Unspecified deflection defaults to the active quality level (see
+    // withQuality / withTier), scaled with the shape's size beyond a 10-unit
+    // bounding diagonal (see scaleDefaultTolerance). The resolved value is a
+    // pure function of the shape, so it keys the cache like an explicit one.
+    const quality = qualityDeflection();
+    const { tolerance = scaleDefaultTolerance(quality.tolerance, shape), angularTolerance = quality.angularTolerance, skipNormals = false, includeUVs = false, cache = true, signal, } = opts;
+    signal?.throwIfAborted();
+    // Check cache first (uses WeakMap keyed by shape object to avoid hash collisions)
+    const cacheKey = buildMeshCacheKey(tolerance, angularTolerance, skipNormals, includeUVs);
+    if (cache) {
+        const cached = getMeshForShape(shape.wrapped, cacheKey);
+        if (cached)
+            return cached;
+    }
+    const result = getKernel().mesh(shape.wrapped, {
+        tolerance,
+        angularTolerance,
+        skipNormals,
+        includeUVs,
+        ...(signal ? { signal } : {}),
+    });
+    const origins = getFaceOrigins(shape);
+    const mesh = {
+        vertices: result.vertices,
+        normals: result.normals,
+        triangles: result.triangles,
+        uvs: result.uvs,
+        faceGroups: result.faceGroups.map((g) => ({
+            start: g.start,
+            count: g.count,
+            faceId: g.faceHash,
+            origin: origins?.get(g.faceHash) ?? 0,
+        })),
+    };
+    // Store in cache
+    if (cache) {
+        setMeshForShape(shape.wrapped, cacheKey, mesh);
+    }
+    return mesh;
+}
+// ---------------------------------------------------------------------------
+// Edge mesh (line segments)
+// ---------------------------------------------------------------------------
+/**
+ * Mesh the edges of a shape as line segments for wireframe rendering.
+ *
+ * Results are cached by default (keyed by shape identity + tolerance parameters).
+ *
+ * @returns An EdgeMesh containing line vertex positions and per-edge groups.
+ * @see toLineGeometryData — convert to Three.js LineSegments format
+ */
+export function meshEdges(shape, opts = {}) {
+    // Default deflection follows mesh(): quality level, scale-relative.
+    const quality = qualityDeflection();
+    const { tolerance = scaleDefaultTolerance(quality.tolerance, shape), angularTolerance = quality.angularTolerance, cache = true, } = opts;
+    // Check cache first (uses WeakMap keyed by shape object to avoid hash collisions)
+    const cacheKey = buildEdgeMeshCacheKey(tolerance, angularTolerance);
+    if (cache) {
+        const cached = getEdgeMeshForShape(shape.wrapped, cacheKey);
+        if (cached)
+            return cached;
+    }
+    const kernelResult = getKernel().meshEdges(shape.wrapped, tolerance, angularTolerance);
+    const result = {
+        lines: kernelResult.lines,
+        edgeGroups: kernelResult.edgeGroups.map((g) => ({
+            start: g.start,
+            count: g.count,
+            edgeId: g.edgeHash,
+        })),
+    };
+    // Store in cache
+    if (cache) {
+        setEdgeMeshForShape(shape.wrapped, cacheKey, result);
+    }
+    return result;
+}
+// ---------------------------------------------------------------------------
+// File export
+// ---------------------------------------------------------------------------
+/**
+ * Export a shape as a STEP file Blob.
+ *
+ * @returns Ok with a Blob (MIME type `application/STEP`), or Err on failure.
+ */
+/**
+ * Classify a thrown export error into three distinct cases:
+ * - the kernel throws "<FMT> export failed:" when the writer reports a non-success status;
+ * - a `WebAssembly.RuntimeError` means the writer trapped on geometry it could not serialize
+ *   (e.g. a degenerate sub-shape) — this can corrupt the kernel for the rest of the session,
+ *   so it must not be silently relabelled as a file-read issue;
+ * - anything else is an FS read failure on the V7 file path (write succeeded, readback threw).
+ */
+function exportError(e, fmt) {
+    if (e instanceof Error && e.message.startsWith(`${fmt} export failed`)) {
+        return ioError(`${fmt}_EXPORT_FAILED`, `Failed to write ${fmt} file`, e);
+    }
+    if (e instanceof WebAssembly.RuntimeError) {
+        return ioError(`${fmt}_EXPORT_CRASHED`, `${fmt} export crashed the kernel (${e.message}); the shape likely contains geometry the ${fmt} writer cannot serialize`, e);
+    }
+    return ioError(`${fmt}_FILE_READ_ERROR`, `Failed to read exported ${fmt} file`, e);
+}
+/**
+ * When a compound's bounds probe fails, localize the offending sub-solid(s) so the
+ * caller can heal or drop them. Returns a suffix for the error message; empty when
+ * the shape is a single solid or localization itself fails. Only reached on the
+ * error path, so the extra per-solid probes cost nothing in the happy case.
+ */
+function describeOffendingSolids(shape) {
+    let solids;
+    try {
+        solids = getSolids(shape);
+    }
+    catch {
+        return '';
+    }
+    if (solids.length <= 1)
+        return '';
+    const bad = [];
+    solids.forEach((solid, i) => {
+        try {
+            getBounds(solid);
+        }
+        catch (e) {
+            // Mirror probeSerializable: a TypeError is a programming bug, not degenerate geometry.
+            if (e instanceof TypeError)
+                throw e;
+            bad.push(i);
+        }
+    });
+    if (bad.length === 0) {
+        return `; could not localize the offending sub-solid among ${solids.length} solids`;
+    }
+    return `; offending sub-solid${bad.length > 1 ? 's' : ''} (of ${solids.length}): index ${bad.join(', ')}`;
+}
+/**
+ * Probe a shape's bounding box before handing it to the STEP/STL writer.
+ *
+ * Some sub-shapes pass `isValid`/`validSolid` yet are degenerate enough that the
+ * OCCT writer traps with a `WebAssembly.RuntimeError` (OOB) mid-transfer — which
+ * corrupts the Emscripten heap and poisons the kernel for the rest of the session
+ * (#1126). `getBounds` exercises the same geometry but fails *catchably*, so a
+ * cheap pre-export probe lets us return a clean `Err` instead of crashing.
+ * Heuristic, not universal: it only catches shapes whose bounding-box evaluation
+ * also throws.
+ *
+ * Note: the canonical #1126 shape (an annular-sector tread fused with a frenet
+ * helical rail) is NOT caught here — `getBounds` *succeeds* on it, as do
+ * `isValid`/`validSolid`/`mesh`/`measureArea`, and `autoHeal` cannot repair it.
+ * No known non-trapping check detects that BOPAlgo corruption; the only safety net
+ * for it is `exportError` classifying the writer's `WebAssembly.RuntimeError` as
+ * `*_EXPORT_CRASHED`. A real fix must come from the kernel (OCCT BOPAlgo).
+ */
+function probeSerializable(shape, fmt) {
+    try {
+        getBounds(shape);
+        return null;
+    }
+    catch (e) {
+        // A TypeError signals a caller/programming bug (e.g. a malformed handle), not
+        // unserializable geometry — let it surface rather than masking it as an export error.
+        if (e instanceof TypeError)
+            throw e;
+        return ioError(`${fmt}_EXPORT_UNSERIALIZABLE`, `${fmt} export aborted: the shape contains degenerate geometry the ${fmt} writer cannot serialize (bounding-box evaluation failed); export was skipped to avoid crashing the kernel${describeOffendingSolids(shape)}`, e);
+    }
+}
+export function exportSTEP(shape) {
+    const unserializable = probeSerializable(shape, 'STEP');
+    if (unserializable)
+        return err(unserializable);
+    try {
+        const stepString = getKernel().exportSTEP([shape.wrapped]);
+        return ok(new Blob([stepString], { type: 'application/STEP' }));
+    }
+    catch (e) {
+        return err(exportError(e, 'STEP'));
+    }
+}
+/**
+ * Export a shape as an STL file Blob.
+ *
+ * @returns Ok with a Blob (MIME type `application/sla`), or Err on failure.
+ */
+export function exportSTL(shape, opts = {}) {
+    // Default deflection follows mesh(): quality level, scale-relative.
+    const quality = qualityDeflection();
+    const { tolerance = scaleDefaultTolerance(quality.tolerance, shape), angularTolerance = quality.angularTolerance, binary = false, } = opts;
+    const unserializable = probeSerializable(shape, 'STL');
+    if (unserializable)
+        return err(unserializable);
+    try {
+        // Ensure shape has triangulation before export
+        if (!getKernel().hasTriangulation(shape.wrapped)) {
+            getKernel().meshShape(shape.wrapped, tolerance, angularTolerance);
+        }
+        const stlData = getKernel().exportSTL(shape.wrapped, binary, tolerance, angularTolerance);
+        return ok(new Blob([stlData], { type: 'application/sla' }));
+    }
+    catch (e) {
+        return err(exportError(e, 'STL'));
+    }
+}
+/**
+ * Export a shape as an IGES file Blob.
+ *
+ * @returns Ok with a Blob (MIME type `application/iges`), or Err on failure.
+ */
+export function exportIGES(shape) {
+    try {
+        const igesString = getKernel().exportIGES([shape.wrapped]);
+        return ok(new Blob([igesString], { type: 'application/iges' }));
+    }
+    catch (e) {
+        return err(ioError('IGES_EXPORT_FAILED', 'Failed to write IGES file', e));
+    }
+}
+/**
+ * Produce coarse (preview) + fine (export) meshes for a shape.
+ *
+ * Coarse mesh uses high tolerance for fast preview rendering.
+ * Fine mesh uses low tolerance for export quality.
+ */
+export function meshMultiLOD(shape, options) {
+    const coarseTol = options?.coarseTolerance ?? 0.5;
+    const fineTol = options?.fineTolerance ?? 0.05;
+    const angTol = options?.angularTolerance ?? 0.5;
+    const coarse = mesh(shape, { tolerance: coarseTol, angularTolerance: angTol });
+    const fine = mesh(shape, { tolerance: fineTol, angularTolerance: angTol * 0.2 });
+    return { coarse, fine };
+}
+function boundsDiagonal(shape) {
+    const b = getBounds(shape);
+    const dx = b.xMax - b.xMin;
+    const dy = b.yMax - b.yMin;
+    const dz = b.zMax - b.zMin;
+    // Fall back to 1 for a degenerate/empty bbox so relative tolerance stays positive.
+    return Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;
+}
+/** Per-level linear tolerances for a LOD ladder, coarse (large) → fine (small). */
+function lodTolerances(shape, options) {
+    let tolerances;
+    if (options.tolerances && options.tolerances.length > 0) {
+        tolerances = [...options.tolerances];
+    }
+    else {
+        const levels = Math.max(1, Math.floor(options.levels ?? 3));
+        const spacing = options.spacing ?? 4;
+        const relative = options.relativeTolerance ?? 0.0005;
+        const finest = relative * boundsDiagonal(shape) || Number.EPSILON;
+        tolerances = [];
+        for (let i = levels - 1; i >= 0; i--)
+            tolerances.push(finest * spacing ** i);
+    }
+    // Sorted so the documented coarse → fine order holds for explicit input and a spacing < 1.
+    tolerances.sort((a, b) => b - a);
+    return tolerances;
+}
+/** A level's angular deflection scales with how much coarser it is than the finest (capped at 1 rad). */
+function levelAngular(tolerance, finestTol, finestAngular) {
+    return Math.min(finestAngular * (tolerance / finestTol), 1);
+}
+/**
+ * Mesh a shape at several levels of detail, coarse → fine.
+ *
+ * Tolerances are **scale-relative** by default: the finest level is a fraction
+ * (`relativeTolerance`) of the shape's bounding-box diagonal and each coarser
+ * level steps up by `spacing`×, so the same call gives sensible detail whether
+ * the part is millimetres or metres. Pass `tolerances` for absolute control.
+ * Each level goes through {@link mesh}, so levels are cached individually.
+ *
+ * @returns LOD levels ordered coarsest → finest.
+ * @see toLODGeometryLevels — convert to THREE.LOD geometry data
+ */
+export function meshLODs(shape, options = {}) {
+    const finestAngular = options.angularTolerance ?? qualityDeflection().angularTolerance;
+    const cache = options.cache ?? true;
+    const tolerances = lodTolerances(shape, options);
+    const finestTol = Math.min(...tolerances);
+    return tolerances.map((tolerance) => {
+        const angularTolerance = levelAngular(tolerance, finestTol, finestAngular);
+        const levelMesh = mesh(shape, {
+            tolerance,
+            angularTolerance,
+            cache,
+            ...(options.signal ? { signal: options.signal } : {}),
+        });
+        return { tolerance, angularTolerance, mesh: levelMesh };
+    });
+}
+function nextTick() {
+    return new Promise((resolve) => {
+        setTimeout(resolve, 0);
+    });
+}
+/**
+ * Mesh a shape at several levels of detail, delivering them over time coarse →
+ * fine instead of all at once — so a viewer paints the coarse preview first and
+ * refines as finer levels land.
+ *
+ * The coarsest level is meshed first and reported via `onLevel`; control then
+ * yields to the event loop before each finer (heavier) level so the UI stays
+ * responsive. Each level is meshed synchronously on the calling thread by
+ * default; pass `meshLevel` to offload finer levels (e.g. to a worker). An
+ * aborted `signal` stops refinement and resolves with the levels produced so far.
+ *
+ * @returns the delivered LOD levels, coarsest → finest.
+ * @see meshLODs — the synchronous, all-at-once variant
+ */
+export async function meshLODsProgressive(shape, options = {}) {
+    const finestAngular = options.angularTolerance ?? qualityDeflection().angularTolerance;
+    const cache = options.cache ?? true;
+    const meshLevel = options.meshLevel ??
+        ((s, tolerance, angularTolerance) => mesh(s, {
+            tolerance,
+            angularTolerance,
+            cache,
+            ...(options.signal ? { signal: options.signal } : {}),
+        }));
+    const tolerances = lodTolerances(shape, options);
+    const finestTol = Math.min(...tolerances);
+    const results = [];
+    for (const [index, tolerance] of tolerances.entries()) {
+        if (options.signal?.aborted)
+            break;
+        const angularTolerance = levelAngular(tolerance, finestTol, finestAngular);
+        let levelMesh;
+        try {
+            levelMesh = await meshLevel(shape, tolerance, angularTolerance);
+        }
+        catch (e) {
+            // An async (e.g. worker-backed) meshLevel may reject when it observes the
+            // abort; treat that as a clean stop and keep the levels already produced.
+            // Rethrow a genuine meshing failure.
+            if (options.signal?.aborted)
+                break;
+            throw e;
+        }
+        // A level that finished meshing is always delivered; abort stops the next one.
+        const level = { tolerance, angularTolerance, mesh: levelMesh };
+        results.push(level);
+        options.onLevel?.(level, index);
+        if (options.signal?.aborted || index === tolerances.length - 1)
+            break;
+        // Yield before the next (finer, heavier) level so the caller can paint.
+        await nextTick();
+    }
+    return results;
+}
+//# sourceMappingURL=meshFns.js.map

package/dist/vendored/brepjs/topology/meshFns.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"meshFns.js","sourceRoot":"","sources":["../../../../src/vendored/brepjs/topology/meshFns.ts"],"names":[],"mappings":"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","sourcesContent":["/**\n * Meshing and export functions — functional replacements for Shape mesh/export methods.\n */\n\nimport { getKernel } from '../kernel/index.js';\nimport { qualityDeflection } from '../kernel/quality.js';\nimport type { AnyShape, Dimension } from '../core/shapeTypes.js';\nimport { type Result, ok, err } from '../core/result.js';\nimport { ioError, type BrepError } from '../core/errors.js';\n\nimport {\n  buildMeshCacheKey,\n  getMeshForShape,\n  setMeshForShape,\n  buildEdgeMeshCacheKey,\n  getEdgeMeshForShape,\n  setEdgeMeshForShape,\n} from './meshCache.js';\nimport { getFaceOrigins } from './shapeFns.js';\nimport { getBounds, getSolids } from './topologyQueryFns.js';\n\n// ---------------------------------------------------------------------------\n// Mesh types\n// ---------------------------------------------------------------------------\n\n/** Triangle mesh data extracted from a shape, ready for GPU rendering. */\nexport interface ShapeMesh {\n  /** Triangle vertex indices (3 per triangle). */\n  triangles: Uint32Array;\n  /** Flat array of vertex positions (x,y,z interleaved). */\n  vertices: Float32Array;\n  /** Flat array of vertex normals (x,y,z interleaved). */\n  normals: Float32Array;\n  /** Flat array of UV coordinates (u,v interleaved), empty if not requested. */\n  uvs: Float32Array;\n  /** Per-face triangle index ranges for multi-material rendering. */\n  faceGroups: { start: number; count: number; faceId: number; origin: number }[];\n}\n\n/** Line segment mesh data for edge rendering (wireframe). */\nexport interface EdgeMesh {\n  /** Flat array of line vertex positions (x,y,z interleaved, 2 vertices per segment). */\n  lines: Float32Array;\n  /** Per-edge line segment index ranges for highlighting individual edges. */\n  edgeGroups: { start: number; count: number; edgeId: number }[];\n}\n\n/** Shared options for meshing operations. */\nexport interface MeshOptions {\n  /** Linear deflection tolerance. Smaller = finer mesh. Defaults to the active\n   *  quality level, scaled with the shape's bounding-box diagonal beyond 10\n   *  model units so default meshes stay scale-invariant. */\n  tolerance?: number;\n  /** Angular deflection tolerance in radians. Smaller = finer mesh on curved surfaces. Defaults to the active quality level. */\n  angularTolerance?: number;\n  /** Abort signal to cancel mesh generation between face iterations. */\n  signal?: AbortSignal;\n}\n\n// Beyond this bounding-box diagonal (model units) the default deflection grows\n// linearly with size, keeping default meshes scale-invariant; below it the\n// absolute tier default applies unchanged. Quality deflections are absolute\n// model units tuned for ~unit-scale parts: adopting them unscaled at BIM\n// (mm) scale explodes a curved surface into 10^5-10^6 triangles and can\n// exhaust the WASM heap.\nconst SCALE_INVARIANT_DIAGONAL = 10;\n\nexport function scaleDefaultTolerance(base: number, shape: AnyShape<Dimension>): number {\n  let diagonal: number;\n  try {\n    const b = getBounds(shape);\n    const dx = b.xMax - b.xMin;\n    const dy = b.yMax - b.yMin;\n    const dz = b.zMax - b.zMin;\n    diagonal = Math.sqrt(dx * dx + dy * dy + dz * dz);\n  } catch {\n    return base;\n  }\n  return base * Math.max(1, diagonal / SCALE_INVARIANT_DIAGONAL);\n}\n\n// ---------------------------------------------------------------------------\n// Triangle mesh\n// ---------------------------------------------------------------------------\n\n/**\n * Mesh a shape as a set of triangles for rendering.\n *\n * Results are cached by default (keyed by shape identity + tolerance parameters).\n * Delegates to the kernel adapter's bulk C++ mesh extraction for performance.\n *\n * @returns A ShapeMesh containing typed arrays ready for GPU upload.\n * @see toBufferGeometryData — convert to Three.js BufferGeometry format\n */\nexport function mesh(\n  shape: AnyShape<Dimension>,\n  opts: MeshOptions & { skipNormals?: boolean; includeUVs?: boolean; cache?: boolean } = {}\n): ShapeMesh {\n  // Unspecified deflection defaults to the active quality level (see\n  // withQuality / withTier), scaled with the shape's size beyond a 10-unit\n  // bounding diagonal (see scaleDefaultTolerance). The resolved value is a\n  // pure function of the shape, so it keys the cache like an explicit one.\n  const quality = qualityDeflection();\n  const {\n    tolerance = scaleDefaultTolerance(quality.tolerance, shape),\n    angularTolerance = quality.angularTolerance,\n    skipNormals = false,\n    includeUVs = false,\n    cache = true,\n    signal,\n  } = opts;\n  signal?.throwIfAborted();\n  // Check cache first (uses WeakMap keyed by shape object to avoid hash collisions)\n  const cacheKey = buildMeshCacheKey(tolerance, angularTolerance, skipNormals, includeUVs);\n  if (cache) {\n    const cached = getMeshForShape(shape.wrapped, cacheKey);\n    if (cached) return cached;\n  }\n\n  const result = getKernel().mesh(shape.wrapped, {\n    tolerance,\n    angularTolerance,\n    skipNormals,\n    includeUVs,\n    ...(signal ? { signal } : {}),\n  });\n\n  const origins = getFaceOrigins(shape);\n  const mesh: ShapeMesh = {\n    vertices: result.vertices,\n    normals: result.normals,\n    triangles: result.triangles,\n    uvs: result.uvs,\n    faceGroups: result.faceGroups.map((g) => ({\n      start: g.start,\n      count: g.count,\n      faceId: g.faceHash,\n      origin: origins?.get(g.faceHash) ?? 0,\n    })),\n  };\n\n  // Store in cache\n  if (cache) {\n    setMeshForShape(shape.wrapped, cacheKey, mesh);\n  }\n\n  return mesh;\n}\n\n// ---------------------------------------------------------------------------\n// Edge mesh (line segments)\n// ---------------------------------------------------------------------------\n\n/**\n * Mesh the edges of a shape as line segments for wireframe rendering.\n *\n * Results are cached by default (keyed by shape identity + tolerance parameters).\n *\n * @returns An EdgeMesh containing line vertex positions and per-edge groups.\n * @see toLineGeometryData — convert to Three.js LineSegments format\n */\nexport function meshEdges(\n  shape: AnyShape<Dimension>,\n  opts: MeshOptions & { cache?: boolean } = {}\n): EdgeMesh {\n  // Default deflection follows mesh(): quality level, scale-relative.\n  const quality = qualityDeflection();\n  const {\n    tolerance = scaleDefaultTolerance(quality.tolerance, shape),\n    angularTolerance = quality.angularTolerance,\n    cache = true,\n  } = opts;\n  // Check cache first (uses WeakMap keyed by shape object to avoid hash collisions)\n  const cacheKey = buildEdgeMeshCacheKey(tolerance, angularTolerance);\n  if (cache) {\n    const cached = getEdgeMeshForShape(shape.wrapped, cacheKey);\n    if (cached) return cached;\n  }\n\n  const kernelResult = getKernel().meshEdges(shape.wrapped, tolerance, angularTolerance);\n\n  const result: EdgeMesh = {\n    lines: kernelResult.lines,\n    edgeGroups: kernelResult.edgeGroups.map((g) => ({\n      start: g.start,\n      count: g.count,\n      edgeId: g.edgeHash,\n    })),\n  };\n\n  // Store in cache\n  if (cache) {\n    setEdgeMeshForShape(shape.wrapped, cacheKey, result);\n  }\n\n  return result;\n}\n\n// ---------------------------------------------------------------------------\n// File export\n// ---------------------------------------------------------------------------\n\n/**\n * Export a shape as a STEP file Blob.\n *\n * @returns Ok with a Blob (MIME type `application/STEP`), or Err on failure.\n */\n/**\n * Classify a thrown export error into three distinct cases:\n * - the kernel throws \"<FMT> export failed:\" when the writer reports a non-success status;\n * - a `WebAssembly.RuntimeError` means the writer trapped on geometry it could not serialize\n *   (e.g. a degenerate sub-shape) — this can corrupt the kernel for the rest of the session,\n *   so it must not be silently relabelled as a file-read issue;\n * - anything else is an FS read failure on the V7 file path (write succeeded, readback threw).\n */\nfunction exportError(e: unknown, fmt: 'STEP' | 'STL'): BrepError {\n  if (e instanceof Error && e.message.startsWith(`${fmt} export failed`)) {\n    return ioError(`${fmt}_EXPORT_FAILED`, `Failed to write ${fmt} file`, e);\n  }\n  if (e instanceof WebAssembly.RuntimeError) {\n    return ioError(\n      `${fmt}_EXPORT_CRASHED`,\n      `${fmt} export crashed the kernel (${e.message}); the shape likely contains geometry the ${fmt} writer cannot serialize`,\n      e\n    );\n  }\n  return ioError(`${fmt}_FILE_READ_ERROR`, `Failed to read exported ${fmt} file`, e);\n}\n\n/**\n * When a compound's bounds probe fails, localize the offending sub-solid(s) so the\n * caller can heal or drop them. Returns a suffix for the error message; empty when\n * the shape is a single solid or localization itself fails. Only reached on the\n * error path, so the extra per-solid probes cost nothing in the happy case.\n */\nfunction describeOffendingSolids(shape: AnyShape<Dimension>): string {\n  let solids;\n  try {\n    solids = getSolids(shape);\n  } catch {\n    return '';\n  }\n  if (solids.length <= 1) return '';\n  const bad: number[] = [];\n  solids.forEach((solid, i) => {\n    try {\n      getBounds(solid);\n    } catch (e) {\n      // Mirror probeSerializable: a TypeError is a programming bug, not degenerate geometry.\n      if (e instanceof TypeError) throw e;\n      bad.push(i);\n    }\n  });\n  if (bad.length === 0) {\n    return `; could not localize the offending sub-solid among ${solids.length} solids`;\n  }\n  return `; offending sub-solid${bad.length > 1 ? 's' : ''} (of ${solids.length}): index ${bad.join(', ')}`;\n}\n\n/**\n * Probe a shape's bounding box before handing it to the STEP/STL writer.\n *\n * Some sub-shapes pass `isValid`/`validSolid` yet are degenerate enough that the\n * OCCT writer traps with a `WebAssembly.RuntimeError` (OOB) mid-transfer — which\n * corrupts the Emscripten heap and poisons the kernel for the rest of the session\n * (#1126). `getBounds` exercises the same geometry but fails *catchably*, so a\n * cheap pre-export probe lets us return a clean `Err` instead of crashing.\n * Heuristic, not universal: it only catches shapes whose bounding-box evaluation\n * also throws.\n *\n * Note: the canonical #1126 shape (an annular-sector tread fused with a frenet\n * helical rail) is NOT caught here — `getBounds` *succeeds* on it, as do\n * `isValid`/`validSolid`/`mesh`/`measureArea`, and `autoHeal` cannot repair it.\n * No known non-trapping check detects that BOPAlgo corruption; the only safety net\n * for it is `exportError` classifying the writer's `WebAssembly.RuntimeError` as\n * `*_EXPORT_CRASHED`. A real fix must come from the kernel (OCCT BOPAlgo).\n */\nfunction probeSerializable(shape: AnyShape<Dimension>, fmt: 'STEP' | 'STL'): BrepError | null {\n  try {\n    getBounds(shape);\n    return null;\n  } catch (e) {\n    // A TypeError signals a caller/programming bug (e.g. a malformed handle), not\n    // unserializable geometry — let it surface rather than masking it as an export error.\n    if (e instanceof TypeError) throw e;\n    return ioError(\n      `${fmt}_EXPORT_UNSERIALIZABLE`,\n      `${fmt} export aborted: the shape contains degenerate geometry the ${fmt} writer cannot serialize (bounding-box evaluation failed); export was skipped to avoid crashing the kernel${describeOffendingSolids(shape)}`,\n      e\n    );\n  }\n}\n\nexport function exportSTEP(shape: AnyShape<Dimension>): Result<Blob> {\n  const unserializable = probeSerializable(shape, 'STEP');\n  if (unserializable) return err(unserializable);\n  try {\n    const stepString = getKernel().exportSTEP([shape.wrapped]);\n    return ok(new Blob([stepString], { type: 'application/STEP' }));\n  } catch (e) {\n    return err(exportError(e, 'STEP'));\n  }\n}\n\n/**\n * Export a shape as an STL file Blob.\n *\n * @returns Ok with a Blob (MIME type `application/sla`), or Err on failure.\n */\nexport function exportSTL(\n  shape: AnyShape<Dimension>,\n  opts: MeshOptions & { binary?: boolean } = {}\n): Result<Blob> {\n  // Default deflection follows mesh(): quality level, scale-relative.\n  const quality = qualityDeflection();\n  const {\n    tolerance = scaleDefaultTolerance(quality.tolerance, shape),\n    angularTolerance = quality.angularTolerance,\n    binary = false,\n  } = opts;\n  const unserializable = probeSerializable(shape, 'STL');\n  if (unserializable) return err(unserializable);\n  try {\n    // Ensure shape has triangulation before export\n    if (!getKernel().hasTriangulation(shape.wrapped)) {\n      getKernel().meshShape(shape.wrapped, tolerance, angularTolerance);\n    }\n    const stlData = getKernel().exportSTL(shape.wrapped, binary, tolerance, angularTolerance);\n    return ok(new Blob([stlData], { type: 'application/sla' }));\n  } catch (e) {\n    return err(exportError(e, 'STL'));\n  }\n}\n\n/**\n * Export a shape as an IGES file Blob.\n *\n * @returns Ok with a Blob (MIME type `application/iges`), or Err on failure.\n */\nexport function exportIGES(shape: AnyShape<Dimension>): Result<Blob> {\n  try {\n    const igesString = getKernel().exportIGES([shape.wrapped]);\n    return ok(new Blob([igesString], { type: 'application/iges' }));\n  } catch (e) {\n    return err(ioError('IGES_EXPORT_FAILED', 'Failed to write IGES file', e));\n  }\n}\n\n// ---------------------------------------------------------------------------\n// Multi-LOD meshing\n// ---------------------------------------------------------------------------\n\nexport interface MultiLODMesh {\n  readonly coarse: ShapeMesh;\n  readonly fine: ShapeMesh;\n}\n\n/**\n * Produce coarse (preview) + fine (export) meshes for a shape.\n *\n * Coarse mesh uses high tolerance for fast preview rendering.\n * Fine mesh uses low tolerance for export quality.\n */\nexport function meshMultiLOD(\n  shape: AnyShape<Dimension>,\n  options?: {\n    readonly coarseTolerance?: number | undefined;\n    readonly fineTolerance?: number | undefined;\n    readonly angularTolerance?: number | undefined;\n  }\n): MultiLODMesh {\n  const coarseTol = options?.coarseTolerance ?? 0.5;\n  const fineTol = options?.fineTolerance ?? 0.05;\n  const angTol = options?.angularTolerance ?? 0.5;\n\n  const coarse = mesh(shape, { tolerance: coarseTol, angularTolerance: angTol });\n  const fine = mesh(shape, { tolerance: fineTol, angularTolerance: angTol * 0.2 });\n\n  return { coarse, fine };\n}\n\n// ---------------------------------------------------------------------------\n// N-level scale-relative LOD meshing\n// ---------------------------------------------------------------------------\n\n/** One level of a multi-resolution mesh: the geometry plus the tolerances it was meshed at. */\nexport interface LODMesh {\n  /** Linear deflection (model units) used for this level. */\n  readonly tolerance: number;\n  /** Angular deflection (radians) used for this level. */\n  readonly angularTolerance: number;\n  /** The meshed geometry at this level. */\n  readonly mesh: ShapeMesh;\n}\n\n/** Options for {@link meshLODs}. */\nexport interface MeshLODsOptions {\n  /** Number of levels, coarsest → finest (>= 1). Default 3. Ignored when `tolerances` is given. */\n  readonly levels?: number;\n  /**\n   * The finest level's linear tolerance as a fraction of the shape's bounding-box\n   * diagonal, so detail is scale-invariant across part sizes. Default 0.0005\n   * (0.05% of the diagonal). Ignored when `tolerances` is given.\n   */\n  readonly relativeTolerance?: number;\n  /**\n   * Geometric ratio between successive levels: each coarser level's tolerance is\n   * `spacing`× the next finer one. Default 4. Ignored when `tolerances` is given.\n   */\n  readonly spacing?: number;\n  /** Explicit absolute linear tolerances (one per level). Overrides `levels`/`relativeTolerance`/`spacing`; sorted coarse → fine. */\n  readonly tolerances?: readonly number[];\n  /** The finest level's angular deflection (radians). Defaults to the active quality level; coarser levels scale up with the tolerance ratio (capped at 1 rad). */\n  readonly angularTolerance?: number;\n  /** Abort signal forwarded to each level's mesh call. */\n  readonly signal?: AbortSignal;\n  /** Whether to use the mesh cache per level. Default true. */\n  readonly cache?: boolean;\n}\n\nfunction boundsDiagonal(shape: AnyShape<Dimension>): number {\n  const b = getBounds(shape);\n  const dx = b.xMax - b.xMin;\n  const dy = b.yMax - b.yMin;\n  const dz = b.zMax - b.zMin;\n  // Fall back to 1 for a degenerate/empty bbox so relative tolerance stays positive.\n  return Math.sqrt(dx * dx + dy * dy + dz * dz) || 1;\n}\n\n/** Per-level linear tolerances for a LOD ladder, coarse (large) → fine (small). */\nfunction lodTolerances(shape: AnyShape<Dimension>, options: MeshLODsOptions): number[] {\n  let tolerances: number[];\n  if (options.tolerances && options.tolerances.length > 0) {\n    tolerances = [...options.tolerances];\n  } else {\n    const levels = Math.max(1, Math.floor(options.levels ?? 3));\n    const spacing = options.spacing ?? 4;\n    const relative = options.relativeTolerance ?? 0.0005;\n    const finest = relative * boundsDiagonal(shape) || Number.EPSILON;\n    tolerances = [];\n    for (let i = levels - 1; i >= 0; i--) tolerances.push(finest * spacing ** i);\n  }\n  // Sorted so the documented coarse → fine order holds for explicit input and a spacing < 1.\n  tolerances.sort((a, b) => b - a);\n  return tolerances;\n}\n\n/** A level's angular deflection scales with how much coarser it is than the finest (capped at 1 rad). */\nfunction levelAngular(tolerance: number, finestTol: number, finestAngular: number): number {\n  return Math.min(finestAngular * (tolerance / finestTol), 1);\n}\n\n/**\n * Mesh a shape at several levels of detail, coarse → fine.\n *\n * Tolerances are **scale-relative** by default: the finest level is a fraction\n * (`relativeTolerance`) of the shape's bounding-box diagonal and each coarser\n * level steps up by `spacing`×, so the same call gives sensible detail whether\n * the part is millimetres or metres. Pass `tolerances` for absolute control.\n * Each level goes through {@link mesh}, so levels are cached individually.\n *\n * @returns LOD levels ordered coarsest → finest.\n * @see toLODGeometryLevels — convert to THREE.LOD geometry data\n */\nexport function meshLODs(shape: AnyShape<Dimension>, options: MeshLODsOptions = {}): LODMesh[] {\n  const finestAngular = options.angularTolerance ?? qualityDeflection().angularTolerance;\n  const cache = options.cache ?? true;\n  const tolerances = lodTolerances(shape, options);\n  const finestTol = Math.min(...tolerances);\n  return tolerances.map((tolerance) => {\n    const angularTolerance = levelAngular(tolerance, finestTol, finestAngular);\n    const levelMesh = mesh(shape, {\n      tolerance,\n      angularTolerance,\n      cache,\n      ...(options.signal ? { signal: options.signal } : {}),\n    });\n    return { tolerance, angularTolerance, mesh: levelMesh };\n  });\n}\n\n// ---------------------------------------------------------------------------\n// Progressive (async) LOD meshing\n// ---------------------------------------------------------------------------\n\n/**\n * Mesh one LOD level. Defaults to the synchronous main-thread {@link mesh}; pass\n * an async implementation (e.g. one that serializes the shape with `toBREP` and\n * meshes it on a worker) to refine finer levels off the main thread.\n */\nexport type MeshLevelFn = (\n  shape: AnyShape<Dimension>,\n  tolerance: number,\n  angularTolerance: number\n) => ShapeMesh | Promise<ShapeMesh>;\n\n/** Options for {@link meshLODsProgressive}. */\nexport interface MeshLODsProgressiveOptions extends MeshLODsOptions {\n  /**\n   * Called as each level finishes, coarsest first, so a viewer can show the\n   * coarse preview immediately and swap in finer meshes as they arrive.\n   */\n  readonly onLevel?: (level: LODMesh, index: number) => void;\n  /** How to mesh one level. Defaults to the synchronous main-thread {@link mesh}. */\n  readonly meshLevel?: MeshLevelFn;\n}\n\nfunction nextTick(): Promise<void> {\n  return new Promise((resolve) => {\n    setTimeout(resolve, 0);\n  });\n}\n\n/**\n * Mesh a shape at several levels of detail, delivering them over time coarse →\n * fine instead of all at once — so a viewer paints the coarse preview first and\n * refines as finer levels land.\n *\n * The coarsest level is meshed first and reported via `onLevel`; control then\n * yields to the event loop before each finer (heavier) level so the UI stays\n * responsive. Each level is meshed synchronously on the calling thread by\n * default; pass `meshLevel` to offload finer levels (e.g. to a worker). An\n * aborted `signal` stops refinement and resolves with the levels produced so far.\n *\n * @returns the delivered LOD levels, coarsest → finest.\n * @see meshLODs — the synchronous, all-at-once variant\n */\nexport async function meshLODsProgressive(\n  shape: AnyShape<Dimension>,\n  options: MeshLODsProgressiveOptions = {}\n): Promise<LODMesh[]> {\n  const finestAngular = options.angularTolerance ?? qualityDeflection().angularTolerance;\n  const cache = options.cache ?? true;\n  const meshLevel: MeshLevelFn =\n    options.meshLevel ??\n    ((s, tolerance, angularTolerance) =>\n      mesh(s, {\n        tolerance,\n        angularTolerance,\n        cache,\n        ...(options.signal ? { signal: options.signal } : {}),\n      }));\n\n  const tolerances = lodTolerances(shape, options);\n  const finestTol = Math.min(...tolerances);\n  const results: LODMesh[] = [];\n\n  for (const [index, tolerance] of tolerances.entries()) {\n    if (options.signal?.aborted) break;\n    const angularTolerance = levelAngular(tolerance, finestTol, finestAngular);\n    let levelMesh: ShapeMesh;\n    try {\n      levelMesh = await meshLevel(shape, tolerance, angularTolerance);\n    } catch (e) {\n      // An async (e.g. worker-backed) meshLevel may reject when it observes the\n      // abort; treat that as a clean stop and keep the levels already produced.\n      // Rethrow a genuine meshing failure.\n      if (options.signal?.aborted) break;\n      throw e;\n    }\n    // A level that finished meshing is always delivered; abort stops the next one.\n    const level: LODMesh = { tolerance, angularTolerance, mesh: levelMesh };\n    results.push(level);\n    options.onLevel?.(level, index);\n    if (options.signal?.aborted || index === tolerances.length - 1) break;\n    // Yield before the next (finer, heavier) level so the caller can paint.\n    await nextTick();\n  }\n  return results;\n}\n"]}

package/dist/vendored/brepjs/topology/metadata/colorFns.d.ts

@@ -0,0 +1,41 @@
+/**
+ * Shape-attached colors — assign RGBA colors to whole shapes or individual
+ * faces, persisting through boolean operations and modifiers via propagation.
+ *
+ * Follows the same WeakMap + HashCode pattern as faceTagFns.ts.
+ */
+import type { ShapeEvolution } from '../../kernel/types.js';
+import type { AnyShape, Dimension, Face } from '../../core/shapeTypes.js';
+/** RGBA color as 0-1 floats. */
+export type Color = [number, number, number, number];
+/** Accepted color inputs: hex string, RGB tuple, or RGBA tuple. */
+export type ColorInput = string | [number, number, number] | [number, number, number, number];
+/** O(1) check whether a shape has any color metadata (shape or face level). */
+export declare function hasColorMetadata(shape: AnyShape<Dimension>): boolean;
+/** Parse any accepted color input into canonical RGBA (exported so content-
+ *  addressed consumers can canonicalize before hashing). */
+export declare function parseColor(input: ColorInput): Color;
+/**
+ * Set a whole-shape color (stored externally via WeakMap).
+ * Returns the same shape reference.
+ */
+export declare function colorShape<T extends AnyShape<Dimension>>(shape: T, color: ColorInput): T;
+/**
+ * Set per-face colors on a shape.
+ * Returns the same shape reference.
+ */
+export declare function colorFaces<T extends AnyShape<Dimension>>(shape: T, faces: Face<Dimension>[], color: ColorInput): T;
+/**
+ * Get the whole-shape color, or undefined if none set.
+ */
+export declare function getShapeColor(shape: AnyShape<Dimension>): Color | undefined;
+/**
+ * Get the color of a specific face, or undefined if none set.
+ */
+export declare function getFaceColor(shape: AnyShape<Dimension>, face: Face<Dimension>): Color | undefined;
+/**
+ * Propagate colors from input shapes to a result shape using a
+ * kernel-provided ShapeEvolution record (no direct kernel op access needed).
+ */
+export declare function propagateColorsFromEvolution(evolution: ShapeEvolution, inputs: readonly AnyShape<Dimension>[], result: AnyShape<Dimension>): void;
+//# sourceMappingURL=colorFns.d.ts.map

package/dist/vendored/brepjs/topology/metadata/colorFns.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"colorFns.d.ts","sourceRoot":"","sources":["../../../../../src/vendored/brepjs/topology/metadata/colorFns.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAEH,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,uBAAuB,CAAC;AAE5D,OAAO,KAAK,EAAE,QAAQ,EAAE,SAAS,EAAE,IAAI,EAAE,MAAM,0BAA0B,CAAC;AAO1E,gCAAgC;AAChC,MAAM,MAAM,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAErD,mEAAmE;AACnE,MAAM,MAAM,UAAU,GAAG,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAC;AAY9F,+EAA+E;AAC/E,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,OAAO,CAEpE;AAeD;4DAC4D;AAC5D,wBAAgB,UAAU,CAAC,KAAK,EAAE,UAAU,GAAG,KAAK,CAqBnD;AAMD;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,QAAQ,CAAC,SAAS,CAAC,EAAE,KAAK,EAAE,CAAC,EAAE,KAAK,EAAE,UAAU,GAAG,CAAC,CAGxF;AAED;;;GAGG;AACH,wBAAgB,UAAU,CAAC,CAAC,SAAS,QAAQ,CAAC,SAAS,CAAC,EACtD,KAAK,EAAE,CAAC,EACR,KAAK,EAAE,IAAI,CAAC,SAAS,CAAC,EAAE,EACxB,KAAK,EAAE,UAAU,GAChB,CAAC,CAOH;AAED;;GAEG;AACH,wBAAgB,aAAa,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,GAAG,KAAK,GAAG,SAAS,CAE3E;AAED;;GAEG;AACH,wBAAgB,YAAY,CAAC,KAAK,EAAE,QAAQ,CAAC,SAAS,CAAC,EAAE,IAAI,EAAE,IAAI,CAAC,SAAS,CAAC,GAAG,KAAK,GAAG,SAAS,CAIjG;AAED;;;GAGG;AACH,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,cAAc,EACzB,MAAM,EAAE,SAAS,QAAQ,CAAC,SAAS,CAAC,EAAE,EACtC,MAAM,EAAE,QAAQ,CAAC,SAAS,CAAC,GAC1B,IAAI,CA+BN"}

package/dist/vendored/brepjs/topology/metadata/colorFns.js

@@ -0,0 +1,128 @@
+/**
+ * Shape-attached colors — assign RGBA colors to whole shapes or individual
+ * faces, persisting through boolean operations and modifiers via propagation.
+ *
+ * Follows the same WeakMap + HashCode pattern as faceTagFns.ts.
+ */
+import { getKernel } from '../../kernel/index.js';
+import { HASH_CODE_MAX } from '../../core/constants.js';
+// ---------------------------------------------------------------------------
+// Internal storage
+// ---------------------------------------------------------------------------
+// Whole-shape color, keyed on shape.wrapped identity
+const shapeColorStore = new WeakMap();
+// Per-face colors: shape.wrapped → face hash → color
+const faceColorStore = new WeakMap();
+/** O(1) check whether a shape has any color metadata (shape or face level). */
+export function hasColorMetadata(shape) {
+    return shapeColorStore.has(shape.wrapped) || faceColorStore.has(shape.wrapped);
+}
+function getFaceColorMap(shape) {
+    let map = faceColorStore.get(shape.wrapped);
+    if (!map) {
+        map = new Map();
+        faceColorStore.set(shape.wrapped, map);
+    }
+    return map;
+}
+// ---------------------------------------------------------------------------
+// Color parsing
+// ---------------------------------------------------------------------------
+/** Parse any accepted color input into canonical RGBA (exported so content-
+ *  addressed consumers can canonicalize before hashing). */
+export function parseColor(input) {
+    if (typeof input === 'string') {
+        let hex = input.startsWith('#') ? input.slice(1) : input;
+        if (hex.length === 3) {
+            hex =
+                hex.charAt(0) +
+                    hex.charAt(0) +
+                    hex.charAt(1) +
+                    hex.charAt(1) +
+                    hex.charAt(2) +
+                    hex.charAt(2);
+        }
+        const r = parseInt(hex.slice(0, 2), 16) / 255;
+        const g = parseInt(hex.slice(2, 4), 16) / 255;
+        const b = parseInt(hex.slice(4, 6), 16) / 255;
+        return [r, g, b, 1];
+    }
+    if (input.length === 3) {
+        return [input[0], input[1], input[2], 1];
+    }
+    return [input[0], input[1], input[2], input[3]];
+}
+// ---------------------------------------------------------------------------
+// Public API
+// ---------------------------------------------------------------------------
+/**
+ * Set a whole-shape color (stored externally via WeakMap).
+ * Returns the same shape reference.
+ */
+export function colorShape(shape, color) {
+    shapeColorStore.set(shape.wrapped, parseColor(color));
+    return shape;
+}
+/**
+ * Set per-face colors on a shape.
+ * Returns the same shape reference.
+ */
+export function colorFaces(shape, faces, color) {
+    const parsed = parseColor(color);
+    const map = getFaceColorMap(shape);
+    for (const face of faces) {
+        map.set(getKernel().hashCode(face.wrapped, HASH_CODE_MAX), parsed);
+    }
+    return shape;
+}
+/**
+ * Get the whole-shape color, or undefined if none set.
+ */
+export function getShapeColor(shape) {
+    return shapeColorStore.get(shape.wrapped);
+}
+/**
+ * Get the color of a specific face, or undefined if none set.
+ */
+export function getFaceColor(shape, face) {
+    const map = faceColorStore.get(shape.wrapped);
+    if (!map)
+        return undefined;
+    return map.get(getKernel().hashCode(face.wrapped, HASH_CODE_MAX));
+}
+/**
+ * Propagate colors from input shapes to a result shape using a
+ * kernel-provided ShapeEvolution record (no direct kernel op access needed).
+ */
+export function propagateColorsFromEvolution(evolution, inputs, result) {
+    // Propagate whole-shape colors: first input with a color wins
+    for (const input of inputs) {
+        const c = shapeColorStore.get(input.wrapped);
+        if (c) {
+            shapeColorStore.set(result.wrapped, c);
+            break;
+        }
+    }
+    // Propagate per-face colors
+    const resultFaceMap = getFaceColorMap(result);
+    for (const input of inputs) {
+        const inputFaceMap = faceColorStore.get(input.wrapped);
+        if (!inputFaceMap || inputFaceMap.size === 0)
+            continue;
+        for (const [hash, color] of inputFaceMap) {
+            if (evolution.deleted.has(hash))
+                continue;
+            const modifiedHashes = evolution.modified.get(hash);
+            if (modifiedHashes && modifiedHashes.length > 0) {
+                for (const modHash of modifiedHashes) {
+                    resultFaceMap.set(modHash, color);
+                }
+            }
+            else {
+                // Face survived unmodified
+                resultFaceMap.set(hash, color);
+            }
+        }
+    }
+}
+//# sourceMappingURL=colorFns.js.map