@metamesh/modeling 0.19.0 → 0.20.0

package/dist/docs/reference/text/VectorFontOptions.md

@@ -14,10 +14,10 @@ Identifies the actual weight of a static face, without synthesizing a different
 
 Actual weight of a static face, 1–1000; defaults to 400.
 
-## Supported imports
+## Import
 
 ```ts
 import type { VectorFontOptions } from "@metamesh/modeling/text";
 ```
 
-Package: `@metamesh/modeling@0.19.0`.
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/{geometry → text}/VectorTextArcBaseline.md

@@ -50,19 +50,10 @@ Alignment datum in degrees counterclockwise from +X; defaults to 90.
 
 Reading direction around the circle; defaults to clockwise.
 
-
-## Guides
-
-- [SVG preflight work and guarantees](../../guides/resolution-and-inspection.md#check-preflight-guarantees)
-
-## Supported imports
-
-```ts
-import type { VectorTextArcBaseline } from "@metamesh/modeling/geometry";
-```
+## Import
 
 ```ts
 import type { VectorTextArcBaseline } from "@metamesh/modeling/text";
 ```
 
-Package: `@metamesh/modeling@0.19.0`.
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/{geometry → text}/VectorTextLayoutOptions.md

@@ -12,7 +12,7 @@ Text bounded to 512 UTF-16 units: horizontal lines or one circular line without
 
 
 
-`readonly` `optional` **align?**: `"left"` \| `"right"` \| `"center"`
+`readonly` `optional` **align?**: `"center"` \| `"left"` \| `"right"`
 
 
 
@@ -108,18 +108,10 @@ Tracking between glyph clusters in millimetres, -100–100; defaults to zero.
 - [VectorTextArcBaseline](VectorTextArcBaseline.md)
 - [VectorTextOptions](VectorTextOptions.md)
 
-## Guides
-
-- [SVG preflight work and guarantees](../../guides/resolution-and-inspection.md#check-preflight-guarantees)
-
-## Supported imports
-
-```ts
-import type { VectorTextLayoutOptions } from "@metamesh/modeling/geometry";
-```
+## Import
 
 ```ts
 import type { VectorTextLayoutOptions } from "@metamesh/modeling/text";
 ```
 
-Package: `@metamesh/modeling@0.19.0`.
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/{geometry → text}/VectorTextOptions.md

@@ -47,18 +47,10 @@ Tracking between glyph clusters in millimetres, -100–100; defaults to zero.
 
 - [VectorTextLayoutOptions](VectorTextLayoutOptions.md)
 
-## Guides
-
-- [SVG preflight work and guarantees](../../guides/resolution-and-inspection.md#check-preflight-guarantees)
-
-## Supported imports
-
-```ts
-import type { VectorTextOptions } from "@metamesh/modeling/geometry";
-```
+## Import
 
 ```ts
 import type { VectorTextOptions } from "@metamesh/modeling/text";
 ```
 
-Package: `@metamesh/modeling@0.19.0`.
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/text/categories/font-preparation.md

@@ -18,6 +18,9 @@ Layout returns immutable paths and metrics in Y-up millimetres. Pass the prepare
 | --- | --- |
 | [VectorFont](../VectorFont.md) | A prepared font owns its parsed bytes; keep handles local to their Worker or invocation. Invalid arguments and bounded-work failures use GeometryError; unexpected dependency errors propagate. |
 | [VectorFontOptions](../VectorFontOptions.md) | Identifies the actual weight of a static face, without synthesizing a different weight. |
+| [VectorTextArcBaseline](../VectorTextArcBaseline.md) | A circular baseline centered at the XY origin, with rigid shaped glyph groups. |
+| [VectorTextLayoutOptions](../VectorTextLayoutOptions.md) | Text bounded to 512 UTF-16 units: horizontal lines or one circular line without wrapping. |
+| [VectorTextOptions](../VectorTextOptions.md) | Shaping controls for a prepared exact font face; all lengths are in millimetres. |
 
 ## Values
 
@@ -25,4 +28,10 @@ Layout returns immutable paths and metrics in Y-up millimetres. Pass the prepare
 | --- | --- |
 | [MAX_VECTOR_FONT_BYTES](../MAX_VECTOR_FONT_BYTES.md) | Maximum input font size in bytes, checked before parsing or shaping untrusted font data. |
 
-Package: `@metamesh/modeling@0.19.0`.
+## Import
+
+```ts
+import * as text from "@metamesh/modeling/text";
+```
+
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/text/prepareVectorFont.md

@@ -21,6 +21,8 @@ async function prepareLabel(fontBytes: Uint8Array) {
 
 **`bytes`** · `Uint8Array` · Required
 
+Non-empty font bytes, at most 16 MiB; copied before parsing.
+
 
 
 <a id="options"></a>
@@ -43,10 +45,10 @@ async function prepareLabel(fontBytes: Uint8Array) {
 - [VectorFont](VectorFont.md)
 - [VectorFontOptions](VectorFontOptions.md)
 
-## Supported imports
+## Import
 
 ```ts
 import { prepareVectorFont } from "@metamesh/modeling/text";
 ```
 
-Package: `@metamesh/modeling@0.19.0`.
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/text.md

@@ -20,4 +20,10 @@ Paths and metrics use Y-up millimetres and a baseline origin. Empty layouts can
 
 - [Font preparation](text/categories/font-preparation.md) — Prepare exact font bytes within limits and reuse vector layouts.
 
-Package: `@metamesh/modeling@0.19.0`.
+## Import
+
+```ts
+import * as text from "@metamesh/modeling/text";
+```
+
+Package: `@metamesh/modeling@0.20.0`.

package/dist/engine/execution.js

@@ -1,7 +1,7 @@
 import { GeometryError } from "../geometry/errors.js";
-import { analyzeTriangleMesh, } from "../geometry/mesh/mesh.js";
-import { assertMeshAllocationWithinLimits } from "../geometry/model-limits.js";
-import { assertSamplingCount } from "../geometry/sampling-limits.js";
+import { assertMeshAllocationWithinLimits } from "../geometry/limits.js";
+import { analyzeTriangleMesh, } from "../geometry/mesh/operations.js";
+import { assertSamplingCount } from "../geometry/sampling/limits.js";
 import { createSectionHandle, createSolidHandle } from "../model/shape-handles.js";
 import { ownScopedManifoldValue, scopedManifoldScope, trackScopedManifoldValue, } from "./native/context.js";
 import { copiedFloat32Array, copiedUint32Array } from "./native/copied-views.js";
@@ -309,6 +309,8 @@ export function createExecutionContext(module, scope, limits, initialResolution
         },
         restoreNative(geometry) {
             assertActive();
+            // Register the borrow for native-operation guards. The cache keeps cleanup responsibility;
+            // putting this value in the run's allocation scope would delete it while the cache retains it.
             trackScopedManifoldValue(scope, geometry.native.value);
             const shape = geometry.native.kind === "solid"
                 ? wrapSolid(geometry.native.value)

package/dist/engine/finalization.js

@@ -1,9 +1,9 @@
 import { GeometryError } from "../geometry/errors.js";
 import { immutableMeshView } from "../geometry/immutable-buffer.js";
-import { optimizePlanarPatches } from "../geometry/mesh/mesh-planar.js";
-import { validateAnalyzedSolidMesh } from "../geometry/mesh/mesh-solid.js";
-import { MeshViewCache } from "../geometry/mesh/mesh-view-cache.js";
-import { analyzeTriangleMesh, } from "../geometry/mesh/mesh.js";
+import { analyzeTriangleMesh, } from "../geometry/mesh/operations.js";
+import { optimizePlanarPatches } from "../geometry/mesh/planar.js";
+import { validateAnalyzedSolidMesh } from "../geometry/mesh/solid.js";
+import { MeshViewCache } from "../geometry/mesh/view-cache.js";
 import { copiedMeshViews, copiedUint32Array } from "./native/copied-views.js";
 function fitsGeometryLimits(mesh, limits) {
     const buffers = new Set([mesh.positions.buffer, mesh.indices.buffer]);
@@ -14,7 +14,7 @@ function fitsGeometryLimits(mesh, limits) {
         mesh.indices.length / 3 <= limits.maxTriangles &&
         bytes <= limits.maxBytes);
 }
-/** Copies, validates and optionally simplifies local geometry, sharing equal views within one transaction. */
+/** Copies, validates and optionally optimizes planar topology, sharing equal views within one transaction. */
 export function createGeometryFinalizer(execution, limits, options) {
     if (options.meshValidation !== undefined &&
         options.meshValidation !== "topology" &&

package/dist/engine/index.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "../geometry/errors.js";
-import { defaultModelingLimits, resolveModelingLimits } from "../geometry/model-limits.js";
+import { defaultModelingLimits, resolveModelingLimits } from "../geometry/limits.js";
 import { createExecutionContext } from "./execution.js";
 import createManifoldModule from "./kernel/manifold.js";
 import { withManifoldScope } from "./native/context.js";
@@ -12,6 +12,9 @@ export const modelingWasmUrl = new URL("./kernel/manifold.wasm", import.meta.url
  * 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.
+ *
+ * @param program - Model declaration to check without evaluating geometry.
+ * @param args - Parameters, then session options; include any required services.
  */
 export function checkModel(program, ...args) {
     const [parameters, options] = args;
@@ -49,8 +52,8 @@ function engineFromModule(module, engineLimits) {
                 const limits = resolveModelingLimits(options.limits, engineLimits);
                 building = true;
                 try {
-                    // The trusted finalizer captures geometry outside native ownership. Publish its
-                    // immutable storage only after the native scope's structural escape check.
+                    // The trusted finalizer captures owned JavaScript data separately from native values.
+                    // Publish its closure-bearing snapshot facade only after the native scope cleans up.
                     let captured;
                     withManifoldScope(module, (scope) => {
                         let execution;
@@ -75,7 +78,9 @@ function engineFromModule(module, engineLimits) {
     }
 }
 /**
- * Initializes one host kernel and returns a lifecycle-safe engine. No generator initializes WASM.
+ * Initializes one host kernel; runs and sessions own native cleanup.
+ *
+ * @param options - WASM URL and engine resource limits.
  *
  * @example Build a box in a host application
  * ```ts

package/dist/engine/native/adapter.js

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

package/dist/engine/native/construction-mesh.js

@@ -1,8 +1,11 @@
 import { GeometryError } from "../../geometry/errors.js";
-import { assertMeshAllocationWithinLimits, } from "../../geometry/model-limits.js";
+import { assertMeshAllocationWithinLimits } from "../../geometry/limits.js";
 import { ownScopedManifoldValue, scopedManifoldModule, } from "./context.js";
 import { assertNativeSolidStatus } from "./status.js";
-/** Builds new native geometry with retained Double construction coordinates and proxy topology. */
+/**
+ * Builds a scope-owned solid from Float32 proxy topology and authoritative Float64 millimetre coordinates.
+ * Each proxy position must identify one native position, even when the kernel merges or reorders vertices.
+ */
 export function nativeConstructionMesh(scope, mesh, limits, operation) {
     const vertices = mesh.positions.length / 3;
     assertMeshAllocationWithinLimits(vertices, mesh.indices.length / 3, mesh.positions.byteLength +
@@ -17,12 +20,16 @@ export function nativeConstructionMesh(scope, mesh, limits, operation) {
     const key = (x, y, z) => `${x},${y},${z}`;
     const coordinates = new Map();
     for (let index = 0; index < mesh.positions.length; index += 3) {
-        if (![0, 1, 2].every((axis) => Number.isFinite(mesh.nativePositions[index + axis])))
+        if (!Number.isFinite(mesh.nativePositions[index]) ||
+            !Number.isFinite(mesh.nativePositions[index + 1]) ||
+            !Number.isFinite(mesh.nativePositions[index + 2]))
             fail("Native construction coordinates must be finite.");
         const identity = key(mesh.positions[index], mesh.positions[index + 1], mesh.positions[index + 2]);
         const prior = coordinates.get(identity);
         if (prior !== undefined &&
-            [0, 1, 2].some((axis) => mesh.nativePositions[prior + axis] !== mesh.nativePositions[index + axis]))
+            (mesh.nativePositions[prior] !== mesh.nativePositions[index] ||
+                mesh.nativePositions[prior + 1] !== mesh.nativePositions[index + 1] ||
+                mesh.nativePositions[prior + 2] !== mesh.nativePositions[index + 2]))
             fail("A captured construction vertex has ambiguous native coordinates.");
         coordinates.set(identity, index);
     }
@@ -33,7 +40,10 @@ export function nativeConstructionMesh(scope, mesh, limits, operation) {
         for (let vertex = 0; vertex < count; vertex++) {
             const offset = vertex * 3;
             const source = coordinates.get(key(positions[offset], positions[offset + 1], positions[offset + 2])) ?? fail("Native construction lost a captured vertex identity.");
-            positions.set(mesh.nativePositions.subarray(source, source + 3), offset);
+            // Copy coordinates directly to avoid allocating a temporary typed-array view per vertex.
+            positions[offset] = mesh.nativePositions[source];
+            positions[offset + 1] = mesh.nativePositions[source + 1];
+            positions[offset + 2] = mesh.nativePositions[source + 2];
         }
     }));
     assertNativeSolidStatus(result, operation);

package/dist/engine/native/context.js

@@ -18,10 +18,10 @@ const stateFor = (context) => {
 export function createScopedManifoldContext(module, scope) {
     assertWasmObjectScopeActive(scope);
     const context = Object.freeze({});
-    contexts.set(context, { active: true, module, owned: new WeakSet(), scope });
+    contexts.set(context, { active: true, module, trackedValues: new WeakSet(), scope });
     return context;
 }
-/** @internal Returns the live upstream module owned by a scoped context. */
+/** @internal Returns the initialized upstream module used by this live context. */
 export function scopedManifoldModule(context) {
     return stateFor(context).module;
 }
@@ -33,12 +33,15 @@ export function scopedManifoldScope(context) {
 export function ownScopedManifoldValue(context, value) {
     const state = stateFor(context);
     const owned = state.scope.own(value);
-    state.owned.add(owned);
+    state.trackedValues.add(owned);
     return owned;
 }
-/** @internal Records a value already transferred to the context's low-level owner. */
+/**
+ * @internal Registers a borrowed or already scope-owned value without transferring cleanup.
+ * Session-cache borrows remain cache-owned; fresh allocations must use ownScopedManifoldValue.
+ */
 export function trackScopedManifoldValue(context, value) {
-    stateFor(context).owned.add(value);
+    stateFor(context).trackedValues.add(value);
     return value;
 }
 /** @internal Verifies that a context remains active without exposing its internals. */
@@ -47,7 +50,7 @@ export function assertScopedManifoldContext(context) {
 }
 /** @internal Verifies that a live WASM value belongs to this exact context. */
 export function assertScopedManifoldValue(context, value) {
-    if (!stateFor(context).owned.has(value)) {
+    if (!stateFor(context).trackedValues.has(value)) {
         throw new Error("WASM-backed values must be used with the scoped context that owns them.");
     }
 }
@@ -124,7 +127,7 @@ const assertNoScopedEscape = (value, context, seen = new WeakSet()) => {
         return;
     seen.add(objectValue);
     const state = contexts.get(context);
-    if (state?.owned.has(objectValue) === true) {
+    if (state?.trackedValues.has(objectValue) === true) {
         throw new Error("WASM-backed values must not escape a scoped Manifold callback.");
     }
     if (isProtectedCopiedView(objectValue))

package/dist/engine/native/index.js

@@ -7,7 +7,7 @@ export { createScopedManifoldContext, withManifoldScope, } from "./context.js";
 export { box, cylinder, sphere, torus, tube, } from "./scoped-primitives.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 { internalThreadCutter, threadRidge, threadedNut, threadedRod, } from "./scoped-threads.js";
 export {} from "./threads.js";
 export { WasmObjectScope, withWasmObjectScope } from "./ownership.js";
 export { crossSectionToRegion, regionToCrossSection } from "./regions.js";

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

@@ -1,6 +1,6 @@
 import { GeometryError } from "../../geometry/errors.js";
-import { triangleSolidAngle } from "../../geometry/mesh/mesh-solid-intersections.js";
-import { assertMeshAllocationWithinLimits, } from "../../geometry/model-limits.js";
+import { assertMeshAllocationWithinLimits } from "../../geometry/limits.js";
+import { triangleSolidAngle } from "../../geometry/mesh/solid-intersections.js";
 import { ownScopedManifoldValue, scopedManifoldModule, } from "./context.js";
 import { observeNativeMesh, } from "./mesh-observation.js";
 import { assertNativeSolidStatus } from "./status.js";

package/dist/engine/native/mesh-observation.js

@@ -1,5 +1,5 @@
 import { GeometryError } from "../../geometry/errors.js";
-import { assertMeshAllocationWithinLimits, } from "../../geometry/model-limits.js";
+import { assertMeshAllocationWithinLimits } from "../../geometry/limits.js";
 import { ownScopedManifoldValue } from "./context.js";
 import { assertNativeSolidStatus } from "./status.js";
 /** Observes native coordinates and topology without a Float32 geometry round trip. */

package/dist/engine/native/regions.js

@@ -1,6 +1,6 @@
 import { GeometryError } from "../../geometry/errors.js";
-import { contourContainsPoint, normalizeContour, normalizeRegion, signedContourArea, } from "../../geometry/regions.js";
-import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../../geometry/sampling-limits.js";
+import { contourContainsPoint, normalizeContour, normalizeRegion, signedContourArea, } from "../../geometry/regions/operations.js";
+import { assertSamplingCount, resolveGeometrySamplingLimits, } from "../../geometry/sampling/limits.js";
 import { assertScopedManifoldValue, ownScopedManifoldValue, scopedManifoldModule, } from "./context.js";
 /** @internal One contour ceiling shared with authored input normalization preflights. */
 export const MAX_AGGREGATE_CONTOURS = 25_000;
@@ -9,6 +9,7 @@ const assertRegionBounds = (regions, operation, limits = {}) => {
     if (!hasArrayShape) {
         throw new GeometryError("INVALID_ARGUMENT", "Regions must be an array.", { operation });
     }
+    const maximumPoints = resolveGeometrySamplingLimits(limits).maxProfilePoints;
     let contours = 0;
     let vertices = 0;
     if (regions.length > MAX_AGGREGATE_CONTOURS) {
@@ -47,9 +48,9 @@ const assertRegionBounds = (regions, operation, limits = {}) => {
                     details: { contours, vertices },
                 });
             }
-            assertSamplingCount(vertices, operation, resolveGeometrySamplingLimits(limits).maxProfilePoints);
-            for (const loop of [polygon.outer, ...polygon.holes]) {
-                for (const point of loop) {
+            assertSamplingCount(vertices, operation, maximumPoints);
+            for (const contour of [polygon.outer, ...polygon.holes]) {
+                for (const point of contour) {
                     if (!Array.isArray(point) || point.length !== 2) {
                         throw new GeometryError("INVALID_ARGUMENT", "Region points must be exact XY tuples.", {
                             operation,
@@ -67,7 +68,7 @@ const assertRegionBounds = (regions, operation, limits = {}) => {
 };
 const contoursFromRegion = (region) => region
     .flatMap((polygon) => [polygon.outer, ...polygon.holes])
-    .map((loop) => loop.map(([x, y]) => [x, y]));
+    .map((contour) => contour.map(([x, y]) => [x, y]));
 /**
  * Converts explicit normalized region topology to a scope-owned CrossSection.
  *
@@ -82,15 +83,19 @@ export function regionToCrossSection(context, region, limits = {}) {
         return ownScopedManifoldValue(context, module.CrossSection.union([]));
     return ownScopedManifoldValue(context, new module.CrossSection(contoursFromRegion(normalized)));
 }
-/** Internal filled-loop classification shared by native Section and exact collar observations. */
-export const regionFromLoops = (loops) => {
-    const outers = loops
-        .filter((loop) => signedContourArea(loop) > 0)
+/**
+ * Classifies native XY contours in millimetres into CCW exteriors and CW holes.
+ * Each hole belongs to its smallest enclosing exterior; contour order carries no topology identity.
+ * Normalization validates the resulting material regions.
+ */
+export const regionFromContours = (contours) => {
+    const outers = contours
+        .filter((contour) => signedContourArea(contour) > 0)
         .map((outer) => ({ outer: normalizeContour(outer, true), holes: [] }));
-    const holes = loops
-        .filter((loop) => signedContourArea(loop) < 0)
+    const holes = contours
+        .filter((contour) => signedContourArea(contour) < 0)
         .map((hole) => normalizeContour(hole, false));
-    if (outers.length === 0 && loops.length > 0) {
+    if (outers.length === 0 && contours.length > 0) {
         throw new GeometryError("INVALID_TOPOLOGY", "CrossSection did not contain an exterior contour.");
     }
     const outerBounds = new Map(outers.map((polygon) => {
@@ -104,20 +109,35 @@ export const regionFromLoops = (loops) => {
             maximumX = Math.max(maximumX, x);
             maximumY = Math.max(maximumY, y);
         }
-        return [polygon, { minimumX, minimumY, maximumX, maximumY }];
+        return [
+            polygon,
+            {
+                minimumX,
+                minimumY,
+                maximumX,
+                maximumY,
+                area: Math.abs(signedContourArea(polygon.outer)),
+            },
+        ];
     }));
     for (const hole of holes) {
         const [x, y] = hole[0];
-        const owner = outers
-            .filter((polygon) => {
+        let owner;
+        let smallestArea = Infinity;
+        // Material islands can nest inside cavities. Keep the nearest enclosing exterior without
+        // sorting candidates or remeasuring their contours for every hole.
+        for (const polygon of outers) {
             const bounds = outerBounds.get(polygon);
-            return (x >= bounds.minimumX &&
+            if ((owner === undefined || bounds.area < smallestArea) &&
+                x >= bounds.minimumX &&
                 x <= bounds.maximumX &&
                 y >= bounds.minimumY &&
                 y <= bounds.maximumY &&
-                contourContainsPoint(polygon.outer, hole[0]));
-        })
-            .sort((a, b) => Math.abs(signedContourArea(a.outer)) - Math.abs(signedContourArea(b.outer)))[0];
+                contourContainsPoint(polygon.outer, hole[0])) {
+                owner = polygon;
+                smallestArea = bounds.area;
+            }
+        }
         if (owner === undefined) {
             throw new GeometryError("INVALID_TOPOLOGY", "CrossSection hole had no containing exterior.");
         }
@@ -129,12 +149,12 @@ export const regionFromLoops = (loops) => {
 export function crossSectionToRegion(context, section, limits = {}) {
     assertScopedManifoldValue(context, section);
     assertSamplingCount(section.numVert(), "crossSectionToRegion", resolveGeometrySamplingLimits(limits).maxProfilePoints);
-    // Normalization owns the one immutable coordinate copy and reuses validated child loops.
-    const loops = section.toPolygons();
-    if (loops.length > MAX_AGGREGATE_CONTOURS) {
+    // Normalization owns the one immutable coordinate copy and reuses validated child contours.
+    const contours = section.toPolygons();
+    if (contours.length > MAX_AGGREGATE_CONTOURS) {
         throw new GeometryError("COMPLEXITY_LIMIT", "Resolved regions exceed 25000 contours.", {
             operation: "crossSectionToRegion",
         });
     }
-    return regionFromLoops(loops);
+    return regionFromContours(contours);
 }

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

@@ -1,6 +1,6 @@
-import { resolveCylinderPrimitive } from "../../geometry/cylinder.js";
-import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../../geometry/model-limits.js";
-import { boxFaceAxes, resolveBoxPrimitive, resolveSpherePrimitive, resolveTorusPrimitive, resolveTubePrimitive, } from "../../geometry/primitive-resolvers.js";
+import { assertMeshAllocationWithinLimits, resolveModelingLimits, } from "../../geometry/limits.js";
+import { resolveCylinderPrimitive } from "../../geometry/primitives/cylinder.js";
+import { boxFaceAxes, resolveBoxPrimitive, resolveSpherePrimitive, resolveTorusPrimitive, resolveTubePrimitive, } from "../../geometry/primitives/resolvers.js";
 import { ownScopedManifoldValue, scopedManifoldModule, } from "./context.js";
 import { transform } from "./transforms.js";
 const meshBudget = (vertices, triangles, operation, limits) => assertMeshAllocationWithinLimits(vertices, triangles, 12 * (vertices + triangles), operation, resolveModelingLimits(limits));

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

@@ -1,18 +1,10 @@
 import { scopedManifoldModule, scopedManifoldScope, trackScopedManifoldValue, } from "./context.js";
-import { internalThreadCutterSolid, preflightInternalThreadCutterSolid, preflightThreadedNutSolid, preflightThreadedRodSolid, threadedNutSolid, threadedRodSolid, threadRidgeSolid, } from "./threads.js";
+import { internalThreadCutterSolid, threadedNutSolid, threadedRodSolid, threadRidgeSolid, } from "./threads.js";
 /** Converts a runtime-neutral helical ridge mesh into a context-owned Manifold. */
 export function threadRidge(context, options) {
     const solid = threadRidgeSolid(scopedManifoldModule(context), options, scopedManifoldScope(context));
     return trackScopedManifoldValue(context, solid);
 }
-/** Preflights the exact compensated direct mesh used by {@link threadedRod}. */
-export function preflightThreadedRod(options) {
-    return preflightThreadedRodSolid(options);
-}
-/** Preflights the exact extended mesh used by {@link internalThreadCutter}. */
-export function preflightInternalThreadCutter(options) {
-    return preflightInternalThreadCutterSolid(options);
-}
 /** Creates a compensated context-owned external threaded rod along +Z. */
 export function threadedRod(context, options) {
     const solid = threadedRodSolid(scopedManifoldModule(context), options, scopedManifoldScope(context));
@@ -23,10 +15,6 @@ export function internalThreadCutter(context, options) {
     const solid = internalThreadCutterSolid(scopedManifoldModule(context), options, scopedManifoldScope(context));
     return trackScopedManifoldValue(context, solid);
 }
-/** Preflights a nut's exact body, cutter, and chamfer geometry without WASM allocation. */
-export function preflightThreadedNut(options) {
-    return preflightThreadedNutSolid(options);
-}
 /** Creates a context-owned nut body and subtracts its compensated internal thread. */
 export function threadedNut(context, options) {
     const solid = threadedNutSolid(scopedManifoldModule(context), options, scopedManifoldScope(context));

package/dist/engine/native/threads.js

@@ -1,7 +1,7 @@
-import { threadRidgeMesh, threadSolidMesh } from "../../geometry/mechanical/index.js";
+import { threadRidgeMesh, threadSolidMesh } from "../../geometry/mechanical/threads/mesh.js";
 import { resolveCompensatedThreadSolidMesh, resolveThreadedNutSolid, } from "../../geometry/mechanical/threads/solids.js";
 import { triangleMeshToManifold } from "./adapter.js";
-export { preflightThreadedRodSolid, preflightInternalThreadCutterSolid, preflightThreadedNutSolid, } from "../../geometry/mechanical/threads/solids.js";
+export {} 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, threadRidgeMesh(options), scope);

package/dist/engine/native/transforms.js

@@ -1,5 +1,5 @@
-import { attachmentTransform3 } from "../../geometry/anchors.js";
 import { GeometryError } from "../../geometry/errors.js";
+import { attachmentTransform3 } from "../../geometry/transforms/anchors.js";
 import { assertScopedManifoldValue, ownScopedManifoldValue, } from "./context.js";
 const finiteVector = (value, name, operation) => {
     if (!value.every(Number.isFinite)) {
@@ -110,5 +110,5 @@ export function attach(context, solid, source, target, options = {}) {
         ...(options.gap === undefined ? {} : { gap: options.gap }),
         ...(options.spin === undefined ? {} : { spin: options.spin }),
         ...(options.tolerance === undefined ? {} : { tolerance: options.tolerance }),
-    }));
+    }).toData());
 }