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

package/bld/chunks/{chunk-JBVIAMJ6.js → chunk-CQKOD54C.js}

@@ -1115,10 +1115,10 @@ function sketchCurveClosestParameter(curve, position2) {
     position2[0] - curve.center[0]
   );
   if (curve.kind === "circle") return sketchPositiveAngle(angle) / tau;
-  const sign3 = Math.sign(curve.sweep), sweep = Math.abs(curve.sweep);
+  const sign3 = Math.sign(curve.sweep), sweep2 = Math.abs(curve.sweep);
   const distance4 = sketchPositiveAngle(sign3 * (angle - curve.start));
-  if (distance4 <= sweep) return sweep ? distance4 / sweep : 0;
-  return distance4 - sweep < tau - distance4 ? 1 : 0;
+  if (distance4 <= sweep2) return sweep2 ? distance4 / sweep2 : 0;
+  return distance4 - sweep2 < tau - distance4 ? 1 : 0;
 }
 __name(sketchCurveClosestParameter, "sketchCurveClosestParameter");
 function sketchCurveBounds(curve) {
@@ -3944,14 +3944,14 @@ function pointSession(context, policies) {
       );
       if (radius === 0) continue;
       radii.set(index, radius);
-      const sweep = reference.constraints.some(
+      const sweep2 = reference.constraints.some(
         (c) => c.kind === "sweep" && c.index === index
       );
       const direction = target.position.every((v, axis) => v === center[axis]) ? current.points[target.point].position : target.position;
       const turn = Math.atan2(direction[1] - center[1], direction[0] - center[0]) - Math.atan2(from[1] - center[1], from[0] - center[0]);
       for (const point3 of arc2.points) {
         let position2 = point3 === target.point ? direction : reference.points[point3].position;
-        if (sweep && point3 !== target.point) {
+        if (sweep2 && point3 !== target.point) {
           const [x, y] = [position2[0] - center[0], position2[1] - center[1]];
           position2 = [
             center[0] + x * Math.cos(turn) - y * Math.sin(turn),
@@ -4172,7 +4172,7 @@ __name(averagePosition, "averagePosition");
 
 // packages/core/src/library/runtime.ts
 import {
-  assembleWire,
+  assembleWire as assembleWire3,
   basicFaceExtrusion,
   BoundingBox as BoundingBox2,
   genericSweep,
@@ -4182,11 +4182,14 @@ import {
   makeCircle as makeCircle2,
   makeCylinder,
   makeFace,
-  makeHelix,
-  makeLine as makeLine2,
+  makeHelix as makeHelix2,
+  makeLine as makeLine3,
   makeSphere,
   makeThreePointArc as makeThreePointArc2,
   makeVertex,
+  measureShapeLinearProperties as measureShapeLinearProperties2,
+  measureShapeSurfaceProperties as measureShapeSurfaceProperties2,
+  measureShapeVolumeProperties,
   sketchCircle,
   sketchEllipse,
   sketchPolysides,
@@ -4538,7 +4541,14 @@ function nearestPoint(point3, geometry) {
 __name(nearestPoint, "nearestPoint");
 
 // packages/core/src/library/extrude.ts
-import { getOC as getOC6, Vector } from "replicad";
+import {
+  assembleWire,
+  getOC as getOC6,
+  makeHelix,
+  makeLine,
+  measureVolume,
+  Vector
+} from "replicad";
 
 // packages/core/src/library/topology.ts
 import {
@@ -5102,12 +5112,169 @@ function extrudeWithTopology(source, direction) {
   }
 }
 __name(extrudeWithTopology, "extrudeWithTopology");
+function revolveWithTopology(source, center, direction, angle, advance) {
+  const oc = getOC6();
+  if (advance === 0) {
+    const point3 = new oc.gp_Pnt(...center);
+    let dir;
+    let axis;
+    let shape2;
+    try {
+      dir = new oc.gp_Dir(...direction);
+      axis = new oc.gp_Ax1(point3, dir);
+      const builder = new oc.BRepPrimAPI_MakeRevol(
+        source.shape.wrapped,
+        axis,
+        angle * (Math.PI / 180),
+        false
+      );
+      try {
+        if (!builder.IsDone()) throw new Error("Could not revolve the face.");
+        shape2 = castOwnedShape3D(builder.Shape());
+        requireRevolvedVolume(shape2);
+        return {
+          shape: shape2,
+          topology: transferShapeTopology([source], shape2, builder)
+        };
+      } finally {
+        builder.delete();
+      }
+    } catch (error) {
+      shape2?.delete();
+      throw error;
+    } finally {
+      axis?.delete();
+      dir?.delete();
+      point3.delete();
+    }
+  }
+  const boundaries = shapeSubshapes(source.shape, "wire");
+  try {
+    if (boundaries.length !== 1)
+      throw new Error("Helical revolution requires a face without holes.");
+  } finally {
+    boundaries.forEach((boundary) => boundary.delete());
+  }
+  const end = [
+    center[0] + direction[0] * advance,
+    center[1] + direction[1] * advance,
+    center[2] + direction[2] * advance
+  ];
+  let startVector;
+  let endVector;
+  let line2;
+  let spine;
+  let guide;
+  let wire;
+  let shape;
+  try {
+    startVector = new Vector([...center]);
+    endVector = new Vector([...end]);
+    line2 = makeLine(startVector, endVector);
+    spine = assembleWire([line2]);
+    guide = makeHelix(
+      advance * 360 / angle,
+      advance,
+      1,
+      [...center],
+      [...direction]
+    );
+    wire = source.shape.clone().outerWire();
+    const builder = new oc.BRepOffsetAPI_MakePipeShell(spine.wrapped);
+    try {
+      builder.SetMode(
+        guide.wrapped,
+        false,
+        oc.BRepFill_TypeOfContact.BRepFill_NoContact
+      );
+      builder.Add(wire.wrapped, false, false);
+      if (!builder.IsReady())
+        throw new Error(
+          "Could not associate the profile with the rotation axis."
+        );
+      builder.Build();
+      if (!builder.IsDone() || !builder.MakeSolid())
+        throw new Error("Could not construct a solid helical revolution.");
+      shape = castOwnedShape3D(builder.Shape());
+      requireRevolvedVolume(shape);
+      return { shape };
+    } finally {
+      builder.delete();
+    }
+  } catch (error) {
+    shape?.delete();
+    throw error;
+  } finally {
+    wire?.delete();
+    guide?.delete();
+    spine?.delete();
+    line2?.delete();
+    endVector?.delete();
+    startVector?.delete();
+  }
+}
+__name(revolveWithTopology, "revolveWithTopology");
+function requireRevolvedVolume(shape) {
+  if (!(Math.abs(measureVolume(shape)) > 0))
+    throw new Error("Revolution did not produce a non-degenerate solid.");
+}
+__name(requireRevolvedVolume, "requireRevolvedVolume");
 
 // packages/core/src/library/loft.ts
 import {
+  assembleWire as assembleWire2,
   cast as cast2,
-  getOC as getOC7
+  getOC as getOC7,
+  measureVolume as measureVolume2
 } from "replicad";
+function sweepWithTopology(profile, path, normal) {
+  if (path.isClosed || !(path.length > 1e-9))
+    throw new Error("Sweep spine must be a non-degenerate open curve.");
+  const start = path.pointAt(0);
+  let tangent2;
+  try {
+    tangent2 = path.tangentAt(0);
+    const position2 = start.toTuple();
+    const direction = tangent2.toTuple();
+    const magnitude = Math.hypot(...direction);
+    if (!(magnitude > 1e-9))
+      throw new Error("Sweep spine must have a non-zero starting tangent.");
+    if (Math.hypot(...position2) > 1e-6)
+      throw new Error(
+        "Sweep profile origin must coincide with the spine start."
+      );
+    if ((normal[0] * direction[0] + normal[1] * direction[1] + normal[2] * direction[2]) / magnitude < 1 - 1e-6)
+      throw new Error(
+        "Sweep profile normal must point along the spine start tangent."
+      );
+  } finally {
+    tangent2?.delete();
+    start.delete();
+  }
+  const spine = assembleWire2([path]);
+  let result;
+  try {
+    result = loftWithTopology([profile], spine, false);
+    if (!(Math.abs(measureVolume2(result.shape)) > 0))
+      throw new Error("Sweep did not produce a non-degenerate solid.");
+    const validation = new (getOC7()).BRepCheck_Analyzer(result.shape.wrapped);
+    try {
+      if (!validation.IsValid())
+        throw new Error(
+          "Sweep produced an invalid solid. Adjust the profile or path to avoid tight bends and intersections."
+        );
+    } finally {
+      validation.delete();
+    }
+    return result;
+  } catch (error) {
+    result?.shape.delete();
+    throw error;
+  } finally {
+    spine.delete();
+  }
+}
+__name(sweepWithTopology, "sweepWithTopology");
 function loftWithTopology(sections, spine, ruled) {
   const holes = [];
   let outer;
@@ -5132,7 +5299,7 @@ function loftWithTopology(sections, spine, ruled) {
       throw new Error("Loft sections must have matching hole counts.");
     if (holes[0].length > 1)
       throw new Error(
-        "Loft currently supports at most one hole per section; multiple holes need explicit correspondence."
+        "A swept or lofted profile currently supports at most one hole; multiple holes need explicit correspondence."
       );
     outer = loftContoursWithTopology(sections, spine, ruled);
     if (!holes[0].length) {
@@ -5190,7 +5357,8 @@ function loftContoursWithTopology(sections, spine, ruled, holes) {
     }
     result = castOwnedShape3D(builder.Shape());
     caps[0] = castOwnedShape(builder.FirstShape());
-    caps[sections.length - 1] = castOwnedShape(builder.LastShape());
+    if (sections.length > 1)
+      caps[sections.length - 1] = castOwnedShape(builder.LastShape());
     const topology = transferShapeTopology(
       sections,
       result,
@@ -6284,13 +6452,13 @@ __name(validVolume, "validVolume");
 import {
   getOC as getOC9,
   makeCircle,
-  makeLine,
+  makeLine as makeLine2,
   makeThreePointArc
 } from "replicad";
 var position = /* @__PURE__ */ __name((p) => [p[0], 0, -p[1]], "position");
 function boundaryEdge(curve) {
   if (curve.kind === "line")
-    return makeLine(position(curve.points[0]), position(curve.points[1]));
+    return makeLine2(position(curve.points[0]), position(curve.points[1]));
   if (curve.kind === "circle" || Math.abs(curve.sweep) === 2 * Math.PI)
     return makeCircle(curve.radius, position(curve.center), [
       0,
@@ -20541,6 +20709,18 @@ var ModelTopologyElement = class extends ModelAnchor {
       topologyCenter(geometry, this.#topology.selection)
     );
   }
+  /** @code3d.inspect inspectLength */
+  get length() {
+    return measureFiniteGeometry(this, "length");
+  }
+  /** @code3d.inspect inspectArea */
+  get area() {
+    return measureFiniteGeometry(this, "area");
+  }
+  /** @code3d.inspect inspectVolume */
+  get volume() {
+    return measureFiniteGeometry(this, "volume");
+  }
   get start() {
     return this.#curvePoint("start", 0);
   }
@@ -21871,6 +22051,18 @@ var ModelObject = class _ModelObject extends RelationObject {
   static create(init) {
     return new _ModelObject(init);
   }
+  /** @code3d.inspect inspectLength */
+  get length() {
+    return measureFiniteGeometry(this, "length");
+  }
+  /** @code3d.inspect inspectArea */
+  get area() {
+    return measureFiniteGeometry(this, "area");
+  }
+  /** @code3d.inspect inspectVolume */
+  get volume() {
+    return measureFiniteGeometry(this, "volume");
+  }
   get origin() {
     return this.frame.origin;
   }
@@ -22318,6 +22510,134 @@ var ModelObject = class _ModelObject extends RelationObject {
     _ModelObject.recordExtrusions([this], [result]);
     return result;
   }
+  revolve(axis, config = { angle: 360 }) {
+    if (this.kind !== "face")
+      throw new Error("revolve requires a single face model.");
+    const { angle = 360, advance = 0 } = config;
+    if (!Number.isFinite(angle) || angle === 0)
+      throw new Error("Revolution angle must be finite and non-zero.");
+    if (!Number.isFinite(advance))
+      throw new Error("Revolution advance must be finite.");
+    if (advance === 0 && Math.abs(angle) > 360)
+      throw new Error("A revolution without advance cannot exceed one turn.");
+    const axisReference = straightAxisReference(axis, "revolve() axis");
+    const context = _ModelObject.createSolveContext([this, axisReference.model]);
+    const facePose = this.solvePose(context);
+    const axisFrame = relativeTransform(
+      composeTransforms(
+        axisReference.model.solvePose(context),
+        axisReference.transform
+      ),
+      facePose
+    );
+    const direction = rotateVector(
+      [0, axisReference.direction ?? 1, 0],
+      axisFrame.quaternion
+    );
+    const source = this.requireGeometry();
+    const axisModel = isModelObject(axisReference.model) ? axisReference.model : void 0;
+    _ModelObject.recordCompositionInspection(context, []);
+    const geometry = evaluateSolidGeometry(
+      "revolve",
+      [axisFrame.position, direction, angle, advance],
+      [source],
+      () => revolveWithTopology(
+        {
+          shape: source.value.shape,
+          topology: source.value.topology,
+          namespace: 1
+        },
+        axisFrame.position,
+        direction,
+        angle,
+        advance
+      )
+    );
+    const result = _ModelObject.create({
+      kind: "solid",
+      name: "Revolve",
+      geometry,
+      material: this.materialSnapshot,
+      placements: this.placements,
+      sourceRefs: [...this.sourceRefs, ...axisModel?.sourceRefs ?? []],
+      parameters: uniqueParameters([
+        ...this.allParameters(),
+        ...axisModel?.allParameters() ?? []
+      ]),
+      meshTolerance: this.meshTolerance,
+      operation: storedOperation("revolve", [
+        { model: this, role: "receiver", index: 0 },
+        ...axisModel ? [{ model: axisModel, role: "reference", index: 1 }] : []
+      ])
+    });
+    _ModelObject.recordCompositionInspection(context, [[result, this]]);
+    return result;
+  }
+  sweep(spine) {
+    if (this.kind !== "face")
+      throw new Error("sweep requires a single face model.");
+    const path = requireModelKind(
+      spine,
+      "edge",
+      "sweep requires an edge model as its spine."
+    );
+    const context = _ModelObject.createSolveContext([this, path]);
+    const profilePose = this.solvePose(context);
+    const pathTransform = relativeTransform(
+      path.solvePose(context),
+      profilePose
+    );
+    const source = this.requireGeometry();
+    const pathGeometry = path.requireGeometry();
+    const normal = rotateVector(
+      [0, 1, 0],
+      this.geometryAnchor.transform.quaternion
+    );
+    _ModelObject.recordCompositionInspection(context, []);
+    const geometry = evaluateSolidGeometry(
+      "sweep",
+      [pathTransform.position, pathTransform.quaternion, normal],
+      [source, pathGeometry],
+      () => {
+        const positionedPath = shapeWithTransform(
+          pathGeometry.value.shape,
+          pathTransform
+        );
+        try {
+          return sweepWithTopology(
+            {
+              shape: source.value.shape,
+              topology: source.value.topology,
+              namespace: 1
+            },
+            positionedPath,
+            normal
+          );
+        } finally {
+          positionedPath.delete();
+        }
+      }
+    );
+    const result = _ModelObject.create({
+      kind: "solid",
+      name: "Sweep",
+      geometry,
+      material: this.materialSnapshot,
+      placements: this.placements,
+      sourceRefs: [...this.sourceRefs, ...path.sourceRefs],
+      parameters: uniqueParameters([
+        ...this.allParameters(),
+        ...path.allParameters()
+      ]),
+      meshTolerance: Math.min(this.meshTolerance, path.meshTolerance),
+      operation: storedOperation("sweep", [
+        { model: this, role: "receiver", index: 0 },
+        { model: path, role: "spine", index: 1 }
+      ])
+    });
+    _ModelObject.recordCompositionInspection(context, [[result, this]]);
+    return result;
+  }
   cut(tools) {
     return cut(this, tools);
   }
@@ -23070,6 +23390,32 @@ var ModelObject = class _ModelObject extends RelationObject {
       target: target.map((value) => frame.positioned(value))
     };
   }
+  /** @internal */
+  static recordRevolve(profile, axis, result) {
+    if (!isRecordingInspection()) return;
+    const reference = straightAxisReference(axis, "revolve() axis");
+    const context = this.createSolveContext([profile, reference.model]);
+    this.recordCompositionInspection(
+      context,
+      result ? [[result, profile]] : []
+    );
+  }
+  /** @internal */
+  static inspectRevolve(profile, axis, result, data, focus) {
+    const frame = this.inspectionFrame(data.poses);
+    const shownProfile = frame.positioned(profile);
+    const shownAxis = anchorAnnotation(frame.positioned(axis), {
+      direction: "forward"
+    });
+    const shownResult = result ? frame.positioned(result) : void 0;
+    return focus === "axis" ? {
+      ambient: [shownProfile, ...shownResult ? [shownResult] : []],
+      target: [shownAxis]
+    } : {
+      ambient: [shownAxis, ...shownResult ? [shownResult] : []],
+      target: [shownProfile]
+    };
+  }
   /** @internal Derive the focused cut volume using the original solved operands. */
   static inspectCutTools(stock, tools, focused, data) {
     const selected = new Set(focused);
@@ -23542,7 +23888,7 @@ function line(startOrEnd, end) {
     "line",
     "Line",
     [start, end],
-    () => makeLine2(toPoint(start), toPoint(end))
+    () => makeLine3(toPoint(start), toPoint(end))
   );
 }
 __name(line, "line");
@@ -23696,11 +24042,11 @@ function coil(coilRadius = 5, wireRadius = 1, pitch = 3, turns = 3) {
     [coilRadius, wireRadius, pitch, turns],
     [],
     () => {
-      const spine = makeHelix(pitch, y, coilRadius, [0, -y / 2, 0], [0, 1, 0]);
+      const spine = makeHelix2(pitch, y, coilRadius, [0, -y / 2, 0], [0, 1, 0]);
       const start = spine.pointAt(0);
       const tangent2 = spine.tangentAt(0);
       const circle2 = makeCircle2(wireRadius, start, tangent2);
-      const section = assembleWire([circle2]);
+      const section = assembleWire3([circle2]);
       try {
         return { shape: genericSweep(section, spine, { frenet: true }) };
       } finally {
@@ -24070,6 +24416,75 @@ var relate;
   relate3.inspectBody = inspectBody;
   __name(inspectBody, "inspectBody");
 })(relate || (relate = {}));
+function measureFiniteGeometry(value, measure) {
+  const topology = value instanceof ModelTopologyElement ? value[anchorReferenceValue].topology : void 0;
+  const owner = value instanceof ModelObject ? value : value[anchorReferenceValue].model;
+  const geometry = (topology?.source ?? value)[modelGeometry]().value;
+  const scale3 = topology?.scale ?? 1;
+  const position2 = /* @__PURE__ */ __name((point3) => topology ? topologyTransform(topology, translation(point3)).position : point3, "position");
+  const read = /* @__PURE__ */ __name((shape) => {
+    const properties = measure === "length" ? measureShapeLinearProperties2(shape) : measure === "area" ? measureShapeSurfaceProperties2(shape) : measureShapeVolumeProperties(shape);
+    try {
+      const magnitude = "length" in properties ? properties.length : "area" in properties ? properties.area : properties.volume;
+      const power = measure === "length" ? 1 : measure === "area" ? 2 : 3;
+      const result = magnitude * scale3 ** power;
+      if (isRecordingInspection()) {
+        const edge = shape;
+        const edgePoint = /* @__PURE__ */ __name((parameter) => {
+          const point3 = edge.pointAt(parameter);
+          try {
+            return position2(point3.toTuple());
+          } finally {
+            point3.delete();
+          }
+        }, "edgePoint");
+        const placement = measure === "length" && edge.geomType === "LINE" ? { start: edgePoint(0), end: edgePoint(1) } : {
+          at: measure === "length" ? edgePoint(0.5) : position2(properties.centerOfMass)
+        };
+        const target = value instanceof ModelObject ? value.kind === "edge" ? value.edges()[0] : value.kind === "face" ? value.surfaces()[0] : value : value;
+        captureInspectData({ owner, target, placement });
+      }
+      return result;
+    } finally {
+      properties.delete();
+    }
+  }, "read");
+  return topology ? withTopologyShape(
+    geometry.shape,
+    geometry.topology,
+    topology.selection,
+    read
+  ) : read(geometry.shape);
+}
+__name(measureFiniteGeometry, "measureFiniteGeometry");
+function inspectLength(_args, context) {
+  return inspectMeasurement(context, "length");
+}
+__name(inspectLength, "inspectLength");
+function inspectArea(_args, context) {
+  return inspectMeasurement(context, "area");
+}
+__name(inspectArea, "inspectArea");
+function inspectVolume(_args, context) {
+  return inspectMeasurement(context, "volume");
+}
+__name(inspectVolume, "inspectVolume");
+function inspectMeasurement(context, kind) {
+  if (context.return === void 0 || !context.data) return;
+  const { owner, target, placement } = context.data;
+  return {
+    target: [
+      target,
+      dimension({
+        owner,
+        value: context.return,
+        ...placement,
+        axisLabel: kind === "length" ? "at" in placement ? "arc length" : void 0 : kind
+      })
+    ]
+  };
+}
+__name(inspectMeasurement, "inspectMeasurement");
 function inspectTopologyReference(_args, context) {
   if (context.return !== void 0 && (!Array.isArray(context.return) || context.return.length > 0))
     return void 0;
@@ -24128,6 +24543,33 @@ function extrude(face, distance4 = 10) {
   }
 }
 __name(extrude, "extrude");
+function revolve(profile, axis, config = { angle: 360 }) {
+  const runtimeProfile = requireModelKind(
+    profile,
+    "face",
+    "revolve requires a face model."
+  );
+  let result;
+  try {
+    result = runtimeProfile.revolve(axis, config);
+    return result;
+  } finally {
+    ModelObject.recordRevolve(
+      runtimeProfile,
+      axis,
+      result
+    );
+  }
+}
+__name(revolve, "revolve");
+function sweep(profile, spine) {
+  return requireModelKind(
+    profile,
+    "face",
+    "sweep requires a face model."
+  ).sweep(spine);
+}
+__name(sweep, "sweep");
 function text(content, font2, size, options) {
   return textGlyphs(content, font2, size, options).flatMap(
     ({ regions, x, y }) => regions.value.map((region, index) => {
@@ -24234,7 +24676,7 @@ function withDistanceShape(part, visit) {
     return withTransformedGeometry(part.geometry.value, part, visit);
   const points = part.points;
   if (points.length <= 2) {
-    const shape = points.length === 1 ? makeVertex(toPoint(points[0])) : makeLine2(toPoint(points[0]), toPoint(points[1]));
+    const shape = points.length === 1 ? makeVertex(toPoint(points[0])) : makeLine3(toPoint(points[0]), toPoint(points[1]));
     try {
       return visit(shape);
     } finally {
@@ -24247,10 +24689,10 @@ function withDistanceShape(part, visit) {
   try {
     points.forEach(
       (point3, index) => edges.push(
-        makeLine2(toPoint(point3), toPoint(points[(index + 1) % points.length]))
+        makeLine3(toPoint(point3), toPoint(points[(index + 1) % points.length]))
       )
     );
-    wire = assembleWire(edges);
+    wire = assembleWire3(edges);
     face = makeFace(wire);
     return visit(face);
   } finally {
@@ -24523,6 +24965,8 @@ var authoringApi = Object.freeze({
   bezier,
   spline,
   loft,
+  revolve,
+  sweep,
   box,
   cylinder,
   tube,
@@ -24837,7 +25281,7 @@ function buildLoftGeometry(sections, spine, ruled) {
         spine.transform
       );
       try {
-        spineWire = assembleWire([edge]);
+        spineWire = assembleWire3([edge]);
       } finally {
         edge.delete();
       }
@@ -25297,6 +25741,84 @@ __name(requireModelKind, "requireModelKind");
   extrude2.inspectMethod = inspectMethod;
   __name(inspectMethod, "inspectMethod");
 })(extrude || (extrude = {}));
+((revolve2) => {
+  function inspectProfile([profile, axis], context) {
+    return context.data && ModelObject.inspectRevolve(
+      profile,
+      axis,
+      context.return,
+      context.data,
+      "profile"
+    );
+  }
+  revolve2.inspectProfile = inspectProfile;
+  __name(inspectProfile, "inspectProfile");
+  function inspectAxis([profile, axis], context) {
+    return context.data && ModelObject.inspectRevolve(
+      profile,
+      axis,
+      context.return,
+      context.data,
+      "axis"
+    );
+  }
+  revolve2.inspectAxis = inspectAxis;
+  __name(inspectAxis, "inspectAxis");
+  function inspectMethodProfile([axis], context) {
+    return context.data && ModelObject.inspectRevolve(
+      context.receiver,
+      axis,
+      context.return,
+      context.data,
+      "profile"
+    );
+  }
+  revolve2.inspectMethodProfile = inspectMethodProfile;
+  __name(inspectMethodProfile, "inspectMethodProfile");
+  function inspectMethodAxis([axis], context) {
+    return context.data && ModelObject.inspectRevolve(
+      context.receiver,
+      axis,
+      context.return,
+      context.data,
+      "axis"
+    );
+  }
+  revolve2.inspectMethodAxis = inspectMethodAxis;
+  __name(inspectMethodAxis, "inspectMethodAxis");
+})(revolve || (revolve = {}));
+((sweep2) => {
+  function inspectProfile([profile, spine], context) {
+    if (!context.data) return void 0;
+    return ModelObject.inspectComposition(
+      context.data,
+      [spine, ...context.return ? [context.return] : []],
+      [profile]
+    );
+  }
+  sweep2.inspectProfile = inspectProfile;
+  __name(inspectProfile, "inspectProfile");
+  function inspectSpine([profile, spine], context) {
+    if (!context.data) return void 0;
+    return ModelObject.inspectComposition(
+      context.data,
+      [profile, ...context.return ? [context.return] : []],
+      [spine]
+    );
+  }
+  sweep2.inspectSpine = inspectSpine;
+  __name(inspectSpine, "inspectSpine");
+  function inspectMethodProfile([spine], context) {
+    return inspectProfile([context.receiver, spine], context);
+  }
+  sweep2.inspectMethodProfile = inspectMethodProfile;
+  __name(inspectMethodProfile, "inspectMethodProfile");
+  function inspectMethodSpine([spine], context) {
+    return inspectSpine([context.receiver, spine], context);
+  }
+  sweep2.inspectMethodSpine = inspectMethodSpine;
+  __name(inspectMethodSpine, "inspectMethodSpine");
+})(sweep || (sweep = {}));
 ((union2) => {
   function inspectOperands([operands], context) {
     if (!context.data) return void 0;
@@ -26323,19 +26845,19 @@ function contourContains(curves, point3) {
       continue;
     }
     const start = curve.kind === "circle" ? 0 : curve.start;
-    const sweep = curve.kind === "circle" ? tau2 : curve.sweep;
+    const sweep2 = curve.kind === "circle" ? tau2 : curve.sweep;
     const cuts = [
       0,
       1,
       ...[Math.PI / 2, 3 * Math.PI / 2].map(
-        (a) => sketchPositiveAngle(Math.sign(sweep) * (a - start)) / Math.abs(sweep)
+        (a) => sketchPositiveAngle(Math.sign(sweep2) * (a - start)) / Math.abs(sweep2)
       ).filter((t) => t > 0 && t < 1)
     ].sort((a, b) => a - b);
     for (let i = 1; i < cuts.length; i++) {
       const a = sketchCurvePosition(curve, cuts[i - 1]), b = sketchCurvePosition(curve, cuts[i]);
       if (a[1] > point3[1] === b[1] > point3[1]) continue;
       const dy = point3[1] - curve.center[1];
-      const x = curve.center[0] + Math.sign(Math.cos(start + sweep * (cuts[i - 1] + cuts[i]) / 2)) * Math.sqrt(Math.max(0, (curve.radius - dy) * (curve.radius + dy)));
+      const x = curve.center[0] + Math.sign(Math.cos(start + sweep2 * (cuts[i - 1] + cuts[i]) / 2)) * Math.sqrt(Math.max(0, (curve.radius - dy) * (curve.radius + dy)));
       if (x > point3[0]) crossings++;
     }
   }
@@ -26443,12 +26965,17 @@ export {
   group,
   distance2 as distance,
   relate,
+  inspectLength,
+  inspectArea,
+  inspectVolume,
   inspectTopologyReference,
   expose,
   on,
   align,
   union,
   extrude,
+  revolve,
+  sweep,
   text,
   cut,
   intersect,
@@ -26471,4 +26998,4 @@ export {
   retainModelGeometry,
   authoringApi
 };
-//# sourceMappingURL=chunk-JBVIAMJ6.js.map
+//# sourceMappingURL=chunk-CQKOD54C.js.map