@code3d/core 0.0.1-alpha.4 → 0.0.1-alpha.6

package/bld/chunks/{chunk-J77FMYFY.js → chunk-T3RAUNSF.js}

@@ -132,12 +132,12 @@ var binaryTypes = {
 };
 function encodeKernelArtifact(signature, value) {
   const chunks = [];
-  let offset = 0;
+  let offset2 = 0;
   const references2 = /* @__PURE__ */ new Map();
   function binary(kind, bytes2) {
-    const node = [kind, [offset, bytes2.byteLength]];
+    const node = [kind, [offset2, bytes2.byteLength]];
     chunks.push(bytes2);
-    offset += bytes2.byteLength;
+    offset2 += bytes2.byteLength;
     return node;
   }
   __name(binary, "binary");
@@ -202,13 +202,13 @@ function encodeKernelArtifact(signature, value) {
   }
   __name(encodeObject, "encodeObject");
   const metadata = encoder.encode(JSON.stringify([signature, encode(value)]));
-  const bytes = new Uint8Array(4 + metadata.byteLength + offset);
+  const bytes = new Uint8Array(4 + metadata.byteLength + offset2);
   new DataView(bytes.buffer).setUint32(0, metadata.byteLength, true);
   bytes.set(metadata, 4);
-  offset = 4 + metadata.byteLength;
+  offset2 = 4 + metadata.byteLength;
   for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
+    bytes.set(chunk, offset2);
+    offset2 += chunk.byteLength;
   }
   return bytes;
 }
@@ -280,20 +280,20 @@ function decodeKernelArtifact(bytes, signature) {
         return object;
       }
       case "view": {
-        const [name, buffer, offset, length] = data;
+        const [name, buffer, offset2, length] = data;
         if (!Object.hasOwn(binaryTypes, name))
           throw new Error("Invalid kernel artifact view");
         return register(
-          new binaryTypes[name](decode(buffer), offset, length)
+          new binaryTypes[name](decode(buffer), offset2, length)
         );
       }
       case "shape":
       case "ArrayBuffer": {
-        const [offset, length] = data;
-        if (!Number.isSafeInteger(offset) || !Number.isSafeInteger(length) || offset < 0 || length < 0 || start + offset + length > bytes.byteLength) {
+        const [offset2, length] = data;
+        if (!Number.isSafeInteger(offset2) || !Number.isSafeInteger(length) || offset2 < 0 || length < 0 || start + offset2 + length > bytes.byteLength) {
           throw new Error("Invalid kernel artifact binary range");
         }
-        const chunk = bytes.slice(start + offset, start + offset + length);
+        const chunk = bytes.slice(start + offset2, start + offset2 + length);
         if (kind === "ArrayBuffer") return register(chunk.buffer);
         const shape = decodeShape(chunk);
         shapes.push(shape);
@@ -386,6 +386,11 @@ function createComputationCache({
   const persisted = /* @__PURE__ */ new Set();
   const pendingPersistence = /* @__PURE__ */ new Map();
   let externalBytes = 0;
+  function setKernelCacheBudget2(bytes) {
+    maximumBytes = bytes;
+    evictHistoricalEntries();
+  }
+  __name(setKernelCacheBudget2, "setKernelCacheBudget");
   function setKernelExternalBytes2(bytes) {
     externalBytes = bytes;
     evictHistoricalEntries();
@@ -624,6 +629,7 @@ function createComputationCache({
     beginKernelOperationEvaluation: beginKernelOperationEvaluation2,
     clearKernelOperationCache: clearKernelOperationCache2,
     kernelOperationCacheStats: kernelOperationCacheStats2,
+    setKernelCacheBudget: setKernelCacheBudget2,
     setKernelArtifactStore: setKernelArtifactStore2,
     findKernelOperation: findKernelOperation2,
     findKernelOperations: findKernelOperations2,
@@ -642,6 +648,7 @@ var {
   beginKernelOperationEvaluation,
   clearKernelOperationCache,
   kernelOperationCacheStats,
+  setKernelCacheBudget,
   setKernelArtifactStore,
   findKernelOperation,
   findKernelOperations,
@@ -1974,12 +1981,12 @@ function candidates(first, second, tolerance2) {
     const gap = Math.abs(perpendicular2);
     if (gap > second.radius + tolerance2) return [];
     const normalized = gap / second.radius;
-    const offset = Math.abs(gap - second.radius) <= tolerance2 ? 0 : second.radius * Math.sqrt(Math.max(0, (1 - normalized) * (1 + normalized)));
+    const offset2 = Math.abs(gap - second.radius) <= tolerance2 ? 0 : second.radius * Math.sqrt(Math.max(0, (1 - normalized) * (1 + normalized)));
     const foot2 = [
       second.center[0] + perpendicular2 * unit3[1],
       second.center[1] - perpendicular2 * unit3[0]
     ];
-    return [-offset, offset].map((along2) => [
+    return [-offset2, offset2].map((along2) => [
       foot2[0] + along2 * unit3[0],
       foot2[1] + along2 * unit3[1]
     ]);
@@ -2001,9 +2008,9 @@ function candidates(first, second, tolerance2) {
     first.center[0] + along * scale3 * unit2[0],
     first.center[1] + along * scale3 * unit2[1]
   ];
-  return [-height, height].map((offset) => [
-    foot[0] - offset * unit2[1],
-    foot[1] + offset * unit2[0]
+  return [-height, height].map((offset2) => [
+    foot[0] - offset2 * unit2[1],
+    foot[1] + offset2 * unit2[0]
   ]);
 }
 __name(candidates, "candidates");
@@ -3333,7 +3340,17 @@ function stableEdgeGroups(shape, topology, groups) {
       topology,
       groups.map((group2) => group2.edgeId)
     );
-    return groups.map((group2, index) => ({ ...group2, edgeId: ids[index] }));
+    const linear = new Map(
+      edges.map((edge) => [
+        edge.hashCode,
+        edge.geomType === "LINE"
+      ])
+    );
+    return groups.map((group2, index) => ({
+      ...group2,
+      edgeId: ids[index],
+      linear: linear.get(group2.edgeId) ?? false
+    }));
   } finally {
     deleteShapes(edges);
   }
@@ -5163,6 +5180,28 @@ function modelMaterialColor(snapshot) {
 __name(modelMaterialColor, "modelMaterialColor");
 
 // packages/core/src/library/bound-solver.ts
+function externalRotationFrame(action, self, reference, inverse = false) {
+  if ("axis" in action) {
+    const axis = composeTransforms(rotation(reference), action.axis);
+    return {
+      center: axis.position,
+      quaternion: axisRotation(axis, inverse ? -action.angle : action.angle).quaternion
+    };
+  }
+  const local = inverse ? invertTransform(rotation(action.rotation)) : rotation(action.rotation);
+  const before = inverse ? composeTransforms(rotation(self), local) : rotation(self);
+  return {
+    center: addVectors(
+      rotateVector(action.point, reference),
+      rotateVector(action.displacement, before.quaternion)
+    ),
+    quaternion: composeTransforms(
+      composeTransforms(before, local),
+      invertTransform(before)
+    ).quaternion
+  };
+}
+__name(externalRotationFrame, "externalRotationFrame");
 var axes = [
   [1, 0, 0],
   [0, 1, 0],
@@ -5194,28 +5233,15 @@ function solveBodies(bodies) {
         "Cyclic external rotation axes cannot determine an authored orientation."
       );
     visiting.add(index);
-    const candidates2 = bodies[index].relations.filter((r) => r.rotations.length).map((relation) => {
-      let pose2 = identityRigidTransform;
-      for (const action of relation.rotations) {
-        pose2 = "local" in action ? composeTransforms(pose2, action.local) : composeTransforms(
-          axisRotation(
-            composeTransforms(seed2(action.body), action.axis),
-            action.angle
-          ),
-          pose2
-        );
-      }
-      return pose2;
-    });
-    const pose = candidates2[0] ?? identityRigidTransform;
-    if (candidates2.some(
-      (candidate) => !transformsAreEquivalent(
-        rotation(candidate.quaternion),
-        rotation(pose.quaternion)
-      )
-    )) {
-      throw new Error(
-        `Conflicting explicit rotations for ${bodies[index].name}.`
+    let pose = bodies[index].initial ?? identityRigidTransform;
+    for (const action of bodies[index].transformations ?? []) {
+      if ("offset" in action) continue;
+      pose = "local" in action ? composeTransforms(pose, action.local) : "point" in action ? composeTransforms(pose, rotation(action.rotation)) : composeTransforms(
+        axisRotation(
+          composeTransforms(seed2(action.body), action.axis),
+          action.angle
+        ),
+        pose
       );
     }
     visiting.delete(index);
@@ -5232,17 +5258,18 @@ function solveBodies(bodies) {
     const known = positioned.get(index);
     if (known) return known;
     let pose = {
-      quaternion: identityRigidTransform.quaternion,
+      quaternion: (bodies[index].initial ?? identityRigidTransform).quaternion,
       position: {
-        constant: origin,
+        constant: (bodies[index].initial ?? identityRigidTransform).position,
         columns: variables.flatMap(
           (body) => axes.map((axis) => body === index ? axis : origin)
         )
       }
     };
-    const actions = bodies[index].relations.find((relation) => relation.rotations.length)?.rotations ?? [];
-    for (const action of actions) {
-      if ("local" in action) {
+    for (const action of bodies[index].transformations ?? []) {
+      if ("offset" in action) {
+        pose = { ...pose, position: shiftPoint(pose.position, action.offset) };
+      } else if ("local" in action) {
         pose = {
           position: shiftPoint(
             pose.position,
@@ -5255,12 +5282,12 @@ function solveBodies(bodies) {
         };
       } else {
         const axisPose = positionBody(action.body);
-        const axis = composeTransforms(
-          rotation(axisPose.quaternion),
-          action.axis
+        const { center, quaternion: q } = externalRotationFrame(
+          action,
+          pose.quaternion,
+          axisPose.quaternion
         );
-        const q = axisRotation(axis, action.angle).quaternion;
-        const axisPoint = shiftPoint(axisPose.position, axis.position);
+        const axisPoint = shiftPoint(axisPose.position, center);
         const rotatedAxis = rotatePoint(axisPoint, q);
         pose = {
           position: addPoints(
@@ -5282,12 +5309,16 @@ function solveBodies(bodies) {
   const preferences = /* @__PURE__ */ new Map();
   bodies.forEach(
     (body, owner) => body.relations.forEach((relation) => {
-      const baseline = undoRotations(poses[owner], relation.rotations, poses);
+      const baseline = undoActions(
+        poses[owner],
+        body.transformations ?? [],
+        poses
+      );
       for (let axis = 0; axis < 3; axis++) {
         const preference = {
           id: relation.id,
           coefficients: baseline.position.columns.map((column) => column[axis]),
-          value: -baseline.position.constant[axis]
+          value: (body.initial?.position[axis] ?? 0) - baseline.position.constant[axis]
         };
         preferences.set(
           JSON.stringify([preference.coefficients, preference.value]),
@@ -5315,14 +5346,8 @@ function solveBodies(bodies) {
         source.position,
         rotateVector(center, targetFrame.quaternion)
       );
-      const targetPoint = shiftPoint(
-        target.position,
-        addVectors(
-          targetFrame.position,
-          rotateVector(relation.offset ?? origin, targetFrame.quaternion)
-        )
-      );
-      for (const localAxis of relation.offset ? axes : [axes[1]]) {
+      const targetPoint = shiftPoint(target.position, targetFrame.position);
+      for (const localAxis of [axes[1]]) {
         const normal = rotateVector(localAxis, targetFrame.quaternion);
         equations.push({
           id: relation.id,
@@ -5357,8 +5382,8 @@ function solveBodies(bodies) {
   }));
 }
 __name(solveBodies, "solveBodies");
-function shiftPoint(point3, offset) {
-  return { ...point3, constant: addVectors(point3.constant, offset) };
+function shiftPoint(point3, offset2) {
+  return { ...point3, constant: addVectors(point3.constant, offset2) };
 }
 __name(shiftPoint, "shiftPoint");
 function rotatePoint(point3, quaternion) {
@@ -5377,9 +5402,14 @@ function addPoints(left, right) {
   };
 }
 __name(addPoints, "addPoints");
-function undoRotations(pose, actions, poses) {
+function undoActions(pose, actions, poses) {
   for (const action of [...actions].reverse()) {
-    if ("local" in action) {
+    if ("offset" in action) {
+      pose = {
+        ...pose,
+        position: shiftPoint(pose.position, negateVector(action.offset))
+      };
+    } else if ("local" in action) {
       const inverse = invertTransform(action.local);
       pose = {
         position: shiftPoint(
@@ -5393,12 +5423,13 @@ function undoRotations(pose, actions, poses) {
       };
     } else {
       const axisPose = poses[action.body];
-      const axis = composeTransforms(
-        rotation(axisPose.quaternion),
-        action.axis
+      const { center, quaternion: q } = externalRotationFrame(
+        action,
+        pose.quaternion,
+        axisPose.quaternion,
+        true
       );
-      const q = axisRotation(axis, -action.angle).quaternion;
-      const axisPoint = shiftPoint(axisPose.position, axis.position);
+      const axisPoint = shiftPoint(axisPose.position, center);
       const rotatedAxis = rotatePoint(axisPoint, q);
       pose = {
         position: addPoints(
@@ -5414,7 +5445,7 @@ function undoRotations(pose, actions, poses) {
   }
   return pose;
 }
-__name(undoRotations, "undoRotations");
+__name(undoActions, "undoActions");
 function solveTranslations(equations, preferences, dimension) {
   const basis = [];
   const magnitude = Math.max(
@@ -5503,54 +5534,40 @@ function solveTranslations(equations, preferences, dimension) {
 __name(solveTranslations, "solveTranslations");
 
 // packages/core/src/library/relation-solver.ts
-function beforeRelation(pose, relation, poses, owner) {
-  for (const action of [...relation.rotations].reverse())
-    pose = "local" in action ? composeTransforms(pose, invertTransform(action.local)) : composeTransforms(
-      axisRotation(
-        composeTransforms(poses[action.body], action.axis),
-        -action.angle
-      ),
-      pose
-    );
-  if (relation.kind === "align" && relation.offset) {
-    const target = relation.target.body === owner ? pose : poses[relation.target.body];
-    const frame = composeTransforms(target, relation.target.transform);
-    pose = {
-      ...pose,
-      position: subtract2(
-        pose.position,
-        rotateVector(relation.offset, frame.quaternion)
-      )
-    };
+function applyExternalRotation(pose, action, reference, inverse = false) {
+  const { center, quaternion } = externalRotationFrame(
+    action,
+    pose.quaternion,
+    reference.quaternion,
+    inverse
+  );
+  const point3 = addVectors(reference.position, center);
+  return composeTransforms(
+    { quaternion, position: subtract2(point3, rotateVector(point3, quaternion)) },
+    pose
+  );
+}
+__name(applyExternalRotation, "applyExternalRotation");
+function beforeTransformations(pose, relation, poses) {
+  for (const action of [...relation.actions].reverse()) {
+    if ("offset" in action) {
+      pose = { ...pose, position: subtract2(pose.position, action.offset) };
+    } else
+      pose = "local" in action ? composeTransforms(pose, invertTransform(action.local)) : applyExternalRotation(pose, action, poses[action.body], true);
   }
   return pose;
 }
-__name(beforeRelation, "beforeRelation");
-function afterRelation(pose, relation, poses, owner) {
-  if (relation.kind === "align" && relation.offset) {
-    const target = relation.target.body === owner ? pose : poses[relation.target.body];
-    pose = {
-      ...pose,
-      position: addVectors(
-        pose.position,
-        rotateVector(
-          relation.offset,
-          composeTransforms(target, relation.target.transform).quaternion
-        )
-      )
-    };
+__name(beforeTransformations, "beforeTransformations");
+function afterTransformations(pose, relation, poses) {
+  for (const action of relation.actions) {
+    if ("offset" in action) {
+      pose = { ...pose, position: addVectors(pose.position, action.offset) };
+    } else
+      pose = "local" in action ? composeTransforms(pose, action.local) : applyExternalRotation(pose, action, poses[action.body]);
   }
-  for (const action of relation.rotations)
-    pose = "local" in action ? composeTransforms(pose, action.local) : composeTransforms(
-      axisRotation(
-        composeTransforms(poses[action.body], action.axis),
-        action.angle
-      ),
-      pose
-    );
   return pose;
 }
-__name(afterRelation, "afterRelation");
+__name(afterTransformations, "afterTransformations");
 function directionRotation(from, to) {
   const product = dot(from, to);
   if (product < -1 + 1e-10) return [...perpendicular(from), 0];
@@ -5673,8 +5690,19 @@ function solveBodies2(bodies) {
       if (relation.kind === "align")
         validateAlignment(relation.source.geometry, relation.target.geometry);
   const active = bodies.flatMap(
-    (body, i) => body.relations.length ? [i] : []
+    (body, i) => body.relations.length || body.transformations?.length ? [i] : []
   );
+  const unplace = /* @__PURE__ */ __name((pose, owner, poses2) => beforeTransformations(
+    pose,
+    { actions: bodies[owner].transformations ?? [] },
+    poses2
+  ), "unplace");
+  const place = /* @__PURE__ */ __name((pose, owner, poses2) => afterTransformations(
+    pose,
+    { actions: bodies[owner].transformations ?? [] },
+    poses2
+  ), "place");
+  const baselinePose = /* @__PURE__ */ __name((pose, poses2, owner) => unplace(pose, owner, poses2), "baselinePose");
   const flexible = bodies.map(
     (body) => body.relations.some((r) => r.kind === "align")
   );
@@ -5685,26 +5713,13 @@ function solveBodies2(bodies) {
   const unique = [
     ...new Map(relations.map((entry) => [key(entry), entry])).entries()
   ].sort(([a], [b]) => a.localeCompare(b)).map(([, entry]) => entry);
-  let poses = bodies.map(() => identityRigidTransform);
-  for (const owner of active) {
-    const authored = unique.find(
-      (entry) => entry.owner === owner && entry.relation.rotations.length
-    )?.relation ?? unique.find(
-      (entry) => entry.owner === owner && entry.relation.kind === "align" && entry.relation.offset
-    )?.relation;
-    if (authored)
-      poses[owner] = afterRelation(
-        identityRigidTransform,
-        authored,
-        poses,
-        owner
-      );
-  }
+  let poses = bodies.map((body) => body.initial ?? identityRigidTransform);
+  for (const owner of active) poses[owner] = place(poses[owner], owner, poses);
   for (const { owner, relation } of unique) {
     if (relation.kind !== "align") continue;
     const sourceSelf = relation.source.body === owner;
     if (relation.target.body === relation.source.body) continue;
-    const baseline = beforeRelation(poses[owner], relation, poses, owner);
+    const baseline = baselinePose(poses[owner], poses, owner);
     const source = transformGeometry(
       relation.source.geometry,
       relation.source.body === owner ? baseline : poses[relation.source.body]
@@ -5713,12 +5728,7 @@ function solveBodies2(bodies) {
       relation.target.body === owner ? baseline : poses[relation.target.body]
     );
     const seed2 = sourceSelf ? alignmentSeed(source, target) : alignmentSeed(target, source);
-    poses[owner] = afterRelation(
-      composeTransforms(seed2, baseline),
-      relation,
-      poses,
-      owner
-    );
+    poses[owner] = place(composeTransforms(seed2, baseline), owner, poses);
   }
   const geometryScale = Math.max(
     1,
@@ -5728,12 +5738,23 @@ function solveBodies2(bodies) {
       ) : []
     )
   );
-  const variables = active.flatMap(
-    (body) => Array.from({ length: 6 }, (_, axis) => ({ body, axis }))
+  const fullVariables = active.flatMap(
+    (body) => (
+      // Bound-only bodies without authored rotations have exactly identity
+      // orientation. Do not numerically perturb those fixed axes: native bound
+      // queries can introduce noise that prevents convergence at the identity.
+      Array.from(
+        {
+          length: flexible[body] || bodies[body].transformations?.some((action) => !("offset" in action)) ? 6 : 3
+        },
+        (_, axis) => ({ body, axis })
+      )
+    )
   );
+  let variables = fullVariables.filter((variable) => variable.axis < 3);
   const residual2 = /* @__PURE__ */ __name((candidate) => [
     ...unique.flatMap(({ owner, relation: r }) => {
-      const baseline = beforeRelation(candidate[owner], r, candidate, owner);
+      const baseline = baselinePose(candidate[owner], candidate, owner);
       const source = r.source.body === owner ? baseline : candidate[r.source.body], target = r.target.body === owner ? baseline : candidate[r.target.body];
       if (r.kind === "align")
         return alignmentResidual(
@@ -5755,27 +5776,25 @@ function solveBodies2(bodies) {
         source.position,
         rotateVector(center, frame.quaternion)
       );
-      const b = composeTransforms(
-        frame,
-        translation(r.offset ?? origin)
-      ).position;
+      const b = frame.position;
       const delta = rotateVector(
         subtract2(a, b),
         invertTransform(frame).quaternion
       );
-      return r.offset ? [...delta] : [delta[1]];
+      return [delta[1]];
     }),
     ...active.flatMap((owner) => {
       if (flexible[owner]) return [];
-      const rotations = bodies[owner].relations.filter((r) => r.rotations.length);
-      return rotations.length ? rotations.flatMap(
-        (r) => beforeRelation(
-          candidate[owner],
-          r,
-          candidate,
-          owner
-        ).quaternion.slice(0, 3)
-      ) : candidate[owner].quaternion.slice(0, 3);
+      const initial = bodies[owner].initial ?? identityRigidTransform;
+      const unplaced = unplace(candidate[owner], owner, candidate);
+      const orientationResidual = /* @__PURE__ */ __name((pose) => composeTransforms(
+        invertTransform(rotation(initial.quaternion)),
+        rotation(pose.quaternion)
+      ).quaternion.slice(0, 3), "orientationResidual");
+      return [
+        ...bodies[owner].relations.length ? [] : subtract2(unplaced.position, initial.position),
+        ...orientationResidual(unplaced)
+      ];
     })
   ], "residual");
   const perturb = /* @__PURE__ */ __name((base, steps) => {
@@ -5795,10 +5814,61 @@ function solveBodies2(bodies) {
       };
     });
   }, "perturb");
+  const settleBoundTranslations = /* @__PURE__ */ __name(() => {
+    if (!active.some((owner) => !flexible[owner])) return poses;
+    const free = active.flatMap((body) => [0, 1, 2].map((axis) => ({ body, axis })));
+    if (!free.length) return poses;
+    const shift = /* @__PURE__ */ __name((steps) => {
+      const result = poses.map((pose) => ({
+        ...pose,
+        position: [...pose.position]
+      }));
+      free.forEach(({ body, axis }, i) => {
+        result[body].position[axis] += steps[i];
+      });
+      return result;
+    }, "shift");
+    const preferences = /* @__PURE__ */ __name((candidate2) => unique.filter(({ owner }) => !flexible[owner]).flatMap(
+      ({ owner }) => subtract2(
+        baselinePose(candidate2[owner], candidate2, owner).position,
+        bodies[owner].initial?.position ?? [0, 0, 0]
+      )
+    ), "preferences");
+    const h = 1e-5;
+    const initial = residual2(poses), preference = preferences(poses);
+    const columns = free.map((_, i) => {
+      const plus = shift(free.map((_2, j) => i === j ? h : 0));
+      const minus = shift(free.map((_2, j) => i === j ? -h : 0));
+      const a = residual2(plus), b = residual2(minus), p = preferences(plus), q = preferences(minus);
+      return {
+        constraints: a.map((v, j) => (v - b[j]) / (2 * h)),
+        preferences: p.map((v, j) => (v - q[j]) / (2 * h))
+      };
+    });
+    const step = solveTranslations(
+      initial.map((value, i) => ({
+        id: "bound translation",
+        value: -value,
+        coefficients: columns.map((column) => column.constraints[i])
+      })),
+      preference.map((value, i) => ({
+        id: "pre-action position",
+        value: -value,
+        coefficients: columns.map((column) => column.preferences[i])
+      })),
+      free.length
+    );
+    const candidate = shift(step);
+    return residual2(candidate).every((value) => Math.abs(value) < 1e-8) ? candidate : poses;
+  }, "settleBoundTranslations");
   let values = residual2(poses), damping = 1e-5;
   const norm = /* @__PURE__ */ __name((values2) => values2.reduce((sum, x) => sum + x * x, 0), "norm");
-  for (let iteration = 0; iteration < 160; iteration++) {
-    if (values.every((v) => Math.abs(v) < 1e-8)) return poses;
+  for (let iteration = 0; iteration < 168; iteration++) {
+    if (iteration === 8) {
+      variables = fullVariables;
+      damping = 1e-5;
+    }
+    if (values.every((v) => Math.abs(v) < 1e-8)) return settleBoundTranslations();
     const h = 1e-6;
     const columns = variables.map((_, i) => {
       const shifted = residual2(
@@ -5807,7 +5877,13 @@ function solveBodies2(bodies) {
           variables.map((_2, j) => i === j ? h : 0)
         )
       );
-      return values.map((v, j) => (shifted[j] - v) / h);
+      const opposite = residual2(
+        perturb(
+          poses,
+          variables.map((_2, j) => i === j ? -h : 0)
+        )
+      );
+      return values.map((_2, j) => (shifted[j] - opposite[j]) / (2 * h));
     });
     const multiply2 = /* @__PURE__ */ __name((a, b) => a.reduce((sum, x, i) => sum + x * b[i], 0), "multiply");
     const matrix = columns.map((a, i) => [
@@ -5830,10 +5906,10 @@ __name(solveBodies2, "solveBodies");
 function eliminate(matrix) {
   const n = matrix.length;
   for (let i = 0; i < n; i++) {
-    let pivot = i;
+    let pivot2 = i;
     for (let j = i + 1; j < n; j++)
-      if (Math.abs(matrix[j][i]) > Math.abs(matrix[pivot][i])) pivot = j;
-    [matrix[i], matrix[pivot]] = [matrix[pivot], matrix[i]];
+      if (Math.abs(matrix[j][i]) > Math.abs(matrix[pivot2][i])) pivot2 = j;
+    [matrix[i], matrix[pivot2]] = [matrix[pivot2], matrix[i]];
     for (let j = i + 1; j < n; j++) {
       const factor = matrix[j][i] / matrix[i][i];
       for (let k = i; k <= n; k++) matrix[j][k] -= factor * matrix[i][k];
@@ -5977,10 +6053,10 @@ function openShell(shape, topology, thickness, removedIds, sourceVolume) {
 __name(openShell, "openShell");
 function closedShell(shape, topology, thickness, sourceVolume) {
   const oc = getOC8();
-  const offset = new oc.BRepOffsetAPI_MakeOffsetShape();
+  const offset2 = new oc.BRepOffsetAPI_MakeOffsetShape();
   let parallel;
   try {
-    offset.PerformByJoin(
+    offset2.PerformByJoin(
       shape.wrapped,
       -thickness,
       tolerance,
@@ -5990,9 +6066,9 @@ function closedShell(shape, topology, thickness, sourceVolume) {
       oc.GeomAbs_JoinType.GeomAbs_Arc,
       false
     );
-    if (!offset.IsDone())
+    if (!offset2.IsDone())
       throw new Error("OpenCascade could not build the cavity offset.");
-    const raw = castOwnedShape3D(offset.Shape());
+    const raw = castOwnedShape3D(offset2.Shape());
     try {
       parallel = singleSolid(raw);
     } finally {
@@ -6049,7 +6125,7 @@ function closedShell(shape, topology, thickness, sourceVolume) {
     }
   } finally {
     parallel?.delete();
-    offset.delete();
+    offset2.delete();
   }
 }
 __name(closedShell, "closedShell");
@@ -17942,19 +18018,19 @@ function getAxisAlignedRayLoopIntersections(loop, p, dir) {
     }
     const ts7 = [];
     let f8;
-    let offset;
+    let offset2;
     let axis;
     const dirIsDecreasing = dir === "left" || dir === "up";
     if (dir === "left" || dir === "right") {
       f8 = /* @__PURE__ */ __name((ps2) => toPowerBasis(ps2)[1], "f");
-      offset = [0, -y];
+      offset2 = [0, -y];
       axis = 0;
     } else {
       f8 = /* @__PURE__ */ __name((ps2) => toPowerBasis(ps2)[0], "f");
-      offset = [-x, 0];
+      offset2 = [-x, 0];
       axis = 1;
     }
-    const translatedPs = ps.map(translate(offset));
+    const translatedPs = ps.map(translate(offset2));
     const poly = f8(translatedPs);
     const ts_ = roots(poly, 0 - DELTA, 1 + DELTA)?.map((r) => r.t) || [];
     for (let i2 = 0; i2 < ts_.length; i2++) {
@@ -19930,9 +20006,9 @@ import {
   measureShapeSurfaceProperties
 } from "replicad";
 function inspectShapeTopology(original, topology, options = {}) {
-  const offset = options.offset ?? 0;
+  const offset2 = options.offset ?? 0;
   const limit = options.limit ?? 48;
-  if (!Number.isSafeInteger(offset) || offset < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 200)
+  if (!Number.isSafeInteger(offset2) || offset2 < 0 || !Number.isSafeInteger(limit) || limit < 1 || limit > 200)
     throw new Error(
       "Topology pages require a nonnegative offset and a limit from 1 to 200."
     );
@@ -19980,7 +20056,7 @@ function inspectShapeTopology(original, topology, options = {}) {
         (id, index) => !options.ids || options.ids.some((requested) => sameTopologyId(requested, id)) ? [{ kind, id, index }] : []
       )
     );
-    const page = all.slice(offset, offset + limit);
+    const page = all.slice(offset2, offset2 + limit);
     const childIndices = /* @__PURE__ */ __name((parent, kind) => {
       const children = shapeSubshapes(parent, kind);
       try {
@@ -20059,8 +20135,8 @@ function inspectShapeTopology(original, topology, options = {}) {
         method: "kernel-enclosure"
       },
       total: all.length,
-      offset,
-      ...offset + page.length < all.length ? { nextOffset: offset + page.length } : {},
+      offset: offset2,
+      ...offset2 + page.length < all.length ? { nextOffset: offset2 + page.length } : {},
       items,
       units: "model",
       coordinates: "scene",
@@ -20188,6 +20264,18 @@ function inspectSurface(face) {
 __name(inspectSurface, "inspectSurface");
 
 // packages/core/src/library/runtime.ts
+function isAxisSelection(pivot2) {
+  return pivot2.kind === "axisLine" || pivot2.kind === "axisEdge";
+}
+__name(isAxisSelection, "isAxisSelection");
+function selectionReference(pivot2) {
+  return pivot2.kind === "axisLine" ? pivot2.axis : pivot2.kind === "pivotPoint" ? pivot2.point : void 0;
+}
+__name(selectionReference, "selectionReference");
+function mapSelectionReference(pivot2, map) {
+  return pivot2.kind === "axisLine" ? { ...pivot2, axis: map(pivot2.axis) } : pivot2.kind === "pivotPoint" ? { ...pivot2, point: map(pivot2.point) } : pivot2;
+}
+__name(mapSelectionReference, "mapSelectionReference");
 var activeRelate;
 var valueTraces = /* @__PURE__ */ new WeakMap();
 var operationTraces = /* @__PURE__ */ new WeakMap();
@@ -20208,6 +20296,7 @@ function valueTrace(value) {
 __name(valueTrace, "valueTrace");
 function transformSolveContext(context, transform) {
   return {
+    frame: composeTransforms(transform, context.frame),
     poses: new Map(
       [...context.poses].map(([model, pose]) => [
         model,
@@ -20436,7 +20525,7 @@ function modelTopologyReference(value) {
 __name(modelTopologyReference, "modelTopologyReference");
 function modelTopologyIds(value, kind) {
   const topology = value instanceof ModelTopologyElement ? value[anchorReferenceValue].topology : void 0;
-  const source = isModelObject(value) ? value : value instanceof ConstraintExpression ? value.self() : topology?.source;
+  const source = isModelObject(value) ? value : value instanceof RelationExpression ? value.self() : topology?.source;
   const geometry = isModelObject(source) ? source[modelGeometry]()?.value : void 0;
   if (!geometry) return void 0;
   return topologyChildren(
@@ -20447,40 +20536,27 @@ function modelTopologyIds(value, kind) {
   );
 }
 __name(modelTopologyIds, "modelTopologyIds");
-var ConstraintExpression = class {
-  constructor(kind, source, target, displacement, rotations, context, constraintId, previous) {
-    this.kind = kind;
-    this.source = source;
-    this.target = target;
-    this.displacement = displacement;
-    this.rotations = rotations;
+var RelationExpression = class {
+  constructor(definition, context, relationId, previous, spatialOperation) {
+    this.definition = definition;
     this.context = context;
-    this.constraintId = constraintId;
+    this.relationId = relationId;
+    this.spatialOperation = spatialOperation;
     valueTraces.set(this, {
       sourceRefs: [...previous ? valueTrace(previous).sourceRefs : []],
       parameters: [...previous ? valueTrace(previous).parameters : []]
     });
   }
-  kind;
-  source;
-  target;
-  displacement;
-  rotations;
+  definition;
   context;
-  constraintId;
+  relationId;
+  spatialOperation;
   static {
-    __name(this, "ConstraintExpression");
-  }
-  get sourceRefs() {
-    return valueTrace(this).sourceRefs;
-  }
-  get parameters() {
-    return valueTrace(this).parameters;
+    __name(this, "RelationExpression");
   }
-  spatialOperation;
   /** @internal */
   attachSource(sourceRef) {
-    const refs = this.sourceRefs;
+    const refs = valueTrace(this).sourceRefs;
     if (!refs.some(
       (ref) => ref.file === sourceRef.file && ref.start === sourceRef.start && ref.end === sourceRef.end
     ))
@@ -20488,7 +20564,7 @@ var ConstraintExpression = class {
   }
   /** @internal */
   attachParameters(parameters) {
-    appendUniqueParameters(this.parameters, parameters);
+    appendUniqueParameters(valueTrace(this).parameters, parameters);
   }
   /** @internal */
   self() {
@@ -20496,79 +20572,89 @@ var ConstraintExpression = class {
   }
   /** @internal */
   traceReference() {
+    if (this.definition.kind === "transformation")
+      return {
+        kind: "transformation",
+        transformationId: this.relationId,
+        self: this.context?.self
+      };
     const rebind = /* @__PURE__ */ __name((model) => model === this.context?.original ? this.context.self : model, "rebind");
     return {
-      constraintId: this.constraintId,
-      source: rebind(this.source.model),
-      target: rebind(this.target.model),
+      kind: "constraint",
+      constraintId: this.relationId,
+      source: rebind(this.definition.source.model),
+      target: rebind(this.definition.target.model),
       self: this.context?.self
     };
   }
   /** @internal */
   storeFor(model, original) {
     const isSelf = /* @__PURE__ */ __name((candidate) => candidate === model || candidate === original, "isSelf");
-    if (!isSelf(this.source.model) && !isSelf(this.target.model))
-      throw new Error(
-        "The constraint returned by relate() must involve self or the original receiver."
-      );
     const bind = /* @__PURE__ */ __name((reference) => ({
       ...reference,
       model: isSelf(reference.model) ? void 0 : reference.model
     }), "bind");
-    const stored = {
-      id: this.constraintId,
-      kind: this.kind,
-      source: bind(this.source),
-      target: bind(this.target),
-      offset: this.displacement,
-      rotations: this.rotations.map((action) => ({
-        ...action,
-        pivot: action.pivot.kind === "around" ? { ...action.pivot, axis: bind(action.pivot.axis) } : action.pivot
-      }))
+    const definition = this.definition;
+    if (definition.kind !== "transformation" && !isSelf(definition.source.model) && !isSelf(definition.target.model))
+      throw new Error(
+        "The constraint returned by relate() must involve self or the original receiver."
+      );
+    const stored = definition.kind === "transformation" ? {
+      kind: "transformation",
+      id: this.relationId,
+      actions: definition.actions.map((action) => {
+        const storedAction = {
+          ...action,
+          ..."pivot" in action ? {
+            pivot: mapSelectionReference(action.pivot, bind)
+          } : {}
+        };
+        valueTraces.set(storedAction, {
+          sourceRefs: [...valueTrace(action).sourceRefs],
+          parameters: [...valueTrace(action).parameters]
+        });
+        return storedAction;
+      })
+    } : {
+      kind: definition.kind,
+      id: this.relationId,
+      source: bind(definition.source),
+      target: bind(definition.target)
     };
     valueTraces.set(stored, {
-      sourceRefs: [...this.sourceRefs],
-      parameters: [...this.parameters]
+      sourceRefs: [...valueTrace(this).sourceRefs],
+      parameters: [...valueTrace(this).parameters]
     });
     return stored;
   }
   /** @internal */
-  preview() {
+  preview(preceding = []) {
     if (!this.context) return void 0;
-    const pivot = this.spatialOperation?.pivot;
-    const selection = pivot?.kind === "around" ? {
+    const pivot2 = this.spatialOperation?.pivot;
+    const selection = pivot2 ? {
       ...this.spatialOperation,
-      pivot: {
-        ...pivot,
-        axis: {
-          ...pivot.axis,
-          model: pivot.axis.model === this.context.self || pivot.axis.model === this.context.original ? void 0 : pivot.axis.model
-        }
-      }
+      pivot: mapSelectionReference(pivot2, (reference) => ({
+        ...reference,
+        model: reference.model === this.context.self || reference.model === this.context.original ? void 0 : reference.model
+      }))
     } : this.spatialOperation;
-    return this.context.original[relationPreview](
-      this.context.self.nodeId,
+    return this.context.self[previewRelation](
       this.storeFor(this.context.self, this.context.original),
-      selection
+      selection,
+      preceding
     );
   }
+  /** @internal */
+  continuationArguments() {
+    return [this.definition, this.context, this.relationId, this];
+  }
 };
-var Constraint = class _Constraint extends ConstraintExpression {
+var Constraint = class _Constraint extends RelationExpression {
   static {
     __name(this, "Constraint");
   }
-  constructor(kind, source, target, displacement = void 0, rotations = [], context = activeRelate, constraintId = `constraint-${nextConstraintId++}`, previous, spatialOperation) {
-    super(
-      kind,
-      source,
-      target,
-      displacement,
-      rotations,
-      context,
-      constraintId,
-      previous
-    );
-    this.spatialOperation = spatialOperation;
+  constructor(definition) {
+    super(definition, activeRelate, `constraint-${nextConstraintId++}`);
   }
   /** @internal */
   static create(source, target, kind = "on") {
@@ -20578,132 +20664,210 @@ var Constraint = class _Constraint extends ConstraintExpression {
       throw new Error(
         "align() requires points, curves, or surfaces; select geometry on a solid or group."
       );
-    return new _Constraint(kind, source, target);
-  }
-  offset(x = 0, y = 0, z = 0) {
-    assertFiniteVector("offset", [x, y, z]);
-    return new _Constraint(
-      this.kind,
-      this.source,
-      this.target,
-      addVectors(this.displacement ?? origin, [x, y, z]),
-      this.rotations,
-      this.context,
-      this.constraintId,
-      this
+    return new _Constraint({ kind, source, target });
+  }
+};
+var Transformation = class extends RelationExpression {
+  static {
+    __name(this, "Transformation");
+  }
+  /** @internal */
+  constructor(action, previous) {
+    const args = previous?.continuationArguments();
+    super(
+      { kind: "transformation", actions: [action] },
+      args ? args[1] : activeRelate,
+      args?.[2] ?? `transformation-${nextConstraintId++}`,
+      previous,
+      "pivot" in action ? { kind: "rotate", pivot: action.pivot } : void 0
     );
+    valueTraces.set(action, valueTrace(this));
   }
-  pivot([x = 0, y = 0, z = 0] = [0, 0, 0]) {
-    assertFiniteVector("pivot", [x, y, z]);
-    return new ConstraintPivotChain(this, { kind: "pivot", point: [x, y, z] });
-  }
-  /** @code3d.param id {kind: 'vertex', label: 'Pivot vertex'} */
-  pivotVertex(id) {
-    return new ConstraintPivotChain(this, { kind: "pivotVertex", id });
-  }
-  /** Select a positioned axis in the composition. */
-  around(axis) {
-    const reference = anchorReference(axis);
-    if (reference.kind !== "line")
-      throw new Error("around() requires an axis or straight edge.");
-    const geometry = reference.topology?.source[modelGeometry]()?.value ?? (reference.whole && isModelObject(reference.model) ? reference.model[modelGeometry]()?.value : void 0);
-    if (geometry) {
-      const straight = reference.topology ? withTopologyShape(
-        geometry.shape,
-        geometry.topology,
-        reference.topology.selection,
-        (shape) => shape.geomType === "LINE"
-      ) : geometry.shape.geomType === "LINE";
-      if (!straight)
-        throw new Error(
-          "around() requires a straight axis; curved edges do not define one rotation axis."
-        );
-    }
-    return new ConstraintAroundChain(this, { kind: "around", axis: reference });
+};
+var TransformationRotation = class extends RelationExpression {
+  static {
+    __name(this, "TransformationRotation");
   }
-  rotate(x = 0, y = 0, z = 0) {
-    return this.withRotation({ kind: "pivot", point: origin }, [x, y, z], this);
+  constructor() {
+    super(
+      { kind: "transformation", actions: [] },
+      activeRelate,
+      `transformation-${nextConstraintId++}`
+    );
   }
-  /** @internal */
-  withRotation(pivot, angles, previous) {
+  withRotation(pivot2, angles, previous) {
     assertFiniteVector(
       "rotate",
       typeof angles === "number" ? [angles, 0, 0] : angles
     );
-    return new _Constraint(
-      this.kind,
-      this.source,
-      this.target,
-      this.displacement,
-      [...this.rotations, { pivot, angles }],
-      this.context,
-      this.constraintId,
-      previous,
-      { kind: "rotate", pivot }
-    );
-  }
-  /** @internal */
-  chainArguments() {
-    return [
-      this.kind,
-      this.source,
-      this.target,
-      this.displacement,
-      this.rotations,
-      this.context,
-      this.constraintId,
-      this
-    ];
+    return new Transformation({ pivot: pivot2, angles }, previous);
   }
 };
-var ConstraintPivotChain = class extends ConstraintExpression {
+function rotationPointReference(point3) {
+  const reference = anchorReference(point3);
+  if (reference.kind !== "point")
+    throw new Error("pivotPoint() requires a point reference.");
+  return reference;
+}
+__name(rotationPointReference, "rotationPointReference");
+function rotationAxisReference(axis) {
+  const reference = anchorReference(axis);
+  if (reference.kind !== "line")
+    throw new Error("axisLine() requires an axis or straight edge.");
+  const geometry = reference.topology?.source[modelGeometry]()?.value ?? (reference.whole && isModelObject(reference.model) ? reference.model[modelGeometry]()?.value : void 0);
+  if (geometry) {
+    const straight = reference.topology ? withTopologyShape(
+      geometry.shape,
+      geometry.topology,
+      reference.topology.selection,
+      (shape) => shape.geomType === "LINE"
+    ) : geometry.shape.geomType === "LINE";
+    if (!straight)
+      throw new Error(
+        "axisLine() requires a straight axis; curved edges do not define one rotation axis."
+      );
+  }
+  return reference;
+}
+__name(rotationAxisReference, "rotationAxisReference");
+var PivotRotation = class extends RelationExpression {
   /** @internal */
-  constructor(constraint, selection) {
-    super(...constraint.chainArguments());
-    this.constraint = constraint;
+  constructor(chain, selection, previous) {
+    super(...(previous ?? chain).continuationArguments(), {
+      kind: selection.offset ? "pivotOffset" : selection.kind,
+      pivot: selection
+    });
+    this.chain = chain;
     this.selection = selection;
-    this.spatialOperation = { kind: selection.kind, pivot: selection };
   }
-  constraint;
+  chain;
   selection;
   static {
-    __name(this, "ConstraintPivotChain");
+    __name(this, "PivotRotation");
   }
   rotate(x = 0, y = 0, z = 0) {
-    return this.constraint.withRotation(this.selection, [x, y, z], this);
+    return this.chain.withRotation(this.selection, [x, y, z], this);
   }
 };
-var ConstraintAroundChain = class extends ConstraintExpression {
+var PivotChain = class extends PivotRotation {
+  static {
+    __name(this, "PivotChain");
+  }
+  pivotOffset(x = 0, y = 0, z = 0) {
+    assertFiniteVector("pivotOffset", [x, y, z]);
+    return new PivotRotation(
+      this.chain,
+      { ...this.selection, offset: [x, y, z] },
+      this
+    );
+  }
+};
+var AxisRotation = class extends RelationExpression {
   /** @internal */
-  constructor(constraint, selection) {
-    super(...constraint.chainArguments());
-    this.constraint = constraint;
+  constructor(chain, selection, previous) {
+    super(...(previous ?? chain).continuationArguments(), {
+      kind: selection.offset ? "axisOffset" : selection.kind,
+      pivot: selection
+    });
+    this.chain = chain;
     this.selection = selection;
-    this.spatialOperation = { kind: selection.kind, pivot: selection };
   }
-  constraint;
+  chain;
   selection;
   static {
-    __name(this, "ConstraintAroundChain");
+    __name(this, "AxisRotation");
   }
   rotate(angle = 0) {
-    return this.constraint.withRotation(this.selection, angle, this);
+    return this.chain.withRotation(this.selection, angle, this);
   }
 };
+var AxisChain = class extends AxisRotation {
+  static {
+    __name(this, "AxisChain");
+  }
+  axisOffset(x = 0, y = 0, z = 0) {
+    assertFiniteVector("axisOffset", [x, y, z]);
+    return new AxisRotation(
+      this.chain,
+      { ...this.selection, offset: [x, y, z] },
+      this
+    );
+  }
+};
+function selectedAxis(axis, offset2) {
+  return composeTransforms(axis.transform, translation(offset2 ?? origin));
+}
+__name(selectedAxis, "selectedAxis");
+function offset(x = 0, y = 0, z = 0) {
+  assertFiniteVector("offset", [x, y, z]);
+  return new Transformation({ offset: [x, y, z] });
+}
+__name(offset, "offset");
+function rotate2(x = 0, y = 0, z = 0) {
+  assertFiniteVector("rotate", [x, y, z]);
+  return new Transformation({
+    pivot: { kind: "pivot", point: origin, implicit: true },
+    angles: [x, y, z]
+  });
+}
+__name(rotate2, "rotate");
+function pivot([x = 0, y = 0, z = 0] = origin) {
+  assertFiniteVector("pivot", [x, y, z]);
+  return new PivotChain(new TransformationRotation(), {
+    kind: "pivot",
+    point: [x, y, z]
+  });
+}
+__name(pivot, "pivot");
+function pivotVertex(id) {
+  assertTopologyId("vertex", id);
+  return new PivotChain(new TransformationRotation(), {
+    kind: "pivotVertex",
+    id
+  });
+}
+__name(pivotVertex, "pivotVertex");
+function pivotPoint(point3) {
+  return new PivotChain(new TransformationRotation(), {
+    kind: "pivotPoint",
+    point: rotationPointReference(point3)
+  });
+}
+__name(pivotPoint, "pivotPoint");
+function axisEdge(id) {
+  assertTopologyId("edge", id);
+  return new AxisChain(new TransformationRotation(), {
+    kind: "axisEdge",
+    id
+  });
+}
+__name(axisEdge, "axisEdge");
+function axisLine(axis) {
+  return new AxisChain(new TransformationRotation(), {
+    kind: "axisLine",
+    axis: rotationAxisReference(axis)
+  });
+}
+__name(axisLine, "axisLine");
 var modelGeometry = /* @__PURE__ */ Symbol("modelGeometry");
 var referenceBounds = /* @__PURE__ */ Symbol("referenceBounds");
 var referenceBoundsParts = /* @__PURE__ */ Symbol("referenceBoundsParts");
 var modelSnapshotQueries = /* @__PURE__ */ Symbol("modelSnapshotQueries");
-var relationPreview = /* @__PURE__ */ Symbol("relationPreview");
+var previewRelation = /* @__PURE__ */ Symbol("previewRelation");
 var RelationObject = class _RelationObject {
   static {
     __name(this, "RelationObject");
   }
   nodeId;
-  constraints;
+  placements;
+  get constraints() {
+    return this.placements.filter(
+      (value) => value.kind !== "transformation"
+    );
+  }
   constructor(init = {}) {
     this.nodeId = init.nodeId ?? `node-${nextNodeId++}`;
-    this.constraints = [...init.constraints ?? []];
+    this.placements = [...init.placements ?? []];
     valueTraces.set(this, {
       sourceRefs: [...init.sourceRefs ?? []],
       parameters: [...init.parameters ?? []]
@@ -20715,6 +20879,17 @@ var RelationObject = class _RelationObject {
   get parameters() {
     return valueTrace(this).parameters;
   }
+  edgeReference(_id) {
+    throw new Error(
+      "axisEdge() requires model topology. Use axisLine(lineRef) for a line reference."
+    );
+  }
+  rotationAxis(pivot2) {
+    return pivot2.kind === "axisLine" ? pivot2.axis : this.edgeReference(pivot2.id);
+  }
+  rotationPoint(pivot2) {
+    return pivot2.kind === "pivot" ? pivot2.point : pivot2.kind === "pivotVertex" ? this.vertexPosition(pivot2.id) : pivot2.point.transform.position;
+  }
   vertexPosition(_id) {
     throw new Error(
       "pivotVertex() requires model topology, not a sketch reference frame. Use pivot([x, y, z]) instead."
@@ -20730,15 +20905,15 @@ var RelationObject = class _RelationObject {
     } finally {
       activeRelate = previous;
     }
-    const constraints = Array.isArray(built) ? built : [built];
-    const stored = constraints.map((constraint) => {
-      if (!(constraint instanceof Constraint))
+    const relations = Array.isArray(built) ? built : [built];
+    const stored = relations.map((constraint) => {
+      if (!(constraint instanceof Constraint) && !(constraint instanceof Transformation))
         throw new Error(
-          "relate() requires a completed Constraint; finish pivot/around with rotate()."
+          "relate() requires a completed Constraint or Transformation; finish the pivot or axis selector with rotate()."
         );
       return constraint.storeFor(this, original);
     });
-    this.constraints.push(...stored);
+    this.placements.push(...stored);
     return uniqueModels(stored.flatMap(constraintReferences));
   }
   [referenceBounds](reference, transform) {
@@ -20825,22 +21000,32 @@ var RelationObject = class _RelationObject {
       arrow
     };
   }
-  bodyRotations(constraint, indices) {
-    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 * (pivot.axis.direction ?? 1)
+  bodyActions(constraint, indices) {
+    return constraint.actions.map((action) => {
+      if ("offset" in action) return { offset: action.offset };
+      const { pivot: pivot2, angles } = action;
+      if (isAxisSelection(pivot2)) {
+        const axis = this.rotationAxis(pivot2);
+        return axis.model ? {
+          body: indices.get(axis.model),
+          axis: selectedAxis(axis, pivot2.offset),
+          angle: angles * (axis.direction ?? 1)
         } : {
           local: axisRotation(
-            pivot.axis.transform,
-            angles * (pivot.axis.direction ?? 1)
+            selectedAxis(axis, pivot2.offset),
+            angles * (axis.direction ?? 1)
           )
         };
       }
+      if (pivot2.kind === "pivotPoint" && pivot2.point.model)
+        return {
+          body: indices.get(pivot2.point.model),
+          point: pivot2.point.transform.position,
+          rotation: rotationAround(origin, angles).quaternion,
+          displacement: pivot2.offset ?? origin
+        };
       const frame = translation(
-        pivot.kind === "pivot" ? pivot.point : this.vertexPosition(pivot.id)
+        addVectors(this.rotationPoint(pivot2), pivot2.offset ?? origin)
       );
       return {
         local: composeTransforms(
@@ -20851,90 +21036,329 @@ var RelationObject = class _RelationObject {
     });
   }
   /** @internal */
-  [relationPreview](nodeId, constraint, selection) {
+  [previewRelation](constraint, selection, preceding = [], original) {
+    let placements = [...(original ?? this).placements];
+    const index = placements.findIndex((value) => value.id === constraint?.id);
+    if (index < 0) {
+      placements.push(
+        ...preceding.map(
+          (value) => value.storeFor(this, value.continuationArguments()[1].original)
+        )
+      );
+      if (constraint) placements.push(constraint);
+    } else if (constraint) {
+      placements[index] = constraint;
+      let end = index + 1;
+      if (constraint.kind !== "transformation")
+        while (end < placements.length && placements[end].kind !== "transformation")
+          end++;
+      placements = placements.slice(0, end);
+    }
     const owner = this.copyRelations({
-      nodeId,
-      constraints: [...this.constraints, constraint]
+      nodeId: this.nodeId,
+      placements
     });
     const context = _RelationObject.createSolveContext([
       owner,
-      ...selection?.pivot.kind === "around" && selection.pivot.axis.model ? [selection.pivot.axis.model] : []
+      ...selection && selectionReference(selection.pivot)?.model ? [selectionReference(selection.pivot).model] : []
     ]);
     return {
       object: {
-        nodeId,
+        nodeId: this.nodeId,
         compositionTransform: toTransform(owner.solvePose(context)),
         constraints: owner.constraints.map(
           (value) => owner.constraintSnapshot(value, context)
-        )
+        ),
+        transformations: owner.transformationSnapshots(context),
+        relationStages: owner.relationStageSnapshots(context)
       },
-      spatial: selection ? owner.constraintSpatial(constraint, selection, context) : void 0
+      spatial: selection && constraint?.kind === "transformation" ? owner.relationSpatial(constraint, selection, context) : constraint?.kind === "transformation" && constraint.actions.at(-1) && "offset" in constraint.actions.at(-1) ? owner.transformationOffsetSpatial(constraint, context) : void 0
     };
   }
-  constraintSpatial(constraint, selection, context) {
+  relationSpatial(constraint, selection, context, actionIndex) {
+    context = this.placementStageContext(constraint, context);
     const models = [...context.poses.keys()];
-    const actions = this.bodyRotations(
-      constraint,
-      new Map(models.map((model, i) => [model, i]))
-    );
-    const stage = actions.length - (selection.kind === "rotate" ? 1 : 0);
+    const actions = this.placementActions(constraint, context);
+    const stage = actionIndex ?? (selection.kind === "rotate" ? constraint.actions.length - 1 - [...constraint.actions].reverse().findIndex((action) => "angles" in action) : actions.length);
     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;
+    const following = this.followingActions(constraint, context);
+    const before = beforeTransformations(
+      beforeTransformations(
+        finalPose,
+        { actions: following },
+        models.map((model) => model.solvePose(context))
+      ),
+      {
+        actions: actions.slice(stage)
+      },
+      models.map((model) => model.solvePose(context))
+    );
+    const pivot2 = selection.pivot;
+    const axis = isAxisSelection(pivot2) ? this.rotationAxis(pivot2) : void 0;
     let frame;
-    if (pivot.kind === "around") {
+    if (axis) {
       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]))
+        axis.model ? axis.model.solvePose(context) : before,
+        (axis.direction ?? 1) === 1 ? selectedAxis(axis, pivot2.offset) : composeTransforms(
+          selectedAxis(axis, pivot2.offset),
+          rotation([1, 0, 0, 0])
+        )
       );
+    } else if (pivot2.kind === "pivotPoint" && pivot2.point.model) {
+      const center = composeTransforms(
+        pivot2.point.model.solvePose(context),
+        pivot2.point.transform
+      ).position;
+      frame = {
+        position: addVectors(
+          center,
+          rotateVector(pivot2.offset ?? origin, before.quaternion)
+        ),
+        quaternion: before.quaternion
+      };
     } else {
       const local = translation(
-        pivot.kind === "pivot" ? pivot.point : this.vertexPosition(pivot.id)
+        addVectors(
+          this.rotationPoint(pivot2),
+          pivot2.offset ?? origin
+        )
       );
       frame = composeTransforms(before, local);
     }
-    const angles = constraint.rotations[stage]?.angles ?? origin;
+    const selected = constraint.actions[stage];
+    const angles = selected && "angles" in selected ? selected.angles : origin;
     const rotationVector = typeof angles === "number" ? [0, angles, 0] : angles;
+    const poses = models.map((model) => model.solvePose(context));
+    let actionPose = afterTransformations(
+      before,
+      { actions: actions.slice(stage, stage + 1) },
+      poses
+    );
+    const remainder = [...actions.slice(stage + 1), ...following];
+    for (const action of remainder) {
+      const next = afterTransformations(
+        actionPose,
+        {
+          actions: [action]
+        },
+        poses
+      );
+      if ("body" in action)
+        frame = composeTransforms(
+          composeTransforms(next, invertTransform(actionPose)),
+          frame
+        );
+      else if ("offset" in action) {
+        frame = {
+          ...frame,
+          position: addVectors(
+            frame.position,
+            addVectors(next.position, negateVector(actionPose.position))
+          )
+        };
+      }
+      actionPose = next;
+    }
     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,
+        vector: selection.kind === "rotate" ? rotationVector : selection.kind === "pivotOffset" || selection.kind === "axisOffset" ? pivot2.offset ?? origin : pivot2.kind === "pivot" ? pivot2.point : origin,
         frame: localFrame,
         rotation: rotationVector,
-        axisOnly: pivot.kind === "around"
+        axisOnly: isAxisSelection(pivot2),
+        reference: {
+          ...pivot2.kind === "axisEdge" || pivot2.kind === "pivotVertex" ? { kind: pivot2.kind, id: pivot2.id } : pivot2.kind === "axisLine" || pivot2.kind === "pivotPoint" ? {
+            kind: pivot2.kind,
+            nodeId: selectionReference(pivot2).model?.nodeId ?? this.nodeId,
+            name: selectionReference(pivot2).name
+          } : { kind: pivot2.kind, point: pivot2.point },
+          offset: pivot2.offset ?? origin,
+          offsetExplicit: pivot2.offset !== void 0,
+          explicit: !pivot2.implicit,
+          rotation: axis && (axis.direction ?? 1) !== 1 ? [0, -rotationVector[1], 0] : rotationVector,
+          frame: axis && (axis.direction ?? 1) !== 1 ? composeTransforms(localFrame, rotation([1, 0, 0, 0])) : localFrame
+        }
       }
     };
   }
-  static createSolveContext(roots2) {
+  placementActions(value, context) {
+    const indices = new Map(
+      [...context.poses.keys()].map((model, i) => [model, i])
+    );
+    return this.bodyActions(value, indices).map(
+      (action) => "offset" in action ? { offset: rotateVector(action.offset, context.frame.quaternion) } : action
+    );
+  }
+  /** Pose at the end of this segment; later constraints have their own input pose. */
+  placementStageContext(placement, context) {
+    const index = this.placements.indexOf(placement);
+    let end = index + 1;
+    if (placement.kind !== "transformation")
+      while (end < this.placements.length && this.placements[end].kind !== "transformation")
+        end++;
+    while (end < this.placements.length && this.placements[end].kind === "transformation")
+      end++;
+    if (end >= this.placements.length) return context;
+    return transformSolveContext(
+      _RelationObject.createSolveContext(
+        [this],
+        /* @__PURE__ */ new Map([[this, this.placements.slice(0, end)]])
+      ),
+      context.frame
+    );
+  }
+  followingActions(placement, context) {
+    let start = this.placements.indexOf(placement) + 1;
+    if (placement.kind !== "transformation")
+      while (start < this.placements.length && this.placements[start].kind !== "transformation")
+        start++;
+    const values = [];
+    while (start < this.placements.length && this.placements[start].kind === "transformation")
+      values.push(this.placements[start++]);
+    return values.flatMap((value) => this.placementActions(value, context));
+  }
+  relationStageSnapshots(context) {
+    if (!this.placements.length) return void 0;
+    const stages = [];
+    let start = 0;
+    while (start < this.placements.length) {
+      let end = start;
+      while (end < this.placements.length && this.placements[end].kind !== "transformation")
+        end++;
+      while (end < this.placements.length && this.placements[end].kind === "transformation")
+        end++;
+      const values = this.placements.slice(start, end);
+      const stage = this.placementStageContext(values[0], context);
+      stages.push({
+        constraintIds: values.filter((value) => value.kind !== "transformation").map((value) => value.id),
+        transformationIds: values.filter((value) => value.kind === "transformation").map((value) => value.id),
+        compositionTransform: toTransform(this.solvePose(stage)),
+        offsetFrame: toTransform(stage.frame)
+      });
+      start = end;
+    }
+    return stages;
+  }
+  transformationSnapshots(context) {
+    const values = this.placements.filter(
+      (value) => value.kind === "transformation"
+    );
+    if (!values.length) return void 0;
+    return values.map(
+      (value) => this.transformationSnapshot(
+        value,
+        this.placementStageContext(value, context)
+      )
+    );
+  }
+  followingReferenceFrame(frame, actions, context) {
+    const models = [...context.poses.keys()];
+    const poses = models.map((model) => model.solvePose(context));
+    let pose = beforeTransformations(this.solvePose(context), { actions }, poses);
+    for (const action of actions) {
+      const next = afterTransformations(pose, { actions: [action] }, poses);
+      if ("body" in action)
+        frame = composeTransforms(
+          composeTransforms(next, invertTransform(pose)),
+          frame
+        );
+      pose = next;
+    }
+    return frame;
+  }
+  transformationSnapshot(value, context) {
+    const models = [...context.poses.keys()];
+    const actions = this.placementActions(value, context);
+    const following = this.followingActions(value, context);
+    const offsets = value.actions.flatMap((action, index) => {
+      if (!("offset" in action)) return [];
+      const frame = this.followingReferenceFrame(
+        context.frame,
+        [...actions.slice(index + 1), ...following],
+        context
+      );
+      return [
+        {
+          value: action.offset,
+          frame: toTransform(frame),
+          sourceRefs: valueTrace(action).sourceRefs
+        }
+      ];
+    });
+    const rotations = value.actions.flatMap(
+      (action, index) => "pivot" in action ? [
+        {
+          spatial: this.relationSpatial(
+            value,
+            { kind: "rotate", pivot: action.pivot },
+            context,
+            index
+          ).spatial,
+          sourceRefs: valueTrace(action).sourceRefs
+        }
+      ] : []
+    );
+    return {
+      id: value.id,
+      offsets,
+      rotations,
+      offsetFrame: toTransform(context.frame),
+      sourceRefs: [...valueTrace(value).sourceRefs],
+      parameters: [...valueTrace(value).parameters]
+    };
+  }
+  transformationOffsetSpatial(value, context) {
+    const offset2 = this.transformationSnapshot(value, context).offsets.at(-1);
+    const local = relativeTransform(
+      { ...offset2.frame, position: this.solvePose(context).position },
+      this.solvePose(context)
+    );
+    return {
+      nodeId: this.nodeId,
+      kind: "offset",
+      spatial: { origin, vector: offset2.value, frame: local }
+    };
+  }
+  static createSolveContext(roots2, overrides = /* @__PURE__ */ new Map()) {
     const models = [];
     const indices = /* @__PURE__ */ new Map();
     const collect = /* @__PURE__ */ __name((model) => {
       if (indices.has(model)) return;
       indices.set(model, models.length);
       models.push(model);
-      model.constraints.flatMap(constraintReferences).forEach(collect);
+      (overrides.get(model) ?? model.placements).flatMap(constraintReferences).forEach(collect);
     }, "collect");
     roots2.forEach(collect);
+    const programs = models.map((model) => {
+      const placements = overrides.get(model) ?? model.placements;
+      let last = placements.length - 1;
+      while (last >= 0 && placements[last].kind === "transformation") last--;
+      let start = last;
+      while (start > 0 && placements[start - 1].kind !== "transformation")
+        start--;
+      const initial = start > 0 ? _RelationObject.createSolveContext(
+        [model],
+        new Map(overrides).set(model, placements.slice(0, start))
+      ).poses.get(model) : identityRigidTransform;
+      return {
+        initial,
+        constraints: placements.slice(Math.max(0, start), last + 1).filter(
+          (value) => value.kind !== "transformation"
+        ),
+        transformations: placements.slice(last + 1).filter(
+          (value) => value.kind === "transformation"
+        ).flatMap((value) => model.bodyActions(value, indices))
+      };
+    });
     const poses = solveBodies2(
-      models.map((model) => ({
+      models.map((model, index) => ({
+        initial: programs[index].initial,
+        transformations: programs[index].transformations,
         name: model.name,
-        relations: model.constraints.map(
+        relations: programs[index].constraints.map(
           (constraint) => constraint.kind === "align" ? {
             kind: "align",
             id: constraint.id,
@@ -20947,9 +21371,7 @@ var RelationObject = class _RelationObject {
               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,
@@ -20965,63 +21387,25 @@ var RelationObject = class _RelationObject {
               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 {
-      poses: new Map(models.map((model, index) => [model, poses[index]]))
+      poses: new Map(models.map((model, index) => [model, poses[index]])),
+      frame: identityRigidTransform
     };
   }
   constraintSnapshot(constraint, context) {
-    const lastRotation = constraint.rotations.at(-1);
-    const rotationSpatial = lastRotation ? this.constraintSpatial(
-      constraint,
-      { kind: "rotate", pivot: lastRotation.pivot },
-      context
-    ).spatial : void 0;
     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,
+    const sourcePose = source.solvePose(context);
+    const contactFrame = composeTransforms(
+      target.solvePose(context),
       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",
@@ -21029,16 +21413,12 @@ var RelationObject = class _RelationObject {
         target: anchorSnapshot(target, constraint.target),
         sourceElement: source.relationElement(constraint.source),
         targetElement: target.relationElement(constraint.target),
-        offsetDirection: 1,
-        offset: constraint.offset ?? origin,
-        offsetFrame: toTransform(offsetFrame),
-        rotation: rotationSpatial,
         sourceRefs: [...valueTrace(constraint).sourceRefs],
         parameters: [...valueTrace(constraint).parameters]
       };
     }
     const orientation = composeTransforms(
-      invertTransform(rotation(offsetFrame.quaternion)),
+      invertTransform(rotation(contactFrame.quaternion)),
       rotation(sourcePose.quaternion)
     ).quaternion;
     const bounds = source[referenceBounds](
@@ -21054,9 +21434,9 @@ var RelationObject = class _RelationObject {
       {
         position: addVectors(
           sourcePose.position,
-          rotateVector(center, offsetFrame.quaternion)
+          rotateVector(center, contactFrame.quaternion)
         ),
-        quaternion: offsetFrame.quaternion
+        quaternion: contactFrame.quaternion
       },
       sourcePose
     );
@@ -21065,19 +21445,6 @@ var RelationObject = class _RelationObject {
       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,
@@ -21111,10 +21478,6 @@ var RelationObject = class _RelationObject {
         transform: toTransform(constraint.target.transform),
         bound: constraint.target.bound
       },
-      offsetDirection: source === this ? 1 : -1,
-      offset: constraint.offset ?? origin,
-      offsetFrame: toTransform(offsetFrame),
-      rotation: rotationSpatial,
       sourceRefs: [...valueTrace(constraint).sourceRefs],
       parameters: [...valueTrace(constraint).parameters]
     };
@@ -21130,7 +21493,7 @@ var SketchFrame = class _SketchFrame extends RelationObject {
   operation = storedOperation("sketch");
   constructor(source, init = {}) {
     super({
-      constraints: source?.constraints,
+      placements: source?.placements,
       sourceRefs: source?.sourceRefs,
       parameters: source?.parameters,
       ...init
@@ -21147,7 +21510,7 @@ var SketchFrame = class _SketchFrame extends RelationObject {
   relatedObjects() {
     return [
       ...this.source ? [this.source] : [],
-      ...this.constraints.flatMap(constraintReferences)
+      ...this.placements.flatMap(constraintReferences)
     ];
   }
   attachOperationTrace(siteId, execution, order, sourceRef, outputIndex = 0) {
@@ -21198,7 +21561,7 @@ var SketchFrame = class _SketchFrame extends RelationObject {
     return related;
   }
   face(region) {
-    return sketchFaceModel(region, this.constraints, this);
+    return sketchFaceModel(region, this.placements, this);
   }
   snapshot() {
     const context = RelationObject.createSolveContext([this]);
@@ -21207,7 +21570,9 @@ var SketchFrame = class _SketchFrame extends RelationObject {
       compositionTransform: toTransform(this.solvePose(context)),
       constraints: this.constraints.map(
         (constraint) => this.constraintSnapshot(constraint, context)
-      )
+      ),
+      transformations: this.transformationSnapshots(context),
+      relationStages: this.relationStageSnapshots(context)
     };
   }
   /** Related finite models, expressed in this sketch's local editing plane. */
@@ -21471,9 +21836,9 @@ var ModelObject = class _ModelObject extends RelationObject {
     );
   }
   originOffset(dx = 0, dy = 0, dz = 0) {
-    const offset = [dx, dy, dz];
-    assertFiniteVector("originOffset", offset);
-    return this.withOrigin(offset, { kind: "originOffset" });
+    const offset2 = [dx, dy, dz];
+    assertFiniteVector("originOffset", offset2);
+    return this.withOrigin(offset2, { kind: "originOffset" });
   }
   originPoint(point3) {
     const reference = anchorReference(point3);
@@ -21499,8 +21864,8 @@ var ModelObject = class _ModelObject extends RelationObject {
     const position2 = this.elements.center.transform.position;
     return this.withOrigin(position2, { kind: "originCenter" });
   }
-  withOrigin(offset, selection) {
-    const transform = translation(negateVector(offset));
+  withOrigin(offset2, selection) {
+    const transform = translation(negateVector(offset2));
     const operation = storedOperation(selection.kind, [
       { model: this, role: "source", index: 0 }
     ]);
@@ -21510,7 +21875,7 @@ var ModelObject = class _ModelObject extends RelationObject {
         role: "reference",
         index: 0
       });
-    operation.spatial = { origin, vector: offset };
+    operation.spatial = { origin, vector: offset2 };
     if (selection.kind === "originVertex") {
       operation.selections.push({
         kind: "vertex",
@@ -21539,7 +21904,7 @@ var ModelObject = class _ModelObject extends RelationObject {
           transformElement(element, transform)
         ])
       ),
-      constraints: this.mapConstraintGeometry(
+      placements: this.mapConstraintGeometry(
         (element) => transformElement(element, transform),
         (point3) => composeTransforms(transform, translation(point3)).position
       )
@@ -21575,15 +21940,37 @@ var ModelObject = class _ModelObject extends RelationObject {
   }
   mapConstraintGeometry(mapElement, mapPoint) {
     const mapReference = /* @__PURE__ */ __name((reference) => reference.model ? reference : { ...reference, ...mapElement(reference) }, "mapReference");
-    return this.constraints.map((constraint) => {
+    const zero = mapPoint(origin);
+    const mapVector = /* @__PURE__ */ __name((vector2) => mapPoint(vector2).map(
+      (value, index) => value - zero[index]
+    ), "mapVector");
+    const scale3 = Math.hypot(...mapVector([1, 0, 0]));
+    return this.placements.map((constraint) => {
       const mapped = {
         ...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
-        }))
+        ...constraint.kind === "transformation" ? {} : {
+          source: mapReference(constraint.source),
+          target: mapReference(constraint.target)
+        },
+        ...constraint.kind === "transformation" ? {
+          actions: constraint.actions.map((action) => {
+            if ("offset" in action) return action;
+            const mappedAction = {
+              ...action,
+              pivot: action.pivot.kind === "pivot" ? { ...action.pivot, point: mapPoint(action.pivot.point) } : mapSelectionReference(action.pivot, mapReference)
+            };
+            if (action.pivot.offset) {
+              mappedAction.pivot = {
+                ...mappedAction.pivot,
+                offset: isAxisSelection(action.pivot) ? selectionReference(action.pivot)?.model ? action.pivot.offset : action.pivot.offset.map(
+                  (value) => value * scale3
+                ) : mapVector(action.pivot.offset)
+              };
+            }
+            valueTraces.set(mappedAction, valueTrace(action));
+            return mappedAction;
+          })
+        } : {}
       };
       valueTraces.set(mapped, valueTrace(constraint));
       return mapped;
@@ -21614,7 +22001,7 @@ var ModelObject = class _ModelObject extends RelationObject {
       {
         geometryAnchor: scaleElement(this.geometryAnchor, factor),
         elements: scaleElements(this.elements, factor),
-        constraints: this.mapConstraintGeometry(
+        placements: this.mapConstraintGeometry(
           (element) => scaleElement(element, factor),
           (point3) => scaleFrame(translation(point3), factor).position
         )
@@ -21650,7 +22037,7 @@ var ModelObject = class _ModelObject extends RelationObject {
       name: "Extrude",
       geometry,
       material: this.materialSnapshot,
-      constraints: this.constraints,
+      placements: this.placements,
       sourceRefs: this.sourceRefs,
       parameters: this.allParameters(),
       meshTolerance: this.meshTolerance,
@@ -21797,7 +22184,7 @@ var ModelObject = class _ModelObject extends RelationObject {
     return [
       ...this.children,
       ...this.operation.inputs.map((input) => input.model),
-      ...this.constraints.flatMap(constraintReferences)
+      ...this.placements.flatMap(constraintReferences)
     ];
   }
   /** @internal */
@@ -21813,7 +22200,7 @@ var ModelObject = class _ModelObject extends RelationObject {
     );
     const parameters = uniqueParameters([
       ...this.parameters,
-      ...this.constraints.flatMap(
+      ...this.placements.flatMap(
         (constraint) => valueTrace(constraint).parameters
       )
     ]);
@@ -21825,6 +22212,8 @@ var ModelObject = class _ModelObject extends RelationObject {
       compositionTransform: toTransform(pose),
       transform: toTransform(inComposition ? pose : identityRigidTransform),
       constraints,
+      transformations: this.transformationSnapshots(solveContext),
+      relationStages: this.relationStageSnapshots(solveContext),
       origin,
       elements: snapshotElements({
         ...this.elements,
@@ -21919,7 +22308,7 @@ var ModelObject = class _ModelObject extends RelationObject {
       name: "Loft",
       geometry,
       material: this.materialSnapshot,
-      constraints: this.constraints,
+      placements: this.placements,
       sourceRefs: inputs.flatMap((input) => input.sourceRefs),
       parameters: uniqueParameters(
         inputs.flatMap((input) => input.allParameters())
@@ -21947,7 +22336,7 @@ var ModelObject = class _ModelObject extends RelationObject {
         geometry: evaluation.geometry,
         name: this.name,
         material: this.materialSnapshot,
-        constraints: this.constraints,
+        placements: this.placements,
         sourceRefs: [this, ...others].flatMap((model) => model.sourceRefs),
         parameters: uniqueParameters(
           [this, ...others].flatMap((model) => model.allParameters())
@@ -22065,7 +22454,7 @@ var ModelObject = class _ModelObject extends RelationObject {
   allParameters() {
     return uniqueParameters([
       ...this.parameters,
-      ...this.constraints.flatMap(
+      ...this.placements.flatMap(
         (constraint) => valueTrace(constraint).parameters
       )
     ]);
@@ -22197,19 +22586,22 @@ var ModelObject = class _ModelObject extends RelationObject {
       } : reference
     );
   }
+  edgeReference(id) {
+    return { ...rotationAxisReference(this.edge(id)), model: void 0 };
+  }
   vertexPosition(id) {
     return anchorReference(this.vertex(id)).transform.position;
   }
   copyRelations(init) {
     return this.copy(init, this.operation);
   }
-  /** Fix the assembly frame once, using only its direct member origins. */
+  /** Fix the assembly frame once in the first member's solved local coordinates. */
   static createAssembly(children) {
     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)));
+    return children.length ? transformSolveContext(
+      context,
+      invertTransform(children[0].solvePose(context))
+    ) : context;
   }
   requireGeometry() {
     if (!this.geometry) {
@@ -22279,7 +22671,7 @@ var ModelObject = class _ModelObject extends RelationObject {
       material: this.materialSnapshot,
       children: this.children,
       assembly: this.assembly,
-      constraints: this.constraints,
+      placements: this.placements,
       elements: this.elements,
       sourceRefs: this.sourceRefs,
       parameters: this.parameters,
@@ -22815,19 +23207,32 @@ function isConstraint(value) {
   return value instanceof Constraint;
 }
 __name(isConstraint, "isConstraint");
-function isConstraintExpression(value) {
-  return value instanceof ConstraintExpression;
-}
-__name(isConstraintExpression, "isConstraintExpression");
-function constraintPreview(value) {
-  return value.preview();
+function isRelationExpression(value) {
+  return value instanceof RelationExpression;
+}
+__name(isRelationExpression, "isRelationExpression");
+function relationPreview(value, preceding = []) {
+  return value.preview(preceding);
+}
+__name(relationPreview, "relationPreview");
+function currentRelationSelf() {
+  return activeRelate?.self;
+}
+__name(currentRelationSelf, "currentRelationSelf");
+function relationSelectionPreview(self, preceding, context) {
+  return self[previewRelation](
+    void 0,
+    void 0,
+    preceding,
+    (preceding[0] ?? context)?.continuationArguments()[1]?.original
+  );
 }
-__name(constraintPreview, "constraintPreview");
-function instrumentConstraint(constraint, sourceRef, parameters) {
+__name(relationSelectionPreview, "relationSelectionPreview");
+function instrumentRelation(constraint, sourceRef, parameters) {
   constraint.attachSource(sourceRef);
   constraint.attachParameters(parameters);
 }
-__name(instrumentConstraint, "instrumentConstraint");
+__name(instrumentRelation, "instrumentRelation");
 function instrumentModelOperation(object, instrumentation) {
   object.attachSource(instrumentation.sourceRef);
   object.attachParameters(instrumentation.parameters);
@@ -22840,10 +23245,10 @@ function instrumentModelOperation(object, instrumentation) {
   );
 }
 __name(instrumentModelOperation, "instrumentModelOperation");
-function constraintTraceReference(constraint) {
+function relationTraceReference(constraint) {
   return constraint.traceReference();
 }
-__name(constraintTraceReference, "constraintTraceReference");
+__name(relationTraceReference, "relationTraceReference");
 function modelObjectRuntimeInfo(object) {
   return {
     nodeId: object.nodeId,
@@ -23045,6 +23450,13 @@ function retainModelGeometry(objects) {
 }
 __name(retainModelGeometry, "retainModelGeometry");
 var authoringApi = Object.freeze({
+  offset,
+  rotate: rotate2,
+  pivot,
+  pivotVertex,
+  pivotPoint,
+  axisEdge,
+  axisLine,
   cached,
   font,
   googleFont,
@@ -23124,7 +23536,10 @@ function disposeModelGeometryValue(geometry) {
 __name(disposeModelGeometryValue, "disposeModelGeometryValue");
 var kernelShape = cachedArtifact(
   (_operation, _arguments, _inputs, compute) => compute(),
-  { key: kernelOperationKey, lifecycle: shapeLifecycle }
+  {
+    key: /* @__PURE__ */ __name((operation, arguments_, inputs) => kernelOperationKey(`kernel-shape:${operation}`, arguments_, inputs), "key"),
+    lifecycle: shapeLifecycle
+  }
 );
 function evaluateKernelShape(operation, arguments_, inputs, compute) {
   return kernelShape(
@@ -23143,7 +23558,10 @@ var evaluateModelGeometry = cachedArtifact(
       referenceBasis: result.referenceBasis
     };
   },
-  { key: kernelOperationKey, lifecycle: modelGeometryLifecycle }
+  {
+    key: /* @__PURE__ */ __name((operation, arguments_, inputs) => kernelOperationKey(`model-geometry:${operation}`, arguments_, inputs), "key"),
+    lifecycle: modelGeometryLifecycle
+  }
 );
 function createModelGeometryValue(shape, topology) {
   try {
@@ -23211,7 +23629,7 @@ function meshUVs(shape, vertexCount) {
   const faces = shape.faces;
   const location = new (getOC12()).TopLoc_Location();
   const uvs = new Float32Array(vertexCount * 2);
-  let offset = 0;
+  let offset2 = 0;
   try {
     for (const face of faces) {
       const triangulation = getOC12().BRep_Tool.Triangulation(
@@ -23229,8 +23647,8 @@ function meshUVs(shape, vertexCount) {
           const uv = triangulation.UVNode(index + 1);
           try {
             const u8 = uv.X(), v = uv.Y();
-            uvs[(offset + index) * 2] = u8;
-            uvs[(offset + index) * 2 + 1] = v;
+            uvs[(offset2 + index) * 2] = u8;
+            uvs[(offset2 + index) * 2 + 1] = v;
             minU = Math.min(minU, u8);
             maxU = Math.max(maxU, u8);
             minV = Math.min(minV, v);
@@ -23240,11 +23658,11 @@ function meshUVs(shape, vertexCount) {
           }
         }
         for (let index = 0; index < count; index++) {
-          const base = (offset + index) * 2;
+          const base = (offset2 + index) * 2;
           uvs[base] = maxU === minU ? 0 : (uvs[base] - minU) / (maxU - minU);
           uvs[base + 1] = maxV === minV ? 0 : (uvs[base + 1] - minV) / (maxV - minV);
         }
-        offset += count;
+        offset2 += count;
       } finally {
         triangulation.delete();
       }
@@ -23256,7 +23674,7 @@ function meshUVs(shape, vertexCount) {
   }
 }
 __name(meshUVs, "meshUVs");
-function sketchFaceModel(region, constraints, source) {
+function sketchFaceModel(region, placements, source) {
   const curves = [region.outer, ...region.holes].map(
     (loop) => loop.map(
       (curve) => curve.kind === "line" ? ["line", curve.points] : curve.kind === "circle" ? ["circle", curve.center, curve.radius] : ["arc", curve.center, curve.radius, curve.start, curve.sweep]
@@ -23272,7 +23690,7 @@ function sketchFaceModel(region, constraints, source) {
   return ModelObject.create({
     kind: "face",
     name: "Sketch face",
-    constraints,
+    placements,
     geometry,
     geometryAnchor: plane,
     elements: { plane },
@@ -23411,10 +23829,9 @@ function solidElements(bounds) {
 __name(solidElements, "solidElements");
 function constraintReferences(constraint) {
   return [
-    constraint.source.model,
-    constraint.target.model,
-    ...constraint.rotations.map(
-      (action) => action.pivot.kind === "around" ? action.pivot.axis.model : void 0
+    ...constraint.kind === "transformation" ? [] : [constraint.source.model, constraint.target.model],
+    ...(constraint.kind === "transformation" ? constraint.actions : []).map(
+      (action) => "pivot" in action ? selectionReference(action.pivot)?.model : void 0
     )
   ].filter((model) => !!model);
 }
@@ -24743,6 +25160,7 @@ export {
   setKernelNativeMemoryCounter,
   clearKernelOperationCache,
   kernelOperationCacheStats,
+  setKernelCacheBudget,
   setKernelArtifactStore,
   setKernelExternalBytes,
   identifyCachedFunction,
@@ -24787,6 +25205,13 @@ export {
   modelElementReference,
   modelTopologyReference,
   modelTopologyIds,
+  offset,
+  rotate2 as rotate,
+  pivot,
+  pivotVertex,
+  pivotPoint,
+  axisEdge,
+  axisLine,
   circle,
   ellipse,
   rectangle,
@@ -24813,11 +25238,13 @@ export {
   intersect,
   isModelObject,
   isConstraint,
-  isConstraintExpression,
-  constraintPreview,
-  instrumentConstraint,
+  isRelationExpression,
+  relationPreview,
+  currentRelationSelf,
+  relationSelectionPreview,
+  instrumentRelation,
   instrumentModelOperation,
-  constraintTraceReference,
+  relationTraceReference,
   modelObjectRuntimeInfo,
   relatedModelObjects,
   planModelSnapshotQueries,
@@ -24839,4 +25266,4 @@ export {
   assertSketchDragConnections,
   solveSketchSnapshot
 };
-//# sourceMappingURL=chunk-J77FMYFY.js.map
+//# sourceMappingURL=chunk-T3RAUNSF.js.map