@metamesh/modeling 0.12.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/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();

package/dist/engine/session-graph.js

@@ -384,18 +384,20 @@ export function createGenerationGraph(options, maxParts) {
                     // Catching an assertion does not turn its revision into a successful snapshot.
                     assertNoFailedAssertion();
                     declaring = false;
-                    if (!isArray(output) || output.length === 0)
+                    const parts = isArray(output) ? output : [output];
+                    if (parts.length === 0)
                         invalid("Generation must return at least one declared part.");
-                    if (output.length > maxParts)
+                    if (parts.length > maxParts)
                         throw new GeometryError("COMPLEXITY_LIMIT", `Output exceeds ${maxParts} parts.`, {
                             operation: "generate",
                         });
                     const returnedIds = new Set();
-                    for (const descriptor of output) {
+                    for (const descriptor of parts) {
                         if (!declaredParts.has(descriptor) || returnedIds.has(descriptor.id))
                             invalid("Return each declared output part at most once.");
                         returnedIds.add(descriptor.id);
                     }
+                    return parts;
                 },
                 dependencies(output) {
                     return createModelDependencies(output, modelParameters, new Map([...computations.nodes].map(([id, node]) => [id, reusableEntry(node)])), readerIds);

package/dist/engine/session.js

@@ -110,8 +110,7 @@ class SessionRevision {
     generate(revision, deferred, native, mode) {
         const { program, services, caches } = this.session;
         const startedAt = performance.now();
-        const output = program.generate({ ...revision.context, services });
-        revision.finish(output);
+        const output = revision.finish(program.generate({ ...revision.context, services }));
         if (mode === "validate")
             return { kind: "validation", diagnostics: Object.freeze([...revision.diagnostics]) };
         const captured = caches.snapshots.capture({

package/dist/geometry/bounds.js

@@ -0,0 +1,117 @@
+import { GeometryError } from "./errors.js";
+function fail(operation, message) {
+    throw new GeometryError("INVALID_ARGUMENT", message, { operation });
+}
+function isArray(value) {
+    return Array.isArray(value);
+}
+function vector(values, operation) {
+    if (values.some((value) => !Number.isFinite(value)))
+        fail(operation, "Bounds calculations must produce finite coordinates.");
+    const normalized = values.map((value) => (value === 0 ? 0 : value));
+    return values.length === 2
+        ? Object.freeze([normalized[0], normalized[1]])
+        : Object.freeze([normalized[0], normalized[1], normalized[2]]);
+}
+function validate(bounds, operation) {
+    if (typeof bounds !== "object" ||
+        bounds === null ||
+        !isArray(bounds.min) ||
+        !isArray(bounds.max) ||
+        (bounds.min.length !== 2 && bounds.min.length !== 3) ||
+        bounds.max.length !== bounds.min.length)
+        fail(operation, "Bounds require matching XY or XYZ minimum and maximum tuples.");
+    for (let axis = 0; axis < bounds.min.length; axis++) {
+        const minimum = bounds.min[axis], maximum = bounds.max[axis];
+        if (!Number.isFinite(minimum) || !Number.isFinite(maximum) || minimum > maximum)
+            fail(operation, "Bounds coordinates must be finite and ordered from minimum to maximum.");
+        if (!Number.isFinite(maximum - minimum))
+            fail(operation, "Bounds dimensions must be finite.");
+    }
+    return bounds.min.length;
+}
+function size(bounds) {
+    return bounds.max.map((value, axis) => value - bounds.min[axis]);
+}
+function center(bounds) {
+    return bounds.min.map((value, axis) => value / 2 + bounds.max[axis] / 2);
+}
+export function boundsFromSize(dimensions, options = {}) {
+    const operation = "boundsFromSize";
+    if (!isArray(dimensions) ||
+        (dimensions.length !== 2 && dimensions.length !== 3) ||
+        Array.from(dimensions).some((value) => !Number.isFinite(value) || value < 0))
+        fail(operation, "Bounds dimensions require two or three finite nonnegative values.");
+    if (typeof options !== "object" ||
+        options === null ||
+        isArray(options) ||
+        (options.center !== undefined && typeof options.center !== "boolean"))
+        fail(operation, "Bounds placement requires an optional boolean center value.");
+    const centered = options.center ?? true;
+    return Object.freeze({
+        min: vector(dimensions.map((value) => (centered ? -value / 2 : 0)), operation),
+        max: vector(dimensions.map((value) => (centered ? value / 2 : value)), operation),
+    });
+}
+export function boundsSize(bounds) {
+    validate(bounds, "boundsSize");
+    return vector(size(bounds), "boundsSize");
+}
+export function boundsCenter(bounds) {
+    validate(bounds, "boundsCenter");
+    return vector(center(bounds), "boundsCenter");
+}
+export function containsBounds(outer, inner) {
+    const dimension = validate(outer, "containsBounds");
+    if (validate(inner, "containsBounds") !== dimension)
+        fail("containsBounds", "Contained bounds must have the same dimension.");
+    return outer.min.every((value, axis) => inner.min[axis] >= value && inner.max[axis] <= outer.max[axis]);
+}
+export function fitBounds(source, target, options = {}) {
+    const operation = "fitBounds";
+    const dimension = validate(source, operation);
+    if (validate(target, operation) !== dimension)
+        fail(operation, "Source and target bounds must have the same dimension.");
+    if (typeof options !== "object" || options === null || isArray(options))
+        fail(operation, "Fitting options must be an object.");
+    if (options.maxScale !== undefined &&
+        (!Number.isFinite(options.maxScale) || options.maxScale <= 0))
+        fail(operation, "Maximum fitting scale must be finite and positive.");
+    const sourceSize = size(source), targetSize = size(target);
+    const ratios = sourceSize.flatMap((extent, axis) => extent === 0 ? [] : [targetSize[axis] / extent]);
+    if (ratios.length === 0)
+        fail(operation, "Fitting needs at least one positive source extent.");
+    const scale = Math.min(...ratios, options.maxScale ?? Infinity);
+    if (!Number.isFinite(scale) || scale <= 0)
+        fail(operation, "Target bounds must allow a finite positive fitting scale.");
+    const sourceCenter = center(source), targetCenter = center(target);
+    const position = vector(targetCenter.map((value, axis) => value - sourceCenter[axis] * scale), operation);
+    const bounds = Object.freeze({
+        min: vector(source.min.map((value, axis) => value * scale + position[axis]), operation),
+        max: vector(source.max.map((value, axis) => value * scale + position[axis]), operation),
+    });
+    return Object.freeze({ scale, position, bounds });
+}
+/**
+ * Returns immutable translations for a +X row of finite XYZ bounds with a nonnegative gap.
+ * Each minimum Y/Z becomes zero, and the first minimum X becomes zero. Supply bounds after
+ * any intended part rotation; translations apply to those bounds. An empty input returns [].
+ */
+export function layoutRow(bounds, options = {}) {
+    const operation = "layoutRow";
+    if (!isArray(bounds) || typeof options !== "object" || options === null || isArray(options))
+        fail(operation, "Row layout requires bounds and an options object.");
+    const gap = options.gap ?? 0;
+    if (!Number.isFinite(gap) || gap < 0)
+        fail(operation, "Row gap must be finite and nonnegative.");
+    let nextX = 0;
+    return Object.freeze(Array.from(bounds, (item) => {
+        if (validate(item, operation) !== 3)
+            fail(operation, "Row layout requires XYZ bounds.");
+        const position = vector([nextX - item.min[0], -item.min[1], -item.min[2]], operation);
+        nextX += item.max[0] - item.min[0] + gap;
+        if (!Number.isFinite(nextX))
+            fail(operation, "Row layout exceeds finite coordinates.");
+        return position;
+    }));
+}

package/dist/geometry/cylinder.js

@@ -60,11 +60,15 @@ export function resolveCylinderPrimitive(options) {
         invalid("Cylinder side dimensions must remain finite.");
     const sideX = radialChange / sideLength, sideZ = options.height / sideLength;
     const bottomAngle = Math.acos(-sideX), topAngle = Math.acos(sideX);
-    const bottom = options.ends?.bottom, top = options.ends?.top;
+    let bottom = options.ends?.bottom, top = options.ends?.top;
     const bottomSetbacks = bottom === undefined
         ? [0, 0]
         : edgeTreatmentSetbacks(bottom, "cylinder", bottomAngle, options.limits);
     const topSetbacks = top === undefined ? [0, 0] : edgeTreatmentSetbacks(top, "cylinder", topAngle, options.limits);
+    if (bottomSetbacks[0] === 0 && bottomSetbacks[1] === 0)
+        bottom = undefined;
+    if (topSetbacks[0] === 0 && topSetbacks[1] === 0)
+        top = undefined;
     if ((bottom && bottomRadius === 0) || (top && topRadius === 0))
         invalid("A zero-radius cone apex cannot receive an end treatment.");
     if ((bottom && bottomSetbacks[0] >= bottomRadius) || (top && topSetbacks[0] >= topRadius))

package/dist/geometry/edge-finishing.js

@@ -29,8 +29,8 @@ export function edgeTreatmentSetbacks(treatment, operation, angle = Math.PI / 2,
             throw new GeometryError("NON_FINITE_VALUE", "Treatment setbacks must be finite.", {
                 operation,
             });
-        if (result.some((value) => value <= 0))
-            fail(operation, "Treatment setbacks must be positive.");
+        if (result.some((value) => value < 0) || (result[0] === 0) !== (result[1] === 0))
+            fail(operation, "Treatment setbacks must be positive or both zero.");
     }
     else if (treatment.kind === "profile") {
         const points = treatment.profile;

package/dist/geometry/heightfield.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "./errors.js";
-import { validateTriangleMesh } from "./mesh.js";
+import { validateTriangleMesh } from "./mesh/mesh.js";
 import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "./model-limits.js";
 import { writeMeshVertex } from "./numeric.js";
 function planHeightfield(options, limits) {