@metamesh/modeling 0.0.0-bootstrap.0 → 0.6.0

package/dist/api/text.d.ts

@@ -0,0 +1,77 @@
+/** Limits apply before parsing or shaping untrusted font data. */
+export declare const MAX_VECTOR_FONT_BYTES: number;
+
+/** Parses bounded font bytes using optional fontkit and WOFF2 peers; no font fetching occurs here. */
+export declare function prepareVectorFont(bytes: Uint8Array, options?: VectorFontOptions): Promise<VectorFont>;
+
+/** A prepared font owns its parsed bytes; keep handles local to their Worker or invocation. */
+export declare interface VectorFont {
+    /** Shape and position up to 512 UTF-16 units and 16 lines; supports empty or whitespace text. */
+    readonly layout: (text: string, options: VectorTextLayoutOptions) => VectorTextLayout;
+    /** Measure the same cached vector layout; all returned lengths are in millimetres. */
+    readonly measure: (text: string, options: VectorTextLayoutOptions) => VectorTextMetrics;
+    /** Serialize visible multiline outlines as bounded path-only SVG in physical millimetres. */
+    readonly toSvg: (text: string, options: VectorTextLayoutOptions) => string;
+}
+
+/** Identifies the actual weight of a static face, without synthesizing a different weight. */
+export declare interface VectorFontOptions {
+    /** Actual weight of a static face, 1–1000; defaults to 400. */
+    readonly staticWeight?: number;
+}
+
+/** Exact curve bounds in millimetres; positive Y points upward. */
+export declare interface VectorTextBounds {
+    /** Minimum X and Y of visible outlines, including accents, descenders, and overhangs. */
+    readonly min: readonly [number, number];
+    /** Maximum X and Y of visible outlines. */
+    readonly max: readonly [number, number];
+}
+
+/** Immutable vector layout with no browser, font parser, or kernel ownership. */
+export declare interface VectorTextLayout {
+    /** Nonzero-filled path data in millimetres, positive Y upward; empty for text with no ink. */
+    readonly paths: readonly string[];
+    /** Exact measurements of these paths and their logical text layout. */
+    readonly metrics: VectorTextMetrics;
+}
+
+/** Horizontal multiline text, bounded to 512 UTF-16 units and 16 lines without wrapping. */
+export declare interface VectorTextLayoutOptions extends VectorTextOptions {
+    /** Place each line's advance at the origin; defaults to left. Ink overhang is preserved. */
+    readonly align?: "left" | "center" | "right";
+    /** Baseline spacing in ems, 0.5–5; omitted uses the selected face's natural vertical metrics. */
+    readonly lineHeight?: number;
+    /** Place the first baseline or the complete ink bounds at Y=0; defaults to baseline. */
+    readonly verticalAlign?: "baseline" | "top" | "center" | "bottom";
+}
+
+/** Text measurements from the same immutable layout that supplies geometry and SVG outlines. */
+export declare interface VectorTextMetrics {
+    /** Visible curve bounds after alignment, or null when the text has no ink. */
+    readonly bounds: VectorTextBounds | null;
+    /** Unaligned pen displacement: final line advance and negative baseline displacement, in mm. */
+    readonly advance: readonly [number, number];
+    /** Maximum line advance in millimetres, including spaces; distinct from visible ink width. */
+    readonly logicalWidth: number;
+    /** Selected font's ascender distance above a baseline in millimetres, independent of the text. */
+    readonly ascent: number;
+    /** Selected font's descender distance below a baseline in millimetres, a non-negative value. */
+    readonly descent: number;
+    /** Actual distance between baselines in millimetres. */
+    readonly lineHeight: number;
+    /** Number of lines, including empty and trailing lines; empty text occupies one line. */
+    readonly lineCount: number;
+}
+
+/** Shaping controls for a prepared exact font face; all lengths are in millimetres. */
+export declare interface VectorTextOptions {
+    /** Em size in millimetres, greater than zero and at most 10000; not the visible glyph height. */
+    readonly fontSize: number;
+    /** Actual static or variable weight, 1–1000; defaults to the prepared face's static weight. */
+    readonly fontWeight?: number;
+    /** Tracking between glyph clusters in millimetres, -100–100; defaults to zero. */
+    readonly letterSpacing?: number;
+}
+
+export { }

package/dist/engine/construction-operations.js

@@ -0,0 +1,189 @@
+import { GeometryError } from "../geometry/errors.js";
+import { resolveExtrusionContourDivisions, resolveExtrusionControls, } from "../geometry/extrusion.js";
+import { heightfieldMesh, preflightHeightfield } from "../geometry/heightfield.js";
+import { assertMeshAllocationWithinLimits } from "../geometry/model-limits.js";
+import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
+import { matchProfiles } from "../geometry/profiles/matched.js";
+import { resolveGeometryResolution } from "../geometry/resolution.js";
+import { assertSamplingCount } from "../geometry/sampling-limits.js";
+import { buildSweepMesh } from "../geometry/sweeps/sweep-mesh.js";
+import { buildFinishedExtrusion } from "./extrusion-finishing.js";
+import { createLoftOperation } from "./loft-operations.js";
+import { triangleMeshToManifold } from "./native/adapter.js";
+import { ownScopedManifoldValue, scopedManifoldScope, trackScopedManifoldValue, } from "./native/context.js";
+import * as kernel from "./native/index.js";
+import { buildProfileSweepMesh } from "./profile-mesh.js";
+/** Internal host-bound construction operations. */
+export function createConstructionOperations(environment, sections) {
+    const { module, scope, limits, assertActive, throwGeometryError, resolveHandle, nativeSolid, nativeSection, wrapSolid, ownSolid, ownSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, assertOperandCount, assertMeshAllocation, withResolutionDefaults, resolveCircularSegments, } = environment;
+    const fromContours = sections.sectionFromContours;
+    const corresponding = (value) => typeof value === "object" && value !== null && "components" in value;
+    const shapeSection = (shape) => corresponding(shape)
+        ? nativeSection(fromContours(shape.components.flatMap((component) => [component.outer, ...component.holes].map((contour) => contour.points))))
+        : nativeSection(shape);
+    const sectionProfile = environment.sectionProfileFor;
+    const extrude = (handle, value) => {
+        assertPrimitiveOptions(value, "extrude");
+        const native = shapeSection(handle), resolved = withResolutionDefaults(value);
+        if (value.ends !== undefined) {
+            const profile = corresponding(handle) ? handle : environment.sectionProfileFor(handle);
+            return solidFromMesh(buildFinishedExtrusion(module, profile, resolved));
+        }
+        assertSamplingCount(native.numVert(), "extrude", resolved.limits.maxProfilePoints);
+        const controls = resolveExtrusionControls(value.height, resolved, "extrude");
+        let divisions = value.divisions;
+        if (divisions === undefined) {
+            const policy = resolveGeometryResolution(resolved.resolution, resolved.limits);
+            // Untwisted uniform taper has planar sides. Its default two-cap topology
+            // needs no native contour extraction or longitudinal interpolation.
+            if (controls.twistDegrees === 0 &&
+                controls.scales[0] === controls.scales[1] &&
+                policy.maxSegmentLength === undefined)
+                divisions = 0;
+            else {
+                const profile = corresponding(handle) ? handle : sectionProfile(handle);
+                divisions = resolveExtrusionContourDivisions(profile.components.flatMap((component) => [component.outer, ...component.holes].map((contour) => contour.points)), value.height, resolved);
+            }
+        }
+        const vertices = native.numVert() * (divisions + 2), 
+        // A connected extrusion has T = 2V + 4H - 4. Treating every extra contour as
+        // a hole also bounds disconnected Sections, without extracting native point data.
+        triangles = Math.max(0, vertices * 2 + 4 * native.numContour() - 8);
+        assertMeshAllocationWithinLimits(vertices, triangles, vertices * 12 + triangles * 12, "extrude", resolved.limits);
+        assertMeshAllocation(vertices, triangles, vertices * 12 + triangles * 12, "extrude");
+        return ownSolid(native.extrude(value.height, divisions, controls.twistDegrees, controls.scales, controls.center));
+    };
+    const boolean = (values, operation) => {
+        assertOperandCount(values, operation);
+        const natives = values.map(resolveHandle), kind = natives[0].kind;
+        if (natives.some((native) => native.kind !== kind))
+            throwGeometryError("INVALID_ARGUMENT", operation, "Boolean operands must have the same dimensionality.");
+        if (kind === "solid") {
+            const solids = values.map((value) => nativeSolid(value));
+            return wrapSolid(operation === "union" ? kernel.union(scope, solids) : kernel.intersect(scope, solids));
+        }
+        const sections = values.map((value) => nativeSection(value));
+        return ownSection(operation === "union"
+            ? module.CrossSection.union(sections)
+            : module.CrossSection.intersection(sections));
+    };
+    const subtract = ((value, cutters) => {
+        assertOperandCount(cutters, "subtract", 0);
+        const native = resolveHandle(value), natives = cutters.map(resolveHandle);
+        if (natives.some((cutter) => cutter.kind !== native.kind))
+            throwGeometryError("INVALID_ARGUMENT", "subtract", "Boolean operands must have the same dimensionality.");
+        if (cutters.length === 0)
+            return value;
+        return native.kind === "solid"
+            ? wrapSolid(kernel.subtract(scope, native.value, cutters.map((cutter) => nativeSolid(cutter))))
+            : ownSection(module.CrossSection.difference([
+                native.value,
+                ...cutters.map((cutter) => nativeSection(cutter)),
+            ]));
+    });
+    const solidFromMesh = (mesh) => {
+        assertActive();
+        assertMeshAllocation(mesh.positions.length / 3, mesh.indices.length / 3, mesh.positions.byteLength + mesh.indices.byteLength, "solidFromMesh");
+        return wrapSolid(trackScopedManifoldValue(scope, triangleMeshToManifold(module, mesh, scopedManifoldScope(scope))));
+    };
+    const operations = {
+        union: ((values) => boolean(values, "union")),
+        subtract,
+        intersect: ((values) => boolean(values, "intersect")),
+        compose: (values) => wrapSolid(kernel.compose(scope, values.map(nativeSolid))),
+        hull: (value) => {
+            assertActive();
+            return wrapSolid(kernel.hull(scope, value.solids === undefined
+                ? { points: value.points }
+                : { solids: value.solids.map(nativeSolid) }));
+        },
+        minkowskiSum: (a, b) => wrapSolid(kernel.minkowskiSum(scope, nativeSolid(a), nativeSolid(b))),
+        solidFromMesh,
+        extrude,
+        revolve: (handle, value = {}) => {
+            assertPrimitiveOptions(value, "revolve");
+            const native = shapeSection(handle), bounds = native.bounds();
+            const degrees = value.revolveDegrees ?? 360;
+            if (requirePositiveNumber(degrees, "revolve") > 360)
+                throwGeometryError("INVALID_ARGUMENT", "revolve", "Sweep must not exceed 360 degrees.");
+            const selected = withResolutionDefaults(value);
+            assertSamplingCount(native.numVert(), "revolve", selected.limits.maxProfilePoints);
+            const count = resolveCircularSegments(Math.max(Math.abs(bounds.min[0]), Math.abs(bounds.max[0])), value);
+            // The public exact/resolved count describes a complete circle, while the native
+            // kernel's count describes this angular sweep, including a partial revolution.
+            const sampledIntervals = degrees === 360 ? count : Math.max(1, Math.ceil((count * degrees) / 360));
+            // Counts below three select Manifold's ambient automatic tessellation instead of an
+            // exact interval count (and can yield an empty tiny-angle result). Adaptive policies
+            // may refine to three; an explicit full-circle count must retain its exact meaning.
+            if (sampledIntervals < 3 &&
+                (value.segments !== undefined || selected.resolution.circularSegments !== undefined))
+                throw new GeometryError("INVALID_ARGUMENT", `Exact partial revolution resolves ${sampledIntervals} angular intervals; native filled revolutions require at least three. Use at least ${Math.floor(720 / degrees) + 1} full-circle segments.`, {
+                    operation: "revolve",
+                    details: {
+                        requiredCount: 3,
+                        allowedCount: sampledIntervals,
+                        requiredCircularSegments: Math.floor(720 / degrees) + 1,
+                        circularSegments: count,
+                    },
+                });
+            const sweepSegments = Math.max(3, sampledIntervals);
+            assertSamplingCount(sweepSegments, "revolve", selected.limits.maxCircularSegments);
+            const rings = degrees === 360 ? sweepSegments : sweepSegments + 1;
+            const vertices = native.numVert() * rings, triangles = Math.max(0, vertices * 2 + (degrees === 360 ? 0 : 4 * native.numContour() - 8));
+            assertMeshAllocationWithinLimits(vertices, triangles, vertices * 12 + triangles * 12, "revolve", selected.limits);
+            return ownSolid(native.revolve(sweepSegments, degrees));
+        },
+        loft: createLoftOperation(environment, solidFromMesh),
+        matchProfiles: (profiles, value = {}) => {
+            assertActive();
+            return matchProfiles(profiles, withResolutionDefaults(value));
+        },
+        sweep: (shape, path, value = {}) => {
+            assertActive();
+            const selected = withResolutionDefaults(value);
+            if (corresponding(shape))
+                return solidFromMesh(buildProfileSweepMesh(module, shape, path, selected, selected.limits));
+            const profile = sectionProfile(shape);
+            const singleComponent = profile.components.length === 1 ? profile.components[0] : undefined;
+            const contours = singleComponent?.holes.length === 0 ? [singleComponent.outer.points] : [];
+            if (contours.length === 1)
+                return solidFromMesh(buildSweepMesh(contours[0], path, selected, assertMeshAllocation));
+            return solidFromMesh(buildProfileSweepMesh(module, profile, path, selected, selected.limits));
+        },
+        heightfield: (value) => {
+            assertActive();
+            const facts = preflightHeightfield(value, limits);
+            assertMeshAllocation(facts.vertexCount, facts.triangleCount, facts.byteCount, "heightfield");
+            return solidFromMesh(heightfieldMesh(value, limits));
+        },
+        implicit: (value) => {
+            assertActive();
+            validateCoordinates(value.bounds.min, 3, "implicit");
+            validateCoordinates(value.bounds.max, 3, "implicit");
+            requirePositiveNumber(value.edgeLength, "implicit");
+            const dimensions = value.bounds.max.map((max, axis) => requirePositiveNumber(max - value.bounds.min[axis], "implicit"));
+            // Native levelSet allocates two BCC lattices using power-of-two Y/Z strides.
+            // Bound that definite sampling work separately from the unknown surface crossings.
+            const [gx, gy, gz] = dimensions.map((extent) => Math.floor(extent / value.edgeLength + 1));
+            const sy = 2 ** Math.ceil(Math.log2(gy + 3));
+            const sz = 2 ** Math.ceil(Math.log2(gz + 3));
+            const slots = 1 + 2 * (gz + 2) + 2 * (gy + 2) * sz + 2 * (gx + 2) * sy * sz;
+            if (!Number.isSafeInteger(slots) || slots > 4_000_000)
+                throwGeometryError("COMPLEXITY_LIMIT", "implicit", "Implicit sampling exceeds 4,000,000 grid slots.");
+            let calls = 0;
+            const field = (point) => {
+                if (++calls > 8_000_000)
+                    throwGeometryError("COMPLEXITY_LIMIT", "implicit", "Implicit field evaluation budget exceeded.");
+                return validateFiniteNumber(value.field(point), "implicit");
+            };
+            if (value.level !== undefined)
+                validateFiniteNumber(value.level, "implicit");
+            if (value.tolerance !== undefined)
+                requirePositiveNumber(value.tolerance, "implicit");
+            const native = ownScopedManifoldValue(scope, module.Manifold.levelSet(field, { min: [...value.bounds.min], max: [...value.bounds.max] }, value.edgeLength, value.level, value.tolerance));
+            assertMeshAllocation(native.numVert(), native.numTri(), native.numVert() * 12 + native.numTri() * 12, "implicit");
+            return wrapSolid(native);
+        },
+    };
+    return operations;
+}

package/dist/engine/execution.js

@@ -0,0 +1,227 @@
+import { GeometryError } from "../geometry/errors.js";
+import { analyzeTriangleMesh, } from "../geometry/mesh.js";
+import { assertMeshAllocationWithinLimits } from "../geometry/model-limits.js";
+import {} from "../geometry/resolution.js";
+import { assertSamplingCount } from "../geometry/sampling-limits.js";
+import { createModelingContext } from "./modeling-context.js";
+import { ownScopedManifoldValue } from "./native/context.js";
+import { copiedFloat32Array, copiedUint32Array } from "./native/copied-views.js";
+import * as kernel from "./native/index.js";
+import { createShapeAnchorOwner } from "./shape-anchors.js";
+/** Internal execution owner; no native value or constructor crosses the public facade. */
+export function createExecutionContext(module, scope, limits, initialResolution = {}) {
+    const handles = new WeakMap();
+    // Native solids are immutable. Keep canonical extraction private until finalization; public
+    // mesh inspection receives independent copies, and this run-owned cache is cleared on exit.
+    const canonicalSolidMeshes = new Map();
+    const canonicalSectionProfiles = new Map();
+    const primitiveSectionProfiles = new Map();
+    let active = true;
+    const throwGeometryError = (code, operation, message) => {
+        throw new GeometryError(code, message, { operation });
+    };
+    const assertActive = () => {
+        if (!active)
+            throwGeometryError("INVALID_ARGUMENT", "model", "The modeling context has expired.");
+    };
+    const resolveHandle = (handle) => {
+        assertActive();
+        const native = typeof handle === "object" && handle !== null ? handles.get(handle) : undefined;
+        return (native ??
+            throwGeometryError("INVALID_ARGUMENT", "model", "Geometry must belong to this exact active build."));
+    };
+    const nativeSolid = (handle) => {
+        const native = resolveHandle(handle);
+        return native.kind === "solid"
+            ? native.value
+            : throwGeometryError("INVALID_ARGUMENT", "model", "Expected a solid.");
+    };
+    const nativeSection = (handle) => {
+        const native = resolveHandle(handle);
+        return native.kind === "section"
+            ? native.value
+            : throwGeometryError("INVALID_ARGUMENT", "model", "Expected a filled section.");
+    };
+    const wrapSolid = (value) => {
+        assertActive();
+        const handle = Object.freeze({});
+        handles.set(handle, { kind: "solid", value });
+        return handle;
+    };
+    const wrapSection = (value) => {
+        assertActive();
+        assertSamplingCount(value.numVert(), "section", limits.maxProfilePoints);
+        const handle = Object.freeze({});
+        handles.set(handle, { kind: "section", value });
+        return handle;
+    };
+    const ownSolid = (value) => wrapSolid(ownScopedManifoldValue(scope, value));
+    const ownSection = (value) => {
+        const owned = ownScopedManifoldValue(scope, value);
+        return wrapSection(owned);
+    };
+    const shapeAnchors = createShapeAnchorOwner((shape) => {
+        resolveHandle(shape);
+    }, (shape) => {
+        const native = resolveHandle(shape);
+        const alias = native.kind === "solid" ? wrapSolid(native.value) : wrapSection(native.value);
+        if (native.kind === "section") {
+            const profile = primitiveSectionProfiles.get(shape);
+            if (profile !== undefined)
+                primitiveSectionProfiles.set(alias, profile);
+        }
+        return alias;
+    });
+    const validateFiniteNumber = (value, operation) => Number.isFinite(value)
+        ? value
+        : throwGeometryError("NON_FINITE_VALUE", operation, "Values must be finite.");
+    const requirePositiveNumber = (value, operation) => validateFiniteNumber(value, operation) > 0
+        ? value
+        : throwGeometryError("INVALID_ARGUMENT", operation, "Dimensions must be positive.");
+    const validateCoordinates = (value, length, operation) => {
+        if (!Array.isArray(value) || value.length !== length)
+            throwGeometryError("INVALID_ARGUMENT", operation, `Expected ${length} finite coordinates.`);
+        if (!Array.from(value).every(Number.isFinite))
+            throwGeometryError("NON_FINITE_VALUE", operation, "Coordinates must be finite.");
+    };
+    const assertOperandCount = (values, operation, minimum = 1) => {
+        if (!Array.isArray(values) || values.length < minimum)
+            throwGeometryError("INVALID_ARGUMENT", operation, `Expected at least ${minimum} operands.`);
+        if (values.length > 1_000)
+            throwGeometryError("COMPLEXITY_LIMIT", operation, "Operations accept at most 1000 operands.");
+    };
+    const assertMeshAllocation = (vertices, triangles, bytes, operation) => {
+        assertMeshAllocationWithinLimits(vertices, triangles, bytes, operation, limits);
+    };
+    const copyNativeMesh = (native) => {
+        const raw = native.getMesh();
+        assertMeshAllocation(raw.numVert, raw.numTri, (raw.numVert + raw.numTri) * 12, "copyMesh");
+        const positions = copiedFloat32Array(raw.numVert * 3);
+        for (let vertex = 0; vertex < raw.numVert; vertex += 1) {
+            positions[vertex * 3] = raw.vertProperties[vertex * raw.numProp];
+            positions[vertex * 3 + 1] = raw.vertProperties[vertex * raw.numProp + 1];
+            positions[vertex * 3 + 2] = raw.vertProperties[vertex * raw.numProp + 2];
+        }
+        return { raw, mesh: { positions, indices: copiedUint32Array(raw.triVerts) } };
+    };
+    const analyzedMeshFor = (handle) => {
+        const native = nativeSolid(handle);
+        const cached = canonicalSolidMeshes.get(native);
+        if (cached !== undefined)
+            return cached;
+        const remember = (mesh) => {
+            const result = Object.freeze({
+                mesh: Object.freeze(mesh),
+                measurements: analyzeTriangleMesh(mesh, {
+                    requireClosed: true,
+                    includeTopology: true,
+                }),
+            });
+            canonicalSolidMeshes.set(native, result);
+            return result;
+        };
+        const first = copyNativeMesh(native);
+        try {
+            return remember(first.mesh);
+        }
+        catch (error) {
+            // Preserve the kernel's merge metadata for its one bounded collapsed-stitch retry.
+            if (!(error instanceof GeometryError))
+                throw error;
+            const reconstructionMesh = new module.Mesh({
+                numProp: 3,
+                vertProperties: first.mesh.positions,
+                triVerts: first.mesh.indices,
+                mergeFromVert: new Uint32Array(first.raw.mergeFromVert),
+                mergeToVert: new Uint32Array(first.raw.mergeToVert),
+                tolerance: first.raw.tolerance,
+            });
+            const reconstructed = ownScopedManifoldValue(scope, new module.Manifold(reconstructionMesh));
+            if (reconstructed.status() !== "NoError")
+                throw error;
+            const second = copyNativeMesh(reconstructed);
+            return remember(second.mesh);
+        }
+    };
+    const sectionProfileFor = (handle) => {
+        const native = nativeSection(handle);
+        const cached = canonicalSectionProfiles.get(native);
+        if (cached !== undefined)
+            return cached;
+        const components = kernel
+            .crossSectionToRegion(scope, native, limits)
+            .map((component, index) => {
+            const contour = (id, points) => Object.freeze({
+                id,
+                points,
+                spans: Object.freeze(points.map((_, point) => `point-${point}`)),
+            });
+            return Object.freeze({
+                id: `component-${index}`,
+                outer: contour("outer", component.outer),
+                holes: Object.freeze(component.holes.map((points, hole) => contour(`hole-${hole}`, points))),
+            });
+        });
+        const profile = Object.freeze({ components: Object.freeze(components) });
+        canonicalSectionProfiles.set(native, profile);
+        return profile;
+    };
+    const primitiveProfileFor = (handle) => {
+        nativeSection(handle);
+        return primitiveSectionProfiles.get(handle);
+    };
+    const rememberPrimitiveProfile = (handle, profile) => {
+        nativeSection(handle);
+        primitiveSectionProfiles.set(handle, profile);
+        return handle;
+    };
+    const owner = {
+        module,
+        scope,
+        limits,
+        assertActive,
+        throwGeometryError,
+        resolveHandle,
+        nativeSolid,
+        nativeSection,
+        wrapSolid,
+        wrapSection,
+        ownSolid,
+        ownSection,
+        validateFiniteNumber,
+        requirePositiveNumber,
+        validateCoordinates,
+        assertOperandCount,
+        assertMeshAllocation,
+        analyzedMeshFor,
+        sectionProfileFor,
+        primitiveProfileFor,
+        rememberPrimitiveProfile,
+        anchor: shapeAnchors.anchor,
+        withAnchors: shapeAnchors.withAnchors,
+        rememberAnchors: shapeAnchors.remember,
+        preserveAnchors: shapeAnchors.preserve,
+    };
+    return {
+        context: createModelingContext(owner, initialResolution),
+        analyzedMeshFor,
+        isSolid: (value) => typeof value === "object" && value !== null && handles.get(value)?.kind === "solid",
+        validateMesh: (mesh) => {
+            const input = new module.Mesh({
+                numProp: 3,
+                vertProperties: mesh.positions,
+                triVerts: mesh.indices,
+            });
+            const native = ownScopedManifoldValue(scope, new module.Manifold(input));
+            if (native.status() !== "NoError")
+                throwGeometryError("INVALID_TOPOLOGY", "finalize", "The geometry kernel rejected the finalized manufacturing mesh.");
+        },
+        dispose: () => {
+            active = false;
+            canonicalSolidMeshes.clear();
+            canonicalSectionProfiles.clear();
+            primitiveSectionProfiles.clear();
+            shapeAnchors.dispose();
+        },
+    };
+}

package/dist/engine/export-3mf.js

@@ -0,0 +1,100 @@
+import { Zip, ZipDeflate } from "fflate";
+import { GeometryError } from "../geometry/errors.js";
+import { analyzeTriangleMesh } from "../geometry/mesh.js";
+const namespace = "http://schemas.microsoft.com/3dmanufacturing/core/2015/02";
+const declaration = '<?xml version="1.0" encoding="UTF-8"?>';
+const encoder = new TextEncoder();
+const escapeXml = (value) => value.replace(/[&<>"']/g, (character) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&apos;" })[character]);
+/** Private core 3MF serializer. It preserves the selected buffers and streams bounded XML chunks. */
+export function meshesTo3mf(parts, options) {
+    const name = options.name ?? "MetaMesh model";
+    if (typeof name !== "string" ||
+        name.length === 0 ||
+        name.length > 1024 ||
+        // eslint-disable-next-line no-control-regex -- XML 1.0 disallows these control characters.
+        /[\u0000-\u0008\u000b\u000c\u000e-\u001f\ud800-\udfff\ufffe\uffff]/u.test(name))
+        throw new GeometryError("INVALID_ARGUMENT", "3MF names require one through 1024 valid XML characters.", { operation: "export3mf" });
+    for (const part of parts) {
+        const facts = analyzeTriangleMesh(part, { requireClosed: true, includeTopology: true });
+        if (!(facts.signedVolume > 0) || facts.vertexCount >= 2 ** 31 || facts.triangleCount >= 2 ** 31)
+            throw new GeometryError("INVALID_TOPOLOGY", "3MF parts require positive oriented volume and valid core resource counts.", { operation: "export3mf" });
+    }
+    const chunks = [];
+    let bytes = 0, complete = false;
+    const zip = new Zip((error, data, final) => {
+        if (error !== null)
+            throw error;
+        bytes += data.byteLength;
+        if (bytes >= 0xffffffff)
+            throw new GeometryError("COMPLEXITY_LIMIT", "3MF ZIP output exceeds its 32-bit container limit.", { operation: "export3mf" });
+        chunks.push(data);
+        complete = final;
+    });
+    const add = (path) => {
+        const file = new ZipDeflate(path, { level: 6 });
+        file.mtime = new Date(1980, 0, 1);
+        zip.add(file);
+        return file;
+    };
+    const addText = (path, contents) => add(path).push(encoder.encode(contents), true);
+    try {
+        addText("[Content_Types].xml", `${declaration}<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="model" ContentType="application/vnd.ms-package.3dmanufacturing-3dmodel+xml"/></Types>`);
+        addText("_rels/.rels", `${declaration}<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Target="/3D/3dmodel.model" Id="model" Type="http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel"/></Relationships>`);
+        const model = add("3D/3dmodel.model");
+        let xml = "", xmlBytes = 0;
+        const flush = (final = false) => {
+            const data = encoder.encode(xml);
+            xmlBytes += data.byteLength;
+            if (xmlBytes >= 0xffffffff)
+                throw new GeometryError("COMPLEXITY_LIMIT", "3MF model XML exceeds its 32-bit ZIP entry limit.", { operation: "export3mf" });
+            model.push(data, final);
+            xml = "";
+        };
+        const append = (value) => {
+            xml += value;
+            if (xml.length >= 32_768)
+                flush();
+        };
+        append(`${declaration}<model unit="millimeter" xml:lang="en-US" xmlns="${namespace}"><metadata name="Application">MetaMesh Modeling</metadata><metadata name="Title">${escapeXml(name)}</metadata><resources>`);
+        const colors = new Map();
+        for (const part of parts)
+            if (part.color !== undefined && !colors.has(part.color.toLowerCase()))
+                colors.set(part.color.toLowerCase(), colors.size);
+        const materialId = parts.length + 1;
+        if (colors.size) {
+            append(`<basematerials id="${materialId}">`);
+            for (const color of colors.keys())
+                append(`<base name="Color ${color.slice(1)}" displaycolor="${color.toUpperCase()}FF"/>`);
+            append("</basematerials>");
+        }
+        parts.forEach((part, index) => {
+            const material = part.color === undefined
+                ? ""
+                : ` pid="${materialId}" pindex="${colors.get(part.color.toLowerCase())}"`;
+            append(`<object id="${index + 1}" name="${escapeXml(part.id)}" partnumber="${escapeXml(part.id)}" type="model"${material}><mesh><vertices>`);
+            for (let offset = 0; offset < part.positions.length; offset += 3)
+                append(`<vertex x="${part.positions[offset]}" y="${part.positions[offset + 1]}" z="${part.positions[offset + 2]}"/>`);
+            append("</vertices><triangles>");
+            for (let offset = 0; offset < part.indices.length; offset += 3)
+                append(`<triangle v1="${part.indices[offset]}" v2="${part.indices[offset + 1]}" v3="${part.indices[offset + 2]}"/>`);
+            append("</triangles></mesh></object>");
+        });
+        append("</resources><build>");
+        parts.forEach((_, index) => append(`<item objectid="${index + 1}"/>`));
+        append("</build></model>");
+        flush(true);
+        zip.end();
+        if (!complete)
+            throw new Error("The synchronous 3MF compressor did not complete.");
+        const result = new Uint8Array(bytes);
+        let offset = 0;
+        for (const chunk of chunks) {
+            result.set(chunk, offset);
+            offset += chunk.byteLength;
+        }
+        return result.buffer;
+    }
+    finally {
+        zip.terminate();
+    }
+}