@metamesh/modeling 0.18.0 → 0.20.0

package/dist/docs/reference/geometry/strokeRegionData.md

@@ -8,8 +8,9 @@ Converts a sampled millimetre path into the filled region covered by a centered
 
 Closed paths omit a duplicated seam point. Zero-length sampled segments are ignored, while the
 effective path must still contain visible length. Round caps and joins use deterministic physical
-resolution. Bevels fill the outer corner triangle; miters extend the outer edges to their
-intersection, falling back to bevels above SVG's default miter limit of 4.
+resolution. Caps are tangent-aligned semicircles with `ceil(circularSegments / 2)` intervals,
+following [resolveArcSegments](resolveArcSegments.md). Bevels fill the outer corner triangle; miters extend the
+outer edges to their intersection, falling back to bevels above SVG's default miter limit of 4.
 
 ## Parameters
 
@@ -17,6 +18,8 @@ intersection, falling back to bevels above SVG's default miter limit of 4.
 
 **`path`** · [`Path2Input`](Path2Input.md) · Required
 
+Sampled XY path in millimetres; path values supply closure.
+
 
 
 <a id="options"></a>
@@ -45,7 +48,7 @@ intersection, falling back to bevels above SVG's default miter limit of 4.
 
 - [`resolution`](StrokeOptions.md#resolution) · [`GeometryResolution`](GeometryResolution.md) · Optional
 
-  Physical tessellation policy for round caps and joins.
+  Physical tessellation for round features; caps use tangent-aligned 180-degree arcs.
 
 
 
@@ -62,6 +65,12 @@ intersection, falling back to bevels above SVG's default miter limit of 4.
 
 ## Guides
 
-- [SVG preflight work and guarantees](../../guides/concepts.md#check-preflight-guarantees)
+- [SVG preflight work and guarantees](../../guides/resolution-and-inspection.md#check-preflight-guarantees)
+
+## Import
+
+```ts
+import { strokeRegionData } from "@metamesh/modeling/geometry";
+```
 
-Package: `@metamesh/modeling@0.18.0`.
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/geometry/transform2.md

@@ -25,6 +25,8 @@ Use `toData()` for frozen matrix interchange.
 
 **`input`** · [`Transform2Input`](Transform2Input.md) · Optional
 
+XY affine value or row-major 3x3 matrix; copied. Defaults to identity.
+
 
 
 ## Returns
@@ -39,7 +41,13 @@ Use `toData()` for frozen matrix interchange.
 
 ## Guides
 
-- [Reusable transforms and vector math](../../guides/concepts.md#reuse-a-transform-across-shapes-and-coordinates)
-- [Fluent values and tuple kernels](../../guides/concepts.md#choose-fluent-values-or-standalone-algorithms)
+- [Reusable transforms and vector math](../../guides/transforms-and-placement.md#reuse-a-transform-across-shapes-and-coordinates)
+- [Fluent values and tuple kernels](../../guides/geometry-values.md#fluent-values-plain-data-and-descriptors)
+
+## Import
+
+```ts
+import { transform2 } from "@metamesh/modeling/geometry";
+```
 
-Package: `@metamesh/modeling@0.18.0`.
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/geometry/transform3.md

@@ -13,13 +13,28 @@ const placement = transform3().rotate([0, 0, 90]).translate([10, 0, 0]);
 placement.applyPoint([1, 0, 0]).toData(); // approximately [10, 1, 0]
 ```
 
-Values and data are copied and validated.
+## Example: Convert a coordinate frame to an affine value
+
+```ts
+const local = frame3({
+  origin: [10, 0, 0],
+  xAxis: [0, 1, 0],
+  yAxis: [-1, 0, 0],
+  zAxis: [0, 0, 1],
+});
+const placement = transform3(local);
+placement.applyPoint([2, 0, 0]).toData(); // [10, 2, 0]
+```
+
+Values, matrices, and frames are copied and validated.
 Calls apply in written order; rotations use degrees and pivots use current world coordinates.
 Zero scales, singular matrices, nonfinite inputs and zero rotation axes throw GeometryError.
-Use frameTransform3(frame) as the input for existing orthonormal frame placement.
+A frame supplies its origin in millimetres and right-handed orthonormal axes as local-to-world
+columns. Invalid axes reject; unit-length roundoff is normalized within geometry tolerance.
 
 Use `toData()` for frozen matrix interchange.
-[composeTransform3](composeTransform3.md) takes matrices in after, before order.
+[multiplyTransform3](../math/multiplyTransform3.md) multiplies left and right matrices;
+the right factor acts first on column vectors.
 
 ## Parameters
 
@@ -27,6 +42,8 @@ Use `toData()` for frozen matrix interchange.
 
 **`input`** · [`Transform3Input`](Transform3Input.md) · Optional
 
+XYZ affine value, row-major 4x4 matrix, or frame; copied. Defaults to identity.
+
 
 
 ## Returns
@@ -41,7 +58,13 @@ Use `toData()` for frozen matrix interchange.
 
 ## Guides
 
-- [Reusable transforms and vector math](../../guides/concepts.md#reuse-a-transform-across-shapes-and-coordinates)
-- [Fluent values and tuple kernels](../../guides/concepts.md#choose-fluent-values-or-standalone-algorithms)
+- [Reusable transforms and vector math](../../guides/transforms-and-placement.md#reuse-a-transform-across-shapes-and-coordinates)
+- [Fluent values and tuple kernels](../../guides/geometry-values.md#fluent-values-plain-data-and-descriptors)
+
+## Import
+
+```ts
+import { transform3 } from "@metamesh/modeling/geometry";
+```
 
-Package: `@metamesh/modeling@0.18.0`.
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/geometry/transformRegionData.md

@@ -12,12 +12,16 @@ Transforms serialized polygon data with reflection-safe winding, without an engi
 
 **`region`** · [`RegionData`](RegionData.md) · Required
 
+Millimetre polygons whose boundaries are normalized before placement.
+
 
 
 <a id="transform"></a>
 
 **`transform`** · [`Transform2Input`](Transform2Input.md) · Required
 
+Planar affine placement; reflections preserve winding.
+
 
 
 <a id="tolerance"></a>
@@ -39,6 +43,12 @@ Transforms serialized polygon data with reflection-safe winding, without an engi
 
 ## Guides
 
-- [Choose a geometry representation](../../guides/concepts.md#geometry-vocabulary)
+- [Choose a geometry representation](../../guides/geometry-values.md#material-boundaries-and-matching-profiles)
+
+## Import
+
+```ts
+import { transformRegionData } from "@metamesh/modeling/geometry";
+```
 
-Package: `@metamesh/modeling@0.18.0`.
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/geometry/triangulateContour.md

@@ -1,6 +1,6 @@
 # triangulateContour
 
-Ear-clips one normalized simple CCW loop into stable local vertex indices.
+Triangulates one simple loop into indices of its normalized CCW vertex order.
 
 **triangulateContour**(`loop`: [`Contour`](Contour.md)): `Uint32Array`
 
@@ -12,6 +12,8 @@ Ear-clips one normalized simple CCW loop into stable local vertex indices.
 
 **`loop`** · [`Contour`](Contour.md) · Required
 
+Boundary to normalize; indices address its cleaned CCW order.
+
 
 
 ## Returns
@@ -25,6 +27,12 @@ Ear-clips one normalized simple CCW loop into stable local vertex indices.
 
 ## Guides
 
-- [Choose a geometry representation](../../guides/concepts.md#geometry-vocabulary)
+- [Choose a geometry representation](../../guides/geometry-values.md#material-boundaries-and-matching-profiles)
+
+## Import
+
+```ts
+import { triangulateContour } from "@metamesh/modeling/geometry";
+```
 
-Package: `@metamesh/modeling@0.18.0`.
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/geometry/vector2.md

@@ -11,7 +11,7 @@ and overflow throw `NON_FINITE_VALUE` GeometryError.
 Use transform2().applyDirection(value) for rotations and nonuniform scaling.
 
 Use `toData()` for frozen tuple interchange, or
-[normalize2](normalize2.md) for tuple-based normalization in numerical loops.
+[normalize2](../math/normalize2.md) for tuple-based normalization in numerical loops.
 
 ## Parameters
 
@@ -19,6 +19,8 @@ Use `toData()` for frozen tuple interchange, or
 
 **`input`** · [`Vector2Input`](Vector2Input.md) · Required
 
+Finite XY tuple or vector; coordinates are copied without changing their units.
+
 
 
 ## Returns
@@ -33,7 +35,13 @@ Use `toData()` for frozen tuple interchange, or
 
 ## Guides
 
-- [Reusable transforms and vector math](../../guides/concepts.md#reuse-a-transform-across-shapes-and-coordinates)
-- [Fluent values and tuple kernels](../../guides/concepts.md#choose-fluent-values-or-standalone-algorithms)
+- [Reusable transforms and vector math](../../guides/transforms-and-placement.md#reuse-a-transform-across-shapes-and-coordinates)
+- [Fluent values and tuple kernels](../../guides/geometry-values.md#fluent-values-plain-data-and-descriptors)
+
+## Import
+
+```ts
+import { vector2 } from "@metamesh/modeling/geometry";
+```
 
-Package: `@metamesh/modeling@0.18.0`.
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/geometry/vector3.md

@@ -9,6 +9,8 @@ Creates immutable XYZ arithmetic from a finite tuple or vector, snapshotting the
 ## Example
 
 ```ts
+import { vector3 } from "@metamesh/modeling/geometry";
+
 const direction = vector3([1, 2, 3]).add([4, 0, 0]).normalize().scale(10);
 const alignment = direction.dot([0, 0, 1]);
 ```
@@ -18,7 +20,7 @@ and overflow throw `NON_FINITE_VALUE` GeometryError.
 Use transform3().applyDirection(value) for rotations and nonuniform scaling.
 
 Use `toData()` for frozen tuple interchange, or
-[normalize3](normalize3.md) for tuple-based normalization in numerical loops.
+[normalize3](../math/normalize3.md) for tuple-based normalization in numerical loops.
 
 ## Parameters
 
@@ -26,6 +28,8 @@ Use `toData()` for frozen tuple interchange, or
 
 **`input`** · [`Vector3Input`](Vector3Input.md) · Required
 
+Finite XYZ tuple or vector; coordinates are copied without changing their units.
+
 
 
 ## Returns
@@ -40,7 +44,13 @@ Use `toData()` for frozen tuple interchange, or
 
 ## Guides
 
-- [Reusable transforms and vector math](../../guides/concepts.md#reuse-a-transform-across-shapes-and-coordinates)
-- [Fluent values and tuple kernels](../../guides/concepts.md#choose-fluent-values-or-standalone-algorithms)
+- [Reusable transforms and vector math](../../guides/transforms-and-placement.md#reuse-a-transform-across-shapes-and-coordinates)
+- [Fluent values and tuple kernels](../../guides/geometry-values.md#fluent-values-plain-data-and-descriptors)
+
+## Import
+
+```ts
+import { vector3 } from "@metamesh/modeling/geometry";
+```
 
-Package: `@metamesh/modeling@0.18.0`.
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/geometry.md

@@ -1,32 +1,27 @@
 # Geometry foundations
 
-Pure curves, profiles, regions, meshes, transforms, and mechanical construction without initializing a native engine.
+Pure geometry values, curves, profiles, regions, and placement algorithms without initializing a native engine.
 
-Use `@metamesh/modeling/geometry` for runtime-neutral calculations with curves, profiles, transforms, regions, meshes, SVG, and mechanical geometry. These helpers work without an SDK or native engine.
+Use @metamesh/modeling/geometry for immutable vectors, transforms, bounds, paths, plain geometry descriptors, contours, identified profiles, regions, placement, sampling, and diagnostics. Pure calculations require no engine. Values accept matching data and expose toData() for frozen interchange. Descriptors remain plain readonly records.
 
-```ts
-import { sampleCurve2, rectangleContour } from "@metamesh/modeling/geometry";
-const arc = sampleCurve2({ kind: "arc", center: [0, 0], radius: 10, sweepAngle: 90 });
-const contour = rectangleContour({ size: [30, 20], treatment: { kind: "round", radius: 3 } });
-```
-
-Lengths use millimetres. Winding and closing conventions are explicit. The [mesh module](mesh.md) constructs and processes ordinary triangle buffers; `mesh.join` concatenates without Boolean union. Mesh inspection reads mutable external arrays afresh. Predictable allocations are checked against limits before sampling.
-
-Use `bounds2`/`bounds3` for immutable measurement queries and `Bounds2Data`/`Bounds3Data` for min/max records. Standalone bounds helpers fit and arrange parts from either form. Fit text vector paths before sampling to retain physical tolerance.
-
-Choose [fluent values or standalone algorithms](../guides/concepts.md#choose-fluent-values-or-standalone-algorithms), compare [geometry representations](../guides/concepts.md#geometry-vocabulary), and check [preflight guarantees](../guides/concepts.md#check-preflight-guarantees).
+Numerical tuple and matrix kernels live in /geometry/math; mechanical dimensions and preflights live in /geometry/mechanical; triangle-buffer operations live in /geometry/mesh. Every public value and type has one import path.
 
 ## Categories
 
-- [Mechanical foundations](geometry/categories/mechanical.md) — Resolve gears, knuckle joints, fastener standards, thread profiles, fit, and predictable allocations.
-- [Triangle meshes and surfaces](geometry/categories/meshes.md) — Data, options, and reports for triangle mesh construction and processing.
+- [Immutable geometry data](geometry/categories/immutable-data.md) — Capture reusable numeric data and construction placement contracts.
 - [SVG and vector layouts](geometry/categories/vector-import.md) — Parse painted SVG within limits and work with explicitly prepared text geometry.
 - [Profiles and regions](geometry/categories/profiles-regions.md) — Define winding, holes, stable profile landmarks, and reusable planar boundaries.
-- [Curves and paths](geometry/categories/curves-paths.md) — Sample reusable lines, arcs, cubic curves, and path frames with explicit physical sampling settings.
+- [Curves and paths](geometry/categories/curves-paths.md) — Query, edit, refine, and interpolate paths with explicit closure and physical sampling settings.
 - [Bounds and layout](geometry/categories/bounds-layout.md) — Measure finite bounds, test positioned containment, and fit or arrange geometry.
 - [Pattern placement](geometry/categories/pattern-placement.md) — Calculate pure linear, radial, grid, and path transforms.
-- [Transforms and vector math](geometry/categories/transforms-math.md) — Build reusable placements and calculate with immutable fluent vectors or tuple math.
+- [Vectors, transforms, and attachment](geometry/categories/transforms-math.md) — Calculate with immutable values and place geometry using frames and anchors.
 - [Resolution and errors](geometry/categories/resolution-errors.md) — Set physical sampling and numerical tolerances, and understand errors in context.
 - [Primitive options](geometry/categories/primitive-options.md) — Configure dimensional primitives and edge treatments with shared options.
 
-Package: `@metamesh/modeling@0.18.0`.
+## Import
+
+```ts
+import * as geometry from "@metamesh/modeling/geometry";
+```
+
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/{geometry → math}/AxisAngleRotation3.md

@@ -61,7 +61,12 @@ Excluded when the angle is expressed in radians.
 
 ## Guides
 
-- [Reusable transforms and vector math](../../guides/concepts.md#reuse-a-transform-across-shapes-and-coordinates)
-- [Fluent values and tuple kernels](../../guides/concepts.md#choose-fluent-values-or-standalone-algorithms)
+- [Fluent values and tuple kernels](../../guides/geometry-values.md#fluent-values-plain-data-and-descriptors)
 
-Package: `@metamesh/modeling@0.18.0`.
+## Import
+
+```ts
+import type { AxisAngleRotation3 } from "@metamesh/modeling/geometry/math";
+```
+
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/math/IDENTITY_TRANSFORM3.md

@@ -0,0 +1,20 @@
+# IDENTITY_TRANSFORM3
+
+Identity transform, safe to share because it is frozen.
+
+`const` **IDENTITY\_TRANSFORM3**: [`Transform3Data`](../geometry/Transform3Data.md)
+
+
+
+
+## Guides
+
+- [Fluent values and tuple kernels](../../guides/geometry-values.md#fluent-values-plain-data-and-descriptors)
+
+## Import
+
+```ts
+import { IDENTITY_TRANSFORM3 } from "@metamesh/modeling/geometry/math";
+```
+
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/math/add2.md

@@ -0,0 +1,38 @@
+# add2
+
+Adds two finite XY vectors component-wise.
+
+`const` **add2**: (`a`: [`Vector2Data`](../geometry/Vector2Data.md), `b`: [`Vector2Data`](../geometry/Vector2Data.md)) => [`Vector2Data`](../geometry/Vector2Data.md)
+
+
+
+## Parameters
+
+<a id="a"></a>
+
+**`a`** · [`Vector2Data`](../geometry/Vector2Data.md) · Required
+
+
+
+<a id="b"></a>
+
+**`b`** · [`Vector2Data`](../geometry/Vector2Data.md) · Required
+
+
+
+## Returns
+
+[`Vector2Data`](../geometry/Vector2Data.md)
+
+
+## Guides
+
+- [Fluent values and tuple kernels](../../guides/geometry-values.md#fluent-values-plain-data-and-descriptors)
+
+## Import
+
+```ts
+import { add2 } from "@metamesh/modeling/geometry/math";
+```
+
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/math/add3.md

@@ -0,0 +1,46 @@
+# add3
+
+Adds two finite XYZ vectors component-wise.
+
+`const` **add3**: (`a`: [`Vector3Data`](../geometry/Vector3Data.md), `b`: [`Vector3Data`](../geometry/Vector3Data.md)) => [`Vector3Data`](../geometry/Vector3Data.md)
+
+
+
+## Example
+
+```ts
+import { add3 } from "@metamesh/modeling/geometry/math";
+
+add3([1, 2, 3], [4, 5, 6]); // [5, 7, 9]
+```
+
+## Parameters
+
+<a id="a"></a>
+
+**`a`** · [`Vector3Data`](../geometry/Vector3Data.md) · Required
+
+
+
+<a id="b"></a>
+
+**`b`** · [`Vector3Data`](../geometry/Vector3Data.md) · Required
+
+
+
+## Returns
+
+[`Vector3Data`](../geometry/Vector3Data.md)
+
+
+## Guides
+
+- [Fluent values and tuple kernels](../../guides/geometry-values.md#fluent-values-plain-data-and-descriptors)
+
+## Import
+
+```ts
+import { add3 } from "@metamesh/modeling/geometry/math";
+```
+
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/math/applyTransformDirection3.md

@@ -0,0 +1,46 @@
+# applyTransformDirection3
+
+Applies only the linear component of an affine transform to a direction.
+
+**applyTransformDirection3**(`transform`: [`Transform3Data`](../geometry/Transform3Data.md), `direction`: [`Vector3Data`](../geometry/Vector3Data.md)): [`Vector3Data`](../geometry/Vector3Data.md)
+
+
+
+The result is not normalized, preserving scale information.
+
+## Parameters
+
+<a id="transform"></a>
+
+**`transform`** · [`Transform3Data`](../geometry/Transform3Data.md) · Required
+
+Valid row-major affine transform.
+
+
+
+<a id="direction"></a>
+
+**`direction`** · [`Vector3Data`](../geometry/Vector3Data.md) · Required
+
+Finite XYZ direction.
+
+
+
+## Returns
+
+[`Vector3Data`](../geometry/Vector3Data.md)
+
+A fresh transformed direction.
+
+
+## Guides
+
+- [Fluent values and tuple kernels](../../guides/geometry-values.md#fluent-values-plain-data-and-descriptors)
+
+## Import
+
+```ts
+import { applyTransformDirection3 } from "@metamesh/modeling/geometry/math";
+```
+
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/math/applyTransformPoint3.md

@@ -0,0 +1,44 @@
+# applyTransformPoint3
+
+Applies an affine transform to a point, including translation.
+
+**applyTransformPoint3**(`transform`: [`Transform3Data`](../geometry/Transform3Data.md), `point`: [`Vector3Data`](../geometry/Vector3Data.md)): [`Vector3Data`](../geometry/Vector3Data.md)
+
+
+
+## Parameters
+
+<a id="transform"></a>
+
+**`transform`** · [`Transform3Data`](../geometry/Transform3Data.md) · Required
+
+Valid row-major affine transform.
+
+
+
+<a id="point"></a>
+
+**`point`** · [`Vector3Data`](../geometry/Vector3Data.md) · Required
+
+Finite XYZ point.
+
+
+
+## Returns
+
+[`Vector3Data`](../geometry/Vector3Data.md)
+
+A fresh transformed point.
+
+
+## Guides
+
+- [Fluent values and tuple kernels](../../guides/geometry-values.md#fluent-values-plain-data-and-descriptors)
+
+## Import
+
+```ts
+import { applyTransformPoint3 } from "@metamesh/modeling/geometry/math";
+```
+
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/math/categories/tuple-matrix.md

@@ -0,0 +1,67 @@
+# Tuple and matrix kernels
+
+Compute directly with coordinate tuples and affine matrices.
+
+Use @metamesh/modeling/geometry/math for explicit data processing without fluent wrappers or host state. Basic tuple arithmetic assumes valid finite inputs; overflow follows JavaScript number semantics. Operations with domain constraints, including normalization and matrix inversion, reject invalid geometry as documented.
+
+Use multiplyTransform3(left, right) for conventional left-times-right matrix multiplication: right acts first on column vectors. rotationTransform3 requires an explicit degrees or radians object. Use /geometry values for checked immutable calculations and written-order andThen composition.
+
+## Functions
+
+| API | Summary |
+| --- | --- |
+| [applyTransformDirection3](../applyTransformDirection3.md) | Applies only the linear component of an affine transform to a direction. |
+| [applyTransformPoint3](../applyTransformPoint3.md) | Applies an affine transform to a point, including translation. |
+| [multiplyTransform3](../multiplyTransform3.md) | Composes two affine transforms without mutating either matrix. |
+| [eulerTransform3](../eulerTransform3.md) | Creates an immutable right-handed XYZ Euler rotation transform. |
+| [inverseTransform3](../inverseTransform3.md) | Inverts a finite, non-singular affine transform. |
+| [rotationTransform3](../rotationTransform3.md) | Creates a right-handed axis-angle rotation transform. |
+| [scaleTransform3](../scaleTransform3.md) | Creates an immutable axis-aligned scale transform. |
+| [transformDeterminant3](../transformDeterminant3.md) | Returns the determinant of a transform's linear 3x3 component. |
+| [translationTransform3](../translationTransform3.md) | Creates an immutable translation transform. |
+| [validateTransform3](../validateTransform3.md) | Validates that a transform is finite, affine, and non-singular. |
+| [validateRigidTransform3](../validateRigidTransform3.md) | Validates a proper rigid transform: finite translation and a right-handed orthonormal rotation. Scale, shear, reflection, and perspective are rejected within the default angular tolerance. Returns the original row-major 4x4 matrix without copying or normalizing it. |
+
+## Type aliases
+
+| API | Summary |
+| --- | --- |
+| [AxisAngleRotation3](../AxisAngleRotation3.md) | One explicitly unit-labelled right-handed axis-angle rotation. |
+
+## Values
+
+| API | Summary |
+| --- | --- |
+| [add2](../add2.md) | Adds two finite XY vectors component-wise. |
+| [subtract2](../subtract2.md) | Subtracts `b` from `a` component-wise. |
+| [scale2](../scale2.md) | Multiplies a vector by a dimensionless scalar. |
+| [dot2](../dot2.md) | Returns the scalar dot product. |
+| [cross2](../cross2.md) | Returns the signed scalar cross product; positive means `b` is counterclockwise from `a`. |
+| [length2](../length2.md) | Returns Euclidean vector length in the vector's coordinate units. |
+| [distance2](../distance2.md) | Returns Euclidean point distance without allocating an intermediate difference vector. |
+| [normalize2](../normalize2.md) | Returns a unit vector; `epsilon` is a finite, nonnegative length threshold (default `1e-12`). |
+| [lerp2](../lerp2.md) | Linearly interpolates two vectors; `t` is dimensionless and may extrapolate. |
+| [rotate2](../rotate2.md) | Rotates a finite vector counterclockwise in XY by `degrees` about the origin. Throws `NON_FINITE_VALUE` for nonfinite coordinates, angles, or derived coordinates. |
+| [add3](../add3.md) | Adds two finite XYZ vectors component-wise. |
+| [cross3](../cross3.md) | Returns the right-handed cross product. |
+| [dot3](../dot3.md) | Returns the scalar dot product. |
+| [length3](../length3.md) | Returns Euclidean vector length in the vector's coordinate units. |
+| [distance3](../distance3.md) | Returns Euclidean point distance without allocating an intermediate difference vector. |
+| [lerp3](../lerp3.md) | Linearly interpolates two vectors; `t` is dimensionless and may extrapolate. |
+| [normalize3](../normalize3.md) | Returns a unit vector; `epsilon` is a finite, nonnegative length threshold (default `1e-12`). |
+| [projectOntoPlane3](../projectOntoPlane3.md) | Removes the component parallel to a normalized plane normal. |
+| [scale3](../scale3.md) | Multiplies a vector by a dimensionless scalar. |
+| [subtract3](../subtract3.md) | Subtracts `b` from `a`. |
+| [IDENTITY_TRANSFORM3](../IDENTITY_TRANSFORM3.md) | Identity transform, safe to share because it is frozen. |
+
+## Guides
+
+- [Fluent values and tuple kernels](../../../guides/geometry-values.md#fluent-values-plain-data-and-descriptors)
+
+## Import
+
+```ts
+import * as math from "@metamesh/modeling/geometry/math";
+```
+
+Package: `@metamesh/modeling@0.20.0`.

package/dist/docs/reference/math/cross2.md

@@ -0,0 +1,38 @@
+# cross2
+
+Returns the signed scalar cross product; positive means `b` is counterclockwise from `a`.
+
+`const` **cross2**: (`a`: [`Vector2Data`](../geometry/Vector2Data.md), `b`: [`Vector2Data`](../geometry/Vector2Data.md)) => `number`
+
+
+
+## Parameters
+
+<a id="a"></a>
+
+**`a`** · [`Vector2Data`](../geometry/Vector2Data.md) · Required
+
+
+
+<a id="b"></a>
+
+**`b`** · [`Vector2Data`](../geometry/Vector2Data.md) · Required
+
+
+
+## Returns
+
+`number`
+
+
+## Guides
+
+- [Fluent values and tuple kernels](../../guides/geometry-values.md#fluent-values-plain-data-and-descriptors)
+
+## Import
+
+```ts
+import { cross2 } from "@metamesh/modeling/geometry/math";
+```
+
+Package: `@metamesh/modeling@0.20.0`.