@code3d/core 0.0.1-alpha.0 → 0.0.1-alpha.11

package/bld/library/runtime.d.ts

@@ -1,11 +1,16 @@
-import type { Material } from './three.js';
-import { type ModelMaterialSnapshot } from './material.js';
-import { type TopologyInspection, type TopologyInspectionOptions } from './topology-inspection.js';
 import { type AnyShape } from 'replicad';
-import { type Quaternion, type RigidTransform, type Vec3 } from './spatial.js';
+import { type AlignmentGeometry } from './alignment-geometry.js';
+import { cache } from './cached.js';
+import { font, googleFont, type Font } from './font.js';
+import { anchorAnnotation, boundsAnnotation, captureInspectData, dimension } from './inspect.js';
 import { type KernelOperationKey } from './kernel-cache.js';
+import { type ModelMaterialSnapshot } from './material.js';
 import type { SketchRegion } from './sketch-regions.js';
+import { type Quaternion, type RigidTransform, type Vec3 } from './spatial.js';
+import { type TextOptions } from './text.js';
+import { type Material } from 'three';
 import { type TopologyId } from './topology-id.js';
+import { type TopologyInspection, type TopologyInspectionOptions } from './topology-inspection.js';
 import { type EdgeId, type ShapeTopology, type SurfaceId, type TopologyKind, type TopologySelection, type VertexId } from './topology.js';
 import { sketch } from './sketch.js';
 export type { Quaternion, Vec3 } from './spatial.js';
@@ -48,7 +53,7 @@ export type ElementSnapshot = Readonly<{
     }>;
     facing?: 1 | -1;
     direction?: 1 | -1;
-    arrow?: RigidTransform;
+    arrows?: readonly RigidTransform[];
     topology?: Readonly<{
         geometryNodeId: string;
         transform: Transform;
@@ -65,9 +70,6 @@ export type ConstraintSnapshot = Readonly<{
     target: ConstraintAnchorSnapshot;
     sourceElement: ElementSnapshot;
     targetElement: ElementSnapshot;
-    offsetDirection: 1 | -1;
-    offset: Vec3;
-    offsetFrame: Transform;
     sourceRefs: readonly SourceRef[];
     parameters: readonly ParameterUsage[];
 }> & (Readonly<{
@@ -80,17 +82,10 @@ export type ConstraintSnapshot = Readonly<{
 }> | Readonly<{
     kind: 'align';
 }>);
-export type ModelOperationKind = 'box' | 'cylinder' | 'tube' | 'coil' | 'sphere' | 'frustum' | 'regularPrism' | 'circle' | 'ellipse' | 'rectangle' | 'regularPolygon' | 'point' | 'line' | 'arc' | 'bezier' | 'spline' | 'loft' | 'sketchFace' | 'extrude' | 'primitive' | 'material' | 'scaled' | 'originOffset' | 'originVertex' | 'originPoint' | 'originCenter' | 'rotate' | 'fillet' | 'chamfer' | 'shell' | 'relate' | 'expose' | 'group' | 'union' | 'cut' | 'intersect';
+export type ModelOperationKind = 'sketch' | 'box' | 'cylinder' | 'tube' | 'coil' | 'sphere' | 'frustum' | 'regularPrism' | 'circle' | 'ellipse' | 'rectangle' | 'regularPolygon' | 'point' | 'line' | 'arc' | 'bezier' | 'spline' | 'loft' | 'sketchFace' | 'text' | 'extrude' | 'primitive' | 'material' | 'scaled' | 'originOffset' | 'originVertex' | 'originPoint' | 'originCenter' | 'rotate' | 'fillet' | 'chamfer' | 'shell' | 'relate' | 'expose' | 'group' | 'union' | 'cut' | 'intersect';
 export type ModelOperationInputRole = 'source' | 'receiver' | 'operand' | 'tool' | 'child' | 'collection' | 'reference' | 'section' | 'spine';
 export type ModelGeometryKind = 'solid' | 'face' | 'edge' | 'vertex';
 export type ModelKind = ModelGeometryKind | 'group';
-export type ModelOperationRegionSnapshot = Readonly<{
-    kind: 'intersection' | 'section';
-    inputNodeId: string;
-    /** The model whose local coordinates contain this region mesh. */
-    frameNodeId: string;
-    mesh: RenderMesh;
-}>;
 export type ModelOperationSelectionSnapshot = Readonly<{
     kind: TopologyKind;
     inputNodeId: string;
@@ -110,7 +105,6 @@ export type ModelOperationSnapshot = Readonly<{
         role: ModelOperationInputRole;
         index: number;
     }>[];
-    regions: readonly ModelOperationRegionSnapshot[];
     selections: readonly ModelOperationSelectionSnapshot[];
     sourceRef?: SourceRef;
     spatial?: ModelSpatialOperation;
@@ -121,6 +115,28 @@ export type ModelParameterDimension = Readonly<{
     origin: Vec3;
     vector: Vec3;
 }>;
+export type RotationReferenceSnapshot = Readonly<{
+    offset: Vec3;
+    offsetExplicit: boolean;
+    explicit: boolean;
+    /** Rotation in the displacement frame, including reversed axes. */
+    rotation: Vec3;
+    /** Reference displacement axes, in the result model's local coordinates. */
+    frame: RigidTransform;
+}> & (Readonly<{
+    kind: 'pivot';
+    point: Vec3;
+}> | Readonly<{
+    kind: 'pivotVertex';
+    id: VertexId;
+}> | Readonly<{
+    kind: 'axisEdge';
+    id: EdgeId;
+}> | Readonly<{
+    kind: 'pivotPoint' | 'axisLine';
+    nodeId: string;
+    name: string;
+}>);
 /** Local geometry coordinates; vector is the authored coordinates, offset, or angles. */
 export type ModelSpatialOperation = Readonly<{
     origin: Vec3;
@@ -129,15 +145,16 @@ export type ModelSpatialOperation = Readonly<{
     frame?: RigidTransform;
     rotation?: Vec3;
     axisOnly?: boolean;
+    reference?: RotationReferenceSnapshot;
 }>;
-export type ConstraintSpatialReference = Readonly<{
+export type RelationSpatialReference = Readonly<{
     nodeId: string;
-    kind: 'pivot' | 'pivotVertex' | 'around' | 'rotate';
+    kind: 'pivot' | 'pivotVertex' | 'pivotPoint' | 'axisEdge' | 'pivotOffset' | 'axisLine' | 'axisOffset' | 'rotate' | 'offset';
     spatial: ModelSpatialOperation;
 }>;
-export type ConstraintPreview = Readonly<{
-    object: Pick<ModelSnapshotObject, 'nodeId' | 'compositionTransform' | 'constraints'>;
-    spatial?: ConstraintSpatialReference;
+export type RelationPreview = Readonly<{
+    object: Pick<ModelSnapshotObject, 'nodeId' | 'compositionTransform' | 'constraints' | 'transformations' | 'relationStages'>;
+    spatial?: RelationSpatialReference;
 }>;
 export type RenderMesh = Readonly<{
     /** Tessellation vertices used by the triangle mesh. */
@@ -159,11 +176,14 @@ export type RenderMesh = Readonly<{
         start: number;
         count: number;
         edgeId: EdgeId;
+        /** True for native straight edges, suitable as rotation references. */
+        linear?: boolean;
     }>[];
 }>;
 export type ModelSnapshotObject = Readonly<{
     nodeId: string;
-    kind: ModelKind;
+    /** Original author geometry retained in an inspection frame, for tool binding. */
+    sourceNodeId?: string;
     name: string;
     /** Effective material, including recursive overrides from enclosing groups. */
     material?: ModelMaterialSnapshot;
@@ -173,13 +193,20 @@ export type ModelSnapshotObject = Readonly<{
     /** Placement in this snapshot tree; a root value uses model-local coordinates. */
     transform: Transform;
     constraints: readonly ConstraintSnapshot[];
+    transformations?: readonly TransformationSnapshot[];
+    relationStages?: readonly RelationStageSnapshot[];
     elements: readonly ElementSnapshot[];
     origin: Vec3;
     sourceRefs: readonly SourceRef[];
     parameters: readonly ParameterUsage[];
     operation: ModelOperationSnapshot;
+}> & (Readonly<{
+    kind: ModelKind;
     mesh?: RenderMesh;
-}>;
+}> | Readonly<{
+    kind: 'reference';
+    mesh?: never;
+}>);
 type StoredElement = Readonly<{
     kind: ElementKind;
     transform: RigidTransform;
@@ -191,6 +218,7 @@ type StoredElement = Readonly<{
     facing?: 1 | -1;
     direction?: 1 | -1;
     topology?: StoredTopology;
+    parts?: readonly StoredTopology[];
     members?: StoredElements;
 }>;
 type StoredTopology = Readonly<{
@@ -204,10 +232,10 @@ type StoredAnchor = StoredElement & Readonly<{
     name: string;
 }>;
 type AnchorReference = StoredAnchor & Readonly<{
-    model: ModelObject;
+    model: RelationObject;
 }>;
 export type ModelElementReference = Readonly<{
-    model: ModelObject;
+    model: RelationObject;
     name: string;
     kind: ElementKind;
     transform: Transform;
@@ -216,19 +244,27 @@ export type ModelElementReference = Readonly<{
     direction?: 1 | -1;
 }>;
 export type ModelTopologyReference = Readonly<{
-    model: ModelObject;
+    model: RelationObject;
     geometry: ModelObject;
     transform: Transform;
 }> & TopologySelection;
 export type ConstraintTraceReference = Readonly<{
+    kind: 'constraint';
     constraintId: string;
-    source: ModelObject;
-    target: ModelObject;
-    self?: ModelObject;
+    source: RelationObject;
+    target: RelationObject;
+    self?: RelationObject;
+}>;
+export type RelationTraceReference = ConstraintTraceReference | Readonly<{
+    kind: 'transformation';
+    transformationId: string;
+    self?: RelationObject;
 }>;
 export type ModelOperationInstrumentation = Readonly<{
     siteId: string;
     execution: number;
+    /** Distinguishes operation results produced by the same call execution. */
+    outputIndex?: number;
     order: number;
     sourceRef: SourceRef;
     parameters: readonly ParameterUsage[];
@@ -238,38 +274,87 @@ export type ModelObjectRuntimeInfo = Readonly<{
     name: string;
     sourceRefs: readonly SourceRef[];
 }>;
+type RelationDefinition = Readonly<{
+    kind: 'on' | 'align';
+    source: AnchorReference;
+    target: AnchorReference;
+}> | Readonly<{
+    kind: 'transformation';
+    actions: readonly TransformationAction[];
+}>;
+type StoredTransformation = Readonly<{
+    id: string;
+    kind: 'transformation';
+    actions: readonly TransformationAction[];
+}>;
+export type RelationStageSnapshot = Readonly<{
+    constraintIds: readonly string[];
+    transformationIds: readonly string[];
+    compositionTransform: Transform;
+    offsetFrame: Transform;
+}>;
+export type TransformationSnapshot = Readonly<{
+    id: string;
+    sourceRefs: readonly SourceRef[];
+    parameters: readonly ParameterUsage[];
+    offsets: readonly Readonly<{
+        value: Vec3;
+        frame: Transform;
+        sourceRefs: readonly SourceRef[];
+    }>[];
+    rotations: readonly Readonly<{
+        spatial: ModelSpatialOperation;
+        sourceRefs: readonly SourceRef[];
+    }>[];
+    offsetFrame: Transform;
+}>;
+type StoredPlacement = StoredConstraint | StoredTransformation;
 type StoredConstraint = Readonly<{
     id: string;
     kind: 'on' | 'align';
     source: RelationReference;
     target: RelationReference;
-    rotations: readonly ConstraintRotation[];
-    offset: Vec3 | undefined;
 }>;
 type RelationReference = StoredAnchor & Readonly<{
-    model?: ModelObject;
+    model?: RelationObject;
 }>;
-type PivotSelection = Readonly<{
+type PivotSelection = (Readonly<{
     kind: 'pivot';
     point: Vec3;
 }> | Readonly<{
     kind: 'pivotVertex';
     id: VertexId;
 }> | Readonly<{
-    kind: 'around';
+    kind: 'pivotPoint';
+    point: RelationReference;
+}> | Readonly<{
+    kind: 'axisEdge';
+    id: EdgeId;
+}> | Readonly<{
+    kind: 'axisLine';
     axis: RelationReference;
+}>) & Readonly<{
+    offset?: Vec3;
+    implicit?: true;
 }>;
-type ConstraintRotation = Readonly<{
+type AxisSelection = Extract<PivotSelection, {
+    kind: 'axisLine' | 'axisEdge';
+}>;
+type PointSelection = Exclude<PivotSelection, AxisSelection>;
+type TransformationRotationAction = Readonly<{
     pivot: PivotSelection;
     angles: Vec3 | number;
 }>;
-type ConstraintSpatialSelection = Readonly<{
-    kind: ConstraintSpatialReference['kind'];
+type TransformationAction = TransformationRotationAction | Readonly<{
+    offset: Vec3;
+}>;
+type TransformationSpatialSelection = Readonly<{
+    kind: RelationSpatialReference['kind'];
     pivot: PivotSelection;
 }>;
 type RelateContext = Readonly<{
-    self: ModelObject;
-    original: ModelObject;
+    self: RelationObject;
+    inheritedPlacements: readonly StoredPlacement[];
 }>;
 /**
  * Start a fresh, serial tooling evaluation without invalidating model geometry.
@@ -278,19 +363,49 @@ type RelateContext = Readonly<{
  * complete results survive cancellation, and cleanup removes the check.
  */
 export declare function beginModelEvaluation(checkCancelled?: () => void): () => void;
+/** Inspectors share the kernel but must retain the model's trace and cache scope. */
+export declare function beginModelInspection(checkCancelled?: () => void): () => void;
 type LocalBounds = readonly [minimum: Vec3, maximum: Vec3];
+type SolveContext = {
+    poses: ReadonlyMap<RelationObject, RigidTransform>;
+    frame: RigidTransform;
+};
 declare const anchorKind: unique symbol;
-declare const modelFamily: unique symbol;
+declare const coordinateFrame: unique symbol;
+declare const modelKind: unique symbol;
 declare const modelNamedElements: unique symbol;
 export interface Anchor<Kind extends ElementKind = ElementKind> {
     readonly [anchorKind]: Kind;
-    /** Translate this geometry's matching bound onto the directed target bound. */
+    /**
+     * Translate this geometry's matching bound onto the directed target bound.
+     * @code3d.inspect on.inspect
+     * @code3d.inspect this on.inspect
+     * @code3d.inspect target on.inspect
+     */
     on(target: Bound): Constraint;
-    /** Align the underlying geometry, retaining unconstrained position and orientation. */
+    /**
+     * Align the underlying geometry, retaining unconstrained position and orientation.
+     * @code3d.inspect align.inspect
+     * @code3d.inspect this align.inspect
+     * @code3d.inspect target align.inspect
+     */
     align(this: Anchor<'point' | 'line' | 'face'>, target: Anchor<'point' | 'line' | 'face'>): Constraint;
+    /**
+     * Coincide origins and all coordinate axes.
+     * @code3d.inspect align.inspect
+     * @code3d.inspect this align.inspect
+     * @code3d.inspect target align.inspect
+     */
+    align(this: FrameAnchor, target: FrameAnchor): Constraint;
 }
 export interface PointAnchor extends Anchor<'point'> {
 }
+/** A coordinate-system reference, independent of model geometry. */
+export interface FrameAnchor extends Anchor<'frame'> {
+    readonly [coordinateFrame]: true;
+    /** The frame's zero-point reference; it has no model geometry. */
+    readonly origin: PointAnchor;
+}
 export interface LineAnchor extends Anchor<'line'> {
     /** Reverse direction without changing geometry or the reference coordinate axes. */
     reverse(): this;
@@ -299,6 +414,8 @@ export interface FaceAnchor extends Anchor<'face'> {
     /** Reverse facing without changing geometry, position, or the reference axes. */
     flip(): this;
 }
+/** Fixed solve-frame direction, or the solved direction of a straight edge/axis. */
+export type DistanceAxis = 'x' | 'y' | 'z' | Vec3 | LineAnchor;
 declare const boundKind: unique symbol;
 export interface Bound extends FaceAnchor {
     readonly [boundKind]: true;
@@ -336,83 +453,125 @@ export interface Solid extends Anchor<'frame'>, GeometryQueryCapabilities, Surfa
 export type ElementSources = Readonly<Record<string, Anchor>>;
 export type NamedElements = Readonly<Record<string, Anchor>>;
 export type ExposedValue<Value> = Value extends {
-    readonly [modelFamily]: infer Family;
+    readonly [modelKind]: infer Kind;
     readonly [modelNamedElements]: infer Elements;
-} ? (Family extends 'solid' ? Solid : Family extends 'face' ? Surface : Family extends 'edge' ? Edge : Family extends 'vertex' ? Vertex : Family extends 'group' ? Anchor<'frame'> : Anchor) & Elements : Value extends Anchor ? Value : never;
+} ? (Kind extends 'solid' ? Solid : Kind extends 'face' ? Surface : Kind extends 'edge' ? Edge : Kind extends 'vertex' ? Vertex : Kind extends 'group' ? Anchor<'frame'> & DirectionalBounds : Anchor) & Elements : Value extends Anchor ? Value : never;
 export type ExposedElements<Sources extends ElementSources> = Readonly<{
     [Name in keyof Sources]: ExposedValue<Sources[Name]>;
 }>;
 export type MergedElements<Existing extends NamedElements, Added extends NamedElements> = Omit<Existing, keyof Added> & Added;
 export type ModelElementKind<Kind extends ModelKind> = Kind extends 'face' ? 'face' : Kind extends 'edge' ? 'line' : Kind extends 'vertex' ? 'point' : 'frame';
-export type ModelFamily = ModelKind | 'model';
-export type ModelFamilyElementKind<Family extends ModelFamily> = Family extends ModelKind ? ModelElementKind<Family> : ElementKind;
-export type ModelForFamily<Elements extends NamedElements, Family extends ModelFamily> = Family extends 'solid' ? SolidModel<Elements> : Family extends 'face' ? FaceModel<Elements> : Family extends 'edge' ? EdgeModel<Elements> : Family extends 'vertex' ? VertexModel<Elements> : Family extends 'group' ? GroupModel<Elements> : Model<Elements>;
-export interface ModelCapabilities<Elements extends NamedElements, Family extends ModelFamily> extends Anchor<ModelFamilyElementKind<Family>>, DirectionalBounds {
-    readonly [modelFamily]: Family extends ModelKind ? Family : ModelKind;
+export type ModelForKind<Elements extends NamedElements, Kind extends ModelKind> = Kind extends 'solid' ? SolidModel<Elements> : Kind extends 'face' ? FaceModel<Elements> : Kind extends 'edge' ? EdgeModel<Elements> : Kind extends 'vertex' ? VertexModel<Elements> : Kind extends 'group' ? GroupModel<Elements> : never;
+/** Tight axis-aligned bounds in the selected model coordinate frame. */
+export type ModelBounds = Readonly<{
+    minimum: Vec3;
+    maximum: Vec3;
+    size: Vec3;
+}>;
+export interface ModelCapabilities<Elements extends NamedElements, Kind extends ModelKind> extends Anchor<ModelElementKind<Kind>>, DirectionalBounds {
+    readonly [modelKind]: Kind;
     readonly [modelNamedElements]: Elements;
-    relate(build: (self: ModelForFamily<Elements, Family>) => Constraint | readonly Constraint[]): ModelForFamily<Elements, Family>;
-    expose<const Sources extends ElementSources>(sources: Sources): ModelForFamily<MergedElements<Elements, ExposedElements<Sources>>, Family>;
+    /** The same reference as frame.origin; not a point model or geometry center. */
+    readonly origin: PointAnchor;
+    /** Reference to the model's local zero and XYZ axes, independent of geometry. */
+    readonly frame: FrameAnchor;
+    /** Measure finite geometry in this model's local frame, or in relativeTo's frame. */
+    bounds(relativeTo?: Model): ModelBounds;
+    /** Model-origin coordinates in relativeTo's local frame, including placement. */
+    position(relativeTo: Model): Vec3;
+    /**
+     * Place a new value represented by callback self; each constraint must involve it.
+     * External model and element references retain their original identity.
+     * @code3d.inspect relate.inspectCall
+     * @code3d.inspect.context build relate.inspectContext
+     * @code3d.inspect.closure build relate.inspectBody
+     */
+    relate(build: (self: ModelForKind<Elements, Kind>) => Relation | readonly Relation[]): ModelForKind<Elements, Kind>;
+    /** @code3d.inspect sources expose.inspectSources */
+    expose<const Sources extends ElementSources>(sources: Sources): ModelForKind<MergedElements<Elements, ExposedElements<Sources>>, Kind>;
     /**
      * Shift the origin by this displacement: every local point becomes p - d.
-     * @code3d.param dx {kind: 'length', label: 'Origin ΔX'}
-     * @code3d.param dy {kind: 'length', label: 'Origin ΔY'}
-     * @code3d.param dz {kind: 'length', label: 'Origin ΔZ'}
+     * @code3d.param dx {kind: 'length', default: 0, label: 'Origin ΔX'}
+     * @code3d.param dy {kind: 'length', default: 0, label: 'Origin ΔY'}
+     * @code3d.param dz {kind: 'length', default: 0, label: 'Origin ΔZ'}
      */
-    originOffset(dx: number, dy: number, dz: number): ModelForFamily<Elements, Family>;
+    originOffset(dx: number, dy: number, dz: number): ModelForKind<Elements, Kind>;
     /** Re-express the model with this point reference at local zero. */
-    originPoint(point: PointAnchor): ModelForFamily<Elements, Family>;
+    originPoint(point: PointAnchor): ModelForKind<Elements, Kind>;
     /**
      * Rotate about the current origin, in degrees, about fixed local X, Y, then Z axes.
-     * @code3d.param x {kind: 'angle', label: 'Rotate X'}
-     * @code3d.param y {kind: 'angle', label: 'Rotate Y'}
-     * @code3d.param z {kind: 'angle', label: 'Rotate Z'}
+     * @code3d.param x {kind: 'angle', default: 0, label: 'Rotate X'}
+     * @code3d.param y {kind: 'angle', default: 0, label: 'Rotate Y'}
+     * @code3d.param z {kind: 'angle', default: 0, label: 'Rotate Z'}
      */
-    rotate(x: number, y: number, z: number): ModelForFamily<Elements, Family>;
+    rotate(x: number, y: number, z: number): ModelForKind<Elements, Kind>;
     /**
      * Return a value with its entire material replaced, including every group descendant.
      * Capture a Three.js material at assignment, or use a CSS color for the default material.
      */
-    material(material: Material | string): ModelForFamily<Elements, Family>;
+    material(material: Material | string): ModelForKind<Elements, Kind>;
 }
-export interface GeometryCapabilities<Elements extends NamedElements, Family extends ModelGeometryKind> extends GeometryQueryCapabilities {
+export interface GeometryCapabilities<Elements extends NamedElements, Kind extends ModelGeometryKind> extends GeometryQueryCapabilities {
     /** Re-express the model with its geometric center at local zero. */
-    originCenter(): ModelForFamily<Elements, Family>;
+    originCenter(): ModelForKind<Elements, Kind>;
     /**
      * Re-express the model with the selected vertex at local zero.
      * @code3d.param id {kind: 'vertex', label: 'Origin vertex'}
      */
-    originVertex(id: VertexId): ModelForFamily<Elements, Family>;
-    /** @code3d.param factor {kind: 'ratio', label: 'Scale'} */
-    scaled(factor: number): ModelForFamily<Elements, Family>;
+    originVertex(id: VertexId): ModelForKind<Elements, Kind>;
+    /** @code3d.param factor {kind: 'ratio', default: 1, label: 'Scale'} */
+    scaled(factor: number): ModelForKind<Elements, Kind>;
 }
 export interface VertexTopologyCapabilities {
-    /** @code3d.param id {kind: 'vertex', label: 'Vertex'} */
+    /**
+     * @code3d.param id {kind: 'vertex', label: 'Vertex'}
+     * @code3d.inspect inspectTopologyReference
+     */
     vertex(id: VertexId): Vertex;
-    /** @code3d.param ids {kind: 'vertex', label: 'Vertices', actions: [{label: 'Use all', action: 'remove-argument'}]} */
+    /**
+     * @code3d.param ids {kind: 'vertex', label: 'Vertices', actions: [{label: 'Use all', action: 'remove-argument'}]}
+     * @code3d.inspect inspectTopologyReference
+     */
     vertices(ids?: readonly VertexId[]): readonly Vertex[];
 }
 export interface EdgeTopologyCapabilities extends VertexTopologyCapabilities {
-    /** @code3d.param id {kind: 'edge', label: 'Edge'} */
+    /**
+     * @code3d.param id {kind: 'edge', label: 'Edge'}
+     * @code3d.inspect inspectTopologyReference
+     */
     edge(id: EdgeId): Edge;
-    /** @code3d.param ids {kind: 'edge', label: 'Edges', actions: [{label: 'Use all', action: 'remove-argument'}]} */
+    /**
+     * @code3d.param ids {kind: 'edge', label: 'Edges', actions: [{label: 'Use all', action: 'remove-argument'}]}
+     * @code3d.inspect inspectTopologyReference
+     */
     edges(ids?: readonly EdgeId[]): readonly Edge[];
 }
 export interface SurfaceTopologyCapabilities extends EdgeTopologyCapabilities {
-    /** @code3d.param id {kind: 'surface', label: 'Surface'} */
+    /**
+     * @code3d.param id {kind: 'surface', label: 'Surface'}
+     * @code3d.inspect inspectTopologyReference
+     */
     surface(id: SurfaceId): Surface;
-    /** @code3d.param ids {kind: 'surface', label: 'Surfaces', actions: [{label: 'Use all', action: 'remove-argument'}]} */
+    /**
+     * @code3d.param ids {kind: 'surface', label: 'Surfaces', actions: [{label: 'Use all', action: 'remove-argument'}]}
+     * @code3d.inspect inspectTopologyReference
+     */
     surfaces(ids?: readonly SurfaceId[]): readonly Surface[];
 }
 export interface SolidModificationCapabilities<Elements extends NamedElements> {
     /** Subtracts all tools in one boolean operation, equivalent to cut(stock, tools). */
+    /**
+     * @code3d.inspect this cut.inspectReceiver
+     * @code3d.inspect tools cut.inspectMethodTools
+     */
     cut(tools: readonly SolidModel<{}>[]): SolidModel;
     /**
-     * @code3d.param radius {kind: 'length', label: 'Fillet radius', constraints: {exclusiveMin: 0}}
+     * @code3d.param radius {kind: 'length', default: 1, label: 'Fillet radius', constraints: {exclusiveMin: 0}}
      * @code3d.param edgeIds {kind: 'edge', actions: [{label: 'Use all', action: 'remove-argument'}]}
      */
     fillet(radius: number, edgeIds?: readonly EdgeId[]): SolidModel<Elements>;
     /**
-     * @code3d.param distance {kind: 'length', label: 'Chamfer distance', constraints: {exclusiveMin: 0}}
+     * @code3d.param distance {kind: 'length', default: 1, label: 'Chamfer distance', constraints: {exclusiveMin: 0}}
      * @code3d.param edgeIds {kind: 'edge', actions: [{label: 'Use all', action: 'remove-argument'}]}
      */
     chamfer(distance: number, edgeIds?: readonly EdgeId[]): SolidModel<Elements>;
@@ -420,12 +579,12 @@ export interface SolidModificationCapabilities<Elements extends NamedElements> {
      * Hollow a solid with uniform walls. Positive thickness offsets inward;
      * negative thickness offsets outward. Selected surfaces become openings.
      * Omit the selection, or use [], for a fully enclosed cavity.
-     * @code3d.param thickness {kind: 'length', label: 'Wall thickness'}
+     * @code3d.param thickness {kind: 'length', default: 1, label: 'Wall thickness'}
      * @code3d.param removedSurfaceIds {kind: 'surface', label: 'Openings', actions: [{label: 'Close all openings', action: 'remove-argument'}]}
      */
     shell(thickness: number, removedSurfaceIds?: readonly SurfaceId[]): SolidModel<Elements>;
 }
-export type Model<Elements extends NamedElements = {}> = ModelCapabilities<Elements, 'model'> & Elements;
+export type Model<Elements extends NamedElements = {}> = ModelCapabilities<Elements, ModelKind> & Elements;
 export type GroupModel<Elements extends NamedElements = {}> = ModelCapabilities<Elements, 'group'> & Elements;
 export type VertexModel<Elements extends NamedElements = {}> = ModelCapabilities<Elements, 'vertex'> & GeometryCapabilities<Elements, 'vertex'> & VertexTopologyCapabilities & Elements;
 export type EdgeModel<Elements extends NamedElements = CurveElements> = ModelCapabilities<Elements, 'edge'> & GeometryCapabilities<Elements, 'edge'> & EdgeTopologyCapabilities & {
@@ -435,7 +594,9 @@ export type FaceModel<Elements extends NamedElements = PlanarElements> = ModelCa
     flip(): Surface;
     /**
      * Extrudes along the face's local plane normal. Signed distance; no recentering.
-     * @code3d.param distance {kind: 'length', label: 'Extrusion distance'}
+     * @code3d.inspect this extrude.inspectMethod
+     * @code3d.inspect distance extrude.inspectMethod
+     * @code3d.param distance {kind: 'length', default: 10, label: 'Extrusion distance'}
      */
     extrude(distance: number): SolidModel;
 } & Elements;
@@ -457,81 +618,204 @@ export type CurveElements = Readonly<{
 export declare function modelElementReference(value: unknown): ModelElementReference | undefined;
 export declare function modelTopologyReference(value: unknown): ModelTopologyReference | undefined;
 export declare function modelTopologyIds(value: unknown, kind: TopologyKind): readonly TopologyId[] | undefined;
-/** Traceable relation values, including unfinished pivot and axis selections. */
-export declare abstract class ConstraintExpression {
-    protected readonly kind: StoredConstraint['kind'];
-    protected readonly source: AnchorReference;
-    protected readonly target: AnchorReference;
-    protected readonly displacement: Vec3 | undefined;
-    protected readonly rotations: readonly ConstraintRotation[];
+/** Snapshot the actual referenced geometry, including an exposed group's parts. */
+export declare function previewAnchorReference(value: unknown, direction?: 'none' | 'forward' | 'both'): Readonly<{
+    model: RelationObject;
+    geometries: readonly ModelObject[];
+    elements: readonly ElementSnapshot[];
+}> | undefined;
+/** Traceable placement values, including unfinished pivot and axis selections. */
+export declare abstract class RelationExpression {
+    protected readonly definition: RelationDefinition;
     protected readonly context: RelateContext | undefined;
-    protected readonly constraintId: string;
-    private get sourceRefs();
-    private get parameters();
-    protected spatialOperation?: ConstraintSpatialSelection;
-    protected constructor(kind: StoredConstraint['kind'], source: AnchorReference, target: AnchorReference, displacement: Vec3 | undefined, rotations: readonly ConstraintRotation[], context: RelateContext | undefined, constraintId: string, previous?: ConstraintExpression);
+    protected readonly relationId: string;
+    protected readonly spatialOperation?: TransformationSpatialSelection | undefined;
+    protected constructor(definition: RelationDefinition, context: RelateContext | undefined, relationId: string, previous?: RelationExpression, spatialOperation?: TransformationSpatialSelection | undefined);
 }
-export declare class Constraint extends ConstraintExpression {
+export declare class Constraint extends RelationExpression {
+    protected readonly definition: Exclude<RelationDefinition, {
+        kind: 'transformation';
+    }>;
     private constructor();
+}
+/** One completed relative placement step. Array order composes transformations. */
+export declare class Transformation extends RelationExpression {
+    protected readonly definition: Extract<RelationDefinition, {
+        kind: 'transformation';
+    }>;
+}
+/** Carries the reference selection until its independent rotation is complete. */
+declare class TransformationRotation extends RelationExpression {
+    constructor();
+    withRotation(pivot: PivotSelection, angles: Vec3 | number, previous: RelationExpression): Transformation;
+}
+export type Relation = Constraint | Transformation;
+export declare class PivotRotation extends RelationExpression {
+    protected readonly chain: TransformationRotation;
+    protected readonly selection: PointSelection;
     /**
-     * In the target reference axes, on() pins matching bound centers; align()
-     * translates self after alignment, retaining the relation's free modes.
-     * Explicit zero pins tangential coordinates for on() only.
-     * @code3d.param x {kind: 'length', label: 'ΔX'}
-     * @code3d.param y {kind: 'length', label: 'ΔY'}
-     * @code3d.param z {kind: 'length', label: 'ΔZ'}
+     * @code3d.inspect relate.inspectRelation
+     * @code3d.param x {kind: 'angle', default: 0, label: 'Rotate X'}
+     * @code3d.param y {kind: 'angle', default: 0, label: 'Rotate Y'}
+     * @code3d.param z {kind: 'angle', default: 0, label: 'Rotate Z'}
      */
-    offset(x: number, y: number, z: number): Constraint;
+    rotate(x: number, y: number, z: number): Transformation;
+}
+export declare class PivotChain extends PivotRotation {
     /**
-     * Select this rotation's pivot in self's local coordinates.
-     * @code3d.param x {kind: 'length', label: 'Pivot X'}
-     * @code3d.param y {kind: 'length', label: 'Pivot Y'}
-     * @code3d.param z {kind: 'length', label: 'Pivot Z'}
+     * Offset the selected pivot along self's local axes, retaining its reference.
+     * @code3d.inspect relate.inspectRelation
+     * @code3d.param x {kind: 'length', default: 0, label: 'Pivot ΔX'}
+     * @code3d.param y {kind: 'length', default: 0, label: 'Pivot ΔY'}
+     * @code3d.param z {kind: 'length', default: 0, label: 'Pivot ΔZ'}
      */
-    pivot([x, y, z]: Vec3): ConstraintPivotChain;
-    /** @code3d.param id {kind: 'vertex', label: 'Pivot vertex'} */
-    pivotVertex(id: VertexId): ConstraintPivotChain;
-    /** Select a positioned axis in the composition. */
-    around(axis: LineAnchor): ConstraintAroundChain;
+    pivotOffset(x: number, y: number, z: number): PivotRotation;
+}
+export declare class AxisRotation extends RelationExpression {
+    protected readonly chain: TransformationRotation;
+    protected readonly selection: AxisSelection;
     /**
-     * Rotate about self's origin and local X, Y, then Z axes, in degrees.
-     * @code3d.param x {kind: 'angle', label: 'Rotate X'}
-     * @code3d.param y {kind: 'angle', label: 'Rotate Y'}
-     * @code3d.param z {kind: 'angle', label: 'Rotate Z'}
+     * @code3d.inspect relate.inspectRelation
+     * @code3d.param angle {kind: 'angle', default: 0, label: 'Rotate'}
      */
-    rotate(x: number, y: number, z: number): Constraint;
+    rotate(angle: number): Transformation;
 }
-export declare class ConstraintPivotChain extends ConstraintExpression {
-    private readonly constraint;
-    private readonly selection;
+export declare class AxisChain extends AxisRotation {
     /**
-     * @code3d.param x {kind: 'angle', label: 'Rotate X'}
-     * @code3d.param y {kind: 'angle', label: 'Rotate Y'}
-     * @code3d.param z {kind: 'angle', label: 'Rotate Z'}
+     * Offset the selected axis in its reference frame, retaining its direction.
+     * @code3d.inspect relate.inspectRelation
+     * @code3d.param x {kind: 'length', default: 0, label: 'Axis ΔX'}
+     * @code3d.param y {kind: 'length', default: 0, label: 'Axis ΔY'}
+     * @code3d.param z {kind: 'length', default: 0, label: 'Axis ΔZ'}
      */
-    rotate(x: number, y: number, z: number): Constraint;
-}
-export declare class ConstraintAroundChain extends ConstraintExpression {
-    private readonly constraint;
-    private readonly selection;
-    /** @code3d.param angle {kind: 'angle', label: 'Rotate'} */
-    rotate(angle: number): Constraint;
+    axisOffset(x: number, y: number, z: number): AxisRotation;
 }
+/**
+ * Move the joint result along the fixed axes of its composition.
+ * @code3d.inspect relate.inspectRelation
+ * @code3d.param x {kind: 'length', default: 0, label: 'ΔX'}
+ * @code3d.param y {kind: 'length', default: 0, label: 'ΔY'}
+ * @code3d.param z {kind: 'length', default: 0, label: 'ΔZ'}
+ */
+export declare function offset(x: number, y: number, z: number): Transformation;
+/**
+ * Rotate about self's current origin and local X, Y, then Z axes.
+ * @code3d.inspect relate.inspectRelation
+ * @code3d.param x {kind: 'angle', default: 0, label: 'Rotate X'}
+ * @code3d.param y {kind: 'angle', default: 0, label: 'Rotate Y'}
+ * @code3d.param z {kind: 'angle', default: 0, label: 'Rotate Z'}
+ */
+export declare function rotate(x: number, y: number, z: number): Transformation;
+/**
+ * Select a pivot in self's local coordinates for the next rotation.
+ * @code3d.inspect relate.inspectRelation
+ * @code3d.param x {kind: 'length', default: 0, label: 'Pivot X'}
+ * @code3d.param y {kind: 'length', default: 0, label: 'Pivot Y'}
+ * @code3d.param z {kind: 'length', default: 0, label: 'Pivot Z'}
+ */
+export declare function pivot([x, y, z]: Vec3): PivotChain;
+/**
+ * @code3d.inspect relate.inspectRelation
+ * @code3d.param id {kind: 'vertex', label: 'Pivot vertex'}
+ */
+export declare function pivotVertex(id: VertexId): PivotChain;
+/**
+ * Select a point reference as the center; rotation axes remain self local.
+ * @code3d.tool
+ * @code3d.inspect relate.inspectRelation
+ */
+export declare function pivotPoint(point: PointAnchor): PivotChain;
+/**
+ * @code3d.inspect relate.inspectRelation
+ * @code3d.param id {kind: 'edge', label: 'Rotation edge'}
+ */
+export declare function axisEdge(id: EdgeId): AxisChain;
+/**
+ * Select a positioned axis in the composition for the next rotation.
+ * @code3d.inspect relate.inspectRelation
+ * @code3d.tool
+ */
+export declare function axisLine(axis: LineAnchor): AxisChain;
 declare const referenceBounds: unique symbol;
 declare const referenceBoundsParts: unique symbol;
 declare const modelSnapshotQueries: unique symbol;
-export declare class ModelObject<Elements extends NamedElements = {}, Kind extends ModelKind = ModelKind> implements Anchor<ModelElementKind<Kind>> {
+type RelationObjectInit = Readonly<{
+    nodeId?: string;
+    placements?: readonly StoredPlacement[];
+    sourceRefs?: readonly SourceRef[];
+    parameters?: readonly ParameterUsage[];
+}>;
+/** A local reference frame and its relations, independent of finite geometry. */
+export declare abstract class RelationObject {
+    readonly nodeId: string;
+    protected placements: StoredPlacement[];
+    protected get initialPose(): RigidTransform;
+    protected get constraints(): StoredConstraint[];
+    protected constructor(init?: RelationObjectInit);
+    get sourceRefs(): SourceRef[];
+    get parameters(): ParameterUsage[];
+    protected abstract copyRelations(init: RelationObjectInit): RelationObject;
+    protected edgeReference(_id: EdgeId): RelationReference;
+    private rotationAxis;
+    private rotationPoint;
+    protected vertexPosition(_id: VertexId): Vec3;
+    /** Store relations only after the complete callback has returned. */
+    protected addRelations(build: () => Relation | readonly Relation[]): readonly RelationObject[];
+    [referenceBounds](reference: StoredAnchor, transform: RigidTransform): LocalBounds;
+    protected alignmentGeometry(reference: StoredAnchor): AlignmentGeometry;
+    solvePose(context: SolveContext): RigidTransform;
+    private bodyActions;
+    private relationSpatial;
+    private placementActions;
+    /** Pose at the end of this segment; later constraints have their own input pose. */
+    private placementStageContext;
+    private followingActions;
+    protected relationStageSnapshots(context: SolveContext): readonly RelationStageSnapshot[] | undefined;
+    protected transformationSnapshots(context: SolveContext): readonly TransformationSnapshot[] | undefined;
+    private followingReferenceFrame;
+    private transformationSnapshot;
+    private transformationOffsetSpatial;
+    static createSolveContext(roots: readonly RelationObject[], overrides?: Map<RelationObject, readonly StoredPlacement[]>): SolveContext;
+    protected constraintSnapshot(constraint: StoredConstraint, context: SolveContext): ConstraintSnapshot;
+}
+/** Plane-only spatial value used by sketches before a B-Rep face exists. */
+export declare class SketchFrame extends RelationObject {
+    private readonly retainedPose?;
+    readonly name = "Sketch";
+    readonly plane: FaceAnchor;
+    private readonly source?;
+    private readonly operation;
+    constructor(source?: SketchFrame, init?: RelationObjectInit, retainedPose?: RigidTransform | undefined);
+    protected get initialPose(): RigidTransform;
+    /** Snapshot the plane's placement without retaining its mutable relation program. */
+    retained(pose: RigidTransform): SketchFrame;
+    protected copyRelations(init: RelationObjectInit): SketchFrame;
+    relatedObjects(): readonly RelationObject[];
+    attachOperationTrace(siteId: string, execution: number, order: number, sourceRef: SourceRef, outputIndex?: number): void;
+    toSnapshot(): ModelSnapshotObject;
+    relate(build: (frame: SketchFrame) => Relation | readonly Relation[]): SketchFrame;
+    face(region: SketchRegion): FaceModel;
+    snapshot(): RelationPreview['object'];
+    /** Related finite models, expressed in this sketch's local editing plane. */
+    context(): readonly Readonly<{
+        nodeId: string;
+        transform: Transform;
+    }>[];
+}
+export declare class ModelObject<Elements extends NamedElements = {}, Kind extends ModelKind = ModelKind> extends RelationObject implements Anchor<ModelElementKind<Kind>> {
+    #private;
     readonly [anchorKind]: ModelElementKind<Kind>;
-    readonly [modelFamily]: Kind;
+    readonly [modelKind]: Kind;
     readonly [modelNamedElements]: Elements;
     private readonly geometry?;
     private readonly assembly?;
     private readonly meshTolerance;
     private readonly geometryAnchor;
     private readonly elements;
-    private constraints;
     private readonly operation;
     private constructor();
+    get origin(): PointAnchor;
+    get frame(): FrameAnchor;
     get up(): Bound;
     get down(): Bound;
     get left(): Bound;
@@ -539,11 +823,24 @@ export declare class ModelObject<Elements extends NamedElements = {}, Kind exten
     get front(): Bound;
     get back(): Bound;
     on(target: Bound): Constraint;
-    align(target: Anchor<'point' | 'line' | 'face'>): Constraint;
+    align(target: Anchor): Constraint;
     reverse(): Edge;
     flip(): Surface;
-    relate(build: (self: RuntimeModel<Elements, Kind>) => Constraint | readonly Constraint[]): RuntimeModel<Elements, Kind>;
+    relate(build: (self: RuntimeModel<Elements, Kind>) => Relation | readonly Relation[]): RuntimeModel<Elements, Kind>;
     expose<const Sources extends ElementSources>(sources: Sources): RuntimeModel<MergedElements<Elements, ExposedElements<Sources>>, Kind>;
+    /**
+     * Measure finite geometry in this model's local frame, or in relativeTo's frame.
+     * An explicit reference includes solved placement and nested group occurrences.
+     * Empty groups have no finite bounds.
+     */
+    bounds(relativeTo?: Model): ModelBounds;
+    /**
+     * Model-origin coordinates in relativeTo's local frame, including placement.
+     * This model's origin in its own frame is always [0, 0, 0], even for point models.
+     */
+    position(relativeTo: Model): Vec3;
+    /** Resolve source frames without losing nested occurrence positions. */
+    private localFrames;
     /** Resolve both own and occurrence references into this model's local frame. */
     private localElements;
     vertex(id: VertexId): Vertex;
@@ -571,22 +868,28 @@ export declare class ModelObject<Elements extends NamedElements = {}, Kind exten
     private snapshotNode;
     private evaluateBoolean;
     private allParameters;
-    private solvePose;
     private memberPoses;
+    /** Finite members in this value's saved local assembly, without re-solving children. */
+    private geometryParts;
+    private static readonly inspectionSources;
+    private static readonly inspectionFrames;
+    /** Retain identities across focus changes; the call owns the saved frame's lifetime. */
+    private static inspectionFrame;
+    private static readonly dimensionSegments;
+    private static recordCompositionInspection;
     /** Bounds of the selected finite geometry after a rigid transform. */
     private [referenceBoundsParts];
     /** Bounds of the selected finite geometry after a rigid transform. */
     [referenceBounds](reference: StoredAnchor, transform: RigidTransform): LocalBounds;
     /** Pure query collection: it never substitutes geometry or runs author code. */
     [modelSnapshotQueries](): SnapshotQueryInput[];
-    private alignmentGeometry;
-    private relationElement;
-    private bodyRotations;
-    private constraintSpatial;
-    /** Fix the assembly frame once, using only its direct member origins. */
+    protected alignmentGeometry(reference: StoredAnchor): AlignmentGeometry;
+    previewElement(reference: StoredAnchor, direction?: 'forward' | 'both'): ElementSnapshot;
+    protected edgeReference(id: EdgeId): RelationReference;
+    protected vertexPosition(id: VertexId): Vec3;
+    protected copyRelations(init: RelationObjectInit): ModelObject;
+    /** Fix the assembly frame once in the first member's solved local coordinates. */
     private static createAssembly;
-    private static createSolveContext;
-    private constraintSnapshot;
     private requireGeometry;
     private requireSolidGeometry;
     private operationSnapshot;
@@ -639,8 +942,15 @@ export type LoftOptions = Readonly<{
     spine?: EdgeModel<{}>;
     ruled?: boolean;
 }>;
+/**
+ * @code3d.inspect sections loft.inspectSections
+ * @code3d.inspect spine loft.inspectSpine
+ */
 export declare function loft(sections: readonly FaceModel<{}>[], { spine, ruled }?: LoftOptions): SolidModel;
 /**
+ * @code3d.inspect x box.inspectDimension
+ * @code3d.inspect y box.inspectDimension
+ * @code3d.inspect z box.inspectDimension
  * @code3d.param x {kind: 'length', default: 10, constraints: {exclusiveMin: 0}}
  * @code3d.param y {kind: 'length', default: 10, constraints: {exclusiveMin: 0}}
  * @code3d.param z {kind: 'length', default: 10, constraints: {exclusiveMin: 0}}
@@ -684,24 +994,63 @@ export declare function frustum(bottomRadius: number, topRadius: number, y: numb
  * @code3d.param rotation {kind: 'angle', default: 0}
  */
 export declare function regularPrism(radius: number, y: number, sides: number, rotation?: number): SolidModel;
+/** Compose members in the first member's local frame; empty groups use the default frame. */
+/** @code3d.inspect children group.inspectChildren */
 export declare function group(children: readonly Model[], name?: string): GroupModel;
+/**
+ * Measure finite models, topology, bounds or point references in their solved placement.
+ * Without axis, returns the shortest geometric distance. With axis, returns the
+ * gap between projected intervals (zero when they overlap). The result is a
+ * non-negative number computed now; later relations do not update it.
+ * @code3d.inspect distance.inspect
+ * @code3d.inspect a distance.inspect
+ * @code3d.inspect b distance.inspect
+ * @code3d.inspect axis distance.inspect
+ */
+export declare function distance(a: Anchor, b: Anchor, axis?: DistanceAxis): number;
+/** @code3d.inspect operands union.inspectOperands */
 export declare function union(operands: readonly SolidModel<{}>[]): SolidModel;
 /**
- * Extrudes a single face; use faces.map(face => extrude(face, distance)) for multiple regions.
- * @code3d.param distance {kind: 'length', label: 'Extrusion distance'}
+ * Extrudes each face independently, preserving array order and placement.
+ * @code3d.inspect face extrude.inspectFaces
+ * @code3d.inspect distance extrude.inspectFaces
+ * @code3d.param distance {kind: 'length', default: 10, label: 'Extrusion distance'}
  */
 export declare function extrude(face: FaceModel<{}>, distance: number): SolidModel;
+/**
+ * Extrudes each face independently.
+ * @code3d.inspect faces extrude.inspectFaces
+ * @code3d.inspect distance extrude.inspectFaces
+ * @code3d.param distance {kind: 'length', default: 10, label: 'Extrusion distance'}
+ */
+export declare function extrude(faces: readonly FaceModel<{}>[], distance: number): readonly SolidModel[];
+/**
+ * Creates connected text faces on the XZ plane: +X right, -Z up, normal +Y.
+ * All faces share the baseline origin. Size is the font em in model units.
+ * @code3d.param size {kind: 'length', label: 'Text size'}
+ */
+export declare function text(content: string, font: Font, size: number, options?: TextOptions): readonly FaceModel[];
+/**
+ * @code3d.inspect stock cut.inspectStock
+ * @code3d.inspect tools cut.inspectTools
+ */
 export declare function cut(stock: SolidModel<{}>, tools: readonly SolidModel<{}>[]): SolidModel;
+/** @code3d.inspect operands intersect.inspectOperands */
 export declare function intersect(operands: readonly SolidModel<{}>[]): SolidModel;
 export declare function isModelObject(value: unknown): value is ModelObject;
+export declare function isSolidModel(value: unknown): value is SolidModel<{}>;
 export declare function isConstraint(value: unknown): value is Constraint;
-export declare function isConstraintExpression(value: unknown): value is ConstraintExpression;
-export declare function constraintPreview(value: ConstraintExpression): ConstraintPreview | undefined;
-export declare function instrumentConstraint(constraint: ConstraintExpression, sourceRef: SourceRef, parameters: readonly ParameterUsage[]): void;
-export declare function instrumentModelOperation(object: ModelObject, instrumentation: ModelOperationInstrumentation): void;
-export declare function constraintTraceReference(constraint: ConstraintExpression): ConstraintTraceReference;
-export declare function modelObjectRuntimeInfo(object: ModelObject): ModelObjectRuntimeInfo;
-export declare function relatedModelObjects(object: ModelObject): readonly ModelObject[];
+export declare function isRelationExpression(value: unknown): value is RelationExpression;
+export declare function relationPreview(value: RelationExpression, preceding?: readonly RelationExpression[]): RelationPreview | undefined;
+/** The current authoring receiver remains available when a free selector throws. */
+export declare function currentRelationSelf(): RelationObject | undefined;
+/** Preview an insertion/selector prefix, retaining only placements inherited by its callback. */
+export declare function relationSelectionPreview(self: RelationObject, preceding: readonly RelationExpression[], context?: RelationExpression): RelationPreview;
+export declare function instrumentRelation(constraint: RelationExpression, sourceRef: SourceRef, parameters: readonly ParameterUsage[]): void;
+export declare function instrumentModelOperation(object: RelationObject, instrumentation: ModelOperationInstrumentation): void;
+export declare function relationTraceReference(constraint: RelationExpression): RelationTraceReference;
+export declare function modelObjectRuntimeInfo(object: RelationObject): ModelObjectRuntimeInfo;
+export declare function relatedModelObjects(object: RelationObject): readonly RelationObject[];
 export type SnapshotQuery = Readonly<{
     key: KernelOperationKey;
 }> & (Readonly<{
@@ -730,13 +1079,13 @@ export type SnapshotQueryBatch = Readonly<{
     weight: number;
     sourceRef?: SourceRef;
     encode(): Uint8Array;
-    accept(query: SnapshotQuery, value: SnapshotQueryResult): void;
+    accept(query: SnapshotQuery, value: SnapshotQueryResult, milliseconds: number): void;
 }>;
-export declare function planModelSnapshotQueries(objects: readonly ModelObject[]): SnapshotQueryBatch[];
+export declare function planModelSnapshotQueries(objects: readonly RelationObject[]): SnapshotQueryBatch[];
 /** Each batch owns its restored shape; completed results leave before cancellation checks. */
-export declare function executeSnapshotQueryBatch(id: string, bytes: Uint8Array, queries: readonly SnapshotQuery[], checkCancelled: () => void, onResult: (query: SnapshotQuery, value: SnapshotQueryResult) => void, onRestore?: (milliseconds: number) => void): void;
-export declare function createModelSnapshotter(): (object: ModelObject) => ModelSnapshotObject;
-export declare function disposeModelObjects(objects: Iterable<ModelObject>): void;
+export declare function executeSnapshotQueryBatch(id: string, bytes: Uint8Array, queries: readonly SnapshotQuery[], checkCancelled: () => void, onResult: (query: SnapshotQuery, value: SnapshotQueryResult, milliseconds: number) => void, onRestore?: (milliseconds: number) => void): void;
+export declare function createModelSnapshotter(): (object: RelationObject) => ModelSnapshotObject;
+export declare function disposeModelObjects(objects: Iterable<RelationObject>): void;
 /** Worker-owned native geometry, independent of the author's object lifetime. */
 export type ModelGeometrySnapshot = Readonly<{
     /** Borrowed shapes; clone before passing them to consuming operations. */
@@ -744,8 +1093,23 @@ export type ModelGeometrySnapshot = Readonly<{
     inspect(nodeId: string, options?: TopologyInspectionOptions): TopologyInspection;
     dispose(): void;
 }>;
-export declare function retainModelGeometry(objects: Iterable<ModelObject>): ModelGeometrySnapshot;
+export declare function retainModelGeometry(objects: Iterable<RelationObject>): ModelGeometrySnapshot;
 export declare const authoringApi: Readonly<{
+    dimension: typeof dimension;
+    boundsAnnotation: typeof boundsAnnotation;
+    anchorAnnotation: typeof anchorAnnotation;
+    captureInspectData: typeof captureInspectData;
+    offset: typeof offset;
+    rotate: typeof rotate;
+    pivot: typeof pivot;
+    pivotVertex: typeof pivotVertex;
+    pivotPoint: typeof pivotPoint;
+    axisEdge: typeof axisEdge;
+    axisLine: typeof axisLine;
+    cache: typeof cache;
+    font: typeof font;
+    googleFont: typeof googleFont;
+    text: typeof text;
     sketch: typeof sketch;
     circle: typeof circle;
     ellipse: typeof ellipse;
@@ -766,10 +1130,9 @@ export declare const authoringApi: Readonly<{
     frustum: typeof frustum;
     regularPrism: typeof regularPrism;
     group: typeof group;
+    distance: typeof distance;
     union: typeof union;
     cut: typeof cut;
     intersect: typeof intersect;
 }>;
-/** Internal bridge from the kernel-independent sketch definition to model geometry. */
-export declare function sketchFaceModel(region: SketchRegion): FaceModel;
 //# sourceMappingURL=runtime.d.ts.map