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

package/src/library/runtime.ts

@@ -1,18 +1,11 @@
-import type {Material} from './three.js';
-import {captureModelMaterial, type ModelMaterialSnapshot} from './material.js';
-import {
-  inspectShapeTopology,
-  type TopologyInspection,
-  type TopologyInspectionOptions,
-} from './topology-inspection.js';
 import {
   assembleWire,
   basicFaceExtrusion,
   BoundingBox,
   genericSweep,
   getOC,
-  makeBSplineApproximation,
   makeBezierCurve,
+  makeBSplineApproximation,
   makeCircle,
   makeCylinder,
   makeFace,
@@ -30,9 +23,26 @@ import {
   type Edge as ReplicadEdge,
   type Face as ReplicadFace,
   type Vertex as ReplicadVertex,
-  type Shape3D,
   type Wire as ReplicadWire,
+  type Shape3D,
 } from 'replicad';
+import {
+  edgeGeometry,
+  faceGeometry,
+  transformGeometry,
+  type AlignmentGeometry,
+} from './alignment-geometry.js';
+import {cached, cachedArtifact} from './cached.js';
+import {extrudeWithTopology} from './extrude.js';
+import {font, googleFont, type Font} from './font.js';
+import {
+  beginKernelOperationEvaluation,
+  kernelOperationKey,
+  type KernelArtifact,
+  type KernelKeyPart,
+  type KernelOperationKey,
+  type KernelValueLifecycle,
+} from './kernel-cache.js';
 import {
   castOwnedShape,
   castOwnedShape3D,
@@ -40,17 +50,29 @@ import {
   shapeSubshapes,
   transformShape,
 } from './kernel-shapes.js';
+import {loftWithTopology} from './loft.js';
+import {captureModelMaterial, type ModelMaterialSnapshot} from './material.js';
+import {
+  axisRotation,
+  solveBodies,
+  type Body,
+  type BodyRotation,
+} from './relation-solver.js';
+import {estimateRetainedBytes} from './retained-memory.js';
+import {shellWithTopology} from './shell.js';
+import {sketchRegionFace} from './sketch-face.js';
+import type {SketchRegion} from './sketch-regions.js';
 import {
   addVectors,
   composeTransforms,
   frameFromYAxis,
   identityRigidTransform,
   invertTransform,
-  rotateVector,
-  origin,
   negateVector,
+  origin,
   quaternionAxisAngle,
   relativeTransform,
+  rotateVector,
   rotation,
   rotationAround,
   translation,
@@ -58,36 +80,14 @@ import {
   type RigidTransform,
   type Vec3,
 } from './spatial.js';
-import {
-  axisRotation,
-  solveBodies,
-  type Body,
-  type BodyRotation,
-} from './relation-solver.js';
-import {
-  edgeGeometry,
-  faceGeometry,
-  transformGeometry,
-  type AlignmentGeometry,
-} from './alignment-geometry.js';
-import {shellWithTopology} from './shell.js';
-import {
-  beginKernelOperationEvaluation,
-  evaluateKernelOperation,
-  kernelOperationKey,
-  findKernelOperation,
-  acceptKernelOperation,
-  type KernelOperationKey,
-  type KernelArtifact,
-  type KernelKeyPart,
-  type KernelValueLifecycle,
-} from './kernel-cache.js';
-import {loftWithTopology} from './loft.js';
-import {estimateRetainedBytes} from './retained-memory.js';
-import {extrudeWithTopology} from './extrude.js';
-import {sketchRegionFace} from './sketch-face.js';
-import type {SketchRegion} from './sketch-regions.js';
+import {textGlyphs, textRegionFace, type TextOptions} from './text.js';
+import type {Material} from 'three';
 import {formatTopologyId, type TopologyId} from './topology-id.js';
+import {
+  inspectShapeTopology,
+  type TopologyInspection,
+  type TopologyInspectionOptions,
+} from './topology-inspection.js';
 import {
   booleanWithTopology,
   chamferEdges,
@@ -99,10 +99,10 @@ import {
   stableEdgeGroups,
   stableSurfaceGroups,
   stableVertexData,
+  topologyChildren,
   topologyEdgeDirections,
   topologySurfaceDirections,
   topologyVertexPoints,
-  topologyChildren,
   withTopologyShape,
   type EdgeId,
   type ShapeTopology,
@@ -112,11 +112,11 @@ import {
   type VertexId,
 } from './topology.js';
 
-import {sketch} from './sketch.js';
 import {
-  encodeKernelArtifact,
   decodeKernelArtifact,
+  encodeKernelArtifact,
 } from './kernel-artifact-codec.js';
+import {sketch} from './sketch.js';
 
 export type {Quaternion, Vec3} from './spatial.js';
 export type {EdgeId, SurfaceId, TopologyKind, VertexId} from './topology.js';
@@ -195,6 +195,7 @@ export type ConstraintSnapshot = Readonly<{
   );
 
 export type ModelOperationKind =
+  | 'sketch'
   | 'box'
   | 'cylinder'
   | 'tube'
@@ -213,6 +214,7 @@ export type ModelOperationKind =
   | 'spline'
   | 'loft'
   | 'sketchFace'
+  | 'text'
   | 'extrude'
   | 'primitive'
   | 'material'
@@ -337,7 +339,6 @@ export type RenderMesh = Readonly<{
 
 export type ModelSnapshotObject = Readonly<{
   nodeId: string;
-  kind: ModelKind;
   name: string;
   /** Effective material, including recursive overrides from enclosing groups. */
   material?: ModelMaterialSnapshot;
@@ -352,8 +353,11 @@ export type ModelSnapshotObject = Readonly<{
   sourceRefs: readonly SourceRef[];
   parameters: readonly ParameterUsage[];
   operation: ModelOperationSnapshot;
-  mesh?: RenderMesh;
-}>;
+}> &
+  (
+    | Readonly<{kind: ModelKind; mesh?: RenderMesh}>
+    | Readonly<{kind: 'reference'; mesh?: never}>
+  );
 
 type StoredElement = Readonly<{
   kind: ElementKind;
@@ -377,10 +381,10 @@ type StoredElements = Readonly<Record<string, StoredElement>>;
 
 type StoredAnchor = StoredElement & Readonly<{name: string}>;
 
-type AnchorReference = StoredAnchor & Readonly<{model: ModelObject}>;
+type AnchorReference = StoredAnchor & Readonly<{model: RelationObject}>;
 
 export type ModelElementReference = Readonly<{
-  model: ModelObject;
+  model: RelationObject;
   name: string;
   kind: ElementKind;
   transform: Transform;
@@ -390,7 +394,7 @@ export type ModelElementReference = Readonly<{
 }>;
 
 export type ModelTopologyReference = Readonly<{
-  model: ModelObject;
+  model: RelationObject;
   geometry: ModelObject;
   transform: Transform;
 }> &
@@ -398,14 +402,16 @@ export type ModelTopologyReference = Readonly<{
 
 export type ConstraintTraceReference = Readonly<{
   constraintId: string;
-  source: ModelObject;
-  target: ModelObject;
-  self?: ModelObject;
+  source: RelationObject;
+  target: RelationObject;
+  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[];
@@ -427,7 +433,7 @@ type StoredConstraint = Readonly<{
 }>;
 
 // An omitted model refers to relate's self, including after immutable copies.
-type RelationReference = StoredAnchor & Readonly<{model?: ModelObject}>;
+type RelationReference = StoredAnchor & Readonly<{model?: RelationObject}>;
 type PivotSelection =
   | Readonly<{kind: 'pivot'; point: Vec3}>
   | Readonly<{kind: 'pivotVertex'; id: VertexId}>
@@ -440,11 +446,11 @@ type ConstraintSpatialSelection = Readonly<{
   kind: ConstraintSpatialReference['kind'];
   pivot: PivotSelection;
 }>;
-type RelateContext = Readonly<{self: ModelObject; original: ModelObject}>;
+type RelateContext = Readonly<{self: RelationObject; original: RelationObject}>;
 let activeRelate: RelateContext | undefined;
 
 type StoredOperationInput = Readonly<{
-  model: ModelObject;
+  model: RelationObject;
   role: ModelOperationInputRole;
   index: number;
 }>;
@@ -551,7 +557,7 @@ type SolidGeometry = KernelArtifact<
 >;
 
 type SolveContext = {
-  poses: ReadonlyMap<ModelObject, RigidTransform>;
+  poses: ReadonlyMap<RelationObject, RigidTransform>;
 };
 
 function transformSolveContext(
@@ -593,7 +599,7 @@ const defaultModelNames = {
 
 const anchorKind = Symbol('anchorKind');
 const anchorReferenceValue = Symbol('anchorReference');
-const modelFamily = Symbol('modelFamily');
+const modelKind = Symbol('modelKind');
 const modelNamedElements = Symbol('modelNamedElements');
 
 export interface Anchor<Kind extends ElementKind = ElementKind> {
@@ -671,18 +677,18 @@ 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'
+  ? (Kind extends 'solid'
       ? Solid
-      : Family extends 'face'
+      : Kind extends 'face'
         ? Surface
-        : Family extends 'edge'
+        : Kind extends 'edge'
           ? Edge
-          : Family extends 'vertex'
+          : Kind extends 'vertex'
             ? Vertex
-            : Family extends 'group'
+            : Kind extends 'group'
               ? Anchor<'frame'>
               : Anchor) &
       Elements
@@ -707,81 +713,76 @@ export type ModelElementKind<Kind extends ModelKind> = Kind extends 'face'
       ? 'point'
       : 'frame';
 
-export type ModelFamily = ModelKind | 'model';
-
-export type ModelFamilyElementKind<Family extends ModelFamily> =
-  Family extends ModelKind ? ModelElementKind<Family> : ElementKind;
-
-export type ModelForFamily<
+export type ModelForKind<
   Elements extends NamedElements,
-  Family extends ModelFamily,
-> = Family extends 'solid'
+  Kind extends ModelKind,
+> = Kind extends 'solid'
   ? SolidModel<Elements>
-  : Family extends 'face'
+  : Kind extends 'face'
     ? FaceModel<Elements>
-    : Family extends 'edge'
+    : Kind extends 'edge'
       ? EdgeModel<Elements>
-      : Family extends 'vertex'
+      : Kind extends 'vertex'
         ? VertexModel<Elements>
-        : Family extends 'group'
+        : Kind extends 'group'
           ? GroupModel<Elements>
-          : Model<Elements>;
+          : never;
 
 export interface ModelCapabilities<
   Elements extends NamedElements,
-  Family extends ModelFamily,
+  Kind extends ModelKind,
 >
-  extends Anchor<ModelFamilyElementKind<Family>>, DirectionalBounds {
-  readonly [modelFamily]: Family extends ModelKind ? Family : ModelKind;
+  extends Anchor<ModelElementKind<Kind>>, DirectionalBounds {
+  readonly [modelKind]: Kind;
   readonly [modelNamedElements]: Elements;
   relate(
     build: (
-      self: ModelForFamily<Elements, Family>,
+      self: ModelForKind<Elements, Kind>,
     ) => Constraint | readonly Constraint[],
-  ): ModelForFamily<Elements, Family>;
+  ): ModelForKind<Elements, Kind>;
   expose<const Sources extends ElementSources>(
     sources: Sources,
-  ): ModelForFamily<MergedElements<Elements, ExposedElements<Sources>>, Family>;
+  ): 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>;
+  ): 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,
+  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 {
@@ -809,12 +810,12 @@ export interface SolidModificationCapabilities<Elements extends NamedElements> {
   /** Subtracts all tools in one boolean operation, equivalent to cut(stock, tools). */
   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>;
@@ -822,7 +823,7 @@ 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(
@@ -833,7 +834,7 @@ export interface SolidModificationCapabilities<Elements extends NamedElements> {
 
 export type Model<Elements extends NamedElements = {}> = ModelCapabilities<
   Elements,
-  'model'
+  ModelKind
 > &
   Elements;
 
@@ -861,7 +862,7 @@ export type FaceModel<Elements extends NamedElements = PlanarElements> =
       flip(): Surface;
       /**
        * Extrudes along the face's local plane normal. Signed distance; no recentering.
-       * @code3d.param distance {kind: 'length', label: 'Extrusion distance'}
+       * @code3d.param distance {kind: 'length', default: 10, label: 'Extrusion distance'}
        */
       extrude(distance: number): SolidModel;
     } & Elements;
@@ -1127,7 +1128,9 @@ export function modelTopologyIds(
     : value instanceof ConstraintExpression
       ? value.self()
       : topology?.source;
-  const geometry = source?.[modelGeometry]()?.value;
+  const geometry = isModelObject(source)
+    ? source[modelGeometry]()?.value
+    : undefined;
   if (!geometry) return undefined;
   return topologyChildren(
     geometry.shape,
@@ -1179,12 +1182,12 @@ export abstract class ConstraintExpression {
     appendUniqueParameters(this.parameters, parameters);
   }
   /** @internal */
-  self(): ModelObject | undefined {
+  self(): RelationObject | undefined {
     return this.context?.self;
   }
   /** @internal */
   traceReference(): ConstraintTraceReference {
-    const rebind = (model: ModelObject) =>
+    const rebind = (model: RelationObject) =>
       model === this.context?.original ? this.context.self : model;
     return {
       constraintId: this.constraintId,
@@ -1194,8 +1197,8 @@ export abstract class ConstraintExpression {
     };
   }
   /** @internal */
-  storeFor(model: ModelObject, original: ModelObject): StoredConstraint {
-    const isSelf = (candidate: ModelObject | undefined) =>
+  storeFor(model: RelationObject, original: RelationObject): StoredConstraint {
+    const isSelf = (candidate: RelationObject | undefined) =>
       candidate === model || candidate === original;
     if (!isSelf(this.source.model) && !isSelf(this.target.model))
       throw new Error(
@@ -1296,11 +1299,12 @@ export class Constraint extends ConstraintExpression {
    * 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.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'}
    */
-  offset(x: number, y: number, z: number): Constraint {
+  offset(x: number, y: number, z: number): Constraint;
+  offset(x = 0, y = 0, z = 0): Constraint {
     assertFiniteVector('offset', [x, y, z]);
     return new Constraint(
       this.kind,
@@ -1315,11 +1319,12 @@ export class Constraint extends ConstraintExpression {
   }
   /**
    * 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'}
+   * @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 {
+  pivot([x, y, z]: Vec3): ConstraintPivotChain;
+  pivot([x = 0, y = 0, z = 0]: Vec3 = [0, 0, 0]): ConstraintPivotChain {
     assertFiniteVector('pivot', [x, y, z]);
     return new ConstraintPivotChain(this, {kind: 'pivot', point: [x, y, z]});
   }
@@ -1334,7 +1339,9 @@ export class Constraint extends ConstraintExpression {
       throw new Error('around() requires an axis or straight edge.');
     const geometry =
       reference.topology?.source[modelGeometry]()?.value ??
-      (reference.whole ? reference.model[modelGeometry]()?.value : undefined);
+      (reference.whole && isModelObject(reference.model)
+        ? reference.model[modelGeometry]()?.value
+        : undefined);
     if (geometry) {
       const straight = reference.topology
         ? withTopologyShape(
@@ -1353,11 +1360,12 @@ export class Constraint extends ConstraintExpression {
   }
   /**
    * 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.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): Constraint {
+  rotate(x: number, y: number, z: number): Constraint;
+  rotate(x = 0, y = 0, z = 0): Constraint {
     return this.withRotation({kind: 'pivot', point: origin}, [x, y, z], this);
   }
   /** @internal */
@@ -1416,11 +1424,12 @@ export class ConstraintPivotChain extends ConstraintExpression {
     this.spatialOperation = {kind: selection.kind, pivot: selection};
   }
   /**
-   * @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): Constraint {
+  rotate(x: number, y: number, z: number): Constraint;
+  rotate(x = 0, y = 0, z = 0): Constraint {
     return this.constraint.withRotation(this.selection, [x, y, z], this);
   }
 }
@@ -1433,8 +1442,9 @@ export class ConstraintAroundChain extends ConstraintExpression {
     super(...constraint.chainArguments());
     this.spatialOperation = {kind: selection.kind, pivot: selection};
   }
-  /** @code3d.param angle {kind: 'angle', label: 'Rotate'} */
-  rotate(angle: number): Constraint {
+  /** @code3d.param angle {kind: 'angle', default: 0, label: 'Rotate'} */
+  rotate(angle: number): Constraint;
+  rotate(angle = 0): Constraint {
     return this.constraint.withRotation(this.selection, angle, this);
   }
 }
@@ -1445,173 +1455,70 @@ const referenceBoundsParts = Symbol('referenceBoundsParts');
 const modelSnapshotQueries = Symbol('modelSnapshotQueries');
 const relationPreview = Symbol('relationPreview');
 
-export class ModelObject<
-  Elements extends NamedElements = {},
-  Kind extends ModelKind = ModelKind,
-> implements Anchor<ModelElementKind<Kind>> {
-  declare readonly [anchorKind]: ModelElementKind<Kind>;
-  declare readonly [modelFamily]: Kind;
-  declare readonly [modelNamedElements]: Elements;
-  /** @internal */
-  readonly elementKind: ModelElementKind<Kind>;
-  /** @internal */
-  readonly nodeId: string;
-  /** @internal */
-  readonly kind: Kind;
-  /** @internal */
-  readonly name: string;
-  /** @internal */
-  private readonly materialSnapshot?: ModelMaterialSnapshot;
-  /** @internal */
-  readonly children: readonly ModelObject[];
-  /** @internal */
-  get sourceRefs(): SourceRef[] {
-    return valueTrace(this).sourceRefs;
-  }
-  /** @internal */
-  get parameters(): ParameterUsage[] {
-    return valueTrace(this).parameters;
-  }
-  private readonly geometry?: ModelGeometry;
-  private readonly assembly?: SolveContext;
-  private readonly meshTolerance: number;
-  private readonly geometryAnchor: StoredElement;
-  private readonly elements: StoredElements;
-  private constraints: StoredConstraint[];
-  private readonly operation: StoredOperation;
+type RelationObjectInit = Readonly<{
+  nodeId?: string;
+  constraints?: readonly StoredConstraint[];
+  sourceRefs?: readonly SourceRef[];
+  parameters?: readonly ParameterUsage[];
+}>;
 
+/** A local reference frame and its relations, independent of finite geometry. */
+export abstract class RelationObject {
+  readonly nodeId: string;
   /** @internal */
-  [modelGeometry](): ModelGeometry | undefined {
-    return this.geometry;
-  }
+  abstract readonly name: string;
+  protected constraints: StoredConstraint[];
 
-  private constructor(init: ModelObjectInit<Kind>) {
-    if (init.kind !== 'group' && !init.geometry) {
-      throw new Error(
-        'A geometric model object must contain an OpenCascade shape.',
-      );
-    }
+  protected constructor(init: RelationObjectInit = {}) {
     this.nodeId = init.nodeId ?? `node-${nextNodeId++}`;
-    this.kind = init.kind;
-    this.elementKind = modelElementKinds[
-      init.kind
-    ] as unknown as ModelElementKind<Kind>;
-    this.geometry = init.geometry;
-    this.geometryAnchor = init.geometryAnchor ?? {
-      kind: this.elementKind,
-      transform: identityRigidTransform,
-    };
-    this.meshTolerance = init.meshTolerance ?? 0.2;
-    this.name = init.name ?? defaultModelNames[init.kind];
-    this.materialSnapshot = init.material;
-    this.children = init.children ?? [];
-    this.assembly =
-      init.assembly ??
-      (this.kind === 'group'
-        ? ModelObject.createAssembly(this.children)
-        : undefined);
     this.constraints = [...(init.constraints ?? [])];
     valueTraces.set(this, {
       sourceRefs: [...(init.sourceRefs ?? [])],
       parameters: [...(init.parameters ?? [])],
     });
-    this.operation = init.operation;
-    const elements =
-      init.elements ??
-      (this.kind === 'solid' && this.geometry
-        ? solidElements(this.geometry.value.localBounds)
-        : {});
-    this.elements = this.geometry
-      ? {
-          center: {
-            kind: 'point',
-            transform: translation(
-              boundsCenter(this.geometry.value.localBounds),
-            ),
-          },
-          ...elements,
-        }
-      : elements;
-    for (const [name, element] of Object.entries(this.elements)) {
-      if (name in this) {
-        throw new Error(
-          `The element name ${name} conflicts with the model API.`,
-        );
-      }
-      Object.defineProperty(this, name, {
-        value: modelAnchor(this, name, element),
-      });
-    }
-  }
-
-  /** @internal */
-  static create<
-    Elements extends NamedElements = {},
-    Kind extends ModelKind = ModelKind,
-  >(init: ModelObjectInit<Kind>): ModelObject<Elements, Kind> {
-    return new ModelObject<Elements, Kind>(init);
   }
 
-  get up(): Bound {
-    return directionalBound(this.relationAnchorReference(), 'up');
-  }
-  get down(): Bound {
-    return directionalBound(this.relationAnchorReference(), 'down');
-  }
-  get left(): Bound {
-    return directionalBound(this.relationAnchorReference(), 'left');
-  }
-  get right(): Bound {
-    return directionalBound(this.relationAnchorReference(), 'right');
-  }
-  get front(): Bound {
-    return directionalBound(this.relationAnchorReference(), 'front');
-  }
-  get back(): Bound {
-    return directionalBound(this.relationAnchorReference(), 'back');
+  get sourceRefs(): SourceRef[] {
+    return valueTrace(this).sourceRefs;
   }
 
-  on(target: Bound): Constraint {
-    return Constraint.create(
-      this.relationAnchorReference(),
-      boundReference(target),
-    );
+  get parameters(): ParameterUsage[] {
+    return valueTrace(this).parameters;
   }
 
-  /** @internal */
-  relationAnchorReference(): AnchorReference {
-    return {model: this, name: 'geometry', ...this.geometryAnchor, whole: true};
-  }
+  protected abstract copyRelations(init: RelationObjectInit): RelationObject;
 
-  align(target: Anchor<'point' | 'line' | 'face'>): Constraint {
-    return Constraint.create(
-      this.relationAnchorReference(),
-      anchorReference(target),
-      'align',
+  protected vertexPosition(_id: VertexId): Vec3 {
+    throw new Error(
+      'pivotVertex() requires model topology, not a sketch reference frame. Use pivot([x, y, z]) instead.',
     );
   }
 
-  reverse(): Edge {
-    return this.edges()[0].reverse();
-  }
-  flip(): Surface {
-    return this.surfaces()[0].flip();
-  }
-
-  relate(
-    build: (
-      self: RuntimeModel<Elements, Kind>,
-    ) => Constraint | readonly Constraint[],
-  ): RuntimeModel<Elements, Kind> {
-    const operation = storedOperation('relate', [
-      {model: this, role: 'source', index: 0},
-    ]);
-    const related = this.copy({}, operation);
+  /** @internal */
+  abstract relatedObjects(): readonly RelationObject[];
+  /** @internal */
+  abstract toSnapshot(
+    meshCache?: Map<AnyShape, RenderMesh>,
+  ): ModelSnapshotObject;
+  /** @internal */
+  abstract attachOperationTrace(
+    siteId: string,
+    execution: number,
+    order: number,
+    sourceRef: SourceRef,
+    outputIndex?: number,
+  ): void;
+
+  /** Store relations only after the complete callback has returned. */
+  protected addRelations(
+    original: RelationObject,
+    build: () => Constraint | readonly Constraint[],
+  ): readonly RelationObject[] {
     const previous = activeRelate;
-    activeRelate = {self: related, original: this};
+    activeRelate = {self: this, original};
     let built: Constraint | readonly Constraint[];
     try {
-      built = build(related);
+      built = build();
     } finally {
       activeRelate = previous;
     }
@@ -1623,1459 +1530,1787 @@ export class ModelObject<
         throw new Error(
           'relate() requires a completed Constraint; finish pivot/around with rotate().',
         );
-      return constraint.storeFor(related, this);
+      return constraint.storeFor(this, original);
     });
-    related.constraints.push(...stored);
-    operation.inputs.push(
-      ...uniqueModels(stored.flatMap(constraintReferences)).map(
-        (model, index) => ({
-          model,
-          role: 'reference' as const,
-          index,
-        }),
-      ),
-    );
-    return related;
+    this.constraints.push(...stored);
+    return uniqueModels(stored.flatMap(constraintReferences));
   }
 
-  expose<const Sources extends ElementSources>(
-    sources: Sources,
-  ): RuntimeModel<MergedElements<Elements, ExposedElements<Sources>>, Kind> {
-    const entries = Object.entries(sources);
-    const elements = this.localElements(entries.map(([, source]) => source));
-    const exposed = Object.fromEntries(
-      entries.map(([name], index) => [name, elements[index]]),
-    );
-    const references = entries.map(
-      ([, source]) => anchorReference(source).model,
+  [referenceBounds](
+    reference: StoredAnchor,
+    transform: RigidTransform,
+  ): LocalBounds {
+    if (reference.bound) {
+      const frame = composeTransforms(transform, reference.transform);
+      const [x, z] = reference.bound.size;
+      return pointBounds(
+        [-1, 1].flatMap(a =>
+          [-1, 1].map(
+            b =>
+              composeTransforms(
+                frame,
+                translation([(a * x) / 2, 0, (b * z) / 2]),
+              ).position,
+          ),
+        ),
+      );
+    }
+    if (reference.kind === 'point') {
+      const point = composeTransforms(transform, reference.transform).position;
+      return [point, point];
+    }
+    throw new Error(
+      `The reference ${reference.name} has no finite geometry. Select a model, vertex, edge, or surface for on().`,
     );
-    const operation = storedOperation('expose', [
-      {model: this, role: 'source', index: 0},
-      ...uniqueModels(references)
-        .filter(model => model !== this)
-        .map((model, index) => ({
-          model,
-          role: 'reference' as const,
-          index,
-        })),
-    ]);
-    return this.copy(
-      {elements: {...this.elements, ...exposed}},
-      operation,
-    ) as unknown as RuntimeModel<
-      MergedElements<Elements, ExposedElements<Sources>>,
-      Kind
-    >;
   }
 
-  /** Resolve both own and occurrence references into this model's local frame. */
-  private localElements(sources: readonly Anchor[]): StoredElement[] {
-    const members = this.memberPoses();
-    const external = sources
-      .map(source => anchorReference(source).model)
-      .filter(model => !members.has(model));
-    const context = external.length
-      ? ModelObject.createSolveContext([this, ...external])
-      : undefined;
-    return sources.map(source => {
-      const reference = anchorReference(source);
-      const {
-        kind,
-        transform: frame,
-        topology,
-        members: nested,
-        bound,
-        facing,
-      } = source instanceof ModelObject ? source.exposedElement() : reference;
-      const memberPose = members.get(reference.model);
-      if (memberPose === null)
-        throw new Error(
-          "The point or element belongs to multiple occurrences. Expose it through the intended child model's named reference.",
-        );
-      const transform =
-        memberPose ??
-        relativeTransform(
-          reference.model.solvePose(context!),
-          this.solvePose(context!),
-        );
-      return transformElement(
-        {kind, transform: frame, topology, members: nested, bound, facing},
-        transform,
-      );
-    });
+  protected alignmentGeometry(reference: StoredAnchor): AlignmentGeometry {
+    if (reference.kind === 'point')
+      return {kind: 'point', point: reference.transform.position};
+    const direction = rotateVector(
+      [
+        0,
+        reference.kind === 'line'
+          ? (reference.direction ?? 1)
+          : (reference.facing ?? reference.bound?.facing ?? 1),
+        0,
+      ],
+      reference.transform.quaternion,
+    );
+    return reference.kind === 'line'
+      ? {kind: 'line', point: reference.transform.position, direction}
+      : {kind: 'plane', point: reference.transform.position, normal: direction};
   }
 
-  vertex(id: VertexId): Vertex {
-    return this.vertices([id])[0];
-  }
-  vertices(ids?: readonly VertexId[]): readonly Vertex[] {
-    return this.selectTopology('vertex', ids) as unknown as readonly Vertex[];
-  }
-  edge(id: EdgeId): Edge {
-    return this.edges([id])[0];
-  }
-  edges(ids?: readonly EdgeId[]): readonly Edge[] {
-    return this.selectTopology('edge', ids) as unknown as readonly Edge[];
-  }
-  surface(id: SurfaceId): Surface {
-    return this.surfaces([id])[0];
+  /** @internal */
+  attachSource(sourceRef: SourceRef): void {
+    const previous = this.sourceRefs.at(-1);
+    if (
+      previous?.file !== sourceRef.file ||
+      previous.start !== sourceRef.start ||
+      previous.end !== sourceRef.end
+    ) {
+      this.sourceRefs.push(sourceRef);
+    }
   }
-  surfaces(ids?: readonly SurfaceId[]): readonly Surface[] {
-    return this.selectTopology('surface', ids) as unknown as readonly Surface[];
+
+  /** @internal */
+  attachParameters(parameters: readonly ParameterUsage[]): void {
+    appendUniqueParameters(this.parameters, parameters);
   }
 
-  private selectTopology(
-    kind: TopologyKind,
-    ids?: readonly TopologyId[],
-  ): readonly ModelTopologyElement[] {
-    const geometry = this.requireGeometry().value;
-    const selected = topologyChildren(
-      geometry.shape,
-      geometry.topology,
-      {kind: 'solid'},
-      kind,
-      ids,
-    );
-    return topologyReferences(
-      this,
-      '',
-      {source: this, transform: identityRigidTransform, scale: 1},
-      kind,
-      selected,
-    );
+  solvePose(context: SolveContext): RigidTransform {
+    return context.poses.get(this)!;
   }
 
-  /** @internal */
-  exposedElement(): StoredElement {
-    if (this.kind === 'group')
-      return {...this.geometryAnchor, members: this.elements};
-    const geometry = this.requireGeometry().value;
-    const kind = (
-      this.kind === 'face' ? 'surface' : this.kind
-    ) as TopologySelection['kind'];
-    const selection: TopologySelection =
-      kind === 'solid'
-        ? {kind}
-        : {
-            kind,
-            id: geometry.topology[
-              kind === 'surface'
-                ? 'surfaces'
-                : kind === 'edge'
-                  ? 'edges'
-                  : 'vertices'
-            ].ids[0],
-          };
-    const context = {
-      source: this,
-      transform: identityRigidTransform,
-      scale: 1,
-    };
-    const anchor =
-      selection.kind === 'solid'
-        ? this.geometryAnchor
-        : topologyReferences(this, '', context, selection.kind, [
-            selection.id,
-          ])[0][anchorReferenceValue];
+  protected relationElement(reference: StoredAnchor): ElementSnapshot {
+    const element = reference;
+    const topology = element.topology;
+    let arrow: RigidTransform | undefined;
+    if (reference.kind === 'line' && topology) {
+      const geometry = topology.source[modelGeometry]()!.value;
+      arrow = withTopologyShape(
+        geometry.shape,
+        geometry.topology,
+        topology.selection,
+        shape => {
+          const edge = shape as ReplicadEdge;
+          const position = (reference.direction ?? 1) === 1 ? 1 : 0;
+          const point = edge.pointAt(position),
+            tangent = edge.tangentAt(position);
+          try {
+            return topologyTransform(
+              topology,
+              frameFromYAxis(
+                point.toTuple(),
+                tangent
+                  .toTuple()
+                  .map(v => v * (reference.direction ?? 1)) as unknown as Vec3,
+              ),
+            );
+          } finally {
+            point.delete();
+            tangent.delete();
+          }
+        },
+      );
+    }
     return {
-      kind: anchor.kind,
-      transform: anchor.transform,
-      members: this.elements,
-      topology: {
-        ...context,
-        selection,
-      },
+      ...snapshotElements({[reference.name]: element})[0],
+      arrow,
     };
   }
 
-  material(material: Material | string): RuntimeModel<Elements, Kind> {
-    return this.copy(
-      {material: captureModelMaterial(material)},
-      storedOperation('material', [{model: this, role: 'source', index: 0}]),
-    );
-  }
-
-  originOffset(
-    dx: number,
-    dy: number,
-    dz: number,
-  ): RuntimeModel<Elements, Kind> {
-    const offset: Vec3 = [dx, dy, dz];
-    assertFiniteVector('originOffset', offset);
-    return this.withOrigin(offset, {kind: 'originOffset'});
+  private bodyRotations(
+    constraint: StoredConstraint,
+    indices: Map<RelationObject, number>,
+  ): BodyRotation[] {
+    return constraint.rotations.map(({pivot, angles}) => {
+      if (pivot.kind === 'around') {
+        return pivot.axis.model
+          ? {
+              body: indices.get(pivot.axis.model)!,
+              axis: pivot.axis.transform,
+              angle: (angles as number) * (pivot.axis.direction ?? 1),
+            }
+          : {
+              local: axisRotation(
+                pivot.axis.transform,
+                (angles as number) * (pivot.axis.direction ?? 1),
+              ),
+            };
+      }
+      const frame = translation(
+        pivot.kind === 'pivot' ? pivot.point : this.vertexPosition(pivot.id),
+      );
+      return {
+        local: composeTransforms(
+          composeTransforms(frame, rotationAround(origin, angles as Vec3)),
+          invertTransform(frame),
+        ),
+      };
+    });
   }
 
-  originPoint(point: PointAnchor): RuntimeModel<Elements, Kind> {
-    const reference = anchorReference(point);
-    if (reference.kind !== 'point')
-      throw new Error('originPoint() requires a point reference.');
-    const [element] = this.localElements([point]);
-    return this.withOrigin(element.transform.position, {
-      kind: 'originPoint',
-      model: reference.model,
+  /** @internal */
+  [relationPreview](
+    nodeId: string,
+    constraint: StoredConstraint,
+    selection: ConstraintSpatialSelection | undefined,
+  ): ConstraintPreview {
+    // This expression starts from the relate receiver, before sibling constraints
+    // are returned and committed to self. Geometry and node identity stay shared.
+    const owner = this.copyRelations({
+      nodeId,
+      constraints: [...this.constraints, constraint],
     });
+    const context = RelationObject.createSolveContext([
+      owner,
+      ...(selection?.pivot.kind === 'around' && selection.pivot.axis.model
+        ? [selection.pivot.axis.model]
+        : []),
+    ]);
+    return {
+      object: {
+        nodeId,
+        compositionTransform: toTransform(owner.solvePose(context)),
+        constraints: owner.constraints.map(value =>
+          owner.constraintSnapshot(value, context),
+        ),
+      },
+      spatial: selection
+        ? owner.constraintSpatial(constraint, selection, context)
+        : undefined,
+    };
   }
 
-  originVertex(id: VertexId): RuntimeModel<Elements, Kind> {
-    const geometry = this.requireGeometry().value;
-    const [{position}] = topologyVertexPoints(
-      geometry.shape,
-      geometry.topology.vertices,
-      [id],
+  private constraintSpatial(
+    constraint: StoredConstraint,
+    selection: ConstraintSpatialSelection,
+    context: SolveContext,
+  ): ConstraintSpatialReference {
+    const models = [...context.poses.keys()];
+    const actions = this.bodyRotations(
+      constraint,
+      new Map(models.map((model, i) => [model, i])),
     );
-    return this.withOrigin(position, {kind: 'originVertex', id});
-  }
-
-  originCenter(): RuntimeModel<Elements, Kind> {
-    this.requireGeometry();
-    const position = this.elements.center.transform.position;
-    return this.withOrigin(position, {kind: 'originCenter'});
-  }
-
-  private withOrigin(
-    offset: Vec3,
-    selection:
-      | {kind: 'originOffset' | 'originCenter'}
-      | {kind: 'originVertex'; id: VertexId}
-      | {kind: 'originPoint'; model: ModelObject},
-  ): RuntimeModel<Elements, Kind> {
-    const transform = translation(negateVector(offset));
-    const operation = storedOperation(selection.kind, [
-      {model: this, role: 'source', index: 0},
-    ]);
-    if (selection.kind === 'originPoint' && selection.model !== this)
-      operation.inputs.push({
-        model: selection.model,
-        role: 'reference',
-        index: 0,
-      });
-    operation.spatial = {origin, vector: offset};
-    if (selection.kind === 'originVertex') {
-      operation.selections.push({
-        kind: 'vertex',
-        input: this,
-        ids: [selection.id],
-        transform,
-      });
+    const stage = actions.length - (selection.kind === 'rotate' ? 1 : 0);
+    const finalPose = this.solvePose(context);
+    let before = finalPose;
+    for (let i = actions.length - 1; i >= stage; i--) {
+      const action = actions[i];
+      before =
+        'local' in action
+          ? composeTransforms(before, invertTransform(action.local))
+          : composeTransforms(
+              axisRotation(
+                composeTransforms(
+                  models[action.body].solvePose(context),
+                  action.axis,
+                ),
+                -action.angle,
+              ),
+              before,
+            );
     }
-    return this.transformed(transform, operation);
-  }
-
-  rotate(x: number, y: number, z: number): RuntimeModel<Elements, Kind> {
-    const angles: Vec3 = [x, y, z];
-    assertFiniteVector('rotate', angles);
-    const operation = storedOperation('rotate', [
-      {model: this, role: 'source', index: 0},
-    ]);
-    operation.spatial = {origin, vector: angles};
-    return this.transformed(rotationAround(origin, angles), operation);
+    const pivot = selection.pivot;
+    let frame: RigidTransform;
+    if (pivot.kind === 'around') {
+      frame = composeTransforms(
+        pivot.axis.model ? pivot.axis.model.solvePose(context) : before,
+        (pivot.axis.direction ?? 1) === 1
+          ? pivot.axis.transform
+          : composeTransforms(pivot.axis.transform, rotation([1, 0, 0, 0])),
+      );
+    } else {
+      const local = translation(
+        pivot.kind === 'pivot' ? pivot.point : this.vertexPosition(pivot.id),
+      );
+      frame = composeTransforms(before, local);
+    }
+    const angles = constraint.rotations[stage]?.angles ?? origin;
+    const rotationVector: Vec3 =
+      typeof angles === 'number' ? [0, angles, 0] : angles;
+    const localFrame = relativeTransform(frame, finalPose);
+    return {
+      nodeId: this.nodeId,
+      kind: selection.kind,
+      spatial: {
+        origin: localFrame.position,
+        vector:
+          selection.kind === 'rotate'
+            ? rotationVector
+            : pivot.kind === 'pivot'
+              ? pivot.point
+              : origin,
+        frame: localFrame,
+        rotation: rotationVector,
+        axisOnly: pivot.kind === 'around',
+      },
+    };
   }
 
-  private transformed(
-    transform: RigidTransform,
-    operation: StoredOperation,
-  ): RuntimeModel<Elements, Kind> {
-    const overrides: Partial<ModelObjectInit<Kind>> = {
-      geometryAnchor: transformElement(this.geometryAnchor, transform),
-      elements: Object.fromEntries(
-        Object.entries(this.elements).map(([name, element]) => [
-          name,
-          transformElement(element, transform),
-        ]),
-      ),
-      constraints: this.mapConstraintGeometry(
-        element => transformElement(element, transform),
-        point => composeTransforms(transform, translation(point)).position,
-      ),
+  static createSolveContext(roots: readonly RelationObject[]): SolveContext {
+    const models: RelationObject[] = [];
+    const indices = new Map<RelationObject, number>();
+    const collect = (model: RelationObject): void => {
+      if (indices.has(model)) return;
+      indices.set(model, models.length);
+      models.push(model);
+      model.constraints.flatMap(constraintReferences).forEach(collect);
     };
-    if (this.assembly)
-      return this.copy(
-        {
-          ...overrides,
-          assembly: transformSolveContext(this.assembly, transform),
-        },
-        operation,
-      );
-    const source = this.requireGeometry();
-    const geometry = evaluateModelGeometry(
-      'transform',
-      [transform.position, transform.quaternion],
-      [source],
-      () => {
-        const shape = shapeWithTransform(source.value.shape, transform);
-        try {
-          return {
-            shape,
-            topology: preserveShapeTopology(shape, source.value.topology),
-            referenceBasis: transformedReferenceBasis(source, transform, 1),
-          };
-        } catch (error) {
-          shape.delete();
-          throw error;
-        }
-      },
+    roots.forEach(collect);
+    const poses = solveBodies(
+      models.map((model): Body => ({
+        name: model.name,
+        relations: model.constraints.map(constraint =>
+          constraint.kind === 'align'
+            ? {
+                kind: 'align',
+                id: constraint.id,
+                source: {
+                  body: indices.get(constraint.source.model ?? model)!,
+                  geometry: (
+                    constraint.source.model ?? model
+                  ).alignmentGeometry(constraint.source),
+                  transform: constraint.source.transform,
+                },
+                target: {
+                  body: indices.get(constraint.target.model ?? model)!,
+                  geometry: (
+                    constraint.target.model ?? model
+                  ).alignmentGeometry(constraint.target),
+                  transform: constraint.target.transform,
+                },
+                offset: constraint.offset,
+                rotations: model.bodyRotations(constraint, indices),
+              }
+            : {
+                kind: 'on',
+                id: constraint.id,
+                source: {
+                  body: indices.get(constraint.source.model ?? model)!,
+                  key: constraint.source.name,
+                  bounds: (orientation: Quaternion) =>
+                    (constraint.source.model ?? model)[referenceBounds](
+                      constraint.source,
+                      rotation(orientation),
+                    ),
+                },
+                target: {
+                  body: indices.get(constraint.target.model ?? model)!,
+                  transform: constraint.target.transform,
+                  facing: constraint.target.bound!.facing,
+                },
+                offset: constraint.offset,
+                rotations: model.bodyRotations(constraint, indices),
+              },
+        ),
+      })),
     );
-    return this.copyWithGeometry(geometry, overrides, operation);
+    return {
+      poses: new Map(models.map((model, index) => [model, poses[index]])),
+    };
   }
 
-  private mapConstraintGeometry(
-    mapElement: (element: StoredElement) => StoredElement,
-    mapPoint: (point: Vec3) => Vec3,
-  ): StoredConstraint[] {
-    const mapReference = (reference: RelationReference): RelationReference =>
-      reference.model ? reference : {...reference, ...mapElement(reference)};
-    return this.constraints.map(constraint => {
-      const mapped: StoredConstraint = {
-        ...constraint,
-        source: mapReference(constraint.source),
-        target: mapReference(constraint.target),
-        rotations: constraint.rotations.map(action => ({
-          ...action,
-          pivot:
-            action.pivot.kind === 'around'
-              ? {...action.pivot, axis: mapReference(action.pivot.axis)}
-              : action.pivot.kind === 'pivot'
-                ? {...action.pivot, point: mapPoint(action.pivot.point)}
-                : action.pivot,
-        })),
+  protected constraintSnapshot(
+    constraint: StoredConstraint,
+    context: SolveContext,
+  ): ConstraintSnapshot {
+    const source = constraint.source.model ?? this;
+    const target = constraint.target.model ?? this;
+    const models = [...context.poses.keys()];
+    const actions = this.bodyRotations(
+      constraint,
+      new Map(models.map((model, i) => [model, i])),
+    );
+    let before = this.solvePose(context);
+    for (const action of [...actions].reverse()) {
+      before =
+        'local' in action
+          ? composeTransforms(before, invertTransform(action.local))
+          : composeTransforms(
+              axisRotation(
+                composeTransforms(
+                  models[action.body].solvePose(context),
+                  action.axis,
+                ),
+                -action.angle,
+              ),
+              before,
+            );
+    }
+    const sourcePose = source === this ? before : source.solvePose(context);
+    const targetPose = target === this ? before : target.solvePose(context);
+    let offsetFrame = composeTransforms(
+      targetPose,
+      constraint.target.transform,
+    );
+    if (constraint.kind === 'align') {
+      for (const action of actions)
+        if ('body' in action)
+          offsetFrame = composeTransforms(
+            axisRotation(
+              composeTransforms(
+                models[action.body].solvePose(context),
+                action.axis,
+              ),
+              action.angle,
+            ),
+            offsetFrame,
+          );
+      return {
+        id: constraint.id,
+        kind: 'align',
+        source: anchorSnapshot(source, constraint.source),
+        target: anchorSnapshot(target, constraint.target),
+        sourceElement: source.relationElement(constraint.source),
+        targetElement: target.relationElement(constraint.target),
+        offsetDirection: 1,
+        offset: constraint.offset ?? origin,
+        offsetFrame: toTransform(offsetFrame),
+        sourceRefs: [...valueTrace(constraint).sourceRefs],
+        parameters: [...valueTrace(constraint).parameters],
       };
-      valueTraces.set(mapped, valueTrace(constraint));
-      return mapped;
-    });
-  }
-
-  scaled(factor: number): RuntimeModel<Elements, Kind> {
-    assertPositive('scale', factor);
-    const source = this.requireGeometry();
-    const geometry = evaluateModelGeometry('scaled', [factor], [source], () => {
-      const shape = shapeWithScale(source.value.shape, factor);
-      try {
-        return {
-          shape,
-          topology: preserveShapeTopology(shape, source.value.topology),
-          referenceBasis: transformedReferenceBasis(
-            source,
-            identityRigidTransform,
-            factor,
-          ),
-        };
-      } catch (error) {
-        shape.delete();
-        throw error;
-      }
-    });
-    return this.copyWithGeometry(
-      geometry,
+    }
+    const orientation = composeTransforms(
+      invertTransform(rotation(offsetFrame.quaternion)),
+      rotation(sourcePose.quaternion),
+    ).quaternion;
+    const bounds = source[referenceBounds](
+      constraint.source,
+      rotation(orientation),
+    );
+    const center: Vec3 = [
+      (bounds[0][0] + bounds[1][0]) / 2,
+      bounds[constraint.target.bound!.facing === 1 ? 0 : 1][1],
+      (bounds[0][2] + bounds[1][2]) / 2,
+    ];
+    const sourceFrame = relativeTransform(
       {
-        geometryAnchor: scaleElement(this.geometryAnchor, factor),
-        elements: scaleElements(this.elements, factor),
-        constraints: this.mapConstraintGeometry(
-          element => scaleElement(element, factor),
-          point => scaleFrame(translation(point), factor).position,
+        position: addVectors(
+          sourcePose.position,
+          rotateVector(center, offsetFrame.quaternion),
         ),
+        quaternion: offsetFrame.quaternion,
       },
-      storedOperation('scaled', [{model: this, role: 'source', index: 0}]),
-    );
-  }
-
-  extrude(this: ModelObject<Elements, 'face'>, distance: number): SolidModel {
-    if (this.kind !== 'face')
-      throw new Error('extrude requires a single face model.');
-    if (!Number.isFinite(distance) || distance === 0)
-      throw new Error('Extrusion distance must be finite and non-zero.');
-    const source = this.requireGeometry();
-    const direction = rotateVector(
-      [0, distance, 0],
-      this.geometryAnchor.transform.quaternion,
+      sourcePose,
     );
-    const geometry = evaluateSolidGeometry(
-      'extrude',
-      [direction],
-      [source],
-      () =>
-        extrudeWithTopology(
-          {
-            shape: source.value.shape,
-            topology: source.value.topology,
-            index: 1,
-          },
-          direction,
+    const sourceSize: Vec3 = [
+      bounds[1][0] - bounds[0][0],
+      bounds[1][1] - bounds[0][1],
+      bounds[1][2] - bounds[0][2],
+    ];
+    for (const action of actions) {
+      if ('body' in action)
+        offsetFrame = composeTransforms(
+          axisRotation(
+            composeTransforms(
+              models[action.body].solvePose(context),
+              action.axis,
+            ),
+            action.angle,
+          ),
+          offsetFrame,
+        );
+    }
+    return {
+      id: constraint.id,
+      kind: constraint.kind,
+      source: anchorSnapshot(source, constraint.source),
+      target: anchorSnapshot(target, constraint.target),
+      sourceBounds: {
+        size: sourceSize,
+        transform: toTransform(
+          composeTransforms(sourceFrame, {
+            position: [
+              0,
+              (constraint.target.bound!.facing * sourceSize[1]) / 2,
+              0,
+            ],
+            quaternion: [0, 0, 0, 1],
+          }),
         ),
-    );
-    return ModelObject.create<CanonicalElements, 'solid'>({
-      kind: 'solid',
-      name: 'Extrude',
-      geometry,
-      material: this.materialSnapshot,
-      constraints: this.constraints,
-      sourceRefs: this.sourceRefs,
-      parameters: this.allParameters(),
-      meshTolerance: this.meshTolerance,
-      operation: storedOperation(
-        'extrude',
-        [{model: this, role: 'receiver', index: 0}],
-        {
-          dimensions: {
-            distance: {
-              origin: this.elements.center.transform.position,
-              vector: direction,
-            },
-          },
+      },
+      sourceElement: {
+        name: `${constraint.source.name}:bound`,
+        kind: 'face',
+        transform: toTransform(sourceFrame),
+        bound: {
+          size: [sourceSize[0], sourceSize[2]],
+          facing: constraint.target.bound!.facing === 1 ? -1 : 1,
         },
-      ),
-    }) as unknown as SolidModel;
+      },
+      targetElement: {
+        name: constraint.target.name,
+        kind: 'face',
+        transform: toTransform(constraint.target.transform),
+        bound: constraint.target.bound,
+      },
+      offsetDirection: source === this ? 1 : -1,
+      offset: constraint.offset ?? origin,
+      offsetFrame: toTransform(offsetFrame),
+      sourceRefs: [...valueTrace(constraint).sourceRefs],
+      parameters: [...valueTrace(constraint).parameters],
+    };
   }
+}
 
-  cut(
-    this: ModelObject<Elements, 'solid'>,
-    tools: readonly SolidModel<{}>[],
-  ): SolidModel {
-    return cut(this as unknown as SolidModel<{}>, tools);
+/** Plane-only spatial value used by sketches before a B-Rep face exists. */
+export class SketchFrame extends RelationObject {
+  readonly name = 'Sketch';
+  readonly plane: FaceAnchor;
+  private readonly source?: SketchFrame;
+  private readonly operation = storedOperation('sketch');
+
+  constructor(source?: SketchFrame, init: RelationObjectInit = {}) {
+    super({
+      constraints: source?.constraints,
+      sourceRefs: source?.sourceRefs,
+      parameters: source?.parameters,
+      ...init,
+    });
+    this.source = source;
+    this.plane = modelAnchor(this, 'plane', {
+      kind: 'face',
+      transform: identityRigidTransform,
+    }) as FaceAnchor;
   }
 
-  fillet(
-    this: ModelObject<Elements, 'solid'>,
-    radius: number,
-    edgeIds?: readonly EdgeId[],
-  ): SolidModel<Elements> {
-    assertPositive('radius', radius);
-    const source = this.requireSolidGeometry();
-    const selectedEdgeIds = resolveEdgeSelection(
-      source.value.topology.edges,
-      edgeIds,
-    );
-    const geometry = evaluateSolidGeometry(
-      'fillet',
-      [radius, selectedEdgeIds],
-      [source],
-      () => {
-        const result = filletEdges(
-          source.value.shape,
-          source.value.topology,
-          radius,
-          selectedEdgeIds,
-        );
-        return {shape: result.shape, topology: result.topology};
-      },
-    );
-    return this.copyWithGeometry(
-      geometry,
-      {},
-      storedOperation('fillet', [{model: this, role: 'source', index: 0}], {
-        selections: [
-          {
-            kind: 'edge',
-            input: this,
-            ids: selectedEdgeIds,
-            transform: identityRigidTransform,
-          },
-        ],
-      }),
-    ) as unknown as SolidModel<Elements>;
-  }
-
-  chamfer(
-    this: ModelObject<Elements, 'solid'>,
-    distance: number,
-    edgeIds?: readonly EdgeId[],
-  ): SolidModel<Elements> {
-    assertPositive('distance', distance);
-    const source = this.requireSolidGeometry();
-    const selectedEdgeIds = resolveEdgeSelection(
-      source.value.topology.edges,
-      edgeIds,
-    );
-    const geometry = evaluateSolidGeometry(
-      'chamfer',
-      [distance, selectedEdgeIds],
-      [source],
-      () => {
-        const result = chamferEdges(
-          source.value.shape,
-          source.value.topology,
-          distance,
-          selectedEdgeIds,
-        );
-        return {shape: result.shape, topology: result.topology};
-      },
-    );
-    return this.copyWithGeometry(
-      geometry,
-      {},
-      storedOperation('chamfer', [{model: this, role: 'source', index: 0}], {
-        selections: [
-          {
-            kind: 'edge',
-            input: this,
-            ids: selectedEdgeIds,
-            transform: identityRigidTransform,
-          },
-        ],
-      }),
-    ) as unknown as SolidModel<Elements>;
-  }
-
-  shell(
-    this: ModelObject<Elements, 'solid'>,
-    thickness: number,
-    removedSurfaceIds: readonly SurfaceId[] = [],
-  ): SolidModel<Elements> {
-    if (!Number.isFinite(thickness) || thickness === 0) {
-      throw new Error('thickness must be a nonzero finite number.');
-    }
-    const source = this.requireSolidGeometry();
-    const selectedIds = resolveTopologySelection(
-      'surface',
-      source.value.topology.surfaces,
-      removedSurfaceIds,
-    );
-    const geometry = evaluateSolidGeometry(
-      'shell',
-      [thickness, selectedIds],
-      [source],
-      () =>
-        shellWithTopology(
-          source.value.shape,
-          source.value.topology,
-          thickness,
-          selectedIds,
-        ),
-    );
-    return this.copyWithGeometry(
-      geometry,
-      {},
-      storedOperation('shell', [{model: this, role: 'source', index: 0}], {
-        selections: [
-          {
-            kind: 'surface',
-            input: this,
-            ids: selectedIds,
-            transform: identityRigidTransform,
-          },
-        ],
-      }),
-    ) as unknown as SolidModel<Elements>;
-  }
-
-  /** @internal */
-  attachSource(sourceRef: SourceRef): void {
-    const previous = this.sourceRefs.at(-1);
-    if (
-      previous?.file !== sourceRef.file ||
-      previous.start !== sourceRef.start ||
-      previous.end !== sourceRef.end
-    ) {
-      this.sourceRefs.push(sourceRef);
-    }
+  protected copyRelations(init: RelationObjectInit): SketchFrame {
+    return new SketchFrame(this, init);
   }
 
-  /** @internal */
-  attachParameters(parameters: readonly ParameterUsage[]): void {
-    appendUniqueParameters(this.parameters, parameters);
+  relatedObjects(): readonly RelationObject[] {
+    return [
+      ...(this.source ? [this.source] : []),
+      ...this.constraints.flatMap(constraintReferences),
+    ];
   }
 
-  /** @internal */
   attachOperationTrace(
     siteId: string,
     execution: number,
     order: number,
     sourceRef: SourceRef,
+    outputIndex = 0,
   ): void {
-    if (operationTraces.has(this.operation)) {
-      return;
-    }
-    operationTraces.set(this.operation, {siteId, execution, order, sourceRef});
-  }
-
-  /** @internal */
-  relatedObjects(): readonly ModelObject[] {
-    return [
-      ...this.children,
-      ...this.operation.inputs.map(input => input.model),
-      ...this.constraints.flatMap(constraintReferences),
-    ];
-  }
-
-  /** @internal */
-  toSnapshot(
-    meshCache: Map<AnyShape, RenderMesh> = new Map(),
-  ): ModelSnapshotObject {
-    const solveContext = ModelObject.createSolveContext([this]);
-    return this.snapshotNode(meshCache, solveContext);
+    if (!operationTraces.has(this.operation))
+      operationTraces.set(this.operation, {
+        siteId,
+        execution,
+        order,
+        sourceRef,
+        outputIndex,
+      });
   }
 
-  private snapshotNode(
-    meshCache: Map<AnyShape, RenderMesh>,
-    solveContext: SolveContext,
-    inComposition = false,
-    overrideMaterial?: ModelMaterialSnapshot,
-  ): ModelSnapshotObject {
-    const material = overrideMaterial ?? this.materialSnapshot;
-    const pose = this.solvePose(solveContext);
-    const constraints = this.constraints.map(constraint =>
-      this.constraintSnapshot(constraint, solveContext),
-    );
-    const parameters = uniqueParameters([
-      ...this.parameters,
-      ...this.constraints.flatMap(
-        constraint => valueTrace(constraint).parameters,
-      ),
-    ]);
-    const common = {
-      nodeId: this.nodeId,
-      kind: this.kind,
+  toSnapshot(): ModelSnapshotObject {
+    const {siteId, execution, order, sourceRef} =
+      operationTraces.get(this.operation) ?? {};
+    return {
+      ...this.snapshot(),
+      kind: 'reference',
       name: this.name,
-      material,
-      compositionTransform: toTransform(pose),
-      transform: toTransform(inComposition ? pose : identityRigidTransform),
-      constraints,
-      origin,
+      children: [],
+      transform: toTransform(identityRigidTransform),
       elements: snapshotElements({
-        ...this.elements,
-        ...(this.geometry || this.children.length
-          ? Object.fromEntries(
-              Object.keys(boundDirections).map(direction => [
-                direction,
-                anchorReference(this[direction as keyof DirectionalBounds]),
-              ]),
-            )
-          : {}),
+        plane: {kind: 'face', transform: identityRigidTransform},
       }),
+      origin,
       sourceRefs: [...this.sourceRefs],
-      parameters,
-      operation: this.operationSnapshot(meshCache),
-    } as const;
+      parameters: [...this.parameters],
+      operation: {
+        id: storedOperationId(this.operation),
+        siteId,
+        execution,
+        order,
+        sourceRef,
+        kind: 'sketch',
+        outputNodeId: this.nodeId,
+        inputs: this.relatedObjects().map((model, index) => ({
+          nodeId: model.nodeId,
+          role: 'reference',
+          index,
+        })),
+        regions: [],
+        selections: [],
+      },
+    };
+  }
 
-    if (this.kind === 'group') {
-      const childContext = this.assembly!;
-      return {
-        ...common,
-        children: this.children.map(child =>
-          child.snapshotNode(meshCache, childContext, true, material),
-        ),
-      };
-    }
+  relate(
+    build: (frame: SketchFrame) => Constraint | readonly Constraint[],
+  ): SketchFrame {
+    const related = new SketchFrame(this);
+    related.addRelations(this, () => build(related));
+    return related;
+  }
 
-    const geometry = this.requireGeometry();
+  face(region: SketchRegion): FaceModel {
+    return sketchFaceModel(region, this.constraints, this);
+  }
+
+  snapshot(): ConstraintPreview['object'] {
+    const context = RelationObject.createSolveContext([this]);
     return {
-      ...common,
-      children: [],
-      mesh: renderMesh(
-        geometry,
-        geometry.value.shape,
-        meshCache,
-        this.meshTolerance,
-        geometry.value.topology,
+      nodeId: this.nodeId,
+      compositionTransform: toTransform(this.solvePose(context)),
+      constraints: this.constraints.map(constraint =>
+        this.constraintSnapshot(constraint, context),
       ),
     };
   }
 
-  /** @internal */
-  disposeShape(disposed: Set<AnyShape>): void {
-    const shapes = [
-      ...(this.geometry ? [this.geometry.value.shape] : []),
-      ...(this.geometry?.value.referenceBasis
-        ? [this.geometry.value.referenceBasis.shape]
-        : []),
-      ...this.operation.regions.map(region => region.artifact.value),
-    ];
-    for (const shape of shapes) {
-      if (!disposed.has(shape)) {
-        disposed.add(shape);
-        shape.delete();
-      }
-    }
-    this.children.forEach(child => child.disposeShape(disposed));
+  /** Related finite models, expressed in this sketch's local editing plane. */
+  context(): readonly Readonly<{nodeId: string; transform: Transform}>[] {
+    const context = RelationObject.createSolveContext([this]);
+    const frame = this.solvePose(context);
+    return [...context.poses].flatMap(([object, pose]) =>
+      object instanceof ModelObject
+        ? [
+            {
+              nodeId: object.nodeId,
+              transform: toTransform(relativeTransform(pose, frame)),
+            },
+          ]
+        : [],
+    );
   }
+}
 
+export class ModelObject<
+  Elements extends NamedElements = {},
+  Kind extends ModelKind = ModelKind,
+>
+  extends RelationObject
+  implements Anchor<ModelElementKind<Kind>>
+{
+  declare readonly [anchorKind]: ModelElementKind<Kind>;
+  declare readonly [modelKind]: Kind;
+  declare readonly [modelNamedElements]: Elements;
   /** @internal */
-  [loftModels](
-    this: ModelObject<Elements, 'face'>,
-    others: readonly ModelObject<{}, 'face'>[],
-    spine: ModelObject<{}, 'edge'> | undefined,
-    ruled: boolean,
-  ): SolidModel {
-    const sections: readonly ModelObject<{}, 'face'>[] = [this, ...others];
-    const solveContext = ModelObject.createSolveContext([
-      ...sections,
-      ...(spine ? [spine] : []),
-    ]);
-    const resultPose = this.solvePose(solveContext);
-    const sectionInputs = sections.map(section => ({
-      model: section,
-      geometry: section.requireGeometry(),
-      transform: relativeTransform(section.solvePose(solveContext), resultPose),
-    }));
-    const spineInput = spine
-      ? {
-          model: spine,
-          geometry: spine.requireGeometry(),
-          transform: relativeTransform(
-            spine.solvePose(solveContext),
-            resultPose,
-          ),
-        }
-      : undefined;
-    const geometry = evaluateSolidGeometry(
-      spine ? 'spine-loft' : 'loft',
-      [
-        ruled,
-        sectionInputs.map(input => [
-          input.transform.position,
-          input.transform.quaternion,
-        ]),
-        spineInput
-          ? [spineInput.transform.position, spineInput.transform.quaternion]
-          : null,
-      ],
-      [
-        ...sectionInputs.map(input => input.geometry),
-        ...(spineInput ? [spineInput.geometry] : []),
-      ],
-      () => buildLoftGeometry(sectionInputs, spineInput, ruled),
-    );
-    const inputs = [...sections, ...(spine ? [spine] : [])];
-    return ModelObject.create<CanonicalElements, 'solid'>({
-      kind: 'solid',
-      name: 'Loft',
-      geometry,
-      material: this.materialSnapshot,
-      constraints: this.constraints,
-      sourceRefs: inputs.flatMap(input => input.sourceRefs),
-      parameters: uniqueParameters(
-        inputs.flatMap(input => input.allParameters()),
-      ),
-      meshTolerance: Math.min(...inputs.map(input => input.meshTolerance)),
-      operation: storedOperation('loft', [
-        {model: this, role: 'receiver', index: 0},
-        ...others.map((model, index) => ({
-          model,
-          role: 'section' as const,
-          index: index + 1,
-        })),
-        ...(spine
-          ? [{model: spine, role: 'spine' as const, index: sections.length}]
-          : []),
-      ]),
-    }) as unknown as SolidModel;
-  }
+  readonly elementKind: ModelElementKind<Kind>;
+  /** @internal */
+  readonly kind: Kind;
+  /** @internal */
+  readonly name: string;
+  /** @internal */
+  private readonly materialSnapshot?: ModelMaterialSnapshot;
+  /** @internal */
+  readonly children: readonly ModelObject[];
+  private readonly geometry?: ModelGeometry;
+  private readonly assembly?: SolveContext;
+  private readonly meshTolerance: number;
+  private readonly geometryAnchor: StoredElement;
+  private readonly elements: StoredElements;
+  private readonly operation: StoredOperation;
 
   /** @internal */
-  [combineModels](
-    this: ModelObject<Elements, 'solid'>,
-    operation: BooleanOperation,
-    others: readonly ModelObject<{}, 'solid'>[],
-  ): SolidModel {
-    const evaluation = this.evaluateBoolean(operation, others);
-    let transferred = false;
-    try {
-      const combined = ModelObject.create<CanonicalElements, 'solid'>({
-        kind: 'solid',
-        geometryAnchor: this.geometryAnchor,
-        geometry: evaluation.geometry,
-        name: this.name,
-        material: this.materialSnapshot,
-        constraints: this.constraints,
-        sourceRefs: [this, ...others].flatMap(model => model.sourceRefs),
-        parameters: uniqueParameters(
-          [this, ...others].flatMap(model => model.allParameters()),
-        ),
-        meshTolerance: Math.min(
-          this.meshTolerance,
-          ...others.map(model => model.meshTolerance),
-        ),
-        operation: storedOperation(
-          operation === 'fuse' ? 'union' : operation,
-          [
-            {model: this, role: 'receiver', index: 0},
-            ...others.map((model, index) => ({
-              model,
-              role:
-                operation === 'cut' ? ('tool' as const) : ('operand' as const),
-              index: index + 1,
-            })),
-          ],
-          {regions: evaluation.regions},
-        ),
-      });
-      transferred = true;
-      return combined as unknown as SolidModel;
-    } finally {
-      if (!transferred) {
-        disposeModelGeometryValue(evaluation.geometry.value);
-        evaluation.regions.forEach(region => region.artifact.value.delete());
-      }
-    }
+  [modelGeometry](): ModelGeometry | undefined {
+    return this.geometry;
   }
 
-  private evaluateBoolean(
-    this: ModelObject<Elements, 'solid'>,
-    operation: BooleanOperation,
-    others: readonly ModelObject<{}, 'solid'>[],
-  ): BooleanEvaluation {
-    const solveContext = ModelObject.createSolveContext([this, ...others]);
-    const targetPose = this.solvePose(solveContext);
-    let geometry = this.requireSolidGeometry();
-    let temporaryGeometry: SolidGeometry | undefined;
-    const regions: StoredOperationRegion[] = [];
-    let evaluated = false;
-    try {
-      for (const [otherIndex, other] of others.entries()) {
-        const otherGeometry = other.requireSolidGeometry();
-        const transform = relativeTransform(
-          other.solvePose(solveContext),
-          targetPose,
-        );
-        const operand = evaluateKernelShape(
-          'transform',
-          [transform.position, transform.quaternion],
-          [otherGeometry],
-          () => shapeWithTransform(otherGeometry.value.shape, transform),
-        );
-        try {
-          if (operation === 'cut' || operation === 'fuse') {
-            regions.push({
-              kind: 'intersection',
-              input: other,
-              frame: this,
-              artifact: evaluateKernelShape(
-                'boolean-intersection-region',
-                [],
-                [geometry, operand],
-                () => geometry.value.shape.intersect(operand.value),
-              ),
-            });
-          }
-          if (operation === 'fuse') {
-            regions.push({
-              kind: 'section',
-              input: other,
-              frame: this,
-              artifact: evaluateKernelShape(
-                'boolean-section-region',
-                [],
-                [geometry, operand],
-                () => unionSectionShape(geometry.value.shape, operand.value),
-              ),
-            });
-          }
-          const nextGeometry = evaluateSolidGeometry(
-            `boolean-${operation}`,
-            [otherIndex],
-            [geometry, operand],
-            () => {
-              const result = booleanWithTopology(
-                {
-                  shape: geometry.value.shape,
-                  topology: geometry.value.topology,
-                  index: otherIndex === 0 ? 1 : undefined,
-                },
-                {
-                  shape: operand.value,
-                  topology: otherGeometry.value.topology,
-                  index: otherIndex + 2,
-                },
-                operation,
-              );
-              return {shape: result.shape, topology: result.topology};
-            },
-          );
-          temporaryGeometry?.value.shape.delete();
-          temporaryGeometry = nextGeometry;
-          geometry = nextGeometry;
-        } finally {
-          operand.value.delete();
+  private constructor(init: ModelObjectInit<Kind>) {
+    super(init);
+    if (init.kind !== 'group' && !init.geometry) {
+      throw new Error(
+        'A geometric model object must contain an OpenCascade shape.',
+      );
+    }
+    this.kind = init.kind;
+    this.elementKind = modelElementKinds[
+      init.kind
+    ] as unknown as ModelElementKind<Kind>;
+    this.geometry = init.geometry;
+    this.geometryAnchor = init.geometryAnchor ?? {
+      kind: this.elementKind,
+      transform: identityRigidTransform,
+    };
+    this.meshTolerance = init.meshTolerance ?? 0.2;
+    this.name = init.name ?? defaultModelNames[init.kind];
+    this.materialSnapshot = init.material;
+    this.children = init.children ?? [];
+    this.assembly =
+      init.assembly ??
+      (this.kind === 'group'
+        ? ModelObject.createAssembly(this.children)
+        : undefined);
+    this.operation = init.operation;
+    const elements =
+      init.elements ??
+      (this.kind === 'solid' && this.geometry
+        ? solidElements(this.geometry.value.localBounds)
+        : {});
+    this.elements = this.geometry
+      ? {
+          center: {
+            kind: 'point',
+            transform: translation(
+              boundsCenter(this.geometry.value.localBounds),
+            ),
+          },
+          ...elements,
         }
+      : elements;
+    for (const [name, element] of Object.entries(this.elements)) {
+      if (name in this) {
+        throw new Error(
+          `The element name ${name} conflicts with the model API.`,
+        );
       }
-      evaluated = true;
-      return {geometry, regions};
-    } finally {
-      if (!evaluated) {
-        temporaryGeometry?.value.shape.delete();
-        regions.forEach(region => region.artifact.value.delete());
-      }
+      Object.defineProperty(this, name, {
+        value: modelAnchor(this, name, element),
+      });
     }
   }
 
-  private allParameters(): ParameterUsage[] {
-    return uniqueParameters([
-      ...this.parameters,
-      ...this.constraints.flatMap(
-        constraint => valueTrace(constraint).parameters,
-      ),
-    ]);
+  /** @internal */
+  static create<
+    Elements extends NamedElements = {},
+    Kind extends ModelKind = ModelKind,
+  >(init: ModelObjectInit<Kind>): ModelObject<Elements, Kind> {
+    return new ModelObject<Elements, Kind>(init);
   }
 
-  private solvePose(context: SolveContext): RigidTransform {
-    return context.poses.get(this)!;
+  get up(): Bound {
+    return directionalBound(this.relationAnchorReference(), 'up');
   }
-
-  private memberPoses(): Map<ModelObject, RigidTransform | null> {
-    const members = new Map<ModelObject, RigidTransform | null>([
-      [this, identityRigidTransform],
-    ]);
-    if (this.children.length) {
-      const context = this.assembly!;
-      for (const child of this.children) {
-        const pose = child.solvePose(context);
-        for (const [member, localPose] of child.memberPoses()) {
-          members.set(
-            member,
-            members.has(member) || localPose === null
-              ? null
-              : composeTransforms(pose, localPose),
-          );
-        }
-      }
-    }
-    return members;
+  get down(): Bound {
+    return directionalBound(this.relationAnchorReference(), 'down');
   }
-
-  /** Bounds of the selected finite geometry after a rigid transform. */
-  private [referenceBoundsParts](
-    reference: StoredAnchor,
-    transform: RigidTransform,
-  ): ({bounds: LocalBounds} | SnapshotQueryInput)[] {
-    if (reference.bound) {
-      const frame = composeTransforms(transform, reference.transform);
-      const [x, z] = reference.bound.size;
-      return [
-        {
-          bounds: pointBounds(
-            [-1, 1].flatMap(a =>
-              [-1, 1].map(
-                b =>
-                  composeTransforms(
-                    frame,
-                    translation([(a * x) / 2, 0, (b * z) / 2]),
-                  ).position,
-              ),
-            ),
-          ),
-        },
-      ];
-    }
-    if (reference.whole) {
-      if (this.geometry) return [boundsQuery(this.geometry, transform)];
-      const context = this.assembly!;
-      return this.children.flatMap(child =>
-        child[referenceBoundsParts](
-          child.relationAnchorReference(),
-          composeTransforms(transform, child.solvePose(context)),
-        ),
-      );
-    }
-    if (reference.topology) {
-      const topology = reference.topology;
-      return [
-        boundsQuery(
-          topology.source.requireGeometry(),
-          composeTransforms(transform, topology.transform),
-          topology.selection,
-          topology.scale,
-        ),
-      ];
-    }
-    if (reference.kind === 'point') {
-      const point = composeTransforms(transform, reference.transform).position;
-      return [{bounds: [point, point]}];
-    }
-    throw new Error(
-      `The reference ${reference.name} has no finite geometry. Select a model, vertex, edge, or surface for on().`,
-    );
+  get left(): Bound {
+    return directionalBound(this.relationAnchorReference(), 'left');
+  }
+  get right(): Bound {
+    return directionalBound(this.relationAnchorReference(), 'right');
+  }
+  get front(): Bound {
+    return directionalBound(this.relationAnchorReference(), 'front');
+  }
+  get back(): Bound {
+    return directionalBound(this.relationAnchorReference(), 'back');
   }
 
-  /** Bounds of the selected finite geometry after a rigid transform. */
-  [referenceBounds](
-    reference: StoredAnchor,
-    transform: RigidTransform,
-  ): LocalBounds {
-    const bounds = this[referenceBoundsParts](reference, transform).map(part =>
-      'bounds' in part
-        ? part.bounds
-        : (evaluateSnapshotQuery(part) as LocalBounds),
+  on(target: Bound): Constraint {
+    return Constraint.create(
+      this.relationAnchorReference(),
+      boundReference(target),
     );
-    return bounds.length === 1 ? bounds[0] : combineBounds(bounds);
   }
 
-  /** Pure query collection: it never substitutes geometry or runs author code. */
-  [modelSnapshotQueries](): SnapshotQueryInput[] {
-    const result: SnapshotQueryInput[] = [];
-    if (this.geometry || this.children.length) {
-      for (const direction of Object.values(boundDirections)) {
-        const transform = invertTransform(
-          rotation(frameFromYAxis(origin, direction).quaternion),
-        );
-        for (const part of this[referenceBoundsParts](
-          this.relationAnchorReference(),
-          transform,
-        ))
-          if (!('bounds' in part)) result.push(part);
-      }
-    }
-    if (this.geometry)
-      result.push(
-        meshQuery(
-          this.geometry,
-          this.geometry.value.shape,
-          this.meshTolerance,
-          this.geometry.value.topology,
-        ),
-      );
-    for (const region of this.operation.regions)
-      result.push(
-        meshQuery(region.artifact, region.artifact.value, this.meshTolerance),
-      );
-    return result;
+  /** @internal */
+  relationAnchorReference(): AnchorReference {
+    return {model: this, name: 'geometry', ...this.geometryAnchor, whole: true};
   }
 
-  private alignmentGeometry(reference: StoredAnchor): AlignmentGeometry {
-    if (reference.kind === 'point')
-      return {
-        kind: 'point',
-        point: reference.whole
-          ? (this.requireGeometry().value.shape as ReplicadVertex).asTuple()
-          : reference.transform.position,
-      };
-    const read = (shape: AnyShape) =>
-      reference.kind === 'line'
-        ? edgeGeometry(shape as ReplicadEdge, reference.direction ?? 1)
-        : faceGeometry(
-            shape as ReplicadFace,
-            reference.facing ?? reference.bound?.facing ?? 1,
-          );
-    if (reference.topology) {
-      const topology = reference.topology,
-        geometry = topology.source.requireGeometry().value;
-      return withTopologyShape(
-        geometry.shape,
-        geometry.topology,
-        topology.selection,
-        shape => {
-          const scaled =
-            topology.scale === 1
-              ? shape
-              : shapeWithScale(shape, topology.scale);
-          try {
-            return transformGeometry(read(scaled), topology.transform);
-          } finally {
-            if (scaled !== shape) scaled.delete();
-          }
-        },
-      );
-    }
-    if (reference.whole) return read(this.requireGeometry().value.shape);
-    const direction = rotateVector(
-      [
-        0,
-        reference.kind === 'line'
-          ? (reference.direction ?? 1)
-          : (reference.facing ?? reference.bound?.facing ?? 1),
-        0,
-      ],
-      reference.transform.quaternion,
+  align(target: Anchor<'point' | 'line' | 'face'>): Constraint {
+    return Constraint.create(
+      this.relationAnchorReference(),
+      anchorReference(target),
+      'align',
     );
-    return reference.kind === 'line'
-      ? {kind: 'line', point: reference.transform.position, direction}
-      : {kind: 'plane', point: reference.transform.position, normal: direction};
   }
 
-  private relationElement(reference: StoredAnchor): ElementSnapshot {
-    const element = reference.whole
-      ? {
-          ...this.exposedElement(),
-          name: reference.name,
-          direction: reference.direction,
-          facing: reference.facing,
-        }
-      : reference;
-    const topology = element.topology;
-    let arrow: RigidTransform | undefined;
-    if (reference.kind === 'line' && topology) {
-      const geometry = topology.source.requireGeometry().value;
-      arrow = withTopologyShape(
-        geometry.shape,
-        geometry.topology,
-        topology.selection,
-        shape => {
-          const edge = shape as ReplicadEdge;
-          const position = (reference.direction ?? 1) === 1 ? 1 : 0;
-          const point = edge.pointAt(position),
-            tangent = edge.tangentAt(position);
-          try {
-            return topologyTransform(
-              topology,
-              frameFromYAxis(
-                point.toTuple(),
-                tangent
-                  .toTuple()
-                  .map(v => v * (reference.direction ?? 1)) as unknown as Vec3,
-              ),
-            );
-          } finally {
-            point.delete();
-            tangent.delete();
-          }
-        },
-      );
-    }
-    return {
-      ...snapshotElements({[reference.name]: element})[0],
-      arrow,
-    };
+  reverse(): Edge {
+    return this.edges()[0].reverse();
   }
-
-  private bodyRotations(
-    constraint: StoredConstraint,
-    indices: Map<ModelObject, number>,
-  ): BodyRotation[] {
-    return constraint.rotations.map(({pivot, angles}) => {
-      if (pivot.kind === 'around') {
-        return pivot.axis.model
-          ? {
-              body: indices.get(pivot.axis.model)!,
-              axis: pivot.axis.transform,
-              angle: (angles as number) * (pivot.axis.direction ?? 1),
-            }
-          : {
-              local: axisRotation(
-                pivot.axis.transform,
-                (angles as number) * (pivot.axis.direction ?? 1),
-              ),
-            };
-      }
-      const frame = translation(
-        pivot.kind === 'pivot'
-          ? pivot.point
-          : anchorReference(this.vertex(pivot.id)).transform.position,
-      );
-      return {
-        local: composeTransforms(
-          composeTransforms(frame, rotationAround(origin, angles as Vec3)),
-          invertTransform(frame),
-        ),
-      };
-    });
+  flip(): Surface {
+    return this.surfaces()[0].flip();
   }
 
-  /** @internal */
-  [relationPreview](
-    nodeId: string,
-    constraint: StoredConstraint,
-    selection: ConstraintSpatialSelection | undefined,
-  ): ConstraintPreview {
-    // This expression starts from the relate receiver, before sibling constraints
-    // are returned and committed to self. Geometry and node identity stay shared.
-    const owner = this.copy(
-      {nodeId, constraints: [...this.constraints, constraint]},
-      this.operation,
-    );
-    const context = ModelObject.createSolveContext([
-      owner,
-      ...(selection?.pivot.kind === 'around' && selection.pivot.axis.model
-        ? [selection.pivot.axis.model]
-        : []),
+  relate(
+    build: (
+      self: RuntimeModel<Elements, Kind>,
+    ) => Constraint | readonly Constraint[],
+  ): RuntimeModel<Elements, Kind> {
+    const operation = storedOperation('relate', [
+      {model: this, role: 'source', index: 0},
     ]);
-    return {
-      object: {
-        nodeId,
-        compositionTransform: toTransform(owner.solvePose(context)),
-        constraints: owner.constraints.map(value =>
-          owner.constraintSnapshot(value, context),
-        ),
-      },
-      spatial: selection
-        ? owner.constraintSpatial(constraint, selection, context)
-        : undefined,
-    };
+    const related = this.copy({}, operation);
+    const references = related.addRelations(this, () => build(related));
+    operation.inputs.push(
+      ...references.map((model, index) => ({
+        model,
+        role: 'reference' as const,
+        index,
+      })),
+    );
+    return related;
   }
 
-  private constraintSpatial(
-    constraint: StoredConstraint,
-    selection: ConstraintSpatialSelection,
-    context: SolveContext,
-  ): ConstraintSpatialReference {
-    const models = [...context.poses.keys()];
-    const actions = this.bodyRotations(
-      constraint,
-      new Map(models.map((model, i) => [model, i])),
+  expose<const Sources extends ElementSources>(
+    sources: Sources,
+  ): RuntimeModel<MergedElements<Elements, ExposedElements<Sources>>, Kind> {
+    const entries = Object.entries(sources);
+    const elements = this.localElements(entries.map(([, source]) => source));
+    const exposed = Object.fromEntries(
+      entries.map(([name], index) => [name, elements[index]]),
     );
-    const stage = actions.length - (selection.kind === 'rotate' ? 1 : 0);
-    const finalPose = this.solvePose(context);
-    let before = finalPose;
-    for (let i = actions.length - 1; i >= stage; i--) {
-      const action = actions[i];
-      before =
-        'local' in action
-          ? composeTransforms(before, invertTransform(action.local))
-          : composeTransforms(
-              axisRotation(
-                composeTransforms(
-                  models[action.body].solvePose(context),
-                  action.axis,
-                ),
-                -action.angle,
-              ),
-              before,
-            );
-    }
-    const pivot = selection.pivot;
-    let frame: RigidTransform;
-    if (pivot.kind === 'around') {
-      frame = composeTransforms(
-        pivot.axis.model ? pivot.axis.model.solvePose(context) : before,
-        (pivot.axis.direction ?? 1) === 1
-          ? pivot.axis.transform
-          : composeTransforms(pivot.axis.transform, rotation([1, 0, 0, 0])),
-      );
-    } else {
-      const local = translation(
-        pivot.kind === 'pivot'
-          ? pivot.point
-          : anchorReference(this.vertex(pivot.id)).transform.position,
+    const references = entries.map(
+      ([, source]) => anchorReference(source).model,
+    );
+    const operation = storedOperation('expose', [
+      {model: this, role: 'source', index: 0},
+      ...uniqueModels(references)
+        .filter(model => model !== this)
+        .map((model, index) => ({
+          model,
+          role: 'reference' as const,
+          index,
+        })),
+    ]);
+    return this.copy(
+      {elements: {...this.elements, ...exposed}},
+      operation,
+    ) as unknown as RuntimeModel<
+      MergedElements<Elements, ExposedElements<Sources>>,
+      Kind
+    >;
+  }
+
+  /** Resolve both own and occurrence references into this model's local frame. */
+  private localElements(sources: readonly Anchor[]): StoredElement[] {
+    const members = this.memberPoses();
+    const external = sources
+      .map(source => anchorReference(source).model)
+      .filter(model => !members.has(model));
+    const context = external.length
+      ? ModelObject.createSolveContext([this, ...external])
+      : undefined;
+    return sources.map(source => {
+      const reference = anchorReference(source);
+      const {
+        kind,
+        transform: frame,
+        topology,
+        members: nested,
+        bound,
+        facing,
+      } = source instanceof ModelObject ? source.exposedElement() : reference;
+      const memberPose = members.get(reference.model);
+      if (memberPose === null)
+        throw new Error(
+          "The point or element belongs to multiple occurrences. Expose it through the intended child model's named reference.",
+        );
+      const transform =
+        memberPose ??
+        relativeTransform(
+          reference.model.solvePose(context!),
+          this.solvePose(context!),
+        );
+      return transformElement(
+        {kind, transform: frame, topology, members: nested, bound, facing},
+        transform,
       );
-      frame = composeTransforms(before, local);
-    }
-    const angles = constraint.rotations[stage]?.angles ?? origin;
-    const rotationVector: Vec3 =
-      typeof angles === 'number' ? [0, angles, 0] : angles;
-    const localFrame = relativeTransform(frame, finalPose);
-    return {
-      nodeId: this.nodeId,
-      kind: selection.kind,
-      spatial: {
-        origin: localFrame.position,
-        vector:
-          selection.kind === 'rotate'
-            ? rotationVector
-            : pivot.kind === 'pivot'
-              ? pivot.point
-              : origin,
-        frame: localFrame,
-        rotation: rotationVector,
-        axisOnly: pivot.kind === 'around',
-      },
-    };
+    });
   }
 
-  /** Fix the assembly frame once, using only its direct member origins. */
-  private static createAssembly(
-    children: readonly ModelObject[],
-  ): SolveContext {
-    const context = ModelObject.createSolveContext(children);
-    const center = children.length
-      ? boundsCenter(
-          pointBounds(children.map(child => child.solvePose(context).position)),
-        )
-      : origin;
-    return transformSolveContext(context, translation(negateVector(center)));
+  vertex(id: VertexId): Vertex {
+    return this.vertices([id])[0];
+  }
+  vertices(ids?: readonly VertexId[]): readonly Vertex[] {
+    return this.selectTopology('vertex', ids) as unknown as readonly Vertex[];
+  }
+  edge(id: EdgeId): Edge {
+    return this.edges([id])[0];
+  }
+  edges(ids?: readonly EdgeId[]): readonly Edge[] {
+    return this.selectTopology('edge', ids) as unknown as readonly Edge[];
+  }
+  surface(id: SurfaceId): Surface {
+    return this.surfaces([id])[0];
+  }
+  surfaces(ids?: readonly SurfaceId[]): readonly Surface[] {
+    return this.selectTopology('surface', ids) as unknown as readonly Surface[];
   }
 
-  private static createSolveContext(
-    roots: readonly ModelObject[],
-  ): SolveContext {
-    const models: ModelObject[] = [];
-    const indices = new Map<ModelObject, number>();
-    const collect = (model: ModelObject): void => {
-      if (indices.has(model)) return;
-      indices.set(model, models.length);
-      models.push(model);
-      model.constraints.flatMap(constraintReferences).forEach(collect);
-    };
-    roots.forEach(collect);
-    const poses = solveBodies(
-      models.map((model): Body => ({
-        name: model.name,
-        relations: model.constraints.map(constraint =>
-          constraint.kind === 'align'
-            ? {
-                kind: 'align',
-                id: constraint.id,
-                source: {
-                  body: indices.get(constraint.source.model ?? model)!,
-                  geometry: (
-                    constraint.source.model ?? model
-                  ).alignmentGeometry(constraint.source),
-                  transform: constraint.source.transform,
-                },
-                target: {
-                  body: indices.get(constraint.target.model ?? model)!,
-                  geometry: (
-                    constraint.target.model ?? model
-                  ).alignmentGeometry(constraint.target),
-                  transform: constraint.target.transform,
-                },
-                offset: constraint.offset,
-                rotations: model.bodyRotations(constraint, indices),
-              }
-            : {
-                kind: 'on',
-                id: constraint.id,
-                source: {
-                  body: indices.get(constraint.source.model ?? model)!,
-                  key: constraint.source.name,
-                  bounds: (orientation: Quaternion) =>
-                    (constraint.source.model ?? model)[referenceBounds](
-                      constraint.source,
-                      rotation(orientation),
-                    ),
-                },
-                target: {
-                  body: indices.get(constraint.target.model ?? model)!,
-                  transform: constraint.target.transform,
-                  facing: constraint.target.bound!.facing,
-                },
-                offset: constraint.offset,
-                rotations: model.bodyRotations(constraint, indices),
-              },
-        ),
-      })),
+  private selectTopology(
+    kind: TopologyKind,
+    ids?: readonly TopologyId[],
+  ): readonly ModelTopologyElement[] {
+    const geometry = this.requireGeometry().value;
+    const selected = topologyChildren(
+      geometry.shape,
+      geometry.topology,
+      {kind: 'solid'},
+      kind,
+      ids,
+    );
+    return topologyReferences(
+      this,
+      '',
+      {source: this, transform: identityRigidTransform, scale: 1},
+      kind,
+      selected,
     );
-    return {
-      poses: new Map(models.map((model, index) => [model, poses[index]])),
-    };
   }
 
-  private constraintSnapshot(
-    constraint: StoredConstraint,
-    context: SolveContext,
-  ): ConstraintSnapshot {
-    const source = constraint.source.model ?? this;
-    const target = constraint.target.model ?? this;
-    const models = [...context.poses.keys()];
-    const actions = this.bodyRotations(
-      constraint,
-      new Map(models.map((model, i) => [model, i])),
-    );
-    let before = this.solvePose(context);
-    for (const action of [...actions].reverse()) {
-      before =
-        'local' in action
-          ? composeTransforms(before, invertTransform(action.local))
-          : composeTransforms(
-              axisRotation(
-                composeTransforms(
-                  models[action.body].solvePose(context),
-                  action.axis,
-                ),
-                -action.angle,
-              ),
-              before,
-            );
+  /** @internal */
+  exposedElement(): StoredElement {
+    if (this.kind === 'group')
+      return {...this.geometryAnchor, members: this.elements};
+    const geometry = this.requireGeometry().value;
+    const kind = (
+      this.kind === 'face' ? 'surface' : this.kind
+    ) as TopologySelection['kind'];
+    const selection: TopologySelection =
+      kind === 'solid'
+        ? {kind}
+        : {
+            kind,
+            id: geometry.topology[
+              kind === 'surface'
+                ? 'surfaces'
+                : kind === 'edge'
+                  ? 'edges'
+                  : 'vertices'
+            ].ids[0],
+          };
+    const context = {
+      source: this,
+      transform: identityRigidTransform,
+      scale: 1,
+    };
+    const anchor =
+      selection.kind === 'solid'
+        ? this.geometryAnchor
+        : topologyReferences(this, '', context, selection.kind, [
+            selection.id,
+          ])[0][anchorReferenceValue];
+    return {
+      kind: anchor.kind,
+      transform: anchor.transform,
+      members: this.elements,
+      topology: {
+        ...context,
+        selection,
+      },
+    };
+  }
+
+  material(material: Material | string): RuntimeModel<Elements, Kind> {
+    return this.copy(
+      {material: captureModelMaterial(material)},
+      storedOperation('material', [{model: this, role: 'source', index: 0}]),
+    );
+  }
+
+  originOffset(
+    dx: number,
+    dy: number,
+    dz: number,
+  ): RuntimeModel<Elements, Kind>;
+  originOffset(dx = 0, dy = 0, dz = 0): RuntimeModel<Elements, Kind> {
+    const offset: Vec3 = [dx, dy, dz];
+    assertFiniteVector('originOffset', offset);
+    return this.withOrigin(offset, {kind: 'originOffset'});
+  }
+
+  originPoint(point: PointAnchor): RuntimeModel<Elements, Kind> {
+    const reference = anchorReference(point);
+    if (reference.kind !== 'point')
+      throw new Error('originPoint() requires a point reference.');
+    const [element] = this.localElements([point]);
+    return this.withOrigin(element.transform.position, {
+      kind: 'originPoint',
+      model: reference.model,
+    });
+  }
+
+  originVertex(id: VertexId): RuntimeModel<Elements, Kind> {
+    const geometry = this.requireGeometry().value;
+    const [{position}] = topologyVertexPoints(
+      geometry.shape,
+      geometry.topology.vertices,
+      [id],
+    );
+    return this.withOrigin(position, {kind: 'originVertex', id});
+  }
+
+  originCenter(): RuntimeModel<Elements, Kind> {
+    this.requireGeometry();
+    const position = this.elements.center.transform.position;
+    return this.withOrigin(position, {kind: 'originCenter'});
+  }
+
+  private withOrigin(
+    offset: Vec3,
+    selection:
+      | {kind: 'originOffset' | 'originCenter'}
+      | {kind: 'originVertex'; id: VertexId}
+      | {kind: 'originPoint'; model: RelationObject},
+  ): RuntimeModel<Elements, Kind> {
+    const transform = translation(negateVector(offset));
+    const operation = storedOperation(selection.kind, [
+      {model: this, role: 'source', index: 0},
+    ]);
+    if (selection.kind === 'originPoint' && selection.model !== this)
+      operation.inputs.push({
+        model: selection.model,
+        role: 'reference',
+        index: 0,
+      });
+    operation.spatial = {origin, vector: offset};
+    if (selection.kind === 'originVertex') {
+      operation.selections.push({
+        kind: 'vertex',
+        input: this,
+        ids: [selection.id],
+        transform,
+      });
+    }
+    return this.transformed(transform, operation);
+  }
+
+  rotate(x: number, y: number, z: number): RuntimeModel<Elements, Kind>;
+  rotate(x = 0, y = 0, z = 0): RuntimeModel<Elements, Kind> {
+    const angles: Vec3 = [x, y, z];
+    assertFiniteVector('rotate', angles);
+    const operation = storedOperation('rotate', [
+      {model: this, role: 'source', index: 0},
+    ]);
+    operation.spatial = {origin, vector: angles};
+    return this.transformed(rotationAround(origin, angles), operation);
+  }
+
+  private transformed(
+    transform: RigidTransform,
+    operation: StoredOperation,
+  ): RuntimeModel<Elements, Kind> {
+    const overrides: Partial<ModelObjectInit<Kind>> = {
+      geometryAnchor: transformElement(this.geometryAnchor, transform),
+      elements: Object.fromEntries(
+        Object.entries(this.elements).map(([name, element]) => [
+          name,
+          transformElement(element, transform),
+        ]),
+      ),
+      constraints: this.mapConstraintGeometry(
+        element => transformElement(element, transform),
+        point => composeTransforms(transform, translation(point)).position,
+      ),
+    };
+    if (this.assembly)
+      return this.copy(
+        {
+          ...overrides,
+          assembly: transformSolveContext(this.assembly, transform),
+        },
+        operation,
+      );
+    const source = this.requireGeometry();
+    const geometry = evaluateModelGeometry(
+      'transform',
+      [transform.position, transform.quaternion],
+      [source],
+      () => {
+        const shape = shapeWithTransform(source.value.shape, transform);
+        try {
+          return {
+            shape,
+            topology: preserveShapeTopology(shape, source.value.topology),
+            referenceBasis: transformedReferenceBasis(source, transform, 1),
+          };
+        } catch (error) {
+          shape.delete();
+          throw error;
+        }
+      },
+    );
+    return this.copyWithGeometry(geometry, overrides, operation);
+  }
+
+  private mapConstraintGeometry(
+    mapElement: (element: StoredElement) => StoredElement,
+    mapPoint: (point: Vec3) => Vec3,
+  ): StoredConstraint[] {
+    const mapReference = (reference: RelationReference): RelationReference =>
+      reference.model ? reference : {...reference, ...mapElement(reference)};
+    return this.constraints.map(constraint => {
+      const mapped: StoredConstraint = {
+        ...constraint,
+        source: mapReference(constraint.source),
+        target: mapReference(constraint.target),
+        rotations: constraint.rotations.map(action => ({
+          ...action,
+          pivot:
+            action.pivot.kind === 'around'
+              ? {...action.pivot, axis: mapReference(action.pivot.axis)}
+              : action.pivot.kind === 'pivot'
+                ? {...action.pivot, point: mapPoint(action.pivot.point)}
+                : action.pivot,
+        })),
+      };
+      valueTraces.set(mapped, valueTrace(constraint));
+      return mapped;
+    });
+  }
+
+  scaled(factor: number): RuntimeModel<Elements, Kind>;
+  scaled(factor = 1): RuntimeModel<Elements, Kind> {
+    assertPositive('scale', factor);
+    const source = this.requireGeometry();
+    const geometry = evaluateModelGeometry('scaled', [factor], [source], () => {
+      const shape = shapeWithScale(source.value.shape, factor);
+      try {
+        return {
+          shape,
+          topology: preserveShapeTopology(shape, source.value.topology),
+          referenceBasis: transformedReferenceBasis(
+            source,
+            identityRigidTransform,
+            factor,
+          ),
+        };
+      } catch (error) {
+        shape.delete();
+        throw error;
+      }
+    });
+    return this.copyWithGeometry(
+      geometry,
+      {
+        geometryAnchor: scaleElement(this.geometryAnchor, factor),
+        elements: scaleElements(this.elements, factor),
+        constraints: this.mapConstraintGeometry(
+          element => scaleElement(element, factor),
+          point => scaleFrame(translation(point), factor).position,
+        ),
+      },
+      storedOperation('scaled', [{model: this, role: 'source', index: 0}]),
+    );
+  }
+
+  extrude(this: ModelObject<Elements, 'face'>, distance: number): SolidModel;
+  extrude(this: ModelObject<Elements, 'face'>, distance = 10): SolidModel {
+    if (this.kind !== 'face')
+      throw new Error('extrude requires a single face model.');
+    if (!Number.isFinite(distance) || distance === 0)
+      throw new Error('Extrusion distance must be finite and non-zero.');
+    const source = this.requireGeometry();
+    const direction = rotateVector(
+      [0, distance, 0],
+      this.geometryAnchor.transform.quaternion,
+    );
+    const geometry = evaluateSolidGeometry(
+      'extrude',
+      [direction],
+      [source],
+      () =>
+        extrudeWithTopology(
+          {
+            shape: source.value.shape,
+            topology: source.value.topology,
+            index: 1,
+          },
+          direction,
+        ),
+    );
+    return ModelObject.create<CanonicalElements, 'solid'>({
+      kind: 'solid',
+      name: 'Extrude',
+      geometry,
+      material: this.materialSnapshot,
+      constraints: this.constraints,
+      sourceRefs: this.sourceRefs,
+      parameters: this.allParameters(),
+      meshTolerance: this.meshTolerance,
+      operation: storedOperation(
+        'extrude',
+        [{model: this, role: 'receiver', index: 0}],
+        {
+          dimensions: {
+            distance: {
+              origin: this.elements.center.transform.position,
+              vector: direction,
+            },
+          },
+        },
+      ),
+    }) as unknown as SolidModel;
+  }
+
+  cut(
+    this: ModelObject<Elements, 'solid'>,
+    tools: readonly SolidModel<{}>[],
+  ): SolidModel {
+    return cut(this as unknown as SolidModel<{}>, tools);
+  }
+
+  fillet(
+    this: ModelObject<Elements, 'solid'>,
+    radius: number,
+    edgeIds?: readonly EdgeId[],
+  ): SolidModel<Elements>;
+  fillet(
+    this: ModelObject<Elements, 'solid'>,
+    radius = 1,
+    edgeIds?: readonly EdgeId[],
+  ): SolidModel<Elements> {
+    assertPositive('radius', radius);
+    const source = this.requireSolidGeometry();
+    const selectedEdgeIds = resolveEdgeSelection(
+      source.value.topology.edges,
+      edgeIds,
+    );
+    const geometry = evaluateSolidGeometry(
+      'fillet',
+      [radius, selectedEdgeIds],
+      [source],
+      () => {
+        const result = filletEdges(
+          source.value.shape,
+          source.value.topology,
+          radius,
+          selectedEdgeIds,
+        );
+        return {shape: result.shape, topology: result.topology};
+      },
+    );
+    return this.copyWithGeometry(
+      geometry,
+      {},
+      storedOperation('fillet', [{model: this, role: 'source', index: 0}], {
+        selections: [
+          {
+            kind: 'edge',
+            input: this,
+            ids: selectedEdgeIds,
+            transform: identityRigidTransform,
+          },
+        ],
+      }),
+    ) as unknown as SolidModel<Elements>;
+  }
+
+  chamfer(
+    this: ModelObject<Elements, 'solid'>,
+    distance: number,
+    edgeIds?: readonly EdgeId[],
+  ): SolidModel<Elements>;
+  chamfer(
+    this: ModelObject<Elements, 'solid'>,
+    distance = 1,
+    edgeIds?: readonly EdgeId[],
+  ): SolidModel<Elements> {
+    assertPositive('distance', distance);
+    const source = this.requireSolidGeometry();
+    const selectedEdgeIds = resolveEdgeSelection(
+      source.value.topology.edges,
+      edgeIds,
+    );
+    const geometry = evaluateSolidGeometry(
+      'chamfer',
+      [distance, selectedEdgeIds],
+      [source],
+      () => {
+        const result = chamferEdges(
+          source.value.shape,
+          source.value.topology,
+          distance,
+          selectedEdgeIds,
+        );
+        return {shape: result.shape, topology: result.topology};
+      },
+    );
+    return this.copyWithGeometry(
+      geometry,
+      {},
+      storedOperation('chamfer', [{model: this, role: 'source', index: 0}], {
+        selections: [
+          {
+            kind: 'edge',
+            input: this,
+            ids: selectedEdgeIds,
+            transform: identityRigidTransform,
+          },
+        ],
+      }),
+    ) as unknown as SolidModel<Elements>;
+  }
+
+  shell(
+    this: ModelObject<Elements, 'solid'>,
+    thickness: number,
+    removedSurfaceIds?: readonly SurfaceId[],
+  ): SolidModel<Elements>;
+  shell(
+    this: ModelObject<Elements, 'solid'>,
+    thickness = 1,
+    removedSurfaceIds: readonly SurfaceId[] = [],
+  ): SolidModel<Elements> {
+    if (!Number.isFinite(thickness) || thickness === 0) {
+      throw new Error('thickness must be a nonzero finite number.');
     }
-    const sourcePose = source === this ? before : source.solvePose(context);
-    const targetPose = target === this ? before : target.solvePose(context);
-    let offsetFrame = composeTransforms(
-      targetPose,
-      constraint.target.transform,
+    const source = this.requireSolidGeometry();
+    const selectedIds = resolveTopologySelection(
+      'surface',
+      source.value.topology.surfaces,
+      removedSurfaceIds,
+    );
+    const geometry = evaluateSolidGeometry(
+      'shell',
+      [thickness, selectedIds],
+      [source],
+      () =>
+        shellWithTopology(
+          source.value.shape,
+          source.value.topology,
+          thickness,
+          selectedIds,
+        ),
+    );
+    return this.copyWithGeometry(
+      geometry,
+      {},
+      storedOperation('shell', [{model: this, role: 'source', index: 0}], {
+        selections: [
+          {
+            kind: 'surface',
+            input: this,
+            ids: selectedIds,
+            transform: identityRigidTransform,
+          },
+        ],
+      }),
+    ) as unknown as SolidModel<Elements>;
+  }
+
+  /** @internal */
+  attachOperationTrace(
+    siteId: string,
+    execution: number,
+    order: number,
+    sourceRef: SourceRef,
+    outputIndex = 0,
+  ): void {
+    if (operationTraces.has(this.operation)) {
+      return;
+    }
+    operationTraces.set(this.operation, {
+      siteId,
+      execution,
+      order,
+      sourceRef,
+      outputIndex,
+    });
+  }
+
+  /** @internal */
+  relatedObjects(): readonly RelationObject[] {
+    return [
+      ...this.children,
+      ...this.operation.inputs.map(input => input.model),
+      ...this.constraints.flatMap(constraintReferences),
+    ];
+  }
+
+  /** @internal */
+  toSnapshot(
+    meshCache: Map<AnyShape, RenderMesh> = new Map(),
+  ): ModelSnapshotObject {
+    const solveContext = ModelObject.createSolveContext([this]);
+    return this.snapshotNode(meshCache, solveContext);
+  }
+
+  private snapshotNode(
+    meshCache: Map<AnyShape, RenderMesh>,
+    solveContext: SolveContext,
+    inComposition = false,
+    overrideMaterial?: ModelMaterialSnapshot,
+  ): ModelSnapshotObject {
+    const material = overrideMaterial ?? this.materialSnapshot;
+    const pose = this.solvePose(solveContext);
+    const constraints = this.constraints.map(constraint =>
+      this.constraintSnapshot(constraint, solveContext),
+    );
+    const parameters = uniqueParameters([
+      ...this.parameters,
+      ...this.constraints.flatMap(
+        constraint => valueTrace(constraint).parameters,
+      ),
+    ]);
+    const common = {
+      nodeId: this.nodeId,
+      kind: this.kind,
+      name: this.name,
+      material,
+      compositionTransform: toTransform(pose),
+      transform: toTransform(inComposition ? pose : identityRigidTransform),
+      constraints,
+      origin,
+      elements: snapshotElements({
+        ...this.elements,
+        ...(this.geometry || this.children.length
+          ? Object.fromEntries(
+              Object.keys(boundDirections).map(direction => [
+                direction,
+                anchorReference(this[direction as keyof DirectionalBounds]),
+              ]),
+            )
+          : {}),
+      }),
+      sourceRefs: [...this.sourceRefs],
+      parameters,
+      operation: this.operationSnapshot(meshCache),
+    } as const;
+
+    if (this.kind === 'group') {
+      const childContext = this.assembly!;
+      return {
+        ...common,
+        children: this.children.map(child =>
+          child.snapshotNode(meshCache, childContext, true, material),
+        ),
+      };
+    }
+
+    const geometry = this.requireGeometry();
+    return {
+      ...common,
+      children: [],
+      mesh: renderMesh(
+        geometry,
+        geometry.value.shape,
+        meshCache,
+        this.meshTolerance,
+        geometry.value.topology,
+      ),
+    };
+  }
+
+  /** @internal */
+  disposeShape(disposed: Set<AnyShape>): void {
+    const shapes = [
+      ...(this.geometry ? [this.geometry.value.shape] : []),
+      ...(this.geometry?.value.referenceBasis
+        ? [this.geometry.value.referenceBasis.shape]
+        : []),
+      ...this.operation.regions.map(region => region.artifact.value),
+    ];
+    for (const shape of shapes) {
+      if (!disposed.has(shape)) {
+        disposed.add(shape);
+        shape.delete();
+      }
+    }
+    this.children.forEach(child => child.disposeShape(disposed));
+  }
+
+  /** @internal */
+  [loftModels](
+    this: ModelObject<Elements, 'face'>,
+    others: readonly ModelObject<{}, 'face'>[],
+    spine: ModelObject<{}, 'edge'> | undefined,
+    ruled: boolean,
+  ): SolidModel {
+    const sections: readonly ModelObject<{}, 'face'>[] = [this, ...others];
+    const solveContext = ModelObject.createSolveContext([
+      ...sections,
+      ...(spine ? [spine] : []),
+    ]);
+    const resultPose = this.solvePose(solveContext);
+    const sectionInputs = sections.map(section => ({
+      model: section,
+      geometry: section.requireGeometry(),
+      transform: relativeTransform(section.solvePose(solveContext), resultPose),
+    }));
+    const spineInput = spine
+      ? {
+          model: spine,
+          geometry: spine.requireGeometry(),
+          transform: relativeTransform(
+            spine.solvePose(solveContext),
+            resultPose,
+          ),
+        }
+      : undefined;
+    const geometry = evaluateSolidGeometry(
+      spine ? 'spine-loft' : 'loft',
+      [
+        ruled,
+        sectionInputs.map(input => [
+          input.transform.position,
+          input.transform.quaternion,
+        ]),
+        spineInput
+          ? [spineInput.transform.position, spineInput.transform.quaternion]
+          : null,
+      ],
+      [
+        ...sectionInputs.map(input => input.geometry),
+        ...(spineInput ? [spineInput.geometry] : []),
+      ],
+      () => buildLoftGeometry(sectionInputs, spineInput, ruled),
     );
-    if (constraint.kind === 'align') {
-      for (const action of actions)
-        if ('body' in action)
-          offsetFrame = composeTransforms(
-            axisRotation(
-              composeTransforms(
-                models[action.body].solvePose(context),
-                action.axis,
+    const inputs = [...sections, ...(spine ? [spine] : [])];
+    return ModelObject.create<CanonicalElements, 'solid'>({
+      kind: 'solid',
+      name: 'Loft',
+      geometry,
+      material: this.materialSnapshot,
+      constraints: this.constraints,
+      sourceRefs: inputs.flatMap(input => input.sourceRefs),
+      parameters: uniqueParameters(
+        inputs.flatMap(input => input.allParameters()),
+      ),
+      meshTolerance: Math.min(...inputs.map(input => input.meshTolerance)),
+      operation: storedOperation('loft', [
+        {model: this, role: 'receiver', index: 0},
+        ...others.map((model, index) => ({
+          model,
+          role: 'section' as const,
+          index: index + 1,
+        })),
+        ...(spine
+          ? [{model: spine, role: 'spine' as const, index: sections.length}]
+          : []),
+      ]),
+    }) as unknown as SolidModel;
+  }
+
+  /** @internal */
+  [combineModels](
+    this: ModelObject<Elements, 'solid'>,
+    operation: BooleanOperation,
+    others: readonly ModelObject<{}, 'solid'>[],
+  ): SolidModel {
+    const evaluation = this.evaluateBoolean(operation, others);
+    let transferred = false;
+    try {
+      const combined = ModelObject.create<CanonicalElements, 'solid'>({
+        kind: 'solid',
+        geometryAnchor: this.geometryAnchor,
+        geometry: evaluation.geometry,
+        name: this.name,
+        material: this.materialSnapshot,
+        constraints: this.constraints,
+        sourceRefs: [this, ...others].flatMap(model => model.sourceRefs),
+        parameters: uniqueParameters(
+          [this, ...others].flatMap(model => model.allParameters()),
+        ),
+        meshTolerance: Math.min(
+          this.meshTolerance,
+          ...others.map(model => model.meshTolerance),
+        ),
+        operation: storedOperation(
+          operation === 'fuse' ? 'union' : operation,
+          [
+            {model: this, role: 'receiver', index: 0},
+            ...others.map((model, index) => ({
+              model,
+              role:
+                operation === 'cut' ? ('tool' as const) : ('operand' as const),
+              index: index + 1,
+            })),
+          ],
+          {regions: evaluation.regions},
+        ),
+      });
+      transferred = true;
+      return combined as unknown as SolidModel;
+    } finally {
+      if (!transferred) {
+        disposeModelGeometryValue(evaluation.geometry.value);
+        evaluation.regions.forEach(region => region.artifact.value.delete());
+      }
+    }
+  }
+
+  private evaluateBoolean(
+    this: ModelObject<Elements, 'solid'>,
+    operation: BooleanOperation,
+    others: readonly ModelObject<{}, 'solid'>[],
+  ): BooleanEvaluation {
+    const solveContext = ModelObject.createSolveContext([this, ...others]);
+    const targetPose = this.solvePose(solveContext);
+    let geometry = this.requireSolidGeometry();
+    let temporaryGeometry: SolidGeometry | undefined;
+    const regions: StoredOperationRegion[] = [];
+    let evaluated = false;
+    try {
+      for (const [otherIndex, other] of others.entries()) {
+        const otherGeometry = other.requireSolidGeometry();
+        const transform = relativeTransform(
+          other.solvePose(solveContext),
+          targetPose,
+        );
+        const operand = evaluateKernelShape(
+          'transform',
+          [transform.position, transform.quaternion],
+          [otherGeometry],
+          () => shapeWithTransform(otherGeometry.value.shape, transform),
+        );
+        try {
+          if (operation === 'cut' || operation === 'fuse') {
+            regions.push({
+              kind: 'intersection',
+              input: other,
+              frame: this,
+              artifact: evaluateKernelShape(
+                'boolean-intersection-region',
+                [],
+                [geometry, operand],
+                () => geometry.value.shape.intersect(operand.value),
               ),
-              action.angle,
-            ),
-            offsetFrame,
+            });
+          }
+          if (operation === 'fuse') {
+            regions.push({
+              kind: 'section',
+              input: other,
+              frame: this,
+              artifact: evaluateKernelShape(
+                'boolean-section-region',
+                [],
+                [geometry, operand],
+                () => unionSectionShape(geometry.value.shape, operand.value),
+              ),
+            });
+          }
+          const nextGeometry = evaluateSolidGeometry(
+            `boolean-${operation}`,
+            [otherIndex],
+            [geometry, operand],
+            () => {
+              const result = booleanWithTopology(
+                {
+                  shape: geometry.value.shape,
+                  topology: geometry.value.topology,
+                  index: otherIndex === 0 ? 1 : undefined,
+                },
+                {
+                  shape: operand.value,
+                  topology: otherGeometry.value.topology,
+                  index: otherIndex + 2,
+                },
+                operation,
+              );
+              return {shape: result.shape, topology: result.topology};
+            },
           );
-      return {
-        id: constraint.id,
-        kind: 'align',
-        source: anchorSnapshot(source, constraint.source),
-        target: anchorSnapshot(target, constraint.target),
-        sourceElement: source.relationElement(constraint.source),
-        targetElement: target.relationElement(constraint.target),
-        offsetDirection: 1,
-        offset: constraint.offset ?? origin,
-        offsetFrame: toTransform(offsetFrame),
-        sourceRefs: [...valueTrace(constraint).sourceRefs],
-        parameters: [...valueTrace(constraint).parameters],
-      };
+          temporaryGeometry?.value.shape.delete();
+          temporaryGeometry = nextGeometry;
+          geometry = nextGeometry;
+        } finally {
+          operand.value.delete();
+        }
+      }
+      evaluated = true;
+      return {geometry, regions};
+    } finally {
+      if (!evaluated) {
+        temporaryGeometry?.value.shape.delete();
+        regions.forEach(region => region.artifact.value.delete());
+      }
     }
-    const orientation = composeTransforms(
-      invertTransform(rotation(offsetFrame.quaternion)),
-      rotation(sourcePose.quaternion),
-    ).quaternion;
-    const bounds = source[referenceBounds](
-      constraint.source,
-      rotation(orientation),
-    );
-    const center: Vec3 = [
-      (bounds[0][0] + bounds[1][0]) / 2,
-      bounds[constraint.target.bound!.facing === 1 ? 0 : 1][1],
-      (bounds[0][2] + bounds[1][2]) / 2,
-    ];
-    const sourceFrame = relativeTransform(
-      {
-        position: addVectors(
-          sourcePose.position,
-          rotateVector(center, offsetFrame.quaternion),
+  }
+
+  private allParameters(): ParameterUsage[] {
+    return uniqueParameters([
+      ...this.parameters,
+      ...this.constraints.flatMap(
+        constraint => valueTrace(constraint).parameters,
+      ),
+    ]);
+  }
+
+  private memberPoses(): Map<RelationObject, RigidTransform | null> {
+    const members = new Map<RelationObject, RigidTransform | null>([
+      [this, identityRigidTransform],
+    ]);
+    if (this.children.length) {
+      const context = this.assembly!;
+      for (const child of this.children) {
+        const pose = child.solvePose(context);
+        for (const [member, localPose] of child.memberPoses()) {
+          members.set(
+            member,
+            members.has(member) || localPose === null
+              ? null
+              : composeTransforms(pose, localPose),
+          );
+        }
+      }
+    }
+    return members;
+  }
+
+  /** Bounds of the selected finite geometry after a rigid transform. */
+  private [referenceBoundsParts](
+    reference: StoredAnchor,
+    transform: RigidTransform,
+  ): ({bounds: LocalBounds} | SnapshotQueryInput)[] {
+    if (reference.bound)
+      return [{bounds: super[referenceBounds](reference, transform)}];
+    if (reference.whole) {
+      if (this.geometry) {
+        const bounds = axisAlignedBounds(
+          this.geometry.value.localBounds,
+          transform,
+        );
+        return [bounds ? {bounds} : boundsQuery(this.geometry, transform)];
+      }
+      const context = this.assembly!;
+      return this.children.flatMap(child =>
+        child[referenceBoundsParts](
+          child.relationAnchorReference(),
+          composeTransforms(transform, child.solvePose(context)),
         ),
-        quaternion: offsetFrame.quaternion,
-      },
-      sourcePose,
+      );
+    }
+    if (reference.topology) {
+      const topology = reference.topology;
+      return [
+        boundsQuery(
+          topology.source.requireGeometry(),
+          composeTransforms(transform, topology.transform),
+          topology.selection,
+          topology.scale,
+        ),
+      ];
+    }
+    return [{bounds: super[referenceBounds](reference, transform)}];
+  }
+
+  /** Bounds of the selected finite geometry after a rigid transform. */
+  override [referenceBounds](
+    reference: StoredAnchor,
+    transform: RigidTransform,
+  ): LocalBounds {
+    const bounds = this[referenceBoundsParts](reference, transform).map(part =>
+      'bounds' in part
+        ? part.bounds
+        : (evaluateSnapshotQuery(part) as LocalBounds),
     );
-    const sourceSize: Vec3 = [
-      bounds[1][0] - bounds[0][0],
-      bounds[1][1] - bounds[0][1],
-      bounds[1][2] - bounds[0][2],
-    ];
-    for (const action of actions) {
-      if ('body' in action)
-        offsetFrame = composeTransforms(
-          axisRotation(
-            composeTransforms(
-              models[action.body].solvePose(context),
-              action.axis,
-            ),
-            action.angle,
-          ),
-          offsetFrame,
+    return bounds.length === 1 ? bounds[0] : combineBounds(bounds);
+  }
+
+  /** Pure query collection: it never substitutes geometry or runs author code. */
+  [modelSnapshotQueries](): SnapshotQueryInput[] {
+    const result: SnapshotQueryInput[] = [];
+    if (this.geometry || this.children.length) {
+      for (const direction of Object.values(boundDirections)) {
+        const transform = invertTransform(
+          rotation(frameFromYAxis(origin, direction).quaternion),
         );
+        for (const part of this[referenceBoundsParts](
+          this.relationAnchorReference(),
+          transform,
+        ))
+          if (!('bounds' in part)) result.push(part);
+      }
     }
-    return {
-      id: constraint.id,
-      kind: constraint.kind,
-      source: anchorSnapshot(source, constraint.source),
-      target: anchorSnapshot(target, constraint.target),
-      sourceBounds: {
-        size: sourceSize,
-        transform: toTransform(
-          composeTransforms(sourceFrame, {
-            position: [
-              0,
-              (constraint.target.bound!.facing * sourceSize[1]) / 2,
-              0,
-            ],
-            quaternion: [0, 0, 0, 1],
-          }),
+    if (this.geometry)
+      result.push(
+        meshQuery(
+          this.geometry,
+          this.geometry.value.shape,
+          this.meshTolerance,
+          this.geometry.value.topology,
         ),
-      },
-      sourceElement: {
-        name: `${constraint.source.name}:bound`,
-        kind: 'face',
-        transform: toTransform(sourceFrame),
-        bound: {
-          size: [sourceSize[0], sourceSize[2]],
-          facing: constraint.target.bound!.facing === 1 ? -1 : 1,
+      );
+    for (const region of this.operation.regions)
+      result.push(
+        meshQuery(region.artifact, region.artifact.value, this.meshTolerance),
+      );
+    return result;
+  }
+
+  protected override alignmentGeometry(
+    reference: StoredAnchor,
+  ): AlignmentGeometry {
+    if (reference.kind === 'point')
+      return {
+        kind: 'point',
+        point: reference.whole
+          ? (this.requireGeometry().value.shape as ReplicadVertex).asTuple()
+          : reference.transform.position,
+      };
+    const read = (shape: AnyShape) =>
+      reference.kind === 'line'
+        ? edgeGeometry(shape as ReplicadEdge, reference.direction ?? 1)
+        : faceGeometry(
+            shape as ReplicadFace,
+            reference.facing ?? reference.bound?.facing ?? 1,
+          );
+    if (reference.topology) {
+      const topology = reference.topology,
+        geometry = topology.source.requireGeometry().value;
+      return withTopologyShape(
+        geometry.shape,
+        geometry.topology,
+        topology.selection,
+        shape => {
+          const scaled =
+            topology.scale === 1
+              ? shape
+              : shapeWithScale(shape, topology.scale);
+          try {
+            return transformGeometry(read(scaled), topology.transform);
+          } finally {
+            if (scaled !== shape) scaled.delete();
+          }
         },
-      },
-      targetElement: {
-        name: constraint.target.name,
-        kind: 'face',
-        transform: toTransform(constraint.target.transform),
-        bound: constraint.target.bound,
-      },
-      offsetDirection: source === this ? 1 : -1,
-      offset: constraint.offset ?? origin,
-      offsetFrame: toTransform(offsetFrame),
-      sourceRefs: [...valueTrace(constraint).sourceRefs],
-      parameters: [...valueTrace(constraint).parameters],
-    };
+      );
+    }
+    if (reference.whole) return read(this.requireGeometry().value.shape);
+    return super.alignmentGeometry(reference);
+  }
+
+  protected override relationElement(reference: StoredAnchor): ElementSnapshot {
+    return super.relationElement(
+      reference.whole
+        ? {
+            ...this.exposedElement(),
+            name: reference.name,
+            direction: reference.direction,
+            facing: reference.facing,
+          }
+        : reference,
+    );
+  }
+
+  protected override vertexPosition(id: VertexId): Vec3 {
+    return anchorReference(this.vertex(id)).transform.position;
+  }
+
+  protected copyRelations(init: RelationObjectInit): ModelObject {
+    return this.copy(init, this.operation);
+  }
+
+  /** Fix the assembly frame once, using only its direct member origins. */
+  private static createAssembly(
+    children: readonly ModelObject[],
+  ): SolveContext {
+    const context = ModelObject.createSolveContext(children);
+    const center = children.length
+      ? boundsCenter(
+          pointBounds(children.map(child => child.solvePose(context).position)),
+        )
+      : origin;
+    return transformSolveContext(context, translation(negateVector(center)));
   }
 
   private requireGeometry(): ModelGeometry {
@@ -3659,39 +3894,34 @@ export function regularPrism(
 }
 
 /** @internal */
-export function modelFromReplicadSolid(shape: Shape3D): SolidModel {
-  let solid: Shape3D;
-  try {
-    solid = normalizeReplicadSolid(shape);
-  } catch (error) {
-    shape.delete();
-    throw error;
-  }
-  // The builder still executes on every call. Cache its actual output, not its
-  // arguments: captured state may change the geometry between invocations.
-  let adopted = false;
-  let geometry: SolidGeometry;
-  try {
-    geometry = evaluateSolidGeometry(
-      'replicad-solid',
-      [solid.serialize()],
-      [],
-      () => {
-        adopted = true;
-        return {shape: solid};
-      },
-    );
-  } finally {
-    // A hit returns an independently owned cached copy; discard this output.
-    // A miss transfers ownership to evaluateSolidGeometry, including on error.
-    if (!adopted) solid.delete();
-  }
-  return ModelObject.create<CanonicalElements, 'solid'>({
-    kind: 'solid',
-    name: 'Custom primitive',
-    geometry,
-    operation: storedOperation('primitive'),
-  }) as unknown as SolidModel;
+export function primitiveConstructor<Args extends unknown[]>(
+  build: (...args: Args) => Shape3D,
+): (...args: Args) => SolidModel {
+  const geometry = cachedArtifact(
+    (...args: Args) => {
+      const shape = build(...args);
+      let solid: Shape3D;
+      try {
+        solid = normalizeReplicadSolid(shape);
+      } catch (error) {
+        shape.delete();
+        throw error;
+      }
+      return createModelGeometryValue(solid);
+    },
+    {
+      identity: build,
+      namespace: 'primitive',
+      lifecycle: modelGeometryLifecycle,
+    },
+  );
+  return (...args) =>
+    ModelObject.create<CanonicalElements, 'solid'>({
+      kind: 'solid',
+      name: 'Custom primitive',
+      geometry: geometry(...args) as SolidGeometry,
+      operation: storedOperation('primitive'),
+    }) as unknown as SolidModel;
 }
 
 function normalizeReplicadSolid(shape: Shape3D): Shape3D {
@@ -3780,15 +4010,55 @@ export 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.param distance {kind: 'length', default: 10, label: 'Extrusion distance'}
+ */
+export function extrude(face: FaceModel<{}>, distance: number): SolidModel;
+/**
+ * Extrudes each face independently.
+ * @code3d.param distance {kind: 'length', default: 10, label: 'Extrusion distance'}
+ */
+export function extrude(
+  faces: readonly FaceModel<{}>[],
+  distance: number,
+): readonly SolidModel[];
+export function extrude(
+  face: FaceModel<{}> | readonly FaceModel<{}>[],
+  distance = 10,
+): SolidModel | readonly SolidModel[] {
+  const faces = (Array.isArray(face) ? face : [face]).map(value =>
+    requireModelKind(
+      value,
+      'face',
+      'extrude requires a face model or an array of face models.',
+    ),
+  );
+  const solids = faces.map(value => value.extrude(distance));
+  return Array.isArray(face) ? solids : solids[0];
+}
+
+/**
+ * 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 function extrude(face: FaceModel<{}>, distance: number): SolidModel {
-  return requireModelKind(
-    face,
-    'face',
-    'extrude requires a single face model.',
-  ).extrude(distance);
+export function text(
+  content: string,
+  font: Font,
+  size: number,
+  options?: TextOptions,
+): readonly FaceModel[] {
+  return textGlyphs(content, font, size, options).flatMap(({regions, x, y}) =>
+    regions.value.map((region, index) => {
+      const geometry = evaluateModelGeometry(
+        'text',
+        [x, y, index],
+        [regions],
+        () => ({shape: textRegionFace(region, x, y)}),
+      );
+      return faceModel('text', 'Text face', geometry);
+    }),
+  );
 }
 
 export function cut(
@@ -3844,7 +4114,7 @@ export function instrumentConstraint(
 }
 
 export function instrumentModelOperation(
-  object: ModelObject,
+  object: RelationObject,
   instrumentation: ModelOperationInstrumentation,
 ): void {
   object.attachSource(instrumentation.sourceRef);
@@ -3854,6 +4124,7 @@ export function instrumentModelOperation(
     instrumentation.execution,
     instrumentation.order,
     instrumentation.sourceRef,
+    instrumentation.outputIndex,
   );
 }
 
@@ -3864,7 +4135,7 @@ export function constraintTraceReference(
 }
 
 export function modelObjectRuntimeInfo(
-  object: ModelObject,
+  object: RelationObject,
 ): ModelObjectRuntimeInfo {
   return {
     nodeId: object.nodeId,
@@ -3874,8 +4145,8 @@ export function modelObjectRuntimeInfo(
 }
 
 export function relatedModelObjects(
-  object: ModelObject,
-): readonly ModelObject[] {
+  object: RelationObject,
+): readonly RelationObject[] {
   return object.relatedObjects();
 }
 
@@ -3947,13 +4218,6 @@ function meshQuery(
   };
 }
 
-const queryLifecycle: KernelValueLifecycle<SnapshotQueryResult> = {
-  estimateBytes: estimateRetainedBytes,
-  retain: value => value,
-  instantiate: value => value,
-  release: () => {},
-};
-
 function computeSnapshotQuery(
   geometry: SnapshotQueryInput['geometry'],
   query: SnapshotQuery,
@@ -3967,14 +4231,13 @@ function computeSnapshotQuery(
       );
 }
 
-function evaluateSnapshotQuery(input: SnapshotQueryInput): SnapshotQueryResult {
-  const cached = findKernelOperation(input.query.key, queryLifecycle);
-  if (cached) return cached.value;
-  let value: SnapshotQueryResult;
-  if (input.query.kind === 'mesh') {
-    // Mesh from the serialized input in every execution mode. BinTools can
-    // renormalize a plane axis by a few ULPs, changing Delaunay diagonal ties.
-    // A local query and a remote query must therefore consume the same BREP.
+const snapshotQuery = cachedArtifact(
+  (input: SnapshotQueryInput): SnapshotQueryResult => {
+    if (input.query.kind !== 'mesh')
+      return computeSnapshotQuery(input.geometry, input.query);
+    // Local and remote meshes consume the same binary input: BinTools can
+    // renormalize plane axes by a few ULPs and change Delaunay diagonal ties.
+    let value!: SnapshotQueryResult;
     executeSnapshotQueryBatch(
       input.inputId,
       encodeKernelArtifact(input.inputId, input.geometry),
@@ -3984,9 +4247,13 @@ function evaluateSnapshotQuery(input: SnapshotQueryInput): SnapshotQueryResult {
         value = result;
       },
     );
-  } else value = computeSnapshotQuery(input.geometry, input.query);
-  acceptKernelOperation(input.query.key, queryLifecycle, value!);
-  return value!;
+    return value;
+  },
+  {key: input => input.query.key},
+);
+
+function evaluateSnapshotQuery(input: SnapshotQueryInput): SnapshotQueryResult {
+  return snapshotQuery(input).value;
 }
 
 /** Host-owned native input and result admission. Only encode() bytes cross runtimes. */
@@ -4000,10 +4267,13 @@ export type SnapshotQueryBatch = Readonly<{
 }>;
 
 export function planModelSnapshotQueries(
-  objects: readonly ModelObject[],
+  objects: readonly RelationObject[],
 ): SnapshotQueryBatch[] {
   const visited = new Set<ModelObject>();
-  const keys = new Map<string, string>();
+  const inputs = new Map<
+    string,
+    {input: SnapshotQueryInput; sourceRef?: SourceRef}
+  >();
   const batches = new Map<
     string,
     {input: SnapshotQueryInput; queries: SnapshotQuery[]; sourceRef?: SourceRef}
@@ -4012,27 +4282,33 @@ export function planModelSnapshotQueries(
     if (visited.has(object)) return;
     visited.add(object);
     for (const input of object[modelSnapshotQueries]()) {
-      const {query, inputId} = input;
-      const signature = keys.get(query.key.id);
-      if (signature) {
-        if (signature !== query.key.signature)
+      const {query} = input;
+      const existing = inputs.get(query.key.id);
+      if (existing) {
+        if (existing.input.query.key.signature !== query.key.signature)
           throw new Error(
             `Kernel operation cache identity collision: ${query.key.id}`,
           );
         continue;
       }
-      keys.set(query.key.id, query.key.signature);
-      if (findKernelOperation(query.key, queryLifecycle)) continue;
-      let batch = batches.get(inputId);
-      if (!batch) {
-        batch = {input, queries: [], sourceRef: object.sourceRefs.at(-1)};
-        batches.set(inputId, batch);
-      }
-      batch.queries.push(query);
+      inputs.set(query.key.id, {input, sourceRef: object.sourceRefs.at(-1)});
     }
     object.children.forEach(collect);
   }
-  objects.forEach(collect);
+  objects.filter(isModelObject).forEach(collect);
+  const pending = [...inputs.values()];
+  const hits = snapshotQuery.findMany(
+    pending.map(({input}) => input.query.key),
+  );
+  pending.forEach(({input, sourceRef}, index) => {
+    if (hits[index]) return;
+    let batch = batches.get(input.inputId);
+    if (!batch) {
+      batch = {input, queries: [], sourceRef};
+      batches.set(input.inputId, batch);
+    }
+    batch.queries.push(input.query);
+  });
   return [...batches].map(([id, {input, queries, sourceRef}]) => ({
     id,
     queries,
@@ -4043,8 +4319,7 @@ export function planModelSnapshotQueries(
         (input.geometry.topology?.surfaces.ids.length ?? 0)) *
       queries.length,
     encode: () => encodeKernelArtifact(id, input.geometry),
-    accept: (query, value) =>
-      acceptKernelOperation(query.key, queryLifecycle, value),
+    accept: (query, value) => snapshotQuery.accept(query.key, value),
   }));
 }
 
@@ -4074,16 +4349,16 @@ export function executeSnapshotQueryBatch(
 }
 
 export function createModelSnapshotter(): (
-  object: ModelObject,
+  object: RelationObject,
 ) => ModelSnapshotObject {
   const meshCache = new Map<AnyShape, RenderMesh>();
   return object => object.toSnapshot(meshCache);
 }
 
-export function disposeModelObjects(objects: Iterable<ModelObject>): void {
+export function disposeModelObjects(objects: Iterable<RelationObject>): void {
   const disposed = new Set<AnyShape>();
   for (const object of objects) {
-    object.disposeShape(disposed);
+    if (isModelObject(object)) object.disposeShape(disposed);
   }
 }
 
@@ -4099,7 +4374,7 @@ export type ModelGeometrySnapshot = Readonly<{
 }>;
 
 export function retainModelGeometry(
-  objects: Iterable<ModelObject>,
+  objects: Iterable<RelationObject>,
 ): ModelGeometrySnapshot {
   const retained = new Map<AnyShape, AnyShape>();
   const shapes = new Map<string, AnyShape>();
@@ -4112,6 +4387,7 @@ export function retainModelGeometry(
   };
   try {
     for (const object of objects) {
+      if (!isModelObject(object)) continue;
       const geometry = object[modelGeometry]()?.value;
       const original = geometry?.shape;
       if (!original) continue;
@@ -4141,6 +4417,10 @@ export function retainModelGeometry(
 }
 
 export const authoringApi = Object.freeze({
+  cached,
+  font,
+  googleFont,
+  text,
   sketch,
   circle,
   ellipse,
@@ -4188,7 +4468,7 @@ function storedOperation(
 function storedOperationId(operation: StoredOperation): string {
   const trace = operationTraces.get(operation);
   return trace
-    ? `${trace.siteId}:execution:${trace.execution}`
+    ? `${trace.siteId}:execution:${trace.execution}:output:${trace.outputIndex ?? 0}`
     : operation.runtimeId;
 }
 
@@ -4233,45 +4513,49 @@ function disposeModelGeometryValue(geometry: ModelGeometryValue): void {
   geometry.referenceBasis?.shape.delete();
 }
 
+const kernelShape = cachedArtifact(
+  (
+    _operation: string,
+    _arguments: readonly KernelKeyPart[],
+    _inputs: readonly KernelArtifact<unknown>[],
+    compute: () => AnyShape,
+  ) => compute(),
+  {key: kernelOperationKey, lifecycle: shapeLifecycle},
+);
+
 function evaluateKernelShape<Shape extends AnyShape>(
   operation: string,
   arguments_: readonly KernelKeyPart[],
   inputs: readonly KernelArtifact<unknown>[],
   compute: () => Shape,
 ): KernelArtifact<Shape> {
-  return evaluateKernelOperation(
+  return kernelShape(
     operation,
     arguments_,
     inputs,
-    shapeLifecycle as KernelValueLifecycle<Shape>,
     compute,
-  );
+  ) as KernelArtifact<Shape>;
 }
 
-function evaluateModelGeometry(
-  operation: string,
-  arguments_: readonly KernelKeyPart[],
-  inputs: readonly KernelArtifact<unknown>[],
-  compute: () => Readonly<{
-    shape: AnyShape;
-    topology?: ShapeTopology;
-    referenceBasis?: ModelGeometryValue['referenceBasis'];
-  }>,
-): ModelGeometry {
-  return evaluateKernelOperation(
-    operation,
-    arguments_,
-    inputs,
-    modelGeometryLifecycle,
-    () => {
-      const result = compute();
-      return {
-        ...createModelGeometryValue(result.shape, result.topology),
-        referenceBasis: result.referenceBasis,
-      };
-    },
-  );
-}
+const evaluateModelGeometry = cachedArtifact(
+  (
+    _operation: string,
+    _arguments: readonly KernelKeyPart[],
+    _inputs: readonly KernelArtifact<unknown>[],
+    compute: () => Readonly<{
+      shape: AnyShape;
+      topology?: ShapeTopology;
+      referenceBasis?: ModelGeometryValue['referenceBasis'];
+    }>,
+  ): ModelGeometryValue => {
+    const result = compute();
+    return {
+      ...createModelGeometryValue(result.shape, result.topology),
+      referenceBasis: result.referenceBasis,
+    };
+  },
+  {key: kernelOperationKey, lifecycle: modelGeometryLifecycle},
+);
 
 function createModelGeometryValue(
   shape: AnyShape,
@@ -4378,6 +4662,8 @@ function meshUVs(
         location,
         0,
       );
+      // Native meshing can omit a face below its geometric tolerance.
+      if (!triangulation) continue;
       try {
         if (triangulation.isNull()) continue;
         if (!triangulation.HasUVNodes()) return undefined;
@@ -4425,7 +4711,11 @@ type PlanarSketch = Readonly<{
 }>;
 
 /** Internal bridge from the kernel-independent sketch definition to model geometry. */
-export function sketchFaceModel(region: SketchRegion): FaceModel {
+function sketchFaceModel(
+  region: SketchRegion,
+  constraints: readonly StoredConstraint[],
+  source: SketchFrame,
+): FaceModel {
   const curves = [region.outer, ...region.holes].map(loop =>
     loop.map(curve =>
       curve.kind === 'line'
@@ -4445,10 +4735,13 @@ export function sketchFaceModel(region: SketchRegion): FaceModel {
   return ModelObject.create<PlanarElements, 'face'>({
     kind: 'face',
     name: 'Sketch face',
+    constraints,
     geometry,
     geometryAnchor: plane,
     elements: {plane},
-    operation: storedOperation('sketchFace'),
+    operation: storedOperation('sketchFace', [
+      {model: source, role: 'source', index: 0},
+    ]),
   }) as unknown as FaceModel;
 }
 
@@ -4471,6 +4764,14 @@ function planarFaceModel(
       sketch.delete();
     }
   });
+  return faceModel(operation, name, geometry);
+}
+
+function faceModel(
+  operation: ModelOperationKind,
+  name: string,
+  geometry: ModelGeometry,
+): FaceModel {
   const plane: StoredElement = {
     kind: 'face',
     transform: identityRigidTransform,
@@ -4607,14 +4908,47 @@ function solidElements(bounds: LocalBounds): StoredElements {
   return {axis: {kind: 'line', transform: translation(boundsCenter(bounds))}};
 }
 
-function constraintReferences(constraint: StoredConstraint): ModelObject[] {
+function constraintReferences(constraint: StoredConstraint): RelationObject[] {
   return [
     constraint.source.model,
     constraint.target.model,
     ...constraint.rotations.map(action =>
       action.pivot.kind === 'around' ? action.pivot.axis.model : undefined,
     ),
-  ].filter((model): model is ModelObject => !!model);
+  ].filter((model): model is RelationObject => !!model);
+}
+
+/** Signed axis permutations preserve tight bounds; arbitrary rotations do not. */
+function axisAlignedBounds(
+  bounds: LocalBounds,
+  transform: RigidTransform,
+): LocalBounds | undefined {
+  const axes = (
+    [
+      [1, 0, 0],
+      [0, 1, 0],
+      [0, 0, 1],
+    ] as const
+  ).map(axis => rotateVector(axis, transform.quaternion));
+  // Account only for floating-point roundoff in quarter-turn quaternion products.
+  if (
+    axes.some(axis =>
+      axis.some(
+        value => Math.abs(value - Math.round(value)) > 8 * Number.EPSILON,
+      ),
+    )
+  )
+    return;
+  return [0, 1].map(side =>
+    axes[0].map((_, output) => {
+      const input = axes.findIndex(axis => Math.abs(axis[output]) > 0.5);
+      const sign = Math.round(axes[input][output]);
+      return (
+        transform.position[output] +
+        sign * bounds[sign > 0 ? side : 1 - side][input]
+      );
+    }),
+  ) as unknown as LocalBounds;
 }
 
 function computeTransformedBounds(
@@ -4699,7 +5033,7 @@ function directionalBound(
 }
 
 function modelAnchor<Kind extends ElementKind>(
-  model: ModelObject,
+  model: RelationObject,
   name: string,
   element: StoredElement & Readonly<{kind: Kind}>,
 ): Anchor<Kind> {
@@ -4875,7 +5209,7 @@ function topologyName(selection: TopologySelection): string {
 }
 
 function topologyReferences(
-  model: ModelObject,
+  model: RelationObject,
   prefix: string,
   context: Omit<StoredTopology, 'selection'>,
   kind: TopologyKind,
@@ -4957,14 +5291,14 @@ function anchorReference(anchor: Anchor): AnchorReference {
 
 function anchorSnapshot(reference: AnchorReference): ConstraintAnchorSnapshot;
 function anchorSnapshot(
-  model: ModelObject,
+  model: RelationObject,
   anchor: StoredAnchor,
 ): ConstraintAnchorSnapshot;
 function anchorSnapshot(
-  modelOrReference: ModelObject | AnchorReference,
+  modelOrReference: RelationObject | AnchorReference,
   stored?: StoredAnchor,
 ): ConstraintAnchorSnapshot {
-  const model = stored ? (modelOrReference as ModelObject) : undefined;
+  const model = stored ? (modelOrReference as RelationObject) : undefined;
   const reference = stored ?? (modelOrReference as AnchorReference);
   return {
     nodeId: (model ?? (modelOrReference as AnchorReference).model).nodeId,
@@ -4973,7 +5307,7 @@ function anchorSnapshot(
   };
 }
 
-function uniqueModels(models: readonly ModelObject[]): ModelObject[] {
+function uniqueModels<T extends RelationObject>(models: readonly T[]): T[] {
   return [...new Set(models)];
 }