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

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

@@ -369,6 +369,7 @@ __name(estimateRetainedBytes, "estimateRetainedBytes");
 // packages/core/src/library/kernel-cache.ts
 function createComputationCache({
   maximumBytes = 2 * 1024 ** 3,
+  minimumPersistenceMilliseconds = 1,
   nativeAllocatedBytes
 }) {
   const entries = /* @__PURE__ */ new Map();
@@ -391,6 +392,10 @@ function createComputationCache({
     evictHistoricalEntries();
   }
   __name(setKernelCacheBudget2, "setKernelCacheBudget");
+  function setKernelCachePersistenceThreshold2(milliseconds) {
+    minimumPersistenceMilliseconds = milliseconds;
+  }
+  __name(setKernelCachePersistenceThreshold2, "setKernelCachePersistenceThreshold");
   function setKernelExternalBytes2(bytes) {
     externalBytes = bytes;
     evictHistoricalEntries();
@@ -431,8 +436,10 @@ function createComputationCache({
   function evaluateCachedArtifact2(key, lifecycle, compute, codec) {
     const hit = findKernelOperation2(key, lifecycle, codec);
     if (hit) return hit;
+    const started = performance.now();
     const value = compute();
-    acceptKernelOperation2(key, lifecycle, value, codec);
+    const milliseconds = performance.now() - started;
+    acceptKernelOperation2(key, lifecycle, value, milliseconds, codec);
     return { id: key.id, value };
   }
   __name(evaluateCachedArtifact2, "evaluateCachedArtifact");
@@ -460,8 +467,8 @@ function createComputationCache({
   function lookup(key, lifecycle, codec, read) {
     currentEvaluation?.checkCancelled?.();
     const { id, signature } = key;
-    let cached2 = entries.get(id);
-    if (!cached2 && codec !== false) {
+    let cached = entries.get(id);
+    if (!cached && codec !== false) {
       const bytes = read();
       if (bytes) {
         let restored;
@@ -473,25 +480,26 @@ function createComputationCache({
           misses += 1;
           return void 0;
         }
-        cached2 = retainEntry(key, lifecycle, restored);
+        cached = retainEntry(key, lifecycle, restored, true);
         persistentHits += 1;
         persisted.add(id);
       }
     }
-    if (!cached2) {
+    if (!cached) {
       misses += 1;
       return void 0;
     }
-    if (cached2.signature !== signature)
+    if (cached.signature !== signature)
       throw new Error(`Kernel operation cache identity collision: ${id}`);
     hits += 1;
-    const value = cached2.instantiate(cached2.value);
-    if (codec !== false) persist(key, cached2.value, codec, true);
-    touchEntry(id, cached2);
+    const value = cached.instantiate(cached.value);
+    if (cached.persistenceEligible && codec !== false)
+      persist(key, cached.value, codec, true);
+    touchEntry(id, cached);
     return { id, value };
   }
   __name(lookup, "lookup");
-  function acceptKernelOperation2(key, lifecycle, value, codec) {
+  function acceptKernelOperation2(key, lifecycle, value, milliseconds, codec) {
     const existing = entries.get(key.id);
     if (existing) {
       if (existing.signature !== key.signature)
@@ -506,8 +514,14 @@ function createComputationCache({
       lifecycle.release(value);
       throw error;
     }
-    const entry = retainEntry(key, lifecycle, retained);
-    if (codec !== false) persist(key, retained, codec);
+    const entry = retainEntry(
+      key,
+      lifecycle,
+      retained,
+      milliseconds >= minimumPersistenceMilliseconds
+    );
+    if (entry.persistenceEligible && codec !== false)
+      persist(key, retained, codec);
     touchEntry(key.id, entry);
   }
   __name(acceptKernelOperation2, "acceptKernelOperation");
@@ -553,8 +567,9 @@ function createComputationCache({
     pendingPersistence.clear();
   }
   __name(flushPendingPersistence, "flushPendingPersistence");
-  function retainEntry(key, lifecycle, retained) {
+  function retainEntry(key, lifecycle, retained, persistenceEligible) {
     const entry = {
+      persistenceEligible,
       estimatedBytes: 256 + estimateRetainedBytes(key.signature) + lifecycle.estimateBytes(retained),
       signature: key.signature,
       value: retained,
@@ -630,6 +645,7 @@ function createComputationCache({
     clearKernelOperationCache: clearKernelOperationCache2,
     kernelOperationCacheStats: kernelOperationCacheStats2,
     setKernelCacheBudget: setKernelCacheBudget2,
+    setKernelCachePersistenceThreshold: setKernelCachePersistenceThreshold2,
     setKernelArtifactStore: setKernelArtifactStore2,
     findKernelOperation: findKernelOperation2,
     findKernelOperations: findKernelOperations2,
@@ -649,6 +665,7 @@ var {
   clearKernelOperationCache,
   kernelOperationCacheStats,
   setKernelCacheBudget,
+  setKernelCachePersistenceThreshold,
   setKernelArtifactStore,
   findKernelOperation,
   findKernelOperations,
@@ -713,19 +730,19 @@ var dataLifecycle = {
   release() {
   }
 };
-function cached(compute, options) {
+function cache(compute, args, options) {
   const operation = cachedArtifact(
-    (...args) => {
-      const value = compute(...args);
+    (...args2) => {
+      const value = compute(...args2);
       if (value && typeof value === "object" && "then" in value && typeof value.then === "function")
-        throw new Error("cached() requires a synchronous computation.");
+        throw new Error("cache() requires a synchronous computation.");
       return value;
     },
     { identity: compute, codec: options }
   );
-  return (...args) => operation(...args).value;
+  return args === void 0 ? (...args2) => operation(...args2).value : operation(...args).value;
 }
-__name(cached, "cached");
+__name(cache, "cache");
 function cachedArtifact(compute, {
   key,
   lifecycle = dataLifecycle,
@@ -742,7 +759,7 @@ function cachedArtifact(compute, {
   ));
   const find = /* @__PURE__ */ __name((key2) => findKernelOperation(key2, lifecycle, persistence), "find");
   const findMany = /* @__PURE__ */ __name((keys) => findKernelOperations(keys, lifecycle, persistence), "findMany");
-  const accept = /* @__PURE__ */ __name((key2, value) => acceptKernelOperation(key2, lifecycle, value, persistence), "accept");
+  const accept = /* @__PURE__ */ __name((key2, value, milliseconds) => acceptKernelOperation(key2, lifecycle, value, milliseconds, persistence), "accept");
   return Object.assign(
     (...args) => {
       return evaluateCachedArtifact(
@@ -1092,9 +1109,9 @@ function sketchCurveClosestParameter(curve, position2) {
   );
   if (curve.kind === "circle") return sketchPositiveAngle(angle) / tau;
   const sign3 = Math.sign(curve.sweep), sweep = Math.abs(curve.sweep);
-  const distance3 = sketchPositiveAngle(sign3 * (angle - curve.start));
-  if (distance3 <= sweep) return sweep ? distance3 / sweep : 0;
-  return distance3 - sweep < tau - distance3 ? 1 : 0;
+  const distance4 = sketchPositiveAngle(sign3 * (angle - curve.start));
+  if (distance4 <= sweep) return sweep ? distance4 / sweep : 0;
+  return distance4 - sweep < tau - distance4 ? 1 : 0;
 }
 __name(sketchCurveClosestParameter, "sketchCurveClosestParameter");
 function sketchCurveBounds(curve) {
@@ -2416,15 +2433,15 @@ function endpointPolicy(problem, point3, scope) {
   controls.delete(point3);
   if (controls.size) return { kind: "endpoint", anchors: [...controls] };
   const graph = neighbors(problem);
-  const distance3 = /* @__PURE__ */ new Map([[point3, 0]]);
-  for (const [p, d] of distance3)
+  const distance4 = /* @__PURE__ */ new Map([[point3, 0]]);
+  for (const [p, d] of distance4)
     for (const next of graph[p])
-      if (scope.has(next) && !distance3.has(next)) distance3.set(next, d + 1);
+      if (scope.has(next) && !distance4.has(next)) distance4.set(next, d + 1);
   let farthest = -1, max12 = 0;
   for (const p of scope)
-    if ((distance3.get(p) ?? 0) > max12) {
+    if ((distance4.get(p) ?? 0) > max12) {
       farthest = p;
-      max12 = distance3.get(p);
+      max12 = distance4.get(p);
     }
   return { kind: "endpoint", anchors: farthest < 0 ? [] : [farthest] };
 }
@@ -3095,22 +3112,22 @@ function nearestPoint(point3, geometry) {
     case "ellipse": {
       const y = cross2(geometry.normal, geometry.major);
       const x0 = dot(delta, geometry.major), y0 = dot(delta, y);
-      const distance3 = /* @__PURE__ */ __name((angle2) => (geometry.radius * Math.cos(angle2) - x0) ** 2 + (geometry.minorRadius * Math.sin(angle2) - y0) ** 2, "distance");
+      const distance4 = /* @__PURE__ */ __name((angle2) => (geometry.radius * Math.cos(angle2) - x0) ** 2 + (geometry.minorRadius * Math.sin(angle2) - y0) ** 2, "distance");
       const step = Math.PI / 16, candidates2 = [];
       for (let i = 0; i < 32; i++) {
         const angle2 = i * step;
-        if (distance3(angle2) > distance3(angle2 - step) || distance3(angle2) > distance3(angle2 + step))
+        if (distance4(angle2) > distance4(angle2 - step) || distance4(angle2) > distance4(angle2 + step))
           continue;
         let lower = angle2 - step, upper = angle2 + step;
         for (let iteration = 0; iteration < 64; iteration++) {
           const a = lower + (upper - lower) * 0.3819660112501051, b = upper - (upper - lower) * 0.3819660112501051;
-          if (distance3(a) < distance3(b)) upper = b;
+          if (distance4(a) < distance4(b)) upper = b;
           else lower = a;
         }
         candidates2.push((lower + upper) / 2);
       }
       const angle = candidates2.reduce(
-        (best, angle2) => distance3(angle2) < distance3(best) ? angle2 : best,
+        (best, angle2) => distance4(angle2) < distance4(best) ? angle2 : best,
         candidates2[0]
       );
       return addVectors(
@@ -3283,8 +3300,8 @@ function filletEdges(shape, source, radius, edgeIds) {
   return modifyEdges("fillet", shape, source, radius, edgeIds);
 }
 __name(filletEdges, "filletEdges");
-function chamferEdges(shape, source, distance3, edgeIds) {
-  return modifyEdges("chamfer", shape, source, distance3, edgeIds);
+function chamferEdges(shape, source, distance4, edgeIds) {
+  return modifyEdges("chamfer", shape, source, distance4, edgeIds);
 }
 __name(chamferEdges, "chamferEdges");
 function booleanWithTopology(left, right, operation) {
@@ -3511,7 +3528,7 @@ function modifyEdges(kind, shape, source, amount, requestedIds) {
     return {
       shape: result,
       topology: transferShapeTopology(
-        [{ shape, topology: source, index: 1 }],
+        [{ shape, topology: source, namespace: "preserve" }],
         result,
         builder
       ),
@@ -3586,15 +3603,18 @@ function transferShapeTopology(inputs, output, history) {
   const transfer = /* @__PURE__ */ __name((kind) => {
     const originals = [];
     const results = topologyShapes(output, kind);
+    let nextId = 1;
     try {
       const candidates2 = inputs.flatMap((input, inputIndex) => {
         const shapes = topologyShapes(input.shape, kind);
         originals.push(shapes);
         const source = input.topology[topologyMetadata[kind].plural];
         assertTopologyLength(kind, shapes, source);
+        if (input.namespace === "preserve")
+          nextId = Math.max(nextId, source.nextId);
         return shapes.map((shape, index) => {
           const id = source.ids[index];
-          const inherited2 = input.index !== void 0 ? inheritedTopologyId(input.index, id) : typeof id === "number" ? void 0 : id;
+          const inherited2 = typeof input.namespace === "number" ? inheritedTopologyId(input.namespace, id) : input.namespace === "preserve" || typeof id !== "number" ? id : void 0;
           const unchanged = matchingOutputShapes(shape.wrapped, results);
           if (unchanged.length) return { id: inherited2, matches: unchanged };
           if (typeof history !== "function") {
@@ -3631,10 +3651,8 @@ function transferShapeTopology(inputs, output, history) {
           inherited.set(index, candidate.id);
         }
       }
-      let nextId = 1;
-      return stableTopology(
-        results.map((_, index) => inherited.get(index) ?? nextId++)
-      );
+      const ids = results.map((_, index) => inherited.get(index) ?? nextId++);
+      return stableTopology(ids, nextId);
     } finally {
       originals.forEach(deleteShapes);
       deleteShapes(results);
@@ -3693,11 +3711,14 @@ function stableGroupIds(kind, shapes, topology, kernelIds) {
 }
 __name(stableGroupIds, "stableGroupIds");
 function initialTopology(shapes) {
-  return stableTopology(shapes.map((_, index) => index + 1));
+  return stableTopology(
+    shapes.map((_, index) => index + 1),
+    shapes.length + 1
+  );
 }
 __name(initialTopology, "initialTopology");
-function stableTopology(ids) {
-  return { ids };
+function stableTopology(ids, nextId) {
+  return { ids, nextId };
 }
 __name(stableTopology, "stableTopology");
 function shapeTopology(vertices, edges, surfaces) {
@@ -3798,7 +3819,11 @@ function loftWithTopology(sections, spine, ruled) {
       ruled,
       holes.map((wires) => wires[0])
     );
-    return booleanWithTopology(outer, inner, "cut");
+    return booleanWithTopology(
+      { ...outer, namespace: "intermediate" },
+      { ...inner, namespace: "intermediate" },
+      "cut"
+    );
   } finally {
     inner?.shape.delete();
     outer?.shape.delete();
@@ -6036,7 +6061,7 @@ function openShell(shape, topology, thickness, removedIds, sourceVolume) {
     return {
       shape: result,
       topology: transferShapeTopology(
-        [{ shape, topology, index: 1 }],
+        [{ shape, topology, namespace: "preserve" }],
         result,
         builder
       )
@@ -6112,7 +6137,7 @@ function closedShell(shape, topology, thickness, sourceVolume) {
       return {
         shape: result,
         topology: transferShapeTopology(
-          [{ shape, topology, index: 1 }],
+          [{ shape, topology, namespace: "preserve" }],
           result,
           cut2
         )
@@ -20264,6 +20289,7 @@ function inspectSurface(face) {
 __name(inspectSurface, "inspectSurface");
 
 // packages/core/src/library/runtime.ts
+var observeDistance;
 function isAxisSelection(pivot2) {
   return pivot2.kind === "axisLine" || pivot2.kind === "axisEdge";
 }
@@ -20279,10 +20305,16 @@ __name(mapSelectionReference, "mapSelectionReference");
 var activeRelate;
 var valueTraces = /* @__PURE__ */ new WeakMap();
 var operationTraces = /* @__PURE__ */ new WeakMap();
-function beginModelEvaluation(checkCancelled) {
+function beginModelEvaluation(checkCancelled, distanceObserver) {
   valueTraces = /* @__PURE__ */ new WeakMap();
   operationTraces = /* @__PURE__ */ new WeakMap();
-  return beginKernelOperationEvaluation(checkCancelled);
+  const previous = observeDistance;
+  observeDistance = distanceObserver;
+  const finish = beginKernelOperationEvaluation(checkCancelled);
+  return () => {
+    observeDistance = previous;
+    finish();
+  };
 }
 __name(beginModelEvaluation, "beginModelEvaluation");
 function valueTrace(value) {
@@ -20710,10 +20742,10 @@ function rotationPointReference(point3) {
   return reference;
 }
 __name(rotationPointReference, "rotationPointReference");
-function rotationAxisReference(axis) {
+function straightAxisReference(axis, operation = "axisLine()") {
   const reference = anchorReference(axis);
   if (reference.kind !== "line")
-    throw new Error("axisLine() requires an axis or straight edge.");
+    throw new Error(`${operation} 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(
@@ -20724,12 +20756,12 @@ function rotationAxisReference(axis) {
     ) : geometry.shape.geomType === "LINE";
     if (!straight)
       throw new Error(
-        "axisLine() requires a straight axis; curved edges do not define one rotation axis."
+        `${operation} requires a straight axis; curved edges do not define one axis.`
       );
   }
   return reference;
 }
-__name(rotationAxisReference, "rotationAxisReference");
+__name(straightAxisReference, "straightAxisReference");
 var PivotRotation = class extends RelationExpression {
   /** @internal */
   constructor(chain, selection, previous) {
@@ -20845,7 +20877,7 @@ __name(axisEdge, "axisEdge");
 function axisLine(axis) {
   return new AxisChain(new TransformationRotation(), {
     kind: "axisLine",
-    axis: rotationAxisReference(axis)
+    axis: straightAxisReference(axis)
   });
 }
 __name(axisLine, "axisLine");
@@ -21736,33 +21768,64 @@ var ModelObject = class _ModelObject extends RelationObject {
       operation
     );
   }
-  /** Resolve both own and occurrence references into this model's local frame. */
-  localElements(sources) {
+  /**
+   * Measure finite geometry in this model's local frame, or in relativeTo's frame.
+   * An explicit reference includes solved placement and nested group occurrences.
+   * Empty groups have no finite bounds.
+   */
+  bounds(relativeTo) {
+    const target = relativeTo === void 0 ? this : requireModelObject(relativeTo, "bounds requires a reference model.");
+    const transform = target.localFrames([this])[0];
+    const [minimum, maximum] = this[referenceBounds](
+      this.relationAnchorReference(),
+      transform
+    );
+    return {
+      minimum,
+      maximum,
+      size: [
+        maximum[0] - minimum[0],
+        maximum[1] - minimum[1],
+        maximum[2] - minimum[2]
+      ]
+    };
+  }
+  /**
+   * Model-origin coordinates in relativeTo's local frame, including placement.
+   * This model's origin in its own frame is always [0, 0, 0], even for point models.
+   */
+  position(relativeTo) {
+    const target = requireModelObject(
+      relativeTo,
+      "position requires a reference model."
+    );
+    return target.localFrames([this])[0].position;
+  }
+  /** Resolve source frames without losing nested occurrence positions. */
+  localFrames(sources) {
     const members = this.memberPoses();
-    const external = sources.map((source) => anchorReference(source).model).filter((model) => !members.has(model));
+    const external = sources.filter((model) => !members.has(model));
     const context = external.length ? _ModelObject.createSolveContext([this, ...external]) : void 0;
     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);
+      const memberPose = members.get(source);
       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 memberPose ?? relativeTransform(source.solvePose(context), this.solvePose(context));
+    });
+  }
+  /** Resolve both own and occurrence references into this model's local frame. */
+  localElements(sources) {
+    const references2 = sources.map(anchorReference);
+    const transforms = this.localFrames(
+      references2.map((reference) => reference.model)
+    );
+    return sources.map((source, index) => {
+      const { kind, transform, topology, parts, members, bound, facing } = source instanceof _ModelObject ? source.exposedElement() : references2[index];
       return transformElement(
-        { kind, transform: frame, topology, members: nested, bound, facing },
-        transform
+        { kind, transform, topology, parts, members, bound, facing },
+        transforms[index]
       );
     });
   }
@@ -21804,7 +21867,11 @@ var ModelObject = class _ModelObject extends RelationObject {
   /** @internal */
   exposedElement() {
     if (this.kind === "group")
-      return { ...this.geometryAnchor, members: this.elements };
+      return {
+        ...this.geometryAnchor,
+        parts: this.geometryParts(),
+        members: this.elements
+      };
     const geometry = this.requireGeometry().value;
     const kind = this.kind === "face" ? "surface" : this.kind;
     const selection = kind === "solid" ? { kind } : {
@@ -22009,14 +22076,14 @@ var ModelObject = class _ModelObject extends RelationObject {
       storedOperation("scaled", [{ model: this, role: "source", index: 0 }])
     );
   }
-  extrude(distance3 = 10) {
+  extrude(distance4 = 10) {
     if (this.kind !== "face")
       throw new Error("extrude requires a single face model.");
-    if (!Number.isFinite(distance3) || distance3 === 0)
+    if (!Number.isFinite(distance4) || distance4 === 0)
       throw new Error("Extrusion distance must be finite and non-zero.");
     const source = this.requireGeometry();
     const direction = rotateVector(
-      [0, distance3, 0],
+      [0, distance4, 0],
       this.geometryAnchor.transform.quaternion
     );
     const geometry = evaluateSolidGeometry(
@@ -22027,7 +22094,7 @@ var ModelObject = class _ModelObject extends RelationObject {
         {
           shape: source.value.shape,
           topology: source.value.topology,
-          index: 1
+          namespace: 1
         },
         direction
       )
@@ -22094,8 +22161,8 @@ var ModelObject = class _ModelObject extends RelationObject {
       })
     );
   }
-  chamfer(distance3 = 1, edgeIds) {
-    assertPositive("distance", distance3);
+  chamfer(distance4 = 1, edgeIds) {
+    assertPositive("distance", distance4);
     const source = this.requireSolidGeometry();
     const selectedEdgeIds = resolveEdgeSelection(
       source.value.topology.edges,
@@ -22103,13 +22170,13 @@ var ModelObject = class _ModelObject extends RelationObject {
     );
     const geometry = evaluateSolidGeometry(
       "chamfer",
-      [distance3, selectedEdgeIds],
+      [distance4, selectedEdgeIds],
       [source],
       () => {
         const result = chamferEdges(
           source.value.shape,
           source.value.topology,
-          distance3,
+          distance4,
           selectedEdgeIds
         );
         return { shape: result.shape, topology: result.topology };
@@ -22423,12 +22490,12 @@ var ModelObject = class _ModelObject extends RelationObject {
                 {
                   shape: geometry.value.shape,
                   topology: geometry.value.topology,
-                  index: otherIndex === 0 ? 1 : void 0
+                  namespace: otherIndex === 0 ? 1 : "intermediate"
                 },
                 {
                   shape: operand.value,
                   topology: otherGeometry.value.topology,
-                  index: otherIndex + 2
+                  namespace: otherIndex + 2
                 },
                 operation
               );
@@ -22477,6 +22544,176 @@ var ModelObject = class _ModelObject extends RelationObject {
     }
     return members;
   }
+  /** Finite members in this value's saved local assembly, without re-solving children. */
+  geometryParts(transform = identityRigidTransform) {
+    if (this.geometry)
+      return [{ source: this, selection: { kind: "solid" }, transform, scale: 1 }];
+    return this.children.flatMap(
+      (child) => child.geometryParts(
+        composeTransforms(transform, child.solvePose(this.assembly))
+      )
+    );
+  }
+  /** @internal */
+  static distance(a, b, axis) {
+    const left = anchorReference(a), right = anchorReference(b);
+    const axisReference = axis !== void 0 && typeof axis !== "string" && !Array.isArray(axis) ? straightAxisReference(axis, "distance() axis") : void 0;
+    const context = _ModelObject.createSolveContext([
+      left.model,
+      right.model,
+      ...axisReference ? [axisReference.model] : []
+    ]);
+    const topologyParts = /* @__PURE__ */ __name((reference) => reference.topology ? [reference.topology] : reference.parts ?? (reference.whole && reference.model instanceof _ModelObject ? reference.model.geometryParts() : void 0), "topologyParts");
+    const parts = /* @__PURE__ */ __name((reference) => {
+      const pose = reference.model.solvePose(context);
+      const frame = composeTransforms(pose, reference.transform);
+      if (reference.kind === "point") return [{ points: [frame.position] }];
+      const topology = topologyParts(reference);
+      if (topology)
+        return topology.map((part) => ({
+          geometry: part.source.requireGeometry(),
+          selection: part.selection,
+          scale: part.scale,
+          transform: composeTransforms(pose, part.transform)
+        }));
+      if (reference.bound) {
+        const [x, z] = reference.bound.size;
+        const corners = x === 0 && z === 0 ? [origin] : x === 0 ? [
+          [0, 0, -z / 2],
+          [0, 0, z / 2]
+        ] : z === 0 ? [
+          [-x / 2, 0, 0],
+          [x / 2, 0, 0]
+        ] : [
+          [-x / 2, 0, -z / 2],
+          [x / 2, 0, -z / 2],
+          [x / 2, 0, z / 2],
+          [-x / 2, 0, z / 2]
+        ];
+        return [
+          {
+            points: corners.map(
+              (point3) => composeTransforms(frame, translation(point3)).position
+            )
+          }
+        ];
+      }
+      throw new Error(
+        "distance() requires finite geometry or a point; select an edge or face instead of an infinite axis or plane."
+      );
+    }, "parts");
+    const first = parts(left), second = parts(right);
+    if (!first.length || !second.length)
+      throw new Error("distance() cannot measure an empty group.");
+    const record = /* @__PURE__ */ __name((result, direction2) => {
+      if (observeDistance) {
+        const operands = [left, right].map((reference) => {
+          const topology = topologyParts(reference);
+          const elements = topology && reference.kind !== "point" ? topology.map(
+            (part) => snapshotElements({
+              [reference.name]: {
+                ...reference,
+                topology: part,
+                members: void 0
+              }
+            })[0]
+          ) : [
+            snapshotElements({
+              [reference.name]: { ...reference, members: void 0 }
+            })[0]
+          ];
+          return { nodeId: reference.model.nodeId, elements };
+        });
+        observeDistance(
+          {
+            ...result,
+            axis: direction2,
+            axisName: typeof axis === "string" ? axis : void 0,
+            operands,
+            placements: [...context.poses].map(([model, pose]) => ({
+              nodeId: model.nodeId,
+              transform: toTransform(pose)
+            }))
+          },
+          [...context.poses.keys()]
+        );
+      }
+      return result.value;
+    }, "record");
+    if (axis === void 0) {
+      let result;
+      for (const a2 of first)
+        for (const b2 of second) {
+          const candidate = "points" in a2 && a2.points.length === 1 && "points" in b2 && b2.points.length === 1 ? {
+            value: Math.hypot(
+              ...a2.points[0].map((value, i) => value - b2.points[0][i])
+            ),
+            start: a2.points[0],
+            end: b2.points[0]
+          } : distanceBetweenParts(a2, b2).value;
+          if (!result || candidate.value < result.value) result = candidate;
+          if (result.value === 0) return record(result);
+        }
+      return record(result);
+    }
+    const direction = axisReference ? rotateVector(
+      [0, 1, 0],
+      composeTransforms(
+        axisReference.model.solvePose(context),
+        axisReference.transform
+      ).quaternion
+    ) : typeof axis === "string" ? distanceAxes[axis] : axis;
+    assertFiniteVector("distance() axis", direction);
+    const magnitude = Math.hypot(...direction);
+    if (magnitude === 0) throw new Error("distance() axis must be non-zero.");
+    const normalized = direction.map(
+      (value) => value / magnitude
+    );
+    const project = invertTransform(frameFromYAxis(origin, normalized));
+    const projectedBounds = /* @__PURE__ */ __name((parts2) => {
+      const bounds = parts2.map((part) => {
+        if ("points" in part)
+          return pointBounds(
+            part.points.map(
+              (point3) => composeTransforms(project, translation(point3)).position
+            )
+          );
+        return evaluateSnapshotQuery(
+          boundsQuery(
+            part.geometry,
+            composeTransforms(project, part.transform),
+            part.selection,
+            part.scale
+          )
+        );
+      });
+      return [
+        [0, 1, 2].map(
+          (i) => Math.min(...bounds.map((value) => value[0][i]))
+        ),
+        [0, 1, 2].map(
+          (i) => Math.max(...bounds.map((value) => value[1][i]))
+        )
+      ];
+    }, "projectedBounds");
+    const aBounds = projectedBounds(first), bBounds = projectedBounds(second);
+    const [aMin, aMax] = [aBounds[0][1], aBounds[1][1]], [bMin, bMax] = [bBounds[0][1], bBounds[1][1]];
+    const overlap2 = (Math.max(aMin, bMin) + Math.min(aMax, bMax)) / 2;
+    const [start, end] = bMin > aMax ? [aMax, bMin] : aMin > bMax ? [aMin, bMax] : [overlap2, overlap2];
+    const center = [0, 1, 2].map(
+      (i) => (Math.max(aBounds[0][i], bBounds[0][i]) + Math.min(aBounds[1][i], bBounds[1][i])) / 2
+    );
+    const unproject = invertTransform(project);
+    const at = /* @__PURE__ */ __name((y) => composeTransforms(unproject, translation([center[0], y, center[2]])).position, "at");
+    return record(
+      {
+        value: Math.max(0, bMin - aMax, aMin - bMax),
+        start: at(start),
+        end: at(end)
+      },
+      normalized
+    );
+  }
   /** Bounds of the selected finite geometry after a rigid transform. */
   [referenceBoundsParts](reference, transform) {
     if (reference.bound)
@@ -22508,6 +22745,15 @@ var ModelObject = class _ModelObject extends RelationObject {
         )
       ];
     }
+    if (reference.parts)
+      return reference.parts.map(
+        (part) => boundsQuery(
+          part.source.requireGeometry(),
+          composeTransforms(transform, part.transform),
+          part.selection,
+          part.scale
+        )
+      );
     return [{ bounds: super[referenceBounds](reference, transform) }];
   }
   /** Bounds of the selected finite geometry after a rigid transform. */
@@ -22587,7 +22833,7 @@ var ModelObject = class _ModelObject extends RelationObject {
     );
   }
   edgeReference(id) {
-    return { ...rotationAxisReference(this.edge(id)), model: void 0 };
+    return { ...straightAxisReference(this.edge(id)), model: void 0 };
   }
   vertexPosition(id) {
     return anchorReference(this.vertex(id)).transform.position;
@@ -22951,11 +23197,11 @@ function assertCoilClearance(radius, wireRadius, pitch, turns) {
     else upper = middle;
   }
   const separation = Math.min(fullTurn * turns, (lower + upper) / 2);
-  const distance3 = Math.hypot(
+  const distance4 = Math.hypot(
     2 * radius * Math.sin(separation / 2),
     pitch * separation / fullTurn
   );
-  if (distance3 <= 2 * wireRadius) {
+  if (distance4 <= 2 * wireRadius) {
     throw new Error(
       "Coil turns must not touch or overlap; increase pitch or decrease wireRadius."
     );
@@ -23148,12 +23394,16 @@ function group(children, name = "Group") {
   });
 }
 __name(group, "group");
+function distance2(a, b, axis) {
+  return ModelObject.distance(a, b, axis);
+}
+__name(distance2, "distance");
 function union(operands) {
   const { first, others } = booleanOperands("union", operands);
   return first[combineModels]("fuse", others);
 }
 __name(union, "union");
-function extrude(face, distance3 = 10) {
+function extrude(face, distance4 = 10) {
   const faces = (Array.isArray(face) ? face : [face]).map(
     (value) => requireModelKind(
       value,
@@ -23161,7 +23411,7 @@ function extrude(face, distance3 = 10) {
       "extrude requires a face model or an array of face models."
     )
   );
-  const solids = faces.map((value) => value.extrude(distance3));
+  const solids = faces.map((value) => value.extrude(distance4));
   return Array.isArray(face) ? solids : solids[0];
 }
 __name(extrude, "extrude");
@@ -23261,6 +23511,83 @@ function relatedModelObjects(object) {
   return object.relatedObjects();
 }
 __name(relatedModelObjects, "relatedModelObjects");
+var distanceAxes = { x: [1, 0, 0], y: [0, 1, 0], z: [0, 0, 1] };
+function withDistanceShape(part, visit) {
+  if (!("points" in part))
+    return withTransformedGeometry(part.geometry.value, part, visit);
+  const points = part.points;
+  if (points.length <= 2) {
+    const shape = points.length === 1 ? makeVertex(toPoint(points[0])) : makeLine2(toPoint(points[0]), toPoint(points[1]));
+    try {
+      return visit(shape);
+    } finally {
+      shape.delete();
+    }
+  }
+  const edges = [];
+  let wire;
+  let face;
+  try {
+    points.forEach(
+      (point3, index) => edges.push(
+        makeLine2(toPoint(point3), toPoint(points[(index + 1) % points.length]))
+      )
+    );
+    wire = assembleWire(edges);
+    face = makeFace(wire);
+    return visit(face);
+  } finally {
+    face?.delete();
+    wire?.delete();
+    edges.forEach((edge) => edge.delete());
+  }
+}
+__name(withDistanceShape, "withDistanceShape");
+var distanceBetweenParts = cachedArtifact(
+  (a, b) => withDistanceShape(
+    a,
+    (left) => withDistanceShape(b, (right) => {
+      const query = new (getOC12()).BRepExtrema_DistShapeShape();
+      try {
+        query.LoadS1(left.wrapped);
+        query.LoadS2(right.wrapped);
+        query.Perform();
+        if (!query.IsDone())
+          throw new Error("distance() could not measure these geometries.");
+        const first = query.PointOnShape1(1), second = query.PointOnShape2(1);
+        try {
+          return {
+            value: query.Value(),
+            start: [first.X(), first.Y(), first.Z()],
+            end: [second.X(), second.Y(), second.Z()]
+          };
+        } finally {
+          first.delete();
+          second.delete();
+        }
+      } finally {
+        query.delete();
+      }
+    })
+  ),
+  {
+    key: /* @__PURE__ */ __name((a, b) => kernelOperationKey(
+      "distance-witnesses",
+      [a, b].map(
+        (part) => "points" in part ? ["points", part.points] : [
+          "shape",
+          part.geometry.id,
+          part.selection.kind,
+          part.selection.kind === "solid" ? null : part.selection.id,
+          part.transform.position,
+          part.transform.quaternion,
+          part.scale
+        ]
+      ),
+      [a, b].flatMap((part) => "points" in part ? [] : [part.geometry])
+    ), "key")
+  }
+);
 function boundsQuery(geometry, transform, selection = { kind: "solid" }, scale3 = 1) {
   return {
     inputId: geometry.id,
@@ -23375,7 +23702,7 @@ function planModelSnapshotQueries(objects) {
     sourceRef,
     weight: (1 + (input.geometry.topology?.edges.ids.length ?? 0) + (input.geometry.topology?.surfaces.ids.length ?? 0)) * queries.length,
     encode: /* @__PURE__ */ __name(() => encodeKernelArtifact(id, input.geometry), "encode"),
-    accept: /* @__PURE__ */ __name((query, value) => snapshotQuery.accept(query.key, value), "accept")
+    accept: /* @__PURE__ */ __name((query, value, milliseconds) => snapshotQuery.accept(query.key, value, milliseconds), "accept")
   }));
 }
 __name(planModelSnapshotQueries, "planModelSnapshotQueries");
@@ -23389,7 +23716,9 @@ function executeSnapshotQueryBatch(id, bytes, queries, checkCancelled, onResult,
     onRestore?.(performance.now() - started);
     for (const query of queries) {
       checkCancelled();
-      onResult(query, computeSnapshotQuery(geometry, query));
+      const started2 = performance.now();
+      const value = computeSnapshotQuery(geometry, query);
+      onResult(query, value, performance.now() - started2);
     }
   } finally {
     geometry.shape.delete();
@@ -23457,7 +23786,7 @@ var authoringApi = Object.freeze({
   pivotPoint,
   axisEdge,
   axisLine,
-  cached,
+  cache,
   font,
   googleFont,
   text,
@@ -23481,6 +23810,7 @@ var authoringApi = Object.freeze({
   frustum,
   regularPrism,
   group,
+  distance: distance2,
   union,
   cut,
   intersect
@@ -23585,15 +23915,15 @@ function evaluateSolidGeometry(operation, arguments_, inputs, compute) {
   );
 }
 __name(evaluateSolidGeometry, "evaluateSolidGeometry");
-function renderMesh(artifact, shape, cache, tolerance2, topology) {
-  const cached2 = cache.get(shape);
-  if (cached2) {
-    return cached2;
+function renderMesh(artifact, shape, cache2, tolerance2, topology) {
+  const cached = cache2.get(shape);
+  if (cached) {
+    return cached;
   }
   const mesh = evaluateSnapshotQuery(
     meshQuery(artifact, shape, tolerance2, topology)
   );
-  cache.set(shape, mesh);
+  cache2.set(shape, mesh);
   return mesh;
 }
 __name(renderMesh, "renderMesh");
@@ -23778,7 +24108,7 @@ function buildLoftGeometry(sections, spine, ruled) {
           section.transform
         ),
         topology: section.geometry.value.topology,
-        index: index + 1
+        namespace: index + 1
       });
     }
     if (spine) {
@@ -23858,6 +24188,10 @@ function axisAlignedBounds(bounds, transform) {
 }
 __name(axisAlignedBounds, "axisAlignedBounds");
 function computeTransformedBounds(geometry, query) {
+  return withTransformedGeometry(geometry, query, shapeBounds);
+}
+__name(computeTransformedBounds, "computeTransformedBounds");
+function withTransformedGeometry(geometry, query, visit) {
   const { transform, selection, scale: scale3 } = query;
   return withTopologyShape(
     geometry.shape,
@@ -23868,7 +24202,7 @@ function computeTransformedBounds(geometry, query) {
       try {
         const moved = shapeWithTransform(scaled, transform);
         try {
-          return shapeBounds(moved);
+          return visit(moved);
         } finally {
           moved.delete();
         }
@@ -23878,7 +24212,7 @@ function computeTransformedBounds(geometry, query) {
     }
   );
 }
-__name(computeTransformedBounds, "computeTransformedBounds");
+__name(withTransformedGeometry, "withTransformedGeometry");
 function pointBounds(points) {
   if (!points.length)
     throw new Error("Empty geometry has no directional bounds.");
@@ -23980,6 +24314,10 @@ function transformElement(element, transform) {
       ...element.topology,
       transform: composeTransforms(transform, element.topology.transform)
     } : void 0,
+    parts: element.parts?.map((part) => ({
+      ...part,
+      transform: composeTransforms(transform, part.transform)
+    })),
     members: element.members ? Object.fromEntries(
       Object.entries(element.members).map(([name, member]) => [
         name,
@@ -24004,6 +24342,11 @@ function scaleElement(element, factor) {
       scale: element.topology.scale * factor,
       transform: scaleFrame(element.topology.transform, factor)
     } : void 0,
+    parts: element.parts?.map((part) => ({
+      ...part,
+      scale: part.scale * factor,
+      transform: scaleFrame(part.transform, factor)
+    })),
     members: element.members ? scaleElements(element.members, factor) : void 0,
     transform: {
       ...element.transform,
@@ -24655,8 +24998,8 @@ function sketchPointResolver(layers) {
   const visiting = /* @__PURE__ */ new Set();
   const resolve = /* @__PURE__ */ __name((ref) => {
     const key = JSON.stringify([ref.layer, ref.id]);
-    const cached2 = resolved.get(key);
-    if (cached2) return cached2;
+    const cached = resolved.get(key);
+    if (cached) return cached;
     const point3 = points.get(key);
     if (!point3) throw new Error(`Missing sketch point ${ref.id}.`);
     if (visiting.has(key))
@@ -24971,7 +25314,7 @@ __name(solvedProblem, "solvedProblem");
 
 // packages/core/src/library/sketch-regions.ts
 var tau2 = 2 * Math.PI;
-var distance2 = /* @__PURE__ */ __name((a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]), "distance");
+var distance3 = /* @__PURE__ */ __name((a, b) => Math.hypot(a[0] - b[0], a[1] - b[1]), "distance");
 function sketchRegions(layers) {
   const resolve = sketchPointResolver(layers);
   const points = new Map(
@@ -24993,7 +25336,7 @@ function sketchRegions(layers) {
   const vertices = [];
   const vertex = /* @__PURE__ */ __name((position2, tolerance2) => {
     const index = vertices.findIndex(
-      (v) => distance2(v.position, position2) <= Math.min(v.tolerance, tolerance2)
+      (v) => distance3(v.position, position2) <= Math.min(v.tolerance, tolerance2)
     );
     if (index >= 0) return index;
     vertices.push({ position: position2, tolerance: tolerance2, edges: [] });
@@ -25023,7 +25366,7 @@ function sketchRegions(layers) {
       ) || contacts.some(
         (c) => c.parameters.some((_, j) => {
           const curve = j === 0 ? a.curve : b.curve;
-          return curve.kind === "circle" || distance2(c.position, sketchCurvePosition(curve, 0)) > sketchCurveTolerance(curve) && distance2(c.position, sketchCurvePosition(curve, 1)) > sketchCurveTolerance(curve);
+          return curve.kind === "circle" || distance3(c.position, sketchCurvePosition(curve, 0)) > sketchCurveTolerance(curve) && distance3(c.position, sketchCurvePosition(curve, 1)) > sketchCurveTolerance(curve);
         })
       ))
         throw new Error(
@@ -25098,7 +25441,7 @@ function overlap(a, b, intersections) {
   if (a.kind === "line" || b.kind === "line") {
     if (a.kind !== "line" || b.kind !== "line" || intersections.length < 2)
       return false;
-  } else if (distance2(a.center, b.center) > Math.min(sketchCurveTolerance(a), sketchCurveTolerance(b)) || Math.abs(a.radius - b.radius) > Math.min(sketchCurveTolerance(a), sketchCurveTolerance(b)))
+  } else if (distance3(a.center, b.center) > Math.min(sketchCurveTolerance(a), sketchCurveTolerance(b)) || Math.abs(a.radius - b.radius) > Math.min(sketchCurveTolerance(a), sketchCurveTolerance(b)))
     return false;
   const cuts = [0, ...intersections, 1].sort((a2, b2) => a2 - b2);
   return cuts.slice(1).some(
@@ -25161,10 +25504,11 @@ export {
   clearKernelOperationCache,
   kernelOperationCacheStats,
   setKernelCacheBudget,
+  setKernelCachePersistenceThreshold,
   setKernelArtifactStore,
   setKernelExternalBytes,
   identifyCachedFunction,
-  cached,
+  cache,
   googleFontUrl,
   googleFontSources,
   installFontEngine,
@@ -25231,6 +25575,7 @@ export {
   regularPrism,
   primitiveConstructor,
   group,
+  distance2 as distance,
   union,
   extrude,
   text,
@@ -25266,4 +25611,4 @@ export {
   assertSketchDragConnections,
   solveSketchSnapshot
 };
-//# sourceMappingURL=chunk-T3RAUNSF.js.map
+//# sourceMappingURL=chunk-MICNLFBF.js.map