@metamesh/modeling 0.11.0 → 0.13.0

package/dist/engine/deferred-context.js

@@ -1,7 +1,8 @@
 import { GeometryError } from "../geometry/errors.js";
+import { gridPatternPlan, linearPatternPlan, pathPatternPlan, radialPatternPlan, } from "../geometry/patterns/placements.js";
 import { geometryRecipe, isGeometryRecipe, recordGeometryRecipe, } from "./geometry-recipes.js";
 import { captureRecipeInputs } from "./immutable-generation-data.js";
-import { gridPatternPlan, linearPatternPlan, pathPatternPlan, radialPatternPlan, } from "./pattern-placements.js";
+import { sectionPatternTransform } from "./pattern-transform.js";
 import { RecipeRealization } from "./recipe-realization.js";
 // Every public operation must explicitly choose its realization and result behavior.
 const operationBehaviors = {
@@ -25,7 +26,7 @@ const operationBehaviors = {
     threadedRod: "solid",
     threadedNut: "solid",
     internalThreadCutter: "solid",
-    sectionFromContours: "section",
+    polygon: "section",
     fromRegion: "section",
     rectangle: "section",
     circle: "section",
@@ -157,11 +158,19 @@ function declarePattern(operation, resolution, supplied, declaration) {
         });
     const source = supplied[0];
     const copies = [];
+    let kind;
     for (let index = 0; index < plan.count; index++) {
         const shape = typeof source === "function"
             ? source(index)
             : source;
-        copies.push(declareOperation("transform", resolution, [shape, plan.transformAt(index)], declaration));
+        const currentKind = inputKind(shape);
+        if (kind !== undefined && kind !== currentKind)
+            throw new GeometryError("INVALID_ARGUMENT", "Pattern factories must return one shape dimension.", {
+                operation,
+            });
+        kind = currentKind;
+        const matrix = plan.transformAt(index);
+        copies.push(declareOperation("transform", resolution, [shape, kind === "section" ? sectionPatternTransform(matrix, operation) : matrix], declaration));
     }
     return Object.freeze(copies);
 }

package/dist/engine/execution.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "../geometry/errors.js";
-import { analyzeTriangleMesh, } from "../geometry/mesh.js";
+import { analyzeTriangleMesh, } from "../geometry/mesh/mesh.js";
 import { assertMeshAllocationWithinLimits } from "../geometry/model-limits.js";
 import { assertSamplingCount } from "../geometry/sampling-limits.js";
 import { createSectionHandle, createSolidHandle } from "../model/shape-handles.js";

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

@@ -1,7 +1,7 @@
 import { Zip, ZipDeflate } from "fflate";
 import { GeometryError } from "../geometry/errors.js";
-import { analyzeSolidMesh } from "../geometry/mesh-solid.js";
-import { analyzeTriangleMesh } from "../geometry/mesh.js";
+import { analyzeSolidMesh } from "../geometry/mesh/mesh-solid.js";
+import { analyzeTriangleMesh } from "../geometry/mesh/mesh.js";
 import { MeshViewCache } from "./mesh-view-cache.js";
 const namespace = "http://schemas.microsoft.com/3dmanufacturing/core/2015/02";
 const declaration = '<?xml version="1.0" encoding="UTF-8"?>';

package/dist/engine/finalization.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../geometry/errors.js";
-import { optimizePlanarPatches } from "../geometry/mesh-planar.js";
-import { validateAnalyzedSolidMesh } from "../geometry/mesh-solid.js";
-import { analyzeTriangleMesh, } from "../geometry/mesh.js";
+import { optimizePlanarPatches } from "../geometry/mesh/mesh-planar.js";
+import { validateAnalyzedSolidMesh } from "../geometry/mesh/mesh-solid.js";
+import { analyzeTriangleMesh, } from "../geometry/mesh/mesh.js";
 import { immutableMeshView } from "../model/immutable-buffer.js";
 import { MeshViewCache } from "./mesh-view-cache.js";
 import { copiedMeshViews, copiedUint32Array } from "./native/copied-views.js";

package/dist/engine/immutable-generation-data.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../geometry/errors.js";
 import { adoptImmutableBuffer, immutableBuffer, immutableBufferView, isImmutableBuffer, } from "../model/immutable-buffer.js";
 import { geometryRecipe, isGeometryRecipe } from "./geometry-recipes.js";
-const mutableBufferMessage = "Generation data cannot contain mutable typed arrays or raw ArrayBuffers. Use immutableBuffer(array) or immutableMesh(mesh) before caching or binding them.";
+const mutableBufferMessage = "Generation data cannot contain mutable typed arrays or raw ArrayBuffers. Use immutableBuffer(array) or immutableMesh(mesh) before caching them or declaring dependencies.";
 /** Iterates plain fields; recipe capture may read each enumerable accessor once. */
 export function* generationDataEntries(value, captureAccessors = false) {
     const prototype = Object.getPrototypeOf(value);
@@ -144,15 +144,18 @@ export function compareGenerationValues(left, right) {
     };
     return compare(left, right);
 }
-function captureValue(value, recipeInputs, readerAllowed = () => false) {
+function captureValue(value, mode, readerAllowed = () => false, validated) {
+    const recipeInputs = mode === "recipe";
     const seen = new Map();
     const copy = (input) => {
         if (typeof input === "function" && !recipeInputs && !readerAllowed(input))
-            throw new GeometryError("INVALID_ARGUMENT", "Computed values and bindings cannot contain arbitrary function closures.", { operation: "computed" });
+            throw new GeometryError("INVALID_ARGUMENT", "Computed values and dependencies cannot contain arbitrary function closures.", { operation: "computed" });
         if (typeof input !== "object" || input === null || isGeometryRecipe(input))
             return input;
         if (isImmutableBuffer(input))
             return adoptImmutableBuffer(input);
+        if (mode === "dependency" && validated?.has(input))
+            return input;
         const old = seen.get(input);
         if (old !== undefined)
             return old;
@@ -166,6 +169,14 @@ function captureValue(value, recipeInputs, readerAllowed = () => false) {
         if (input instanceof ArrayBuffer)
             throw new TypeError(mutableBufferMessage);
         const entries = generationDataEntries(input, recipeInputs);
+        if (mode === "dependency") {
+            if (!Object.isFrozen(input))
+                throw new GeometryError("INVALID_ARGUMENT", "Computed dependencies require deeply immutable objects and arrays. Read params inside the callback, use a computed value, or depend on individual scalar values.", { operation: "computed" });
+            seen.set(input, input);
+            for (const [, field] of entries)
+                copy(field);
+            return input;
+        }
         const result = Array.isArray(input)
             ? new Array(input.length)
             : Object.create(Object.getPrototypeOf(input) === null ? null : Object.prototype);
@@ -174,13 +185,32 @@ function captureValue(value, recipeInputs, readerAllowed = () => false) {
             Object.defineProperty(result, key, { value: copy(field), enumerable: true });
         return Object.freeze(result);
     };
-    return copy(value);
+    const result = copy(value);
+    // Cache validation only after the complete immutable graph succeeds, including cycles.
+    if (mode === "dependency")
+        for (const input of seen.keys())
+            validated?.add(input);
+    return result;
 }
 /** Validates while capturing immutable data; only explicitly allowed session readers may be functions. */
 export function captureGenerationValue(value, readerAllowed) {
-    return captureValue(value, false, readerAllowed);
+    return captureValue(value, "data", readerAllowed);
+}
+/** Snapshots the list, preserving immutable entry identities and validating each object only once. */
+export function captureGenerationDependencies(values, readerAllowed, validated) {
+    const inputs = [];
+    for (const [key, value] of generationDataEntries(values)) {
+        if (key !== String(inputs.length))
+            throw new TypeError("Computed dependencies must be a dense array without extra fields.");
+        inputs.push(value);
+    }
+    if (inputs.length !== values.length)
+        throw new TypeError("Computed dependencies must be a dense array without extra fields.");
+    const result = Object.freeze(inputs);
+    captureValue(result, "dependency", readerAllowed, validated);
+    return result;
 }
 /** Captures ordinary inputs once, including accessor values and mutable numeric arrays. */
 export function captureRecipeInputs(values) {
-    return captureValue(values, true);
+    return captureValue(values, "recipe");
 }

package/dist/engine/loft-operations.js

@@ -1,8 +1,8 @@
 import { GeometryError } from "../geometry/errors.js";
-import { loftProfilePointCount, pointLoftProfile, prepareLoftGeometry, } from "../geometry/loft-geometry.js";
-import { loftFrame, resolveLoftControls } from "../geometry/loft-options.js";
-import { simpleLoftMesh } from "../geometry/loft-simple-mesh.js";
-import { measureTriangleMesh } from "../geometry/mesh.js";
+import { loftProfilePointCount, pointLoftProfile, prepareLoftGeometry, } from "../geometry/loft/loft-geometry.js";
+import { loftFrame, resolveLoftControls } from "../geometry/loft/loft-options.js";
+import { simpleLoftMesh } from "../geometry/loft/loft-simple-mesh.js";
+import { measureTriangleMesh } from "../geometry/mesh/mesh.js";
 import { assertSamplingCount } from "../geometry/sampling-limits.js";
 import { correspondingPrimitiveProfiles, rectangularPrimitiveFamily, } from "./primitive-profiles.js";
 import { buildProfileLoftMesh } from "./profile-mesh.js";

package/dist/engine/native/adapter.js

@@ -1,4 +1,4 @@
-import { validateTriangleMesh } from "../../geometry/mesh.js";
+import { validateTriangleMesh } from "../../geometry/mesh/mesh.js";
 import { assertNativeSolidStatus } from "./status.js";
 /**
  * Constructs a live Manifold solid from a copied indexed triangle mesh.

package/dist/engine/native/regions.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "../../geometry/errors.js";
-import { loopContainsPoint, normalizeLoop2, normalizeRegion2, signedAreaLoop2, } from "../../geometry/regions.js";
+import { contourContainsPoint, normalizeContour, normalizeRegion, signedContourArea, } 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;
@@ -75,7 +75,7 @@ const contoursFromRegion = (region) => region
  */
 export function regionToCrossSection(context, region, limits = {}) {
     assertRegionBounds([region], "regionToCrossSection", limits);
-    const normalized = normalizeRegion2(region);
+    const normalized = normalizeRegion(region);
     const module = scopedManifoldModule(context);
     if (normalized.length === 0)
         return ownScopedManifoldValue(context, module.CrossSection.union([]));
@@ -83,11 +83,11 @@ export function regionToCrossSection(context, region, limits = {}) {
 }
 const regionFromLoops = (loops) => {
     const outers = loops
-        .filter((loop) => signedAreaLoop2(loop) > 0)
-        .map((outer) => ({ outer: normalizeLoop2(outer, true), holes: [] }));
+        .filter((loop) => signedContourArea(loop) > 0)
+        .map((outer) => ({ outer: normalizeContour(outer, true), holes: [] }));
     const holes = loops
-        .filter((loop) => signedAreaLoop2(loop) < 0)
-        .map((hole) => normalizeLoop2(hole, false));
+        .filter((loop) => signedContourArea(loop) < 0)
+        .map((hole) => normalizeContour(hole, false));
     if (outers.length === 0 && loops.length > 0) {
         throw new GeometryError("INVALID_TOPOLOGY", "CrossSection did not contain an exterior contour.");
     }
@@ -113,15 +113,15 @@ const regionFromLoops = (loops) => {
                 x <= bounds.maximumX &&
                 y >= bounds.minimumY &&
                 y <= bounds.maximumY &&
-                loopContainsPoint(polygon.outer, hole[0]));
+                contourContainsPoint(polygon.outer, hole[0]));
         })
-            .sort((a, b) => Math.abs(signedAreaLoop2(a.outer)) - Math.abs(signedAreaLoop2(b.outer)))[0];
+            .sort((a, b) => Math.abs(signedContourArea(a.outer)) - Math.abs(signedContourArea(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) })));
+    return normalizeRegion(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 = {}) {

package/dist/engine/pattern-operations.js

@@ -1,36 +1,47 @@
+import { gridPatternPlan, linearPatternPlan, pathPatternPlan, radialPatternPlan, } from "../geometry/patterns/placements.js";
+import { assertSamplingCount } from "../geometry/sampling-limits.js";
 import { IDENTITY_TRANSFORM3 } from "../geometry/transform3.js";
-import { gridPatternPlan, linearPatternPlan, pathPatternPlan, radialPatternPlan, } from "./pattern-placements.js";
+import { sectionPatternTransform } from "./pattern-transform.js";
 /** Private pattern owner; all copies use the shared transform/metadata/lifetime path. */
 export function createPatternOperations(environment, transforms) {
     const apply = (source, makePlan, operation) => {
         environment.assertActive();
         const plan = makePlan();
         let vertices = 0, triangles = 0;
-        const budget = (solid, multiplier) => {
-            const native = environment.nativeSolid(solid);
-            vertices += native.numVert() * multiplier;
-            triangles += native.numTri() * multiplier;
+        let kind;
+        const budget = (shape, multiplier) => {
+            const native = environment.resolveHandle(shape);
+            if (kind !== undefined && native.kind !== kind)
+                environment.throwGeometryError("INVALID_ARGUMENT", operation, "Pattern factories must return one shape dimension.");
+            kind = native.kind;
+            vertices += native.value.numVert() * multiplier;
+            if (native.kind === "solid")
+                triangles += native.value.numTri() * multiplier;
+            else
+                assertSamplingCount(vertices, operation, environment.limits.maxProfilePoints);
             environment.assertMeshAllocation(vertices, triangles, (vertices + triangles) * 12, operation);
         };
         if (typeof source !== "function")
             budget(source, plan.count);
         const copies = [];
         for (let index = 0; index < plan.count; index++) {
-            const solid = typeof source === "function" ? source(index) : source;
+            const shape = typeof source === "function" ? source(index) : source;
             if (typeof source === "function")
-                budget(solid, 1);
+                budget(shape, 1);
             const matrix = plan.transformAt(index);
             copies.push(matrix.every((value, i) => value === IDENTITY_TRANSFORM3[i])
-                ? solid
-                : transforms.operations.transform(solid, matrix));
+                ? shape
+                : kind === "section"
+                    ? transforms.operations.transform(shape, sectionPatternTransform(matrix, operation))
+                    : transforms.operations.transform(shape, matrix));
         }
         return copies;
     };
     const operations = {
-        linearPattern: (source, options) => apply(source, () => linearPatternPlan(options), "linearPattern"),
-        radialPattern: (source, options) => apply(source, () => radialPatternPlan(options), "radialPattern"),
-        gridPattern: (source, options) => apply(source, () => gridPatternPlan(options), "gridPattern"),
-        pathPattern: (source, path, options) => apply(source, () => pathPatternPlan(path, options, environment.limits), "pathPattern"),
+        linearPattern: ((source, options) => apply(source, () => linearPatternPlan(options), "linearPattern")),
+        radialPattern: ((source, options) => apply(source, () => radialPatternPlan(options), "radialPattern")),
+        gridPattern: ((source, options) => apply(source, () => gridPatternPlan(options), "gridPattern")),
+        pathPattern: ((source, path, options) => apply(source, () => pathPatternPlan(path, options, environment.limits), "pathPattern")),
     };
     return operations;
 }

package/dist/engine/pattern-transform.js

@@ -0,0 +1,9 @@
+import { GeometryError } from "../geometry/errors.js";
+/** Converts only plane-preserving pattern placements to a Section's affine XY transform. */
+export function sectionPatternTransform(matrix, operation) {
+    if (Math.abs(matrix[8]) > 1e-10 || Math.abs(matrix[9]) > 1e-10 || Math.abs(matrix[11]) > 1e-10)
+        throw new GeometryError("INVALID_ARGUMENT", "Section patterns must preserve the XY plane.", {
+            operation,
+        });
+    return [matrix[0], matrix[1], matrix[3], matrix[4], matrix[5], matrix[7], 0, 0, 1];
+}

package/dist/engine/placement.js

@@ -1,5 +1,5 @@
-import { validateAnalyzedSolidMesh } from "../geometry/mesh-solid.js";
-import { measureTriangleMesh } from "../geometry/mesh.js";
+import { validateAnalyzedSolidMesh } from "../geometry/mesh/mesh-solid.js";
+import { measureTriangleMesh } from "../geometry/mesh/mesh.js";
 import { composeTransform3, eulerTransform3, translationTransform3, } from "../geometry/transform3.js";
 /** Places already validated immutable geometry once, retaining its indexed topology. */
 export function placeFinalizedGeometry(source, position, rotation, meshValidation) {

package/dist/engine/primitive-operations.js

@@ -1,9 +1,9 @@
 import { resolveCylinderRadii } from "../geometry/cylinder.js";
 import { resolveModelingLimits } from "../geometry/model-limits.js";
 import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
-import { regularPolygonLoop, starLoop } from "../geometry/profiles/profiles.js";
-import { rectangleLoop, resolveRectangle, } from "../geometry/profiles/rectangle.js";
-import { ellipseLoop } from "../geometry/profiles/shapes.js";
+import { regularPolygonContour, starContour } from "../geometry/profiles/profiles.js";
+import { rectangleContour, resolveRectangle, } from "../geometry/profiles/rectangle.js";
+import { ellipseContour } from "../geometry/profiles/shapes.js";
 import { requireProfileVertexCount } from "../geometry/profiles/validation.js";
 import * as kernel from "./native/index.js";
 import { boxAnchors, cylinderAnchors, originAnchor, planarAnchors, sphereAnchors, torusAnchors, tubeAnchors, } from "./primitive-anchors.js";
@@ -12,7 +12,7 @@ import { ellipticalSectionProfile, polygonSectionProfile, rectangleSectionProfil
 export function createPrimitiveOperations(environment, transforms, sections) {
     const { module, scope, assertActive, throwGeometryError, ownSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, withResolutionDefaults, resolveCircularSegments, } = environment;
     const { placedSolid, placedSection } = transforms;
-    const fromContours = sections.sectionFromContours;
+    const fromContours = (contours) => sections.polygon({ contours });
     const operations = {
         box: (value) => {
             assertActive();
@@ -74,7 +74,7 @@ export function createPrimitiveOperations(environment, transforms, sections) {
         rectangle: (value) => placedSection(value, () => {
             assertActive();
             const resolved = withResolutionDefaults(value);
-            resolveRectangle(resolved, "rectangle");
+            const { setbacks } = resolveRectangle(resolved, "rectangle");
             const treatment = value.treatment;
             const resolvedCorner = (corner) => corner.kind === "round" || corner.kind === "smooth"
                 ? withResolutionDefaults({
@@ -92,9 +92,9 @@ export function createPrimitiveOperations(environment, transforms, sections) {
                             : resolvedCorner(treatment),
                     }),
             };
-            const points = rectangleLoop(options);
+            const points = rectangleContour(options);
             const dimensions = typeof value.size === "number" ? [value.size, value.size] : value.size;
-            const section = treatment === undefined
+            const section = setbacks.every((pair) => pair.every((distance) => distance === 0))
                 ? ownSection(module.CrossSection.square(dimensions, value.center ?? true))
                 : fromContours([points]);
             environment.rememberAnchors(section, planarAnchors(dimensions, value.center ?? true));
@@ -122,7 +122,7 @@ export function createPrimitiveOperations(environment, transforms, sections) {
             validateCoordinates(radii, 2, "ellipse");
             const resolved = withResolutionDefaults(value);
             const section = fromContours([
-                ellipseLoop({
+                ellipseContour({
                     radius: radii,
                     segments: resolveCircularSegments(Math.max(...radii), value),
                     limits: resolved.limits,
@@ -132,14 +132,14 @@ export function createPrimitiveOperations(environment, transforms, sections) {
             return environment.rememberPrimitiveProfile(section, ellipticalSectionProfile(radii, value, resolved.resolution, resolved.limits));
         }),
         regularPolygon: (value) => placedSection(value, () => {
-            const resolved = withResolutionDefaults(value), loop = regularPolygonLoop(resolved);
+            const resolved = withResolutionDefaults(value), loop = regularPolygonContour(resolved);
             const section = environment.rememberAnchors(fromContours([loop]), originAnchor());
             return environment.rememberPrimitiveProfile(section, polygonSectionProfile(`polygon-${value.sides}`, loop, resolved.resolution, resolved.limits));
         }),
         star: (value) => placedSection(value, () => {
             const angle = (validateFiniteNumber(value.rotationDegrees ?? 0, "star") * Math.PI) / 180;
             const resolved = withResolutionDefaults(value);
-            const loop = starLoop(value.outerRadius, value.points, value.innerRadius, resolved.limits).map(([x, y]) => [
+            const loop = starContour(value.outerRadius, value.points, value.innerRadius, resolved.limits).map(([x, y]) => [
                 x * Math.cos(angle) - y * Math.sin(angle),
                 x * Math.sin(angle) + y * Math.cos(angle),
             ]);

package/dist/engine/profile-mesh.js

@@ -1,8 +1,8 @@
 import { GeometryError } from "../geometry/errors.js";
-import { loftFrame } from "../geometry/loft-options.js";
+import { loftFrame } from "../geometry/loft/loft-options.js";
 import { assertMeshAllocationWithinLimits } from "../geometry/model-limits.js";
 import { writeMeshVertex } from "../geometry/numeric.js";
-import { normalizeRegion2, signedAreaLoop2 } from "../geometry/regions.js";
+import { normalizeRegion, signedContourArea } from "../geometry/regions.js";
 import { assertSamplingCount } from "../geometry/sampling-limits.js";
 import { resolveSweepScales } from "../geometry/sweeps/options.js";
 import { computeSweepFrames, validateSweepOptions } from "../geometry/sweeps/orientation.js";
@@ -127,17 +127,17 @@ export function buildProfileLoftMesh(module, stations, limits, closed = false, s
         let contourIndex = 0;
         const region = profile.components.map((component) => {
             const outer = physical[contourIndex++];
-            if (!intermediateWorldGrid && !(signedAreaLoop2(outer.points) > 0))
+            if (!intermediateWorldGrid && !(signedContourArea(outer.points) > 0))
                 fail("Matched outer contours must retain CCW winding.");
             const holes = component.holes.map(() => {
                 const hole = physical[contourIndex++];
-                if (!intermediateWorldGrid && !(signedAreaLoop2(hole.points) < 0))
+                if (!intermediateWorldGrid && !(signedContourArea(hole.points) < 0))
                     fail("Matched hole contours must retain CW winding.");
                 return hole.points;
             });
             return { outer: outer.points, holes };
         });
-        const normalized = intermediateWorldGrid ? [] : normalizeRegion2(region);
+        const normalized = intermediateWorldGrid ? [] : normalizeRegion(region);
         normalized.forEach((component, index) => {
             if (component.outer.length !== region[index].outer.length ||
                 component.holes.some((hole, holeIndex) => hole.length !== region[index].holes[holeIndex].length))
@@ -163,7 +163,7 @@ export function buildProfileLoftMesh(module, stations, limits, closed = false, s
             const paired = upper[contourIndex];
             for (let index = 0; index < contour.slots.length; index += 1) {
                 const next = (index + 1) % contour.slots.length;
-                const advance = signedAreaLoop2(paired.points) < 0 ? -seamProfileOffset : seamProfileOffset;
+                const advance = signedContourArea(paired.points) < 0 ? -seamProfileOffset : seamProfileOffset;
                 const offset = closed && station === stations.length - 1
                     ? ((advance % paired.slots.length) + paired.slots.length) % paired.slots.length
                     : 0;
@@ -217,7 +217,7 @@ export function buildProfileSweepMesh(module, profile, inputPath, options, limit
         for (const contour of contourList(profile)) {
             const extent = contour.points.reduce((maximum, [x, y]) => Math.max(maximum, Math.abs(x * scaleX), Math.abs(y * scaleY)), 1);
             const tolerance = resolveGeometryTolerance(extent).linear;
-            const advance = signedAreaLoop2(contour.points) < 0 ? -seamProfileOffset : seamProfileOffset;
+            const advance = signedContourArea(contour.points) < 0 ? -seamProfileOffset : seamProfileOffset;
             const offset = ((advance % contour.points.length) + contour.points.length) % contour.points.length;
             for (let index = 0; index < contour.points.length; index++) {
                 const [x, y] = contour.points[index], target = contour.points[(index + offset) % contour.points.length];

package/dist/engine/section-operations.js

@@ -7,32 +7,43 @@ import * as kernel from "./native/index.js";
 export function createSectionOperations(environment, transforms) {
     const { module, limits, scope, assertActive, throwGeometryError, nativeSolid, nativeSection, wrapSection, ownSection, validateFiniteNumber, validateCoordinates, assertOperandCount, withResolutionDefaults, resolveCircularSegments, } = environment;
     const { translate } = transforms.operations;
-    const fromContours = (contours, value = {}) => {
+    const fromContours = (contours, fillRule = "nonzero") => {
         assertActive();
-        if (typeof value !== "object" || value === null || Array.isArray(value))
-            throwGeometryError("INVALID_ARGUMENT", "sectionFromContours", "Options must be an object.");
-        assertOperandCount(contours, "sectionFromContours", 0);
+        assertOperandCount(contours, "polygon", 0);
         let count = 0;
         const copied = Array.from(contours, (contour) => {
             if (!Array.isArray(contour) || contour.length < 3)
-                throwGeometryError("INVALID_ARGUMENT", "sectionFromContours", "Each contour needs at least three points.");
+                throwGeometryError("INVALID_ARGUMENT", "polygon", "Each contour needs at least three points.");
             count += contour.length;
-            assertSamplingCount(count, "sectionFromContours", limits.maxProfilePoints);
+            assertSamplingCount(count, "polygon", limits.maxProfilePoints);
             return Array.from(contour, (point) => {
-                validateCoordinates(point, 2, "sectionFromContours");
+                validateCoordinates(point, 2, "polygon");
                 return [point[0], point[1]];
             });
         });
-        if (value.fillRule !== undefined &&
-            value.fillRule !== "nonzero" &&
-            value.fillRule !== "evenodd")
-            throwGeometryError("INVALID_ARGUMENT", "sectionFromContours", "Unsupported fill rule.");
+        if (fillRule !== "nonzero" && fillRule !== "evenodd")
+            throwGeometryError("INVALID_ARGUMENT", "polygon", "Unsupported fill rule.");
         if (copied.length === 0)
             return ownSection(module.CrossSection.union([]));
-        return ownSection(new module.CrossSection(copied, value.fillRule === "evenodd" ? "EvenOdd" : "NonZero"));
+        return ownSection(new module.CrossSection(copied, fillRule === "evenodd" ? "EvenOdd" : "NonZero"));
     };
     const operations = {
-        sectionFromContours: fromContours,
+        polygon: (input) => {
+            assertActive();
+            if (Array.isArray(input))
+                return fromContours([input]);
+            if (typeof input !== "object" || input === null)
+                throwGeometryError("INVALID_ARGUMENT", "polygon", "Use an outline or polygon options.");
+            const options = input;
+            if ("outer" in options) {
+                if ("contours" in options || "fillRule" in options)
+                    throwGeometryError("INVALID_ARGUMENT", "polygon", "Explicit topology excludes compound fill options.");
+                return wrapSection(kernel.regionToCrossSection(scope, [{ outer: options.outer, holes: options.holes === undefined ? [] : options.holes }], limits));
+            }
+            if (!("contours" in options) || "holes" in options)
+                throwGeometryError("INVALID_ARGUMENT", "polygon", "Compound fill requires contours without explicit holes.");
+            return fromContours(options.contours, options.fillRule);
+        },
         fromRegion: (region) => {
             assertActive();
             return wrapSection(kernel.regionToCrossSection(scope, region, limits));
@@ -77,7 +88,7 @@ export function createSectionOperations(environment, transforms) {
         },
         svgPathSection: (path, value = {}) => {
             const parsed = parseSvgPath(path, withResolutionDefaults(value));
-            const filled = parsed.groups.map((group) => fromContours(group.contours, { fillRule: group.fillRule }));
+            const filled = parsed.groups.map((group) => fromContours(group.contours, group.fillRule));
             let result = ownSection(module.CrossSection.union(filled.map(nativeSection)));
             if ((value.origin ?? "center") === "center") {
                 const bounds = nativeSection(result).bounds();