@metamesh/modeling 0.13.0 → 0.15.0

package/dist/engine/deferred-context.js

@@ -1,85 +1,17 @@
-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 { sectionPatternTransform } from "./pattern-transform.js";
+import { geometryRecipe, isGeometryRecipe } from "../model/geometry-recipes.js";
+import { dispatchModelOperation } from "../model/operation-dispatch.js";
+import { createRecipeContext } from "../model/recipe-declaration.js";
 import { RecipeRealization } from "./recipe-realization.js";
-// Every public operation must explicitly choose its realization and result behavior.
-const operationBehaviors = {
-    withResolution: "resolution",
-    box: "solid",
-    cylinder: "solid",
-    tube: "solid",
-    sphere: "solid",
-    torus: "solid",
-    heightfield: "solid",
-    implicit: "solid",
-    extrude: "solid",
-    revolve: "solid",
-    loft: "solid",
-    sweep: "solid",
-    compose: "solid",
-    minkowskiSum: "solid",
-    solidFromMesh: "solid",
-    setTolerance: "solid",
-    threadRidge: "solid",
-    threadedRod: "solid",
-    threadedNut: "solid",
-    internalThreadCutter: "solid",
-    polygon: "section",
-    fromRegion: "section",
-    rectangle: "section",
-    circle: "section",
-    ellipse: "section",
-    regularPolygon: "section",
-    star: "section",
-    projectSection: "section",
-    sliceSection: "section",
-    textSection: "section",
-    svgSection: "section",
-    svgPathSection: "section",
-    translate: "preserve",
-    rotate: "preserve",
-    scale: "preserve",
-    mirror: "preserve",
-    transform: "preserve",
-    offset: "preserve",
-    simplify: "preserve",
-    withAnchors: "preserve",
-    attach: "preserve",
-    union: "preserve",
-    intersect: "preserve",
-    subtract: "preserve",
-    hull: "preserve",
-    toTriangleMesh: "observation",
-    toRegion: "observation",
-    inspectSection: "observation",
-    inspectSolid: "observation",
-    isEmpty: "observation",
-    distance: "observation",
-    rayCast: "observation",
-    anchor: "observation",
-    matchProfiles: "observation",
-    preflightThreadedRod: "observation",
-    preflightInternalThreadCutter: "observation",
-    preflightThreadedNut: "observation",
-    split: "split",
-    splitByPlane: "split",
-    components: "components",
-    linearPattern: "pattern",
-    radialPattern: "pattern",
-    gridPattern: "pattern",
-    pathPattern: "pattern",
-};
-/**
- * Binds declaration to one active revision. Recipe handles retain only immutable session identity
- * and captured inputs; native results remain private to the revision's realization owner.
- */
-export function createDeferredContext(owner, native, limits, initialResolution, duringNative, assertActive, restoreNative = () => undefined) {
+/** Supplies active observations and limits without capturing the host's implicit sampling policy. */
+export function createDeferredContext(owner, native, limits, duringNative, assertActive, restoreNative = () => undefined) {
     const realization = new RecipeRealization(owner, native, duringNative, restoreNative);
-    const declaration = { owner, limits, realization, assertActive };
     return {
-        context: createModelingContext(initialResolution, declaration),
+        context: createRecipeContext(undefined, {
+            limits,
+            realization,
+            assertActive,
+            dispatch: dispatchModelOperation,
+        }),
         resolve: (shape) => realization.resolve(shape),
         isRecipe: isGeometryRecipe,
         realizedShape: (shape) => realization.realizedShape(shape),
@@ -87,105 +19,3 @@ export function createDeferredContext(owner, native, limits, initialResolution,
         isSolid: (shape) => isGeometryRecipe(shape) && geometryRecipe(shape)?.kind === "solid",
     };
 }
-function createModelingContext(resolution, declaration) {
-    return Object.freeze(Object.fromEntries(Object.keys(operationBehaviors).map((key) => [
-        key,
-        (...supplied) => declareOperation(key, resolution, supplied, declaration),
-    ])));
-}
-/** Captures and validates inputs before deciding whether an operation needs native geometry now. */
-function declareOperation(operation, resolution, supplied, declaration) {
-    declaration.assertActive();
-    const behavior = operationBehaviors[operation];
-    if (behavior === "resolution") {
-        const nextResolution = Object.freeze({ ...resolution, ...supplied[0] });
-        return createModelingContext(nextResolution, declaration);
-    }
-    if (behavior === "pattern")
-        return declarePattern(operation, resolution, supplied, declaration);
-    const args = captureRecipeInputs(supplied);
-    declaration.realization.assertOwned(args);
-    const call = { method: operation, args, resolution };
-    if (behavior === "observation")
-        return declaration.realization.invoke(call);
-    const recipe = {
-        owner: declaration.owner,
-        kind: resultKind(behavior, args[0]),
-        call,
-    };
-    if (behavior === "split")
-        return Object.freeze([
-            recordGeometryRecipe({ ...recipe, index: 0 }),
-            recordGeometryRecipe({ ...recipe, index: 1 }),
-        ]);
-    if (behavior === "components") {
-        // Cardinality requires realization now; projected handles reuse that same call result later.
-        const values = declaration.realization.evaluate(call);
-        return Object.freeze(values.map((_value, index) => recordGeometryRecipe({ ...recipe, index })));
-    }
-    return recordGeometryRecipe(recipe);
-}
-function resultKind(behavior, input) {
-    if (behavior === "section")
-        return "section";
-    if (behavior === "preserve" || behavior === "components")
-        return inputKind(input);
-    return "solid";
-}
-function inputKind(value) {
-    if (Array.isArray(value))
-        return inputKind(value[0]);
-    if (typeof value !== "object" || value === null)
-        return "solid";
-    const recipe = geometryRecipe(value);
-    if (recipe !== undefined)
-        return recipe.kind;
-    if ("sections" in value)
-        return "section";
-    if ("points" in value &&
-        Array.isArray(value.points) &&
-        Array.isArray(value.points[0]) &&
-        value.points[0].length === 2)
-        return "section";
-    return "solid";
-}
-/** Runs every factory during declaration; each placed copy stays deferred until it is used. */
-function declarePattern(operation, resolution, supplied, declaration) {
-    const plan = patternPlan(operation, supplied, declaration.limits);
-    if (plan.count > declaration.limits.maxVertices)
-        throw new GeometryError("COMPLEXITY_LIMIT", "Pattern declaration exceeds execution limits.", {
-            operation,
-        });
-    const source = supplied[0];
-    const copies = [];
-    let kind;
-    for (let index = 0; index < plan.count; index++) {
-        const shape = typeof source === "function"
-            ? source(index)
-            : source;
-        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);
-}
-function patternPlan(operation, supplied, limits) {
-    const options = supplied[1];
-    switch (operation) {
-        case "linearPattern":
-            return linearPatternPlan(options);
-        case "radialPattern":
-            return radialPatternPlan(options);
-        case "gridPattern":
-            return gridPatternPlan(options);
-        case "pathPattern":
-            return pathPatternPlan(options, supplied[2], limits);
-        default:
-            throw new Error(`Operation ${operation} does not declare a pattern.`);
-    }
-}

package/dist/engine/execution.js

@@ -7,6 +7,7 @@ import { createModelingContext } from "./modeling-context.js";
 import { ownScopedManifoldValue, scopedManifoldScope, trackScopedManifoldValue, } from "./native/context.js";
 import { copiedFloat32Array, copiedUint32Array } from "./native/copied-views.js";
 import * as kernel from "./native/index.js";
+import { solidMaterialComponents } from "./native/material-components.js";
 import { assertNativeSolidStatus } from "./native/status.js";
 import { createShapeAnchorOwner } from "./shape-anchors.js";
 /** Internal execution owner; no native value or constructor crosses the public facade. */
@@ -18,6 +19,8 @@ export function createExecutionContext(module, scope, limits, initialResolution
     const canonicalSectionProfiles = new Map();
     let solidInspections;
     let sectionInspections;
+    let solidComponents;
+    let sectionComponents;
     const primitiveSectionProfiles = new Map();
     let active = true;
     const throwGeometryError = (code, operation, message) => {
@@ -63,6 +66,30 @@ export function createExecutionContext(module, scope, limits, initialResolution
         const owned = ownScopedManifoldValue(scope, value);
         return wrapSection(owned);
     };
+    const solidComponentsFor = (handle) => {
+        const native = nativeSolid(handle);
+        const cached = solidComponents?.get(native);
+        if (cached !== undefined)
+            return cached;
+        const components = solidMaterialComponents(scope, native, limits);
+        const cache = (solidComponents ??= new Map());
+        cache.set(native, components);
+        for (const component of components)
+            cache.set(component, Object.freeze([component]));
+        return components;
+    };
+    const sectionComponentsFor = (handle) => {
+        const native = nativeSection(handle);
+        const cached = sectionComponents?.get(native);
+        if (cached !== undefined)
+            return cached;
+        const components = Object.freeze(native.isEmpty() ? [] : native.decompose().map((part) => ownScopedManifoldValue(scope, part)));
+        const cache = (sectionComponents ??= new Map());
+        cache.set(native, components);
+        for (const component of components)
+            cache.set(component, Object.freeze([component]));
+        return components;
+    };
     // Geometry is immutable for a native value. Validate build ownership before every cache hit,
     // and retain only frozen plain facts so callers cannot corrupt later inspections.
     const solidInspectionFor = (handle) => {
@@ -72,12 +99,12 @@ export function createExecutionContext(module, scope, limits, initialResolution
             return cached;
         assertNativeSolidStatus(native, "inspectSolid");
         const bounds = native.boundingBox();
-        const parts = native.decompose().map((part) => ownScopedManifoldValue(scope, part));
+        const components = solidComponentsFor(handle);
         const facts = Object.freeze({
             min: Object.freeze([...bounds.min]),
             max: Object.freeze([...bounds.max]),
             isEmpty: native.isEmpty(),
-            parts: parts.length,
+            componentCount: components.length,
             volume: native.volume(),
             surfaceArea: native.surfaceArea(),
             tolerance: native.tolerance(),
@@ -92,17 +119,15 @@ export function createExecutionContext(module, scope, limits, initialResolution
             return cached;
         const bounds = native.bounds();
         const empty = native.isEmpty();
-        const parts = empty
-            ? []
-            : native.decompose().map((part) => ownScopedManifoldValue(scope, part));
+        const components = sectionComponentsFor(handle);
         const facts = Object.freeze({
             min: Object.freeze([...bounds.min]),
             max: Object.freeze([...bounds.max]),
             isEmpty: empty,
             area: native.area(),
-            contours: native.numContour(),
-            parts: parts.length,
-            vertices: native.numVert(),
+            contourCount: native.numContour(),
+            componentCount: components.length,
+            vertexCount: native.numVert(),
         });
         (sectionInspections ??= new Map()).set(native, facts);
         return facts;
@@ -244,6 +269,8 @@ export function createExecutionContext(module, scope, limits, initialResolution
         analyzedMeshFor,
         solidInspectionFor,
         sectionInspectionFor,
+        solidComponentsFor,
+        sectionComponentsFor,
         sectionProfileFor,
         primitiveProfileFor,
         rememberPrimitiveProfile,
@@ -305,8 +332,12 @@ export function createExecutionContext(module, scope, limits, initialResolution
             canonicalSectionProfiles.clear();
             solidInspections?.clear();
             sectionInspections?.clear();
+            solidComponents?.clear();
+            sectionComponents?.clear();
             solidInspections = undefined;
             sectionInspections = undefined;
+            solidComponents = undefined;
+            sectionComponents = undefined;
             primitiveSectionProfiles.clear();
             shapeAnchors.dispose();
         },

package/dist/engine/extrusion-finishing.js

@@ -10,7 +10,7 @@ const fail = (message) => {
 /** Finishes inward convex extrusion rims with exact parallel-edge offsets and retained correspondence. */
 export function buildFinishedExtrusion(module, profile, options) {
     const controls = resolveExtrusionControls(options.height, options, "extrude");
-    if (controls.twistDegrees !== 0 ||
+    if (controls.twist !== 0 ||
         controls.scales.some((scale) => scale !== 1) ||
         options.divisions !== undefined)
         fail("End treatments require a straight extrusion without twist, top scaling or divisions.");

package/dist/engine/index.js

@@ -97,8 +97,13 @@ function engineFromModule(module, engineLimits) {
  */
 export async function createModelEngine(options = {}) {
     const limits = resolveModelingLimits(options.limits);
+    const wasmUrl = options.wasmUrl === undefined ? modelingWasmUrl : options.wasmUrl;
+    if (typeof wasmUrl !== "string" || wasmUrl.trim().length === 0)
+        throw new GeometryError("INVALID_ARGUMENT", "wasmUrl must be a non-empty asset URL string.", {
+            operation: "createModelEngine",
+        });
     const module = await createManifoldModule({
-        locateFile: options.locateFile ?? (() => modelingWasmUrl),
+        locateFile: () => wasmUrl,
     });
     module.setup();
     return engineFromModule(module, limits);

package/dist/engine/inspection-operations.js

@@ -1,10 +1,11 @@
+import { vector3Data } from "../geometry/math/vector-value.js";
 import { ownScopedManifoldValue } from "./native/context.js";
 import { copiedMeshViews } from "./native/copied-views.js";
 import { measureSolidDistance } from "./native/distance.js";
 import { assertNativeSolidStatus } from "./native/status.js";
 /** Internal host-bound inspection operations. */
 export function createInspectionOperations(environment) {
-    const { scope, throwGeometryError, nativeSolid, resolveHandle, ownSolid, ownSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, analyzedMeshFor, solidInspectionFor, sectionInspectionFor, } = environment;
+    const { scope, throwGeometryError, nativeSolid, resolveHandle, ownSolid, ownSection, wrapSolid, wrapSection, validateFiniteNumber, requirePositiveNumber, validateCoordinates, analyzedMeshFor, solidInspectionFor, sectionInspectionFor, solidComponentsFor, sectionComponentsFor, } = environment;
     const operations = {
         toTriangleMesh: (value) => copiedMeshViews(analyzedMeshFor(value).mesh, new Map()),
         inspectSection: sectionInspectionFor,
@@ -16,12 +17,14 @@ export function createInspectionOperations(environment) {
             return native.value.isEmpty();
         },
         distance: (handle, other) => measureSolidDistance(nativeSolid(handle), nativeSolid(other)),
-        rayCast: (handle, origin, endpoint) => {
-            validateCoordinates(origin, 3, "rayCast");
-            validateCoordinates(endpoint, 3, "rayCast");
+        castSegment: (handle, inputOrigin, inputEndpoint) => {
+            const origin = vector3Data(inputOrigin);
+            const endpoint = vector3Data(inputEndpoint);
+            validateCoordinates(origin, 3, "castSegment");
+            validateCoordinates(endpoint, 3, "castSegment");
             const segmentLength = Math.hypot(...origin.map((value, axis) => value - endpoint[axis]));
             if (!Number.isFinite(segmentLength) || segmentLength === 0)
-                throwGeometryError("DEGENERATE_GEOMETRY", "rayCast", "Ray segment endpoints must differ.");
+                throwGeometryError("DEGENERATE_GEOMETRY", "castSegment", "Segment endpoints must differ.");
             return Object.freeze(nativeSolid(handle)
                 .rayCast([...origin], [...endpoint])
                 .map((hit) => Object.freeze({
@@ -34,9 +37,8 @@ export function createInspectionOperations(environment) {
         components: ((handle) => {
             const native = resolveHandle(handle);
             if (native.kind === "section")
-                return Object.freeze(native.value.isEmpty() ? [] : native.value.decompose().map(ownSection));
-            assertNativeSolidStatus(native.value, "components");
-            return Object.freeze(native.value.decompose().map(ownSolid));
+                return Object.freeze(sectionComponentsFor(handle).map(wrapSection));
+            return Object.freeze(solidComponentsFor(handle).map(wrapSolid));
         }),
         simplify: ((handle, tolerance) => {
             const native = resolveHandle(handle);
@@ -46,9 +48,9 @@ export function createInspectionOperations(environment) {
             const original = ownScopedManifoldValue(scope, native.value.asOriginal());
             return ownSolid(original.simplify(distance));
         }),
-        setTolerance: (handle, tolerance) => {
-            if (validateFiniteNumber(tolerance, "setTolerance") < 0)
-                throwGeometryError("INVALID_ARGUMENT", "setTolerance", "Tolerance must be nonnegative millimetres.");
+        withTolerance: (handle, tolerance) => {
+            if (validateFiniteNumber(tolerance, "withTolerance") < 0)
+                throwGeometryError("INVALID_ARGUMENT", "withTolerance", "Tolerance must be nonnegative millimetres.");
             return ownSolid(nativeSolid(handle).setTolerance(tolerance));
         },
     };

package/dist/engine/loft-operations.js

@@ -2,11 +2,13 @@ import { GeometryError } from "../geometry/errors.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 { analyzeTriangleMesh } from "../geometry/mesh/mesh.js";
+import { capturePath2Input, path2InputData, } from "../geometry/paths/path-value.js";
 import { assertSamplingCount } from "../geometry/sampling-limits.js";
 import { correspondingPrimitiveProfiles, rectangularPrimitiveFamily, } from "./primitive-profiles.js";
 import { buildProfileLoftMesh } from "./profile-mesh.js";
 const explicitProfile = (value) => typeof value === "object" && value !== null && "components" in value;
+const pointProfile = (value) => Array.isArray(value) || (typeof value === "object" && value !== null && "toArray" in value);
 const fail = (message) => {
     throw new GeometryError("INVALID_ARGUMENT", message, { operation: "loft" });
 };
@@ -63,21 +65,40 @@ function primitivePolygon(profile) {
 }
 /** Private host adapter: known authored identity or explicitly requested geometric correspondence. */
 export function createLoftOperation(environment, solidFromMesh) {
-    return (stations, value = {}) => {
+    return (inputStations, value = {}) => {
         environment.assertActive();
-        if (!Array.isArray(stations) || stations.length < 2)
+        if (!Array.isArray(inputStations) || inputStations.length < 2)
             fail("Loft requires at least two stations.");
-        assertSamplingCount(stations.length, "loft", environment.limits.maxPathPoints);
-        stations.forEach((station) => loftFrame(station));
-        resolveLoftControls(value, stations.length);
-        const rawPoints = stations.reduce((sum, station) => sum +
-            (explicitProfile(station.profile)
-                ? loftProfilePointCount(station.profile)
-                : Array.isArray(station.profile)
-                    ? station.profile.length
-                    : environment.nativeSection(station.profile).numVert()), 0);
-        assertSamplingCount(rawPoints, "loft", 1_000_000);
+        assertSamplingCount(inputStations.length, "loft", environment.limits.maxPathPoints);
+        inputStations.forEach((station) => loftFrame(station));
         let selected = environment.withResolutionDefaults(value);
+        resolveLoftControls(value, inputStations.length);
+        const captured = inputStations.map(({ profile, ...placement }) => {
+            const source = pointProfile(profile) ? capturePath2Input(profile, true) : undefined;
+            return { placement, profile: source?.input ?? profile, count: source?.count };
+        });
+        let rawPoints = 0, fixedPoints = 0;
+        for (const { profile, count } of captured) {
+            const fixed = count === undefined
+                ? explicitProfile(profile)
+                    ? loftProfilePointCount(profile)
+                    : environment.nativeSection(profile).numVert()
+                : 0;
+            fixedPoints += fixed;
+            rawPoints += count ?? fixed;
+            assertSamplingCount(rawPoints, "loft", 1_000_000);
+        }
+        let remaining = 1_000_000 - fixedPoints;
+        const stations = captured.map(({ placement, profile, count }) => {
+            if (count === undefined)
+                return { ...placement, profile };
+            const points = path2InputData(profile, true, {
+                maxPathPoints: Math.max(1, Math.min(selected.limits.maxProfilePoints, remaining)),
+            }).points;
+            assertSamplingCount(points.length, "loft", remaining);
+            remaining -= points.length;
+            return { ...placement, profile: points };
+        });
         const controls = resolveLoftControls(selected, stations.length);
         const explicit = stations.some((station) => explicitProfile(station.profile));
         let profiles, authoritative = false;
@@ -145,7 +166,7 @@ export function createLoftOperation(environment, solidFromMesh) {
             station.profile.components[0].holes.length === 0))
             return solidFromMesh(simpleLoftMesh(geometry, selected.limits));
         const mesh = buildProfileLoftMesh(environment.module, geometry.stations, selected.limits, false, 0, (station, contour, slot) => geometry.world[station][contour][slot]);
-        if (measureTriangleMesh(mesh).signedVolume < 0)
+        if (analyzeTriangleMesh(mesh).signedVolume < 0)
             for (let index = 0; index < mesh.indices.length; index += 3) {
                 const b = mesh.indices[index + 1];
                 mesh.indices[index + 1] = mesh.indices[index + 2];

package/dist/engine/model-summary.js

@@ -1,11 +1,12 @@
 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, volumeMm3 = 0;
+    let vertices = 0, triangles = 0, bytes = 0, partCount = 0, volumeMm3 = 0;
     const storage = new Set();
     const min = [Infinity, Infinity, Infinity], max = [-Infinity, -Infinity, -Infinity];
     return {
         add(geometry) {
+            partCount++;
             const measurements = geometry.measurements;
             vertices += measurements.vertexCount;
             triangles += measurements.triangleCount;
@@ -15,7 +16,8 @@ export function createModelSummary(limits) {
                     storage.add(buffer);
                     bytes += buffer.byteLength;
                 }
-            if (vertices > limits.maxVertices ||
+            if (partCount > limits.maxParts ||
+                vertices > limits.maxVertices ||
                 triangles > limits.maxTriangles ||
                 bytes > limits.maxBytes)
                 throw new GeometryError("COMPLEXITY_LIMIT", "Aggregate output exceeds the execution limits.", { operation: "generate" });
@@ -29,9 +31,10 @@ export function createModelSummary(limits) {
             return {
                 bounds: Object.freeze({ min: Object.freeze(min), max: Object.freeze(max) }),
                 stats: Object.freeze({
-                    vertices,
-                    triangles,
-                    bytes,
+                    partCount,
+                    vertexCount: vertices,
+                    triangleCount: triangles,
+                    byteCount: bytes,
                     volumeMm3,
                     buildMs: builtAt - startedAt,
                     finalizationMs: endedAt - builtAt,