@metamesh/modeling 0.0.0-stage → 0.7.0

package/dist/engine/native/context.js

@@ -0,0 +1,209 @@
+import { isProtectedCopiedView } from "./copied-views.js";
+import { assertSynchronousScopeResult, assertWasmObjectScopeActive, WasmObjectScope, } from "./ownership.js";
+const contexts = new WeakMap();
+const stateFor = (context) => {
+    const state = contexts.get(context);
+    if (state === undefined || !state.active) {
+        throw new Error("Cannot use an expired scoped Manifold context.");
+    }
+    assertWasmObjectScopeActive(state.scope);
+    return state;
+};
+/**
+ * Creates a concise Manifold context backed by an existing low-level owner.
+ *
+ * The caller remains responsible for disposing `scope`. Prefer
+ * {@link withManifoldScope} for local builds.
+ */
+export function createScopedManifoldContext(module, scope) {
+    assertWasmObjectScopeActive(scope);
+    const context = Object.freeze({});
+    contexts.set(context, { active: true, module, owned: new WeakSet(), scope });
+    return context;
+}
+/** @internal Returns the live upstream module owned by a scoped context. */
+export function scopedManifoldModule(context) {
+    return stateFor(context).module;
+}
+/** @internal Returns the live low-level owner behind a scoped context. */
+export function scopedManifoldScope(context) {
+    return stateFor(context).scope;
+}
+/** @internal Owns and records a newly allocated WASM value. */
+export function ownScopedManifoldValue(context, value) {
+    const state = stateFor(context);
+    const owned = state.scope.own(value);
+    state.owned.add(owned);
+    return owned;
+}
+/** @internal Records a value already transferred to the context's low-level owner. */
+export function trackScopedManifoldValue(context, value) {
+    stateFor(context).owned.add(value);
+    return value;
+}
+/** @internal Verifies that a context remains active without exposing its internals. */
+export function assertScopedManifoldContext(context) {
+    stateFor(context);
+}
+/** @internal Verifies that a live WASM value belongs to this exact context. */
+export function assertScopedManifoldValue(context, value) {
+    if (!stateFor(context).owned.has(value)) {
+        throw new Error("WASM-backed values must be used with the scoped context that owns them.");
+    }
+}
+const propertyDescriptor = (value, property) => {
+    let current = value;
+    while (current !== null) {
+        const descriptor = Object.getOwnPropertyDescriptor(current, property);
+        if (descriptor !== undefined)
+            return descriptor;
+        current = Object.getPrototypeOf(current);
+    }
+    return undefined;
+};
+const assertInspectableProperties = (value, context, seen) => {
+    for (const property of Reflect.ownKeys(value)) {
+        const descriptor = Object.getOwnPropertyDescriptor(value, property);
+        if (descriptor === undefined)
+            continue;
+        if (!("value" in descriptor)) {
+            throw new Error("Accessor properties must not escape a scoped Manifold callback.");
+        }
+        assertNoScopedEscape(descriptor.value, context, seen);
+    }
+};
+const inspectableViewPrototypes = new Set([
+    BigInt64Array.prototype,
+    BigUint64Array.prototype,
+    DataView.prototype,
+    Float32Array.prototype,
+    Float64Array.prototype,
+    Int8Array.prototype,
+    Int16Array.prototype,
+    Int32Array.prototype,
+    Uint8Array.prototype,
+    Uint8ClampedArray.prototype,
+    Uint16Array.prototype,
+    Uint32Array.prototype,
+]);
+const isCanonicalTypedArrayIndex = (property) => {
+    if (typeof property !== "string" || property.length === 0)
+        return false;
+    const index = Number(property);
+    return Number.isSafeInteger(index) && index >= 0 && String(index) === property;
+};
+const assertInspectableViewProperties = (value, context, seen) => {
+    const properties = Reflect.ownKeys(value);
+    // Integer-indexed elements are primitive numeric/bigint storage. ECMAScript orders every such
+    // key before ordinary strings and symbols, so only the short trailing expando suffix needs deep
+    // inspection even for a large copied mesh buffer.
+    for (let index = properties.length - 1; index >= 0; index -= 1) {
+        const property = properties[index];
+        if (isCanonicalTypedArrayIndex(property))
+            break;
+        const descriptor = Object.getOwnPropertyDescriptor(value, property);
+        if (descriptor === undefined)
+            continue;
+        if (!("value" in descriptor)) {
+            throw new Error("Accessor properties must not escape a scoped Manifold callback.");
+        }
+        assertNoScopedEscape(descriptor.value, context, seen);
+    }
+};
+const assertNoScopedEscape = (value, context, seen = new WeakSet()) => {
+    if (value === context) {
+        throw new Error("Scoped Manifold contexts must not escape their callback.");
+    }
+    if ((typeof value !== "object" && typeof value !== "function") || value === null)
+        return;
+    if (typeof value === "function") {
+        throw new Error("Functions and closures must not escape a scoped Manifold callback.");
+    }
+    const objectValue = value;
+    if (seen.has(objectValue))
+        return;
+    seen.add(objectValue);
+    const state = contexts.get(context);
+    if (state?.owned.has(objectValue) === true) {
+        throw new Error("WASM-backed values must not escape a scoped Manifold callback.");
+    }
+    if (isProtectedCopiedView(objectValue))
+        return;
+    if (ArrayBuffer.isView(objectValue)) {
+        if (!inspectableViewPrototypes.has(Object.getPrototypeOf(objectValue))) {
+            throw new Error("Custom-prototype objects must not escape a scoped Manifold callback.");
+        }
+        assertInspectableViewProperties(objectValue, context, seen);
+        assertNoScopedEscape(objectValue.buffer, context, seen);
+        return;
+    }
+    if (objectValue instanceof ArrayBuffer) {
+        if (Object.getPrototypeOf(objectValue) !== ArrayBuffer.prototype) {
+            throw new Error("Custom-prototype objects must not escape a scoped Manifold callback.");
+        }
+        assertInspectableProperties(objectValue, context, seen);
+        return;
+    }
+    if (objectValue instanceof Map) {
+        if (Object.getPrototypeOf(objectValue) !== Map.prototype) {
+            throw new Error("Custom-prototype objects must not escape a scoped Manifold callback.");
+        }
+        assertInspectableProperties(objectValue, context, seen);
+        Map.prototype.forEach.call(objectValue, (entry, key) => {
+            assertNoScopedEscape(key, context, seen);
+            assertNoScopedEscape(entry, context, seen);
+        });
+        return;
+    }
+    if (objectValue instanceof Set) {
+        if (Object.getPrototypeOf(objectValue) !== Set.prototype) {
+            throw new Error("Custom-prototype objects must not escape a scoped Manifold callback.");
+        }
+        assertInspectableProperties(objectValue, context, seen);
+        Set.prototype.forEach.call(objectValue, (entry) => {
+            assertNoScopedEscape(entry, context, seen);
+        });
+        return;
+    }
+    if (Array.isArray(objectValue)) {
+        if (Object.getPrototypeOf(objectValue) !== Array.prototype) {
+            throw new Error("Custom-prototype objects must not escape a scoped Manifold callback.");
+        }
+        assertInspectableProperties(objectValue, context, seen);
+        return;
+    }
+    const deleteDescriptor = propertyDescriptor(objectValue, "delete");
+    if (deleteDescriptor !== undefined &&
+        "value" in deleteDescriptor &&
+        typeof deleteDescriptor.value === "function") {
+        throw new Error("WASM-backed values must not escape a scoped Manifold callback.");
+    }
+    const prototype = Object.getPrototypeOf(objectValue);
+    assertInspectableProperties(objectValue, context, seen);
+    if (prototype !== Object.prototype && prototype !== null) {
+        // Arbitrary instances may hide WASM-backed values in private fields or other internal slots,
+        // which cannot be inspected without executing user code.
+        throw new Error("Custom-prototype objects must not escape a scoped Manifold callback.");
+    }
+};
+/**
+ * Runs synchronous modeling work in one deterministic Manifold lifetime.
+ *
+ * The callback may return copied JavaScript data, but not the context or any
+ * WASM-backed value. Returning a promise is rejected.
+ */
+export function withManifoldScope(module, callback) {
+    const scope = new WasmObjectScope();
+    const context = createScopedManifoldContext(module, scope);
+    const state = contexts.get(context);
+    try {
+        const result = callback(context);
+        assertSynchronousScopeResult(result, "withManifoldScope callbacks must be synchronous.");
+        assertNoScopedEscape(result, context);
+        return result;
+    }
+    finally {
+        state.active = false;
+        scope.dispose();
+    }
+}

package/dist/engine/native/copied-views.js

@@ -0,0 +1,46 @@
+// Only fresh, intrinsic views created by this module enter the registry. Preventing extensions
+// also locks their prototypes, so consumers cannot attach an opaque value after registration.
+const copiedViews = new WeakSet();
+const Float32Copy = Float32Array;
+const Uint32Copy = Uint32Array;
+const protect = (view, prototype) => {
+    if (Object.getPrototypeOf(view) !== prototype ||
+        Object.getPrototypeOf(view.buffer) !== ArrayBuffer.prototype) {
+        throw new Error("Copied mesh buffers must use intrinsic typed-array prototypes.");
+    }
+    Object.preventExtensions(view.buffer);
+    Object.preventExtensions(view);
+    copiedViews.add(view.buffer);
+    copiedViews.add(view);
+    return view;
+};
+/** @internal Allocates a fresh numeric mesh view that cannot acquire escape-bearing properties. */
+export function copiedFloat32Array(source) {
+    const view = typeof source === "number" ? new Float32Copy(source) : new Float32Copy(source);
+    return protect(view, Float32Copy.prototype);
+}
+/** @internal Copies a fresh index view that cannot acquire escape-bearing properties. */
+export function copiedUint32Array(source) {
+    return protect(new Uint32Copy(source), Uint32Copy.prototype);
+}
+/** @internal Recognizes only this module's non-extensible, freshly allocated views and buffers. */
+export function isProtectedCopiedView(value) {
+    return copiedViews.has(value);
+}
+/** @internal Copies shared backing storage once while retaining mesh view offsets. */
+export function copiedMeshViews(mesh, buffers) {
+    const copy = (buffer) => {
+        if (!(buffer instanceof ArrayBuffer))
+            throw new Error("Mesh buffers must be transferable ArrayBuffers.");
+        let cloned = buffers.get(buffer);
+        if (cloned === undefined) {
+            cloned = buffer.slice(0);
+            buffers.set(buffer, cloned);
+        }
+        return cloned;
+    };
+    return {
+        positions: protect(new Float32Copy(copy(mesh.positions.buffer), mesh.positions.byteOffset, mesh.positions.length), Float32Copy.prototype),
+        indices: protect(new Uint32Copy(copy(mesh.indices.buffer), mesh.indices.byteOffset, mesh.indices.length), Uint32Copy.prototype),
+    };
+}

package/dist/engine/native/index.js

@@ -0,0 +1,13 @@
+/**
+ * Private host-native implementation details. Import public operations from @metamesh/modeling.
+ *
+ * @packageDocumentation
+ */
+export { createScopedManifoldContext, withManifoldScope, } from "./context.js";
+export { box, cylinder, sphere, torus, tube, } from "./scoped-primitives.js";
+export { compose, hull, intersect, minkowskiSum, subtract, union, } from "./operations.js";
+export { attach, mirror, rotate, scale, transform, translate, } from "./transforms.js";
+export { internalThreadCutter, preflightInternalThreadCutter, preflightThreadedNut, preflightThreadedRod, threadRidge, threadedNut, threadedRod, } from "./scoped-threads.js";
+export {} from "./threads.js";
+export { WasmObjectScope, withWasmObjectScope } from "./ownership.js";
+export { crossSectionToRegion, regionToCrossSection } from "./regions.js";

package/dist/engine/native/operations.js

@@ -0,0 +1,115 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { assertScopedManifoldContext, assertScopedManifoldValue, ownScopedManifoldValue, scopedManifoldModule, } from "./context.js";
+const operands = (context, solids, operation) => {
+    assertScopedManifoldContext(context);
+    const hasArrayShape = Array.isArray(solids);
+    if (!hasArrayShape) {
+        throw new GeometryError("INVALID_ARGUMENT", "solids must be an array.", { operation });
+    }
+    if (solids.length === 0) {
+        throw new GeometryError("INVALID_ARGUMENT", `${operation} needs at least one solid.`, {
+            operation,
+        });
+    }
+    if (solids.length > 1_000) {
+        throw new GeometryError("COMPLEXITY_LIMIT", "Solid operations accept at most 1000 operands.", {
+            operation,
+        });
+    }
+    for (const solid of solids)
+        assertScopedManifoldValue(context, solid);
+};
+/** Returns the Boolean union of one or more context-owned solids. */
+export function union(context, solids) {
+    operands(context, solids, "union");
+    if (solids.length === 1)
+        return solids[0];
+    return ownScopedManifoldValue(context, scopedManifoldModule(context).Manifold.union(solids));
+}
+/** Subtracts every context-owned cutter from a context-owned source solid. */
+export function subtract(context, solid, cutters) {
+    assertScopedManifoldValue(context, solid);
+    operands(context, [solid, ...cutters], "subtract");
+    if (cutters.length === 0)
+        return solid;
+    return ownScopedManifoldValue(context, scopedManifoldModule(context).Manifold.difference([solid, ...cutters]));
+}
+/** Returns the Boolean intersection of one or more context-owned solids. */
+export function intersect(context, solids) {
+    operands(context, solids, "intersect");
+    if (solids.length === 1)
+        return solids[0];
+    return ownScopedManifoldValue(context, scopedManifoldModule(context).Manifold.intersection(solids));
+}
+/** Combines disjoint context-owned solids without resolving overlaps. */
+export function compose(context, solids) {
+    operands(context, solids, "compose");
+    if (solids.length === 1)
+        return solids[0];
+    return ownScopedManifoldValue(context, scopedManifoldModule(context).Manifold.compose(solids));
+}
+/**
+ * Creates the scope-owned convex hull of finite XYZ millimetre points or solids.
+ *
+ * Point input needs at least four non-coplanar points and accepts at most 100000 points. Solid
+ * input accepts one through 1000 operands belonging to this exact live context.
+ */
+export function hull(context, options) {
+    assertScopedManifoldContext(context);
+    if (typeof options !== "object" || options === null || Array.isArray(options)) {
+        throw new GeometryError("INVALID_ARGUMENT", "Hull options must be an object.", {
+            operation: "hull",
+        });
+    }
+    if ((options.points === undefined) === (options.solids === undefined)) {
+        throw new GeometryError("INVALID_ARGUMENT", "Supply either points or solids to hull.", {
+            operation: "hull",
+        });
+    }
+    if (options.solids !== undefined) {
+        operands(context, options.solids, "hull");
+        return ownScopedManifoldValue(context, scopedManifoldModule(context).Manifold.hull(options.solids));
+    }
+    const points = options.points;
+    if (!Array.isArray(points) || points.length < 4) {
+        throw new GeometryError("INVALID_ARGUMENT", "A point hull needs at least four XYZ points.", {
+            operation: "hull",
+        });
+    }
+    if (points.length > 100_000) {
+        throw new GeometryError("COMPLEXITY_LIMIT", "Point hulls accept at most 100000 points.", {
+            operation: "hull",
+        });
+    }
+    for (const point of points) {
+        if (!Array.isArray(point) || point.length !== 3) {
+            throw new GeometryError("INVALID_ARGUMENT", "Hull points must be exact XYZ tuples.", {
+                operation: "hull",
+            });
+        }
+        if (![point[0], point[1], point[2]].every(Number.isFinite)) {
+            throw new GeometryError("NON_FINITE_VALUE", "Hull coordinates must be finite.", {
+                operation: "hull",
+            });
+        }
+    }
+    const result = ownScopedManifoldValue(context, scopedManifoldModule(context).Manifold.hull(points));
+    const volume = result.volume();
+    if (!Number.isFinite(volume)) {
+        throw new GeometryError("NON_FINITE_VALUE", "Point hull volume must be finite.", {
+            operation: "hull",
+        });
+    }
+    if (result.isEmpty() || volume <= 0) {
+        throw new GeometryError("DEGENERATE_GEOMETRY", "Hull points must span a nonzero volume.", {
+            operation: "hull",
+        });
+    }
+    return result;
+}
+/** Adds two context-owned solids by a scope-owned Minkowski sum in XYZ millimetres. */
+export function minkowskiSum(context, solid, other) {
+    assertScopedManifoldValue(context, solid);
+    assertScopedManifoldValue(context, other);
+    return ownScopedManifoldValue(context, solid.minkowskiSum(other));
+}

package/dist/engine/native/ownership.js

@@ -0,0 +1,98 @@
+const disposedScopes = new WeakSet();
+/**
+ * Small deterministic owner for WASM-backed values. Values are released in
+ * reverse construction order and disposal is idempotent.
+ */
+export class WasmObjectScope {
+    #owned = [];
+    #disposed = false;
+    /**
+     * Transfers cleanup responsibility for a live WASM value to this scope.
+     * If the scope is already disposed, the value is deleted before throwing.
+     */
+    own(value) {
+        if (this.#disposed) {
+            value.delete();
+            throw new Error("Cannot add an object to a disposed WASM scope.");
+        }
+        this.#owned.push(value);
+        return value;
+    }
+    /**
+     * Deletes owned values in reverse construction order.
+     *
+     * Every deletion is attempted even when an earlier deletion fails. Cleanup
+     * failures are reported together in one `AggregateError`. Repeated calls
+     * are safe and do not retry values whose deletion failed.
+     */
+    dispose() {
+        if (this.#disposed) {
+            return;
+        }
+        this.#disposed = true;
+        disposedScopes.add(this);
+        const errors = [];
+        for (let index = this.#owned.length - 1; index >= 0; index -= 1) {
+            try {
+                this.#owned[index].delete();
+            }
+            catch (error) {
+                errors.push(error);
+            }
+        }
+        this.#owned.length = 0;
+        if (errors.length > 0) {
+            throw new AggregateError(errors, `Failed to delete ${errors.length} WASM object(s).`);
+        }
+    }
+}
+/** @internal Throws when a scoped Manifold operation uses an expired low-level owner. */
+export function assertWasmObjectScopeActive(scope) {
+    if (disposedScopes.has(scope)) {
+        throw new Error("Cannot use a disposed WASM scope.");
+    }
+}
+/** @internal Rejects async scope results without invoking custom thenable methods. */
+export function assertSynchronousScopeResult(value, error) {
+    if ((typeof value !== "object" && typeof value !== "function") || value === null)
+        return;
+    let current = value;
+    let depth = 0;
+    let inspectThen = true;
+    while (current !== null) {
+        if (++depth > 64)
+            throw typeof error === "string" ? new Error(error) : error();
+        const descriptor = inspectThen ? Object.getOwnPropertyDescriptor(current, "then") : undefined;
+        if (current === Promise.prototype ||
+            (descriptor !== undefined && "value" in descriptor && typeof descriptor.value === "function")) {
+            try {
+                // Consume native-Promise rejections even when its own then method was replaced.
+                void Promise.prototype.then.call(value, undefined, () => undefined);
+            }
+            catch {
+                // Intrinsic brand or species failures must not replace the misuse error.
+            }
+            throw typeof error === "string" ? new Error(error) : error();
+        }
+        if (descriptor !== undefined)
+            inspectThen = false;
+        current = Object.getPrototypeOf(current);
+    }
+}
+/**
+ * Runs synchronous construction work with a deterministic WASM owner.
+ *
+ * Do not return an owned WASM value from `callback`; the scope is disposed
+ * before this function returns. Copy mesh or scalar data out instead.
+ */
+export const withWasmObjectScope = (callback) => {
+    const scope = new WasmObjectScope();
+    try {
+        const result = callback(scope);
+        assertSynchronousScopeResult(result, "withWasmObjectScope callbacks must be synchronous.");
+        return result;
+    }
+    finally {
+        scope.dispose();
+    }
+};

package/dist/engine/native/regions.js

@@ -0,0 +1,138 @@
+import { GeometryError } from "../../geometry/errors.js";
+import { loopContainsPoint, normalizeLoop2, normalizeRegion2, signedAreaLoop2, } from "../../geometry/regions.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../../geometry/sampling-limits.js";
+import { assertScopedManifoldValue, ownScopedManifoldValue, scopedManifoldModule, } from "./context.js";
+const MAX_AGGREGATE_CONTOURS = 25_000;
+const assertRegionBounds = (regions, operation, limits = {}) => {
+    const hasArrayShape = Array.isArray(regions);
+    if (!hasArrayShape) {
+        throw new GeometryError("INVALID_ARGUMENT", "Regions must be an array.", { operation });
+    }
+    let contours = 0;
+    let vertices = 0;
+    if (regions.length > MAX_AGGREGATE_CONTOURS) {
+        throw new GeometryError("COMPLEXITY_LIMIT", "Region collection exceeds 25000 entries.", {
+            operation,
+        });
+    }
+    for (const region of regions) {
+        const hasRegionShape = Array.isArray(region);
+        if (!hasRegionShape) {
+            throw new GeometryError("INVALID_ARGUMENT", "Each region must be an array of polygons.", {
+                operation,
+            });
+        }
+        for (const polygon of region) {
+            const hasOuterShape = Array.isArray(polygon?.outer);
+            const hasHoleShape = Array.isArray(polygon?.holes);
+            if (typeof polygon !== "object" || polygon === null || !hasOuterShape || !hasHoleShape) {
+                throw new GeometryError("INVALID_ARGUMENT", "Polygons need outer and hole arrays.", {
+                    operation,
+                });
+            }
+            contours += 1 + polygon.holes.length;
+            vertices += polygon.outer.length;
+            for (const hole of polygon.holes) {
+                if (!Array.isArray(hole)) {
+                    throw new GeometryError("INVALID_ARGUMENT", "Polygon holes must be arrays.", {
+                        operation,
+                    });
+                }
+                vertices += hole.length;
+            }
+            if (contours > MAX_AGGREGATE_CONTOURS) {
+                throw new GeometryError("COMPLEXITY_LIMIT", "Regions exceed 25000 aggregate contours.", {
+                    operation,
+                    details: { contours, vertices },
+                });
+            }
+            assertSamplingCount(vertices, operation, resolveGeometrySamplingLimits(limits).maxProfilePoints);
+            for (const loop of [polygon.outer, ...polygon.holes]) {
+                for (const point of loop) {
+                    if (!Array.isArray(point) || point.length !== 2) {
+                        throw new GeometryError("INVALID_ARGUMENT", "Region points must be exact XY tuples.", {
+                            operation,
+                        });
+                    }
+                    if (!Number.isFinite(point[0]) || !Number.isFinite(point[1])) {
+                        throw new GeometryError("NON_FINITE_VALUE", "Region coordinates must be finite.", {
+                            operation,
+                        });
+                    }
+                }
+            }
+        }
+    }
+};
+const contoursFromRegion = (region) => region
+    .flatMap((polygon) => [polygon.outer, ...polygon.holes])
+    .map((loop) => loop.map(([x, y]) => [x, y]));
+/**
+ * Converts explicit normalized region topology to a scope-owned CrossSection.
+ *
+ * Manifold CrossSection uses Clipper2's positive fill rule, so CCW exteriors
+ * and clockwise holes map directly without XOR-list ambiguity.
+ */
+export function regionToCrossSection(context, region, limits = {}) {
+    assertRegionBounds([region], "regionToCrossSection", limits);
+    const normalized = normalizeRegion2(region);
+    const module = scopedManifoldModule(context);
+    if (normalized.length === 0)
+        return ownScopedManifoldValue(context, module.CrossSection.union([]));
+    return ownScopedManifoldValue(context, new module.CrossSection(contoursFromRegion(normalized)));
+}
+const regionFromLoops = (loops) => {
+    const outers = loops
+        .filter((loop) => signedAreaLoop2(loop) > 0)
+        .map((outer) => ({ outer: normalizeLoop2(outer, true), holes: [] }));
+    const holes = loops
+        .filter((loop) => signedAreaLoop2(loop) < 0)
+        .map((hole) => normalizeLoop2(hole, false));
+    if (outers.length === 0 && loops.length > 0) {
+        throw new GeometryError("INVALID_TOPOLOGY", "CrossSection did not contain an exterior contour.");
+    }
+    const outerBounds = new Map(outers.map((polygon) => {
+        let minimumX = Number.POSITIVE_INFINITY;
+        let minimumY = Number.POSITIVE_INFINITY;
+        let maximumX = Number.NEGATIVE_INFINITY;
+        let maximumY = Number.NEGATIVE_INFINITY;
+        for (const [x, y] of polygon.outer) {
+            minimumX = Math.min(minimumX, x);
+            minimumY = Math.min(minimumY, y);
+            maximumX = Math.max(maximumX, x);
+            maximumY = Math.max(maximumY, y);
+        }
+        return [polygon, { minimumX, minimumY, maximumX, maximumY }];
+    }));
+    for (const hole of holes) {
+        const [x, y] = hole[0];
+        const owner = outers
+            .filter((polygon) => {
+            const bounds = outerBounds.get(polygon);
+            return (x >= bounds.minimumX &&
+                x <= bounds.maximumX &&
+                y >= bounds.minimumY &&
+                y <= bounds.maximumY &&
+                loopContainsPoint(polygon.outer, hole[0]));
+        })
+            .sort((a, b) => Math.abs(signedAreaLoop2(a.outer)) - Math.abs(signedAreaLoop2(b.outer)))[0];
+        if (owner === undefined) {
+            throw new GeometryError("INVALID_TOPOLOGY", "CrossSection hole had no containing exterior.");
+        }
+        owner.holes.push(hole);
+    }
+    return normalizeRegion2(outers.map(({ outer, holes }) => ({ outer, holes: Object.freeze(holes) })));
+};
+/** Copies a robust CrossSection into MetaMesh's explicit outer/hole topology. */
+export function crossSectionToRegion(context, section, limits = {}) {
+    assertScopedManifoldValue(context, section);
+    assertSamplingCount(section.numVert(), "crossSectionToRegion", resolveGeometrySamplingLimits(limits).maxProfilePoints);
+    // Normalization owns the one immutable coordinate copy and reuses validated child loops.
+    const loops = section.toPolygons();
+    if (loops.length > MAX_AGGREGATE_CONTOURS) {
+        throw new GeometryError("COMPLEXITY_LIMIT", "Resolved regions exceed 25000 contours.", {
+            operation: "crossSectionToRegion",
+        });
+    }
+    return regionFromLoops(loops);
+}