forgecad 0.10.0 → 0.10.1

package/dist-cli/{chunk-OAN5T4XD.js → chunk-UWTJCGXF.js}

@@ -361,8 +361,8 @@ function normalizeVariadicArgs({ apiName, inputs, minCount, itemName, usage, coe
   return flattened.map((value, index) => {
     try {
       return coerce(value);
-    } catch (error) {
-      const message = error instanceof Error ? error.message : String(error);
+    } catch (error2) {
+      const message = error2 instanceof Error ? error2.message : String(error2);
       throw new Error(`${apiName} argument ${index + 1}: ${message}`);
     }
   });
@@ -2442,7 +2442,7 @@ function cloneProfileCompilePlan(plan) {
       return {
         kind: "boolean",
         op: plan.op,
-        profiles: plan.profiles.map((profile) => cloneProfileCompilePlan(profile)),
+        profiles: plan.profiles.map((profile2) => cloneProfileCompilePlan(profile2)),
         transforms: plan.transforms.map(cloneProfileTransform)
       };
     case "offset":
@@ -2580,7 +2580,7 @@ function cloneShapeCompilePlan(plan) {
     case "loft":
       result = {
         kind: "loft",
-        profiles: plan.profiles.map((profile) => cloneProfileCompilePlan(profile)),
+        profiles: plan.profiles.map((profile2) => cloneProfileCompilePlan(profile2)),
         heights: plan.heights.map((height) => height),
         edgeLength: plan.edgeLength,
         boundsPadding: plan.boundsPadding,
@@ -2975,7 +2975,7 @@ function buildBooleanProfileCompilePlan(op, profiles2) {
   return {
     kind: "boolean",
     op,
-    profiles: profiles2.map((profile) => cloneProfileCompilePlan(profile)),
+    profiles: profiles2.map((profile2) => cloneProfileCompilePlan(profile2)),
     transforms: []
   };
 }
@@ -3044,7 +3044,7 @@ function buildChamferShapeCompilePlan(base, edge, size, quadrant) {
 function buildLoftShapeCompilePlan(profiles2, heights, options) {
   return {
     kind: "loft",
-    profiles: profiles2.map((profile) => cloneProfileCompilePlan(profile)),
+    profiles: profiles2.map((profile2) => cloneProfileCompilePlan(profile2)),
     heights: heights.map((height) => canonicalNumber(height)),
     edgeLength: canonicalNumber(options.edgeLength),
     boundsPadding: canonicalNumber(options.boundsPadding),
@@ -3053,10 +3053,10 @@ function buildLoftShapeCompilePlan(profiles2, heights, options) {
     edgeLabels: options.edgeLabels ? { ...options.edgeLabels } : void 0
   };
 }
-function buildSweepShapeCompilePlan(profile, path2, options) {
+function buildSweepShapeCompilePlan(profile2, path2, options) {
   return {
     kind: "sweep",
-    profile: cloneProfileCompilePlan(profile),
+    profile: cloneProfileCompilePlan(profile2),
     path: cloneSweepPathCompilePlan(path2),
     edgeLength: canonicalNumber(options.edgeLength),
     boundsPadding: canonicalNumber(options.boundsPadding),
@@ -4543,48 +4543,48 @@ var DRAFT_TO_LOFT_EPSILON = 1e-9;
 var DRAFT_TO_LOFT_ZERO_EPSILON = 1e-12;
 var DRAFT_TO_LOFT_EDGE_LENGTH = 1;
 var DRAFT_TO_LOFT_BOUNDS_PADDING = 1;
-function offsetProfile(profile, delta) {
-  if (Math.abs(delta) <= DRAFT_TO_LOFT_ZERO_EPSILON) return cloneProfileCompilePlan(profile);
+function offsetProfile(profile2, delta) {
+  if (Math.abs(delta) <= DRAFT_TO_LOFT_ZERO_EPSILON) return cloneProfileCompilePlan(profile2);
   return {
     kind: "offset",
-    base: cloneProfileCompilePlan(profile),
+    base: cloneProfileCompilePlan(profile2),
     delta,
     join: "Miter",
     transforms: []
   };
 }
-function scaleProfile(profile, scale11) {
+function scaleProfile(profile2, scale11) {
   if (!Number.isFinite(scale11[0]) || !Number.isFinite(scale11[1]) || scale11[0] <= DRAFT_TO_LOFT_EPSILON || scale11[1] <= DRAFT_TO_LOFT_EPSILON) {
     return null;
   }
   if (Math.abs(scale11[0] - 1) <= DRAFT_TO_LOFT_EPSILON && Math.abs(scale11[1] - 1) <= DRAFT_TO_LOFT_EPSILON) {
-    return cloneProfileCompilePlan(profile);
+    return cloneProfileCompilePlan(profile2);
   }
-  if (profile.transforms.length > 0) return null;
-  switch (profile.kind) {
+  if (profile2.transforms.length > 0) return null;
+  switch (profile2.kind) {
     case "rect":
-      return { kind: "rect", width: profile.width * scale11[0], height: profile.height * scale11[1], transforms: [] };
+      return { kind: "rect", width: profile2.width * scale11[0], height: profile2.height * scale11[1], transforms: [] };
     case "roundedRect":
       if (Math.abs(scale11[0] - scale11[1]) > DRAFT_TO_LOFT_EPSILON) return null;
       return {
         kind: "roundedRect",
-        width: profile.width * scale11[0],
-        height: profile.height * scale11[1],
-        radius: profile.radius * scale11[0],
+        width: profile2.width * scale11[0],
+        height: profile2.height * scale11[1],
+        radius: profile2.radius * scale11[0],
         transforms: []
       };
     case "circle":
       if (Math.abs(scale11[0] - scale11[1]) > DRAFT_TO_LOFT_EPSILON) return null;
-      return { kind: "circle", radius: profile.radius * scale11[0], segments: profile.segments, transforms: [] };
+      return { kind: "circle", radius: profile2.radius * scale11[0], segments: profile2.segments, transforms: [] };
     case "polygon":
-      return { kind: "polygon", points: profile.points.map(([x, y]) => [x * scale11[0], y * scale11[1]]), transforms: [] };
+      return { kind: "polygon", points: profile2.points.map(([x, y]) => [x * scale11[0], y * scale11[1]]), transforms: [] };
     case "pathProfile":
       return null;
     case "boolean": {
-      if (profile.transforms.length > 0) return null;
-      const profiles2 = profile.profiles.map((child) => scaleProfile(child, scale11));
+      if (profile2.transforms.length > 0) return null;
+      const profiles2 = profile2.profiles.map((child) => scaleProfile(child, scale11));
       if (profiles2.some((child) => child == null)) return null;
-      return { kind: "boolean", op: profile.op, profiles: profiles2, transforms: [] };
+      return { kind: "boolean", op: profile2.op, profiles: profiles2, transforms: [] };
     }
     case "offset":
     case "project":
@@ -4597,10 +4597,10 @@ function directVerticalPrismDraftBase(plan) {
       return directVerticalPrismDraftBase(plan.base);
     case "box": {
       if (![plan.x, plan.y, plan.z].every(Number.isFinite)) return null;
-      const profile = { kind: "rect", width: Math.abs(plan.x), height: Math.abs(plan.y), transforms: [] };
+      const profile2 = { kind: "rect", width: Math.abs(plan.x), height: Math.abs(plan.y), transforms: [] };
       return {
-        bottomProfile: cloneProfileCompilePlan(profile),
-        topProfile: cloneProfileCompilePlan(profile),
+        bottomProfile: cloneProfileCompilePlan(profile2),
+        topProfile: cloneProfileCompilePlan(profile2),
         zMin: Math.min(0, plan.z),
         zMax: Math.max(0, plan.z)
       };
@@ -4951,13 +4951,13 @@ function buildHoleShapeCompilePlan(base, placement, hole2, extent) {
     extent: cloneFeatureCutExtent2(extent)
   };
 }
-function buildCutShapeCompilePlan(base, placement, profile, extent, taper) {
-  if (!base || !placement || !profile || !isFinitePositive2(featureCutExtentDepth(extent))) return null;
+function buildCutShapeCompilePlan(base, placement, profile2, extent, taper) {
+  if (!base || !placement || !profile2 || !isFinitePositive2(featureCutExtentDepth(extent))) return null;
   return {
     kind: "cut",
     base: cloneShapeCompilePlan(base),
     placement: cloneShapeWorkplanePlacement(placement),
-    profile: cloneProfileCompilePlan(profile),
+    profile: cloneProfileCompilePlan(profile2),
     extent: cloneFeatureCutExtent2(extent),
     taper: taper ? { scale: [taper.scale[0], taper.scale[1]] } : void 0
   };
@@ -6179,12 +6179,12 @@ function parseModel(data) {
   const objects = [];
   for (const match of xml.matchAll(/<object\b([^>]*)>([\s\S]*?)<\/object>/gi)) {
     const attrs = parseAttrs(match[1]);
-    const body = match[2];
-    const vertices = [...body.matchAll(/<vertex\b([^>]*)\/?>/gi)].map((vertexMatch) => {
+    const body2 = match[2];
+    const vertices = [...body2.matchAll(/<vertex\b([^>]*)\/?>/gi)].map((vertexMatch) => {
       const vertex = parseAttrs(vertexMatch[1]);
       return [finiteNumber(vertex.x, "vertex x"), finiteNumber(vertex.y, "vertex y"), finiteNumber(vertex.z, "vertex z")];
     });
-    const triangles = [...body.matchAll(/<triangle\b([^>]*)\/?>/gi)].map((triangleMatch) => {
+    const triangles = [...body2.matchAll(/<triangle\b([^>]*)\/?>/gi)].map((triangleMatch) => {
       const triangle = parseAttrs(triangleMatch[1]);
       return [
         finiteIndex(triangle.v1, "triangle v1"),
@@ -6204,8 +6204,8 @@ function parseModel(data) {
       type: cleanName(attrs.type) ?? void 0,
       vertices,
       triangles,
-      meshCount: [...body.matchAll(/<mesh\b/gi)].length,
-      components: [...body.matchAll(/<component\b([^>]*)\/?>/gi)].map((componentMatch) => {
+      meshCount: [...body2.matchAll(/<mesh\b/gi)].length,
+      components: [...body2.matchAll(/<component\b([^>]*)\/?>/gi)].map((componentMatch) => {
         const component = parseAttrs(componentMatch[1]);
         if (!component.objectid) throw new Error(`3MF object "${attrs.id ?? objects.length + 1}" contains a component without objectid`);
         return { objectId: component.objectid, transform: parseTransform(component.transform) };
@@ -8790,8 +8790,8 @@ function positiveMod(v, period) {
 function evalStripesPattern(u, v, directionX, directionY, spacing, width, depth) {
   const coord = u * directionX + v * directionY;
   const d = abs3(coord - Math.round(coord / spacing) * spacing);
-  const profile = max2(0, 1 - d / (width * 0.5));
-  return -(profile * profile) * depth;
+  const profile2 = max2(0, 1 - d / (width * 0.5));
+  return -(profile2 * profile2) * depth;
 }
 function evalOverUnderWeavePattern(u, v, spacingX, spacingY, widthX, widthY, depth, underScale) {
   const su = u / spacingX;
@@ -13014,7 +13014,7 @@ function applyProfileCompileTransforms(crossSection, transforms) {
   return out;
 }
 function lowerProfileBooleanCompilePlan(plan, wasm) {
-  const profiles2 = plan.profiles.map((profile) => lowerProfileCompilePlanToCrossSection(profile, wasm));
+  const profiles2 = plan.profiles.map((profile2) => lowerProfileCompilePlanToCrossSection(profile2, wasm));
   if (profiles2.length === 0) {
     throw new Error(`Cannot lower empty profile boolean (${plan.op})`);
   }
@@ -13414,11 +13414,11 @@ function fromSlicesOffsetEquivalentPlanForManifold(plan) {
   };
   return transformZAlignedFromSlicesPlanForManifold(zAligned, group2.normal);
 }
-function offsetProfilePolygonsForManifold(profile, thickness, wasm) {
+function offsetProfilePolygonsForManifold(profile2, thickness, wasm) {
   const crossSection = lowerProfileCompilePlanToCrossSection(
     {
       kind: "offset",
-      base: profile,
+      base: profile2,
       delta: thickness,
       join: "Miter",
       transforms: []
@@ -13431,8 +13431,8 @@ function offsetProfilePolygonsForManifold(profile, thickness, wasm) {
     disposeWasmObject(crossSection);
   }
 }
-function profilePolygonsForManifold(profile, wasm) {
-  const crossSection = lowerProfileCompilePlanToCrossSection(profile, wasm);
+function profilePolygonsForManifold(profile2, wasm) {
+  const crossSection = lowerProfileCompilePlanToCrossSection(profile2, wasm);
   try {
     return crossSection.toPolygons();
   } finally {
@@ -13475,7 +13475,7 @@ function lowerOffsetLoftCompilePlan(plan, thickness, wasm) {
   if (heights.some((height) => !Number.isFinite(height)) || heights.some((height, idx) => idx > 0 && height <= heights[idx - 1] + OFFSET_SOLID_EPS)) {
     throw new Error("offsetSolid() collapsed the compatible-loft height span.");
   }
-  const offsetPolygons = plan.profiles.map((profile) => offsetProfilePolygonsForManifold(profile, thickness, wasm));
+  const offsetPolygons = plan.profiles.map((profile2) => offsetProfilePolygonsForManifold(profile2, thickness, wasm));
   const stitched = loftStitched(offsetPolygons, heights, wasm, { edgeLength: plan.edgeLength });
   if (!stitched) {
     throw new Error(`Offset solid requires the OCCT backend. ${OCCT_BACKEND_REQUIRED_HINT}`);
@@ -13586,7 +13586,7 @@ function lowerOffsetSolidCompilePlan(plan, wasm) {
   if (zMax <= zMin + OFFSET_SOLID_EPS) {
     throw new Error("offsetSolid() collapsed the vertical-prism height.");
   }
-  const profile = lowerProfileCompilePlanToCrossSection(
+  const profile2 = lowerProfileCompilePlanToCrossSection(
     {
       kind: "offset",
       base: base.profile,
@@ -13597,16 +13597,16 @@ function lowerOffsetSolidCompilePlan(plan, wasm) {
     wasm
   );
   try {
-    const solid = profile.extrude(zMax - zMin, 0, 0, void 0, false);
+    const solid = profile2.extrude(zMax - zMin, 0, 0, void 0, false);
     if (Math.abs(zMin) <= OFFSET_SOLID_EPS) return solid;
     return applyShapeCompileTransforms(solid, [{ kind: "translate", x: 0, y: 0, z: zMin }]);
   } finally {
-    disposeWasmObject(profile);
+    disposeWasmObject(profile2);
   }
 }
 function lowerShapeLoftCompilePlan(plan, wasm) {
-  const inputPolygons = plan.profiles.map((profile) => {
-    const crossSection = lowerProfileCompilePlanToCrossSection(profile, wasm);
+  const inputPolygons = plan.profiles.map((profile2) => {
+    const crossSection = lowerProfileCompilePlanToCrossSection(profile2, wasm);
     try {
       return crossSection.toPolygons();
     } finally {
@@ -14007,9 +14007,9 @@ function lowerShapeFilletCompilePlan(plan, wasm) {
     const result = applyFilletSelectionToManifold(base, selection.selection, plan.radius, plan.segments, wasm);
     if (result !== base) disposeWasmObject(base);
     return result;
-  } catch (error) {
+  } catch (error2) {
     disposeWasmObject(base);
-    throw error;
+    throw error2;
   }
 }
 function lowerShapeChamferCompilePlan(plan, wasm) {
@@ -14025,9 +14025,9 @@ function lowerShapeChamferCompilePlan(plan, wasm) {
     const result = applyChamferSelectionToManifold(base, selection.selection, plan.size, wasm);
     if (result !== base) disposeWasmObject(base);
     return result;
-  } catch (error) {
+  } catch (error2) {
     disposeWasmObject(base);
-    throw error;
+    throw error2;
   }
 }
 function edgeSegmentToSelection(segment) {
@@ -14188,10 +14188,10 @@ function lowerShapeCompilePlanToManifold(plan, wasm) {
       }
     }
     case "extrude": {
-      const profile = lowerProfileCompilePlanToCrossSection(plan.profile, wasm);
+      const profile2 = lowerProfileCompilePlanToCrossSection(plan.profile, wasm);
       try {
         const height = plan.height;
-        const solid = profile.extrude(
+        const solid = profile2.extrude(
           Math.abs(height),
           plan.twistSegments ?? 0,
           plan.twist ?? 0,
@@ -14205,7 +14205,7 @@ function lowerShapeCompilePlanToManifold(plan, wasm) {
           disposeWasmObject(solid);
         }
       } finally {
-        disposeWasmObject(profile);
+        disposeWasmObject(profile2);
       }
     }
     case "sheetMetal":
@@ -14226,11 +14226,11 @@ function lowerShapeCompilePlanToManifold(plan, wasm) {
       return lowerShapeCompilePlanToManifold(lowered.plan, wasm);
     }
     case "revolve": {
-      const profile = lowerProfileCompilePlanToCrossSection(plan.profile, wasm);
+      const profile2 = lowerProfileCompilePlanToCrossSection(plan.profile, wasm);
       try {
-        return profile.revolve(plan.segments ?? 0, plan.degrees);
+        return profile2.revolve(plan.segments ?? 0, plan.degrees);
       } finally {
-        disposeWasmObject(profile);
+        disposeWasmObject(profile2);
       }
     }
     case "loft":
@@ -14757,9 +14757,9 @@ var ManifoldProfileBackend = class _ManifoldProfileBackend {
 function wrapManifoldProfileBackend(cs) {
   return new ManifoldProfileBackend(cs);
 }
-function requireManifoldCrossSection(profile) {
-  if (profile instanceof ManifoldProfileBackend) {
-    return profile.requireCrossSection();
+function requireManifoldCrossSection(profile2) {
+  if (profile2 instanceof ManifoldProfileBackend) {
+    return profile2.requireCrossSection();
   }
   throw new Error("requireManifoldCrossSection(): expected a ManifoldProfileBackend");
 }
@@ -15522,9 +15522,9 @@ var OCCTProfileBackend = class _OCCTProfileBackend {
 function wrapOCCTProfileBackend(face) {
   return new OCCTProfileBackend(face);
 }
-function requireOCCTFace(profile) {
-  if (profile instanceof OCCTProfileBackend) {
-    return profile.requireFace();
+function requireOCCTFace(profile2) {
+  if (profile2 instanceof OCCTProfileBackend) {
+    return profile2.requireFace();
   }
   throw new Error("requireOCCTFace(): expected an OCCTProfileBackend");
 }
@@ -17804,9 +17804,9 @@ function expandBounds3(b, amount) {
   const pad = Math.abs(amount);
   return bounds3([b.min[0] - pad, b.min[1] - pad, b.min[2] - pad], [b.max[0] + pad, b.max[1] + pad, b.max[2] + pad]);
 }
-function boundsFromProfileZ(profile, z0, z1) {
-  if (!profile) return null;
-  return bounds3([profile.min[0], profile.min[1], z0], [profile.max[0], profile.max[1], z1]);
+function boundsFromProfileZ(profile2, z0, z1) {
+  if (!profile2) return null;
+  return bounds3([profile2.min[0], profile2.min[1], z0], [profile2.max[0], profile2.max[1], z1]);
 }
 function transformBounds(b, transform) {
   if (!b) return null;
@@ -17857,14 +17857,14 @@ function transformedBySteps(b, steps) {
   return out;
 }
 function extrudeBounds(plan) {
-  const profile = boundsFromProfilePlan(plan.profile);
-  let base = boundsFromProfileZ(profile, 0, plan.height);
-  if (!base || !profile) return null;
+  const profile2 = boundsFromProfilePlan(plan.profile);
+  let base = boundsFromProfileZ(profile2, 0, plan.height);
+  if (!base || !profile2) return null;
   if (plan.scaleTop) {
     const top = boundsFromProfileZ(
       {
-        min: [profile.min[0] * plan.scaleTop[0], profile.min[1] * plan.scaleTop[1]],
-        max: [profile.max[0] * plan.scaleTop[0], profile.max[1] * plan.scaleTop[1]]
+        min: [profile2.min[0] * plan.scaleTop[0], profile2.min[1] * plan.scaleTop[1]],
+        max: [profile2.max[0] * plan.scaleTop[0], profile2.max[1] * plan.scaleTop[1]]
       },
       plan.height,
       plan.height
@@ -17873,10 +17873,10 @@ function extrudeBounds(plan) {
   }
   if (plan.twist && Math.abs(plan.twist) > 1e-9 && base) {
     const radial = Math.max(
-      Math.hypot(profile.min[0], profile.min[1]),
-      Math.hypot(profile.min[0], profile.max[1]),
-      Math.hypot(profile.max[0], profile.min[1]),
-      Math.hypot(profile.max[0], profile.max[1])
+      Math.hypot(profile2.min[0], profile2.min[1]),
+      Math.hypot(profile2.min[0], profile2.max[1]),
+      Math.hypot(profile2.max[0], profile2.min[1]),
+      Math.hypot(profile2.max[0], profile2.max[1])
     );
     base = bounds3([-radial, -radial, base.min[2]], [radial, radial, base.max[2]]);
   }
@@ -17902,13 +17902,13 @@ function pathBounds(path2) {
       );
   }
 }
-function profileRadius(profile) {
-  if (!profile) return 0;
+function profileRadius(profile2) {
+  if (!profile2) return 0;
   return Math.max(
-    Math.hypot(profile.min[0], profile.min[1]),
-    Math.hypot(profile.min[0], profile.max[1]),
-    Math.hypot(profile.max[0], profile.min[1]),
-    Math.hypot(profile.max[0], profile.max[1])
+    Math.hypot(profile2.min[0], profile2.min[1]),
+    Math.hypot(profile2.min[0], profile2.max[1]),
+    Math.hypot(profile2.max[0], profile2.min[1]),
+    Math.hypot(profile2.max[0], profile2.max[1])
   );
 }
 function analyticSurfaceBounds(plan) {
@@ -17957,14 +17957,14 @@ function boundsFromShapeBase(plan) {
     case "extrude":
       return extrudeBounds(plan);
     case "revolve": {
-      const profile = boundsFromProfilePlan(plan.profile);
-      if (!profile) return null;
-      const radius = Math.max(Math.abs(profile.min[0]), Math.abs(profile.max[0]));
-      return bounds3([-radius, -radius, profile.min[1]], [radius, radius, profile.max[1]]);
+      const profile2 = boundsFromProfilePlan(plan.profile);
+      if (!profile2) return null;
+      const radius = Math.max(Math.abs(profile2.min[0]), Math.abs(profile2.max[0]));
+      return bounds3([-radius, -radius, profile2.min[1]], [radius, radius, profile2.max[1]]);
     }
     case "loft":
       return unionBounds3(
-        plan.profiles.map((profile, i) => boundsFromProfileZ(boundsFromProfilePlan(profile), plan.heights[i] ?? 0, plan.heights[i] ?? 0))
+        plan.profiles.map((profile2, i) => boundsFromProfileZ(boundsFromProfilePlan(profile2), plan.heights[i] ?? 0, plan.heights[i] ?? 0))
       );
     case "sweep":
       return expandBounds3(pathBounds(plan.path), profileRadius(boundsFromProfilePlan(plan.profile)) + plan.boundsPadding);
@@ -19010,12 +19010,12 @@ function wrapTruckPolygonProfileBackend(polygons) {
 function wrapTruckProfileRegions(regions) {
   return new TruckPolygonProfileBackend(regions, true);
 }
-function requireTruckPolygonProfileBackend(profile) {
-  if (profile instanceof TruckPolygonProfileBackend) return profile;
+function requireTruckPolygonProfileBackend(profile2) {
+  if (profile2 instanceof TruckPolygonProfileBackend) return profile2;
   throw new Error("requireTruckPolygonProfileBackend(): expected a TruckPolygonProfileBackend");
 }
-function requireTruckProfileRegions(profile) {
-  return requireTruckPolygonProfileBackend(profile).requireRegions();
+function requireTruckProfileRegions(profile2) {
+  return requireTruckPolygonProfileBackend(profile2).requireRegions();
 }
 
 // src/forge/backends/truck/shapeBackend.ts
@@ -20330,7 +20330,7 @@ function lowerProfileBooleanToRegions(plan) {
   if (plan.profiles.length === 0) {
     throw new Error(`Truck backend cannot lower empty profile boolean "${plan.op}".`);
   }
-  const operands = plan.profiles.map((profile) => regionsToMultiPolygon2(profilePlanToRegions(profile)));
+  const operands = plan.profiles.map((profile2) => regionsToMultiPolygon2(profilePlanToRegions(profile2)));
   const result = (() => {
     switch (plan.op) {
       case "union":
@@ -21127,8 +21127,8 @@ function lowerGenericBooleanPlan(plan) {
     let rawBoolean;
     try {
       rawBoolean = wrapTruckShapeBackend(getTruckGeometryWasm().geometry_boolean(JSON.stringify(booleanHandles), plan.op));
-    } catch (error) {
-      if (plan.op !== "union") throw error;
+    } catch (error2) {
+      if (plan.op !== "union") throw error2;
       returned = wrapTruckShapeBackend(getTruckGeometryWasm().geometry_union(JSON.stringify(booleanHandles)));
       return returned;
     }
@@ -21479,9 +21479,9 @@ function lowerImportedMeshPlan(plan) {
         })
       )
     );
-  } catch (error) {
+  } catch (error2) {
     throw new Error(
-      `importMesh("${plan.filePath}"): Truck rejected the mesh; it must be closed, manifold, and non-degenerate. Original error: ${error instanceof Error ? error.message : String(error)}`
+      `importMesh("${plan.filePath}"): Truck rejected the mesh; it must be closed, manifold, and non-degenerate. Original error: ${error2 instanceof Error ? error2.message : String(error2)}`
     );
   }
 }
@@ -21696,8 +21696,8 @@ function lowerSdfPlan(plan) {
     const shape = lowerExtractedSdfMesh(mesh, cappedEvalFn, true);
     if (plan.meshing?.diagnostics) logSdfMeshingDiagnostics("SDF meshing result", plan.meshing.diagnostics);
     return shape;
-  } catch (error) {
-    surfaceNetsError = error;
+  } catch (error2) {
+    surfaceNetsError = error2;
   }
   const tetraMesh = marchingTetrahedra(cappedEvalFn, plan.bounds, plan.edgeLength);
   assertSdfMeshBudget(tetraMesh, plan);
@@ -21705,9 +21705,9 @@ function lowerSdfPlan(plan) {
     const shape = lowerExtractedSdfMesh(tetraMesh, cappedEvalFn, false);
     if (plan.meshing?.diagnostics) logSdfMeshingDiagnostics("SDF meshing result", plan.meshing.diagnostics);
     return shape;
-  } catch (error) {
+  } catch (error2) {
     throw new Error(
-      `Truck backend does not support compile plan "sdf" for this materialized field yet: Surface Nets failed with ${surfaceNetsError instanceof Error ? surfaceNetsError.message : String(surfaceNetsError)}; marching tetrahedra failed with ${error instanceof Error ? error.message : String(error)}`
+      `Truck backend does not support compile plan "sdf" for this materialized field yet: Surface Nets failed with ${surfaceNetsError instanceof Error ? surfaceNetsError.message : String(surfaceNetsError)}; marching tetrahedra failed with ${error2 instanceof Error ? error2.message : String(error2)}`
     );
   }
 }
@@ -21863,7 +21863,7 @@ function lowerDraftPlan2(plan) {
   );
 }
 function offsetLoftPlan(plan, thickness) {
-  const offsetStations = plan.profiles.map((profile) => offsetRegionsWithClipper2(profilePlanToRegions(profile), thickness, "Miter"));
+  const offsetStations = plan.profiles.map((profile2) => offsetRegionsWithClipper2(profilePlanToRegions(profile2), thickness, "Miter"));
   if (!regionsHaveMatchingTopology(offsetStations)) {
     return truckUnsupported("offsetSolid() for lofts whose station offsets change profile topology");
   }
@@ -22083,8 +22083,8 @@ function lowerLoftPlan2(plan) {
   return wrapTruckShapeBackend(
     getTruckGeometryWasm().geometry_create_lofted_regions(
       JSON.stringify(
-        plan.profiles.map((profile, idx) => ({
-          regions: profilePlanToRegions(profile),
+        plan.profiles.map((profile2, idx) => ({
+          regions: profilePlanToRegions(profile2),
           z: plan.heights[idx]
         }))
       )
@@ -22431,9 +22431,9 @@ function lowerThickenedClosedSewMesh(shapes, thickness) {
   if (!mesh) return null;
   try {
     return wrapTruckShapeBackend(getTruckGeometryWasm().geometry_create_imported_triangle_mesh(JSON.stringify(mesh)));
-  } catch (error) {
+  } catch (error2) {
     throw new Error(
-      `Truck backend could not thicken the closed sewn surface set as a manifold shell: ${error instanceof Error ? error.message : String(error)}`
+      `Truck backend could not thicken the closed sewn surface set as a manifold shell: ${error2 instanceof Error ? error2.message : String(error2)}`
     );
   }
 }
@@ -22510,9 +22510,9 @@ function lowerSurfaceSolidPlan2(plan) {
   if (!mesh) truckUnsupported("Surface.Solid() for this surface source");
   try {
     return wrapTruckShapeBackend(getTruckGeometryWasm().geometry_create_imported_triangle_mesh(JSON.stringify(mesh)));
-  } catch (error) {
+  } catch (error2) {
     throw new Error(
-      `Truck backend could not build Surface.Solid() from the closed surface set: ${error instanceof Error ? error.message : String(error)}`
+      `Truck backend could not build Surface.Solid() from the closed surface set: ${error2 instanceof Error ? error2.message : String(error2)}`
     );
   }
 }
@@ -22917,9 +22917,9 @@ function transformedSphereProfile(basePlan, steps, sliceOffset) {
   const radius = Math.abs(source.radius * scale11);
   const sectionRadius = sliceOffset == null ? radius : Math.sqrt(Math.max(0, radius * radius - (sliceOffset - center[2]) * (sliceOffset - center[2])));
   if (sectionRadius <= EXACT_PROFILE_EPS) return emptyProfilePlan();
-  const profile = circleProfilePlan(sectionRadius, source.segments);
-  if (!isNearlyZero(center[0]) || !isNearlyZero(center[1])) profile.transforms.push({ kind: "translate", x: center[0], y: center[1] });
-  return profile;
+  const profile2 = circleProfilePlan(sectionRadius, source.segments);
+  if (!isNearlyZero(center[0]) || !isNearlyZero(center[1])) profile2.transforms.push({ kind: "translate", x: center[0], y: center[1] });
+  return profile2;
 }
 function profileTransformsForShapeTransform(step) {
   switch (step.kind) {
@@ -23823,15 +23823,15 @@ function centeredRectSegmentEnvelopeProjectionProfilePlan(footprints) {
   for (let idx = 0; idx + 1 < footprints.length; idx += 1) {
     const a = footprints[idx];
     const b = footprints[idx + 1];
-    const profile = centeredRectPairProjectionProfilePlan({ outer: a.outer, holes: [] }, { outer: b.outer, holes: [] });
-    if (!profile) return null;
+    const profile2 = centeredRectPairProjectionProfilePlan({ outer: a.outer, holes: [] }, { outer: b.outer, holes: [] });
+    if (!profile2) return null;
     const segmentOuter = selectLargestNestedRectFootprint([a.outer, b.outer]) ?? {
       width: Math.max(a.outer.width, b.outer.width),
       height: Math.max(a.outer.height, b.outer.height)
     };
     const holes = centeredRectCommonHoleFootprints([a, b], segmentOuter);
     if (!holes) return null;
-    profiles2.push(differenceCenteredRectHoles(profile, holes));
+    profiles2.push(differenceCenteredRectHoles(profile2, holes));
   }
   if (profiles2.length === 1) return profiles2[0];
   return { kind: "boolean", op: "union", profiles: profiles2, transforms: [] };
@@ -24373,8 +24373,8 @@ function singleRegionWithoutHoles(regions) {
 }
 function nestedSingleRegionLoftProjectionProfilePlan(profiles2) {
   if (profiles2.length < 2) return null;
-  const regions = profiles2.map((profile) => {
-    const lowered = regionsForProfilePlan(profile);
+  const regions = profiles2.map((profile2) => {
+    const lowered = regionsForProfilePlan(profile2);
     return lowered ? singleRegionWithoutHoles(lowered) : null;
   });
   if (regions.some((region) => !region)) return null;
@@ -24403,8 +24403,8 @@ function loftProjectedProfilePlan(plan) {
 function variableSweepProjectedProfilePlan(plan) {
   const pathInfo = verticalSweepPathInfo(plan.path, plan.up);
   if (!pathInfo || !hasDistinctFiniteSectionParameters(plan.sections)) return null;
-  const profile = compatibleLoftProjectionProfilePlan(plan.sections.map((section) => section.profile));
-  return profile ? appendProfileTransforms(profile, pathInfo.transforms) : null;
+  const profile2 = compatibleLoftProjectionProfilePlan(plan.sections.map((section) => section.profile));
+  return profile2 ? appendProfileTransforms(profile2, pathInfo.transforms) : null;
 }
 function normalizeIntervals(intervals) {
   const sorted = intervals.map(([a, b]) => [Math.min(a, b), Math.max(a, b)]).filter(([a, b]) => b - a > EXACT_PROFILE_EPS).sort((a, b) => a[0] - b[0]);
@@ -24451,7 +24451,7 @@ function subtractIntervals(subject, clips) {
   return out;
 }
 function profilePlanForRadialIntervals(intervals, segments) {
-  const profiles2 = normalizeIntervals(intervals).map(([inner, outer]) => annulusProfilePlan(outer, Math.max(0, inner), segments)).filter((profile) => !isEmptyProfilePlan(profile));
+  const profiles2 = normalizeIntervals(intervals).map(([inner, outer]) => annulusProfilePlan(outer, Math.max(0, inner), segments)).filter((profile2) => !isEmptyProfilePlan(profile2));
   if (profiles2.length === 0) return emptyProfilePlan();
   if (profiles2.length === 1) return profiles2[0];
   return { kind: "boolean", op: "union", profiles: profiles2, transforms: [] };
@@ -24482,7 +24482,7 @@ function sectorProfilePlan(innerRadius, outerRadius, degrees, segments) {
 }
 function partialRevolutionProfilePlanForRadialIntervals(intervals, degrees, segments) {
   if (!Number.isFinite(degrees) || isNearlyZero(degrees)) return null;
-  const profiles2 = normalizeIntervals(intervals).map(([inner, outer]) => sectorProfilePlan(inner, outer, degrees, segments)).filter((profile) => !isEmptyProfilePlan(profile));
+  const profiles2 = normalizeIntervals(intervals).map(([inner, outer]) => sectorProfilePlan(inner, outer, degrees, segments)).filter((profile2) => !isEmptyProfilePlan(profile2));
   if (profiles2.length === 0) return emptyProfilePlan();
   if (profiles2.length === 1) return profiles2[0];
   return { kind: "boolean", op: "union", profiles: profiles2, transforms: [] };
@@ -24715,11 +24715,11 @@ function expandSimpleFullRevolutionProfileFootprint(plan, distance5) {
   }
 }
 function profilePlanForSimpleFullRevolutionFootprint(footprint, segments) {
-  const translate = (profile, center) => {
+  const translate = (profile2, center) => {
     if (!isNearlyZero(center[0]) || !isNearlyZero(center[1])) {
-      profile.transforms.push({ kind: "translate", x: center[0], y: center[1] });
+      profile2.transforms.push({ kind: "translate", x: center[0], y: center[1] });
     }
-    return profile;
+    return profile2;
   };
   switch (footprint.kind) {
     case "circle":
@@ -24737,12 +24737,12 @@ function profilePlanForSimpleFullRevolutionFootprint(footprint, segments) {
     case "roundedRect": {
       const { halfWidth, halfHeight, radius, xAxis, yAxis, center } = footprint.footprint;
       if (halfWidth <= EXACT_PROFILE_EPS || halfHeight <= EXACT_PROFILE_EPS || radius < -EXACT_PROFILE_EPS) return null;
-      const profile = roundedRectProfilePlan({
+      const profile2 = roundedRectProfilePlan({
         width: halfWidth * 2,
         height: halfHeight * 2,
         radius
       });
-      profile.transforms.push(
+      profile2.transforms.push(
         ...profileOrientationTransforms({
           m00: xAxis[0],
           m01: yAxis[0],
@@ -24750,7 +24750,7 @@ function profilePlanForSimpleFullRevolutionFootprint(footprint, segments) {
           m11: yAxis[1]
         })
       );
-      return translate(profile, center);
+      return translate(profile2, center);
     }
     default:
       return assertExhaustive(footprint);
@@ -24854,9 +24854,9 @@ function insetRadialIntervalsForFullRevolutionProfile(plan, distance5) {
       if (plan.op === "union") {
         const baseIntervalGroups = [];
         const insetIntervals = [];
-        for (const profile of profiles2) {
-          const baseIntervals = radialProjectionIntervalsForRevolveProfile(profile);
-          const profileInsetIntervals = insetRadialIntervalsForFullRevolutionProfile(profile, distance5);
+        for (const profile2 of profiles2) {
+          const baseIntervals = radialProjectionIntervalsForRevolveProfile(profile2);
+          const profileInsetIntervals = insetRadialIntervalsForFullRevolutionProfile(profile2, distance5);
           if (!baseIntervals || !profileInsetIntervals) return null;
           baseIntervalGroups.push(baseIntervals);
           insetIntervals.push(...profileInsetIntervals);
@@ -24905,9 +24905,9 @@ function insetSliceProfileForFullRevolutionProfile(plan, distance5, segments) {
       if (plan.op === "union") {
         const baseIntervalGroups = [];
         const sliceProfiles = [];
-        for (const profile of profiles2) {
-          const baseIntervals = radialProjectionIntervalsForRevolveProfile(profile);
-          const sliceProfile = insetSliceProfileForFullRevolutionProfile(profile, distance5, segments);
+        for (const profile2 of profiles2) {
+          const baseIntervals = radialProjectionIntervalsForRevolveProfile(profile2);
+          const sliceProfile = insetSliceProfileForFullRevolutionProfile(profile2, distance5, segments);
           if (!baseIntervals || !sliceProfile) return null;
           baseIntervalGroups.push(baseIntervals);
           sliceProfiles.push(sliceProfile);
@@ -25061,7 +25061,7 @@ function fullRevolutionOffsetSourceContext(plan) {
   }
 }
 function booleanProfilesWithParentTransforms(plan) {
-  return plan.transforms.length === 0 ? plan.profiles : plan.profiles.map((profile) => appendProfileTransforms(profile, plan.transforms));
+  return plan.transforms.length === 0 ? plan.profiles : plan.profiles.map((profile2) => appendProfileTransforms(profile2, plan.transforms));
 }
 function radialProjectionIntervalsForRevolveProfile(plan) {
   if (plan.kind === "circle") {
@@ -25078,8 +25078,8 @@ function radialProjectionIntervalsForRevolveProfile(plan) {
     const profiles2 = booleanProfilesWithParentTransforms(plan);
     if (plan.op === "union") {
       const intervals2 = [];
-      for (const profile of profiles2) {
-        const profileIntervals = radialProjectionIntervalsForRevolveProfile(profile);
+      for (const profile2 of profiles2) {
+        const profileIntervals = radialProjectionIntervalsForRevolveProfile(profile2);
         if (!profileIntervals) return null;
         intervals2.push(...profileIntervals);
       }
@@ -25152,8 +25152,8 @@ function radialSliceIntervalsForRevolveProfile(plan, z) {
     const profiles2 = booleanProfilesWithParentTransforms(plan);
     if (plan.op === "union") {
       const intervals2 = [];
-      for (const profile of profiles2) {
-        const profileIntervals = radialSliceIntervalsForRevolveProfile(profile, z);
+      for (const profile2 of profiles2) {
+        const profileIntervals = radialSliceIntervalsForRevolveProfile(profile2, z);
         if (!profileIntervals) return null;
         intervals2.push(...profileIntervals);
       }
@@ -25276,9 +25276,9 @@ function offsetSolidFullRevolutionProfilePlan(plan) {
   const baseProjectionIntervals = radialProjectionIntervalsForRevolveProfile(source.plan.profile);
   const projectionIntervals = localThickness > EXACT_PROFILE_EPS ? baseProjectionIntervals ? expandRadialIntervalsForOutwardOffset(baseProjectionIntervals, localThickness) : null : insetRadialIntervalsForFullRevolutionProfile(source.plan.profile, Math.abs(localThickness));
   const sliceProfile = localThickness < -EXACT_PROFILE_EPS ? insetSliceProfileForFullRevolutionProfile(source.plan.profile, Math.abs(localThickness), source.plan.segments) : null;
-  const profile = fullRevolutionOffsetProfilePlan(source.plan.profile, localThickness);
-  return profile ? {
-    profile,
+  const profile2 = fullRevolutionOffsetProfilePlan(source.plan.profile, localThickness);
+  return profile2 ? {
+    profile: profile2,
     projectionIntervals,
     sliceProfile,
     segments: source.plan.segments,
@@ -25336,25 +25336,25 @@ function exactVerticalProjectionProfilePlan(plan) {
     case "transform": {
       const base = exactVerticalProjectionProfilePlan(plan.base);
       if (!base) return null;
-      let profile = base.profile;
+      let profile2 = base.profile;
       let span = [base.zMin, base.zMax];
       for (const step of plan.steps) {
         const projectedTransforms = profileTransformsForShapeTransform(step);
         if (!projectedTransforms) return null;
         const nextSpan = transformZSpan(span, step);
         if (!nextSpan) return null;
-        profile = appendProfileTransforms(profile, projectedTransforms);
+        profile2 = appendProfileTransforms(profile2, projectedTransforms);
         span = nextSpan;
       }
-      return { profile, zMin: span[0], zMax: span[1] };
+      return { profile: profile2, zMin: span[0], zMax: span[1] };
     }
     default:
       return null;
   }
 }
 function zSpanOverlap(profiles2) {
-  const zMin = Math.max(...profiles2.map((profile) => profile.zMin));
-  const zMax = Math.min(...profiles2.map((profile) => profile.zMax));
+  const zMin = Math.max(...profiles2.map((profile2) => profile2.zMin));
+  const zMax = Math.min(...profiles2.map((profile2) => profile2.zMax));
   return zMax - zMin > EXACT_PROFILE_EPS;
 }
 function clippedZSpan(subject, clip) {
@@ -25427,7 +25427,7 @@ function regionsHaveMatchingTopology2(stations) {
 }
 function loftSlicedProfilePlan(plan, offset2) {
   if (plan.profiles.length !== plan.heights.length || plan.profiles.length < 2) return null;
-  const stations = plan.profiles.map((profile, idx) => ({ profile, height: plan.heights[idx] })).sort((a, b) => a.height - b.height);
+  const stations = plan.profiles.map((profile2, idx) => ({ profile: profile2, height: plan.heights[idx] })).sort((a, b) => a.height - b.height);
   if (stations.some((station) => !Number.isFinite(station.height))) return null;
   if (stations.some((station, idx) => idx > 0 && station.height <= stations[idx - 1].height + EXACT_PROFILE_EPS)) return null;
   if (!offsetInRange(offset2, stations[0].height, stations[stations.length - 1].height)) return emptyProfilePlan();
@@ -25454,17 +25454,17 @@ function offsetSolidCompatibleLoftSlicedProfilePlan(plan, offset2) {
   const base = compatibleLoftProfileReplayBasePlan(plan.base);
   if (!base || !Number.isFinite(plan.thickness) || isNearlyZero(plan.thickness)) return null;
   const offsetProfiles = base.profiles.map(
-    (profile) => ({
+    (profile2) => ({
       kind: "offset",
-      base: cloneProfileCompilePlan(profile),
+      base: cloneProfileCompilePlan(profile2),
       delta: plan.thickness,
       join: "Miter",
       transforms: []
     })
   );
   const offsetStations = [];
-  for (const profile of offsetProfiles) {
-    const regions = regionsForProfilePlan(profile);
+  for (const profile2 of offsetProfiles) {
+    const regions = regionsForProfilePlan(profile2);
     if (!regions) return null;
     offsetStations.push(regions);
   }
@@ -25502,9 +25502,9 @@ function offsetSolidCompatibleLoftProjectedProfilePlan(plan) {
   if (!hasDistinctFiniteHeights(base.heights)) return null;
   return compatibleLoftProjectionProfilePlan(
     base.profiles.map(
-      (profile) => ({
+      (profile2) => ({
         kind: "offset",
-        base: cloneProfileCompilePlan(profile),
+        base: cloneProfileCompilePlan(profile2),
         delta: plan.thickness,
         join: "Miter",
         transforms: []
@@ -25518,7 +25518,7 @@ function offsetSolidVerticalVariableSweepProjectedProfilePlan(plan) {
   if (base.kind !== "variableSweep" || !Number.isFinite(plan.thickness) || isNearlyZero(plan.thickness)) return null;
   const pathInfo = verticalSweepPathInfo(base.path, base.up);
   if (!pathInfo || !hasDistinctFiniteSectionParameters(base.sections)) return null;
-  const profile = compatibleLoftProjectionProfilePlan(
+  const profile2 = compatibleLoftProjectionProfilePlan(
     base.sections.map(
       (section) => ({
         kind: "offset",
@@ -25529,7 +25529,7 @@ function offsetSolidVerticalVariableSweepProjectedProfilePlan(plan) {
       })
     )
   );
-  return profile ? appendProfileTransforms(profile, pathInfo.transforms) : null;
+  return profile2 ? appendProfileTransforms(profile2, pathInfo.transforms) : null;
 }
 function offsetSolidVerticalVariableSweepSlicedProfilePlan(plan, offset2) {
   let base = plan.base;
@@ -25734,27 +25734,27 @@ function exactTruckProjectedProfilePlan(plan) {
     case "transform": {
       const transformedSphere = transformedSphereProfile(plan.base, plan.steps);
       if (transformedSphere) return transformedSphere;
-      let profile = exactTruckProjectedProfilePlan(plan.base);
-      if (!profile) return null;
+      let profile2 = exactTruckProjectedProfilePlan(plan.base);
+      if (!profile2) return null;
       for (const step of plan.steps) {
         const projectedTransforms = profileTransformsForShapeTransform(step);
         if (!projectedTransforms) return null;
-        profile = appendProfileTransforms(profile, projectedTransforms);
+        profile2 = appendProfileTransforms(profile2, projectedTransforms);
       }
-      return profile;
+      return profile2;
     }
     case "boolean": {
       if (plan.op === "union") {
         const profiles3 = [];
         for (const shape of plan.shapes) {
-          const profile = exactTruckProjectedProfilePlan(shape);
-          if (!profile) return null;
-          profiles3.push(profile);
+          const profile2 = exactTruckProjectedProfilePlan(shape);
+          if (!profile2) return null;
+          profiles3.push(profile2);
         }
         return { kind: "boolean", op: "union", profiles: profiles3, transforms: [] };
       }
       const verticalProfiles = plan.shapes.map(exactVerticalProjectionProfilePlan);
-      if (verticalProfiles.some((profile) => !profile)) return null;
+      if (verticalProfiles.some((profile2) => !profile2)) return null;
       const profiles2 = verticalProfiles;
       switch (plan.op) {
         case "difference": {
@@ -25764,7 +25764,7 @@ function exactTruckProjectedProfilePlan(plan) {
         }
         case "intersection":
           if (profiles2.length === 0 || !zSpanOverlap(profiles2)) return emptyProfilePlan();
-          return { kind: "boolean", op: "intersection", profiles: profiles2.map((profile) => profile.profile), transforms: [] };
+          return { kind: "boolean", op: "intersection", profiles: profiles2.map((profile2) => profile2.profile), transforms: [] };
         default:
           return assertExhaustive(plan.op);
       }
@@ -25859,15 +25859,15 @@ function exactTruckSlicedProfilePlan(plan, offset2) {
     case "extrude": {
       if (isNearlyZero(plan.height) || !offsetInRange(offset2, 0, plan.height)) return emptyProfilePlan();
       if (plan.twist != null && !isNearlyZero(plan.twist)) return null;
-      const profile = cloneProfileCompilePlan(plan.profile);
+      const profile2 = cloneProfileCompilePlan(plan.profile);
       if (plan.scaleTop) {
         const t = offset2 / plan.height;
         const scaleX = 1 + (plan.scaleTop[0] - 1) * t;
         const scaleY = 1 + (plan.scaleTop[1] - 1) * t;
         if (isNearlyZero(scaleX) || isNearlyZero(scaleY)) return emptyProfilePlan();
-        profile.transforms.push({ kind: "scale", x: scaleX, y: scaleY });
+        profile2.transforms.push({ kind: "scale", x: scaleX, y: scaleY });
       }
-      return profile;
+      return profile2;
     }
     case "transform": {
       const transformedSphere = transformedSphereProfile(plan.base, plan.steps, offset2);
@@ -25878,25 +25878,25 @@ function exactTruckSlicedProfilePlan(plan, offset2) {
         if (nextOffset == null) return null;
         sourceOffset = nextOffset;
       }
-      let profile = exactTruckSlicedProfilePlan(plan.base, sourceOffset);
-      if (!profile) return null;
+      let profile2 = exactTruckSlicedProfilePlan(plan.base, sourceOffset);
+      if (!profile2) return null;
       for (const step of plan.steps) {
         const transforms = profileTransformsForShapeTransform(step);
         if (!transforms) return null;
-        profile = appendProfileTransforms(profile, transforms);
+        profile2 = appendProfileTransforms(profile2, transforms);
       }
-      return profile;
+      return profile2;
     }
     case "boolean": {
       const profiles2 = [];
       for (const shape of plan.shapes) {
-        const profile = exactTruckSlicedProfilePlan(shape, offset2);
-        if (!profile) return null;
-        profiles2.push(profile);
+        const profile2 = exactTruckSlicedProfilePlan(shape, offset2);
+        if (!profile2) return null;
+        profiles2.push(profile2);
       }
       switch (plan.op) {
         case "union": {
-          const nonEmpty = profiles2.filter((profile) => !isEmptyProfilePlan(profile));
+          const nonEmpty = profiles2.filter((profile2) => !isEmptyProfilePlan(profile2));
           if (nonEmpty.length === 0) return emptyProfilePlan();
           if (nonEmpty.length === 1) return cloneProfileCompilePlan(nonEmpty[0]);
           return { kind: "boolean", op: "union", profiles: nonEmpty, transforms: [] };
@@ -25904,7 +25904,7 @@ function exactTruckSlicedProfilePlan(plan, offset2) {
         case "difference": {
           const [subject, ...clips] = profiles2;
           if (!subject || isEmptyProfilePlan(subject)) return emptyProfilePlan();
-          const nonEmptyClips = clips.filter((profile) => !isEmptyProfilePlan(profile));
+          const nonEmptyClips = clips.filter((profile2) => !isEmptyProfilePlan(profile2));
           if (nonEmptyClips.length === 0) return cloneProfileCompilePlan(subject);
           return { kind: "boolean", op: "difference", profiles: [subject, ...nonEmptyClips], transforms: [] };
         }
@@ -26527,26 +26527,26 @@ function findOriginOperation(plan) {
       return { operation: plan.kind };
   }
 }
-function summarizeProfile(profile) {
-  switch (profile.kind) {
+function summarizeProfile(profile2) {
+  switch (profile2.kind) {
     case "rect":
-      return `${profile.width}\xD7${profile.height} rect`;
+      return `${profile2.width}\xD7${profile2.height} rect`;
     case "roundedRect":
-      return `${profile.width}\xD7${profile.height} rounded rect`;
+      return `${profile2.width}\xD7${profile2.height} rounded rect`;
     case "circle":
-      return `r=${profile.radius} circle`;
+      return `r=${profile2.radius} circle`;
     case "polygon":
-      return `polygon (${profile.points.length} pts)`;
+      return `polygon (${profile2.points.length} pts)`;
     case "boolean":
-      return `${profile.op} profile`;
+      return `${profile2.op} profile`;
     case "offset":
       return "offset profile";
     case "project":
       return "projected profile";
     case "pathProfile":
-      return `path profile (${profile.edges.length} edges)`;
+      return `path profile (${profile2.edges.length} edges)`;
     default:
-      assertExhaustive(profile);
+      assertExhaustive(profile2);
   }
 }
 function collectTimelineEntries(plan, entries) {
@@ -27200,13 +27200,13 @@ function isRectanglePolygon(points) {
   const cross13 = vectors[1][0] * vectors[3][1] - vectors[1][1] * vectors[3][0];
   return Math.abs(dot01) <= 1e-6 * Math.max(1, lengths[0] * lengths[1]) && Math.abs(dot12) <= 1e-6 * Math.max(1, lengths[1] * lengths[2]) && Math.abs(dot23) <= 1e-6 * Math.max(1, lengths[2] * lengths[3]) && Math.abs(dot30) <= 1e-6 * Math.max(1, lengths[3] * lengths[0]) && Math.abs(cross02) <= 1e-6 * Math.max(1, lengths[0] * lengths[2]) && Math.abs(cross13) <= 1e-6 * Math.max(1, lengths[1] * lengths[3]);
 }
-function rectLikeProfileCorners(profile) {
-  const matrix = profileTransformMatrix(profile.transforms);
-  if (profile.kind === "rect" || profile.kind === "roundedRect") {
-    const minX = -profile.width / 2;
-    const minY = -profile.height / 2;
-    const maxX = minX + profile.width;
-    const maxY = minY + profile.height;
+function rectLikeProfileCorners(profile2) {
+  const matrix = profileTransformMatrix(profile2.transforms);
+  if (profile2.kind === "rect" || profile2.kind === "roundedRect") {
+    const minX = -profile2.width / 2;
+    const minY = -profile2.height / 2;
+    const maxX = minX + profile2.width;
+    const maxY = minY + profile2.height;
     return [
       profilePoint(matrix, minX, minY),
       profilePoint(matrix, maxX, minY),
@@ -27214,8 +27214,8 @@ function rectLikeProfileCorners(profile) {
       profilePoint(matrix, minX, maxY)
     ];
   }
-  if (!isRectanglePolygon(profile.points)) return null;
-  const transformed = profile.points.map(([x, y]) => profilePoint(matrix, x, y));
+  if (!isRectanglePolygon(profile2.points)) return null;
+  const transformed = profile2.points.map(([x, y]) => profilePoint(matrix, x, y));
   return [transformed[0], transformed[1], transformed[2], transformed[3]];
 }
 function buildBoxFaceTable(plan, owner) {
@@ -27297,8 +27297,8 @@ function buildCylinderFaceTable(plan, owner) {
   });
   return table;
 }
-function buildRectExtrudeFaceTable(profile, height, owner) {
-  const corners2 = rectLikeProfileCorners(profile);
+function buildRectExtrudeFaceTable(profile2, height, owner) {
+  const corners2 = rectLikeProfileCorners(profile2);
   if (!corners2) return emptyFaceTable();
   const [bl, br, tr, tl] = corners2;
   const center2d = midpoint2d(bl, tr);
@@ -27331,11 +27331,11 @@ function buildRectExtrudeFaceTable(profile, height, owner) {
   registerFace(table, faceFrom2DEdge("side-left", tl, bl, (zTop + zBot) / 2, createTrackedFaceQuery("side-left", owner)));
   return table;
 }
-function buildCircleExtrudeFaceTable(profile, height, owner) {
+function buildCircleExtrudeFaceTable(profile2, height, owner) {
   const table = emptyFaceTable();
-  const matrix = profileTransformMatrix(profile.transforms);
+  const matrix = profileTransformMatrix(profile2.transforms);
   const origin = Transform.from(matrix).point([0, 0, 0]);
-  const sidePoint = Transform.from(matrix).point([profile.radius, 0, 0]);
+  const sidePoint = Transform.from(matrix).point([profile2.radius, 0, 0]);
   const sideNormal = normalizeAxis([sidePoint[0] - origin[0], sidePoint[1] - origin[1], 0]);
   const xAxis = normalizeAxis(Transform.from(matrix).vector([1, 0, 0]));
   const yAxis = normalizeAxis(Transform.from(matrix).vector([0, 1, 0]));
@@ -27490,16 +27490,16 @@ function holeCreatedFaceNames(hole2, extent) {
   if (featureCutExtentReverseSide(extent)?.kind === "blind") names.push("cap");
   return names;
 }
-function cutCreatedFaceNames(profile, extent, _taper) {
+function cutCreatedFaceNames(profile2, extent, _taper) {
   const names = (() => {
-    switch (profile.kind) {
+    switch (profile2.kind) {
       case "circle":
         return ["wall"];
       case "rect":
       case "roundedRect":
         return ["wall-bottom", "wall-right", "wall-top", "wall-left"];
       case "polygon":
-        return isRectanglePolygon(profile.points) ? ["wall-bottom", "wall-right", "wall-top", "wall-left"] : [];
+        return isRectanglePolygon(profile2.points) ? ["wall-bottom", "wall-right", "wall-top", "wall-left"] : [];
       default:
         return [];
     }
@@ -27518,8 +27518,8 @@ function holeCreatedEdgeNames(hole2, extent) {
   }
   return names;
 }
-function cutCreatedEdgeNames(profile, extent, taper) {
-  if (cutCreatedFaceNames(profile, extent, taper).length === 0) return [];
+function cutCreatedEdgeNames(profile2, extent, taper) {
+  if (cutCreatedFaceNames(profile2, extent, taper).length === 0) return [];
   const names = ["entry-rim", "forward-end-rim"];
   if (featureCutExtentReverseSide(extent)) {
     names.push("reverse-end-rim");
@@ -28267,14 +28267,14 @@ function supportedShellCreatedFaceNames(basePlan, openFaces) {
 function supportedHoleCreatedFaceNames(hole2, extent) {
   return holeCreatedFaceNames(hole2, extent);
 }
-function supportedCutCreatedFaceNames(profile, extent, taper) {
-  return cutCreatedFaceNames(profile, extent, taper);
+function supportedCutCreatedFaceNames(profile2, extent, taper) {
+  return cutCreatedFaceNames(profile2, extent, taper);
 }
 function supportedHoleCreatedEdgeNames(hole2, extent) {
   return holeCreatedEdgeNames(hole2, extent);
 }
-function supportedCutCreatedEdgeNames(profile, extent, taper) {
-  return cutCreatedEdgeNames(profile, extent, taper);
+function supportedCutCreatedEdgeNames(profile2, extent, taper) {
+  return cutCreatedEdgeNames(profile2, extent, taper);
 }
 function preservedShapeFaceQueries(basePlan) {
   return listShapeFaceQueries(basePlan);
@@ -31595,7 +31595,7 @@ function buildHoleTopologyRewritePropagation(owner, base, placement, hole2, exte
   buildHoleCutEdgePropagation(propagation, owner, base, blocked, "hole");
   return propagation;
 }
-function buildCutTopologyRewritePropagation(owner, base, placement, profile, extent, taper) {
+function buildCutTopologyRewritePropagation(owner, base, placement, profile2, extent, taper) {
   const propagation = createTopologyRewritePropagation("cut", owner);
   const blocked = new Map(blockedShapeFacesForFeature(base, placement.workplane.source, extent).map((entry) => [entry.name, entry.reason]));
   for (const entry of preservedShapeFaceQueries(base)) {
@@ -31630,7 +31630,7 @@ function buildCutTopologyRewritePropagation(owner, base, placement, profile, ext
       })
     );
   }
-  const createdNames = supportedCutCreatedFaceNames(profile, extent);
+  const createdNames = supportedCutCreatedFaceNames(profile2, extent);
   for (const name of createdNames) {
     const query = createCreatedFaceQueryRef(owner, "cut", name);
     propagation.createdFaces.push({
@@ -31644,7 +31644,7 @@ function buildCutTopologyRewritePropagation(owner, base, placement, profile, ext
       })
     );
   }
-  for (const name of supportedCutCreatedEdgeNames(profile, extent, taper)) {
+  for (const name of supportedCutCreatedEdgeNames(profile2, extent, taper)) {
     const query = createCreatedEdgeQueryRef(owner, "cut", name);
     propagation.createdEdges.push({
       query,
@@ -32103,8 +32103,8 @@ function selectTruckKernelEdges(shape, query) {
     return JSON.parse(
       getTruckGeometryWasm().geometry_select_edges(getTruckShapeBackendHandle(backend), JSON.stringify(query))
     );
-  } catch (error) {
-    throw new Error(`selectEdges(): native Truck edge selection failed: ${error instanceof Error ? error.message : String(error)}`);
+  } catch (error2) {
+    throw new Error(`selectEdges(): native Truck edge selection failed: ${error2 instanceof Error ? error2.message : String(error2)}`);
   }
 }
 function selectEdges(shape, query = {}) {
@@ -33230,11 +33230,11 @@ function extractSdfExpression(source) {
   const src = source.toString().trim();
   const arrowIdx = src.indexOf("=>");
   if (arrowIdx !== -1) {
-    const body = src.slice(arrowIdx + 2).trim();
-    if (body.startsWith("{") && body.endsWith("}")) {
-      return expressionFromFunctionBody(body.slice(1, -1));
+    const body2 = src.slice(arrowIdx + 2).trim();
+    if (body2.startsWith("{") && body2.endsWith("}")) {
+      return expressionFromFunctionBody(body2.slice(1, -1));
     }
-    return stripReturnKeyword(body);
+    return stripReturnKeyword(body2);
   }
   const start = src.indexOf("{");
   const end = src.lastIndexOf("}");
@@ -33319,8 +33319,8 @@ function validateSdfFunctionConstant(value, label) {
   }
   throw new Error(`sdf.fromFunction() ${label} must be a JSON-compatible value.`);
 }
-function expressionFromFunctionBody(body) {
-  const trimmed = body.trim();
+function expressionFromFunctionBody(body2) {
+  const trimmed = body2.trim();
   const match = trimmed.match(/^return\s+([\s\S]*?);?$/);
   if (match) return stripReturnKeyword(match[1].trim());
   return `(function() {
@@ -33422,8 +33422,8 @@ var SurfacePattern = class {
   body;
   /** Named constants injected into the function. */
   constants;
-  constructor(body, constants) {
-    this.body = body;
+  constructor(body2, constants) {
+    this.body = body2;
     this.constants = constants;
   }
 };
@@ -33432,8 +33432,8 @@ function getTypedSurfacePattern(pattern) {
   return typedSurfacePatterns.get(pattern);
 }
 var Pattern2D = class extends SurfacePattern {
-  constructor(body) {
-    super(body);
+  constructor(body2) {
+    super(body2);
   }
   /** Add this pattern to one or more patterns or constant height offsets. */
   add(...patterns) {
@@ -33686,10 +33686,10 @@ Fix: use a known preset or pass material props directly.`
   if (!input || typeof input !== "object") {
     throw new Error(`${label}() expects a material preset string or material properties object.`);
   }
-  const { color, ...material } = input;
+  const { color, ...material2 } = input;
   return {
     ...typeof color === "string" ? { color } : {},
-    material: validateMaterialProps(material)
+    material: validateMaterialProps(material2)
   };
 }
 function requirePositiveFinite4(value, label) {
@@ -34250,21 +34250,21 @@ var SdfShape = class _SdfShape {
    * ```
    */
   surfaceDisplace(pattern, options) {
-    let body;
+    let body2;
     let constants;
     let typedPattern;
     if (pattern instanceof SurfacePattern) {
-      body = pattern.body;
+      body2 = pattern.body;
       constants = pattern.constants;
       typedPattern = getTypedSurfacePattern(pattern);
     } else {
-      body = extractFunctionBody(pattern);
+      body2 = extractFunctionBody(pattern);
     }
     return this.withNode({
       kind: "sdf:surfaceDisplace",
       child: this._node,
       ...typedPattern ? { pattern: typedPattern } : {},
-      patternBody: body,
+      patternBody: body2,
       constants,
       ...options?.uv ? { uvMode: options.uv } : {},
       ...options?.triplanarSharpness !== void 0 ? { triplanarSharpness: options.triplanarSharpness } : {}
@@ -36161,8 +36161,8 @@ function formatShapeBoundsForDiagnostic(shape) {
   try {
     const bounds = shape.boundingBox();
     return `bounds=${formatDiagnosticVec(bounds.min)}..${formatDiagnosticVec(bounds.max)}`;
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
+  } catch (error2) {
+    const message = error2 instanceof Error ? error2.message : String(error2);
     return `bounds=unavailable(${message})`;
   }
 }
@@ -36396,10 +36396,10 @@ function parseReferencePath(path2) {
   if (!trimmed) throw new Error("Shape.ref() requires a non-empty path.");
   const atIndex = trimmed.indexOf("@");
   if (atIndex < 0) return { body: trimmed };
-  const body = trimmed.slice(0, atIndex).trim();
+  const body2 = trimmed.slice(0, atIndex).trim();
   const selector = trimmed.slice(atIndex + 1).trim();
-  if (!body || !selector) throw new Error(`Shape.ref("${path2}") has an incomplete @ selector.`);
-  return { body, selector };
+  if (!body2 || !selector) throw new Error(`Shape.ref("${path2}") has an incomplete @ selector.`);
+  return { body: body2, selector };
 }
 function midpoint32(a, b) {
   return [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2, (a[2] + b[2]) / 2];
@@ -36477,21 +36477,21 @@ function explainReferenceMissingFace(shape, path2, name) {
     `Shape.ref("${path2}") could not resolve face "${name}". Available face refs: ${shape.faceNames().join(", ") || "none"}`
   );
 }
-function resolveReferenceBody(shape, originalPath, body) {
-  const exactFaces = resolveShapeRefFaces(shape, body);
+function resolveReferenceBody(shape, originalPath, body2) {
+  const exactFaces = resolveShapeRefFaces(shape, body2);
   if (exactFaces) {
     return {
       baseKind: "face",
-      rule: exactFaces.length === 1 ? `face(${body})` : `face-set(${body})`,
+      rule: exactFaces.length === 1 ? `face(${body2})` : `face-set(${body2})`,
       faces: exactFaces,
       edges: [],
       points: []
     };
   }
-  const slashIndex = body.indexOf("/");
-  if (slashIndex < 0) explainReferenceMissingFace(shape, originalPath, body);
-  const leftName = body.slice(0, slashIndex).trim();
-  const rightName = body.slice(slashIndex + 1).trim();
+  const slashIndex = body2.indexOf("/");
+  if (slashIndex < 0) explainReferenceMissingFace(shape, originalPath, body2);
+  const leftName = body2.slice(0, slashIndex).trim();
+  const rightName = body2.slice(slashIndex + 1).trim();
   if (!leftName || !rightName) throw new Error(`Shape.ref("${originalPath}") has an incomplete face relationship path.`);
   const leftFaces = resolveShapeRefFaces(shape, leftName) ?? explainReferenceMissingFace(shape, originalPath, leftName);
   const rightFaces = resolveShapeRefFaces(shape, rightName) ?? explainReferenceMissingFace(shape, originalPath, rightName);
@@ -36591,8 +36591,8 @@ var ShapeRef = class _ShapeRef {
   resolve() {
     try {
       return resolveShapeReference(this.shape, this.path);
-    } catch (error) {
-      if (!this.optional) throw error;
+    } catch (error2) {
+      if (!this.optional) throw error2;
       const sourcePath = resolveShapeRefAliases(this.shape, this.path.trim());
       const parsed = parseReferencePath(sourcePath);
       const missingKind = parsed.selector ? "point-set" : parsed.body.includes("/") ? "edge-set" : "face-set";
@@ -36603,7 +36603,7 @@ var ShapeRef = class _ShapeRef {
         kind: missingKind,
         status: "deleted",
         cardinality: "zero",
-        rule: error instanceof Error ? error.message : "optional reference failed to resolve",
+        rule: error2 instanceof Error ? error2.message : "optional reference failed to resolve",
         faces: [],
         edges: [],
         points: []
@@ -39149,11 +39149,11 @@ var constraintDefs = /* @__PURE__ */ new Map([
 ]);
 function buildVariables(bodies) {
   const vars = [];
-  for (const [id, body] of bodies) {
-    if (body.grounded) continue;
+  for (const [id, body2] of bodies) {
+    if (body2.grounded) continue;
     for (let c = 0; c < 6; c++) {
       const isRotation = c >= 3;
-      const arr = isRotation ? body.rotation : body.position;
+      const arr = isRotation ? body2.rotation : body2.position;
       const idx = isRotation ? c - 3 : c;
       vars.push({
         bodyId: id,
@@ -39162,15 +39162,15 @@ function buildVariables(bodies) {
         set: (v) => {
           arr[idx] = v;
         },
-        scale: isRotation ? 1 : computePositionScale(body)
+        scale: isRotation ? 1 : computePositionScale(body2)
       });
     }
   }
   return vars;
 }
-function computePositionScale(body) {
+function computePositionScale(body2) {
   let maxDist = 1;
-  for (const face of body.faces.values()) {
+  for (const face of body2.faces.values()) {
     const d = Math.hypot(face.center[0], face.center[1], face.center[2]);
     if (d > maxDist) maxDist = d;
   }
@@ -39180,41 +39180,41 @@ function createContext(bodies) {
   return {
     bodies,
     toWorld(bodyId, point2) {
-      const body = bodies.get(bodyId);
-      if (!body) throw new Error(`Unknown body: ${bodyId}`);
-      return transformPoint2(body.rotation, body.position, point2);
+      const body2 = bodies.get(bodyId);
+      if (!body2) throw new Error(`Unknown body: ${bodyId}`);
+      return transformPoint2(body2.rotation, body2.position, point2);
     },
     toWorldDir(bodyId, dir) {
-      const body = bodies.get(bodyId);
-      if (!body) throw new Error(`Unknown body: ${bodyId}`);
-      return normalize36(transformDir(body.rotation, dir));
+      const body2 = bodies.get(bodyId);
+      if (!body2) throw new Error(`Unknown body: ${bodyId}`);
+      return normalize36(transformDir(body2.rotation, dir));
     },
     worldFace(bodyId, faceName) {
-      const body = bodies.get(bodyId);
-      if (!body) throw new Error(`Unknown body: ${bodyId}`);
-      const face = body.faces.get(faceName);
+      const body2 = bodies.get(bodyId);
+      if (!body2) throw new Error(`Unknown body: ${bodyId}`);
+      const face = body2.faces.get(faceName);
       if (!face) throw new Error(`Unknown face "${faceName}" on body "${bodyId}"`);
       return {
-        normal: normalize36(transformDir(body.rotation, face.normal)),
-        center: transformPoint2(body.rotation, body.position, face.center)
+        normal: normalize36(transformDir(body2.rotation, face.normal)),
+        center: transformPoint2(body2.rotation, body2.position, face.center)
       };
     },
     worldAxis(bodyId, axisName) {
-      const body = bodies.get(bodyId);
-      if (!body) throw new Error(`Unknown body: ${bodyId}`);
-      const axis = body.axes.get(axisName);
+      const body2 = bodies.get(bodyId);
+      if (!body2) throw new Error(`Unknown body: ${bodyId}`);
+      const axis = body2.axes.get(axisName);
       if (!axis) throw new Error(`Unknown axis "${axisName}" on body "${bodyId}"`);
       return {
-        origin: transformPoint2(body.rotation, body.position, axis.origin),
-        direction: normalize36(transformDir(body.rotation, axis.direction))
+        origin: transformPoint2(body2.rotation, body2.position, axis.origin),
+        direction: normalize36(transformDir(body2.rotation, axis.direction))
       };
     },
     worldPoint(bodyId, pointName) {
-      const body = bodies.get(bodyId);
-      if (!body) throw new Error(`Unknown body: ${bodyId}`);
-      const pt = body.points.get(pointName);
+      const body2 = bodies.get(bodyId);
+      if (!body2) throw new Error(`Unknown body: ${bodyId}`);
+      const pt = body2.points.get(pointName);
       if (!pt) throw new Error(`Unknown point "${pointName}" on body "${bodyId}"`);
-      return transformPoint2(body.rotation, body.position, pt.position);
+      return transformPoint2(body2.rotation, body2.position, pt.position);
     }
   };
 }
@@ -39346,8 +39346,8 @@ function solve3D(bodies, constraints, options = {}) {
     if (def) totalEquations += def.equations;
   }
   let freeBodies = 0;
-  for (const body of bodies.values()) {
-    if (!body.grounded) freeBodies++;
+  for (const body2 of bodies.values()) {
+    if (!body2.grounded) freeBodies++;
   }
   const totalDof = 6 * freeBodies;
   const netDof = totalDof - totalEquations;
@@ -39365,8 +39365,8 @@ function solve3D(bodies, constraints, options = {}) {
     };
   }
   let refLength = 1;
-  for (const body of bodies.values()) {
-    for (const face of body.faces.values()) {
+  for (const body2 of bodies.values()) {
+    for (const face of body2.faces.values()) {
       const d = Math.hypot(face.center[0], face.center[1], face.center[2]);
       if (d > refLength) refLength = d;
     }
@@ -39431,10 +39431,10 @@ function classifyStatus(dof, maxError, tolerance) {
 }
 function extractTransforms(bodies) {
   const result = /* @__PURE__ */ new Map();
-  for (const [id, body] of bodies) {
+  for (const [id, body2] of bodies) {
     result.set(id, {
-      position: [...body.position],
-      rotation: [...body.rotation]
+      position: [...body2.position],
+      rotation: [...body2.rotation]
     });
   }
   return result;
@@ -40096,6 +40096,201 @@ function jointsView(options = {}) {
   _collected2 = collectJointsView(options, _collected2);
 }
 
+// src/forge/sim.ts
+function requireNonEmptyString(value, label) {
+  if (typeof value !== "string" || value.trim().length === 0) {
+    throw new Error(`${label} must be a non-empty string`);
+  }
+  return value.trim();
+}
+function requireFiniteNumber2(value, label) {
+  if (value !== void 0 && !Number.isFinite(value)) {
+    throw new Error(`${label} must be finite`);
+  }
+}
+function requirePositiveNumber(value, label) {
+  requireFiniteNumber2(value, label);
+  if (value !== void 0 && value <= 0) {
+    throw new Error(`${label} must be > 0`);
+  }
+}
+function requireUnitRange(value, label) {
+  requireFiniteNumber2(value, label);
+  if (value !== void 0 && (value < 0 || value > 1)) {
+    throw new Error(`${label} must be between 0 and 1`);
+  }
+}
+function cloneMaterial(material2) {
+  return material2 ? { ...material2 } : void 0;
+}
+function cloneSimCollider(collider2) {
+  return collider2 ? { ...collider2 } : void 0;
+}
+function cloneSimContact(contact2) {
+  return { ...contact2 };
+}
+function cloneSimContacts(contacts) {
+  if (!contacts) return void 0;
+  return Object.fromEntries(Object.entries(contacts).map(([name, contact2]) => [name, cloneSimContact(contact2)]));
+}
+function cloneSimBody(body2) {
+  if (!body2) return void 0;
+  return {
+    ...body2,
+    material: cloneMaterial(body2.material),
+    collider: cloneSimCollider(body2.collider),
+    contacts: cloneSimContacts(body2.contacts)
+  };
+}
+function cloneSimDrive(drive) {
+  return drive ? { ...drive } : void 0;
+}
+function cloneSimController(controller) {
+  return {
+    ...controller,
+    leftJoints: [...controller.leftJoints],
+    rightJoints: [...controller.rightJoints]
+  };
+}
+function cloneSimProfile(profile2) {
+  return { ...profile2 };
+}
+function cloneSimAssemblySimulation(simulation) {
+  if (!simulation) return void 0;
+  return {
+    ...simulation,
+    profile: cloneSimProfile(simulation.profile),
+    controllers: simulation.controllers?.map((controller) => cloneSimController(controller))
+  };
+}
+function simProfileRequiresRootPart(profile2) {
+  return profile2?.name === "Robot-Body-Runnable" || profile2?.name === "Robot-Body-Isaac";
+}
+function simProfileAllowsControllers(profile2) {
+  return simProfileRequiresRootPart(profile2);
+}
+function material(name, options = {}) {
+  const materialName = requireNonEmptyString(name, "Sim.material(...) name");
+  requirePositiveNumber(options.densityKgM3, `Sim.material("${materialName}") densityKgM3`);
+  requireUnitRange(options.staticFriction, `Sim.material("${materialName}") staticFriction`);
+  requireUnitRange(options.dynamicFriction, `Sim.material("${materialName}") dynamicFriction`);
+  requireUnitRange(options.restitution, `Sim.material("${materialName}") restitution`);
+  return { kind: "material", name: materialName, ...options };
+}
+function body(options) {
+  if (!options || typeof options !== "object") {
+    throw new Error("Sim.body(...) expects an options object");
+  }
+  requirePositiveNumber(options.massKg, "Sim.body(...) massKg");
+  requirePositiveNumber(options.densityKgM3, "Sim.body(...) densityKgM3");
+  if (options.massKg === void 0 && options.densityKgM3 === void 0 && options.material?.densityKgM3 === void 0) {
+    throw new Error("Sim.body(...) requires massKg, densityKgM3, or material densityKgM3");
+  }
+  return {
+    kind: "body",
+    massKg: options.massKg,
+    densityKgM3: options.densityKgM3,
+    material: cloneMaterial(options.material),
+    collider: cloneSimCollider(options.collider),
+    contacts: cloneSimContacts(options.contacts)
+  };
+}
+function collider(mode, reason) {
+  const trimmedReason = reason?.trim();
+  if (mode === "none" && !trimmedReason) {
+    throw new Error("Sim.collider.none(reason) requires a non-empty reason");
+  }
+  return trimmedReason ? { kind: "collider", mode, reason: trimmedReason } : { kind: "collider", mode };
+}
+function contact(kind, connectorName) {
+  return { kind, connectorName: requireNonEmptyString(connectorName, `Sim.contact.${kind}(...) connectorName`) };
+}
+function passiveDrive(options = {}) {
+  requireFiniteNumber2(options.damping, "Sim.drive.passive(...) damping");
+  requireFiniteNumber2(options.friction, "Sim.drive.passive(...) friction");
+  return { kind: "passive", ...options };
+}
+function velocityDrive(options) {
+  if (!options || typeof options !== "object") {
+    throw new Error("Sim.drive.velocity(...) expects an options object");
+  }
+  requirePositiveNumber(options.maxTorqueNm, "Sim.drive.velocity(...) maxTorqueNm");
+  requirePositiveNumber(options.maxSpeedRpm, "Sim.drive.velocity(...) maxSpeedRpm");
+  requireFiniteNumber2(options.damping, "Sim.drive.velocity(...) damping");
+  requireFiniteNumber2(options.friction, "Sim.drive.velocity(...) friction");
+  return { kind: "velocity", ...options };
+}
+function diffDrive(options) {
+  if (!options || typeof options !== "object") {
+    throw new Error("Sim.controller.diffDrive(...) expects an options object");
+  }
+  if (!Array.isArray(options.leftJoints) || options.leftJoints.length === 0) {
+    throw new Error("Sim.controller.diffDrive(...) requires at least one left joint");
+  }
+  if (!Array.isArray(options.rightJoints) || options.rightJoints.length === 0) {
+    throw new Error("Sim.controller.diffDrive(...) requires at least one right joint");
+  }
+  const leftJoints = options.leftJoints.map(
+    (joint2, index) => requireNonEmptyString(joint2, `Sim.controller.diffDrive(...) leftJoints[${index}]`)
+  );
+  const rightJoints = options.rightJoints.map(
+    (joint2, index) => requireNonEmptyString(joint2, `Sim.controller.diffDrive(...) rightJoints[${index}]`)
+  );
+  requirePositiveNumber(options.wheelSeparationMm, "Sim.controller.diffDrive(...) wheelSeparationMm");
+  requirePositiveNumber(options.wheelRadiusMm, "Sim.controller.diffDrive(...) wheelRadiusMm");
+  requireFiniteNumber2(options.maxLinearVelocity, "Sim.controller.diffDrive(...) maxLinearVelocity");
+  requireFiniteNumber2(options.maxAngularVelocity, "Sim.controller.diffDrive(...) maxAngularVelocity");
+  requireFiniteNumber2(options.linearAcceleration, "Sim.controller.diffDrive(...) linearAcceleration");
+  requireFiniteNumber2(options.angularAcceleration, "Sim.controller.diffDrive(...) angularAcceleration");
+  return { ...options, kind: "diffDrive", leftJoints, rightJoints };
+}
+var profile = (name) => ({ kind: "profile", name });
+var Sim = {
+  /** Create a named physical material with density and contact coefficients for simulation export and checks. */
+  material,
+  /** Describe one assembly part as a physical body with mass/density, material, collider intent, and optional contact surfaces. */
+  body,
+  /** Collision-geometry intent constructors for physical parts. */
+  collider: {
+    /** Use a generated collision mesh for the part. This is the default fast rigid-body collider for irregular parts. */
+    convexHull: () => collider("convex"),
+    /** Use the part bounding box as the collision geometry. This is fastest and works well for chassis and simple blocks. */
+    boundingBox: () => collider("box"),
+    /** Use the visual mesh as collision geometry. This is exact but usually slower in physics engines. */
+    visualMesh: () => collider("visual"),
+    /** Disable collision for a part with an explicit reason, such as a sensor-only or decorative object. */
+    none: (reason) => collider("none", reason)
+  },
+  /** Joint-drive intent constructors for passive or powered assembly joints. */
+  drive: {
+    /** Mark a joint as passive while preserving damping and friction metadata for simulation export. */
+    passive: passiveDrive,
+    /** Mark a revolute joint as velocity-driven with torque and speed limits. Speed is authored in rpm and exported as deg/s or rad/s as needed. */
+    velocity: velocityDrive
+  },
+  /** Contact-surface metadata over existing part connectors. */
+  contact: {
+    /** Mark a connector as the wheel tread contact surface for offline checks and downstream simulation metadata. */
+    wheelSurface: (connectorName) => contact("wheelSurface", connectorName),
+    /** Mark a connector as a gripper pad/contact surface for offline checks and downstream grasp-readiness metadata. */
+    gripperSurface: (connectorName) => contact("gripperSurface", connectorName)
+  },
+  /** Named validation/export profile constructors. */
+  profile: {
+    /** SimReady-style profile for a robot body that should be runnable in a physics simulator. */
+    robotBodyRunnable: () => profile("Robot-Body-Runnable"),
+    /** SimReady-style profile for robot bodies targeting Isaac Sim readiness. */
+    robotBodyIsaac: () => profile("Robot-Body-Isaac"),
+    /** SimReady-style profile for robotics assets with PhysX-ready rigid bodies and colliders. */
+    roboticsAssetPhysx: () => profile("Prop-Robotics-Physx")
+  },
+  /** Standard controller metadata constructors for simulator package generation. */
+  controller: {
+    /** Describe a differential-drive controller from left/right wheel joints and wheel dimensions. */
+    diffDrive
+  }
+};
+
 // src/forge/assembly/frames.ts
 function requireFiniteVec33(input, label) {
   if (!Array.isArray(input) || input.length !== 3) throw new Error(`${label} must be a [x, y, z] tuple`);
@@ -40839,6 +41034,7 @@ var Assembly = class _Assembly {
   viewAnimations = [];
   _defaultViewAnimation;
   _refs = createPlacementReferences();
+  _simulation;
   _portsByPart = /* @__PURE__ */ new Map();
   _usedPortRefs = /* @__PURE__ */ new Set();
   _connectCounter = 0;
@@ -40848,6 +41044,7 @@ var Assembly = class _Assembly {
   _fork() {
     const next = new _Assembly(this.name);
     next._refs = clonePlacementReferences(this._refs);
+    next._simulation = cloneSimAssemblySimulation(this._simulation);
     next._connectCounter = this._connectCounter;
     next._frameEdgeCounter = this._frameEdgeCounter;
     next._linkEdgeCounter = this._linkEdgeCounter;
@@ -40859,6 +41056,7 @@ var Assembly = class _Assembly {
         part: record.part,
         base: record.base,
         metadata: record.metadata ? { ...record.metadata } : void 0,
+        sim: cloneSimBody(record.sim),
         mates: record.mates.map((mate) => ({ ...mate })),
         bindToFrame: record.bindToFrame
       });
@@ -40879,6 +41077,7 @@ var Assembly = class _Assembly {
         velocity: joint2.velocity,
         damping: joint2.damping,
         friction: joint2.friction,
+        sim: joint2.sim ? { drive: cloneSimDrive(joint2.sim.drive) } : void 0,
         connectorRefs: joint2.connectorRefs ? { ...joint2.connectorRefs } : void 0
       });
     }
@@ -40999,6 +41198,42 @@ var Assembly = class _Assembly {
   getReferences() {
     return clonePlacementReferences(this._refs);
   }
+  /**
+   * Attach the root simulation contract for this assembly.
+   *
+   * Use this after adding physical parts and joints. Robot-body profiles require
+   * `rootPart`; asset profiles can describe one-part or multi-part physical assets.
+   * URDF/SDF exporters and `forgecad check simready` read this contract directly,
+   * so model files no longer need a separate `robotExport(...)` side effect.
+   *
+   * @category Assembly
+   */
+  withSimulation(options) {
+    if (!options || typeof options !== "object") {
+      throw new Error("assembly.withSimulation(...) expects an options object");
+    }
+    if (!options.profile || options.profile.kind !== "profile") {
+      throw new Error("assembly.withSimulation(...) requires a Sim.profile.*() value");
+    }
+    const rootPart = typeof options.rootPart === "string" ? options.rootPart.trim() : "";
+    if (simProfileRequiresRootPart(options.profile) && !rootPart) {
+      throw new Error("assembly.withSimulation(...) rootPart is required for robot-body profiles");
+    }
+    if (rootPart && !this.parts.has(rootPart)) {
+      throw new Error(`assembly.withSimulation(...) rootPart "${rootPart}" does not exist`);
+    }
+    if (options.controllers && options.controllers.length > 0 && !simProfileAllowsControllers(options.profile)) {
+      throw new Error("assembly.withSimulation(...) controllers are only supported for robot-body profiles");
+    }
+    const simulation = {
+      kind: "simulation",
+      profile: cloneSimProfile(options.profile),
+      rootPart: rootPart || void 0,
+      controllers: options.controllers?.map((controller) => ({ ...controller }))
+    };
+    this._simulation = cloneSimAssemblySimulation(simulation);
+    return this;
+  }
   withConnectors(partNameOrConnectors, maybeConnectors) {
     if (typeof partNameOrConnectors === "string") {
       const partName = partNameOrConnectors;
@@ -41588,6 +41823,7 @@ var Assembly = class _Assembly {
       part,
       base: options.transform ? Transform.from(options.transform) : Transform.identity(),
       metadata: options.metadata ? { ...options.metadata } : void 0,
+      sim: cloneSimBody(options.sim),
       mates: mates.map((mate, index) => {
         const connector = typeof mate.connector === "string" ? mate.connector.trim() : "";
         const toLink = typeof mate.toLink === "string" ? mate.toLink.trim() : "";
@@ -41676,6 +41912,7 @@ var Assembly = class _Assembly {
       velocity: options.velocity,
       damping: options.damping,
       friction: options.friction,
+      sim: options.drive ? { drive: cloneSimDrive(options.drive) } : void 0,
       connectorRefs: options.connectorRefs ? { ...options.connectorRefs } : void 0
     });
     if (options.follows) {
@@ -41766,8 +42003,15 @@ var Assembly = class _Assembly {
    * mating makes the axes anti-parallel, like a plug meeting a socket (same
    * convention as `matchTo()`).
    *
-   * **Mirrored revolute axes:** revolute values follow the right-hand rule, so a
-   * mirrored hinge axis (`[1, 0, 0]` vs `[-1, 0, 0]`) rotates oppositely for the
+   * **Revolute sign:** a positive joint value follows the right-hand rule about
+   * the **child** connector's placed axis. Because face-to-face mating makes
+   * the axes anti-parallel, that is the *left*-hand rule about the parent
+   * connector's outward axis — if `+30` swings the opposite way you expected,
+   * you predicted from the parent's axis. `forgecad debug assembly` prints each
+   * joint's resolved world axis.
+   *
+   * **Mirrored revolute axes:** because of the right-hand rule, a mirrored
+   * hinge axis (`[1, 0, 0]` vs `[-1, 0, 0]`) rotates oppositely for the
    * same `+theta`: negate the mirrored side's value and mirror limits as
    * `[min, max] -> [-max, -min]`. Prismatic joints have no handedness flip. Use
    * an explicit per-side sign mapping (or side-neutral link controls) for
@@ -41825,6 +42069,7 @@ var Assembly = class _Assembly {
       velocity: options.velocity,
       damping: options.damping,
       friction: options.friction,
+      drive: options.drive,
       follows: options.follows,
       connectorRefs: {
         parent: parentConnectorRef,
@@ -43291,11 +43536,13 @@ var Assembly = class _Assembly {
   describe() {
     return {
       name: this.name,
+      sim: cloneSimAssemblySimulation(this._simulation),
       parts: [...this.parts.values()].map((part) => ({
         name: part.name,
         part: part.part,
         base: part.base,
         metadata: part.metadata ? { ...part.metadata } : void 0,
+        sim: cloneSimBody(part.sim),
         mates: part.mates.map((mate) => ({ ...mate })),
         bindToFrame: part.bindToFrame
       })),
@@ -43314,6 +43561,7 @@ var Assembly = class _Assembly {
         velocity: joint2.velocity,
         damping: joint2.damping,
         friction: joint2.friction,
+        sim: joint2.sim ? { drive: cloneSimDrive(joint2.sim.drive) } : void 0,
         connectorRefs: joint2.connectorRefs ? { ...joint2.connectorRefs } : void 0
       })),
       jointCouplings: [...this.jointCouplings.values()].map((coupling) => ({
@@ -43644,6 +43892,7 @@ var ImportedAssembly = class _ImportedAssembly {
       parent.addPart(`${pfx}${p2.name}`, p2.part, {
         transform: p2.base,
         metadata: p2.metadata,
+        sim: p2.sim,
         mate: p2.mates.map((mate) => ({ connector: mate.connector, toLink: `${pfx}${mate.toLink}` }))
       });
     }
@@ -43658,7 +43907,8 @@ var ImportedAssembly = class _ImportedAssembly {
         effort: j.effort,
         velocity: j.velocity,
         damping: j.damping,
-        friction: j.friction
+        friction: j.friction,
+        drive: j.sim?.drive
       });
     }
     const allPorts = this._assembly.getAllPorts();
@@ -44173,9 +44423,9 @@ var GCodeBuilder = class {
   _maxZ = -Infinity;
   // Filament cross-section area (precomputed)
   filamentArea;
-  constructor(profile) {
-    const preset = profile?.printer ?? DEFAULT_PROFILE.printer;
-    this.profile = { ...DEFAULT_PROFILE, ...bambuOverridesFor(preset), ...profile };
+  constructor(profile2) {
+    const preset = profile2?.printer ?? DEFAULT_PROFILE.printer;
+    this.profile = { ...DEFAULT_PROFILE, ...bambuOverridesFor(preset), ...profile2 };
     this.currentSpeed = this.profile.printSpeed;
     this.filamentArea = Math.PI * (this.profile.filament / 2) ** 2;
   }
@@ -44836,8 +45086,8 @@ function bambuConfigBlock(p2, hotend, bed) {
   lines.push("; CONFIG_BLOCK_END");
   return lines;
 }
-function gcode(profile) {
-  return new GCodeBuilder(profile);
+function gcode(profile2) {
+  return new GCodeBuilder(profile2);
 }
 
 // src/forge/sketch/workplane.ts
@@ -44926,8 +45176,8 @@ function resolvePlanarFaceWorkplane(face) {
     source
   };
 }
-function isGenericMissingFaceError(error, face) {
-  const message = error instanceof Error ? error.message : String(error);
+function isGenericMissingFaceError(error2, face) {
+  const message = error2 instanceof Error ? error2.message : String(error2);
   return message === `Face "${face}" is not available. Supported faces: none` || message.startsWith(`Face "${face}" is not available. Supported faces: `);
 }
 function resolveSketchWorkplane(parentOrFace, face) {
@@ -44951,9 +45201,9 @@ function resolveSketchWorkplane(parentOrFace, face) {
         workplane.source = { kind: "canonical-face", face, owner: resolveTargetQueryOwner(parentOrFace) };
       }
       return workplane;
-    } catch (error) {
-      if (!isCanonicalFace(face) || !isGenericMissingFaceError(error, face)) {
-        throw error;
+    } catch (error2) {
+      if (!isCanonicalFace(face) || !isGenericMissingFaceError(error2, face)) {
+        throw error2;
       }
     }
   }
@@ -45308,22 +45558,22 @@ function validateHoleExtentCompatibility(hole2, extent) {
     throw new Error("Shape.hole() thread.depth cannot exceed the primary forward hole depth.");
   }
 }
-function resolveCutTaperCompilePlan(profile, opts, extent) {
+function resolveCutTaperCompilePlan(profile2, opts, extent) {
   if (opts.taperScale == null) return void 0;
   if (extent.kind === "two-sided") {
     throw new Error("Shape.cutout() does not yet combine taperScale with reverse two-sided extents.");
   }
-  if (!profile) {
+  if (!profile2) {
     throw new Error("Shape.cutout() requires a compile-covered sketch profile before taperScale can be validated.");
   }
-  if (profile.kind !== "circle" && profile.kind !== "rect" && profile.kind !== "roundedRect") {
+  if (profile2.kind !== "circle" && profile2.kind !== "rect" && profile2.kind !== "roundedRect") {
     throw new Error("Shape.cutout() taperScale currently supports circle, rect, and roundedRect sketch profiles only.");
   }
   const scale11 = Array.isArray(opts.taperScale) ? opts.taperScale : [opts.taperScale, opts.taperScale];
   if (scale11.length !== 2 || !isFinitePositive3(scale11[0]) || !isFinitePositive3(scale11[1])) {
     throw new Error("Shape.cutout() taperScale must be a positive finite number or [x, y] pair.");
   }
-  if (profile.kind === "circle" && Math.abs(scale11[0] - scale11[1]) > 1e-6) {
+  if (profile2.kind === "circle" && Math.abs(scale11[0] - scale11[1]) > 1e-6) {
     throw new Error("Shape.cutout() circular tapered cuts currently require a uniform taperScale.");
   }
   return {
@@ -45418,8 +45668,8 @@ function shapeCutout(target, sketch, opts = {}) {
   if (!basePlan) {
     throw new Error("Shape.cutout() currently requires a compile-covered target shape.");
   }
-  const profile = getSketchCompileProfilePlan(sketch);
-  if (!profile) {
+  const profile2 = getSketchCompileProfilePlan(sketch);
+  if (!profile2) {
     throw new Error("Shape.cutout() requires a compile-covered sketch profile.");
   }
   const placementModel = getSketchPlacementModel(sketch);
@@ -45441,7 +45691,7 @@ function shapeCutout(target, sketch, opts = {}) {
     },
     "Shape.cutout()"
   );
-  const taper = resolveCutTaperCompilePlan(profile, opts, extent);
+  const taper = resolveCutTaperCompilePlan(profile2, opts, extent);
   const plan = createOwnedTopologyRewritePlan2(
     buildCutShapeCompilePlan(
       basePlan,
@@ -45449,12 +45699,12 @@ function shapeCutout(target, sketch, opts = {}) {
         matrix: placementMatrix2,
         placement: cloneSketchPlacementModel(placementModel)
       },
-      profile,
+      profile2,
       extent,
       taper
     ),
     "cut",
-    (owner) => buildCutTopologyRewritePropagation(owner, basePlan, placementModel, profile, extent, taper)
+    (owner) => buildCutTopologyRewritePropagation(owner, basePlan, placementModel, profile2, extent, taper)
   );
   return buildFeatureResult(target, plan);
 }
@@ -47570,20 +47820,20 @@ function tSlotProfile(options = {}) {
     sketchRotateAround(sideSlot, 180, [0, 0]),
     sketchRotateAround(sideSlot, 270, [0, 0])
   );
-  let profile = union2d(shell, webX, webY);
-  if (boss2) profile = union2d(profile, boss2);
-  profile = difference2d(profile, slots);
+  let profile2 = union2d(shell, webX, webY);
+  if (boss2) profile2 = union2d(profile2, boss2);
+  profile2 = difference2d(profile2, slots);
   if (centerBoreDia > 0) {
-    profile = difference2d(profile, circle2d(centerBoreDia / 2, segments));
+    profile2 = difference2d(profile2, circle2d(centerBoreDia / 2, segments));
   }
-  return profile;
+  return profile2;
 }
 function tSlotExtrusion(length7, options = {}) {
   if (!Number.isFinite(length7) || length7 <= 0) {
     throw new Error('tSlotExtrusion: "length" must be > 0');
   }
-  const profile = tSlotProfile(options);
-  return sketchExtrude(profile, length7);
+  const profile2 = tSlotProfile(options);
+  return sketchExtrude(profile2, length7);
 }
 
 // src/forge/lib/profiles-2020.ts
@@ -47648,26 +47898,26 @@ function profile2020BSlot6Profile(options = {}) {
     sketchRotateAround(sideSlot, 180, [0, 0]),
     sketchRotateAround(sideSlot, 270, [0, 0])
   );
-  let profile = difference2d(outer, slots);
+  let profile2 = difference2d(outer, slots);
   const centerBoss = opts.centerBossDia > 0 ? circle2d(opts.centerBossDia / 2, opts.segments) : null;
   const webLen = size * 1.15;
   const xWeb = rect(webLen, opts.diagonalWebWidth);
   const webs = union2d(sketchRotateAround(xWeb, 45, [0, 0]), sketchRotateAround(xWeb, -45, [0, 0]));
-  profile = union2d(profile, webs);
+  profile2 = union2d(profile2, webs);
   if (centerBoss) {
-    profile = union2d(profile, centerBoss);
+    profile2 = union2d(profile2, centerBoss);
   }
   if (opts.centerBoreDia > 0) {
-    profile = difference2d(profile, circle2d(opts.centerBoreDia / 2, opts.segments));
+    profile2 = difference2d(profile2, circle2d(opts.centerBoreDia / 2, opts.segments));
   }
-  return profile;
+  return profile2;
 }
 function profile2020BSlot6(length7, options = {}) {
   if (!Number.isFinite(length7) || length7 <= 0) {
     throw new Error('profile2020BSlot6: "length" must be > 0');
   }
-  const profile = profile2020BSlot6Profile(options);
-  return sketchExtrude(profile, length7);
+  const profile2 = profile2020BSlot6Profile(options);
+  return sketchExtrude(profile2, length7);
 }
 
 // src/forge/assembly/explodeCore.ts
@@ -48930,7 +49180,7 @@ function loftInternal(profiles2, heights, options = {}) {
   if (profiles2.length !== heights.length) {
     throw new Error("loft requires heights.length === profiles.length");
   }
-  const pairs = profiles2.map((profile, i) => ({ profile, z: heights[i] })).sort((a, b) => a.z - b.z);
+  const pairs = profiles2.map((profile2, i) => ({ profile: profile2, z: heights[i] })).sort((a, b) => a.z - b.z);
   for (let i = 1; i < pairs.length; i++) {
     if (Math.abs(pairs[i].z - pairs[i - 1].z) < 1e-8) {
       throw new Error("loft requires strictly increasing, unique heights");
@@ -48981,8 +49231,8 @@ function loftInternal(profiles2, heights, options = {}) {
     sources: isKernelLoft ? ["loft"] : ["loft", "level-set"]
   });
 }
-function extractSweepEdgeLabels(profile) {
-  const labels = getSketchEdgeLabels(profile);
+function extractSweepEdgeLabels(profile2) {
+  const labels = getSketchEdgeLabels(profile2);
   if (labels.size === 0) return void 0;
   const result = {};
   for (const [name, label] of labels) {
@@ -49088,14 +49338,14 @@ function buildPathPlan(path2) {
   }
   throw new Error("sweep: unsupported path type");
 }
-function sweep(profile, path2, options = {}) {
+function sweep(profile2, path2, options = {}) {
   const requestedPathSamples = Math.max(4, options.samples ?? 48);
   const effectivePathSamples = scaleSweepPathSamples(requestedPathSamples);
   const { plan: pathPlan, sampleForBounds } = buildPathPlan(path2);
   const pathPts = sampleForBounds(effectivePathSamples);
   if (pathPts.length < 2) throw new Error("sweep requires a path with at least two points");
   const up = options.up ?? [0, 0, 1];
-  const pb = profile.bounds();
+  const pb = profile2.bounds();
   const pr = Math.max(Math.abs(pb.min[0]), Math.abs(pb.max[0]), Math.abs(pb.min[1]), Math.abs(pb.max[1]));
   const roughStats = measurePathPoints(pathPts);
   const span = Math.max(
@@ -49109,8 +49359,8 @@ function sweep(profile, path2, options = {}) {
   const edgeLength2 = scaleLevelSetEdgeLength(requestedEdgeLength);
   const requestedPad = options.boundsPadding ?? Math.max(pr + edgeLength2 * 2, span * 0.04, 2);
   const pad = scaleLevelSetBoundsPadding(requestedPad);
-  const edgeLabels = extractSweepEdgeLabels(profile);
-  const plan = buildSweepShapeCompilePlan(getSketchCompileProfilePlan(profile), pathPlan, {
+  const edgeLabels = extractSweepEdgeLabels(profile2);
+  const plan = buildSweepShapeCompilePlan(getSketchCompileProfilePlan(profile2), pathPlan, {
     edgeLength: edgeLength2,
     boundsPadding: pad,
     up,
@@ -49123,7 +49373,7 @@ function sweep(profile, path2, options = {}) {
   const ownedPlan = createOwnedShapeCompilePlan(plan, "sweep");
   const activeBackend = getActiveBackend();
   const isKernelSweep = activeBackend === "occt" || activeBackend === "truck";
-  return buildShapeFromCompilePlan(ownedPlan, profile.colorHex, {
+  return buildShapeFromCompilePlan(ownedPlan, profile2.colorHex, {
     fidelity: isKernelSweep ? "kernel-native" : "sampled",
     sources: isKernelSweep ? ["sweep"] : ["sweep", "level-set"]
   });
@@ -49277,8 +49527,8 @@ var HelixCurve = class extends Curve3D {
     return Math.hypot(this.radius * Math.PI * 2 * this.turns, this.height);
   }
 };
-function profileHalfExtent(profile) {
-  const bounds = profile.bounds();
+function profileHalfExtent(profile2) {
+  const bounds = profile2.bounds();
   return Math.max(Math.abs(bounds.min[0]), Math.abs(bounds.max[0]), Math.abs(bounds.min[1]), Math.abs(bounds.max[1]));
 }
 function buildHelixCoil(profileOrOptions, maybeOptions) {
@@ -49286,12 +49536,12 @@ function buildHelixCoil(profileOrOptions, maybeOptions) {
   const options = hasCustomProfile ? maybeOptions : profileOrOptions;
   if (!options) throw new Error("Helix.coil: options are required.");
   const spec2 = normalizeHelixOptions(options, "Helix.coil");
-  const profile = hasCustomProfile ? profileOrOptions : circle2d(
+  const profile2 = hasCustomProfile ? profileOrOptions : circle2d(
     requirePositive(options.wireRadius, "Helix.coil.wireRadius"),
     requireIntegerAtLeast2(options.profileSegments ?? 24, "Helix.coil.profileSegments", 8)
   );
-  if (profile.isEmpty()) throw new Error("Helix.coil: profile must not be empty.");
-  const halfExtent = profileHalfExtent(profile);
+  if (profile2.isEmpty()) throw new Error("Helix.coil: profile must not be empty.");
+  const halfExtent = profileHalfExtent(profile2);
   if (spec2.radius <= halfExtent) {
     throw new Error(`Helix.coil: radius must be greater than the profile half-extent (${halfExtent}).`);
   }
@@ -49305,7 +49555,7 @@ function buildHelixCoil(profileOrOptions, maybeOptions) {
     ...options,
     samplesPerTurn: divisionsPerTurn
   });
-  return sweep(profile, guide, { samples, up: [0, 0, -spec2.direction] });
+  return sweep(profile2, guide, { samples, up: [0, 0, -spec2.direction] });
 }
 var Helix = {
   path(options) {
@@ -50027,8 +50277,8 @@ function pipeRoute(points, radius, options) {
   }
   const route = Curve.Route.fromPolyline(simplifyStraightPipeRoutePoints(points), { cornerRadius: bendR });
   const outer = circle2d(radius, segs);
-  const profile = wall != null && wall > 0 ? difference2d(outer, circle2d(radius - wall, segs)) : outer;
-  return sweep(profile, route, { samples: segs });
+  const profile2 = wall != null && wall > 0 ? difference2d(outer, circle2d(radius - wall, segs)) : outer;
+  return sweep(profile2, route, { samples: segs });
 }
 function simplifyStraightPipeRoutePoints(points) {
   const simplified = [points[0]];
@@ -50076,9 +50326,9 @@ function elbow(pipeRadius, bendRadius, angle, options) {
   const center = scale7(inward, bendRadius);
   const endRadial = rotateDirection(scale7(inward, -bendRadius), turnAxis, angleRad);
   const end = addVec(center, endRadial);
-  const profile = profileForPipeRadius(pipeRadius, wall, Math.floor(segments));
+  const profile2 = profileForPipeRadius(pipeRadius, wall, Math.floor(segments));
   const pathSamples = Math.max(6, Math.ceil(segments * (angleRad * 180 / Math.PI) / 360) + 1);
-  return sweep(profile, Curve.Arc({ start: [0, 0, 0], end, tangent: from }), { samples: pathSamples, up: turnAxis });
+  return sweep(profile2, Curve.Arc({ start: [0, 0, 0], end, tangent: from }), { samples: pathSamples, up: turnAxis });
 }
 
 // src/forge/lib/belts.ts
@@ -50427,14 +50677,14 @@ function readGearMeta(shape) {
   const meta = shape[GEAR_META_KEY];
   return meta ?? null;
 }
-function remapErrorPrefix(error, sourcePrefix, targetPrefix) {
-  if (error instanceof Error) {
-    if (error.message.startsWith(`${sourcePrefix}:`)) {
-      throw new Error(`${targetPrefix}:${error.message.slice(sourcePrefix.length + 1)}`);
+function remapErrorPrefix(error2, sourcePrefix, targetPrefix) {
+  if (error2 instanceof Error) {
+    if (error2.message.startsWith(`${sourcePrefix}:`)) {
+      throw new Error(`${targetPrefix}:${error2.message.slice(sourcePrefix.length + 1)}`);
     }
-    throw error;
+    throw error2;
   }
-  throw error;
+  throw error2;
 }
 
 // src/forge/lib/gears/spur.ts
@@ -50561,11 +50811,11 @@ function buildSpurGearProfile(meta, segmentsPerTooth) {
 function spurGear(options) {
   const normalized = normalizeSpurGearOptions(options);
   const meta = buildSpurGearMeta(normalized);
-  let profile = buildSpurGearProfile(meta, normalized.segmentsPerTooth);
+  let profile2 = buildSpurGearProfile(meta, normalized.segmentsPerTooth);
   if (normalized.boreDiameter > 0) {
-    profile = difference2d(profile, circle2d(normalized.boreDiameter * 0.5, Math.max(48, normalized.teeth * 2)));
+    profile2 = difference2d(profile2, circle2d(normalized.boreDiameter * 0.5, Math.max(48, normalized.teeth * 2)));
   }
-  const shape = sketchExtrude(profile, normalized.faceWidth);
+  const shape = sketchExtrude(profile2, normalized.faceWidth);
   const shapeWithConnectors = shape.withConnectors({
     bore: connectorFactory(
       "gear-bore",
@@ -50614,8 +50864,8 @@ function gearBodyDisk(options) {
   const bore = requireOptionalBore("gearBodyDisk", options.boreDiameter, options.outerRadius * 2);
   const segments = resolveSegments(options.segments);
   const outer = circle2d(options.outerRadius, segments);
-  const profile = bore > 0 ? difference2d(outer, circle2d(bore * 0.5, segments)) : outer;
-  return sketchExtrude(profile, options.faceWidth);
+  const profile2 = bore > 0 ? difference2d(outer, circle2d(bore * 0.5, segments)) : outer;
+  return sketchExtrude(profile2, options.faceWidth);
 }
 function gearBodyDiskWithHub(options) {
   requirePositive2("gearBodyDiskWithHub", "hubDiameter", options.hubDiameter);
@@ -50656,15 +50906,15 @@ function gearBodySpoked(options) {
   for (let i = 0; i < options.spokeCount; i++) {
     spokes.push(sketchRotateAround(spoke, 360 / options.spokeCount * i, [0, 0]));
   }
-  const profile = bore > 0 ? difference2d(union2d(rim, hub, ...spokes), circle2d(bore * 0.5, segments)) : union2d(rim, hub, ...spokes);
-  return sketchExtrude(profile, options.faceWidth);
+  const profile2 = bore > 0 ? difference2d(union2d(rim, hub, ...spokes), circle2d(bore * 0.5, segments)) : union2d(rim, hub, ...spokes);
+  return sketchExtrude(profile2, options.faceWidth);
 }
-function gearBodyFromProfile(profile, options) {
-  if (!(profile instanceof Sketch)) throw new Error('gearBodyFromProfile: "profile" must be a Sketch');
+function gearBodyFromProfile(profile2, options) {
+  if (!(profile2 instanceof Sketch)) throw new Error('gearBodyFromProfile: "profile" must be a Sketch');
   requirePositive2("gearBodyFromProfile", "faceWidth", options.faceWidth);
   const bore = options.boreDiameter ?? 0;
   if (!Number.isFinite(bore) || bore < 0) throw new Error('gearBodyFromProfile: "boreDiameter" must be >= 0');
-  return cutBore(sketchExtrude(profile, options.faceWidth), bore);
+  return cutBore(sketchExtrude(profile2, options.faceWidth), bore);
 }
 
 // src/forge/lib/gears/drive-wheel-geometry.ts
@@ -50702,16 +50952,16 @@ function buildSpurTeethRegion(options, name, faceWidth) {
   let normalized;
   try {
     normalized = normalizeSpurGearOptions({ ...options, teeth: teethOnFullCircle, faceWidth, boreDiameter: 0 });
-  } catch (error) {
-    remapErrorPrefix(error, "spurGear", scope);
+  } catch (error2) {
+    remapErrorPrefix(error2, "spurGear", scope);
   }
   const gearMeta = buildSpurGearMeta(normalized);
   const pitchStepDeg = 360 / teethOnFullCircle;
   const fromAngleDeg = firstTooth * pitchStepDeg - pitchStepDeg * 0.5;
   const toAngleDeg = (firstTooth + toothCount - 1) * pitchStepDeg + pitchStepDeg * 0.5;
-  const profile = buildSpurToothRegionProfile(gearMeta, firstTooth, toothCount, normalized.segmentsPerTooth);
+  const profile2 = buildSpurToothRegionProfile(gearMeta, firstTooth, toothCount, normalized.segmentsPerTooth);
   return {
-    shape: sketchExtrude(profile, faceWidth),
+    shape: sketchExtrude(profile2, faceWidth),
     gearMeta,
     meta: {
       name,
@@ -50858,8 +51108,8 @@ var DriveWheelBuilder = class {
     if (firstGearRegion && this.boreDiameter * 0.5 >= firstGearRegion.rootRadius - EPSILON4) {
       throw new Error("driveWheel: bore is too large for the first spur-tooth region");
     }
-    const body = this.body?.clone() ?? gearBodyDisk({ outerRadius: firstGearRegion?.rootRadius ?? this.defaultBodyRadius(), faceWidth });
-    let combined = body;
+    const body2 = this.body?.clone() ?? gearBodyDisk({ outerRadius: firstGearRegion?.rootRadius ?? this.defaultBodyRadius(), faceWidth });
+    let combined = body2;
     for (const region of this.regions) combined = combined.add(region.shape);
     combined = cutBore2(combined, this.boreDiameter);
     const withConnectors = combined.withConnectors({
@@ -50873,7 +51123,7 @@ var DriveWheelBuilder = class {
       kind: "driveWheel",
       faceWidth,
       boreDiameter: this.boreDiameter,
-      regions: this.regionMetadata(body, faceWidth)
+      regions: this.regionMetadata(body2, faceWidth)
     });
   }
   measurements(faceWidth) {
@@ -50890,9 +51140,9 @@ var DriveWheelBuilder = class {
       } : {}
     };
   }
-  regionMetadata(body, faceWidth) {
+  regionMetadata(body2, faceWidth) {
     return [
-      { name: "body", kind: "body", outerRadius: bodyOuterRadius(body), faceWidth },
+      { name: "body", kind: "body", outerRadius: bodyOuterRadius(body2), faceWidth },
       ...this.regions.map((region) => ({ ...region.meta }))
     ];
   }
@@ -50990,8 +51240,8 @@ function normalizeFaceGearOptions(options) {
   let normalizedSpur;
   try {
     normalizedSpur = normalizeSpurGearOptions(options);
-  } catch (error) {
-    remapErrorPrefix(error, "spurGear", "faceGear");
+  } catch (error2) {
+    remapErrorPrefix(error2, "spurGear", "faceGear");
   }
   const side = options.side ?? "top";
   if (side !== "top" && side !== "bottom") {
@@ -51036,8 +51286,8 @@ function faceGear(options) {
   let spurMeta;
   try {
     spurMeta = buildSpurGearMeta(normalized);
-  } catch (error) {
-    remapErrorPrefix(error, "spurGear", "faceGear");
+  } catch (error2) {
+    remapErrorPrefix(error2, "spurGear", "faceGear");
   }
   const zBands = resolveFaceGearZBands(normalized);
   const meta = {
@@ -51051,8 +51301,8 @@ function faceGear(options) {
   };
   const segments = Math.max(48, normalized.teeth * normalized.segmentsPerTooth);
   const rootDisk = cylinder2(normalized.faceWidth, meta.rootRadius, void 0, segments);
-  const profile = buildSpurGearProfile(spurMeta, normalized.segmentsPerTooth);
-  const toothBandRaw = difference2d(profile, circle2d(meta.rootRadius, Math.max(48, normalized.teeth * 2)));
+  const profile2 = buildSpurGearProfile(spurMeta, normalized.segmentsPerTooth);
+  const toothBandRaw = difference2d(profile2, circle2d(meta.rootRadius, Math.max(48, normalized.teeth * 2)));
   const simplifiedCross = toothBandRaw.cross.simplify(1e-6);
   const toothBandProfile = setSketchCompileProfilePlan(
     new Sketch(simplifiedCross, toothBandRaw.colorHex),
@@ -51095,8 +51345,8 @@ function faceGear(options) {
 function sideGear(options) {
   try {
     return faceGear(options);
-  } catch (error) {
-    remapErrorPrefix(error, "faceGear", "sideGear");
+  } catch (error2) {
+    remapErrorPrefix(error2, "faceGear", "sideGear");
   }
 }
 
@@ -51207,8 +51457,8 @@ function ringGear(options) {
   for (let i = 0; i < normalized.teeth; i++) {
     spaces.push(sketchRotateAround(toothSpace, 360 / normalized.teeth * i, [0, 0]));
   }
-  const profile = difference2d(ringBlank, union2d(...spaces));
-  const shape = sketchExtrude(profile, normalized.faceWidth);
+  const profile2 = difference2d(ringBlank, union2d(...spaces));
+  const shape = sketchExtrude(profile2, normalized.faceWidth);
   const shapeWithConnectors = shape.withConnectors({
     bore: connectorFactory(
       "ring-bore",
@@ -51281,8 +51531,8 @@ function rackGear(options) {
   const span = (options.teeth - 1) * pitch + halfRoot * 2;
   const length7 = span + module * 2;
   const base = sketchTranslate(rect(length7, baseHeight), 0, -dedendum - baseHeight * 0.5);
-  const profile = union2d(base, ...teethSketches);
-  const shape = sketchExtrude(profile, options.faceWidth);
+  const profile2 = union2d(base, ...teethSketches);
+  const shape = sketchExtrude(profile2, options.faceWidth);
   const meta = {
     kind: "rack",
     module,
@@ -51390,11 +51640,11 @@ function normalizeBevelGearOptions(options) {
 function bevelGear(options) {
   const normalized = normalizeBevelGearOptions(options);
   const meta = buildSpurGearMeta(normalized);
-  let profile = buildSpurGearProfile(meta, normalized.segmentsPerTooth);
+  let profile2 = buildSpurGearProfile(meta, normalized.segmentsPerTooth);
   if (normalized.boreDiameter > 0) {
-    profile = difference2d(profile, circle2d(normalized.boreDiameter * 0.5, Math.max(48, normalized.teeth * 2)));
+    profile2 = difference2d(profile2, circle2d(normalized.boreDiameter * 0.5, Math.max(48, normalized.teeth * 2)));
   }
-  const shape = sketchExtrude(profile, normalized.faceWidth, {
+  const shape = sketchExtrude(profile2, normalized.faceWidth, {
     scaleTop: normalized.topScale
   });
   const apexZ = normalized.module * normalized.teeth * 0.5 / Math.tan(normalized.pitchAngleRad);
@@ -51886,8 +52136,8 @@ function sideGearPair(options) {
       place: options.place,
       phaseDeg: options.phaseDeg
     });
-  } catch (error) {
-    remapErrorPrefix(error, "faceGearPair", "sideGearPair");
+  } catch (error2) {
+    remapErrorPrefix(error2, "faceGearPair", "sideGearPair");
   }
   const diagnostics = pair.diagnostics.map((d) => ({
     ...d,
@@ -52235,7 +52485,7 @@ var partLibrary = {
   gearBodyFromProfile: softDeprecated(
     "lib.gearBodyFromProfile",
     "lib.gearBodies.fromProfile(profile, options)",
-    (profile, options) => gearBodyFromProfile(profile, options)
+    (profile2, options) => gearBodyFromProfile(profile2, options)
   )
 };
 
@@ -65834,23 +66084,23 @@ function lowerShapeCompilePlanToCadQueryResultAtPath(plan, path2) {
       }
       return compilerSuccess({ kind: "torus", majorRadius: plan.majorRadius, minorRadius: plan.minorRadius });
     case "extrude": {
-      const profile = lowerProfileCompilePlanToCadQueryResultAtPath(plan.profile, `${path2}.profile`);
-      if (!profile.ok) return compilerFailure(...profile.diagnostics);
+      const profile2 = lowerProfileCompilePlanToCadQueryResultAtPath(plan.profile, `${path2}.profile`);
+      if (!profile2.ok) return compilerFailure(...profile2.diagnostics);
       return compilerSuccess(
         {
           kind: "extrude",
-          profile: profile.value,
+          profile: profile2.value,
           height: plan.height,
           scaleTop: plan.scaleTop ? [plan.scaleTop[0], plan.scaleTop[1]] : void 0
         },
-        profile.diagnostics
+        profile2.diagnostics
       );
     }
     case "sheetMetal": {
       try {
         return lowerShapeCompilePlanToCadQueryResultAtPath(lowerSheetMetalBasePlan(plan.model, plan.output), path2);
-      } catch (error) {
-        return compilerFailure(unsupportedSheetMetalDiagnostic(path2, error instanceof Error ? error.message : String(error)));
+      } catch (error2) {
+        return compilerFailure(unsupportedSheetMetalDiagnostic(path2, error2 instanceof Error ? error2.message : String(error2)));
       }
     }
     case "shell": {
@@ -65872,15 +66122,15 @@ function lowerShapeCompilePlanToCadQueryResultAtPath(plan, path2) {
       if (plan.segments != null && plan.segments > 0) {
         return compilerFailure(segmentedShapeDiagnostic("revolve", path2));
       }
-      const profile = lowerProfileCompilePlanToCadQueryResultAtPath(plan.profile, `${path2}.profile`);
-      if (!profile.ok) return compilerFailure(...profile.diagnostics);
+      const profile2 = lowerProfileCompilePlanToCadQueryResultAtPath(plan.profile, `${path2}.profile`);
+      if (!profile2.ok) return compilerFailure(...profile2.diagnostics);
       return compilerSuccess(
         {
           kind: "revolve",
-          profile: profile.value,
+          profile: profile2.value,
           degrees: plan.degrees
         },
-        profile.diagnostics
+        profile2.diagnostics
       );
     }
     case "loft": {
@@ -65910,18 +66160,18 @@ function lowerShapeCompilePlanToCadQueryResultAtPath(plan, path2) {
       );
     }
     case "sweep": {
-      const profile = lowerProfileCompilePlanToCadQueryResultAtPath(plan.profile, `${path2}.profile`);
-      if (!profile.ok) return compilerFailure(...profile.diagnostics);
+      const profile2 = lowerProfileCompilePlanToCadQueryResultAtPath(plan.profile, `${path2}.profile`);
+      if (!profile2.ok) return compilerFailure(...profile2.diagnostics);
       return compilerSuccess(
         {
           kind: "sweep",
-          profile: profile.value,
+          profile: profile2.value,
           path: lowerSweepPathToCadQuery(plan.path),
           edgeLength: plan.edgeLength,
           boundsPadding: plan.boundsPadding,
           up: [plan.up[0], plan.up[1], plan.up[2]]
         },
-        profile.diagnostics
+        profile2.diagnostics
       );
     }
     case "variableSweep": {
@@ -66856,8 +67106,8 @@ var ProductSkinBuilder = class {
     return { side, u, v };
   }
   /** Apply a product material preset to the lowered skin. */
-  material(material) {
-    this.materialValue = material;
+  material(material2) {
+    this.materialValue = material2;
     return this;
   }
   /** Apply a simple color override to the lowered skin. */
@@ -66926,8 +67176,8 @@ var ProductPanelBuilder = class {
     return this;
   }
   /** Use a custom 2D panel profile. */
-  profile(profile) {
-    this.profileValue = profile;
+  profile(profile2) {
+    this.profileValue = profile2;
     return this;
   }
   /** Set panel extrusion thickness. */
@@ -66936,8 +67186,8 @@ var ProductPanelBuilder = class {
     return this;
   }
   /** Apply a product material preset to the panel. */
-  material(material) {
-    this.materialValue = material;
+  material(material2) {
+    this.materialValue = material2;
     return this;
   }
   /** Apply a simple color override to the panel. */
@@ -66991,8 +67241,8 @@ var ProductSpoutBuilder = class {
     return this;
   }
   /** Apply a product material preset to the spout. */
-  material(material) {
-    this.materialValue = material;
+  material(material2) {
+    this.materialValue = material2;
     return this;
   }
   /** Apply a simple color override to the spout. */
@@ -67062,18 +67312,18 @@ var ProductHandleBuilder = class {
     return this;
   }
   /** Set the grip cross-section profile. */
-  grip(profile) {
-    this.gripProfile = profile;
+  grip(profile2) {
+    this.gripProfile = profile2;
     return this;
   }
   /** Apply a product material preset to the grip. */
-  material(material) {
-    this.materialValue = material;
+  material(material2) {
+    this.materialValue = material2;
     return this;
   }
   /** Apply a product material preset to handle landing pads. */
-  padMaterial(material) {
-    this.padMaterialValue = material;
+  padMaterial(material2) {
+    this.padMaterialValue = material2;
     return this;
   }
   /** Set the sampled loft target edge length for the grip. */
@@ -67248,8 +67498,8 @@ var ProductRibbonBuilder = class {
     return this;
   }
   /** Apply a product material preset. */
-  material(material) {
-    this.materialValue = material;
+  material(material2) {
+    this.materialValue = material2;
     return this;
   }
   /** Apply a simple color override. */
@@ -67563,8 +67813,8 @@ var Product = {
     return detail.transform(frame.matrix);
   },
   /** Small blended landing volume for manual structural bridges and connection proofs. */
-  landing(name, radius = 10, material) {
-    return applyMaterial(sphere2(radius, 48).scale([1.25, 0.75, 0.38]).as(name), material);
+  landing(name, radius = 10, material2) {
+    return applyMaterial(sphere2(radius, 48).scale([1.25, 0.75, 0.38]).as(name), material2);
   }
 };
 
@@ -68260,19 +68510,19 @@ function ease(t, easing) {
 function validateWidth(width, label) {
   return requirePositive6(width, label);
 }
-function widthAt(profile, t) {
-  if (typeof profile === "number") return profile;
-  if (typeof profile === "function") return validateWidth(profile(t), "SurfaceBand width function result");
-  if ("from" in profile)
-    return validateWidth(profile.from + (profile.to - profile.from) * ease(t, profile.easing), "SurfaceBand eased width");
-  const stations = [...profile.stations].sort((a, b) => a.t - b.t);
+function widthAt(profile2, t) {
+  if (typeof profile2 === "number") return profile2;
+  if (typeof profile2 === "function") return validateWidth(profile2(t), "SurfaceBand width function result");
+  if ("from" in profile2)
+    return validateWidth(profile2.from + (profile2.to - profile2.from) * ease(t, profile2.easing), "SurfaceBand eased width");
+  const stations = [...profile2.stations].sort((a, b) => a.t - b.t);
   if (stations.length === 0) throw new Error("SurfaceBand width profile requires at least one station");
   if (t <= stations[0].t) return stations[0].width;
   for (let index = 0; index < stations.length - 1; index += 1) {
     const a = stations[index];
     const b = stations[index + 1];
     if (t > b.t) continue;
-    const localT = ease((t - a.t) / Math.max(1e-8, b.t - a.t), profile.easing);
+    const localT = ease((t - a.t) / Math.max(1e-8, b.t - a.t), profile2.easing);
     return a.width + (b.width - a.width) * localT;
   }
   return stations[stations.length - 1].width;
@@ -70287,8 +70537,8 @@ function debugCarrierFootprintPoint(path2, frame, across) {
   return add9(frame.point, scale10(frame.tangentAcross, across));
 }
 var SurfaceJoinBuilder = class {
-  constructor(body, join2) {
-    this.body = body;
+  constructor(body2, join2) {
+    this.body = body2;
     this.join = join2;
   }
   /** Select named anchors on the source and target members before lowering this join. */
@@ -70308,8 +70558,8 @@ var SurfaceJoinBuilder = class {
   }
 };
 var SurfaceMemberBuilder = class {
-  constructor(body, record) {
-    this.body = body;
+  constructor(body2, record) {
+    this.body = body2;
     this.record = record;
   }
   plate() {
@@ -72885,54 +73135,123 @@ function assertFinite(value, label) {
     throw new Error(`${label} must be finite`);
   }
 }
+function metadataNumber(value) {
+  return typeof value === "number" ? value : void 0;
+}
+function metadataCollision(value) {
+  return value === "none" || value === "visual" || value === "box" || value === "convex" ? value : void 0;
+}
+function colliderCollision(collider2) {
+  if (!collider2) return void 0;
+  if (collider2.mode === "box") return "box";
+  if (collider2.mode === "visual") return "visual";
+  return collider2.mode;
+}
+function velocityDriveEffort(drive) {
+  return drive?.kind === "velocity" ? drive.maxTorqueNm : void 0;
+}
+function velocityDriveVelocityDegS(drive) {
+  return drive?.kind === "velocity" ? drive.maxSpeedRpm * 6 : void 0;
+}
+function driveDamping(drive) {
+  return drive?.damping;
+}
+function driveFriction(drive) {
+  return drive?.friction;
+}
 function jointByName(assembly2) {
   return new Map(assembly2.joints.map((joint2) => [joint2.name, joint2]));
 }
+function diffDriveFromControllers(controllers) {
+  if (!controllers) return void 0;
+  const diffDrives = controllers.filter((controller) => controller.kind === "diffDrive");
+  if (diffDrives.length > 1) {
+    throw new Error("assembly.withSimulation(...) currently supports one Sim.controller.diffDrive(...) controller");
+  }
+  const diffDrive2 = diffDrives[0];
+  return diffDrive2 ? {
+    leftJoints: [...diffDrive2.leftJoints],
+    rightJoints: [...diffDrive2.rightJoints],
+    wheelSeparationMm: diffDrive2.wheelSeparationMm,
+    wheelRadiusMm: diffDrive2.wheelRadiusMm,
+    topic: diffDrive2.topic,
+    odomTopic: diffDrive2.odomTopic,
+    tfTopic: diffDrive2.tfTopic,
+    frameId: diffDrive2.frameId,
+    odomFrameId: diffDrive2.odomFrameId,
+    maxLinearVelocity: diffDrive2.maxLinearVelocity,
+    maxAngularVelocity: diffDrive2.maxAngularVelocity,
+    linearAcceleration: diffDrive2.linearAcceleration,
+    angularAcceleration: diffDrive2.angularAcceleration
+  } : void 0;
+}
 function resetRobotExport() {
   _collectedRobotExport = null;
 }
 function getCollectedRobotExport() {
   return _collectedRobotExport;
 }
-function robotExport(options) {
-  if (!options || typeof options !== "object") {
-    throw new Error("robotExport(...) expects an options object");
-  }
-  if (!options.assembly || typeof options.assembly.describe !== "function") {
-    throw new Error("robotExport(...) requires an assembly");
-  }
-  const assembly2 = options.assembly.describe();
+function collectSimulationModel(assemblyInput, options = {}) {
+  const assembly2 = typeof assemblyInput.describe === "function" ? assemblyInput.describe() : assemblyInput;
   const partNames = new Set(assembly2.parts.map((part) => part.name));
   const joints = jointByName(assembly2);
   const links = cloneLinkOptions(options.links);
+  for (const part of assembly2.parts) {
+    const fromSim = part.sim;
+    const fromMaterialDensity = fromSim?.material?.densityKgM3;
+    const current = links[part.name] ?? {};
+    const next = {
+      massKg: current.massKg ?? fromSim?.massKg ?? metadataNumber(part.metadata?.massKg),
+      densityKgM3: current.densityKgM3 ?? fromSim?.densityKgM3 ?? fromMaterialDensity ?? metadataNumber(part.metadata?.densityKgM3),
+      collision: current.collision ?? colliderCollision(fromSim?.collider) ?? metadataCollision(part.metadata?.collision)
+    };
+    if (next.massKg !== void 0 || next.densityKgM3 !== void 0 || next.collision !== void 0) {
+      links[part.name] = next;
+    }
+  }
   for (const [partName, link] of Object.entries(links)) {
-    if (!partNames.has(partName)) throw new Error(`robotExport(...) unknown link "${partName}"`);
-    assertFinite(link.massKg, `robotExport link "${partName}" massKg`);
-    assertFinite(link.densityKgM3, `robotExport link "${partName}" densityKgM3`);
+    if (!partNames.has(partName)) throw new Error(`simulation model references unknown link "${partName}"`);
+    assertFinite(link.massKg, `simulation model link "${partName}" massKg`);
+    assertFinite(link.densityKgM3, `simulation model link "${partName}" densityKgM3`);
   }
   const jointOpts = cloneJointOptions(options.joints);
+  for (const joint2 of assembly2.joints) {
+    const drive = joint2.sim?.drive;
+    const current = jointOpts[joint2.name] ?? {};
+    const next = {
+      effort: current.effort ?? velocityDriveEffort(drive) ?? joint2.effort,
+      velocity: current.velocity ?? velocityDriveVelocityDegS(drive) ?? joint2.velocity,
+      damping: current.damping ?? driveDamping(drive) ?? joint2.damping,
+      friction: current.friction ?? driveFriction(drive) ?? joint2.friction
+    };
+    if (next.effort !== void 0 || next.velocity !== void 0 || next.damping !== void 0 || next.friction !== void 0) {
+      jointOpts[joint2.name] = next;
+    }
+  }
   for (const [jointName, joint2] of Object.entries(jointOpts)) {
-    if (!joints.has(jointName)) throw new Error(`robotExport(...) unknown joint "${jointName}"`);
-    assertFinite(joint2.effort, `robotExport joint "${jointName}" effort`);
-    assertFinite(joint2.velocity, `robotExport joint "${jointName}" velocity`);
-    assertFinite(joint2.damping, `robotExport joint "${jointName}" damping`);
-    assertFinite(joint2.friction, `robotExport joint "${jointName}" friction`);
-  }
-  const diffDrive = cloneDiffDrive(options.plugins?.diffDrive);
-  if (diffDrive) {
-    if (diffDrive.leftJoints.length === 0 || diffDrive.rightJoints.length === 0) {
-      throw new Error("robotExport(...) diffDrive requires at least one left joint and one right joint");
-    }
-    assertFinite(diffDrive.wheelSeparationMm, "robotExport(...) diffDrive wheelSeparationMm");
-    assertFinite(diffDrive.wheelRadiusMm, "robotExport(...) diffDrive wheelRadiusMm");
-    if (diffDrive.wheelSeparationMm <= 0 || diffDrive.wheelRadiusMm <= 0) {
-      throw new Error("robotExport(...) diffDrive wheel separation and radius must be > 0");
-    }
-    [...diffDrive.leftJoints, ...diffDrive.rightJoints].forEach((jointName) => {
+    if (!joints.has(jointName)) throw new Error(`simulation model references unknown joint "${jointName}"`);
+    assertFinite(joint2.effort, `simulation model joint "${jointName}" effort`);
+    assertFinite(joint2.velocity, `simulation model joint "${jointName}" velocity`);
+    assertFinite(joint2.damping, `simulation model joint "${jointName}" damping`);
+    assertFinite(joint2.friction, `simulation model joint "${jointName}" friction`);
+  }
+  const simulation = cloneSimAssemblySimulation(assembly2.sim) ?? null;
+  const simulationDiffDrive = diffDriveFromControllers(simulation?.controllers);
+  const diffDrive2 = cloneDiffDrive(options.plugins?.diffDrive) ?? simulationDiffDrive;
+  if (diffDrive2) {
+    if (diffDrive2.leftJoints.length === 0 || diffDrive2.rightJoints.length === 0) {
+      throw new Error("simulation model diffDrive requires at least one left joint and one right joint");
+    }
+    assertFinite(diffDrive2.wheelSeparationMm, "simulation model diffDrive wheelSeparationMm");
+    assertFinite(diffDrive2.wheelRadiusMm, "simulation model diffDrive wheelRadiusMm");
+    if (diffDrive2.wheelSeparationMm <= 0 || diffDrive2.wheelRadiusMm <= 0) {
+      throw new Error("simulation model diffDrive wheel separation and radius must be > 0");
+    }
+    [...diffDrive2.leftJoints, ...diffDrive2.rightJoints].forEach((jointName) => {
       const joint2 = joints.get(jointName);
-      if (!joint2) throw new Error(`robotExport(...) diffDrive references unknown joint "${jointName}"`);
+      if (!joint2) throw new Error(`simulation model diffDrive references unknown joint "${jointName}"`);
       if (joint2.type !== "revolute") {
-        throw new Error(`robotExport(...) diffDrive joint "${jointName}" must be revolute`);
+        throw new Error(`simulation model diffDrive joint "${jointName}" must be revolute`);
       }
     });
   }
@@ -72940,19 +73259,21 @@ function robotExport(options) {
   if (jointStatePublisher?.joints) {
     jointStatePublisher.joints.forEach((jointName) => {
       if (!joints.has(jointName)) {
-        throw new Error(`robotExport(...) jointStatePublisher references unknown joint "${jointName}"`);
+        throw new Error(`simulation model jointStatePublisher references unknown joint "${jointName}"`);
       }
     });
   }
   const world = cloneWorld(options.world);
   if (world?.spawnPose) {
-    world.spawnPose.forEach((value, index) => assertFinite(value, `robotExport(...) world spawnPose[${index}]`));
+    world.spawnPose.forEach((value, index) => assertFinite(value, `simulation model world spawnPose[${index}]`));
   }
-  assertFinite(world?.keyboardTeleop?.linearStep, "robotExport(...) world keyboardTeleop.linearStep");
-  assertFinite(world?.keyboardTeleop?.angularStep, "robotExport(...) world keyboardTeleop.angularStep");
-  _collectedRobotExport = {
-    modelName: (options.modelName ?? assembly2.name ?? "ForgeCAD Robot").trim() || "ForgeCAD Robot",
+  assertFinite(world?.keyboardTeleop?.linearStep, "simulation model world keyboardTeleop.linearStep");
+  assertFinite(world?.keyboardTeleop?.angularStep, "simulation model world keyboardTeleop.angularStep");
+  return {
+    modelName: (options.modelName ?? assembly2.name ?? "ForgeCAD Simulation").trim() || "ForgeCAD Simulation",
     assembly: assembly2,
+    simulation,
+    source: options.source ?? "assembly",
     state: { ...options.state ?? {} },
     static: options.static ?? false,
     selfCollide: options.selfCollide ?? false,
@@ -72960,14 +73281,358 @@ function robotExport(options) {
     links,
     joints: jointOpts,
     plugins: {
-      diffDrive,
+      diffDrive: diffDrive2,
       jointStatePublisher
     },
     world
   };
+}
+function robotExport(options) {
+  if (!options || typeof options !== "object") {
+    throw new Error("robotExport(...) expects an options object");
+  }
+  if (!options.assembly || typeof options.assembly.describe !== "function") {
+    throw new Error("robotExport(...) requires an assembly");
+  }
+  _collectedRobotExport = collectSimulationModel(options.assembly, { ...options, source: "robotExport" });
   return _collectedRobotExport;
 }
 
+// src/forge/export/simreadyValidation.ts
+function error(findings, code, message, path2) {
+  findings.push({ level: "error", code, message, path: path2 });
+}
+function warn(findings, code, message, path2) {
+  findings.push({ level: "warning", code, message, path: path2 });
+}
+function isFiniteNumber3(value) {
+  return value === void 0 || Number.isFinite(value);
+}
+function requireFinite9(findings, value, label, path2) {
+  if (!isFiniteNumber3(value)) error(findings, "SIM.NUMBER.FINITE", `${label} must be finite.`, path2);
+}
+function requirePositive7(findings, value, label, path2) {
+  requireFinite9(findings, value, label, path2);
+  if (value !== void 0 && value <= 0) error(findings, "SIM.NUMBER.POSITIVE", `${label} must be > 0.`, path2);
+}
+function requireNonNegative(findings, value, label, path2) {
+  requireFinite9(findings, value, label, path2);
+  if (value !== void 0 && value < 0) error(findings, "SIM.NUMBER.NON_NEGATIVE", `${label} must be >= 0.`, path2);
+}
+function partConnectorNames(part) {
+  if (part.part instanceof Shape) return new Set(Object.keys(getShapePorts(part.part)));
+  if (part.part instanceof ShapeGroup) return new Set(Object.keys(getShapeGroupPorts(part.part)));
+  return /* @__PURE__ */ new Set();
+}
+function profileRequiresExplicitCollider(model) {
+  return model.simulation !== null;
+}
+function validatePart(findings, model, part) {
+  const link = model.links[part.name];
+  const hasLegacyPhysicalData = link?.massKg !== void 0 || link?.densityKgM3 !== void 0;
+  const path2 = `parts.${part.name}`;
+  if (!part.sim && !hasLegacyPhysicalData) {
+    error(
+      findings,
+      "SIM.BODY.MISSING",
+      `Part "${part.name}" needs Sim.body(...) metadata or legacy massKg/densityKgM3 export metadata.`,
+      path2
+    );
+    return;
+  }
+  requirePositive7(findings, link?.massKg, `Part "${part.name}" massKg`, `${path2}.massKg`);
+  requirePositive7(findings, link?.densityKgM3, `Part "${part.name}" densityKgM3`, `${path2}.densityKgM3`);
+  if (link?.massKg === void 0 && link?.densityKgM3 === void 0) {
+    error(findings, "SIM.BODY.MASS_MISSING", `Part "${part.name}" needs massKg or densityKgM3.`, path2);
+  }
+  if (profileRequiresExplicitCollider(model) && !part.sim?.collider && !link?.collision) {
+    error(findings, "SIM.COLLIDER.MISSING", `Part "${part.name}" needs an explicit Sim.collider.*(...) selection.`, `${path2}.collider`);
+  }
+  if (part.sim?.collider?.mode === "none" && !part.sim.collider.reason?.trim()) {
+    error(findings, "SIM.COLLIDER.NONE_REASON", `Part "${part.name}" uses Sim.collider.none(...) without a reason.`, `${path2}.collider`);
+  }
+  const material2 = part.sim?.material;
+  if (material2) {
+    requirePositive7(findings, material2.densityKgM3, `Material "${material2.name}" densityKgM3`, `${path2}.material.densityKgM3`);
+    requireNonNegative(findings, material2.staticFriction, `Material "${material2.name}" staticFriction`, `${path2}.material.staticFriction`);
+    requireNonNegative(
+      findings,
+      material2.dynamicFriction,
+      `Material "${material2.name}" dynamicFriction`,
+      `${path2}.material.dynamicFriction`
+    );
+    requireNonNegative(findings, material2.restitution, `Material "${material2.name}" restitution`, `${path2}.material.restitution`);
+  }
+  const connectorNames = partConnectorNames(part);
+  for (const [name, contact2] of Object.entries(part.sim?.contacts ?? {})) {
+    if (!connectorNames.has(contact2.connectorName)) {
+      error(
+        findings,
+        "SIM.CONTACT.CONNECTOR_MISSING",
+        `Contact "${name}" on part "${part.name}" references missing connector "${contact2.connectorName}".`,
+        `${path2}.contacts.${name}`
+      );
+    }
+  }
+}
+function validateJoint(findings, model, joint2) {
+  const opts = model.joints[joint2.name];
+  const path2 = `joints.${joint2.name}`;
+  requirePositive7(findings, opts?.effort, `Joint "${joint2.name}" effort`, `${path2}.effort`);
+  requirePositive7(findings, opts?.velocity, `Joint "${joint2.name}" velocity`, `${path2}.velocity`);
+  requireNonNegative(findings, opts?.damping, `Joint "${joint2.name}" damping`, `${path2}.damping`);
+  requireNonNegative(findings, opts?.friction, `Joint "${joint2.name}" friction`, `${path2}.friction`);
+  const drive = joint2.sim?.drive;
+  if (drive?.kind === "velocity") {
+    requirePositive7(findings, drive.maxTorqueNm, `Joint "${joint2.name}" velocity drive maxTorqueNm`, `${path2}.drive.maxTorqueNm`);
+    requirePositive7(findings, drive.maxSpeedRpm, `Joint "${joint2.name}" velocity drive maxSpeedRpm`, `${path2}.drive.maxSpeedRpm`);
+  }
+  if (drive) {
+    requireNonNegative(findings, drive.damping, `Joint "${joint2.name}" drive damping`, `${path2}.drive.damping`);
+    requireNonNegative(findings, drive.friction, `Joint "${joint2.name}" drive friction`, `${path2}.drive.friction`);
+  }
+}
+function validateDiffDriveController(findings, model) {
+  const diffDrive2 = model.plugins.diffDrive;
+  if (!diffDrive2) return;
+  const jointsByName = new Map(model.assembly.joints.map((joint2) => [joint2.name, joint2]));
+  if (diffDrive2.leftJoints.length === 0 || diffDrive2.rightJoints.length === 0) {
+    error(
+      findings,
+      "SIM.CONTROLLER.DIFF_DRIVE_EMPTY",
+      "Diff-drive controller needs at least one left and one right joint.",
+      "controllers.diffDrive"
+    );
+  }
+  requirePositive7(findings, diffDrive2.wheelRadiusMm, "Diff-drive wheelRadiusMm", "controllers.diffDrive.wheelRadiusMm");
+  requirePositive7(findings, diffDrive2.wheelSeparationMm, "Diff-drive wheelSeparationMm", "controllers.diffDrive.wheelSeparationMm");
+  for (const jointName of [...diffDrive2.leftJoints, ...diffDrive2.rightJoints]) {
+    const joint2 = jointsByName.get(jointName);
+    if (!joint2) {
+      error(
+        findings,
+        "SIM.CONTROLLER.UNKNOWN_JOINT",
+        `Diff-drive controller references unknown joint "${jointName}".`,
+        "controllers.diffDrive"
+      );
+    } else if (joint2.type !== "revolute") {
+      error(
+        findings,
+        "SIM.CONTROLLER.JOINT_TYPE",
+        `Diff-drive joint "${jointName}" must be revolute, got ${joint2.type}.`,
+        `joints.${jointName}`
+      );
+    }
+  }
+}
+function validateRobotGraph(findings, model) {
+  if (!simProfileRequiresRootPart(model.simulation?.profile)) return;
+  const rootPart = model.simulation?.rootPart;
+  if (!rootPart) return;
+  const partNames = new Set(model.assembly.parts.map((part) => part.name));
+  if (!partNames.has(rootPart)) {
+    error(findings, "SIM.ROBOT.ROOT_PART", `Robot rootPart "${rootPart}" does not exist.`, "sim.rootPart");
+    return;
+  }
+  const graph = /* @__PURE__ */ new Map();
+  for (const part of partNames) graph.set(part, /* @__PURE__ */ new Set());
+  for (const joint2 of model.assembly.joints) {
+    graph.get(joint2.parent)?.add(joint2.child);
+    graph.get(joint2.child)?.add(joint2.parent);
+  }
+  const visited = /* @__PURE__ */ new Set();
+  const queue = [rootPart];
+  while (queue.length > 0) {
+    const current = queue.shift();
+    if (visited.has(current)) continue;
+    visited.add(current);
+    for (const next of graph.get(current) ?? []) {
+      if (!visited.has(next)) queue.push(next);
+    }
+  }
+  const disconnected = [...partNames].filter((partName) => !visited.has(partName));
+  if (disconnected.length > 0) {
+    error(
+      findings,
+      "SIM.ROBOT.DISCONNECTED_GRAPH",
+      `Robot joint graph is disconnected from rootPart "${rootPart}": ${disconnected.join(", ")}.`,
+      "sim.graph"
+    );
+  }
+}
+function validateWorld(findings, model) {
+  const world = model.world;
+  if (!world) return;
+  world.spawnPose?.forEach((value, index) => requireFinite9(findings, value, `world spawnPose[${index}]`, `world.spawnPose.${index}`));
+  requirePositive7(findings, world.keyboardTeleop?.linearStep, "world keyboardTeleop.linearStep", "world.keyboardTeleop.linearStep");
+  requirePositive7(findings, world.keyboardTeleop?.angularStep, "world keyboardTeleop.angularStep", "world.keyboardTeleop.angularStep");
+}
+function validateSimulationModel(model) {
+  const findings = [];
+  const simulation = model.simulation;
+  if (!simulation && model.source !== "robotExport") {
+    error(findings, "SIM.SIMULATION.MISSING", "Model must return assembly(...).withSimulation(...).", "sim");
+  }
+  if (!simulation && model.source === "robotExport") {
+    warn(
+      findings,
+      "SIM.SIMULATION.LEGACY_ROBOT_EXPORT",
+      "Legacy robotExport(...) metadata is accepted for compatibility; prefer assembly.withSimulation(...).",
+      "sim"
+    );
+  }
+  if (simulation && !simulation.profile) {
+    error(findings, "SIM.PROFILE.MISSING", "Simulation contract needs a Sim.profile.*() value.", "sim.profile");
+  }
+  if (simProfileRequiresRootPart(simulation?.profile) && !simulation?.rootPart) {
+    error(findings, "SIM.ROBOT.ROOT_PART_MISSING", "Robot-body simulation profiles require rootPart.", "sim.rootPart");
+  }
+  if (simulation?.controllers && simulation.controllers.length > 0 && !simProfileAllowsControllers(simulation.profile)) {
+    error(
+      findings,
+      "SIM.CONTROLLER.PROFILE_UNSUPPORTED",
+      "Controllers are only supported for robot-body simulation profiles.",
+      "sim.controllers"
+    );
+  }
+  model.assembly.parts.forEach((part) => validatePart(findings, model, part));
+  model.assembly.joints.forEach((joint2) => validateJoint(findings, model, joint2));
+  validateDiffDriveController(findings, model);
+  validateRobotGraph(findings, model);
+  validateWorld(findings, model);
+  const errors = findings.filter((finding) => finding.level === "error");
+  const warnings = findings.filter((finding) => finding.level === "warning");
+  return {
+    ok: errors.length === 0,
+    modelName: model.modelName,
+    profile: simulation?.profile.name ?? null,
+    contract: simulation?.kind ?? null,
+    errors,
+    warnings
+  };
+}
+
+// src/forge/export/simreadyManifest.ts
+function materialManifest(material2) {
+  if (!material2) return void 0;
+  return {
+    name: material2.name,
+    densityKgM3: material2.densityKgM3,
+    staticFriction: material2.staticFriction,
+    dynamicFriction: material2.dynamicFriction,
+    restitution: material2.restitution
+  };
+}
+function bodyPhysicalSource(sim, link) {
+  if (sim) return "sim";
+  if (link?.massKg !== void 0 || link?.densityKgM3 !== void 0 || link?.collision !== void 0) return "legacy-export";
+  return "missing";
+}
+function bodyManifest(model) {
+  return model.assembly.parts.map((part) => {
+    const link = model.links[part.name];
+    const contacts = Object.entries(part.sim?.contacts ?? {}).map(([name, contact2]) => ({
+      name,
+      kind: contact2.kind,
+      connectorName: contact2.connectorName
+    }));
+    return {
+      name: part.name,
+      physicalSource: bodyPhysicalSource(part.sim, link),
+      massKg: link?.massKg,
+      densityKgM3: link?.densityKgM3,
+      material: materialManifest(part.sim?.material),
+      collider: part.sim?.collider ? { mode: part.sim.collider.mode, reason: part.sim.collider.reason } : void 0,
+      contacts
+    };
+  });
+}
+function jointManifest(model) {
+  return model.assembly.joints.map((joint2) => {
+    const exportDynamics = model.joints[joint2.name];
+    return {
+      name: joint2.name,
+      type: joint2.type,
+      parent: joint2.parent,
+      child: joint2.child,
+      limits: joint2.min !== void 0 || joint2.max !== void 0 ? {
+        min: joint2.min,
+        max: joint2.max,
+        unit: joint2.unit
+      } : void 0,
+      drive: joint2.sim?.drive,
+      exportDynamics
+    };
+  });
+}
+function diffDriveManifest(diffDrive2) {
+  if (!diffDrive2) return [];
+  return [
+    {
+      kind: "diffDrive",
+      leftJoints: [...diffDrive2.leftJoints],
+      rightJoints: [...diffDrive2.rightJoints],
+      wheelSeparationMm: diffDrive2.wheelSeparationMm,
+      wheelRadiusMm: diffDrive2.wheelRadiusMm
+    }
+  ];
+}
+function externalStages(model) {
+  const stages = ["convert-to-usd", "validate-usd-minimum"];
+  if (model.simulation) stages.push("simready-conform-profile");
+  stages.push("omni-asset-validate", "omni-asset-validate-geometry", "omni-asset-validate-physics", "simready-validate");
+  return stages;
+}
+function buildSimReadyManifest(model) {
+  const validation = validateSimulationModel(model);
+  const bodies = bodyManifest(model);
+  const joints = jointManifest(model);
+  const controllers = diffDriveManifest(model.plugins.diffDrive);
+  const contactSurfaceCount = bodies.reduce((sum, body2) => sum + body2.contacts.length, 0);
+  const profile2 = model.simulation?.profile;
+  return {
+    format: "forgecad-simready-manifest",
+    version: 1,
+    modelName: model.modelName,
+    sourceModelName: model.assembly.name,
+    source: model.source,
+    profile: profile2?.name ?? null,
+    profileVersion: "1.0.0",
+    units: {
+      sourceLength: "millimeter",
+      exportLength: "meter",
+      sourceToMeters: 1e-3
+    },
+    contract: model.simulation ? { kind: model.simulation.kind, rootPart: model.simulation.rootPart } : null,
+    capabilities: {
+      bodyCount: bodies.length,
+      jointCount: joints.length,
+      contactSurfaceCount,
+      drivenJointCount: joints.filter((joint2) => joint2.drive || joint2.exportDynamics).length,
+      controllerCount: controllers.length,
+      hasRobotProfile: simProfileRequiresRootPart(profile2),
+      hasAssetProfile: profile2?.name === "Prop-Robotics-Physx"
+    },
+    bodies,
+    joints,
+    controllers,
+    validation: {
+      ok: validation.ok,
+      errors: validation.errors,
+      warnings: validation.warnings
+    },
+    externalHandoff: {
+      usdAuthoring: "not-included",
+      nvidiaValidation: "optional-external",
+      suggestedStages: externalStages(model)
+    }
+  };
+}
+function simReadyManifestJson(manifest) {
+  return `${JSON.stringify(manifest, null, 2)}
+`;
+}
+
 // src/forge/sketch/entities.ts
 var Point2D = class _Point2D {
   constructor(x, y) {
@@ -73516,7 +74181,7 @@ function requireVec34(v, label) {
   }
   return v;
 }
-function requireFiniteNumber2(n, label) {
+function requireFiniteNumber3(n, label) {
   if (typeof n !== "number" || !Number.isFinite(n)) {
     throw new Error(`${label} must be a finite number, got ${JSON.stringify(n)}`);
   }
@@ -73535,7 +74200,7 @@ function midpoint4(a, b) {
 function lerp4(a, b, t) {
   requireVec34(a, "a");
   requireVec34(b, "b");
-  requireFiniteNumber2(t, "t");
+  requireFiniteNumber3(t, "t");
   return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t, a[2] + (b[2] - a[2]) * t];
 }
 function direction(a, b) {
@@ -73553,7 +74218,7 @@ function direction(a, b) {
 function offset(point2, dir, amount) {
   requireVec34(point2, "point");
   requireVec34(dir, "dir");
-  requireFiniteNumber2(amount, "amount");
+  requireFiniteNumber3(amount, "amount");
   return [point2[0] + dir[0] * amount, point2[1] + dir[1] * amount, point2[2] + dir[2] * amount];
 }
 var Points2 = {
@@ -73661,14 +74326,14 @@ var WoodBoard = class _WoodBoard {
 };
 
 // src/forge/wood/joints.ts
-function requireFinite9(value, name) {
+function requireFinite10(value, name) {
   if (!Number.isFinite(value)) {
     throw new Error(`${name} must be a finite number, got ${value}`);
   }
   return value;
 }
-function requirePositive7(value, name) {
-  requireFinite9(value, name);
+function requirePositive8(value, name) {
+  requireFinite10(value, name);
   if (value <= 0) {
     throw new Error(`${name} must be positive, got ${value}`);
   }
@@ -73694,7 +74359,7 @@ function dado(host, guest, opts) {
   const fit = opts.fit ?? "snug";
   const clearance = clearanceForFit(fit);
   const channelWidth = guest.thickness + clearance;
-  const channelDepth = opts.depth != null ? requirePositive7(opts.depth, "depth") : host.thickness / 3;
+  const channelDepth = opts.depth != null ? requirePositive8(opts.depth, "depth") : host.thickness / 3;
   if (opts.fromBottom != null && opts.fromTop != null) {
     throw new Error("dado: specify fromBottom or fromTop, not both");
   }
@@ -73703,15 +74368,15 @@ function dado(host, guest, opts) {
   }
   let fromBottom;
   if (opts.fromBottom != null) {
-    fromBottom = requireFinite9(opts.fromBottom, "fromBottom");
+    fromBottom = requireFinite10(opts.fromBottom, "fromBottom");
   } else {
     fromBottom = host.height - opts.fromTop - channelWidth;
-    requireFinite9(fromBottom, "computed fromBottom");
+    requireFinite10(fromBottom, "computed fromBottom");
   }
   let dadoLength = host.width;
   let xOffset = 0;
   if (opts.stopped != null) {
-    const stoppedDist = requirePositive7(opts.stopped, "stopped");
+    const stoppedDist = requirePositive8(opts.stopped, "stopped");
     dadoLength = host.width - stoppedDist;
     xOffset = -stoppedDist / 2;
   }
@@ -73723,8 +74388,8 @@ function dado(host, guest, opts) {
 function rabbet(board, opts) {
   if (!board) throw new Error("rabbet: board is required");
   if (!opts) throw new Error("rabbet: options are required");
-  const width = requirePositive7(opts.width, "width");
-  const depth = requirePositive7(opts.depth, "depth");
+  const width = requirePositive8(opts.width, "width");
+  const depth = requirePositive8(opts.depth, "depth");
   const edge = opts.edge;
   const bw = board.width;
   const bh = board.height;
@@ -73764,10 +74429,10 @@ function mortiseAndTenon(mortiseBoard, tenonBoard, opts) {
   const style = o.style ?? "blind";
   const fit = o.fit ?? "snug";
   const clearance = clearanceForFit(fit);
-  const cornerRadius = o.cornerRadius != null ? requireFinite9(o.cornerRadius, "cornerRadius") : 0;
-  const tenonThickness = o.tenonThickness != null ? requirePositive7(o.tenonThickness, "tenonThickness") : tenonBoard.thickness / 3;
-  const tenonWidth = o.tenonWidth != null ? requirePositive7(o.tenonWidth, "tenonWidth") : Math.min(tenonBoard.height * 0.6, mortiseBoard.height * 0.8);
-  const tenonLength = o.tenonLength != null ? requirePositive7(o.tenonLength, "tenonLength") : style === "through" ? mortiseBoard.thickness : mortiseBoard.thickness * 2 / 3;
+  const cornerRadius = o.cornerRadius != null ? requireFinite10(o.cornerRadius, "cornerRadius") : 0;
+  const tenonThickness = o.tenonThickness != null ? requirePositive8(o.tenonThickness, "tenonThickness") : tenonBoard.thickness / 3;
+  const tenonWidth = o.tenonWidth != null ? requirePositive8(o.tenonWidth, "tenonWidth") : Math.min(tenonBoard.height * 0.6, mortiseBoard.height * 0.8);
+  const tenonLength = o.tenonLength != null ? requirePositive8(o.tenonLength, "tenonLength") : style === "through" ? mortiseBoard.thickness : mortiseBoard.thickness * 2 / 3;
   const mortiseW = tenonThickness + clearance;
   const mortiseH = tenonWidth + clearance;
   const mortiseDepth = style === "through" ? mortiseBoard.thickness + 1 : tenonLength;
@@ -73777,10 +74442,10 @@ function mortiseAndTenon(mortiseBoard, tenonBoard, opts) {
       throw new Error("mortiseAndTenon: specify position.fromTop or position.fromBottom, not both");
     }
     if (o.position.fromTop != null) {
-      requireFinite9(o.position.fromTop, "position.fromTop");
+      requireFinite10(o.position.fromTop, "position.fromTop");
       mortiseCenterY = mortiseBoard.height / 2 - o.position.fromTop - mortiseH / 2;
     } else if (o.position.fromBottom != null) {
-      requireFinite9(o.position.fromBottom, "position.fromBottom");
+      requireFinite10(o.position.fromBottom, "position.fromBottom");
       mortiseCenterY = -mortiseBoard.height / 2 + o.position.fromBottom + mortiseH / 2;
     }
   }
@@ -73788,8 +74453,8 @@ function mortiseAndTenon(mortiseBoard, tenonBoard, opts) {
   const mortiseZBase = style === "through" ? -0.5 : mortiseBoard.thickness - mortiseDepth;
   if (cornerRadius > 0) {
     const r = Math.min(cornerRadius, mortiseW / 2, mortiseH / 2);
-    const profile = roundedRect(mortiseW, mortiseH, r);
-    mortiseCutter = profile.extrude(mortiseDepth).translate(0, mortiseCenterY, mortiseZBase);
+    const profile2 = roundedRect(mortiseW, mortiseH, r);
+    mortiseCutter = profile2.extrude(mortiseDepth).translate(0, mortiseCenterY, mortiseZBase);
   } else {
     mortiseCutter = box2(mortiseW, mortiseH, mortiseDepth).translate(0, mortiseCenterY, mortiseZBase);
   }
@@ -73881,19 +74546,19 @@ function isOrbitKeyframe(kf) {
 function isCartesianKeyframe(kf) {
   return "position" in kf;
 }
-function requireFinite10(value, label) {
+function requireFinite11(value, label) {
   if (!Number.isFinite(value)) {
     throw new Error(`cameraTrajectory(): ${label} must be a finite number, got ${value}`);
   }
 }
 function validateOrbitKeyframe(kf, index) {
-  requireFinite10(kf.at, `keyframes[${index}].at`);
-  requireFinite10(kf.orbit.angle, `keyframes[${index}].orbit.angle`);
-  requireFinite10(kf.orbit.pitch, `keyframes[${index}].orbit.pitch`);
-  requireFinite10(kf.orbit.distance, `keyframes[${index}].orbit.distance`);
+  requireFinite11(kf.at, `keyframes[${index}].at`);
+  requireFinite11(kf.orbit.angle, `keyframes[${index}].orbit.angle`);
+  requireFinite11(kf.orbit.pitch, `keyframes[${index}].orbit.pitch`);
+  requireFinite11(kf.orbit.distance, `keyframes[${index}].orbit.distance`);
 }
 function validateCartesianKeyframe(kf, index) {
-  requireFinite10(kf.at, `keyframes[${index}].at`);
+  requireFinite11(kf.at, `keyframes[${index}].at`);
   if (!Array.isArray(kf.position) || kf.position.length !== 3) {
     throw new Error(`cameraTrajectory(): keyframes[${index}].position must be a 3-element array`);
   }
@@ -73901,8 +74566,8 @@ function validateCartesianKeyframe(kf, index) {
     throw new Error(`cameraTrajectory(): keyframes[${index}].target must be a 3-element array`);
   }
   for (let i = 0; i < 3; i++) {
-    requireFinite10(kf.position[i], `keyframes[${index}].position[${i}]`);
-    requireFinite10(kf.target[i], `keyframes[${index}].target[${i}]`);
+    requireFinite11(kf.position[i], `keyframes[${index}].position[${i}]`);
+    requireFinite11(kf.target[i], `keyframes[${index}].target[${i}]`);
   }
 }
 function validateKeyframeOrder(keyframes) {
@@ -74157,21 +74822,28 @@ function consumeBroadEdgeFeatureBudget(edgeCount) {
   broadEdgeFeatureBudget = Math.max(0, remaining - edgeCount);
   return true;
 }
+var BROAD_EDGE_FEATURE_REMEDY = "Pass an explicit edge selector (e.g. selectEdges(shape) or { convex: true }), use high quality/export, or raise the budget with FORGECAD_BROAD_EDGE_FEATURE_BUDGET / FORGECAD_ALLOW_BROAD_EDGE_FEATURES=1.";
+function skipOrRejectBroadEdgeFeature(operation, reason) {
+  if (getForgeQualityPreset() === "live") {
+    emitRuntimeWarning(
+      `${operation}() without an edge selector ${reason} Skipped this edge finish for live-preview responsiveness. ${BROAD_EDGE_FEATURE_REMEDY}`
+    );
+    return true;
+  }
+  throw new Error(`${operation}() without an edge selector ${reason} ${BROAD_EDGE_FEATURE_REMEDY}`);
+}
 function shouldSkipBroadEdgeFeature(operation, edgeCount) {
   if (consumeBroadEdgeFeatureBudget(edgeCount)) return false;
   const remaining = Math.max(0, remainingBroadEdgeFeatureBudget());
-  emitRuntimeWarning(
-    `${operation}() without an edge selector matched ${edgeCount} edge(s), exceeding the remaining broad edge-feature budget (${remaining}). Skipped this cosmetic edge finish for responsiveness. Pass an explicit edge selector, use high quality/export, or set FORGECAD_BROAD_EDGE_FEATURE_BUDGET to opt into more broad edge finishing.`
+  return skipOrRejectBroadEdgeFeature(
+    operation,
+    `matched ${edgeCount} edge(s), exceeding the remaining broad edge-feature budget (${remaining}).`
   );
-  return true;
 }
 function shouldSkipExhaustedBroadEdgeFeature(operation) {
   const remaining = remainingBroadEdgeFeatureBudget();
   if (!Number.isFinite(remaining) || remaining > 0) return false;
-  emitRuntimeWarning(
-    `${operation}() without an edge selector was skipped because the broad edge-feature budget is exhausted. Skipped this cosmetic edge finish for responsiveness. Pass an explicit edge selector, use high quality/export, or set FORGECAD_BROAD_EDGE_FEATURE_BUDGET to opt into more broad edge finishing.`
-  );
-  return true;
+  return skipOrRejectBroadEdgeFeature(operation, "cannot run because the broad edge-feature budget is exhausted.");
 }
 function estimateSelectorlessEdgeCount(plan) {
   if (!plan) return null;
@@ -74190,10 +74862,10 @@ function shouldSkipUnestimatedBroadEdgeFeature(operation, target) {
   if (!Number.isFinite(remaining)) return false;
   const estimatedEdges = estimateSelectorlessEdgeCount(getShapeCompilePlan(target));
   if (estimatedEdges !== null && estimatedEdges <= remaining) return false;
-  emitRuntimeWarning(
-    `${operation}() without an edge selector was skipped before broad edge enumeration because this shape is too complex for the remaining broad edge-feature budget (${Math.max(0, remaining)}). Skipped this cosmetic edge finish for responsiveness. Pass an explicit edge selector, use high quality/export, or set FORGECAD_BROAD_EDGE_FEATURE_BUDGET to opt into more broad edge finishing.`
+  return skipOrRejectBroadEdgeFeature(
+    operation,
+    `targets a shape too complex for the remaining broad edge-feature budget (${Math.max(0, remaining)}).`
   );
-  return true;
 }
 function edgesToTargets(edges) {
   return edges.map((e) => {
@@ -74439,7 +75111,7 @@ function applyMatrixToPlacement(placement, matrix) {
 function applyShapeTransformToPlacement(placement, step) {
   return applyMatrixToPlacement(placement, shapeTransformStepMatrix2(step));
 }
-function mapProfileToPlane(profile, sourcePlacement, targetPlane) {
+function mapProfileToPlane(profile2, sourcePlacement, targetPlane) {
   const sourceTransform = Transform.from(sourcePlacement.matrix);
   const sourceOrigin = sourceTransform.point([0, 0, 0]);
   const sourceU = sourceTransform.vector([1, 0, 0]);
@@ -74470,7 +75142,7 @@ function mapProfileToPlane(profile, sourcePlacement, targetPlane) {
   if (!nearlyEqual(Math.abs(det), 1, 1e-5)) {
     return { reason: "projection replay requires a rigid or mirrored in-plane basis." };
   }
-  let next = cloneProfileCompilePlan(profile);
+  let next = cloneProfileCompilePlan(profile2);
   if (!nearlyEqual(sx, 1) || !nearlyEqual(sy, 1)) {
     next = appendProfileCompileTransform(next, { kind: "scale", x: sx, y: sy });
   }
@@ -74494,8 +75166,8 @@ function mapProfileToPlane(profile, sourcePlacement, targetPlane) {
   }
   return { profile: next };
 }
-function buildReplayProfile(profile, sourcePlacement, targetPlane) {
-  return mapProfileToPlane(profile, sourcePlacement, targetPlane);
+function buildReplayProfile(profile2, sourcePlacement, targetPlane) {
+  return mapProfileToPlane(profile2, sourcePlacement, targetPlane);
 }
 function circleProjectionProfile(radius, segments) {
   return {
@@ -74550,14 +75222,14 @@ function targetPlanePlacement(targetPlane) {
   };
 }
 function sphereProjectionProfileAtCenter(radius, segments, center, targetPlane) {
-  const profile = circleProjectionProfile(Math.abs(radius), segments);
+  const profile2 = circleProjectionProfile(Math.abs(radius), segments);
   const delta = sub11(center, targetPlane.origin);
   const tx = dot11(delta, targetPlane.u);
   const ty = dot11(delta, targetPlane.v);
   if (!nearlyEqual(tx, 0) || !nearlyEqual(ty, 0)) {
-    profile.transforms.push({ kind: "translate", x: tx, y: ty });
+    profile2.transforms.push({ kind: "translate", x: tx, y: ty });
   }
-  return profile;
+  return profile2;
 }
 function pointDistance2d(a, b) {
   return Math.hypot(a[0] - b[0], a[1] - b[1]);
@@ -74705,7 +75377,7 @@ function transformedTorusSideProjectionReplayProfile(sourceShape, targetPlane) {
   const radiusDirection = normalize9(cross11(targetPlane.normal, axis));
   const radiusDirectionU = dot11(radiusDirection, targetPlane.u);
   const radiusDirectionV = dot11(radiusDirection, targetPlane.v);
-  const profile = {
+  const profile2 = {
     kind: "roundedRect",
     width: 2 * (majorRadius + minorRadius),
     height: 2 * minorRadius,
@@ -74713,15 +75385,15 @@ function transformedTorusSideProjectionReplayProfile(sourceShape, targetPlane) {
     transforms: []
   };
   const angle = Math.atan2(radiusDirectionV, radiusDirectionU) * 180 / Math.PI;
-  if (!nearlyEqual(angle, 0)) profile.transforms.push({ kind: "rotate", degrees: angle });
+  if (!nearlyEqual(angle, 0)) profile2.transforms.push({ kind: "rotate", degrees: angle });
   const center = input.transform.point([0, 0, 0]);
   const delta = sub11(center, targetPlane.origin);
   const tx = dot11(delta, targetPlane.u);
   const ty = dot11(delta, targetPlane.v);
   if (!nearlyEqual(tx, 0) || !nearlyEqual(ty, 0)) {
-    profile.transforms.push({ kind: "translate", x: tx, y: ty });
+    profile2.transforms.push({ kind: "translate", x: tx, y: ty });
   }
-  return { profile, placement: targetPlanePlacement(targetPlane) };
+  return { profile: profile2, placement: targetPlanePlacement(targetPlane) };
 }
 function transformedExtrudeProjectionInput(sourceShape) {
   const source = unwrapQueryOwnerPlan3(sourceShape);
@@ -74844,7 +75516,7 @@ function intervalGroupsAreStrictlySeparated2(groups) {
   return true;
 }
 function radialIntervalsProjectionProfile(intervals, segments) {
-  const profiles2 = normalizeIntervals2(intervals).map(([inner, outer]) => annulusProjectionProfile(outer, inner, segments)).filter((profile) => profile != null);
+  const profiles2 = normalizeIntervals2(intervals).map(([inner, outer]) => annulusProjectionProfile(outer, inner, segments)).filter((profile2) => profile2 != null);
   if (profiles2.length === 0) return null;
   if (profiles2.length === 1) return profiles2[0];
   return buildBooleanProfileCompilePlan("union", profiles2);
@@ -74875,7 +75547,7 @@ function radialSectorProjectionProfile(innerRadius, outerRadius, degrees, segmen
 }
 function partialRevolveProjectionProfile(intervals, degrees, segments) {
   if (!Number.isFinite(degrees) || nearlyEqual(degrees, 0)) return null;
-  const profiles2 = normalizeIntervals2(intervals).map(([inner, outer]) => radialSectorProjectionProfile(inner, outer, degrees, segments)).filter((profile) => profile != null);
+  const profiles2 = normalizeIntervals2(intervals).map(([inner, outer]) => radialSectorProjectionProfile(inner, outer, degrees, segments)).filter((profile2) => profile2 != null);
   if (profiles2.length === 0) return null;
   if (profiles2.length === 1) return profiles2[0];
   return buildBooleanProfileCompilePlan("union", profiles2);
@@ -75039,8 +75711,8 @@ function profileOuterProjectionLoops(plan) {
       if (plan.profiles.length === 0) return null;
       if (plan.op === "union") {
         loops = [];
-        for (const profile of plan.profiles) {
-          const profileLoops = profileOuterProjectionLoops(profile);
+        for (const profile2 of plan.profiles) {
+          const profileLoops = profileOuterProjectionLoops(profile2);
           if (!profileLoops) return null;
           loops.push(...profileLoops);
         }
@@ -75070,10 +75742,10 @@ function profileOuterProjectionLoops(plan) {
   }
   return transformProfileLoops(loops, plan.transforms);
 }
-function profileStrictlyContainsCircle(profile, circle2) {
-  switch (profile.kind) {
+function profileStrictlyContainsCircle(profile2, circle2) {
+  switch (profile2.kind) {
     case "circle": {
-      const container = circleProfileFootprint(profile);
+      const container = circleProfileFootprint(profile2);
       if (!container) return false;
       const distance5 = Math.hypot(circle2.center[0] - container.center[0], circle2.center[1] - container.center[1]);
       return distance5 + circle2.radius < container.radius - EPS10;
@@ -75081,11 +75753,11 @@ function profileStrictlyContainsCircle(profile, circle2) {
     case "rect":
     case "polygon":
     case "boolean": {
-      const loops = profileOuterProjectionLoops(profile);
+      const loops = profileOuterProjectionLoops(profile2);
       return loops ? loops.some((loop) => loopStrictlyContainsCircle2d(loop, circle2)) : false;
     }
     case "roundedRect": {
-      const container = roundedRectProfileFootprint(profile);
+      const container = roundedRectProfileFootprint(profile2);
       return container ? roundedRectStrictlyContainsCircle2d(container, circle2) : false;
     }
     case "offset":
@@ -75093,25 +75765,25 @@ function profileStrictlyContainsCircle(profile, circle2) {
     case "pathProfile":
       return false;
     default:
-      return assertExhaustive(profile);
+      return assertExhaustive(profile2);
   }
 }
-function profileStrictlyContainsRoundedRect(profile, roundedRect2) {
-  switch (profile.kind) {
+function profileStrictlyContainsRoundedRect(profile2, roundedRect2) {
+  switch (profile2.kind) {
     case "circle": {
-      const container = circleProfileFootprint(profile);
+      const container = circleProfileFootprint(profile2);
       return container ? circleStrictlyContainsRoundedRect2d(container, roundedRect2) : false;
     }
     case "rect": {
-      const container = rectProfileFootprint(profile);
+      const container = rectProfileFootprint(profile2);
       return container ? rectStrictlyContainsRoundedRect2d(container, roundedRect2) : false;
     }
     case "roundedRect": {
-      const container = roundedRectProfileFootprint(profile);
+      const container = roundedRectProfileFootprint(profile2);
       return container ? roundedRectStrictlyContainsRoundedRect2d(container, roundedRect2) : false;
     }
     case "polygon": {
-      const loops = profileOuterProjectionLoops(profile);
+      const loops = profileOuterProjectionLoops(profile2);
       return loops ? loops.some((loop) => loopStrictlyContainsRoundedRect2d(loop, roundedRect2)) : false;
     }
     case "boolean":
@@ -75120,23 +75792,23 @@ function profileStrictlyContainsRoundedRect(profile, roundedRect2) {
     case "pathProfile":
       return false;
     default:
-      return assertExhaustive(profile);
+      return assertExhaustive(profile2);
   }
 }
-function profileStrictlyContainsLoop(profile, loop) {
-  switch (profile.kind) {
+function profileStrictlyContainsLoop(profile2, loop) {
+  switch (profile2.kind) {
     case "circle": {
-      const circle2 = circleProfileFootprint(profile);
+      const circle2 = circleProfileFootprint(profile2);
       return circle2 ? circleStrictlyContainsLoop2d(circle2, loop) : false;
     }
     case "rect":
     case "polygon":
     case "boolean": {
-      const loops = profileOuterProjectionLoops(profile);
+      const loops = profileOuterProjectionLoops(profile2);
       return loops ? loops.some((subjectLoop) => loopStrictlyContainsLoop2d(subjectLoop, loop)) : false;
     }
     case "roundedRect": {
-      const container = roundedRectProfileFootprint(profile);
+      const container = roundedRectProfileFootprint(profile2);
       return container ? roundedRectStrictlyContainsLoop2d(container, loop) : false;
     }
     case "offset":
@@ -75144,7 +75816,7 @@ function profileStrictlyContainsLoop(profile, loop) {
     case "pathProfile":
       return false;
     default:
-      return assertExhaustive(profile);
+      return assertExhaustive(profile2);
   }
 }
 function profileStrictlyContainsProfile(container, subject) {
@@ -75152,7 +75824,7 @@ function profileStrictlyContainsProfile(container, subject) {
     const profiles2 = booleanProfilesWithParentTransforms2(subject);
     if (!profiles2 || profiles2.length === 0) return false;
     if (subject.op === "union") {
-      return profiles2.every((profile) => profileStrictlyContainsProfile(container, profile));
+      return profiles2.every((profile2) => profileStrictlyContainsProfile(container, profile2));
     }
     if (subject.op === "intersection") {
       const contained = containedIntersectionProfile2(profiles2);
@@ -75272,7 +75944,7 @@ function profileProjectionIntervalAlongDirection(plan, direction2) {
       const profiles2 = booleanProfilesWithParentTransforms2(plan);
       if (!profiles2 || profiles2.length === 0) return null;
       if (plan.op === "union") {
-        const intervals = profiles2.map((profile) => profileProjectionIntervalAlongDirection(profile, direction2));
+        const intervals = profiles2.map((profile2) => profileProjectionIntervalAlongDirection(profile2, direction2));
         if (intervals.some((interval) => !interval)) return null;
         const merged = normalizeIntervals2(intervals);
         return merged.length === 1 ? merged[0] : null;
@@ -75313,7 +75985,7 @@ function profileSupportsDefendedMiterOffsetSideInterval(plan, delta) {
       const profiles2 = booleanProfilesWithParentTransforms2(plan);
       if (!profiles2 || profiles2.length === 0) return false;
       if (plan.op === "union") {
-        return delta >= -EPS10 && profiles2.every((profile) => profileSupportsDefendedMiterOffsetSideInterval(profile, delta));
+        return delta >= -EPS10 && profiles2.every((profile2) => profileSupportsDefendedMiterOffsetSideInterval(profile2, delta));
       }
       if (plan.op === "intersection") {
         const contained = containedIntersectionProfile2(profiles2);
@@ -75422,7 +76094,7 @@ function miterOffsetConvexPolygonProfileProjectionIntervalAlongDirection(plan, d
       return miterOffsetConvexPolygonProfileProjectionIntervalAlongDirection(subject, direction2, delta);
     }
     if (plan.op !== "union" || delta < -EPS10) return null;
-    const intervals = profiles2.map((profile) => miterOffsetConvexPolygonProfileProjectionIntervalAlongDirection(profile, direction2, delta));
+    const intervals = profiles2.map((profile2) => miterOffsetConvexPolygonProfileProjectionIntervalAlongDirection(profile2, direction2, delta));
     if (intervals.some((interval) => !interval)) return null;
     const merged = normalizeIntervals2(intervals);
     return merged.length === 1 ? merged[0] : null;
@@ -75462,11 +76134,11 @@ function miterOffsetConvexPolygonProfileForLocalDelta(plan, localDelta) {
   if (strictlyConvexPolygonOrientation(offsetPoints) !== orientation3) return null;
   return { kind: "polygon", points: offsetPoints, transforms: [] };
 }
-function translatedProfileIfNeeded(profile, center) {
+function translatedProfileIfNeeded(profile2, center) {
   if (!nearlyEqual(center[0], 0) || !nearlyEqual(center[1], 0)) {
-    profile.transforms.push({ kind: "translate", x: center[0], y: center[1] });
+    profile2.transforms.push({ kind: "translate", x: center[0], y: center[1] });
   }
-  return profile;
+  return profile2;
 }
 function insetProfileForContainment(plan, distance5) {
   if (!Number.isFinite(distance5) || distance5 < -EPS10) return null;
@@ -75498,7 +76170,7 @@ function insetProfileForContainment(plan, distance5) {
     if (!roundedRect2 || roundedRect2.halfWidth <= distance5 + EPS10 || roundedRect2.halfHeight <= distance5 + EPS10 || roundedRect2.radius <= distance5 + EPS10) {
       return null;
     }
-    const profile = {
+    const profile2 = {
       kind: "roundedRect",
       width: 2 * (roundedRect2.halfWidth - distance5),
       height: 2 * (roundedRect2.halfHeight - distance5),
@@ -75506,8 +76178,8 @@ function insetProfileForContainment(plan, distance5) {
       transforms: []
     };
     const angle = Math.atan2(roundedRect2.xAxis[1], roundedRect2.xAxis[0]) * 180 / Math.PI;
-    if (!nearlyEqual(angle, 0)) profile.transforms.push({ kind: "rotate", degrees: angle });
-    return translatedProfileIfNeeded(profile, roundedRect2.center);
+    if (!nearlyEqual(angle, 0)) profile2.transforms.push({ kind: "rotate", degrees: angle });
+    return translatedProfileIfNeeded(profile2, roundedRect2.center);
   }
   if (plan.kind === "polygon") {
     return miterOffsetConvexPolygonProfileForLocalDelta(plan, -distance5);
@@ -75520,8 +76192,8 @@ function expandedProfileForContainment(plan, distance5) {
   if (plan.kind === "boolean" && plan.op === "union") {
     const profiles2 = booleanProfilesWithParentTransforms2(plan);
     if (!profiles2 || profiles2.length === 0) return null;
-    const expandedProfiles = profiles2.map((profile) => expandedProfileForContainment(profile, distance5));
-    return expandedProfiles.some((profile) => !profile) ? null : buildBooleanProfileCompilePlan("union", expandedProfiles);
+    const expandedProfiles = profiles2.map((profile2) => expandedProfileForContainment(profile2, distance5));
+    return expandedProfiles.some((profile2) => !profile2) ? null : buildBooleanProfileCompilePlan("union", expandedProfiles);
   }
   if (plan.kind === "boolean" && plan.op === "intersection") {
     const profiles2 = booleanProfilesWithParentTransforms2(plan);
@@ -75555,7 +76227,7 @@ function expandedProfileForContainment(plan, distance5) {
   if (plan.kind === "roundedRect") {
     const roundedRect2 = roundedRectProfileFootprint(plan);
     if (!roundedRect2) return null;
-    const profile = {
+    const profile2 = {
       kind: "roundedRect",
       width: 2 * (roundedRect2.halfWidth + distance5),
       height: 2 * (roundedRect2.halfHeight + distance5),
@@ -75563,8 +76235,8 @@ function expandedProfileForContainment(plan, distance5) {
       transforms: []
     };
     const angle = Math.atan2(roundedRect2.xAxis[1], roundedRect2.xAxis[0]) * 180 / Math.PI;
-    if (!nearlyEqual(angle, 0)) profile.transforms.push({ kind: "rotate", degrees: angle });
-    return translatedProfileIfNeeded(profile, roundedRect2.center);
+    if (!nearlyEqual(angle, 0)) profile2.transforms.push({ kind: "rotate", degrees: angle });
+    return translatedProfileIfNeeded(profile2, roundedRect2.center);
   }
   if (plan.kind === "polygon") {
     return miterOffsetConvexPolygonProfileForLocalDelta(plan, distance5);
@@ -75577,7 +76249,7 @@ function booleanOffsetProfileProjectionIntervalAlongDirection(plan, direction2,
   if (!profiles2 || profiles2.length === 0) return null;
   if (plan.op === "union") {
     if (delta < -EPS10) return null;
-    const intervals = profiles2.map((profile) => childInterval(profile, direction2, delta));
+    const intervals = profiles2.map((profile2) => childInterval(profile2, direction2, delta));
     if (intervals.some((interval) => !interval)) return null;
     const merged = normalizeIntervals2(intervals);
     return merged.length === 1 ? merged[0] : null;
@@ -75655,7 +76327,7 @@ function circularOffsetProfileProjectionIntervalAlongDirection(plan, direction2,
   if (plan.kind === "boolean" && plan.op === "union" && delta >= -EPS10) {
     const profiles2 = booleanProfilesWithParentTransforms2(plan);
     if (!profiles2 || profiles2.length === 0) return null;
-    const intervals = profiles2.map((profile) => circularOffsetProfileProjectionIntervalAlongDirection(profile, direction2, delta));
+    const intervals = profiles2.map((profile2) => circularOffsetProfileProjectionIntervalAlongDirection(profile2, direction2, delta));
     if (intervals.some((interval2) => !interval2)) return null;
     const merged = normalizeIntervals2(intervals);
     return merged.length === 1 ? merged[0] : null;
@@ -75672,7 +76344,7 @@ function miterOffsetProfileProjectionIntervalAlongCardinalDirection(plan, direct
   if (plan.kind === "boolean" && plan.op === "union" && delta >= -EPS10) {
     const profiles2 = booleanProfilesWithParentTransforms2(plan);
     if (!profiles2 || profiles2.length === 0) return null;
-    const intervals = profiles2.map((profile) => miterOffsetProfileProjectionIntervalAlongCardinalDirection(profile, direction2, delta));
+    const intervals = profiles2.map((profile2) => miterOffsetProfileProjectionIntervalAlongCardinalDirection(profile2, direction2, delta));
     if (intervals.some((interval2) => !interval2)) return null;
     const merged = normalizeIntervals2(intervals);
     return merged.length === 1 ? merged[0] : null;
@@ -75708,8 +76380,8 @@ function radialProjectionIntervalsForLoops(loops) {
 function booleanProfilesWithParentTransforms2(plan) {
   if (plan.transforms.length === 0) return plan.profiles;
   const profiles2 = [];
-  for (const profile of plan.profiles) {
-    const transformed = appendProfileCompileTransforms(profile, plan.transforms);
+  for (const profile2 of plan.profiles) {
+    const transformed = appendProfileCompileTransforms(profile2, plan.transforms);
     if (!transformed) return null;
     profiles2.push(transformed);
   }
@@ -75732,8 +76404,8 @@ function radialProjectionIntervalsForRevolveProfile2(plan) {
       if (!profiles2) return null;
       if (plan.op === "union") {
         const intervals = [];
-        for (const profile of profiles2) {
-          const profileIntervals = radialProjectionIntervalsForRevolveProfile2(profile);
+        for (const profile2 of profiles2) {
+          const profileIntervals = radialProjectionIntervalsForRevolveProfile2(profile2);
           if (!profileIntervals) return null;
           intervals.push(...profileIntervals);
         }
@@ -75963,9 +76635,9 @@ function insetRadialIntervalsForFullRevolutionProfile2(plan, distance5) {
       if (plan.op === "union") {
         const baseIntervalGroups = [];
         const insetIntervals = [];
-        for (const profile of profiles2) {
-          const baseIntervals = radialProjectionIntervalsForRevolveProfile2(profile);
-          const profileInsetIntervals = insetRadialIntervalsForFullRevolutionProfile2(profile, distance5);
+        for (const profile2 of profiles2) {
+          const baseIntervals = radialProjectionIntervalsForRevolveProfile2(profile2);
+          const profileInsetIntervals = insetRadialIntervalsForFullRevolutionProfile2(profile2, distance5);
           if (!baseIntervals || !profileInsetIntervals) return null;
           baseIntervalGroups.push(baseIntervals);
           insetIntervals.push(...profileInsetIntervals);
@@ -76010,11 +76682,11 @@ function revolveProjectionReplayContext(plan) {
       reason: "projection replay currently supports revolve sources only when the radial profile has finite non-negative rect/polygon/circle/rounded-rectangle outer footprints and contained difference holes."
     };
   }
-  const profile = isFullRevolution2(plan.degrees) ? radialIntervalsProjectionProfile(intervals, plan.segments) : partialRevolveProjectionProfile(intervals, plan.degrees, plan.segments);
-  if (!profile) {
+  const profile2 = isFullRevolution2(plan.degrees) ? radialIntervalsProjectionProfile(intervals, plan.segments) : partialRevolveProjectionProfile(intervals, plan.degrees, plan.segments);
+  if (!profile2) {
     return { ok: false, reason: "projection replay could not derive a non-empty revolve projection profile." };
   }
-  return { ok: true, context: defaultProjectionContext(profile) };
+  return { ok: true, context: defaultProjectionContext(profile2) };
 }
 function pointOnSegment2d2(point2, a, b) {
   const cross12 = (point2[0] - a[0]) * (b[1] - a[1]) - (point2[1] - a[1]) * (b[0] - a[0]);
@@ -76282,8 +76954,8 @@ function nestedPolygonProjectionProfile(profiles2) {
   const container = checked.find((candidate) => checked.every((subject) => loopContainsLoop2d(candidate.points, subject.points)));
   return container ? cloneProfileCompilePlan(container) : null;
 }
-function appendProfileCompileTransforms(profile, transforms) {
-  let next = cloneProfileCompilePlan(profile);
+function appendProfileCompileTransforms(profile2, transforms) {
+  let next = cloneProfileCompilePlan(profile2);
   for (const transform of transforms) {
     next = appendProfileCompileTransform(next, transform);
   }
@@ -76346,23 +77018,23 @@ function loftProjectionReplayContext(plan) {
   if (plan.heights.some((height) => !Number.isFinite(height))) {
     return { ok: false, reason: "projection replay requires finite loft heights." };
   }
-  const profile = nestedPolygonProjectionProfile(plan.profiles);
-  if (!profile) {
+  const profile2 = nestedPolygonProjectionProfile(plan.profiles);
+  if (!profile2) {
     return {
       ok: false,
       reason: "projection replay currently supports loft sources only when every section has a no-transform polygon footprint and one section contains all others."
     };
   }
-  return { ok: true, context: defaultProjectionContext(profile) };
+  return { ok: true, context: defaultProjectionContext(profile2) };
 }
 function sweepProjectionReplayContext(plan) {
   const transforms = verticalSweepFrameProfileTransforms(plan.path, plan.up);
   if (!transforms) {
     return { ok: false, reason: "projection replay currently supports sweep sources only for monotone vertical polyline paths." };
   }
-  const profile = appendProfileCompileTransforms(plan.profile, transforms);
-  if (!profile) return { ok: false, reason: "projection replay could not map the sweep profile into its vertical path frame." };
-  return { ok: true, context: defaultProjectionContext(profile) };
+  const profile2 = appendProfileCompileTransforms(plan.profile, transforms);
+  if (!profile2) return { ok: false, reason: "projection replay could not map the sweep profile into its vertical path frame." };
+  return { ok: true, context: defaultProjectionContext(profile2) };
 }
 function variableSweepProjectionReplayContext(plan) {
   const transforms = verticalSweepFrameProfileTransforms(plan.path, plan.up);
@@ -76376,14 +77048,14 @@ function variableSweepProjectionReplayContext(plan) {
   if (sortedT.some((t, idx) => idx > 0 && t <= sortedT[idx - 1] + EPS10)) {
     return { ok: false, reason: "projection replay requires distinct variable-sweep section parameters." };
   }
-  const profile = nestedPolygonProjectionProfile(plan.sections.map((section) => section.profile));
-  if (!profile) {
+  const profile2 = nestedPolygonProjectionProfile(plan.sections.map((section) => section.profile));
+  if (!profile2) {
     return {
       ok: false,
       reason: "projection replay currently supports variable sweep sources only when every section has a no-transform polygon footprint and one section contains all others."
     };
   }
-  const transformed = appendProfileCompileTransforms(profile, transforms);
+  const transformed = appendProfileCompileTransforms(profile2, transforms);
   if (!transformed)
     return { ok: false, reason: "projection replay could not map the variable-sweep profile into its vertical path frame." };
   return { ok: true, context: defaultProjectionContext(transformed) };
@@ -76520,8 +77192,8 @@ function transformedSphereProjectionReplayProfile(sourceShape, targetPlane) {
     return analyticPrimitive ? transformedSphereProjectionReplayProfile(analyticPrimitive, targetPlane) : null;
   }
   if (source.kind === "sphere") {
-    const profile2 = sphereProjectionProfileAtCenter(source.radius, source.segments, [0, 0, 0], targetPlane);
-    return { profile: profile2, placement: targetPlanePlacement(targetPlane) };
+    const profile3 = sphereProjectionProfileAtCenter(source.radius, source.segments, [0, 0, 0], targetPlane);
+    return { profile: profile3, placement: targetPlanePlacement(targetPlane) };
   }
   if (source.kind !== "transform") return null;
   const base = unwrapQueryOwnerPlan3(source.base);
@@ -76535,8 +77207,8 @@ function transformedSphereProjectionReplayProfile(sourceShape, targetPlane) {
     distanceScale *= next.scale;
   }
   const center = transform.point([0, 0, 0]);
-  const profile = sphereProjectionProfileAtCenter(base.radius * distanceScale, base.segments, center, targetPlane);
-  return { profile, placement: targetPlanePlacement(targetPlane) };
+  const profile2 = sphereProjectionProfileAtCenter(base.radius * distanceScale, base.segments, center, targetPlane);
+  return { profile: profile2, placement: targetPlanePlacement(targetPlane) };
 }
 function targetPlaneSpecificProjectionReplayContext(sourceShape, targetPlane) {
   const boxReplay = transformedBoxProjectionReplayProfile(sourceShape, targetPlane);
@@ -76599,9 +77271,9 @@ function targetPlaneSpecificProjectionReplayContext(sourceShape, targetPlane) {
     profiles2.push(replay.profile);
   }
   if (!usedTargetPlaneSpecificReplay) return null;
-  const profile = buildBooleanProfileCompilePlan("union", profiles2);
-  return profile ? {
-    profile,
+  const profile2 = buildBooleanProfileCompilePlan("union", profiles2);
+  return profile2 ? {
+    profile: profile2,
     placement: targetPlanePlacement(targetPlane),
     usedTargetPlaneSpecificReplay
   } : null;
@@ -76719,8 +77391,8 @@ function offsetSolidFromSlicesLoftProjectionReplayContext(plan) {
   if (zMax <= zMin + EPS10) {
     return { ok: false, reason: "projection replay cannot derive a collapsed offsetSolid(Shape.fromSlices(...)) vertical span." };
   }
-  const profile = nestedPolygonProjectionProfile(sorted.map((slice) => slice.profile));
-  if (!profile) {
+  const profile2 = nestedPolygonProjectionProfile(sorted.map((slice) => slice.profile));
+  if (!profile2) {
     return {
       ok: false,
       reason: "projection replay currently supports offsetSolid(Shape.fromSlices(...)) lofts only when every slice has a no-transform polygon footprint and one contains all others."
@@ -76729,7 +77401,7 @@ function offsetSolidFromSlicesLoftProjectionReplayContext(plan) {
   return {
     ok: true,
     context: {
-      profile: buildOffsetProfileCompilePlan(profile, plan.thickness, "Miter"),
+      profile: buildOffsetProfileCompilePlan(profile2, plan.thickness, "Miter"),
       placement
     }
   };
@@ -76809,8 +77481,8 @@ function offsetSolidFullRevolutionProjectionReplayContext(plan) {
       reason: "projection replay could not derive non-empty radial intervals for the offset revolved solid."
     };
   }
-  const profile = radialIntervalsProjectionProfile(offsetIntervals, source.context.plan.segments);
-  return profile ? { ok: true, context: { profile, placement: cloneShapeWorkplanePlacement(source.context.placement) } } : { ok: false, reason: "projection replay could not build a profile for the offset revolved solid." };
+  const profile2 = radialIntervalsProjectionProfile(offsetIntervals, source.context.plan.segments);
+  return profile2 ? { ok: true, context: { profile: profile2, placement: cloneShapeWorkplanePlacement(source.context.placement) } } : { ok: false, reason: "projection replay could not build a profile for the offset revolved solid." };
 }
 function offsetSolidProjectionReplayContext(plan) {
   if (!Number.isFinite(plan.thickness) || nearlyEqual(plan.thickness, 0)) {
@@ -76845,9 +77517,9 @@ function offsetSolidProjectionReplayContext(plan) {
 function holeProjectionRadius(plan) {
   return Math.max(plan.hole.radius, plan.hole.counterbore?.radius ?? 0, plan.hole.countersink?.radius ?? 0);
 }
-function defaultProjectionContext(profile) {
+function defaultProjectionContext(profile2) {
   return {
-    profile: cloneProfileCompilePlan(profile),
+    profile: cloneProfileCompilePlan(profile2),
     placement: cloneShapeWorkplanePlacement(DEFAULT_PROJECTION_PLACEMENT)
   };
 }
@@ -76874,14 +77546,14 @@ function projectThroughHoleIntoContext(base, plan) {
       reason: `projection replay can only absorb hole rewrites when the hole axis stays parallel to the projected source basis. ${mapped.reason ?? ""}`.trim()
     };
   }
-  const profile = buildBooleanProfileCompilePlan("difference", [base.profile, mapped.profile]);
-  if (!profile) {
+  const profile2 = buildBooleanProfileCompilePlan("difference", [base.profile, mapped.profile]);
+  if (!profile2) {
     return { ok: false, reason: "projection replay could not subtract the hole silhouette from the projected source profile." };
   }
   return {
     ok: true,
     context: {
-      profile,
+      profile: profile2,
       placement: cloneShapeWorkplanePlacement(base.placement)
     }
   };
@@ -76894,14 +77566,14 @@ function projectThroughCutIntoContext(base, plan) {
       reason: `projection replay can only absorb cut rewrites when the cut workplane stays parallel to the projected source basis. ${mapped.reason ?? ""}`.trim()
     };
   }
-  const profile = buildBooleanProfileCompilePlan("difference", [base.profile, mapped.profile]);
-  if (!profile) {
+  const profile2 = buildBooleanProfileCompilePlan("difference", [base.profile, mapped.profile]);
+  if (!profile2) {
     return { ok: false, reason: "projection replay could not subtract the cut silhouette from the projected source profile." };
   }
   return {
     ok: true,
     context: {
-      profile,
+      profile: profile2,
       placement: cloneShapeWorkplanePlacement(base.placement)
     }
   };
@@ -77028,14 +77700,14 @@ function buildProjectionReplayContext(plan) {
         }
         unionProfiles.push(reoriented.context.profile);
       }
-      const profile = buildBooleanProfileCompilePlan("union", unionProfiles);
-      if (!profile) {
+      const profile2 = buildBooleanProfileCompilePlan("union", unionProfiles);
+      if (!profile2) {
         return { ok: false, reason: "projection replay could not combine the projected union operands into one 2D profile." };
       }
       return {
         ok: true,
         context: {
-          profile,
+          profile: profile2,
           placement: targetPlacement
         }
       };
@@ -77046,8 +77718,8 @@ function buildProjectionReplayContext(plan) {
         context: defaultProjectionContext(circleProjectionProfile(plan.radius, plan.segments))
       };
     case "torus": {
-      const profile = annulusProjectionProfile(plan.majorRadius + plan.minorRadius, plan.majorRadius - plan.minorRadius, plan.segments);
-      return profile ? { ok: true, context: defaultProjectionContext(profile) } : { ok: false, reason: "projection replay could not derive a non-empty torus annulus profile." };
+      const profile2 = annulusProjectionProfile(plan.majorRadius + plan.minorRadius, plan.majorRadius - plan.minorRadius, plan.segments);
+      return profile2 ? { ok: true, context: defaultProjectionContext(profile2) } : { ok: false, reason: "projection replay could not derive a non-empty torus annulus profile." };
     }
     case "sheetMetal":
       return {
@@ -79514,8 +80186,8 @@ var ConstrainedSketchBuilder = class _ConstrainedSketchBuilder {
         if (err2 >= 0 && err2 <= DEFAULT_TOLERANCE3 * 100) {
           this.syncPointsFromSession();
         }
-      } catch (error) {
-        if (this.strict) throw error;
+      } catch (error2) {
+        if (this.strict) throw error2;
       }
       return;
     }
@@ -79541,8 +80213,8 @@ var ConstrainedSketchBuilder = class _ConstrainedSketchBuilder {
       if (Number.isFinite(maxError) && maxError <= DEFAULT_TOLERANCE3 * 100) {
         this.syncFromDefinition(working);
       }
-    } catch (error) {
-      if (this.strict) throw error;
+    } catch (error2) {
+      if (this.strict) throw error2;
     }
   }
   /** Serialize a constraint for the session API (matches Rust serde format). */
@@ -82962,8 +83634,8 @@ function applyAxisRail(bounds, axis, minRail, maxRail, center) {
     bounds[maxKey] = center + width / 2;
   }
 }
-function fitProfileToBounds(profile, target) {
-  const source = sketchBounds(profile);
+function fitProfileToBounds(profile2, target) {
+  const source = sketchBounds(profile2);
   const sourceWidth = source.maxX - source.minX;
   const sourceDepth = source.maxY - source.minY;
   if (sourceWidth < LOFT_GUIDE_EPS || sourceDepth < LOFT_GUIDE_EPS) {
@@ -82971,10 +83643,10 @@ function fitProfileToBounds(profile, target) {
   }
   const sourceCenter = [(source.minX + source.maxX) / 2, (source.minY + source.maxY) / 2];
   const targetCenter = [(target.minX + target.maxX) / 2, (target.minY + target.maxY) / 2];
-  return profile.scaleAround(sourceCenter, [(target.maxX - target.minX) / sourceWidth, (target.maxY - target.minY) / sourceDepth]).translate(targetCenter[0] - sourceCenter[0], targetCenter[1] - sourceCenter[1]);
+  return profile2.scaleAround(sourceCenter, [(target.maxX - target.minX) / sourceWidth, (target.maxY - target.minY) / sourceDepth]).translate(targetCenter[0] - sourceCenter[0], targetCenter[1] - sourceCenter[1]);
 }
-function sketchBounds(profile) {
-  const bounds = profile.bounds();
+function sketchBounds(profile2) {
+  const bounds = profile2.bounds();
   return { minX: bounds.min[0], maxX: bounds.max[0], minY: bounds.min[1], maxY: bounds.max[1] };
 }
 function lerpBounds(a, b, t) {
@@ -83029,9 +83701,9 @@ function fieldLoftMeshingOptions(options) {
 }
 var Loft = {
   /** Create a loft station from a 2D profile and an axis position. */
-  station(profile, position) {
+  station(profile2, position) {
     if (!Number.isFinite(position)) throw new Error("Loft.station position must be finite");
-    return { profile, position };
+    return { profile: profile2, position };
   },
   /**
    * Loft by interpolating signed-distance fields instead of matching vertices.
@@ -85670,11 +86342,11 @@ function parseSvgGeometry(svgText, options) {
       continue;
     }
     const selfClosing = rawTag.endsWith("/>");
-    const body = rawTag.slice(1, rawTag.length - (selfClosing ? 2 : 1)).trim();
-    if (!body) continue;
-    const space = body.search(/\s/);
-    const tag = (space < 0 ? body : body.slice(0, space)).toLowerCase();
-    const attrText = space < 0 ? "" : body.slice(space + 1);
+    const body2 = rawTag.slice(1, rawTag.length - (selfClosing ? 2 : 1)).trim();
+    if (!body2) continue;
+    const space = body2.search(/\s/);
+    const tag = (space < 0 ? body2 : body2.slice(0, space)).toLowerCase();
+    const attrText = space < 0 ? "" : body2.slice(space + 1);
     const attrs = parseAttributes(attrText);
     const parent = stack[stack.length - 1].ctx;
     const mergedStyle = mergeStyle(parent.style, attrs);
@@ -85913,31 +86585,31 @@ function extractFaceProfile(rawShape, face) {
 function shapePocket(rawShape, face, depth, opts) {
   const faceRef = rawShape.face(face);
   const frame = resolvePlaneFrame({ face: faceRef });
-  let profile = extractFaceProfile(rawShape, faceRef);
+  let profile2 = extractFaceProfile(rawShape, faceRef);
   if (opts?.inset) {
-    profile = sketchOffset(profile, -opts.inset, opts.join ?? "Round");
+    profile2 = sketchOffset(profile2, -opts.inset, opts.join ?? "Round");
   } else if (opts?.scale != null && opts.scale !== 1) {
-    profile = profile.scale(opts.scale);
+    profile2 = profile2.scale(opts.scale);
   }
   const worldToPlane = planeFrameToWorldToPlaneMatrix(frame);
   const planeToWorld = Transform.from(worldToPlane).inverse();
   const inwardShift = Transform.translation(0, 0, -depth);
   const toolTransform = Transform.compose(inwardShift, planeToWorld).toArray();
-  const tool = profile.extrude(depth).transform(toolTransform);
+  const tool = profile2.extrude(depth).transform(toolTransform);
   return rawShape.subtract(tool);
 }
 function shapeBoss(rawShape, face, height, opts) {
   const faceRef = rawShape.face(face);
   const frame = resolvePlaneFrame({ face: faceRef });
-  let profile = extractFaceProfile(rawShape, faceRef);
+  let profile2 = extractFaceProfile(rawShape, faceRef);
   if (opts?.inset) {
-    profile = sketchOffset(profile, -opts.inset, opts.join ?? "Round");
+    profile2 = sketchOffset(profile2, -opts.inset, opts.join ?? "Round");
   } else if (opts?.scale != null && opts.scale !== 1) {
-    profile = profile.scale(opts.scale);
+    profile2 = profile2.scale(opts.scale);
   }
   const worldToPlane = planeFrameToWorldToPlaneMatrix(frame);
   const planeToWorld = Transform.from(worldToPlane).inverse();
-  const tool = profile.extrude(height).transform(planeToWorld.toArray());
+  const tool = profile2.extrude(height).transform(planeToWorld.toArray());
   return rawShape.add(tool);
 }
 Shape.prototype.pocket = function pocket(face, depth, opts) {
@@ -86318,13 +86990,62 @@ function sheetMetal(options) {
   return new SheetMetalPart(model);
 }
 
+// src/forge/import/sourceFrame.ts
+var SOURCE_FRAME_UP_AXES = ["+X", "-X", "+Y", "-Y", "+Z", "-Z"];
+function isRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sourceFrameErrorContext(importKind, fileName) {
+  return `${importKind}("${fileName}")`;
+}
+function requireSourceFrameUp(importKind, fileName, sourceFrame) {
+  if (sourceFrame === void 0) return null;
+  const context = sourceFrameErrorContext(importKind, fileName);
+  if (!isRecord(sourceFrame)) throw new Error(`${context}: sourceFrame must be an object with an "up" axis`);
+  const keys = Object.keys(sourceFrame);
+  if (keys.some((key) => key !== "up")) {
+    throw new Error(
+      `${context}: sourceFrame only supports "up"; remove unsupported keys: ${keys.filter((key) => key !== "up").join(", ")}`
+    );
+  }
+  if (!Object.prototype.hasOwnProperty.call(sourceFrame, "up")) throw new Error(`${context}: sourceFrame.up is required`);
+  const up = sourceFrame.up;
+  if (typeof up !== "string" || !SOURCE_FRAME_UP_AXES.includes(up)) {
+    throw new Error(`${context}: sourceFrame.up must be one of ${SOURCE_FRAME_UP_AXES.join(", ")}, got ${JSON.stringify(up)}`);
+  }
+  return up;
+}
+function sourceFrameTransformStep(importKind, fileName, sourceFrame) {
+  const up = requireSourceFrameUp(importKind, fileName, sourceFrame);
+  switch (up) {
+    case null:
+    case "+Z":
+      return null;
+    case "-Z":
+      return { kind: "rotateAround", axisX: 1, axisY: 0, axisZ: 0, degrees: 180, pivotX: 0, pivotY: 0, pivotZ: 0 };
+    case "+Y":
+      return { kind: "rotateAround", axisX: 1, axisY: 0, axisZ: 0, degrees: 90, pivotX: 0, pivotY: 0, pivotZ: 0 };
+    case "-Y":
+      return { kind: "rotateAround", axisX: 1, axisY: 0, axisZ: 0, degrees: -90, pivotX: 0, pivotY: 0, pivotZ: 0 };
+    case "+X":
+      return { kind: "rotateAround", axisX: 0, axisY: 1, axisZ: 0, degrees: -90, pivotX: 0, pivotY: 0, pivotZ: 0 };
+    case "-X":
+      return { kind: "rotateAround", axisX: 0, axisY: 1, axisZ: 0, degrees: 90, pivotX: 0, pivotY: 0, pivotZ: 0 };
+  }
+}
+function applySourceFrameToShapePlan(plan, importKind, fileName, sourceFrame) {
+  const step = sourceFrameTransformStep(importKind, fileName, sourceFrame);
+  return step ? appendShapeCompileTransform(plan, step) : plan;
+}
+
 // src/forge/import/importStep.ts
-function importStepFromBuffer(fileData, displayName = "import.step") {
-  return buildShapeFromCompilePlan(
-    createOwnedShapeCompilePlan({ kind: "importedStep", filePath: displayName, fileData }, "importStep"),
-    void 0,
-    { fidelity: "exact", sources: ["imported"] }
-  );
+function importStepFromBuffer(fileData, displayName = "import.step", options = {}) {
+  let plan = { kind: "importedStep", filePath: displayName, fileData };
+  plan = applySourceFrameToShapePlan(plan, "Import.step", displayName, options.sourceFrame);
+  return buildShapeFromCompilePlan(createOwnedShapeCompilePlan(plan, "importStep"), void 0, {
+    fidelity: "exact",
+    sources: ["imported"]
+  });
 }
 
 // src/forge/export/sheetStock.ts
@@ -86337,9 +87058,9 @@ function resetSheetStock() {
 function getCollectedSheetStock() {
   return collectedSheetStock;
 }
-function normalizeMaterial(material) {
-  if (typeof material !== "string") return "sheet stock";
-  const value = material.trim();
+function normalizeMaterial(material2) {
+  if (typeof material2 !== "string") return "sheet stock";
+  const value = material2.trim();
   return value.length > 0 ? value : "sheet stock";
 }
 function sheetStock(width, height, description, opts) {
@@ -86368,14 +87089,14 @@ function sheetStock(width, height, description, opts) {
 }
 
 // src/forge/laserKit/joints.ts
-function requireFinite11(value, name) {
+function requireFinite12(value, name) {
   if (!Number.isFinite(value)) {
     throw new Error(`${name} must be a finite number, got ${value}`);
   }
   return value;
 }
-function requirePositive8(value, name) {
-  requireFinite11(value, name);
+function requirePositive9(value, name) {
+  requireFinite12(value, name);
   if (value <= 0) {
     throw new Error(`${name} must be positive, got ${value}`);
   }
@@ -86388,10 +87109,10 @@ function requireOdd(value, name) {
   return value;
 }
 function fingerJointProfile(length7, thickness, options = {}) {
-  requirePositive8(length7, "length");
-  requirePositive8(thickness, "thickness");
-  const clearance = requireFinite11(options.clearance ?? 0, "clearance");
-  const kerf = requireFinite11(options.kerf ?? 0, "kerf");
+  requirePositive9(length7, "length");
+  requirePositive9(thickness, "thickness");
+  const clearance = requireFinite12(options.clearance ?? 0, "clearance");
+  const kerf = requireFinite12(options.kerf ?? 0, "kerf");
   const endStyle = options.endStyle ?? "full";
   let fingers;
   if (options.fingers != null) {
@@ -86400,7 +87121,7 @@ function fingerJointProfile(length7, thickness, options = {}) {
     fingers = Math.max(3, Math.round(length7 / (2 * thickness)) | 1);
     if (fingers % 2 === 0) fingers += 1;
   }
-  const fingerWidth = options.fingerWidth != null ? requirePositive8(options.fingerWidth, "fingerWidth") : length7 / (2 * fingers - 1);
+  const fingerWidth = options.fingerWidth != null ? requirePositive9(options.fingerWidth, "fingerWidth") : length7 / (2 * fingers - 1);
   const halfKerf = kerf / 2;
   const evenFingers = [];
   const oddFingers = [];
@@ -86452,13 +87173,13 @@ function fingerJointProfile(length7, thickness, options = {}) {
   return { tabProfile, matingProfile, slotProfile };
 }
 function tabSlotProfile(length7, thickness, options = {}) {
-  requirePositive8(length7, "length");
-  requirePositive8(thickness, "thickness");
-  const clearance = requireFinite11(options.clearance ?? 0, "clearance");
-  const kerf = requireFinite11(options.kerf ?? 0, "kerf");
-  const inset = requirePositive8(options.inset ?? thickness, "inset");
-  const tabWidth = requirePositive8(options.tabWidth ?? 2 * thickness, "tabWidth");
-  const tabCountRaw = options.tabCount != null ? requireFinite11(options.tabCount, "tabCount") : length7 / (4 * thickness);
+  requirePositive9(length7, "length");
+  requirePositive9(thickness, "thickness");
+  const clearance = requireFinite12(options.clearance ?? 0, "clearance");
+  const kerf = requireFinite12(options.kerf ?? 0, "kerf");
+  const inset = requirePositive9(options.inset ?? thickness, "inset");
+  const tabWidth = requirePositive9(options.tabWidth ?? 2 * thickness, "tabWidth");
+  const tabCountRaw = options.tabCount != null ? requireFinite12(options.tabCount, "tabCount") : length7 / (4 * thickness);
   const tabCount = Math.max(1, Math.round(tabCountRaw));
   const halfKerf = kerf / 2;
   const usableLength = length7 - 2 * inset;
@@ -86508,20 +87229,20 @@ function kerfCompensateSlots(sketch, kerf) {
 }
 function kerfCompensatePart(baseProfile, joints, kerf) {
   requireFiniteKerf(kerf);
-  let profile = baseProfile;
+  let profile2 = baseProfile;
   if (joints.additions) {
     for (const tab of joints.additions) {
       const compensated = kerfCompensateTabs(tab, kerf);
-      profile = profile.add(compensated);
+      profile2 = profile2.add(compensated);
     }
   }
   if (joints.subtractions) {
     for (const slot2 of joints.subtractions) {
       const compensated = kerfCompensateSlots(slot2, kerf);
-      profile = profile.subtract(compensated);
+      profile2 = profile2.subtract(compensated);
     }
   }
-  return kerfCompensateOutline(profile, kerf);
+  return kerfCompensateOutline(profile2, kerf);
 }
 var COMMON_KERFS_DATA = [
   // Plywood
@@ -86541,22 +87262,22 @@ var COMMON_KERFS_DATA = [
   { material: "cardboard", thickness: 3, kerf: 0.15, laserType: "CO2-40W" }
 ];
 var COMMON_KERFS = COMMON_KERFS_DATA;
-function lookupKerf(material, thickness, laserType) {
+function lookupKerf(material2, thickness, laserType) {
   const entry = COMMON_KERFS_DATA.find(
-    (e) => e.material === material && e.thickness === thickness && (laserType === void 0 || e.laserType === laserType)
+    (e) => e.material === material2 && e.thickness === thickness && (laserType === void 0 || e.laserType === laserType)
   );
   return entry?.kerf;
 }
 
 // src/forge/laserKit/flatPart.ts
-function requireFinite12(value, name) {
+function requireFinite13(value, name) {
   if (!Number.isFinite(value)) {
     throw new Error(`${name} must be a finite number, got ${value}`);
   }
   return value;
 }
-function requirePositive9(value, name) {
-  requireFinite12(value, name);
+function requirePositive10(value, name) {
+  requireFinite13(value, name);
   if (value <= 0) {
     throw new Error(`${name} must be positive, got ${value}`);
   }
@@ -86580,7 +87301,7 @@ var FlatPart = class {
   _partNumber = 0;
   constructor(name, baseProfile, thickness, edges, options) {
     requireNonEmpty(name, "name");
-    requirePositive9(thickness, "thickness");
+    requirePositive10(thickness, "thickness");
     if (baseProfile.area() <= 0) {
       throw new Error(`FlatPart "${name}" baseProfile must have positive area`);
     }
@@ -86650,14 +87371,14 @@ var FlatPart = class {
     return this.profile(kerf).extrude(this.thickness);
   }
 };
-function positionAlongEdge(profile, edge, inward = false) {
+function positionAlongEdge(profile2, edge, inward = false) {
   const nx = inward ? -edge.normal[0] : edge.normal[0];
   const ny = inward ? -edge.normal[1] : edge.normal[1];
   const angle = Math.atan2(-nx, ny) * (180 / Math.PI);
   const edx = (edge.end[0] - edge.start[0]) / edge.length;
   const edy = (edge.end[1] - edge.start[1]) / edge.length;
   const dot12 = ny * edx + -nx * edy;
-  const rotated = profile.rotateAround(angle, [0, 0]);
+  const rotated = profile2.rotateAround(angle, [0, 0]);
   if (dot12 > 0) {
     return rotated.translate(edge.start[0], edge.start[1]);
   } else {
@@ -86665,20 +87386,20 @@ function positionAlongEdge(profile, edge, inward = false) {
   }
 }
 function flatPanel(name, width, height, thickness, options) {
-  requirePositive9(width, "width");
-  requirePositive9(height, "height");
-  requirePositive9(thickness, "thickness");
-  const profile = rect(width, height);
+  requirePositive10(width, "width");
+  requirePositive10(height, "height");
+  requirePositive10(thickness, "thickness");
+  const profile2 = rect(width, height);
   const edges = /* @__PURE__ */ new Map([
     ["bottom", { name: "bottom", start: [0, 0], end: [width, 0], length: width, normal: [0, -1] }],
     ["right", { name: "right", start: [width, 0], end: [width, height], length: height, normal: [1, 0] }],
     ["top", { name: "top", start: [width, height], end: [0, height], length: width, normal: [0, 1] }],
     ["left", { name: "left", start: [0, height], end: [0, 0], length: height, normal: [-1, 0] }]
   ]);
-  return new FlatPart(name, profile, thickness, edges, options);
+  return new FlatPart(name, profile2, thickness, edges, options);
 }
-function flatPart(name, profile, thickness, edges, options) {
-  requirePositive9(thickness, "thickness");
+function flatPart(name, profile2, thickness, edges, options) {
+  requirePositive10(thickness, "thickness");
   const edgeMap = /* @__PURE__ */ new Map();
   if (edges) {
     for (const [eName, e] of Object.entries(edges)) {
@@ -86693,7 +87414,7 @@ function flatPart(name, profile, thickness, edges, options) {
       edgeMap.set(eName, { name: eName, start: e.start, end: e.end, length: len2, normal: [nx, ny] });
     }
   }
-  return new FlatPart(name, profile, thickness, edgeMap, options);
+  return new FlatPart(name, profile2, thickness, edgeMap, options);
 }
 function fingerJoint(partA, edgeNameA, partB, edgeNameB, options) {
   const edgeA = partA.edge(edgeNameA);
@@ -86793,10 +87514,10 @@ function groupByMaterial(pieces) {
   }
   return groups;
 }
-function createEmptySheet(sheetIndex, material, sheetWidth, sheetHeight) {
+function createEmptySheet(sheetIndex, material2, sheetWidth, sheetHeight) {
   return {
     sheetIndex,
-    material,
+    material: material2,
     pieces: [],
     sheetWidth,
     sheetHeight,
@@ -87160,7 +87881,7 @@ function packSingleSheetExact(pieces, sheetW, sheetH, kerf) {
     usedArea: bestUsedArea
   };
 }
-function packMaterialGroupExact(pieces, sheetW, sheetH, material, kerf) {
+function packMaterialGroupExact(pieces, sheetW, sheetH, material2, kerf) {
   const sheets = [];
   let remainingPieces = [...pieces];
   while (remainingPieces.length > 0) {
@@ -87176,7 +87897,7 @@ function packMaterialGroupExact(pieces, sheetW, sheetH, material, kerf) {
       continue;
     }
     sheets.push({
-      ...createEmptySheet(sheets.length, material, sheetW, sheetH),
+      ...createEmptySheet(sheets.length, material2, sheetW, sheetH),
       pieces: searchResult.placedPieces.map((placedPiece) => ({ ...placedPiece.packed })),
       usedArea: searchResult.usedArea
     });
@@ -87185,10 +87906,10 @@ function packMaterialGroupExact(pieces, sheetW, sheetH, material, kerf) {
   }
   return sheets;
 }
-function packMaterialGroup(pieces, sheetW, sheetH, material, kerf) {
+function packMaterialGroup(pieces, sheetW, sheetH, material2, kerf) {
   const sorted = [...pieces].sort((a, b) => b.width * b.height - a.width * a.height);
   if (sorted.length <= EXACT_SHEET_SEARCH_MAX_PIECES) {
-    const sheets = packMaterialGroupExact(sorted, sheetW, sheetH, material, kerf);
+    const sheets = packMaterialGroupExact(sorted, sheetW, sheetH, material2, kerf);
     for (const sheet of sheets) {
       sheet.cuts = computeSheetCutSequence(sheet);
     }
@@ -87304,8 +88025,8 @@ function computeCuttingLayout(entries, sheetWidth, sheetHeight, kerf = 0) {
   const expanded = expandPieces(entries);
   const groups = groupByMaterial(expanded);
   const allSheets = [];
-  for (const [material, pieces] of groups) {
-    const sheets = packMaterialGroup(pieces, sheetWidth, sheetHeight, material, kerf);
+  for (const [material2, pieces] of groups) {
+    const sheets = packMaterialGroup(pieces, sheetWidth, sheetHeight, material2, kerf);
     allSheets.push(...sheets);
   }
   allSheets.forEach((s, i) => {
@@ -87639,13 +88360,13 @@ function renderSummaryPage(layout, sheetWidth, sheetHeight) {
     arr.push(s);
   }
   cmd.push(commandSetFill([0.14, 0.14, 0.16]));
-  for (const [material, sheets] of byMaterial) {
+  for (const [material2, sheets] of byMaterial) {
     const usedArea = sheets.reduce((s, sh) => s + sh.usedArea, 0);
     const totalArea = sheets.length * sheetWidth * sheetHeight;
     const waste = totalArea > 0 ? (totalArea - usedArea) / totalArea * 100 : 0;
     const matCuts = sheets.reduce((s, sh) => s + sh.cuts.length, 0);
     const matCutLen = sheets.reduce((s, sh) => s + sh.cuts.reduce((cs, c) => cs + c.lengthMm, 0), 0);
-    cmd.push(commandText(material, colMaterial + 4, tableY, 9));
+    cmd.push(commandText(material2, colMaterial + 4, tableY, 9));
     cmd.push(commandText(String(sheets.length), colSheets + 4, tableY, 9));
     cmd.push(commandText(`${matCuts} (${formatNumber2(matCutLen)} mm)`, colCuts + 4, tableY, 9));
     cmd.push(commandText(formatNumber2(usedArea), colArea + 4, tableY, 9));
@@ -88225,8 +88946,8 @@ var LaserKit = class {
     const pieces = [];
     let idCounter = 0;
     for (const { part, qty } of this._parts) {
-      const profile = part.profile(this.kerf);
-      const bounds = getSketchBounds(profile);
+      const profile2 = part.profile(this.kerf);
+      const bounds = getSketchBounds(profile2);
       const w = bounds.maxX - bounds.minX;
       const h = bounds.maxY - bounds.minY;
       idCounter++;
@@ -88244,8 +88965,8 @@ var LaserKit = class {
   /** Bill of materials listing every part with dimensions. */
   bom() {
     return this._parts.map(({ part, qty }) => {
-      const profile = part.profile(this.kerf);
-      const bounds = getSketchBounds(profile);
+      const profile2 = part.profile(this.kerf);
+      const bounds = getSketchBounds(profile2);
       return {
         partNumber: part.partNumber,
         name: part.name,
@@ -88260,8 +88981,8 @@ var LaserKit = class {
   partSvgs() {
     const result = /* @__PURE__ */ new Map();
     for (const { part } of this._parts) {
-      const profile = part.profile(this.kerf);
-      const svg = sketchToSvg(profile, { strokeWidth: 0.1, padding: 1 });
+      const profile2 = part.profile(this.kerf);
+      const svg = sketchToSvg(profile2, { strokeWidth: 0.1, padding: 1 });
       result.set(part.name, svg);
     }
     return result;
@@ -88275,13 +88996,13 @@ var LaserKit = class {
     let maxCellH = 0;
     const partData = [];
     for (const { part, qty } of this._parts) {
-      const profile = part.profile(this.kerf);
-      const bounds = getSketchBounds(profile);
+      const profile2 = part.profile(this.kerf);
+      const bounds = getSketchBounds(profile2);
       const w = bounds.maxX - bounds.minX;
       const h = bounds.maxY - bounds.minY;
       maxCellW = Math.max(maxCellW, w);
       maxCellH = Math.max(maxCellH, h);
-      const polys = profile.toPolygons();
+      const polys = profile2.toPolygons();
       const pathParts = [];
       for (const loop of polys) {
         if (loop.length < 2) continue;
@@ -88407,7 +89128,7 @@ var Laser = {
    * @returns A new FlatPart with the given named edges.
    * @category Laser Cutting
    */
-  part: (name, profile, thickness, edges, options) => flatPart(name, profile, thickness, edges, options),
+  part: (name, profile2, thickness, edges, options) => flatPart(name, profile2, thickness, edges, options),
   /**
    * Connect two parts with finger joints along the named edges.
    *
@@ -88503,7 +89224,7 @@ var Laser = {
    * @returns Full kerf width in mm, or `undefined`.
    * @category Laser Cutting
    */
-  lookupKerf: (material, thickness, laserType) => lookupKerf(material, thickness, laserType),
+  lookupKerf: (material2, thickness, laserType) => lookupKerf(material2, thickness, laserType),
   /**
    * Common full-kerf values by material, thickness, and laser type.
    *
@@ -89980,9 +90701,9 @@ var LOG_MAX_DEPTH = 4;
 var LOG_MAX_ARRAY_ITEMS = 24;
 var LOG_MAX_OBJECT_KEYS = 32;
 var LOG_NUMBER_PRECISION = 4;
-function formatLogError(error) {
-  if (error instanceof Error) return `${error.name}: ${error.message}`;
-  return String(error);
+function formatLogError(error2) {
+  if (error2 instanceof Error) return `${error2.name}: ${error2.message}`;
+  return String(error2);
 }
 function roundLogNumber(value) {
   return Number(value.toFixed(LOG_NUMBER_PRECISION));
@@ -90008,28 +90729,28 @@ function summarizeShapeForLog(shape) {
     if (min2.length === max4.length && min2.length > 0) {
       summary.size = min2.map((value, index) => roundLogNumber(max4[index] - value));
     }
-  } catch (error) {
-    summary.bboxError = formatLogError(error);
+  } catch (error2) {
+    summary.bboxError = formatLogError(error2);
   }
   try {
     summary.volume = roundLogNumber(shape.volume());
-  } catch (error) {
-    summary.volumeError = formatLogError(error);
+  } catch (error2) {
+    summary.volumeError = formatLogError(error2);
   }
   try {
     summary.surfaceArea = roundLogNumber(shape.surfaceArea());
-  } catch (error) {
-    summary.surfaceAreaError = formatLogError(error);
+  } catch (error2) {
+    summary.surfaceAreaError = formatLogError(error2);
   }
   try {
     summary.triangles = shape.numTri();
-  } catch (error) {
-    summary.triangleError = formatLogError(error);
+  } catch (error2) {
+    summary.triangleError = formatLogError(error2);
   }
   try {
     summary.isEmpty = shape.isEmpty();
-  } catch (error) {
-    summary.isEmptyError = formatLogError(error);
+  } catch (error2) {
+    summary.isEmptyError = formatLogError(error2);
   }
   return summary;
 }
@@ -90104,8 +90825,8 @@ function formatLogArg(value) {
     const inspected = inspectForLog(value);
     if (typeof inspected === "string") return inspected;
     return JSON.stringify(inspected, null, 2);
-  } catch (error) {
-    return `[Log serialization failed: ${formatLogError(error)}]`;
+  } catch (error2) {
+    return `[Log serialization failed: ${formatLogError(error2)}]`;
   }
 }
 function makeSandboxConsole(collectedLogs, mirror) {
@@ -91401,6 +92122,9 @@ function attachAssemblySource(runResult, result) {
   }
   return runResult;
 }
+function getRunResultAssemblySource(runResult) {
+  return runResult[RUN_RESULT_ASSEMBLY_SOURCE] ?? null;
+}
 var FORGE_RUNTIME_MODULE_SPECIFIERS = /* @__PURE__ */ new Set(["forgecad", "@forge/runtime", "@forgecad/runtime"]);
 var MAX_PERSISTENT_COMPILED_FILES = 256;
 var persistentCompiledFiles = /* @__PURE__ */ new Map();
@@ -91523,12 +92247,12 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
           verts: result.numVert()
         });
         return result;
-      } catch (error) {
+      } catch (error2) {
         logImportTrace(_collectedLogs, fileName, scope, options, "Import.svgSketch", resolvedPath, "error", {
           requested: name,
-          error: formatLogError(error)
+          error: formatLogError(error2)
         });
-        throw error;
+        throw error2;
       }
     };
     const importDxfSketch = (name, optionsArg) => {
@@ -91550,12 +92274,12 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
           verts: result.numVert()
         });
         return result;
-      } catch (error) {
+      } catch (error2) {
         logImportTrace(_collectedLogs, fileName, scope, options, "Import.dxfSketch", resolvedPath, "error", {
           requested: name,
-          error: formatLogError(error)
+          error: formatLogError(error2)
         });
-        throw error;
+        throw error2;
       }
     };
     const importMesh = (name, meshOptions) => {
@@ -91569,6 +92293,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
         const ext = resolvedPath.split(".").pop() ?? "";
         throw new Error(`Import.mesh("${name}"): unsupported format ".${ext}". Supported: .stl, .obj, .3mf`);
       }
+      const sourceFrameStep = sourceFrameTransformStep("Import.mesh", name, meshOptions?.sourceFrame);
       if (!options.readBinaryFile) {
         throw new Error(
           `Import.mesh("${name}"): binary file reading is not available in this environment. Provide a readBinaryFile callback in RunScriptOptions.`
@@ -91603,6 +92328,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
           ...object ? { object } : {},
           fileData
         };
+        if (sourceFrameStep) plan = appendShapeCompileTransform(plan, sourceFrameStep);
         if (meshOptions?.scale != null && meshOptions.scale !== 1) {
           const s = meshOptions.scale;
           if (!Number.isFinite(s) || s <= 0) {
@@ -91626,7 +92352,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       }
       return centerImportedMesh(buildImportedMeshShape());
     };
-    const importStep = (name) => {
+    const importStep = (name, stepOptions) => {
       if (typeof name !== "string" || name.trim().length === 0) {
         throw new Error("Import.step() requires a non-empty file path string");
       }
@@ -91636,13 +92362,14 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       if (ext !== "step" && ext !== "stp") {
         throw new Error(`Import.step("${name}"): unsupported extension ".${ext}". Expected .step or .stp`);
       }
+      sourceFrameTransformStep("Import.step", name, stepOptions?.sourceFrame);
       if (!options.readBinaryFile) {
         throw new Error(
           `Import.step("${name}"): binary file reading is not available in this environment. Provide a readBinaryFile callback in RunScriptOptions.`
         );
       }
       const fileData = options.readBinaryFile(resolvedPath);
-      return importStepFromBuffer(fileData, name);
+      return importStepFromBuffer(fileData, name, stepOptions);
     };
     const Import = {
       dxfSketch: importDxfSketch,
@@ -91867,6 +92594,7 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
       bom,
       sheetStock,
       robotExport,
+      Sim,
       group,
       ShapeGroup,
       console: sandboxConsole,
@@ -91983,13 +92711,13 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
             cached: false
           });
           return finalExports;
-        } catch (error) {
+        } catch (error2) {
           options.moduleCache.delete(cacheKey3);
           logImportTrace(_collectedLogs, fileName, scope, options, "require", resolvedPath, "error", {
             requested: normalizedRequested,
-            error: formatLogError(error)
+            error: formatLogError(error2)
           });
-          throw error;
+          throw error2;
         } finally {
           restoreJointsView(savedJointsView);
         }
@@ -92022,13 +92750,13 @@ function executeFile(code, fileName, allFiles, visited, scope = {}, options, exe
           cached: false
         });
         return finalExports;
-      } catch (error) {
+      } catch (error2) {
         options.moduleCache.delete(cacheKey2);
         logImportTrace(_collectedLogs, fileName, scope, options, "require", resolvedPath, "error", {
           requested: normalizedRequested,
-          error: formatLogError(error)
+          error: formatLogError(error2)
         });
-        throw error;
+        throw error2;
       }
     };
     const bindingNames = Object.keys(runtimeBindings).filter((name) => name !== "showLabels");
@@ -92552,8 +93280,8 @@ function runDirectCliMain(metaUrl, sourceEntryPath, run) {
   Promise.resolve().then(() => {
     setActiveBackend(CLI_DEFAULT_BACKEND);
     return run();
-  }).catch((error) => {
-    const message = error instanceof Error ? error.message : String(error);
+  }).catch((error2) => {
+    const message = error2 instanceof Error ? error2.message : String(error2);
     console.error(message);
     process.exit(1);
   });
@@ -92766,23 +93494,23 @@ function collectFilesRecursive(dir, root) {
   return result;
 }
 var MANIFEST_FILE = "forgecad.json";
-function errorMessage(error) {
-  return error instanceof Error ? error.message : String(error);
+function errorMessage(error2) {
+  return error2 instanceof Error ? error2.message : String(error2);
 }
-function errorPath(error) {
-  if (!error || typeof error !== "object" || !("path" in error)) return null;
-  const path2 = error.path;
+function errorPath(error2) {
+  if (!error2 || typeof error2 !== "object" || !("path" in error2)) return null;
+  const path2 = error2.path;
   return typeof path2 === "string" && path2.length > 0 ? path2 : null;
 }
-function formatProjectCollectionError(scriptPath, projectRoot, error) {
-  const failedPath = errorPath(error);
+function formatProjectCollectionError(scriptPath, projectRoot, error2) {
+  const failedPath = errorPath(error2);
   const rootNote = resolve2(projectRoot) === resolve2(homedir()) ? "The inferred project root is your home directory. Move the model into a dedicated folder or put forgecad.json in the intended project folder." : "ForgeCAD scans the project root for .forge.js, .js, .svg, and .dxf files so local require/import paths work.";
   return [
     "ForgeCAD could not collect local project files.",
     `  Input file: ${resolve2(scriptPath)}`,
     `  Project root used for import discovery: ${projectRoot}`,
     failedPath ? `  Failed path: ${failedPath}` : null,
-    `  Filesystem error: ${errorMessage(error)}`,
+    `  Filesystem error: ${errorMessage(error2)}`,
     "",
     rootNote,
     "If this root is too broad, run the command from a dedicated ForgeCAD folder or initialize the folder with `forgecad project init`."
@@ -92807,8 +93535,8 @@ function collectProjectFiles(scriptPath) {
   let allFiles;
   try {
     allFiles = collectFilesRecursive(root, root);
-  } catch (error) {
-    throw Object.assign(new Error(formatProjectCollectionError(absScript, root, error)), { cause: error });
+  } catch (error2) {
+    throw Object.assign(new Error(formatProjectCollectionError(absScript, root, error2)), { cause: error2 });
   }
   const fileName = relative(root, absScript);
   const readBinaryFile = (relativePath) => {
@@ -92924,10 +93652,10 @@ function inspectShapeObject(object, compiled) {
         summary: summarizeShapeRuntime(lowerShapeCompilePlanToShapeBackend(report.compilePlan, getManifoldWasm())),
         error: null
       };
-    } catch (error) {
+    } catch (error2) {
       return {
         summary: null,
-        error: error instanceof Error ? error.message : String(error)
+        error: error2 instanceof Error ? error2.message : String(error2)
       };
     }
   })();
@@ -92965,10 +93693,10 @@ function inspectSketchObject(object, compiled) {
         summary: summarizeCrossSectionRuntime(lowerProfileCompilePlanToCrossSection(compilePlan, getManifoldWasm())),
         error: null
       };
-    } catch (error) {
+    } catch (error2) {
       return {
         summary: null,
-        error: error instanceof Error ? error.message : String(error)
+        error: error2 instanceof Error ? error2.message : String(error2)
       };
     }
   })();
@@ -93102,6 +93830,10 @@ export {
   mapDimensionsToOwnerIds,
   generateReportPdf,
   getCollectedRobotExport,
+  collectSimulationModel,
+  validateSimulationModel,
+  buildSimReadyManifest,
+  simReadyManifestJson,
   Rectangle2D,
   filletTrackedEdge,
   chamferTrackedEdge,
@@ -93137,6 +93869,7 @@ export {
   getDesignTraceInputs,
   buildDesignTraceNeighborhood,
   formatDesignTraceAnchor,
+  getRunResultAssemblySource,
   runScript,
   generateCuttingLayoutDxf,
   init,