@metamesh/modeling 0.12.0 → 0.14.0

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

@@ -0,0 +1,111 @@
+# VectorTextLayoutOptions
+
+Text bounded to 512 UTF-16 units: horizontal lines or one circular line without wrapping.
+
+## Extends
+
+- [`VectorTextOptions`](VectorTextOptions.md)
+
+## Properties
+
+### align?
+
+
+
+`readonly` `optional` **align?**: `"left"` \| `"right"` \| `"center"`
+
+
+
+Place the advance's start, midpoint or end at the datum; defaults to center on arcs, otherwise left.
+
+***
+
+### baseline?
+
+
+
+`readonly` `optional` **baseline?**: [`VectorTextArcBaseline`](VectorTextArcBaseline.md)
+
+
+
+Omitted uses horizontal lines. Arcs require one line and baseline vertical alignment.
+
+***
+
+### lineHeight?
+
+
+
+`readonly` `optional` **lineHeight?**: `number`
+
+
+
+Baseline spacing in ems, 0.5–5; omitted uses the selected face's natural vertical metrics.
+
+***
+
+### verticalAlign?
+
+
+
+`readonly` `optional` **verticalAlign?**: `"top"` \| `"bottom"` \| `"center"` \| `"baseline"`
+
+
+
+Place the first baseline or complete ink bounds at Y=0; arcs only accept baseline.
+
+***
+
+### fontSize
+
+
+
+`readonly` **fontSize**: `number`
+
+
+
+Em size in millimetres, greater than zero and at most 10000; not the visible glyph height.
+
+#### Inherited from
+
+[`VectorTextOptions`](VectorTextOptions.md).[`fontSize`](VectorTextOptions.md#fontsize)
+
+***
+
+### fontWeight?
+
+
+
+`readonly` `optional` **fontWeight?**: `number`
+
+
+
+Actual static or variable weight, 1–1000; defaults to the prepared face's static weight.
+
+#### Inherited from
+
+[`VectorTextOptions`](VectorTextOptions.md).[`fontWeight`](VectorTextOptions.md#fontweight)
+
+***
+
+### letterSpacing?
+
+
+
+`readonly` `optional` **letterSpacing?**: `number`
+
+
+
+Tracking between glyph clusters in millimetres, -100–100; defaults to zero.
+
+#### Inherited from
+
+[`VectorTextOptions`](VectorTextOptions.md).[`letterSpacing`](VectorTextOptions.md#letterspacing)
+
+
+## Related APIs
+
+- [VectorTextArcBaseline](VectorTextArcBaseline.md)
+- [VectorTextOptions](VectorTextOptions.md)
+
+Package: `@metamesh/modeling@0.14.0`.

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

@@ -0,0 +1,94 @@
+# VectorTextMetrics
+
+Text measurements from the same immutable layout that supplies geometry and SVG outlines.
+
+## Properties
+
+### bounds
+
+
+
+`readonly` **bounds**: [`Bounds2`](Bounds2.md) \| `null`
+
+
+
+Visible curve bounds after alignment, or null when the text has no ink.
+
+***
+
+### advance
+
+
+
+`readonly` **advance**: readonly \[`number`, `number`\]
+
+
+
+Unaligned logical advance and negative baseline displacement in mm; arcs retain [arc length, 0].
+
+***
+
+### logicalWidth
+
+
+
+`readonly` **logicalWidth**: `number`
+
+
+
+Maximum logical line advance in millimetres, including spaces; arc length on circular baselines.
+
+***
+
+### ascent
+
+
+
+`readonly` **ascent**: `number`
+
+
+
+Selected font's ascender distance above a baseline in millimetres, independent of the text.
+
+***
+
+### descent
+
+
+
+`readonly` **descent**: `number`
+
+
+
+Selected font's descender distance below a baseline in millimetres, a non-negative value.
+
+***
+
+### lineHeight
+
+
+
+`readonly` **lineHeight**: `number`
+
+
+
+Actual distance between baselines in millimetres.
+
+***
+
+### lineCount
+
+
+
+`readonly` **lineCount**: `number`
+
+
+
+Number of lines, including empty and trailing lines; empty text occupies one line.
+
+
+## Related APIs
+
+- [Bounds2](Bounds2.md)
+
+Package: `@metamesh/modeling@0.14.0`.

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

@@ -0,0 +1,50 @@
+# VectorTextOptions
+
+Shaping controls for a prepared exact font face; all lengths are in millimetres.
+
+## Extended by
+
+- [`VectorTextLayoutOptions`](VectorTextLayoutOptions.md)
+
+## Properties
+
+### fontSize
+
+
+
+`readonly` **fontSize**: `number`
+
+
+
+Em size in millimetres, greater than zero and at most 10000; not the visible glyph height.
+
+***
+
+### fontWeight?
+
+
+
+`readonly` `optional` **fontWeight?**: `number`
+
+
+
+Actual static or variable weight, 1–1000; defaults to the prepared face's static weight.
+
+***
+
+### letterSpacing?
+
+
+
+`readonly` `optional` **letterSpacing?**: `number`
+
+
+
+Tracking between glyph clusters in millimetres, -100–100; defaults to zero.
+
+
+## Related APIs
+
+- [VectorTextLayoutOptions](VectorTextLayoutOptions.md)
+
+Package: `@metamesh/modeling@0.14.0`.

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

@@ -0,0 +1,38 @@
+# Font preparation
+
+Prepare bounded exact font bytes and reusable vector layouts.
+
+Prepare fonts before modeling. TTF, OTF, and WOFF are parsed directly; WOFF2 decoding loads lazily. No fetching occurs in this library. Font layout returns immutable paths and metrics in Y-up millimetres. Pass that prepared layout to textSection inside a build; do not shape it again.
+
+## Functions
+
+| API | Summary |
+| --- | --- |
+| [prepareVectorFont](../prepareVectorFont.md) | Parses bounded font bytes using optional fontkit and WOFF2 peers; no font fetching occurs here. |
+
+## Interfaces
+
+| API | Summary |
+| --- | --- |
+| [VectorFont](../VectorFont.md) | A prepared font owns its parsed bytes; keep handles local to their Worker or invocation. |
+| [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. |
+| [VectorTextLayout](../VectorTextLayout.md) | Immutable vector layout with no browser, font parser, or kernel ownership. |
+| [VectorTextLayoutOptions](../VectorTextLayoutOptions.md) | Text bounded to 512 UTF-16 units: horizontal lines or one circular line without wrapping. |
+| [VectorTextMetrics](../VectorTextMetrics.md) | Text measurements from the same immutable layout that supplies geometry and SVG outlines. |
+| [VectorTextOptions](../VectorTextOptions.md) | Shaping controls for a prepared exact font face; all lengths are in millimetres. |
+| [Bounds2](../Bounds2.md) | Axis-aligned bounds in two-dimensional model space. |
+
+## Type aliases
+
+| API | Summary |
+| --- | --- |
+| [Vector2Tuple](../Vector2Tuple.md) | A two-dimensional Cartesian vector or point. |
+
+## Values
+
+| API | Summary |
+| --- | --- |
+| [MAX_VECTOR_FONT_BYTES](../MAX_VECTOR_FONT_BYTES.md) | Limits apply before parsing or shaping untrusted font data. |
+
+Package: `@metamesh/modeling@0.14.0`.

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

@@ -0,0 +1,46 @@
+# prepareVectorFont
+
+Parses bounded font bytes using optional fontkit and WOFF2 peers; no font fetching occurs here.
+
+**prepareVectorFont**(`bytes`: `Uint8Array`, `options?`: [`VectorFontOptions`](VectorFontOptions.md)): `Promise`\<[`VectorFont`](VectorFont.md)\>
+
+
+
+## Example: Prepare a label before building geometry
+
+```ts
+async function prepareLabel(fontBytes: Uint8Array) {
+  const font = await prepareVectorFont(fontBytes);
+  return font.layout("MetaMesh", { fontSize: 8 });
+}
+```
+
+## Parameters
+
+<a id="bytes"></a>
+
+**`bytes`** · `Uint8Array` · Required
+
+
+
+<a id="options"></a>
+
+**`options`** · [`VectorFontOptions`](VectorFontOptions.md) · Optional
+
+- [`staticWeight`](VectorFontOptions.md#staticweight) · `number` · Optional
+
+  Actual weight of a static face, 1–1000; defaults to 400.
+
+
+
+## Returns
+
+`Promise`\<[`VectorFont`](VectorFont.md)\>
+
+
+## Related APIs
+
+- [VectorFont](VectorFont.md)
+- [VectorFontOptions](VectorFontOptions.md)
+
+Package: `@metamesh/modeling@0.14.0`.

package/dist/docs/reference/text.md

@@ -0,0 +1,21 @@
+# Text preparation
+
+Prepare exact font bytes and shape reusable vector layouts before entering synchronous modeling.
+
+Install `fontkit` for font preparation and `woff2-encoder` for WOFF2 decoding. Import optional exact-font preparation from `@metamesh/modeling/text`. Supply already acquired font bytes; this entrypoint never fetches a font. Shape once during preparation and pass the immutable layout to modeling.
+
+```ts
+import { prepareVectorFont } from "@metamesh/modeling/text";
+export async function prepareLabel(bytes: Uint8Array) {
+  const font = await prepareVectorFont(bytes);
+  return font.layout("MetaMesh", { fontSize: 8 });
+}
+```
+
+Paths and metrics use Y-up millimetres and a baseline origin. Empty layouts can be measured but cannot create a manufacturing section. Font parsing and WOFF2 decoding stay outside synchronous native builds.
+
+## Categories
+
+- [Font preparation](text/categories/font-preparation.md) — Prepare bounded exact font bytes and reusable vector layouts.
+
+Package: `@metamesh/modeling@0.14.0`.

package/dist/engine/construction-operations.js

@@ -1,3 +1,4 @@
+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";
@@ -28,7 +29,7 @@ export function createConstructionOperations(environment, sections) {
         const normal = [scaled[0] / length, scaled[1] / length, scaled[2] / length];
         return { normal, offset: validateFiniteNumber(value.offset ?? 0, operation) };
     };
-    const fromContours = sections.sectionFromContours;
+    const fromContours = (contours) => sections.polygon({ contours });
     const corresponding = (value) => typeof value === "object" && value !== null && "components" in value;
     const shapeSection = (shape) => corresponding(shape)
         ? nativeSection(fromContours(shape.components.flatMap((component) => [component.outer, ...component.holes].map((contour) => contour.points))))
@@ -38,8 +39,14 @@ export function createConstructionOperations(environment, sections) {
         assertPrimitiveOptions(value, "extrude");
         const native = shapeSection(handle), resolved = withResolutionDefaults(value);
         if (value.ends !== undefined) {
-            const profile = corresponding(handle) ? handle : environment.sectionProfileFor(handle);
-            return solidFromMesh(buildFinishedExtrusion(module, profile, resolved));
+            assertPrimitiveOptions(value.ends, "extrude");
+            const setbacks = [value.ends.bottom, value.ends.top].map((treatment) => treatment === undefined
+                ? [0, 0]
+                : edgeTreatmentSetbacks(treatment, "extrude", Math.PI / 2, resolved.limits));
+            if (setbacks.some((pair) => pair.some((distance) => distance > 0))) {
+                const profile = corresponding(handle) ? handle : environment.sectionProfileFor(handle);
+                return solidFromMesh(buildFinishedExtrusion(module, profile, resolved));
+            }
         }
         assertSamplingCount(native.numVert(), "extrude", resolved.limits.maxProfilePoints);
         const controls = resolveExtrusionControls(value.height, resolved, "extrude");

package/dist/engine/deferred-context.js

@@ -1,84 +1,17 @@
-import { GeometryError } from "../geometry/errors.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 { 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",
-    sectionFromContours: "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),
@@ -86,97 +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 = [];
-    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));
-    }
-    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

@@ -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.