@metamesh/modeling 0.17.0 → 0.18.0

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

@@ -1,116 +1,23 @@
-import { Zip, ZipDeflate } from "fflate";
-import { GeometryError } from "../geometry/errors.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"?>';
-const encoder = new TextEncoder();
-const escapeXml = (value) => value.replace(/[&<>"']/g, (character) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;", "'": "&apos;" })[character]);
-/** Private core 3MF serializer. It preserves the selected buffers and streams bounded XML chunks. */
-export function meshesTo3mf(parts, options) {
-    if (options.meshValidation !== undefined &&
-        options.meshValidation !== "topology" &&
-        options.meshValidation !== "solid")
-        throw new GeometryError("INVALID_ARGUMENT", "Unsupported mesh validation mode.", {
-            operation: "export3mf",
-        });
-    const name = options.name ?? "MetaMesh model";
-    if (typeof name !== "string" ||
-        name.length === 0 ||
-        name.length > 1024 ||
-        // eslint-disable-next-line no-control-regex -- XML 1.0 disallows these control characters.
-        /[\u0000-\u0008\u000b\u000c\u000e-\u001f\ud800-\udfff\ufffe\uffff]/u.test(name))
-        throw new GeometryError("INVALID_ARGUMENT", "3MF names require one through 1024 valid XML characters.", { operation: "export3mf" });
-    const analyzed = new MeshViewCache();
-    for (const part of parts) {
-        let facts = analyzed.get(part);
-        if (facts !== undefined)
-            continue;
-        facts =
-            options.meshValidation === "solid"
-                ? analyzeSolidMesh(part)
-                : analyzeTriangleMesh(part, { requireClosed: true, includeTopology: true });
-        if (!(facts.signedVolume > 0) || facts.vertexCount >= 2 ** 31 || facts.triangleCount >= 2 ** 31)
-            throw new GeometryError("INVALID_TOPOLOGY", "3MF parts require positive oriented volume and valid core resource counts.", { operation: "export3mf" });
-        analyzed.set(part, facts);
-    }
-    const chunks = [];
-    let bytes = 0, complete = false;
-    const zip = new Zip((error, data, final) => {
-        if (error !== null)
-            throw error;
-        bytes += data.byteLength;
-        if (bytes >= 0xffffffff)
-            throw new GeometryError("COMPLEXITY_LIMIT", "3MF ZIP output exceeds its 32-bit container limit.", { operation: "export3mf" });
-        chunks.push(data);
-        complete = final;
-    });
-    const add = (path) => {
-        const file = new ZipDeflate(path, { level: 6 });
-        file.mtime = new Date(1980, 0, 1);
-        zip.add(file);
-        return file;
-    };
-    const addText = (path, contents) => add(path).push(encoder.encode(contents), true);
-    try {
-        addText("[Content_Types].xml", `${declaration}<Types xmlns="http://schemas.openxmlformats.org/package/2006/content-types"><Default Extension="rels" ContentType="application/vnd.openxmlformats-package.relationships+xml"/><Default Extension="model" ContentType="application/vnd.ms-package.3dmanufacturing-3dmodel+xml"/></Types>`);
-        addText("_rels/.rels", `${declaration}<Relationships xmlns="http://schemas.openxmlformats.org/package/2006/relationships"><Relationship Target="/3D/3dmodel.model" Id="model" Type="http://schemas.microsoft.com/3dmanufacturing/2013/01/3dmodel"/></Relationships>`);
-        const model = add("3D/3dmodel.model");
-        let xml = "", xmlBytes = 0;
-        const flush = (final = false) => {
-            const data = encoder.encode(xml);
-            xmlBytes += data.byteLength;
-            if (xmlBytes >= 0xffffffff)
-                throw new GeometryError("COMPLEXITY_LIMIT", "3MF model XML exceeds its 32-bit ZIP entry limit.", { operation: "export3mf" });
-            model.push(data, final);
-            xml = "";
-        };
-        const append = (value) => {
-            xml += value;
-            if (xml.length >= 32_768)
-                flush();
-        };
-        append(`${declaration}<model unit="millimeter" xml:lang="en-US" xmlns="${namespace}"><metadata name="Application">MetaMesh Modeling</metadata><metadata name="Title">${escapeXml(name)}</metadata><resources>`);
-        const colors = new Map();
-        for (const part of parts)
-            if (part.color !== undefined && !colors.has(part.color.toLowerCase()))
-                colors.set(part.color.toLowerCase(), colors.size);
-        const materialId = parts.length + 1;
-        if (colors.size) {
-            append(`<basematerials id="${materialId}">`);
-            for (const color of colors.keys())
-                append(`<base name="Color ${color.slice(1)}" displaycolor="${color.toUpperCase()}FF"/>`);
-            append("</basematerials>");
-        }
-        parts.forEach((part, index) => {
-            const material = part.color === undefined
-                ? ""
-                : ` pid="${materialId}" pindex="${colors.get(part.color.toLowerCase())}"`;
-            append(`<object id="${index + 1}" name="${escapeXml(part.id)}" partnumber="${escapeXml(part.id)}" type="model"${material}><mesh><vertices>`);
-            for (let offset = 0; offset < part.positions.length; offset += 3)
-                append(`<vertex x="${part.positions[offset]}" y="${part.positions[offset + 1]}" z="${part.positions[offset + 2]}"/>`);
-            append("</vertices><triangles>");
-            for (let offset = 0; offset < part.indices.length; offset += 3)
-                append(`<triangle v1="${part.indices[offset]}" v2="${part.indices[offset + 1]}" v3="${part.indices[offset + 2]}"/>`);
-            append("</triangles></mesh></object>");
-        });
-        append("</resources><build>");
-        parts.forEach((_, index) => append(`<item objectid="${index + 1}"/>`));
-        append("</build></model>");
-        flush(true);
-        zip.end();
-        if (!complete)
-            throw new Error("The synchronous 3MF compressor did not complete.");
-        const result = new Uint8Array(bytes);
-        let offset = 0;
-        for (const chunk of chunks) {
-            result.set(chunk, offset);
-            offset += chunk.byteLength;
-        }
-        return result.buffer;
-    }
-    finally {
-        zip.terminate();
-    }
+import { resolveModelingLimits } from "../geometry/model-limits.js";
+import { captureExportParts } from "./finalization.js";
+/**
+ * Serializes captured manufacturing meshes as millimetre 3MF without initializing an engine.
+ * Captures input arrays and options before awaiting; later mutations, runs and session cleanup
+ * cannot change the exported geometry. Trusted limits default to the package output ceilings.
+ *
+ * @example Export a pure mesh without an engine
+ * ```ts
+ * import { export3mf } from "@metamesh/modeling/engine";
+ * import * as mesh from "@metamesh/modeling/geometry/mesh";
+ * import { rectangleContour } from "@metamesh/modeling/geometry";
+ * const plate = mesh.extrude(rectangleContour({ size: [30, 20] }), { height: 6 });
+ * const bytes = await export3mf([{ id: "plate", ...plate }], { name: "Plate" });
+ * ```
+ */
+export async function export3mf(parts, options = {}) {
+    const limits = resolveModelingLimits(options.limits);
+    const captured = captureExportParts(parts, limits);
+    const settings = { ...options };
+    const { meshesTo3mf } = await import("./serialize-3mf.js");
+    return meshesTo3mf(captured, settings);
 }

package/dist/engine/finalization.js

@@ -1,16 +1,11 @@
 import { GeometryError } from "../geometry/errors.js";
+import { immutableMeshView, isImmutableBuffer, } from "../geometry/immutable-buffer.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";
 const isArray = (value) => Array.isArray(value);
-const snapshotMeshes = new WeakMap();
-/** Registers trusted snapshot storage without exposing its shared backing arrays publicly. */
-export function rememberSnapshotPart(part, mesh) {
-    snapshotMeshes.set(part, mesh);
-}
 function fitsGeometryLimits(mesh, limits) {
     const buffers = new Set([mesh.positions.buffer, mesh.indices.buffer]);
     let bytes = 0;
@@ -96,12 +91,15 @@ export function captureExportParts(parts, limits) {
     const captured = parts.map((part) => {
         if (typeof part !== "object" || part === null)
             throw new GeometryError("INVALID_ARGUMENT", "Export part IDs must be unique canonical identifiers.", { operation: "export3mf" });
-        // Access public owned-copy getters exactly once, or retain trusted private sharing for a
-        // snapshot created by this engine. Capture still copies before the asynchronous boundary.
-        const mesh = snapshotMeshes.get(part) ?? { positions: part.positions, indices: part.indices };
+        // Trusted immutable storage can outlive the asynchronous export directly. Mutable external
+        // input is captured once below, preserving shared backing buffers before the first await.
+        const { positions, indices } = part;
+        const immutable = isImmutableBuffer(positions) && isImmutableBuffer(indices);
+        const mesh = immutableMeshView({ positions, indices });
         const id = part.id, color = part.color;
         return {
             id,
+            immutable,
             positions: mesh.positions,
             indices: mesh.indices,
             ...(color === undefined ? {} : { color }),
@@ -149,7 +147,9 @@ export function captureExportParts(parts, limits) {
     const copiedBuffers = new Map();
     return captured.map((part) => ({
         id: part.id,
-        ...copiedMeshViews(part, copiedBuffers),
+        ...(part.immutable
+            ? { positions: part.positions, indices: part.indices }
+            : copiedMeshViews(part, copiedBuffers)),
         ...(part.color === undefined ? {} : { color: part.color }),
     }));
 }

package/dist/engine/index.js

@@ -1,23 +1,26 @@
 import { GeometryError } from "../geometry/errors.js";
 import { defaultModelingLimits, resolveModelingLimits } from "../geometry/model-limits.js";
 import { createExecutionContext } from "./execution.js";
-import { captureExportParts } from "./finalization.js";
 import createManifoldModule from "./kernel/manifold.js";
 import { withManifoldScope } from "./native/context.js";
-import { createSession } from "./session.js";
+import { createSession } from "./session/session.js";
 export { defaultModelingLimits };
+export { export3mf } from "./export-3mf.js";
 /** URL of the package's pinned WASM asset; browser bundlers may replace it with their emitted URL. */
 export const modelingWasmUrl = new URL("./kernel/manifold.wasm", import.meta.url).href;
 /**
  * Runs declaration and immediate assertions without initializing a kernel or finalizing parts.
- * Geometry observations require an initialized session's `validate` method instead.
+ * Returns reached assertion errors and warnings; unexpected execution failures throw.
+ * Returned geometry is not realized or validated.
+ * Geometry observations require an initialized session's `check` method instead.
  */
-export function validateModel(program, params, ...settings) {
-    const session = createSession(program, settings[0] ?? {}, defaultModelingLimits, (_options, callback) => callback(() => {
-        throw new GeometryError("INVALID_ARGUMENT", "Geometry observations require an initialized model session.", { operation: "validateModel", details: { requiresKernel: true } });
+export function checkModel(program, ...args) {
+    const [parameters, options] = args;
+    const session = createSession(program, options ?? {}, defaultModelingLimits, (_options, callback) => callback(() => {
+        throw new GeometryError("INVALID_ARGUMENT", "Geometry observations require an initialized model session.", { operation: "checkModel", details: { requiresKernel: true } });
     }));
     try {
-        return session.validate(params);
+        return session.check(...[parameters]);
     }
     finally {
         session.dispose();
@@ -26,20 +29,16 @@ export function validateModel(program, params, ...settings) {
 /** Serializes operations over one initialized kernel; sessions own their caches. */
 function engineFromModule(module, engineLimits) {
     let building = false;
-    return Object.freeze({
+    const engine = Object.freeze({
         limits: engineLimits,
-        async export3mf(parts, options = {}) {
-            if (building)
-                throw new GeometryError("INVALID_ARGUMENT", "An engine cannot export during another operation.", { operation: "export3mf" });
-            const snapshot = captureExportParts(parts, engineLimits);
-            const snapshotOptions = { ...options };
-            building = true;
+        run(program, ...args) {
+            const [parameters, options] = args;
+            const session = createSessionForRun(program, { ...options, cache: false });
             try {
-                const { meshesTo3mf } = await import("./export-3mf.js");
-                return meshesTo3mf(snapshot, snapshotOptions);
+                return session.run(...[parameters]);
             }
             finally {
-                building = false;
+                session.dispose();
             }
         },
         createSession(program, ...settings) {
@@ -51,8 +50,8 @@ function engineFromModule(module, engineLimits) {
                 const limits = resolveModelingLimits(options.limits, engineLimits);
                 building = true;
                 try {
-                    // The trusted finalizer captures only copied manufacturing buffers. Its snapshot has
-                    // owned-copy accessors, so publish it after the native scope's structural escape check.
+                    // The trusted finalizer captures geometry outside native ownership. Publish its
+                    // immutable storage only after the native scope's structural escape check.
                     let captured;
                     withManifoldScope(module, (scope) => {
                         let execution;
@@ -71,6 +70,10 @@ function engineFromModule(module, engineLimits) {
             });
         },
     });
+    return engine;
+    function createSessionForRun(program, options) {
+        return engine.createSession(program, ...[options]);
+    }
 }
 /**
  * Initializes one host kernel and returns a lifecycle-safe engine. No generator initializes WASM.
@@ -78,21 +81,12 @@ function engineFromModule(module, engineLimits) {
  * @example Build a box in a host application
  * ```ts
  * import { box, generate } from "@metamesh/modeling";
- * import { createModelEngine } from "@metamesh/modeling/engine";
+ * import { createModelEngine, export3mf } from "@metamesh/modeling/engine";
  *
  * const engine = await createModelEngine();
  * const model = generate<Record<never, never>>(({ part }) => [part("body", box({ size: [30, 20, 8] }))]);
- * const session = engine.createSession(model);
- * try {
- *   const snapshot = session.run({});
- *   try {
- *     await engine.export3mf(snapshot.parts);
- *   } finally {
- *     snapshot.dispose();
- *   }
- * } finally {
- *   session.dispose();
- * }
+ * const result = engine.run(model);
+ * await export3mf(result.parts);
  * ```
  */
 export async function createModelEngine(options = {}) {

package/dist/engine/model-parts.js

@@ -0,0 +1,8 @@
+import { GeometryError } from "../geometry/errors.js";
+/** Resolves an exact semantic ID without changing output order or retaining another index. */
+export function requireModelPart(parts, id) {
+    const part = parts.find((part) => part.id === id);
+    if (part !== undefined)
+        return part;
+    throw new GeometryError("INVALID_ARGUMENT", `Model has no part ${JSON.stringify(id)}. Available parts: ${parts.map((part) => part.id).join(", ")}.`, { operation: "part", details: { partId: id } });
+}

package/dist/engine/model-summary.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../geometry/errors.js";
 /** Counts manufacturing instances while charging shared backing storage only once. */
 export function createModelSummary(limits) {
-    let vertices = 0, triangles = 0, bytes = 0, partCount = 0, volumeMm3 = 0;
+    let vertices = 0, triangles = 0, bytes = 0, partCount = 0, signedVolume = 0;
     const storage = new Set();
     const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
     return {
@@ -10,7 +10,7 @@ export function createModelSummary(limits) {
             const measurements = geometry.measurements;
             vertices += measurements.vertexCount;
             triangles += measurements.triangleCount;
-            volumeMm3 += measurements.signedVolume;
+            signedVolume += measurements.signedVolume;
             for (const buffer of [geometry.positions.buffer, geometry.indices.buffer])
                 if (!storage.has(buffer)) {
                     storage.add(buffer);
@@ -35,10 +35,10 @@ export function createModelSummary(limits) {
                     vertexCount: vertices,
                     triangleCount: triangles,
                     byteCount: bytes,
-                    volumeMm3,
+                    signedVolume,
                     buildMs: builtAt - startedAt,
-                    finalizationMs: endedAt - builtAt,
-                    generationMs: endedAt - startedAt,
+                    finalizeMs: endedAt - builtAt,
+                    generateMs: endedAt - startedAt,
                 }),
             };
         },

package/dist/engine/native/index.js

@@ -5,7 +5,7 @@
  */
 export { createScopedManifoldContext, withManifoldScope, } from "./context.js";
 export { box, cylinder, sphere, torus, tube, } from "./scoped-primitives.js";
-export { compose, hull, intersect, minkowskiSum, subtract, union, } from "./operations.js";
+export { hull, intersect, minkowskiSum, subtract, union } from "./operations.js";
 export { attach, mirror, rotate, scale, transform, translate, } from "./transforms.js";
 export { internalThreadCutter, preflightInternalThreadCutter, preflightThreadedNut, preflightThreadedRod, threadRidge, threadedNut, threadedRod, } from "./scoped-threads.js";
 export {} from "./threads.js";

package/dist/engine/native/material-components.js

@@ -256,8 +256,8 @@ export function solidMaterialComponents(scope, solid, limits) {
         return Object.freeze([solid]);
     if (entries.length !== shells.length || orphanedCavity) {
         // Selecting from the original would retain contact sheets inside a sealed cavity.
-        // Rebuild only this exceptional case from its material boundaries. The JS kernel's
-        // compose aliases union, so turn inward shells into positive native cutters instead.
+        // Rebuild only this exceptional case from its material boundaries. Union fills inward
+        // shells, so turn them into positive native cutters instead.
         const cutters = new Map(exteriors.map(({ shell }) => [shell, []]));
         for (const { cavity, parent } of enclosedCavities) {
             // An inward shell removes positive occupancy only inside an exterior. A lone
@@ -291,7 +291,7 @@ export function solidMaterialComponents(scope, solid, limits) {
         if (parent !== undefined)
             children.get(parent.shell).push(exterior.shell);
     }
-    // The JS kernel aliases compose to union, which fills independently supplied inward shells.
+    // Union fills independently supplied inward shells.
     // Select from the original material instead, retaining its native precision and cavity winding.
     return Object.freeze(exteriors.map(({ shell }) => {
         const selected = ownScopedManifoldValue(scope, solid.intersect(shell));

package/dist/engine/native/operations.js

@@ -41,13 +41,6 @@ export function intersect(context, solids) {
         return solids[0];
     return ownScopedManifoldValue(context, scopedManifoldModule(context).Manifold.intersection(solids));
 }
-/** Combines disjoint context-owned solids without resolving overlaps. */
-export function compose(context, solids) {
-    operands(context, solids, "compose");
-    if (solids.length === 1)
-        return solids[0];
-    return ownScopedManifoldValue(context, scopedManifoldModule(context).Manifold.compose(solids));
-}
 /**
  * Creates the scope-owned convex hull of finite XYZ millimetre points or solids.
  *

package/dist/engine/native/scoped-primitives.js

@@ -90,18 +90,19 @@ export function cylinder(context, options) {
 }
 /** Creates a scope-owned hollow tube along +Z. */
 export function tube(context, options) {
-    resolveTubePrimitive(options);
-    const segments = resolveCylinderPrimitive({ ...options, radius: options.outerRadius }).segments;
+    const { segments, innerVertexRadius, outerVertexRadius } = resolveTubePrimitive(options);
     meshBudget(4 * segments, 8 * segments, "tube", options.limits);
     const outer = cylinder(context, {
         ...options,
-        radius: options.outerRadius,
+        radius: outerVertexRadius,
+        segments,
     });
     const inner = cylinder(context, {
         ...options,
         center: true,
         height: options.height + 0.02,
-        radius: options.innerRadius,
+        radius: innerVertexRadius,
+        segments,
     });
     const positionedInner = options.center === false
         ? ownScopedManifoldValue(context, inner.translate([0, 0, options.height / 2]))

package/dist/engine/native/threads.js

@@ -1,10 +1,10 @@
-import { helicalThreadRidgeMesh, helicalThreadSolidMesh } from "../../geometry/mechanical/index.js";
-import { resolveCompensatedThreadSolidMesh, resolveThreadedNutSolid, } from "../../geometry/mechanical/thread-solids.js";
+import { threadRidgeMesh, threadSolidMesh } from "../../geometry/mechanical/index.js";
+import { resolveCompensatedThreadSolidMesh, resolveThreadedNutSolid, } from "../../geometry/mechanical/threads/solids.js";
 import { triangleMeshToManifold } from "./adapter.js";
-export { preflightThreadedRodSolid, preflightInternalThreadCutterSolid, preflightThreadedNutSolid, } from "../../geometry/mechanical/thread-solids.js";
+export { preflightThreadedRodSolid, preflightInternalThreadCutterSolid, preflightThreadedNutSolid, } from "../../geometry/mechanical/threads/solids.js";
 /** Converts the runtime-neutral ridge mesh into a scope-owned Manifold solid. */
 export function threadRidgeSolid(module, options, scope) {
-    return triangleMeshToManifold(module, helicalThreadRidgeMesh(options), scope);
+    return triangleMeshToManifold(module, threadRidgeMesh(options), scope);
 }
 const compensatedThreadSolid = (module, options, role, scope) => {
     const resolved = resolveCompensatedThreadSolidMesh(options, role);
@@ -12,7 +12,7 @@ const compensatedThreadSolid = (module, options, role, scope) => {
 };
 const compensatedThreadSolidFromResolved = (module, resolved, scope) => {
     const { axialExtension, meshOptions } = resolved;
-    const combined = triangleMeshToManifold(module, helicalThreadSolidMesh(meshOptions), scope);
+    const combined = triangleMeshToManifold(module, threadSolidMesh(meshOptions), scope);
     return axialExtension === 0 ? combined : scope.own(combined.translate([0, 0, -axialExtension]));
 };
 /** Creates a compensated, scope-owned external threaded rod along +Z. */
@@ -30,21 +30,21 @@ export function internalThreadCutterSolid(module, options, scope) {
 /** Creates a scope-owned nut body and subtracts its compensated internal thread. */
 export function threadedNutSolid(module, options, scope) {
     const resolved = resolveThreadedNutSolid(options, "threadedNutSolid");
-    const { bevelBottom, bevelTop, outerRadius } = resolved;
-    const { bodySegments: segments, chamferSize: chamfer } = resolved.preflight;
+    const { outerRadius } = resolved;
+    const { bodySegments: segments, outerBevel: [bottomBevel, topBevel], } = resolved.preflight;
     const bodyParts = [];
-    if (bevelBottom) {
-        bodyParts.push(scope.own(module.Manifold.cylinder(chamfer, outerRadius - chamfer, outerRadius, segments, false)));
+    if (bottomBevel > 0) {
+        bodyParts.push(scope.own(module.Manifold.cylinder(bottomBevel, outerRadius - bottomBevel, outerRadius, segments, false)));
     }
-    const middleStart = bevelBottom ? chamfer : 0;
-    const middleEnd = options.thickness - (bevelTop ? chamfer : 0);
+    const middleStart = bottomBevel;
+    const middleEnd = options.thickness - topBevel;
     if (middleEnd > middleStart) {
         const middle = scope.own(module.Manifold.cylinder(middleEnd - middleStart, outerRadius, outerRadius, segments, false));
         bodyParts.push(middleStart === 0 ? middle : scope.own(middle.translate([0, 0, middleStart])));
     }
-    if (bevelTop) {
-        const top = scope.own(module.Manifold.cylinder(chamfer, outerRadius, outerRadius - chamfer, segments, false));
-        bodyParts.push(scope.own(top.translate([0, 0, options.thickness - chamfer])));
+    if (topBevel > 0) {
+        const top = scope.own(module.Manifold.cylinder(topBevel, outerRadius, outerRadius - topBevel, segments, false));
+        bodyParts.push(scope.own(top.translate([0, 0, options.thickness - topBevel])));
     }
     const body = bodyParts.length === 1 ? bodyParts[0] : scope.own(module.Manifold.union(bodyParts));
     const cutter = compensatedThreadSolidFromResolved(module, resolved.cutter, scope);

package/dist/engine/{construction-operations.js → operations/construction.js}

@@ -1,22 +1,22 @@
-import { edgeTreatmentSetbacks } from "../geometry/edge-finishing.js";
-import { GeometryError } from "../geometry/errors.js";
-import { resolveExtrusionContourDivisions, resolveExtrusionControls, } from "../geometry/extrusion.js";
-import { heightfieldMesh } from "../geometry/heightfield.js";
-import { vector2Data, vector3Data } from "../geometry/math/vector-value.js";
-import { assertMeshAllocationWithinLimits } from "../geometry/model-limits.js";
-import { path3InputData } from "../geometry/paths/path-value.js";
-import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
-import { matchProfiles } from "../geometry/profiles/matched.js";
-import { resolveGeometryResolution } from "../geometry/resolution.js";
-import { assertSamplingCount } from "../geometry/sampling-limits.js";
-import { sweepMesh } from "../geometry/sweeps/sweep-mesh.js";
-import { immutableMeshView } from "../model/immutable-buffer.js";
+import { edgeTreatmentSetbacks } from "../../geometry/edge-finishing.js";
+import { GeometryError } from "../../geometry/errors.js";
+import { resolveExtrusionContourDivisions, resolveExtrusionControls, } from "../../geometry/extrusion.js";
+import { heightfieldMesh } from "../../geometry/heightfield.js";
+import { immutableMeshView } from "../../geometry/immutable-buffer.js";
+import { vector2Data, vector3Data } from "../../geometry/math/vector-value.js";
+import { assertMeshAllocationWithinLimits } from "../../geometry/model-limits.js";
+import { path3InputData } from "../../geometry/paths/path-value.js";
+import { assertPrimitiveOptions } from "../../geometry/primitive-resolvers.js";
+import { matchProfiles } from "../../geometry/profiles/match-profiles.js";
+import { resolveGeometryResolution } from "../../geometry/resolution.js";
+import { assertSamplingCount } from "../../geometry/sampling-limits.js";
+import { sweepMesh } from "../../geometry/sweeps/sweep-mesh.js";
+import { triangleMeshToManifold } from "../native/adapter.js";
+import { ownScopedManifoldValue, scopedManifoldScope, trackScopedManifoldValue, } from "../native/context.js";
+import * as kernel from "../native/index.js";
 import { buildFinishedExtrusion } from "./extrusion-finishing.js";
-import { createLoftOperation } from "./loft-operations.js";
-import { triangleMeshToManifold } from "./native/adapter.js";
-import { ownScopedManifoldValue, scopedManifoldScope, trackScopedManifoldValue, } from "./native/context.js";
-import * as kernel from "./native/index.js";
-import { buildProfileSweepMesh } from "./profile-mesh.js";
+import { createLoftOperation } from "./loft.js";
+import { buildProfileSweepMesh } from "./primitives/profile-mesh.js";
 /** Internal host-bound construction operations. */
 export function createConstructionOperations(environment, sections) {
     const { module, scope, limits, assertActive, throwGeometryError, resolveHandle, nativeSolid, nativeSection, wrapSolid, wrapSection, ownSolid, ownSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, assertOperandCount, assertMeshAllocation, withResolutionDefaults, resolveCircularSegments, } = environment;
@@ -33,7 +33,10 @@ export function createConstructionOperations(environment, sections) {
         return { normal, offset: validateFiniteNumber(value.offset ?? 0, operation) };
     };
     const fromContours = (contours) => sections.polygon({ contours });
-    const corresponding = (value) => typeof value === "object" && value !== null && "components" in value;
+    const corresponding = (value) => typeof value === "object" &&
+        value !== null &&
+        "components" in value &&
+        Array.isArray(value.components);
     const shapeSection = (shape) => corresponding(shape)
         ? nativeSection(fromContours(shape.components.flatMap((component) => [component.outer, ...component.holes].map((contour) => contour.points))))
         : nativeSection(shape);
@@ -74,7 +77,7 @@ export function createConstructionOperations(environment, sections) {
         assertMeshAllocationWithinLimits(vertices, triangles, vertices * 12 + triangles * 12, "extrude", resolved.limits);
         return ownSolid(native.extrude(value.height, divisions, controls.twist, controls.scales, controls.center));
     };
-    const boolean = (values, operation) => {
+    const applyBoolean = (values, operation) => {
         assertOperandCount(values, operation);
         const natives = values.map(resolveHandle), kind = natives[0].kind;
         if (natives.some((native) => native.kind !== kind))
@@ -109,9 +112,9 @@ export function createConstructionOperations(environment, sections) {
         return wrapSolid(trackScopedManifoldValue(scope, triangleMeshToManifold(module, mesh, scopedManifoldScope(scope))));
     };
     const operations = {
-        union: ((values) => boolean(values, "union")),
+        union: ((values) => applyBoolean(values, "union")),
         subtract,
-        intersect: ((values) => boolean(values, "intersect")),
+        intersect: ((values) => applyBoolean(values, "intersect")),
         split: (solid, cutter) => {
             const results = nativeSolid(solid).split(nativeSolid(cutter));
             return Object.freeze([ownSolid(results[0]), ownSolid(results[1])]);
@@ -122,7 +125,6 @@ export function createConstructionOperations(environment, sections) {
             const results = native.splitByPlane(plane.normal, plane.offset);
             return Object.freeze([ownSolid(results[0]), ownSolid(results[1])]);
         },
-        compose: (values) => wrapSolid(kernel.compose(scope, values.map(nativeSolid))),
         hull: ((value) => {
             assertActive();
             assertPrimitiveOptions(value, "hull");

package/dist/engine/{modeling-context.js → operations/context.js}

@@ -1,13 +1,13 @@
-import { resolveGeometryResolution } from "../geometry/resolution.js";
-import { createConstructionOperations } from "./construction-operations.js";
-import { createHoleCutterOperation } from "./hole-cutter-operation.js";
-import { createInspectionOperations } from "./inspection-operations.js";
-import { createMechanicalOperations } from "./mechanical-operations.js";
-import { createOperationEnvironment } from "./operation-environment.js";
-import { createPatternOperations } from "./pattern-operations.js";
-import { createPrimitiveOperations } from "./primitive-operations.js";
-import { createSectionOperations } from "./section-operations.js";
-import { createTransformOperations } from "./transform-operations.js";
+import { resolveGeometryResolution } from "../../geometry/resolution.js";
+import { createConstructionOperations } from "./construction.js";
+import { createOperationEnvironment } from "./environment.js";
+import { createHoleCutterOperation } from "./hole-cutter.js";
+import { createInspectionOperations } from "./inspection.js";
+import { createMechanicalOperations } from "./mechanical.js";
+import { createPatternOperations } from "./patterns.js";
+import { createPrimitiveOperations } from "./primitives/construction.js";
+import { createSectionOperations } from "./sections.js";
+import { createTransformOperations } from "./transforms.js";
 /** Composes bound families over one execution owner and immutable local resolution. */
 export function createModelingContext(owner, initialResolution) {
     const make = (resolution) => {

package/dist/engine/{operation-environment.js → operations/environment.js}

@@ -1,5 +1,5 @@
-import { resolveModelingLimits } from "../geometry/model-limits.js";
-import { resolveCircularPrimitiveSegments } from "../geometry/primitive-resolution.js";
+import { resolveModelingLimits } from "../../geometry/model-limits.js";
+import { resolveCircularPrimitiveSegments } from "../../geometry/primitive-resolution.js";
 /** Applies explicit resolution inheritance once for this bound context. */
 export function createOperationEnvironment(owner, resolution) {
     const withResolutionDefaults = (value) => {

package/dist/engine/{extrusion-finishing.js → operations/extrusion-finishing.js}

@@ -1,10 +1,10 @@
-import { convexContourOffsets } from "../geometry/convex-offset.js";
-import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../geometry/edge-finishing.js";
-import { GeometryError } from "../geometry/errors.js";
-import { resolveExtrusionControls } from "../geometry/extrusion.js";
-import { assertMeshAllocationWithinLimits } from "../geometry/model-limits.js";
-import { assertSamplingCount } from "../geometry/sampling-limits.js";
-import { buildProfileLoftMesh } from "./profile-mesh.js";
+import { convexContourOffsets } from "../../geometry/convex-offset.js";
+import { edgeTreatmentPointCount, edgeTreatmentSetbacks, sampleEdgeTreatment, } from "../../geometry/edge-finishing.js";
+import { GeometryError } from "../../geometry/errors.js";
+import { resolveExtrusionControls } from "../../geometry/extrusion.js";
+import { assertMeshAllocationWithinLimits, } from "../../geometry/model-limits.js";
+import { assertSamplingCount } from "../../geometry/sampling-limits.js";
+import { buildProfileLoftMesh } from "./primitives/profile-mesh.js";
 const fail = (message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "extrude" });
 };

package/dist/engine/{hole-cutter-operation.js → operations/hole-cutter.js}

@@ -1,6 +1,6 @@
-import { convexContourOffsets } from "../geometry/convex-offset.js";
-import { GeometryError } from "../geometry/errors.js";
-import { assertPrimitiveOptions } from "../geometry/primitive-resolvers.js";
+import { convexContourOffsets } from "../../geometry/convex-offset.js";
+import { GeometryError } from "../../geometry/errors.js";
+import { assertPrimitiveOptions } from "../../geometry/primitive-resolvers.js";
 /** Composes cutters inside the evaluating host, retaining deferred Section and sampling ownership. */
 export function createHoleCutterOperation(environment, operations) {
     return (options) => {