@metamesh/modeling 0.18.0 → 0.19.0

package/dist/geometry/mesh/mesh-render.js

@@ -0,0 +1,205 @@
+import { GeometryError } from "../errors.js";
+import { immutableMeshView } from "../immutable-buffer.js";
+import { validateTriangleMesh } from "./mesh.js";
+const MAX_NORMAL_COMPARISONS = 50_000_000;
+function tableCapacity(count) {
+    let capacity = 16;
+    while (capacity < count * 2)
+        capacity *= 2;
+    if (capacity > 0x8000_0000)
+        throw new GeometryError("COMPLEXITY_LIMIT", "Render mesh exceeds hash table capacity.");
+    return capacity;
+}
+/**
+ * Builds crease-aware render buffers without moving or merging distinct positions.
+ * Face normals are averaged only at exactly coincident positions within the crease angle.
+ * Returns owned buffers; every triangle retains its coordinates, order and winding.
+ * Pathological vertex fans exceeding 50 million normal comparisons reject with a complexity error.
+ *
+ * @example
+ * ```ts
+ * import * as mesh from "@metamesh/modeling/geometry/mesh";
+ * const surface = mesh.heightfield({ size: [10, 10], segments: [2, 2], height: () => 0 });
+ * const rendered = mesh.render(surface);
+ * // rendered.positions and rendered.normals can be passed to a renderer or GLB writer.
+ * ```
+ */
+export function renderMesh(input, options = {}) {
+    const angle = options.creaseAngle ?? 20;
+    if (!Number.isFinite(angle) || angle < 0 || angle > 180)
+        throw new GeometryError("INVALID_ARGUMENT", "Crease angle must be from 0 through 180 degrees.", {
+            operation: "renderMesh",
+        });
+    validateTriangleMesh(input);
+    const { positions, indices } = immutableMeshView(input);
+    const vertexCount = positions.length / 3;
+    const cornerCount = indices.length;
+    const faceCount = cornerCount / 3;
+    const positionBits = new Uint32Array(positions.buffer, positions.byteOffset, positions.length);
+    const faceNormals = new Float64Array(cornerCount);
+    for (let face = 0; face < faceCount; face += 1) {
+        const offset = face * 3;
+        const a = indices[offset] * 3;
+        const b = indices[offset + 1] * 3;
+        const c = indices[offset + 2] * 3;
+        const ux = positions[b] - positions[a];
+        const uy = positions[b + 1] - positions[a + 1];
+        const uz = positions[b + 2] - positions[a + 2];
+        const vx = positions[c] - positions[a];
+        const vy = positions[c + 1] - positions[a + 1];
+        const vz = positions[c + 2] - positions[a + 2];
+        const nx = uy * vz - uz * vy;
+        const ny = uz * vx - ux * vz;
+        const nz = ux * vy - uy * vx;
+        const inverseLength = 1 / Math.hypot(nx, ny, nz);
+        faceNormals[offset] = nx * inverseLength;
+        faceNormals[offset + 1] = ny * inverseLength;
+        faceNormals[offset + 2] = nz * inverseLength;
+    }
+    // Position identity is exact. In particular, no tolerance can collapse a thin physical gap.
+    const positionIds = new Uint32Array(vertexCount);
+    const representatives = new Uint32Array(vertexCount);
+    const positionTable = new Uint32Array(tableCapacity(vertexCount));
+    const positionMask = positionTable.length - 1;
+    let uniquePositions = 0;
+    const positionHash = (offset) => Math.imul(positions[offset] === 0 ? 0 : positionBits[offset], 73_856_093) ^
+        Math.imul(positions[offset + 1] === 0 ? 0 : positionBits[offset + 1], 19_349_663) ^
+        Math.imul(positions[offset + 2] === 0 ? 0 : positionBits[offset + 2], 83_492_791);
+    for (let vertex = 0; vertex < vertexCount; vertex += 1) {
+        const offset = vertex * 3;
+        let slot = positionHash(offset) & positionMask;
+        while (positionTable[slot] !== 0) {
+            const id = positionTable[slot] - 1;
+            const other = representatives[id] * 3;
+            if (positions[offset] === positions[other] &&
+                positions[offset + 1] === positions[other + 1] &&
+                positions[offset + 2] === positions[other + 2])
+                break;
+            slot = (slot + 1) & positionMask;
+        }
+        if (positionTable[slot] === 0) {
+            representatives[uniquePositions] = vertex;
+            positionTable[slot] = ++uniquePositions;
+        }
+        positionIds[vertex] = positionTable[slot] - 1;
+    }
+    const bucketOffsets = new Uint32Array(uniquePositions + 1);
+    for (const vertex of indices)
+        bucketOffsets[positionIds[vertex] + 1] += 1;
+    let comparisons = 0;
+    for (let id = 0; id < uniquePositions; id += 1) {
+        const count = bucketOffsets[id + 1];
+        comparisons += count * count;
+        if (angle !== 0 && comparisons > MAX_NORMAL_COMPARISONS)
+            throw new GeometryError("COMPLEXITY_LIMIT", "Render mesh exceeds the normal comparison work limit.", { operation: "renderMesh", details: { maxNormalComparisons: MAX_NORMAL_COMPARISONS } });
+        bucketOffsets[id + 1] = count + bucketOffsets[id];
+    }
+    const bucketFaces = new Uint32Array(cornerCount);
+    const cursors = bucketOffsets.slice(0, uniquePositions);
+    for (let corner = 0; corner < cornerCount; corner += 1) {
+        const id = positionIds[indices[corner]];
+        bucketFaces[cursors[id]] = Math.floor(corner / 3);
+        cursors[id] += 1;
+    }
+    let capacity = Math.min(cornerCount, Math.max(16, vertexCount));
+    let renderPositions = new Float32Array(capacity * 3);
+    let renderNormals = new Float32Array(capacity * 3);
+    let renderPositionBits = new Uint32Array(renderPositions.buffer);
+    let renderNormalBits = new Uint32Array(renderNormals.buffer);
+    let renderTable = new Uint32Array(tableCapacity(capacity));
+    let renderMask = renderTable.length - 1;
+    const renderedIndices = new Uint32Array(cornerCount);
+    const candidateNormal = new Float32Array(3);
+    const normalBits = new Uint32Array(candidateNormal.buffer);
+    let renderedCount = 0;
+    const creaseDot = Math.cos((angle * Math.PI) / 180);
+    const renderHash = (offset) => {
+        return (Math.imul(renderPositions[offset] === 0 ? 0 : renderPositionBits[offset], 73_856_093) ^
+            Math.imul(renderPositions[offset + 1] === 0 ? 0 : renderPositionBits[offset + 1], 19_349_663) ^
+            Math.imul(renderPositions[offset + 2] === 0 ? 0 : renderPositionBits[offset + 2], 83_492_791) ^
+            Math.imul(renderNormals[offset] === 0 ? 0 : renderNormalBits[offset], 49_979_687) ^
+            Math.imul(renderNormals[offset + 1] === 0 ? 0 : renderNormalBits[offset + 1], 67_867_967) ^
+            Math.imul(renderNormals[offset + 2] === 0 ? 0 : renderNormalBits[offset + 2], 86_028_121));
+    };
+    for (let corner = 0; corner < cornerCount; corner += 1) {
+        const faceOffset = Math.floor(corner / 3) * 3;
+        const nx = faceNormals[faceOffset];
+        const ny = faceNormals[faceOffset + 1];
+        const nz = faceNormals[faceOffset + 2];
+        const positionOffset = indices[corner] * 3;
+        let sumX = nx, sumY = ny, sumZ = nz;
+        if (angle !== 0) {
+            sumX = 0;
+            sumY = 0;
+            sumZ = 0;
+            const id = positionIds[indices[corner]];
+            for (let k = bucketOffsets[id]; k < bucketOffsets[id + 1]; k += 1) {
+                const other = bucketFaces[k] * 3;
+                const ox = faceNormals[other];
+                const oy = faceNormals[other + 1];
+                const oz = faceNormals[other + 2];
+                if (other === faceOffset || nx * ox + ny * oy + nz * oz >= creaseDot) {
+                    sumX += ox;
+                    sumY += oy;
+                    sumZ += oz;
+                }
+            }
+        }
+        const length = Math.hypot(sumX, sumY, sumZ);
+        candidateNormal[0] = length > 1e-12 ? sumX / length : nx;
+        candidateNormal[1] = length > 1e-12 ? sumY / length : ny;
+        candidateNormal[2] = length > 1e-12 ? sumZ / length : nz;
+        const hash = positionHash(positionOffset) ^
+            Math.imul(candidateNormal[0] === 0 ? 0 : normalBits[0], 49_979_687) ^
+            Math.imul(candidateNormal[1] === 0 ? 0 : normalBits[1], 67_867_967) ^
+            Math.imul(candidateNormal[2] === 0 ? 0 : normalBits[2], 86_028_121);
+        let slot = hash & renderMask;
+        while (renderTable[slot] !== 0) {
+            const offset = (renderTable[slot] - 1) * 3;
+            if (renderPositions[offset] === positions[positionOffset] &&
+                renderPositions[offset + 1] === positions[positionOffset + 1] &&
+                renderPositions[offset + 2] === positions[positionOffset + 2] &&
+                renderNormals[offset] === candidateNormal[0] &&
+                renderNormals[offset + 1] === candidateNormal[1] &&
+                renderNormals[offset + 2] === candidateNormal[2])
+                break;
+            slot = (slot + 1) & renderMask;
+        }
+        if (renderTable[slot] === 0) {
+            if (renderedCount === capacity) {
+                capacity = Math.min(cornerCount, capacity * 2);
+                const grownPositions = new Float32Array(capacity * 3);
+                const grownNormals = new Float32Array(capacity * 3);
+                grownPositions.set(renderPositions);
+                grownNormals.set(renderNormals);
+                renderPositions = grownPositions;
+                renderNormals = grownNormals;
+                renderPositionBits = new Uint32Array(renderPositions.buffer);
+                renderNormalBits = new Uint32Array(renderNormals.buffer);
+                renderTable = new Uint32Array(tableCapacity(capacity));
+                renderMask = renderTable.length - 1;
+                for (let index = 0; index < renderedCount; index += 1) {
+                    let target = renderHash(index * 3) & renderMask;
+                    while (renderTable[target] !== 0)
+                        target = (target + 1) & renderMask;
+                    renderTable[target] = index + 1;
+                }
+                slot = hash & renderMask;
+                while (renderTable[slot] !== 0)
+                    slot = (slot + 1) & renderMask;
+            }
+            const offset = renderedCount * 3;
+            renderPositions[offset] = positions[positionOffset];
+            renderPositions[offset + 1] = positions[positionOffset + 1];
+            renderPositions[offset + 2] = positions[positionOffset + 2];
+            renderNormals.set(candidateNormal, offset);
+            renderTable[slot] = ++renderedCount;
+        }
+        renderedIndices[corner] = renderTable[slot] - 1;
+    }
+    return {
+        positions: renderPositions.slice(0, renderedCount * 3),
+        normals: renderNormals.slice(0, renderedCount * 3),
+        indices: renderedIndices,
+    };
+}

package/dist/geometry/mesh/mesh-solid-intersections.js

@@ -28,13 +28,26 @@ const dominantAxis = (value) => {
             axis = index;
     return axis;
 };
+/** Returns the actual nearby segment point; offset half-planes overexpand acute corners. */
+function nearbySegmentPoint(point, a, b, epsilon) {
+    const dx = b[0] - a[0], dy = b[1] - a[1], dz = b[2] - a[2];
+    const lengthSquared = dx * dx + dy * dy + dz * dz;
+    const fraction = lengthSquared === 0
+        ? 0
+        : Math.max(0, Math.min(1, ((point[0] - a[0]) * dx + (point[1] - a[1]) * dy + (point[2] - a[2]) * dz) /
+            lengthSquared));
+    const x = a[0] + fraction * dx, y = a[1] + fraction * dy, z = a[2] + fraction * dz;
+    return Math.hypot(point[0] - x, point[1] - y, point[2] - z) <= epsilon ? [x, y, z] : undefined;
+}
 function inside(point, triangle, direction, epsilon) {
     const axis = dominantAxis(direction), p = project(point, axis), points = triangle.map((vertex) => project(vertex, axis));
     const sign = Math.sign(turn(points[0], points[1], points[2]));
-    return points.every((a, index) => {
+    if (points.every((a, index) => {
         const b = points[(index + 1) % 3];
-        return sign * turn(a, b, p) >= -epsilon * Math.hypot(b[0] - a[0], b[1] - a[1]);
-    });
+        return sign * turn(a, b, p) >= 0;
+    }))
+        return true;
+    return triangle.some((a, index) => nearbySegmentPoint(point, a, triangle[(index + 1) % 3], epsilon) !== undefined);
 }
 function onSharedBoundary(point, shared, epsilon) {
     if (shared.some((vertex) => distance(point, vertex) <= epsilon))
@@ -53,13 +66,12 @@ function coplanarIntersection(first, second, direction, shared, epsilon) {
     let polygon = [...first];
     for (let edge = 0; edge < 3 && polygon.length > 0; edge++) {
         const a = clip[edge], b = clip[(edge + 1) % 3];
-        const tolerance = epsilon * Math.hypot(b[0] - a[0], b[1] - a[1]);
         const signed = (point) => sign * turn(a, b, project(point, axis));
         const next = [];
         for (let index = 0; index < polygon.length; index++) {
             const start = polygon[index], end = polygon[(index + 1) % polygon.length];
             const d0 = signed(start), d1 = signed(end);
-            const in0 = d0 >= -tolerance, in1 = d1 >= -tolerance;
+            const in0 = d0 >= 0, in1 = d1 >= 0;
             if (in0)
                 next.push(start);
             if (in0 !== in1) {
@@ -73,22 +85,36 @@ function coplanarIntersection(first, second, direction, shared, epsilon) {
         }
         polygon = next;
     }
-    if (polygon.length === 0)
-        return false;
-    const origin = project(polygon[0], axis);
-    let area = 0;
-    for (let index = 1; index + 1 < polygon.length; index++)
-        area += turn(origin, project(polygon[index], axis), project(polygon[index + 1], axis));
-    const scale = Math.max(...first.map((point, index) => distance(point, first[(index + 1) % 3])));
-    if (Math.abs(area) > epsilon * scale)
-        return true;
-    return polygon.some((point) => !onSharedBoundary(point, shared, epsilon));
+    if (polygon.length > 0) {
+        const origin = project(polygon[0], axis);
+        let area = 0;
+        for (let index = 1; index + 1 < polygon.length; index++)
+            area += turn(origin, project(polygon[index], axis), project(polygon[index + 1], axis));
+        const scale = Math.max(...first.map((point, index) => distance(point, first[(index + 1) % 3])));
+        if (Math.abs(area) > epsilon * scale)
+            return true;
+        if (polygon.some((point) => !onSharedBoundary(point, shared, epsilon)))
+            return true;
+    }
+    // A distance tolerance rounds a triangle's corners. Clipping against independently offset
+    // support lines instead creates long miters and can report contact many epsilons away.
+    const nearbyContact = (source, target) => source.some((point) => target.some((a, index) => {
+        const closest = nearbySegmentPoint(point, a, target[(index + 1) % 3], epsilon);
+        return (closest !== undefined &&
+            (!onSharedBoundary(point, shared, epsilon) || !onSharedBoundary(closest, shared, epsilon)));
+    }));
+    return nearbyContact(first, second) || nearbyContact(second, first);
 }
 /** @internal Detects contact beyond a permitted indexed vertex or edge, without welding. */
 export function trianglesIntersectBeyondSharedBoundary(firstGeometry, secondGeometry, shared, epsilon) {
     const first = firstGeometry.points, second = secondGeometry.points, n0 = firstGeometry.normal, n1 = secondGeometry.normal;
-    const distances0 = first.map((point) => dot(n1, subtract(point, second[0])));
-    const distances1 = second.map((point) => dot(n0, subtract(point, first[0])));
+    // Indexed shared vertices lie exactly on both planes. Dot-product cancellation must not
+    // turn that known zero into a false crossing along a nearly coplanar edge.
+    const planeDistance = (point, n, origin) => shared.some((vertex) => vertex.every((value, axis) => value === point[axis]))
+        ? 0
+        : dot(n, subtract(point, origin));
+    const distances0 = first.map((point) => planeDistance(point, n1, second[0]));
+    const distances1 = second.map((point) => planeDistance(point, n0, first[0]));
     const separated = (values) => values.every((value) => value > epsilon) || values.every((value) => value < -epsilon);
     if (separated(distances0) || separated(distances1))
         return false;

package/dist/geometry/mesh/mesh-solid.js

@@ -172,7 +172,8 @@ function checkSolidGeometry(mesh, facts, options, { count, maxTests }) {
                 min[axis] = Math.min(min[axis], bounds[order[index] * 6 + axis]);
                 max[axis] = Math.max(max[axis], bounds[order[index] * 6 + axis + 3]);
             }
-        if (end - start <= 8)
+        // Small leaves avoid an 8x8 cross-product of false candidates on thin sampled surfaces.
+        if (end - start <= 4)
             return { start, end, min, max };
         let axis = 0;
         for (let index = 1; index < 3; index++)
@@ -219,7 +220,10 @@ function checkSolidGeometry(mesh, facts, options, { count, maxTests }) {
             visit(a.children[1], a.children[1]);
             return;
         }
-        if (a.children !== undefined) {
+        // Narrow both sides of a candidate pair instead of descending one entire subtree
+        // against a broad node on the other side of the thin sampled surface.
+        if (a.children !== undefined &&
+            (b.children === undefined || a.end - a.start >= b.end - b.start)) {
             visit(a.children[0], b);
             visit(a.children[1], b);
             return;

package/dist/geometry/mesh-api.js

@@ -10,5 +10,6 @@ export { computeTriangleMeshCentroid as centroid } from "./mesh/mesh-centroid.js
 export { analyzeTriangleMeshQuality as analyzeQuality } from "./mesh/mesh-quality.js";
 export { computeTriangleMeshSignature as signature } from "./mesh/mesh-signature.js";
 export { validateSolidMesh as validateSolid } from "./mesh/mesh-solid.js";
+export { renderMesh as render } from "./mesh/mesh-render.js";
 export { optimizePlanarPatches } from "./mesh/mesh-planar.js";
 export { immutableMesh as immutable } from "./immutable-buffer.js";

package/dist/geometry/region-offset.js

@@ -0,0 +1,278 @@
+import { GeometryError } from "./errors.js";
+import { resolveModelingLimits } from "./model-limits.js";
+import { normalizeRegionWithWork, signedContourArea } from "./regions.js";
+import { assertSamplingCount } from "./sampling-limits.js";
+import { resolveGeometryTolerance } from "./tolerance.js";
+const maximumWork = 2_000_000;
+const cross = (a, b) => a[0] * b[1] - a[1] * b[0];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1];
+const difference = (a, b) => [a[0] - b[0], a[1] - b[1]];
+/**
+ * Plans parallel-edge offsets of every material boundary, preserving logical slots and seams.
+ * Positive distance contracts material; negative distance expands it. The range includes zero.
+ * Boundary events are excluded throughout the interval, not only at generated mesh stations.
+ * @internal
+ */
+export function planRegionOffsets(profile, range, operation, overrides = {}) {
+    const fail = (code, message, boundary) => {
+        throw new GeometryError(code, message, {
+            operation,
+            ...(boundary === undefined ? {} : { details: { boundary } }),
+        });
+    };
+    if (!Array.isArray(range) || range.length !== 2 || range.some((value) => !Number.isFinite(value)))
+        fail("NON_FINITE_VALUE", "Offset bounds must be a finite distance pair.");
+    if (range[0] > 0 || range[1] < 0 || range[0] > range[1])
+        fail("INVALID_ARGUMENT", "Offset bounds must be ordered and include zero.");
+    range = [range[0], range[1]];
+    if (!Array.isArray(profile?.components) || profile.components.length === 0)
+        fail("DEGENERATE_GEOMETRY", "Finishing requires a nonempty filled profile.");
+    const limits = resolveModelingLimits(overrides);
+    let logicalCount = 0;
+    const identity = (value) => typeof value === "string" && /^[a-z0-9]+(?:-[a-z0-9]+)*$/.test(value) && value.length <= 64;
+    const prepare = (source) => {
+        if (typeof source !== "object" ||
+            source === null ||
+            !identity(source.id) ||
+            !Array.isArray(source.points) ||
+            !Array.isArray(source.spans) ||
+            source.points.length !== source.spans.length ||
+            source.spans.some((span) => !identity(span)))
+            fail("INVALID_TOPOLOGY", "Offset contours require identified points and paired span slots.");
+        logicalCount += source.points.length;
+        assertSamplingCount(logicalCount, operation, limits.maxProfilePoints);
+        if (logicalCount * 176 > limits.maxBytes)
+            fail("COMPLEXITY_LIMIT", "Offset planning exceeds the configured intermediate byte ceiling.");
+        const points = [];
+        const slots = [];
+        for (const point of source.points) {
+            if (!Array.isArray(point) ||
+                point.length !== 2 ||
+                point.some((value) => !Number.isFinite(value)))
+                fail("NON_FINITE_VALUE", "Offset contours require finite XY points.", source.id);
+            const previous = points.at(-1);
+            if (previous === undefined || previous[0] !== point[0] || previous[1] !== point[1])
+                points.push(Object.freeze([point[0], point[1]]));
+            slots.push(points.length - 1);
+        }
+        if (points.length > 1 &&
+            points[0][0] === points.at(-1)[0] &&
+            points[0][1] === points.at(-1)[1]) {
+            const last = points.length - 1;
+            points.pop();
+            for (let index = 0; index < slots.length; index++)
+                if (slots[index] === last)
+                    slots[index] = 0;
+        }
+        if (points.length < 3)
+            fail("DEGENERATE_GEOMETRY", "An offset boundary needs three physical vertices.", source.id);
+        const directions = points.map((point, index) => {
+            const delta = difference(points[(index + 1) % points.length], point);
+            const length = Math.hypot(...delta);
+            if (!(length > 0) || !Number.isFinite(length))
+                fail("DEGENERATE_GEOMETRY", "Offset edges require finite positive length.", source.id);
+            return [delta[0] / length, delta[1] / length];
+        });
+        const motion = directions.map((edge, index) => {
+            const previous = directions[(index + directions.length - 1) % directions.length];
+            const denominator = 1 + dot(previous, edge);
+            if (!(denominator > Number.EPSILON * 8))
+                fail("DEGENERATE_GEOMETRY", "Offset boundaries cannot backtrack.", source.id);
+            const result = [
+                (-previous[1] - edge[1]) / denominator,
+                (previous[0] + edge[0]) / denominator,
+            ];
+            if (!result.every(Number.isFinite))
+                fail("NON_FINITE_VALUE", "Offset corner motion exceeds numeric precision.", source.id);
+            return Object.freeze(result);
+        });
+        // A logical point on a straight run follows the run's corresponding edge
+        // fraction. A normal-only velocity could let a nearby moving corner overtake it.
+        const corners = directions.flatMap((edge, index) => {
+            const previous = directions[(index + directions.length - 1) % directions.length];
+            return Math.abs(cross(previous, edge)) > Number.EPSILON * 32 ? [index] : [];
+        });
+        if (corners.length < 3)
+            fail("DEGENERATE_GEOMETRY", "Offset boundaries need three resolved corners.", source.id);
+        for (let corner = 0; corner < corners.length; corner++) {
+            const first = corners[corner], last = corners[(corner + 1) % corners.length];
+            const start = points[first], end = points[last];
+            const delta = difference(end, start), squaredLength = dot(delta, delta);
+            for (let index = (first + 1) % points.length; index !== last; index = (index + 1) % points.length) {
+                const fraction = dot(difference(points[index], start), delta) / squaredLength;
+                motion[index] = Object.freeze([
+                    motion[first][0] + (motion[last][0] - motion[first][0]) * fraction,
+                    motion[first][1] + (motion[last][1] - motion[first][1]) * fraction,
+                ]);
+            }
+        }
+        return Object.freeze({
+            id: source.id,
+            spans: Object.freeze([...source.spans]),
+            slots: Object.freeze(slots),
+            points: Object.freeze(points),
+            motion: Object.freeze(motion),
+        });
+    };
+    const componentIds = new Set();
+    const components = profile.components.map((component) => {
+        if (typeof component !== "object" ||
+            component === null ||
+            !identity(component.id) ||
+            componentIds.has(component.id) ||
+            !Array.isArray(component.holes))
+            fail("INVALID_TOPOLOGY", "Offset components require unique identities and explicit holes.");
+        componentIds.add(component.id);
+        const outer = prepare(component.outer);
+        const holes = component.holes.map(prepare);
+        const ids = new Set([outer.id]);
+        for (const hole of holes) {
+            if (ids.has(hole.id))
+                fail("INVALID_TOPOLOGY", "Offset contour identities must be unique.");
+            ids.add(hole.id);
+        }
+        if (signedContourArea(outer.points) <= 0 ||
+            holes.some((hole) => signedContourArea(hole.points) >= 0))
+            fail("INVALID_TOPOLOGY", "Offset outer contours must be CCW and holes clockwise.");
+        return { id: component.id, outer, holes };
+    });
+    const initial = normalizeRegionWithWork(components.map((component) => ({
+        outer: component.outer.points,
+        holes: component.holes.map((hole) => hole.points),
+    })));
+    const contours = components.flatMap((component) => [component.outer, ...component.holes]);
+    const allPoints = contours.flatMap((contour) => contour.points);
+    let minX = Infinity, minY = Infinity, maxX = -Infinity, maxY = -Infinity;
+    for (const [x, y] of allPoints) {
+        minX = Math.min(minX, x);
+        minY = Math.min(minY, y);
+        maxX = Math.max(maxX, x);
+        maxY = Math.max(maxY, y);
+    }
+    const tolerance = resolveGeometryTolerance(Math.max(maxX - minX, maxY - minY));
+    const epsilon = Math.max(tolerance.linear, Number.EPSILON * 16 * Math.max(Math.abs(minX), Math.abs(maxX), Math.abs(minY), Math.abs(maxY)));
+    const pointAt = (point, velocity, distance) => distance === 0 ? point : [point[0] + distance * velocity[0], point[1] + distance * velocity[1]];
+    const edges = contours.flatMap((contour) => contour.points.map((a, index) => {
+        const next = (index + 1) % contour.points.length;
+        const b = contour.points[next], av = contour.motion[index], bv = contour.motion[next];
+        const delta = difference(b, a), length = Math.hypot(...delta);
+        const direction = [delta[0] / length, delta[1] / length];
+        const lengthSlope = dot(difference(bv, av), direction);
+        for (const distance of range) {
+            if (!(length + lengthSlope * distance > epsilon))
+                fail("DEGENERATE_GEOMETRY", "Treatment offset collapses or reverses a contour edge.", contour.id);
+        }
+        const endpoints = [
+            pointAt(a, av, range[0]),
+            pointAt(a, av, range[1]),
+            pointAt(b, bv, range[0]),
+            pointAt(b, bv, range[1]),
+        ];
+        if (endpoints.some((point) => point.some((value) => !Number.isFinite(value))))
+            fail("NON_FINITE_VALUE", "Offset coordinates exceed numeric precision.", contour.id);
+        return {
+            contour,
+            index,
+            a,
+            b,
+            av,
+            bv,
+            direction,
+            length,
+            lengthSlope,
+            minX: Math.min(...endpoints.map((point) => point[0])) - epsilon,
+            maxX: Math.max(...endpoints.map((point) => point[0])) + epsilon,
+            minY: Math.min(...endpoints.map((point) => point[1])) - epsilon,
+            maxY: Math.max(...endpoints.map((point) => point[1])) + epsilon,
+        };
+    }));
+    // Intersect affine inequalities c + slope*d >= 0 over the complete distance interval.
+    const intersect = (bounds, constant, slope) => {
+        if (slope === 0)
+            return constant >= 0;
+        const root = -constant / slope;
+        if (slope > 0)
+            bounds[0] = Math.max(bounds[0], root);
+        else
+            bounds[1] = Math.min(bounds[1], root);
+        return bounds[0] <= bounds[1];
+    };
+    const collide = (a, b) => {
+        const bounds = [range[0], range[1]];
+        const delta = difference(b.a, a.a), deltaSlope = difference(b.av, a.av);
+        const determinant = cross(a.direction, b.direction);
+        if (Math.abs(determinant) > tolerance.angular) {
+            const alongA = cross(delta, b.direction) / determinant;
+            const alongASlope = cross(deltaSlope, b.direction) / determinant;
+            const alongB = cross(delta, a.direction) / determinant;
+            const alongBSlope = cross(deltaSlope, a.direction) / determinant;
+            const slack = epsilon / Math.abs(determinant);
+            return (intersect(bounds, alongA + slack, alongASlope) &&
+                intersect(bounds, a.length - alongA + slack, a.lengthSlope - alongASlope) &&
+                intersect(bounds, alongB + slack, alongBSlope) &&
+                intersect(bounds, b.length - alongB + slack, b.lengthSlope - alongBSlope));
+        }
+        // Near-parallel support lines need both line coincidence and tangential overlap.
+        const distance = cross(a.direction, delta), distanceSlope = cross(a.direction, deltaSlope);
+        const longest = Math.max(a.length + a.lengthSlope * range[0], a.length + a.lengthSlope * range[1], b.length + b.lengthSlope * range[0], b.length + b.lengthSlope * range[1]);
+        const slack = epsilon + Math.abs(determinant) * longest;
+        if (!intersect(bounds, slack - distance, -distanceSlope) ||
+            !intersect(bounds, slack + distance, distanceSlope))
+            return false;
+        const same = dot(a.direction, b.direction) >= 0;
+        const lowPoint = same ? b.a : b.b, lowVelocity = same ? b.av : b.bv;
+        const highPoint = same ? b.b : b.a, highVelocity = same ? b.bv : b.av;
+        const low = dot(difference(lowPoint, a.a), a.direction);
+        const lowSlope = dot(difference(lowVelocity, a.av), a.direction);
+        const high = dot(difference(highPoint, a.a), a.direction);
+        const highSlope = dot(difference(highVelocity, a.av), a.direction);
+        return (intersect(bounds, high + epsilon, highSlope) &&
+            intersect(bounds, a.length - low + epsilon, a.lengthSlope - lowSlope));
+    };
+    edges.sort((a, b) => a.minX - b.minX || a.minY - b.minY);
+    const active = [];
+    let workCount = initial.workCount;
+    for (const current of edges) {
+        let retained = 0;
+        for (const candidate of active) {
+            if (++workCount > maximumWork)
+                fail("COMPLEXITY_LIMIT", "Offset validation exceeds the 2000000 candidate-work ceiling.");
+            if (candidate.maxX < current.minX)
+                continue;
+            active[retained++] = candidate;
+            if (candidate.maxY < current.minY || current.maxY < candidate.minY)
+                continue;
+            if (candidate.contour === current.contour &&
+                ((candidate.index + 1) % current.contour.points.length === current.index ||
+                    (current.index + 1) % current.contour.points.length === candidate.index))
+                continue;
+            if (collide(candidate, current))
+                fail("SELF_INTERSECTION", "Treatment offsets make source boundaries contact or intersect.", current.contour.id);
+        }
+        active.length = retained;
+        active.push(current);
+    }
+    const magnification = contours.reduce((maximum, contour) => contour.motion.reduce((maximum, motion) => Math.max(maximum, Math.hypot(...motion)), maximum), 1);
+    const contourAt = (contour, distance) => ({
+        id: contour.id,
+        spans: contour.spans,
+        points: Object.freeze(contour.slots.map((slot) => Object.freeze(pointAt(contour.points[slot], contour.motion[slot], distance)))),
+    });
+    return Object.freeze({
+        magnification,
+        workCount,
+        profileAt(distance) {
+            if (!Number.isFinite(distance))
+                fail("NON_FINITE_VALUE", "Offset distance must be finite.");
+            if (distance < range[0] || distance > range[1])
+                fail("INVALID_ARGUMENT", "Offset distance is outside the validated interval.");
+            return Object.freeze({
+                components: Object.freeze(components.map((component) => Object.freeze({
+                    id: component.id,
+                    outer: Object.freeze(contourAt(component.outer, distance)),
+                    holes: Object.freeze(component.holes.map((hole) => Object.freeze(contourAt(hole, distance)))),
+                }))),
+            });
+        },
+    });
+}

package/dist/geometry/regions.js

@@ -274,6 +274,17 @@ const normalizePolygonWithBudget = (polygon, tolerance, budget) => {
  * Previously validated immutable results may be returned unchanged under the same tolerance policy.
  */
 export function normalizeRegion(region, tolerance = {}) {
+    return normalizeRegionWithWork(region, tolerance).region;
+}
+/** @internal Shares normalization's bounded predicate work with a containing operation. */
+export function normalizeRegionWithWork(region, tolerance = {}) {
+    const budget = { candidates: 0 };
+    return {
+        region: normalizeRegionWithBudget(region, tolerance, budget),
+        workCount: budget.candidates,
+    };
+}
+function normalizeRegionWithBudget(region, tolerance, budget) {
     const policy = resolveGeometryTolerance(1, tolerance);
     if (samePolicy(normalizedRegions.get(region), policy))
         return region;
@@ -282,7 +293,6 @@ export function normalizeRegion(region, tolerance = {}) {
             throw new GeometryError("INVALID_TOPOLOGY", "Region polygons must not contain missing entries.");
         }
     }
-    const budget = { candidates: 0 };
     const polygons = region.map((polygon) => normalizePolygonWithBudget(polygon, policy, budget));
     const containsFilledPoint = (polygon, point) => contourContainsPoint(polygon.outer, point) &&
         !polygon.holes.some((hole) => contourContainsPoint(hole, point));

package/dist/model/execution-binding.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../geometry/errors.js";
 // One protocol key lets locally bundled operation wrappers resolve the host's execution
 // without depending on package instances, class identity, or initializing a native runtime.
-const executionKey = Symbol.for("@metamesh/modeling/execution/11");
+const executionKey = Symbol.for("@metamesh/modeling/execution/12");
 const bindings = globalThis;
 /** Internal host binding. Executable callbacks are synchronous and may not nest executions. */
 export function bindModelContext(context, build) {
@@ -10,7 +10,7 @@ export function bindModelContext(context, build) {
             operation: "build",
         });
     }
-    bindings[executionKey] = { version: 11, context };
+    bindings[executionKey] = { version: 12, context };
     try {
         return build();
     }
@@ -31,5 +31,5 @@ export function currentModelContext(operation) {
 /** Reads an optional binding without initializing an engine or creating ambient authoring state. */
 export function activeModelContext() {
     const binding = bindings[executionKey];
-    return binding?.version === 11 ? binding.context : undefined;
+    return binding?.version === 12 ? binding.context : undefined;
 }