@metamesh/modeling 0.13.0 → 0.15.0

package/dist/api/index.d.ts

@@ -1,4 +1,4 @@
-/** Imported modeling operations and opaque host-owned contracts. @packageDocumentation */
+/** Immutable modeling recipes and math values; the host owns geometry evaluation. @packageDocumentation */
 
 /** ACME 29-degree included-angle profile. */
 declare interface AcmeThreadProfileSpec extends ThreadProfileBaseSpec {
@@ -30,23 +30,21 @@ export declare function anchor(shape: Solid | Section, name: string): Anchor3;
  */
 export declare interface Anchor3 {
   /** Unit outward normal used as the anchor's local +Z direction. */
-  readonly direction: Vector3;
+  readonly direction: Vector3Tuple;
   /** World-space attachment position. */
-  readonly position: Vector3;
+  readonly position: Vector3Tuple;
   /** Roll guide projected into the plane perpendicular to `direction`. */
-  readonly up: Vector3;
+  readonly up: Vector3Tuple;
 }
 
-/**
- * Degree-based anchor attachment controls for a scoped solid.
- */
+/** Options controlling how one anchor is attached to another. */
 export declare interface AttachOptions {
   /** Align outward directions face-to-face (`opposed`) or in parallel (`same`). */
   readonly alignment?: "opposed" | "same";
-  /** Separation along the target anchor's outward direction in millimetres. */
+  /** Separation along the target anchor's outward direction in model units. */
   readonly gap?: number;
   /** Additional right-handed roll about the attached direction, in degrees. */
-  readonly spinDegrees?: number;
+  readonly spin?: number;
   /** Optional numeric comparison overrides. */
   readonly tolerance?: GeometryToleranceOptions;
 }
@@ -54,17 +52,17 @@ export declare interface AttachOptions {
 /** Axis-aligned bounds in two-dimensional model space. */
 export declare interface Bounds2 {
   /** Inclusive maximum X/Y coordinates. */
-  readonly max: Vector2;
+  readonly max: Vector2Tuple;
   /** Inclusive minimum X/Y coordinates. */
-  readonly min: Vector2;
+  readonly min: Vector2Tuple;
 }
 
 /** Axis-aligned bounds in three-dimensional model space. */
 export declare interface Bounds3 {
   /** Inclusive maximum X/Y/Z coordinates. */
-  readonly max: Vector3;
+  readonly max: Vector3Tuple;
   /** Inclusive minimum X/Y/Z coordinates. */
-  readonly min: Vector3;
+  readonly min: Vector3Tuple;
 }
 
 /**
@@ -103,7 +101,7 @@ export declare type BoxEdgeTreatments = Readonly<
 /**
  * Dimensions, placement, and uniform or independently selected finishing for an axis-aligned box.
  */
-export declare interface BoxOptions extends PrimitivePlacement {
+export declare interface BoxOptions extends PrimitiveAttachment {
   /** Explicit sampling ceilings for edge treatments, bounded by the host policy. */
   readonly limits?: Partial<GeometrySamplingLimits>;
   /**
@@ -112,7 +110,7 @@ export declare interface BoxOptions extends PrimitivePlacement {
    */
   readonly center?: boolean;
   /** Positive uniform size or explicit `[X, Y, Z]` extents in millimetres. */
-  readonly size: number | Vector3;
+  readonly size: number | Vector3Tuple;
   /** Uniform treatment or independent disjoint nominal edge/group treatments. */
   readonly treatment?: EdgeTreatment | BoxEdgeTreatments;
 }
@@ -137,6 +135,13 @@ declare interface ButtressThreadProfileSpec extends ThreadProfileBaseSpec {
   readonly pressureFlankSide?: ButtressPressureFlankSide;
 }
 
+/** Copies intersections along the finite directed origin-to-endpoint segment. */
+export declare function castSegment(
+  solid: Solid,
+  origin: Vector3Input,
+  endpoint: Vector3Input,
+): readonly SolidSegmentHit[];
+
 /**
  * A planar edge or corner chamfer with equal or independent surface setbacks.
  */
@@ -180,7 +185,7 @@ export declare type CircleContourOptions = CircularPrimitiveOptions &
 /**
  * Circular dimensions with exactly one nominal radius or diameter.
  */
-export declare type CircleOptions = CircleContourOptions & PrimitivePlacement;
+export declare type CircleOptions = CircleContourOptions & PrimitiveAttachment;
 
 /**
  * Tessellation controls shared by circular primitives across Geometry entry points.
@@ -200,11 +205,13 @@ export declare interface CircularPrimitiveOptions {
 }
 
 /**
- * Separates a solid's disconnected surface shells into same-session solid handles.
+ * Observes disconnected material pieces as session-restricted solid selections.
  *
- * For solids without enclosed cavities, these shells are the disconnected material islands.
- * Enclosed cavities produce separate inward shells with negative signed volume; these cannot
- * be finalized alone as manufacturing parts. This does not cut connected geometry.
+ * Each piece retains its enclosed cavities. A sealed hollow box is one component; adding a loose
+ * ball inside its cavity produces two. Recombining the pieces preserves the original material.
+ * This does not cut connected geometry. Containment is bounded to 2,000,000 comparisons.
+ * Selection order and cardinality depend on evaluated topology. Results and recipes using them
+ * can only be evaluated in this session; composition itself requires no engine.
  *
  * @example Move disconnected pieces independently
  * ```ts
@@ -216,7 +223,10 @@ export declare interface CircularPrimitiveOptions {
  */
 export declare function components(solid: Solid): readonly Solid[];
 
-/** Separates filled 2D islands into sections, retaining each island's holes; empty gives []. */
+/**
+ * Observes filled 2D islands, retaining each island's holes; empty gives [].
+ * Selections and recipes using them can only be evaluated in this session.
+ */
 export declare function components(section: Section): readonly Section[];
 
 /** Combines disjoint components without resolving overlap. */
@@ -241,7 +251,7 @@ export declare type ComputedValue<T> = T | Computed<T>;
  * Polygon exteriors are counter-clockwise and holes are clockwise. Algorithms
  * may reject duplicate adjacent points or fewer than three effective vertices.
  */
-export declare type Contour = readonly Vector2[];
+export declare type Contour = readonly Vector2Tuple[];
 
 /** One sampled component retaining contour identities and logical point correspondence. */
 export declare interface CorrespondingComponent {
@@ -275,6 +285,20 @@ export declare type CorrespondingProfileStation = LoftPlacement & {
   readonly profile: CorrespondingProfile;
 };
 
+/**
+ * Explicit physical sampling and allocation policy for reusable curves.
+ */
+declare interface CurveSamplingOptions {
+  /** Exact segment count overrides physical criteria; curve parameters are spaced uniformly. */
+  readonly segments?: number;
+  /** Millimetre sampling policy; circularSegments applies only to arcs. */
+  readonly resolution?: GeometryResolution;
+  /** Output vertex ceiling of at least two; may only lower limits.maxPathPoints. */
+  readonly maxVertices?: number;
+  /** Explicit sampling ceilings; omitted values use package defaults without ambient state. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
+}
+
 /** Caller-defined periodic axial/radial profile in millimetres. */
 declare interface CustomThreadProfileSpec extends ThreadProfileBaseSpec {
   /** Selects a caller-defined periodic profile. */
@@ -283,7 +307,7 @@ declare interface CustomThreadProfileSpec extends ThreadProfileBaseSpec {
    * Open path spanning exactly `[-pitch/2, pitch/2]`, with both endpoints on the minor envelope,
    * one connected ridge, one contiguous crest, and radial zero at the major envelope.
    */
-  readonly points: readonly Vector2[];
+  readonly points: readonly Vector2Tuple[];
 }
 
 /**
@@ -306,7 +330,7 @@ export declare function cylinder(options: CylinderOptions): Solid;
  */
 export declare type CylinderOptions = CircularPrimitiveOptions &
   RadialSizingOptions &
-  PrimitivePlacement & {
+  PrimitiveAttachment & {
     /**
      * Centers the solid on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
      * @defaultValue `true`
@@ -343,7 +367,7 @@ export declare interface DiagnosticOptions<P> {
  * Uses actual geometry, not bounding-box separation or distance between object origins.
  * Contact or overlapping material returns zero, including one solid inside another.
  * The kernel's search range is managed internally; the result is not capped at a caller limit.
- * Empty, expired or foreign-build handles reject. Results follow native numeric precision.
+ * Empty geometry and component selections from another session reject. Results follow native numeric precision.
  *
  * @example Measure the gap between two blocks
  * ```ts
@@ -380,13 +404,13 @@ export declare type EllipseContourOptions = CircularPrimitiveOptions &
   (
     | {
         /** Positive XY radii in millimetres; mutually exclusive with size. */
-        readonly radius: Vector2;
+        readonly radius: Vector2Tuple;
         /** Full XY extents are unavailable when radius is supplied. */
         readonly size?: never;
       }
     | {
         /** Positive full XY extents in millimetres; mutually exclusive with radius. */
-        readonly size: Vector2;
+        readonly size: Vector2Tuple;
         /** XY radii are unavailable when size is supplied. */
         readonly radius?: never;
       }
@@ -395,7 +419,8 @@ export declare type EllipseContourOptions = CircularPrimitiveOptions &
 /**
  * Ellipse dimensions in local XY, with exactly one radii or full-size tuple.
  */
-export declare type EllipseOptions = EllipseContourOptions & PrimitivePlacement;
+export declare type EllipseOptions = EllipseContourOptions &
+  PrimitiveAttachment;
 
 /**
  * Independent inward finishing on primitive or straight convex extrusion ends.
@@ -447,9 +472,9 @@ declare interface ExtrusionSamplingOptions {
   /** Operation-level physical policy over the nearest model scope. */
   readonly resolution?: GeometryResolution;
   /** Finite uniform or XY scale of the top profile; defaults to one. */
-  readonly scaleTop?: number | Vector2;
+  readonly scaleTop?: number | Vector2Input;
   /** Finite rotation of the top profile about +Z, in degrees; defaults to zero. */
-  readonly twistDegrees?: number;
+  readonly twist?: number;
 }
 
 /** Finalized manufacturing snapshot. Its arrays are independent of all native values. */
@@ -460,19 +485,21 @@ export declare interface FinalizedModel {
   readonly bounds: Bounds3;
   /** Aggregate counts, unique backing storage, volume, and execution timings. */
   readonly stats: {
+    /** Number of declared output parts, including repeated geometry instances. */
+    readonly partCount: number;
     /** Aggregate position-buffer vertex count. */
-    readonly vertices: number;
+    readonly vertexCount: number;
     /** Aggregate indexed triangle count. */
-    readonly triangles: number;
+    readonly triangleCount: number;
     /** Signed enclosed volume of all selected parts in cubic millimetres. */
     readonly volumeMm3: number;
     /** Unique transferable backing-buffer bytes, counted once across all parts. */
-    readonly bytes: number;
+    readonly byteCount: number;
     /** Synchronous callback duration in milliseconds. */
     readonly buildMs: number;
     /** Manufacturing validation and buffer finalization duration in milliseconds. */
     readonly finalizationMs: number;
-    /** Total callback and finalization duration in milliseconds. */
+    /** Total generation duration, including cache retention and native cleanup, in milliseconds. */
     readonly generationMs: number;
   };
 }
@@ -490,18 +517,15 @@ export declare interface FinalizedPart extends TriangleMesh {
 /** A right-handed orthonormal coordinate frame expressed in world coordinates. */
 export declare interface Frame3 {
   /** World-space origin of the local frame. */
-  readonly origin: Vector3;
+  readonly origin: Vector3Tuple;
   /** Unit vector defining the local +X axis. */
-  readonly xAxis: Vector3;
+  readonly xAxis: Vector3Tuple;
   /** Unit vector defining the local +Y axis. */
-  readonly yAxis: Vector3;
+  readonly yAxis: Vector3Tuple;
   /** Unit vector defining the local +Z axis. */
-  readonly zAxis: Vector3;
+  readonly zAxis: Vector3Tuple;
 }
 
-/** Imports explicit region topology once. */
-export declare function fromRegion(region: Region): Section;
-
 /**
  * Defines a typed model without executing it. Use `computed` only for work worth reusing.
  *
@@ -587,9 +611,9 @@ export declare interface GeometryResolution {
   /** Optional maximum sampled edge length in millimetres. */
   readonly maxSegmentLength?: number;
   /** Upper safety bound for a full circle; defaults to the selected maxCircularSegments (512 by default). */
-  readonly maximumSegments?: number;
+  readonly maxSegments?: number;
   /** Lower full-circle segment count; defaults to 16 or a lower selected circular ceiling. */
-  readonly minimumSegments?: number;
+  readonly minSegments?: number;
 }
 
 /** Explicit allocation ceilings for pure sampling and host-owned modeling operations. */
@@ -627,16 +651,17 @@ export declare function gridPattern(
   options: GridPatternOptions,
 ): readonly Solid[];
 
-/** Repeats a filled Section on a grid; placements must preserve its XY plane. */
+/** Repeats a filled Section on an XY grid; any explicit frame must preserve the XY plane. */
 export declare function gridPattern(
   source: PatternSource<Section>,
-  options: GridPatternOptions,
+  options: GridPatternOptions<2>,
 ): readonly Section[];
 
 /**
  * XY or XYZ grid with X varying fastest. The first item starts at the local origin.
+ * Dimension 2 restricts counts and spacing to XY; any frame must preserve the XY plane.
  */
-export declare type GridPatternOptions = {
+export declare type GridPatternOptions<Dimension extends 2 | 3 = 3> = {
   /** Center the complete distribution around its local origin; defaults to false. */
   readonly center?: boolean;
   /** Optional right-handed local axes and origin for the grid. */
@@ -644,21 +669,24 @@ export declare type GridPatternOptions = {
 } & (
   | {
       /** Positive integer counts on X and Y. */
-      readonly count: Vector2;
+      readonly count: Vector2Tuple;
       /** Signed millimetres between adjacent copies on X and Y. */
-      readonly spacing: Vector2;
-    }
-  | {
-      /** Positive integer counts on X, Y and Z. */
-      readonly count: Vector3;
-      /** Signed millimetres between adjacent copies on X, Y and Z. */
-      readonly spacing: Vector3;
+      readonly spacing: Vector2Tuple;
     }
+  | (Dimension extends 3
+      ? {
+          /** Positive integer counts on X, Y and Z. */
+          readonly count: Vector3Tuple;
+          /** Signed millimetres between adjacent copies on X, Y and Z. */
+          readonly spacing: Vector3Tuple;
+        }
+      : never)
 );
 
 /**
  * Closed rectilinear top above a flat base, with uniform or explicit XY coordinates.
  * Samples each grid height once; center-error triangulation also samples each cell centre.
+ * The retained callback must capture independent immutable inputs, not live session readers or parameters.
  *
  * @example Heightfield
  * ```ts
@@ -681,7 +709,7 @@ export declare function heightfield(options: HeightfieldOptions): Solid;
  */
 export declare type HeightfieldOptions = {
   /** Absolute top Z at the supplied XY point. Every sample must be above baseZ. */
-  readonly height: (point: Vector2) => number;
+  readonly height: (point: Vector2Tuple) => number;
   /** Flat bottom Z. Defaults to zero. */
   readonly baseZ?: number;
   /**
@@ -694,11 +722,11 @@ export declare type HeightfieldOptions = {
 } & (
   | {
       /** Positive XY footprint for uniform sampling. */
-      readonly size: Vector2;
+      readonly size: Vector2Tuple;
       /** Exact positive integer X/Y interval counts. */
       readonly segments: readonly [x: number, y: number];
       /** Lower-left footprint XY. Omitted centers the footprint on XY. */
-      readonly origin?: Vector2;
+      readonly origin?: Vector2Tuple;
       /** Explicit coordinates cannot be combined with uniform sampling. */
       readonly coordinates?: never;
     }
@@ -738,7 +766,7 @@ export declare interface HelicalThreadRidgeMeshOptions {
   /** Nominal major diameter before any caller-owned fit compensation. */
   readonly majorDiameter: number;
   /** Angular offset of the first start in degrees. Default: `0`. */
-  readonly phaseDegrees?: number;
+  readonly phase?: number;
   /** Validated periodic profile repeated around the shaft. */
   readonly profile: ThreadProfile;
   /** Optional circular-resolution policy. */
@@ -773,19 +801,19 @@ export declare interface HelicalThreadSolidMeshPreflight {
  */
 export declare function hull(options: HullOptions): Solid;
 
-/** Convex filled XY hull of finite points or same-session sections. */
+/** Convex filled XY hull of finite points or filled section recipes. */
 export declare function hull(options: SectionHullOptions): Section;
 
-/** Hull inputs are either finite points or same-session solids. */
+/** Hull inputs are either finite points or solid recipes. */
 export declare type HullOptions =
   | {
       /** Finite millimetre XYZ points to include in the convex hull. */
-      readonly points: readonly Vector3[];
+      readonly points: readonly Vector3Input[];
       /** Point input excludes solid input. */
       readonly solids?: never;
     }
   | {
-      /** Same-build solids to include in the convex hull. */
+      /** Solid recipes to include in the convex hull. */
       readonly solids: readonly Solid[];
       /** Solid input excludes point input. */
       readonly points?: never;
@@ -847,13 +875,16 @@ export declare interface ImmutableTriangleMesh {
   readonly indices: ImmutableBuffer<Uint32Array>;
 }
 
-/** Bounded positive-inside implicit field constructor. */
+/**
+ * Bounded positive-inside implicit field constructor.
+ * The retained callback must capture independent immutable inputs, not live session readers or parameters.
+ */
 export declare function implicit(options: ImplicitOptions): Solid;
 
 /** Positive-inside sampling, bounded to 4M native BCC grid slots and 8M field calls. */
 export declare interface ImplicitOptions {
   /** Positive-inside scalar field evaluated at finite XYZ points. */
-  readonly field: (point: Vector3) => number;
+  readonly field: (point: Vector3Tuple) => number;
   /** Axis-aligned XYZ bounds in millimetres. */
   readonly bounds: Bounds3;
   /** Positive sampling edge length in millimetres. */
@@ -892,8 +923,8 @@ export declare function inspectSolid(solid: Solid): SolidInspection;
  * @example Internal thread
  * ```ts
  * import { cylinder, internalThreadCutter } from "@metamesh/modeling";
- * import { createThreadProfile } from "@metamesh/modeling/geometry";
- * const profile = createThreadProfile({ kind: "triangular", pitch: 1.75 });
+ * import { threadProfile } from "@metamesh/modeling/geometry";
+ * const profile = threadProfile({ kind: "triangular", pitch: 1.75 });
  * const body = cylinder({ diameter: 20, height: 12, center: false });
  * const cutter = internalThreadCutter({ nominalMajorDiameter: 12, length: 12, profile });
  * body.subtract([cutter]);
@@ -928,7 +959,7 @@ export declare function intersect(solids: readonly Solid[]): Solid;
 export declare function intersect(sections: readonly Section[]): Section;
 
 /**
- * Checks whether a same-session solid or filled section contains no geometry.
+ * Checks whether a solid or filled section contains no geometry during host execution.
  *
  * Accepts a 3D Solid or 2D Section handle, not a finalized model or raw triangle mesh.
  * Useful after a Boolean operation whose inputs may not overlap; no mesh is extracted.
@@ -956,18 +987,19 @@ export declare function linearPattern(
   options: LinearPatternOptions,
 ): readonly Solid[];
 
-/** Repeats a filled Section; every placement must preserve its XY plane. */
+/** Repeats a filled Section along an XY direction, defaulting to +X. */
 export declare function linearPattern(
   source: PatternSource<Section>,
-  options: LinearPatternOptions,
+  options: LinearPatternOptions<2>,
 ): readonly Section[];
 
 /**
  * Equal linear intervals determined by exactly two of count, spacing and total length.
+ * Dimension defaults to 3; Section patterns use 2 and accept XY vector directions.
  */
-export declare type LinearPatternOptions = {
+export declare type LinearPatternOptions<Dimension extends 2 | 3 = 3> = {
   /** Direction of repetition; magnitude is ignored. Defaults to +X. */
-  readonly direction?: Vector3;
+  readonly direction?: Dimension extends 2 ? Vector2Input : Vector3Input;
 } & (
   | {
       /** Positive copy count, including the original. */
@@ -1072,11 +1104,14 @@ export declare type LoftPlacement =
  * A Section or point loop at an explicit height or frame.
  */
 export declare type LoftStation = LoftPlacement & {
-  /** Same-build filled Section or ordered XY boundary point data. */
-  readonly profile: Section | Contour;
+  /** Filled Section recipe or ordered XY boundary point data. */
+  readonly profile: Section | Path2Input;
 };
 
-/** Explicit family matching on a shared physical span grid using session or operation resolution. */
+/**
+ * Matches a profile family using operation settings over host resolution and limits.
+ * Requires active synchronous model execution. Use Geometry's matchProfiles for standalone preparation.
+ */
 export declare function matchProfiles(
   profiles: readonly Profile[],
   options?: MatchProfilesOptions,
@@ -1124,14 +1159,100 @@ export declare type PartGeometry = Solid | TriangleMesh | ImmutableTriangleMesh;
 export declare interface PartOptions {
   /** Local geometry or a lazy reader; native objects never cross a revision. */
   readonly geometry: ComputedValue<PartGeometry>;
-  /** XYZ translation in millimetres, applied after rotation; defaults to zero. */
-  readonly position?: ComputedValue<Vector3>;
-  /** Fixed global X, Y, Z rotations in degrees; defaults to zero. */
-  readonly rotation?: ComputedValue<Vector3>;
+  /** XYZ vector or tuple translation in millimetres, applied after rotation; defaults to zero. */
+  readonly position?: ComputedValue<Vector3Input>;
+  /** XYZ vector or tuple of fixed global X, Y, Z rotations in degrees; defaults to zero. */
+  readonly rotation?: ComputedValue<Vector3Input>;
   /** Optional six-digit hexadecimal semantic part color. */
   readonly color?: string;
 }
 
+/** Immutable directed XY polyline. Closure is explicit and does not imply a filled Section. */
+export declare interface Path2 {
+  /** Coordinate dimension; identifies planar paths even when empty. */
+  readonly dimension: 2;
+  /** Whether traversal includes the last-to-first edge. */
+  readonly closed: boolean;
+  /** Returns frozen tuple coordinates; closure remains separate metadata. Repeated calls do not allocate. */
+  toArray(): Path2Data;
+  /** Total sampled edge length in model units, including the closing edge when closed. */
+  length(): number;
+  /** Axis-aligned bounds, or undefined for an empty path. */
+  bounds(): Bounds2 | undefined;
+  /** Finds the nearest edge location; requires at least two vertices. */
+  closestPoint(point: Vector2Input): PathLocation<Vector2>;
+  /** Applies an XY placement without reordering traversal, including after reflection. */
+  transform(placement: Transform2Input): Path2;
+  /** Reverses vertex order and traversal; neither the source nor its coordinates are mutated. */
+  reverse(): Path2;
+  /** Returns a path sampled at equal arc lengths. Corners may be bridged; closure is preserved. */
+  resample(options?: PathResamplingOptions): Path2;
+}
+
+/**
+ * Snapshots finite XY coordinates as an immutable sampled path, independent of engine initialization.
+ * Open paths may be empty or have one point; closed paths need three vertices and omit a duplicated
+ * seam. Repeated adjacent vertices are retained. No winding normalization or filling is performed.
+ * Malformed dimensions or topology throw INVALID_ARGUMENT; nonfinite coordinates or measurement
+ * overflow throw NON_FINITE_VALUE; exhausted allocation ceilings throw COMPLEXITY_LIMIT GeometryError.
+ * A path input retains its closure. Limits bound construction only; resampling takes its own limits.
+ */
+export declare function path2(input: Path2Input, options?: PathOptions): Path2;
+
+/** XY point tuples for interchange; closure is supplied by the consuming operation or Path2 value. */
+export declare type Path2Data = readonly Vector2Tuple[];
+
+/** An immutable XY sampled path or a collection of XY tuples and fluent vectors. */
+export declare type Path2Input = Path2 | readonly Vector2Input[];
+
+/** Immutable directed XYZ polyline; it represents sampled edges, not an analytic curve. */
+export declare interface Path3 {
+  /** Coordinate dimension; identifies spatial paths even when empty. */
+  readonly dimension: 3;
+  /** Whether traversal includes the last-to-first edge. */
+  readonly closed: boolean;
+  /** Returns frozen tuple coordinates; closure remains separate metadata. Repeated calls do not allocate. */
+  toArray(): Path3Data;
+  /** Total sampled edge length in model units, including the closing edge when closed. */
+  length(): number;
+  /** Axis-aligned bounds, or undefined for an empty path. */
+  bounds(): Bounds3 | undefined;
+  /** Finds the nearest edge location; requires at least two vertices. */
+  closestPoint(point: Vector3Input): PathLocation<Vector3>;
+  /** Applies an XYZ placement without changing traversal order or closure. */
+  transform(placement: Transform3Input): Path3;
+  /** Reverses vertex order and traversal without mutating the source. */
+  reverse(): Path3;
+  /** Returns a path sampled at equal arc lengths. Corners may be bridged; closure is preserved. */
+  resample(options?: PathResamplingOptions): Path3;
+}
+
+/**
+ * Snapshots finite XYZ coordinates as an immutable sampled path with the same closure, seam,
+ * allocation and error rules as path2. Analytic curves must be sampled explicitly first.
+ */
+export declare function path3(input: Path3Input, options?: PathOptions): Path3;
+
+/**
+ * XYZ point tuples for interchange; closure is supplied by the consuming operation or Path3 value.
+ */
+export declare type Path3Data = readonly Vector3Tuple[];
+
+/** An immutable XYZ sampled path or a collection of XYZ tuples and fluent vectors. */
+export declare type Path3Input = Path3 | readonly Vector3Input[];
+
+/** Nearest location on a sampled boundary, rather than inside a filled shape or on an analytic curve. */
+export declare interface PathLocation<Point extends Vector2 | Vector3> {
+  /** Immutable position on the selected edge. */
+  readonly point: Point;
+  /** Euclidean distance from the query in model units. */
+  readonly distance: number;
+  /** Starting vertex of the selected edge; ties keep the first edge in traversal order. */
+  readonly edgeIndex: number;
+  /** Clamped fraction along that edge, not the whole path's normalized arc length. */
+  readonly fraction: number;
+}
+
 /**
  * Supplies a profile-X orientation guide for each original normalized sweep station.
  *
@@ -1140,9 +1261,17 @@ export declare interface PartOptions {
  * @returns A finite guide vector that is not parallel to the local path tangent.
  */
 export declare type PathNormalGuide = (
-  point: Vector3,
+  point: Vector3Tuple,
   index: number,
-) => Vector3;
+) => Vector3Input;
+
+/** Topology and allocation ceiling for an immutable sampled path. */
+export declare interface PathOptions {
+  /** Connects the last vertex to the first; closed paths omit the repeated seam. Defaults to false. */
+  readonly closed?: boolean;
+  /** Construction point ceiling; defaults to package sampling limits. Later sampling has its own options. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
+}
 
 /**
  * Physical arc-length copies along a sampled path, with optional tangent orientation.
@@ -1154,17 +1283,17 @@ export declare type PathNormalGuide = (
  */
 export declare function pathPattern(
   source: PatternSource,
-  path: readonly Vector3[],
+  path: Path3Input,
   options: PathPatternOptions,
 ): readonly Solid[];
 
 /**
- * Repeats a filled Section along a sampled XY path at Z=0. Fixed orientation preserves XY;
- * tangent orientation maps +Z to the tangent and rejects when that leaves the plane.
+ * Repeats a filled Section along a sampled XY path. Tangent orientation maps local +X
+ * to the path tangent counterclockwise, preserving the XY plane.
  */
 export declare function pathPattern(
   source: PatternSource<Section>,
-  path: readonly Vector3[],
+  path: Path2Input,
   options: PathPatternOptions,
 ): readonly Section[];
 
@@ -1172,26 +1301,56 @@ export declare function pathPattern(
 export declare interface PathPatternOptions {
   /** Positive number of copies; open paths include both endpoints when greater than one. */
   readonly count: number;
-  /** Include the closing edge without duplicating the seam; defaults to false. */
+  /** Raw point closure defaults to false; a path value supplies closure and rejects conflicts. */
   readonly closed?: boolean;
-  /** Preserve the source orientation, or align its +Z to the path tangent; defaults to fixed. */
+  /** Preserve orientation, or align local +X for Sections / +Z for Solids to the tangent. Defaults to fixed. */
   readonly orientation?: "fixed" | "tangent";
 }
 
+/** Equal arc-length sampling; the path itself owns whether its closing edge is included. */
+export declare interface PathResamplingOptions extends CurveSamplingOptions {
+  /** Exact arc-length intervals; closed paths need at least three. Otherwise physical resolution or the effective source edge count controls sampling. */
+  readonly segments?: number;
+}
+
 /**
- * One same-session shape, or a synchronous factory called once per copy in index order.
+ * One immutable shape, or a synchronous factory called once per copy in index order.
  */
 export declare type PatternSource<T extends Solid | Section = Solid> =
   T | ((index: number) => T);
 
+/** A fixed XY point in world coordinates; omitted pivots use the coordinate origin. */
+export declare interface Pivot2Options {
+  /** World-space point left fixed by rotation or scaling. */
+  readonly pivot?: Vector2Input;
+}
+
+/** A fixed XYZ point in world coordinates; omitted pivots use the coordinate origin. */
+export declare interface Pivot3Options {
+  /** World-space point left fixed by rotation or scaling. */
+  readonly pivot?: Vector3Input;
+}
+
 /** A world-space cutting plane, retaining the half-space in the normal's direction. */
 export declare interface PlaneOptions {
   /** Finite nonzero plane normal; magnitude does not affect the plane. */
-  readonly normal: Vector3;
+  readonly normal: Vector3Input;
   /** Signed millimetre distance from the origin along the unit normal. Defaults to zero. */
   readonly offset?: number;
 }
 
+/**
+ * Fills one closed millimetre XY outline, explicit outer/hole topology, or compound contours.
+ * Closing edges are implicit. Compound contours use nonzero fill unless selected otherwise.
+ * Explicit topology must be simple and disjoint; compound winding may resolve overlaps.
+ *
+ * @example Extrude a triangular plate
+ * ```ts
+ * polygon([[0, 0], [20, 0], [10, 12]]).extrude({ height: 3 });
+ * ```
+ */
+export declare function polygon(input: Path2Input | PolygonOptions): Section;
+
 /**
  * One bounded two-dimensional polygon.
  *
@@ -1199,83 +1358,79 @@ export declare interface PlaneOptions {
  * their duplicated closing point. Holes must lie inside `outer` and must not
  * intersect each other or the exterior.
  */
-export declare interface Polygon {
+export declare interface PolygonData {
   /** Clockwise interior boundaries, each omitting its duplicated closing point. */
   readonly holes: readonly Contour[];
   /** Counter-clockwise exterior boundary, omitting its duplicated closing point. */
   readonly outer: Contour;
 }
 
-/**
- * Fills one closed millimetre XY outline, explicit outer/hole topology, or compound contours.
- * Closing edges are implicit. Compound contours use nonzero fill unless selected otherwise.
- * Explicit topology must be simple and disjoint; compound winding may resolve overlaps.
- *
- * @example Extrude a triangular plate
- * ```ts
- * polygon([[0, 0], [20, 0], [10, 12]]).extrude({ height: 3 });
- * ```
- */
-export declare function polygon(input: Contour | PolygonOptions): Section;
-
 /** Explicit polygon topology or compound contours; all closing edges are implicit. */
 export declare type PolygonOptions =
   | {
       /** One simple exterior boundary, normalized to counterclockwise winding. */
-      readonly outer: Contour;
+      readonly outer: Path2Input;
       /** Disjoint simple holes inside the exterior; normalized to clockwise winding. */
-      readonly holes?: readonly Contour[];
+      readonly holes?: readonly Path2Input[];
       /** Explicit topology excludes compound contours. */
       readonly contours?: never;
       /** Explicit topology determines fill without a winding rule. */
       readonly fillRule?: never;
+      /** Explicit topology excludes serialized multi-polygon data. */
+      readonly polygons?: never;
     }
   | {
       /** Compound boundaries; may overlap or contain holes according to the fill rule. */
-      readonly contours: readonly Contour[];
+      readonly contours: readonly Path2Input[];
       /** Winding interpretation; defaults to nonzero. An empty list creates an empty Section. */
       readonly fillRule?: "nonzero" | "evenodd";
       /** Compound contours exclude explicit topology. */
       readonly outer?: never;
       /** Compound contours determine their own holes. */
       readonly holes?: never;
+      /** Compound fill excludes serialized multi-polygon data. */
+      readonly polygons?: never;
+    }
+  | {
+      /** Explicit filled polygons for serialization and interchange; an empty array is empty. */
+      readonly polygons: RegionData;
+      /** Serialized topology excludes a standalone outer contour. */
+      readonly outer?: never;
+      /** Each serialized polygon owns its own holes. */
+      readonly holes?: never;
+      /** Serialized topology excludes compound contours. */
+      readonly contours?: never;
+      /** Serialized polygons define fill explicitly. */
+      readonly fillRule?: never;
     };
 
-/** Allocation-free internal-thread facts. */
+/** Internal-thread facts using host resolution and limits; requires active synchronous model execution. */
 export declare function preflightInternalThreadCutter(
   options: InternalThreadCutterOptions,
 ): HelicalThreadSolidMeshPreflight;
 
-/** Allocation-free nut/cutter facts. */
+/** Nut/cutter facts using host resolution and limits; requires active synchronous model execution. */
 export declare function preflightThreadedNut(
   options: ThreadedNutOptions,
 ): ThreadedNutPreflight;
 
-/** Allocation-free external-thread facts. */
+/** External-thread facts using host resolution and limits; requires active synchronous model execution. */
 export declare function preflightThreadedRod(
   options: ThreadedRodOptions,
 ): HelicalThreadSolidMeshPreflight;
 
-/** Placement shared by solid and filled-section factories. */
-export declare interface PrimitivePlacement {
-  /** Applied after local construction; Section placement must preserve the XY plane. */
-  readonly placement?: PrimitivePlacementOptions;
+/** Anchor attachment shared by solid and filled-section factories. */
+export declare interface PrimitiveAttachment {
+  /** Applied after local construction; Section attachment must preserve the XY plane. */
+  readonly attachment?: PrimitiveAttachmentOptions;
 }
 
 /** Maps an explicit or named shape-local attachment anchor onto a world-space anchor. */
-export declare interface PrimitivePlacementOptions {
+export declare interface PrimitiveAttachmentOptions extends AttachOptions {
   /** Shape-local source frame or a named primitive anchor such as bottom. */
   readonly source: Anchor3 | string;
   /** World-space target frame in millimetres. */
   readonly target: Anchor3;
-  /** Align outward directions face-to-face or in parallel. Defaults to opposed. */
-  readonly alignment?: "opposed" | "same";
-  /** Finite separation along the target direction in millimetres. Defaults to zero. */
-  readonly gap?: number;
-  /** Finite additional roll around the attached direction in degrees. Defaults to zero. */
-  readonly spinDegrees?: number;
-  /** Explicit numeric comparison overrides for anchor normalization. */
-  readonly tolerance?: GeometryToleranceOptions;
 }
 
 /**
@@ -1332,7 +1487,7 @@ export declare interface ProfiledEdgeTreatment {
    * First coordinates decrease and second coordinates increase. Cylinder/extrusion ends use
    * cap inset first, side setback second; planar corners use incoming then outgoing edges.
    */
-  readonly profile: readonly Vector2[];
+  readonly profile: readonly Vector2Tuple[];
 }
 
 /** An identified line, circular arc, or cubic Bézier between corresponding landmarks. */
@@ -1348,33 +1503,33 @@ export declare type ProfileSpan2 = {
       /** Selects a straight span. */
       readonly kind: "line";
       /** Start point in millimetres. */
-      readonly start: Vector2;
+      readonly start: Vector2Tuple;
       /** End point in millimetres. */
-      readonly end: Vector2;
+      readonly end: Vector2Tuple;
     }
   | {
       /** Selects the geometric curve or span family. */
       readonly kind: "arc";
       /** Center point in millimetres. */
-      readonly center: Vector2;
+      readonly center: Vector2Tuple;
       /** Circular radius in millimetres. */
       readonly radius: number;
       /** Initial counterclockwise angle in degrees. */
-      readonly startDegrees: number;
+      readonly startAngle: number;
       /** Signed counterclockwise angular sweep in degrees. */
-      readonly sweepDegrees: number;
+      readonly sweepAngle: number;
     }
   | {
       /** Selects a cubic Bézier span with the same coordinates as CubicBezierCurve2. */
       readonly kind: "cubic";
       /** Start point in millimetres. */
-      readonly start: Vector2;
+      readonly start: Vector2Tuple;
       /** First control point in millimetres. */
-      readonly control1: Vector2;
+      readonly control1: Vector2Tuple;
       /** Second control point in millimetres. */
-      readonly control2: Vector2;
+      readonly control2: Vector2Tuple;
       /** End point in millimetres. */
-      readonly end: Vector2;
+      readonly end: Vector2Tuple;
     }
 );
 
@@ -1384,7 +1539,7 @@ export declare type ProfileSpan2 = {
  * @example Six copies around Z
  * ```ts
  * const pin = cylinder({ height: 6, radius: 2 }).translate([12, 0, 0]);
- * radialPattern(pin, { count: 6, axis: [0, 0, 1], angleDegrees: 60 });
+ * radialPattern(pin, { count: 6, axis: [0, 0, 1], angle: 60 });
  * ```
  */
 export declare function radialPattern(
@@ -1392,29 +1547,33 @@ export declare function radialPattern(
   options: RadialPatternOptions,
 ): readonly Solid[];
 
-/** Repeats a filled Section about an axis; placements must preserve its XY plane. */
+/** Repeats a filled Section counterclockwise about a fixed XY pivot, using the implicit +Z axis. */
 export declare function radialPattern(
   source: PatternSource<Section>,
-  options: RadialPatternOptions,
+  options: RadialPatternOptions<2>,
 ): readonly Section[];
 
 /**
- * Options for repeating one solid around an axis through a center point.
+ * Degree rotations about a fixed world-space pivot; XY patterns use the implicit +Z axis.
  */
-export declare interface RadialPatternOptions {
-  /** Number of solids to return, including the original. */
+export declare type RadialPatternOptions<Dimension extends 2 | 3 = 3> = {
+  /** Number of shapes to return, including the original. */
   readonly count: number;
-  /** Axis of the right-handed rotation. Its magnitude is ignored. */
-  readonly axis: Vector3;
   /** Signed rotation from one copy to the next, in degrees. */
-  readonly angleDegrees: number;
-  /** Rotation center in world coordinates. Defaults to the origin. */
-  readonly center?: Vector3;
-}
+  readonly angle: number;
+  /** Fixed world-space rotation pivot; defaults to the coordinate origin. */
+  readonly pivot?: Dimension extends 2 ? Vector2Input : Vector3Input;
+} & (Dimension extends 2
+  ? {
+      /** XY rotation uses +Z; an explicit spatial axis is unavailable. */
+      readonly axis?: never;
+    }
+  : {
+      /** Axis of the right-handed rotation. Its nonzero magnitude is ignored. */
+      readonly axis: Vector3Input;
+    });
 
-/**
- * Radial dimensions refer to polygon vertices or compensate faceting to meet polygon faces.
- */
+/** Radial dimensions refer to polygon vertices or compensate faceting to meet polygon faces. */
 export declare type RadialSizing = "vertex" | "face";
 
 /**
@@ -1427,13 +1586,6 @@ export declare interface RadialSizingOptions {
   readonly sizing?: RadialSizing;
 }
 
-/** Copies intersections along the finite directed origin-to-endpoint segment. */
-export declare function rayCast(
-  solid: Solid,
-  origin: Vector3,
-  endpoint: Vector3,
-): readonly SolidRayHit[];
-
 /**
  * Filled rectangular section with uniform or independently treated corners.
  *
@@ -1449,7 +1601,7 @@ export declare function rectangle(options: RectangleOptions): Section;
  */
 export declare interface RectangleContourOptions {
   /** Positive uniform size or explicit XY extents in millimetres. */
-  readonly size: number | Vector2;
+  readonly size: number | Vector2Tuple;
   /** Center on XY; otherwise the minimum corner is the origin. Defaults to true. */
   readonly center?: boolean;
   /** Uniform treatment or four corner treatments. Exact round segments describe a complete circle and must divide by four. */
@@ -1478,25 +1630,10 @@ export declare type RectangleCornerTreatments = readonly [
  * Rectangle dimensions, placement and uniform or per-corner treatment.
  */
 export declare interface RectangleOptions
-  extends RectangleContourOptions, PrimitivePlacement {}
+  extends RectangleContourOptions, PrimitiveAttachment {}
 
 /** A two-dimensional region represented by disjoint filled polygons. */
-export declare type Region = readonly Polygon[];
-
-/** Clipper2 join styles accepted by robust region offsets. */
-export declare type RegionOffsetJoin = "miter" | "round" | "square";
-
-/** Options controlling robust Clipper2 region offsets. */
-export declare interface RegionOffsetOptions {
-  /** Number of segments per full circle for round joins. */
-  readonly circularSegments?: number;
-  /** Corner treatment; defaults to `round`. */
-  readonly join?: RegionOffsetJoin;
-  /** Maximum miter extension in offset-distance multiples; at least two. */
-  readonly miterLimit?: number;
-  /** Operation-level physical tessellation policy over the active model-wide policy. */
-  readonly resolution?: GeometryResolution;
-}
+export declare type RegionData = readonly PolygonData[];
 
 /**
  * Regular polygon with a vertex on +X.
@@ -1512,13 +1649,13 @@ export declare function regularPolygon(options: RegularPolygonOptions): Section;
  * Regular polygon dimensions, radial convention and degree rotation.
  */
 export declare type RegularPolygonOptions = RadialSizingOptions &
-  PrimitivePlacement & {
+  PrimitiveAttachment & {
     /** Positive nominal radius in millimetres, interpreted according to sizing. */
     readonly radius: number;
     /** Exact integer side count from three through 100000. */
     readonly sides: number;
     /** Counterclockwise rotation in degrees; defaults to zero with a vertex on +X. */
-    readonly rotationDegrees?: number;
+    readonly rotation?: number;
   };
 
 /**
@@ -1532,7 +1669,7 @@ export declare type RegularPolygonOptions = RadialSizingOptions &
  *
  * // Contour coordinates are [radius, Z].
  * const [profile] = matchProfiles([rectangleProfile({ size: [4, 16], center: false })]);
- * revolve(profile!, { revolveDegrees: 270 });
+ * revolve(profile!, { degrees: 270 });
  * ```
  */
 export declare function revolve(
@@ -1545,12 +1682,14 @@ export declare function revolve(
  */
 export declare interface RevolveOptions extends CircularPrimitiveOptions {
   /**
-   * Positive angular sweep no greater than 360 degrees; partial revolutions have end caps.
+   * Positive sweep in degrees, no greater than 360. Defaults to a full revolution;
+   * smaller sweeps form partial revolutions with end caps.
    * Segment counts describe a complete circle and scale to this angular span. Native filled
    * revolutions require at least three sweep intervals: adaptive sampling refines to that floor,
    * while exact counts that imply fewer intervals reject. Pure revolveMesh supports one interval.
+   * @defaultValue `360`
    */
-  readonly revolveDegrees?: number;
+  readonly degrees?: number;
   /** Explicit output and sampling allocation ceilings. */
   readonly limits?: Partial<ModelingLimits>;
 }
@@ -1566,10 +1705,12 @@ export declare interface RoundedEdgeTreatment extends CircularPrimitiveOptions {
 }
 
 /**
- * Immutable deferred filled XY section recipe belonging to exactly one model session.
- * Methods run during synchronous generation and preserve their receiver.
- * Distances use millimetres; rotations are counterclockwise degrees about the origin.
- * Construction uses the session resolution unless the operation supplies explicit options.
+ * Immutable deferred filled XY section recipe. Construction and composition require no engine.
+ * Ordinary recipes may be reused across sessions regardless of where constructed.
+ * Observed components and recipes using them can only be evaluated in their originating session.
+ * Methods leave the source unchanged; observations require a synchronous model execution.
+ * Distances use millimetres; rotations use counterclockwise degrees.
+ * Explicit resolution settings are captured; unspecified settings inherit the evaluating host's defaults.
  *
  * @example Extrude an outline with a border
  * ```ts
@@ -1580,20 +1721,30 @@ export declare interface RoundedEdgeTreatment extends CircularPrimitiveOptions {
  * ```
  */
 export declare interface Section {
-  /** Compile-time ownership brand for a same-session section. */
+  /** Compile-time identity brand for an immutable filled section recipe. */
   readonly [sectionBrand]: "Section";
   /** Translates XY coordinates in millimetres. */
-  translate(this: Section, offset: Vector2): Section;
-  /** Rotates counterclockwise about the origin by a scalar angle in degrees. */
-  rotate(this: Section, degrees: number): Section;
+  translate(this: Section, offset: Vector2Input): Section;
   /**
-   * Nonsingular scaling about the origin.
+   * Rotates counterclockwise in degrees.
+   * `options.pivot` is a fixed world-space point; omission uses the coordinate origin.
    */
-  scale(this: Section, factors: number | Vector2): Section;
+  rotate(this: Section, degrees: number, options?: Pivot2Options): Section;
+  /**
+   * Uniform or per-axis nonsingular scaling; negative factors reflect geometry.
+   * `options.pivot` is a fixed world-space point; omission uses the coordinate origin.
+   */
+  scale(
+    this: Section,
+    factors: number | Vector2Input,
+    options?: Pivot2Options,
+  ): Section;
   /** Reflection across an origin line/plane. */
-  mirror(this: Section, normal: Vector2): Section;
-  /** Row-major affine transform preserving dimensionality. */
-  transform(this: Section, matrix: Transform2): Section;
+  mirror(this: Section, normal: Vector2Input): Section;
+  /** Applies a reusable XY placement or canonical row-major matrix. */
+  transform(this: Section, placement: Transform2Input): Section;
+  /** Copies canonical filled polygons for interchange; requires an active model execution. */
+  toRegionData(this: Section): RegionData;
   /** Native section difference; an empty cutter array preserves the source. */
   subtract(this: Section, cutters: readonly Section[]): Section;
   /**
@@ -1604,7 +1755,7 @@ export declare interface Section {
    */
   simplify(this: Section, tolerance: number): Section;
   /**
-   * Returns a new same-session handle with copied named anchors; existing names may be replaced.
+   * Returns a new recipe with copied named anchors; existing names may be replaced.
    */
   withAnchors(
     this: Section,
@@ -1616,7 +1767,7 @@ export declare interface Section {
   offset(
     this: Section,
     distance: number,
-    options?: RegionOffsetOptions,
+    options?: SectionOffsetOptions,
   ): Section;
   /**
    * Extrudes along +Z with degree twist and top scaling.
@@ -1629,21 +1780,21 @@ export declare interface Section {
   /**
    * Sweeps this filled section using the selected frame policy and degree twist.
    */
-  sweep(this: Section, path: readonly Vector3[], options?: SweepOptions): Solid;
+  sweep(this: Section, path: Path3Input, options?: SweepOptions): Solid;
 }
 
 declare const sectionBrand: unique symbol;
 
-/** Planar convex hull inputs are finite XY points or same-session filled sections. */
+/** Planar convex hull inputs are finite XY points or filled section recipes. */
 export declare type SectionHullOptions =
   | {
       /** At least three finite millimetre XY points spanning positive area. */
-      readonly points: readonly Vector2[];
+      readonly points: readonly Vector2Input[];
       /** Point input excludes section input. */
       readonly sections?: never;
     }
   | {
-      /** One through 1000 same-session sections to include in the convex hull. */
+      /** One through 1000 filled section recipes to include in the convex hull. */
       readonly sections: readonly Section[];
       /** Section input excludes point input. */
       readonly points?: never;
@@ -1659,15 +1810,30 @@ export declare interface SectionInspection {
   /** Filled section area in square millimetres. */
   readonly area: number;
   /** Number of extracted outer and hole contours. */
-  readonly contours: number;
+  readonly contourCount: number;
   /** Inclusive maximum coordinates in millimetres. */
-  readonly max: Vector2;
+  readonly max: Vector2Tuple;
   /** Inclusive minimum coordinates in millimetres. */
-  readonly min: Vector2;
+  readonly min: Vector2Tuple;
   /** Number of disconnected filled section components. */
-  readonly parts: number;
+  readonly componentCount: number;
   /** Number of native section vertices. */
-  readonly vertices: number;
+  readonly vertexCount: number;
+}
+
+/** Clipper2 join styles accepted by robust region offsets. */
+export declare type SectionOffsetJoin = "miter" | "round" | "square";
+
+/** Options controlling robust Clipper2 region offsets. */
+export declare interface SectionOffsetOptions {
+  /** Number of segments per full circle for round joins. */
+  readonly circularSegments?: number;
+  /** Corner treatment; defaults to `round`. */
+  readonly join?: SectionOffsetJoin;
+  /** Maximum miter extension in offset-distance multiples; at least two. */
+  readonly miterLimit?: number;
+  /** Operation-level physical tessellation policy over the active model-wide policy. */
+  readonly resolution?: GeometryResolution;
 }
 
 /** A cubic corner transition with zero curvature at its straight tangent joins. */
@@ -1685,8 +1851,11 @@ export declare interface SmoothEdgeTreatment {
 }
 
 /**
- * Immutable deferred solid recipe belonging to exactly one model session.
- * Methods run during synchronous generation, preserve their receiver, and use millimetres and degrees.
+ * Immutable deferred solid recipe. Construction and composition require no engine.
+ * Ordinary recipes may be reused across sessions regardless of where constructed.
+ * Explicit resolution settings are captured; unspecified settings inherit the evaluating host's defaults.
+ * Observed components and recipes using them can only be evaluated in their originating session.
+ * Methods leave the source unchanged and use millimetres and degrees.
  * A no-op may reuse the receiver; final part placement belongs in `part` options.
  *
  * @example Shape a body with a through bore
@@ -1697,26 +1866,34 @@ export declare interface SmoothEdgeTreatment {
  * ```
  */
 export declare interface Solid {
-  /** Compile-time ownership brand for a same-session solid. */
+  /** Compile-time identity brand for an immutable solid recipe. */
   readonly [solidBrand]: "Solid";
   /**
    * Translates XYZ coordinates in millimetres.
    */
-  translate(this: Solid, offset: Vector3): Solid;
+  translate(this: Solid, offset: Vector3Input): Solid;
   /**
-   * Rotates about the origin using XYZ Euler angles in degrees.
+   * Rotates about global X, then Y, then Z in degrees.
+   * `options.pivot` is a fixed world-space point; omission uses the coordinate origin.
    */
-  rotate(this: Solid, degrees: Vector3): Solid;
+  rotate(this: Solid, degrees: Vector3Input, options?: Pivot3Options): Solid;
   /**
-   * Nonsingular scaling about the origin.
+   * Uniform or per-axis nonsingular scaling; negative factors reflect geometry.
+   * `options.pivot` is a fixed world-space point; omission uses the coordinate origin.
    */
-  scale(this: Solid, factors: number | Vector3): Solid;
+  scale(
+    this: Solid,
+    factors: number | Vector3Input,
+    options?: Pivot3Options,
+  ): Solid;
   /**
    * Reflection across an origin line/plane.
    */
-  mirror(this: Solid, normal: Vector3): Solid;
-  /** Row-major affine transform preserving dimensionality. */
-  transform(this: Solid, matrix: Transform3): Solid;
+  mirror(this: Solid, normal: Vector3Input): Solid;
+  /** Applies a reusable XYZ placement or canonical row-major matrix. */
+  transform(this: Solid, placement: Transform3Input): Solid;
+  /** Copies manufacturing mesh buffers for interchange; requires an active model execution. */
+  toTriangleMesh(this: Solid): TriangleMesh;
   /**
    * Robust difference; an empty cutter array preserves the source.
    */
@@ -1729,7 +1906,7 @@ export declare interface Solid {
    */
   simplify(this: Solid, tolerance: number): Solid;
   /**
-   * Returns a new same-session handle with copied named anchors; existing names may be replaced.
+   * Returns a new recipe with copied named anchors; existing names may be replaced.
    */
   withAnchors(this: Solid, anchors: Readonly<Record<string, Anchor3>>): Solid;
   /**
@@ -1741,8 +1918,8 @@ export declare interface Solid {
     target: Anchor3,
     options?: AttachOptions,
   ): Solid;
-  /** Replaces native tolerance on an immutable copy; zero selects the kernel minimum. */
-  setTolerance(this: Solid, tolerance: number): Solid;
+  /** Returns an immutable copy with this native tolerance; zero selects the kernel minimum. */
+  withTolerance(this: Solid, tolerance: number): Solid;
   /** Projects this solid into a filled XY section. */
   projectSection(this: Solid): Section;
   /** Takes a filled horizontal slice at Z millimetres. */
@@ -1775,11 +1952,11 @@ export declare interface SolidInspection {
   /** Whether this native solid contains no material. */
   readonly isEmpty: boolean;
   /** Inclusive maximum coordinates in millimetres. */
-  readonly max: Vector3;
+  readonly max: Vector3Tuple;
   /** Inclusive minimum coordinates in millimetres. */
-  readonly min: Vector3;
-  /** Number of connected surface shells; inward cavity shells count separately. */
-  readonly parts: number;
+  readonly min: Vector3Tuple;
+  /** Number of disconnected material components, each retaining enclosed cavities. */
+  readonly componentCount: number;
   /** Enclosed native solid volume in cubic millimetres. */
   readonly volume: number;
   /** Total native surface area in square millimetres. */
@@ -1789,15 +1966,15 @@ export declare interface SolidInspection {
 }
 
 /** Copied surface intersection from a finite directed segment. Distance is in millimetres. */
-export declare interface SolidRayHit {
+export declare interface SolidSegmentHit {
   /** Copied numeric native face identity. */
   readonly faceId: number;
-  /** Distance from the ray origin in millimetres. */
+  /** Distance from the segment origin in millimetres. */
   readonly distance: number;
   /** Intersection position in millimetres. */
-  readonly position: Vector3;
+  readonly position: Vector3Tuple;
   /** Outward unit surface normal at the intersection. */
-  readonly normal: Vector3;
+  readonly normal: Vector3Tuple;
 }
 
 /**
@@ -1814,7 +1991,7 @@ export declare function sphere(options: SphereOptions): Solid;
  * Exactly one radius or diameter, placement, and tessellation for an origin-centered sphere.
  */
 export declare type SphereOptions = CircularPrimitiveOptions &
-  PrimitivePlacement &
+  PrimitiveAttachment &
   (
     | {
         /** Positive radius in millimetres; mutually exclusive with diameter. */
@@ -1900,7 +2077,7 @@ export declare function star(options: StarOptions): Section;
 /**
  * Alternating outer and inner vertices, centered on the XY origin.
  */
-export declare interface StarOptions extends PrimitivePlacement {
+export declare interface StarOptions extends PrimitiveAttachment {
   /** Explicit sampling ceilings, bounded by the host policy. */
   readonly limits?: Partial<GeometrySamplingLimits>;
   /** Positive outer vertex radius in millimetres. */
@@ -1910,7 +2087,46 @@ export declare interface StarOptions extends PrimitivePlacement {
   /** Integer outer point count from three through 50000. */
   readonly points: number;
   /** Initial counterclockwise rotation in degrees; defaults to zero. */
-  readonly rotationDegrees?: number;
+  readonly rotation?: number;
+}
+
+/**
+ * Creates a centered-width native Section along a sampled XY path.
+ *
+ * Shares caps, joins and physical sampling with Geometry's strokeRegionData. Native union
+ * resolves overlapping stroke primitives. Session resolution and resource ceilings apply;
+ * closed paths omit the duplicated seam. Returns an immutable deferred recipe.
+ *
+ * @example Extrude a rounded track
+ * ```ts
+ * stroke([[0, 0], [20, 0], [20, 10]], { width: 3, join: "round", cap: "round" }).extrude({ height: 2 });
+ * ```
+ */
+export declare function stroke(
+  path: Path2Input,
+  options: StrokeOptions,
+): Section;
+
+/** End-cap treatment for an open stroked path. */
+export declare type StrokeCap = "butt" | "round" | "square";
+
+/** Join treatment where adjacent stroked path segments meet. */
+export declare type StrokeJoin = "bevel" | "miter" | "round";
+
+/** Physical stroke and topology controls shared by pure regions and native Sections. */
+export declare interface StrokeOptions {
+  /** Explicit path, circular and expanded-profile allocation ceilings. */
+  readonly limits?: Partial<GeometrySamplingLimits>;
+  /** Raw point closure defaults to false; a Path2 supplies its closure and rejects conflicts. */
+  readonly closed?: boolean;
+  /** End-cap treatment for an open path. Ignored for closed paths. Default: `butt`. */
+  readonly cap?: StrokeCap;
+  /** Corner treatment; miters exceeding SVG's default limit of 4 become bevels. Default: `miter`. */
+  readonly join?: StrokeJoin;
+  /** Physical tessellation policy for round caps and joins. */
+  readonly resolution?: GeometryResolution;
+  /** Positive total stroke width in millimetres, centered on the sampled path. */
+  readonly width: number;
 }
 
 /** Placement of painted SVG geometry after SVG Y-axis inversion. */
@@ -1990,7 +2206,7 @@ export declare interface SvgSectionOptions {
  */
 export declare function sweep(
   shape: CorrespondingProfile,
-  path: readonly Vector3[],
+  path: Path3Input,
   options?: SweepOptions,
 ): Solid;
 
@@ -1998,7 +2214,7 @@ export declare function sweep(
  * Controls shared by pure mesh construction and filled modeling sweeps.
  */
 export declare interface SweepOptions {
-  /** Join the path's last station to its first. Open paths retain watertight end caps. */
+  /** Raw point closure defaults to false; a Path3 supplies its closure and rejects conflicts. */
   readonly closed?: boolean;
   /** Explicit output and sampling allocation ceilings. */
   readonly limits?: Partial<ModelingLimits>;
@@ -2007,11 +2223,11 @@ export declare interface SweepOptions {
   /** Physical sampling of nonzero twist; inserted stations retain authored station controls. */
   readonly resolution?: GeometryResolution;
   /** Total additional profile rotation in degrees, with progression selected by twistBy. */
-  readonly twistDegrees?: number;
+  readonly twist?: number;
   /** Twist advances by physical path length (default), or normalized authored station position, including a closed seam gap. */
   readonly twistBy?: "length" | "stations";
   /** Positive uniform/XY scale, or one XY pair per path station. Defaults to one. */
-  readonly scale?: number | Vector2 | readonly Vector2[];
+  readonly scale?: number | Vector2Input | readonly Vector2Input[];
   /** Corresponding point-index advance at a rotationally equivalent closed seam. */
   readonly seamProfileOffset?: number;
 }
@@ -2024,13 +2240,13 @@ export declare type SweepOrientation =
       /** Minimizes frame rotation by parallel transport. */
       readonly kind: "transport";
       /** Initial profile +X guide, projected perpendicular to the first tangent. */
-      readonly initialNormal?: Vector3;
+      readonly initialNormal?: Vector3Input;
     }
   | {
       /** Projects one fixed world-space normal at every path station. */
       readonly kind: "fixed-normal";
       /** Directed profile +X guide; must not be parallel to any local tangent. */
-      readonly normal: Vector3;
+      readonly normal: Vector3Input;
     }
   | {
       /** Uses an explicitly directed normal callback at each original normalized station. */
@@ -2088,9 +2304,9 @@ declare interface ThreadBevelOptions {
  * @example Threaded nut
  * ```ts
  * import { threadedNut } from "@metamesh/modeling";
- * import { createThreadProfile } from "@metamesh/modeling/geometry";
+ * import { threadProfile } from "@metamesh/modeling/geometry";
  *
- * const profile = createThreadProfile({ kind: "triangular", pitch: 1.75 });
+ * const profile = threadProfile({ kind: "triangular", pitch: 1.75 });
  * threadedNut({ nominalMajorDiameter: 12, thickness: 8, width: 20, shape: "hex", profile, fit: "normal" });
  * ```
  */
@@ -2152,9 +2368,9 @@ export declare type ThreadedNutShape = "hex" | "round" | "square";
  * @example Threaded rod
  * ```ts
  * import { threadedRod } from "@metamesh/modeling";
- * import { createThreadProfile } from "@metamesh/modeling/geometry";
+ * import { threadProfile } from "@metamesh/modeling/geometry";
  *
- * const profile = createThreadProfile({ kind: "triangular", pitch: 1.75 });
+ * const profile = threadProfile({ kind: "triangular", pitch: 1.75 });
  * threadedRod({ nominalMajorDiameter: 12, length: 24, profile, fit: "normal" });
  * ```
  */
@@ -2237,7 +2453,7 @@ export declare interface ThreadProfile {
   /** Adjacent axial thread spacing in millimetres. */
   readonly pitch: number;
   /** Immutable open `[axial, radial]` path spanning one pitch. */
-  readonly points: readonly Vector2[];
+  readonly points: readonly Vector2Tuple[];
   /** Axial width of the flat at the minor envelope. */
   readonly rootFlatWidth: number;
 }
@@ -2267,9 +2483,6 @@ export declare function threadRidge(options: ThreadRidgeOptions): Solid;
 /** Parameters for a helical ridge before solid construction. */
 export declare type ThreadRidgeOptions = HelicalThreadRidgeMeshOptions;
 
-/** Explicit copied topology inspection; not needed for section operations. */
-export declare function toRegion(section: Section): Region;
-
 /**
  * Torus around +Z.
  *
@@ -2283,7 +2496,7 @@ export declare function torus(options: TorusOptions): Solid;
 /**
  * Dimensions and independent ring/profile tessellation for a torus around the Z axis.
  */
-export declare interface TorusOptions extends PrimitivePlacement {
+export declare interface TorusOptions extends PrimitiveAttachment {
   /** Explicit sampling ceilings, bounded by the host policy. */
   readonly limits?: Partial<GeometrySamplingLimits>;
   /** Radius from the Z axis to the profile center, in millimetres; greater than `minorRadius`. */
@@ -2298,11 +2511,51 @@ export declare interface TorusOptions extends PrimitivePlacement {
   readonly resolution?: GeometryResolution;
 }
 
-/** Copies a handle to manufacturing mesh buffers. */
-export declare function toTriangleMesh(solid: Solid): TriangleMesh;
+/** Immutable reusable XY placement. Methods apply in written order; angles are degrees. */
+export declare interface Transform2 {
+  /** Applies a translation in model units after this placement. */
+  translate(offset: Vector2Input): Transform2;
+  /** Rotates counterclockwise in degrees about an optional world-space pivot (default origin). */
+  rotate(degrees: number, options?: Pivot2Options): Transform2;
+  /** Scales about an optional world-space pivot; finite nonzero factors may reflect. */
+  scale(factors: number | Vector2Input, options?: Pivot2Options): Transform2;
+  /** Applies this placement first, then `next`; neither operand is mutated. */
+  andThen(next: Transform2Input): Transform2;
+  /** Returns the inverse; singular and numerically unstable transforms throw GeometryError. */
+  inverse(): Transform2;
+  /** Transforms a finite point, including translation. Returns a fresh immutable vector. */
+  applyPoint(point: Vector2Input): Vector2;
+  /** Transforms a finite direction, excluding translation and retaining scale. This is not a normal transform. */
+  applyDirection(direction: Vector2Input): Vector2;
+  /** Applies the inverse transpose and normalizes. Ignores translation; rejects zero normals. */
+  applyNormal(normal: Vector2Input): Vector2;
+  /** Returns the frozen canonical row-major 3x3 matrix for interchange. */
+  toMatrix(): Transform2Matrix;
+  /** Embeds this placement in XYZ, leaving Z unchanged, for solids and 3D paths. */
+  to3D(): Transform3;
+}
+
+/**
+ * Creates an immutable XY transform, identity by default. Matrices are copied and validated.
+ * Pass it directly to Section.transform() and planar data helpers; to3D() explicitly crosses into XYZ.
+ * Zero scales and singular matrices throw GeometryError; negative scales reflect.
+ *
+ * @example
+ * ```ts
+ * const placement = transform2().rotate(90).translate([10, 0]);
+ * placement.applyPoint([1, 0]).toArray(); // approximately [10, 1]
+ * ```
+ */
+export declare function transform2(matrix?: Transform2Matrix): Transform2;
+
+/** An immutable XY transform or its canonical row-major matrix for interchange. */
+export declare type Transform2Input = Transform2 | Transform2Matrix;
 
-/** Row-major affine XY matrix. Translation occupies m02/m12; final row is [0, 0, 1]. */
-export declare type Transform2 = readonly [
+/**
+ * A row-major affine 3x3 XY matrix applied to column vectors.
+ * Translation occupies indices 2 and 5; the final row is `[0, 0, 1]`.
+ */
+export declare type Transform2Matrix = readonly [
   m00: number,
   m01: number,
   m02: number,
@@ -2314,13 +2567,60 @@ export declare type Transform2 = readonly [
   m22: number,
 ];
 
+/** Immutable reusable XYZ placement. Methods apply in written order; angles are degrees. */
+export declare interface Transform3 {
+  /** Applies a translation in model units after this placement. */
+  translate(offset: Vector3Input): Transform3;
+  /** Rotates about global X, then Y, then Z in degrees, about an optional world-space pivot. */
+  rotate(degrees: Vector3Input, options?: Pivot3Options): Transform3;
+  /** Rotates right-handed in degrees about a nonzero axis and optional world-space pivot. */
+  rotateAxis(
+    axis: Vector3Input,
+    degrees: number,
+    options?: Pivot3Options,
+  ): Transform3;
+  /** Scales about an optional world-space pivot; finite nonzero factors may reflect. */
+  scale(factors: number | Vector3Input, options?: Pivot3Options): Transform3;
+  /** Applies this placement first, then `next`; equivalent to composeTransform3(next, current). */
+  andThen(next: Transform3Input): Transform3;
+  /** Returns the inverse; singular and numerically unstable transforms throw GeometryError. */
+  inverse(): Transform3;
+  /** Transforms a finite point, including translation. Returns a fresh immutable vector. */
+  applyPoint(point: Vector3Input): Vector3;
+  /** Transforms a finite direction, excluding translation and retaining scale. This is not a normal transform. */
+  applyDirection(direction: Vector3Input): Vector3;
+  /** Applies the inverse transpose and normalizes. Ignores translation; rejects zero normals. */
+  applyNormal(normal: Vector3Input): Vector3;
+  /** Returns the frozen canonical row-major 4x4 matrix for interchange. */
+  toMatrix(): Transform3Matrix;
+  /** Restricts to XY; throws GeometryError for a plane change or singular XY restriction. */
+  to2D(): Transform2;
+}
+
+/**
+ * Creates an immutable XYZ transform, identity by default. Matrices 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.
+ *
+ * @example
+ * ```ts
+ * const placement = transform3().rotate([0, 0, 90]).translate([10, 0, 0]);
+ * placement.applyPoint([1, 0, 0]).toArray(); // approximately [10, 1, 0]
+ * ```
+ */
+export declare function transform3(matrix?: Transform3Matrix): Transform3;
+
+/** An immutable XYZ transform or its canonical row-major matrix for interchange. */
+export declare type Transform3Input = Transform3 | Transform3Matrix;
+
 /**
  * A row-major affine 4x4 matrix applied to column vectors.
  *
  * Translation occupies indices 3, 7, and 11. The final row must be
  * `[0, 0, 0, 1]` within the active geometry tolerance.
  */
-export declare type Transform3 = readonly [
+export declare type Transform3Matrix = readonly [
   m00: number,
   m01: number,
   m02: number,
@@ -2349,10 +2649,11 @@ declare interface TrapezoidalThreadProfileSpec extends ThreadProfileBaseSpec {
    */
   readonly depth?: number;
   /**
-   * Included flank angle in degrees. Use `90` for printable 45-degree slopes.
+   * Full angle between the flanks in degrees, from `0` inclusive to `180` exclusive.
+   * Each flank uses half this angle from the radial direction; `90` gives 45-degree slopes.
    * @defaultValue `30`
    */
-  readonly threadAngle?: number;
+  readonly includedAngle?: number;
 }
 
 /**
@@ -2369,7 +2670,7 @@ export declare interface TriangleMesh {
  * Measurements and optional edge-connected topology from one validated mesh traversal.
  */
 export declare interface TriangleMeshAnalysis extends TriangleMeshMeasurements {
-  /** Number of referenced edge-connected components when `includeTopology` is requested. */
+  /** Number of referenced edge-connected boundary shells when `includeTopology` is requested; cavities count separately. */
   readonly connectedComponentCount?: number;
   /** Number of distinct indexed undirected edges when `includeTopology` is requested. */
   readonly edgeCount?: number;
@@ -2423,7 +2724,7 @@ export declare function tube(options: TubeOptions): Solid;
  * Dimensions, placement, and tessellation for a hollow Z-axis tube.
  */
 export declare interface TubeOptions
-  extends CircularPrimitiveOptions, PrimitivePlacement {
+  extends CircularPrimitiveOptions, PrimitiveAttachment {
   /**
    * Centers the tube on the Z origin when `true`; otherwise its bottom is at `Z = 0`.
    * @defaultValue `true`
@@ -2452,11 +2753,97 @@ export declare function union(solids: readonly Solid[]): Solid;
 /** Native filled section union; dimensions cannot be mixed. */
 export declare function union(sections: readonly Section[]): Section;
 
+/** Immutable XY arithmetic; vector operations return new values and measurements return numbers. */
+export declare interface Vector2 {
+  /** X coordinate in the vector's coordinate units. */
+  readonly x: number;
+  /** Y coordinate in the vector's coordinate units. */
+  readonly y: number;
+  /** Adds another vector component-wise. */
+  add(other: Vector2Input): Vector2;
+  /** Subtracts another vector component-wise. */
+  subtract(other: Vector2Input): Vector2;
+  /** Multiplies by a finite dimensionless scalar. */
+  scale(factor: number): Vector2;
+  /** Returns a unit vector; rejects length at or below finite nonnegative `epsilon` (default `1e-12`). */
+  normalize(epsilon?: number): Vector2;
+  /** Interpolates toward another vector by finite dimensionless `t`; extrapolation is allowed. */
+  lerp(other: Vector2Input, t: number): Vector2;
+  /** Returns the scalar dot product. */
+  dot(other: Vector2Input): number;
+  /** Returns the signed scalar cross product; positive means the other vector is counterclockwise. */
+  cross(other: Vector2Input): number;
+  /** Returns Euclidean length in the vector's coordinate units. */
+  length(): number;
+  /** Returns Euclidean distance to another vector in the same coordinate units. */
+  distance(other: Vector2Input): number;
+  /** Returns this value's frozen readonly tuple for interchange; repeated calls do not allocate. */
+  toArray(): Vector2Tuple;
+}
+
+/**
+ * Creates immutable XY arithmetic from a finite tuple or vector, snapshotting the coordinates.
+ * Values and results are finite. Invalid dimensions throw `INVALID_ARGUMENT`; nonfinite coordinates
+ * and overflow throw `NON_FINITE_VALUE` GeometryError.
+ * Use transform2().applyDirection(value) for rotations and nonuniform scaling.
+ */
+export declare function vector2(input: Vector2Input): Vector2;
+
+/** An XY tuple or immutable fluent vector accepted by vector operations. */
+export declare type Vector2Input = Vector2Tuple | Vector2;
+
 /** A two-dimensional Cartesian vector or point. */
-export declare type Vector2 = readonly [x: number, y: number];
+export declare type Vector2Tuple = readonly [x: number, y: number];
+
+/** Immutable XYZ arithmetic; vector operations return new values and measurements return numbers. */
+export declare interface Vector3 {
+  /** X coordinate in the vector's coordinate units. */
+  readonly x: number;
+  /** Y coordinate in the vector's coordinate units. */
+  readonly y: number;
+  /** Z coordinate in the vector's coordinate units. */
+  readonly z: number;
+  /** Adds another vector component-wise. */
+  add(other: Vector3Input): Vector3;
+  /** Subtracts another vector component-wise. */
+  subtract(other: Vector3Input): Vector3;
+  /** Multiplies by a finite dimensionless scalar. */
+  scale(factor: number): Vector3;
+  /** Returns a unit vector; rejects length at or below finite nonnegative `epsilon` (default `1e-12`). */
+  normalize(epsilon?: number): Vector3;
+  /** Interpolates toward another vector by finite dimensionless `t`; extrapolation is allowed. */
+  lerp(other: Vector3Input, t: number): Vector3;
+  /** Returns the scalar dot product. */
+  dot(other: Vector3Input): number;
+  /** Returns the right-handed cross product as a new vector. */
+  cross(other: Vector3Input): Vector3;
+  /** Returns Euclidean length in the vector's coordinate units. */
+  length(): number;
+  /** Returns Euclidean distance to another vector in the same coordinate units. */
+  distance(other: Vector3Input): number;
+  /** Returns this value's frozen readonly tuple for interchange; repeated calls do not allocate. */
+  toArray(): Vector3Tuple;
+}
+
+/**
+ * Creates immutable XYZ arithmetic from a finite tuple or vector, snapshotting the coordinates.
+ * Values and results are finite. Invalid dimensions throw `INVALID_ARGUMENT`; nonfinite coordinates
+ * and overflow throw `NON_FINITE_VALUE` GeometryError.
+ * Use transform3().applyDirection(value) for rotations and nonuniform scaling.
+ *
+ * @example
+ * ```ts
+ * const direction = vector3([1, 2, 3]).add([4, 0, 0]).normalize().scale(10);
+ * const alignment = direction.dot([0, 0, 1]);
+ * ```
+ */
+export declare function vector3(input: Vector3Input): Vector3;
+
+/** An XYZ tuple or immutable fluent vector accepted by vector operations. */
+export declare type Vector3Input = Vector3Tuple | Vector3;
 
 /** A three-dimensional Cartesian vector or point. */
-export declare type Vector3 = readonly [x: number, y: number, z: number];
+export declare type Vector3Tuple = readonly [x: number, y: number, z: number];
 
 /**
  * Immutable vector layout with no browser, font parser, or kernel ownership.