@constructorfleet/sketchforge-engine 1.26.0 → 1.28.0

package/dist/serverCadOperations.js

@@ -12,16 +12,22 @@
  * talks to `self.postMessage` and is close to upstream's, and prising it apart
  * would conflict with every upstream change to it. What is shared instead is
  * the result format, so a shape filleted here is indistinguishable in the
- * editor from one filleted there.
+ * editor from one filleted there -- and, through `meshShellSolids`, how a mesh
+ * of several closed shells becomes one solid, so the two agree on which meshes
+ * with internal voids are solids (#527).
  */
 import { faceIdsFromEvolution } from "./faceLineage.js";
 import { withCadKernel } from "./serverCadKernel.js";
 import { exactSolidForShape, mirroredInShapeFrame, shapeIsTurned, unrotatedSolidForShape, UnbuildableShapeError, EXACT_SOLID_KINDS, } from "./cadSolids.js";
-import { canonicalizeShape } from "./workplaneShapes.js";
+import { canonicalizeShape, shapeHasTaper } from "./workplaneShapes.js";
 import { createLocalId } from "./localIds.js";
-import { cadSketchRegions } from "./sketchCadProfile.js";
+import { cadSketchRegions, draftPrismLoop } from "./sketchCadProfile.js";
+import { sketchExtrusionSolid } from "./sketchExtrusionSolid.js";
 import { normalizeSketchRevolveSettings, sketchProfileToRevolvePolygons } from "./sketchRevolve.js";
 import { triangleFaceGroups } from "./cadFaceMesh.js";
+import { meshDataFromPositions } from "./meshMassProperties.js";
+import { MeshShellsOverlapError } from "./meshShellOverlap.js";
+import { MeshShellSolidError, nestedMeshShellSolid } from "./meshShellSolids.js";
 import { draftSketchFace, draftPrismProfileOffset, faceIdsForCadResult } from "./sketchFaceDraftKernel.js";
 export class ServerCadError extends Error {
     status;
@@ -34,6 +40,71 @@ export class ServerCadError extends Error {
 const MESH_DEFLECTION = 0.1;
 const MIN_CAD_DIMENSION = 0.01;
 const FACE_HASH_UPPER_BOUND = 2_147_483_647;
+/**
+ * How far a retained sketch output has been resized since it was swept: its
+ * drawn dimensions over the ones its source geometry was built at.
+ */
+export function sketchResizeFactors(shape) {
+    const mesh = shape.importedMesh;
+    // A face-drafted output's bounds include its taper, so the resize recorded
+    // with the draft is the one to use. Once the draft is gone the bounds are
+    // the extrusion's again, and a recorded scale would hide any resize since.
+    if (shape.faceDraft && shape.faceDraftSourceScale)
+        return shape.faceDraftSourceScale;
+    const factor = (drawn, base) => base && base > 0 ? drawn / base : 1;
+    return {
+        width: factor(shape.width, mesh?.baseWidth),
+        depth: factor(shape.depth, mesh?.baseDepth),
+        height: factor(shape.height, mesh?.baseHeight),
+    };
+}
+function scaledSketchProfile(profile, width, depth) {
+    const xs = profile.points.map((point) => point.x);
+    const zs = profile.points.map((point) => point.z);
+    const centerX = (Math.min(...xs) + Math.max(...xs)) / 2;
+    const centerZ = (Math.min(...zs) + Math.max(...zs)) / 2;
+    const scalePoint = (point) => ({
+        ...point,
+        x: centerX + (point.x - centerX) * width,
+        z: centerZ + (point.z - centerZ) * depth,
+        ...(point.handleIn ? { handleIn: { ...point.handleIn, x: centerX + (point.handleIn.x - centerX) * width, z: centerZ + (point.handleIn.z - centerZ) * depth } } : {}),
+        ...(point.handleOut ? { handleOut: { ...point.handleOut, x: centerX + (point.handleOut.x - centerX) * width, z: centerZ + (point.handleOut.z - centerZ) * depth } } : {}),
+    });
+    return { ...profile, points: profile.points.map(scalePoint) };
+}
+const isResized = (factors) => [factors.width, factors.depth, factors.height].some((factor) => Math.abs(factor - 1) > 1e-8);
+/**
+ * A sketch extrusion whose exact solid is still its bare sweep -- no draft,
+ * treatment or shell -- has its B-rep stored at the size it was drawn. A resize
+ * since then lives only in its dimensions, so its exact solid at the size it is
+ * shown is its profile scaled by that resize and extruded to its height, the
+ * rebuild `applySketchFaceDraft` makes (#452 for width and depth; #546 fixed
+ * the engine handing a height-resized extrusion to it at twice its height).
+ * Null when there is no resize to apply, or the solid is something else.
+ *
+ * Without this, a fillet, chamfer or shell of a resized extrusion was built
+ * from the B-rep as drawn and stored back at the original size (#539).
+ */
+export function resizedSketchExtrusionProfile(shape) {
+    if (shape.sketchOperation !== "extrude" || !shape.sketchProfile || !shape.cadBrep)
+        return null;
+    if (shape.faceDraft !== undefined || shape.draftPrismAngle !== undefined || shape.shell
+        || (shape.edgeTreatments?.length ?? 0) > 0 || (shape.edgeTreatmentHistory?.length ?? 0) > 0)
+        return null;
+    const resize = sketchResizeFactors(shape);
+    return isResized(resize) ? scaledSketchProfile(shape.sketchProfile, resize.width, resize.depth) : null;
+}
+/** The bare extrusion's exact solid at its drawn size, or its stored solid when it has not been resized. */
+function storedOrResizedSolid(cad, shape) {
+    const resizedProfile = resizedSketchExtrusionProfile(shape);
+    if (!resizedProfile)
+        return localSolidForShape(cad, shape);
+    const solid = sketchExtrusionSolid(cad, resizedProfile, shape.height);
+    if (!cadResultIsValid(cad, solid)) {
+        throw new ServerCadError("The resized sketch extrusion could not be rebuilt as exact CAD geometry.");
+    }
+    return solid;
+}
 function meshPositionsOf(shape) {
     const positions = shape.importedMesh?.positions;
     return positions && positions.length >= 9 ? positions : null;
@@ -91,8 +162,39 @@ function solidFromBrep(cad, brep) {
     }
     throw new ServerCadError("The stored exact geometry for that shape could not be read.");
 }
-/** A solid sewn from a flat list of triangle corners, which is how a stored mesh arrives. */
+/**
+ * A solid sewn from a flat list of triangle corners, which is how a stored mesh arrives.
+ *
+ * A mesh made of several closed shells -- a part with a sealed internal void,
+ * or separate bodies -- is built one shell at a time and put back together by
+ * nesting (#501). Sewn all at once, OCCT got a shell inside a shell, could make
+ * no one solid of it, and refused a watertight part outright.
+ */
 export function solidFromMeshPositions(cad, positions) {
+    let nested;
+    try {
+        nested = nestedMeshShellSolid(cad, meshDataFromPositions(positions), (shell) => sewnMeshSolid(cad, shell));
+    }
+    catch (error) {
+        if (!(error instanceof MeshShellSolidError))
+            throw error;
+        throw new ServerCadError(error.reason === "shells-overlap" ? MESH_SHELLS_OVERLAP : MESH_NOT_SOLID);
+    }
+    return nested ?? sewnMeshSolid(cad, positions);
+}
+/** The exact path's refusal for a mesh error the kernel-free measures throw; anything else unchanged. */
+export function asServerCadError(error) {
+    return error instanceof MeshShellsOverlapError ? new ServerCadError(MESH_SHELLS_OVERLAP) : error;
+}
+const MESH_SHELLS_OVERLAP = "That shape's mesh has closed bodies that overlap without one enclosing the other, so the CAD kernel cannot tell which side of each is material. Union the bodies in the mesh before importing it.";
+/**
+ * Why a mesh could not become a solid. Shared by every exact path that reads a
+ * mesh -- properties, booleans, interference, drawings -- so it names none of
+ * them; it used to say "cannot be filleted" to all of them.
+ */
+const MESH_NOT_SOLID = "That shape's mesh is not a closed solid, so the CAD kernel cannot build exact geometry from it.";
+/** One shell's triangles sewn into a solid, loosening the tolerance until it closes. */
+function sewnMeshSolid(cad, positions) {
     const imported = cad.importStl(asciiStlFromPositions(positions));
     let shape = cad.fixShape(imported);
     if (isValidSolid(cad, shape))
@@ -113,7 +215,7 @@ export function solidFromMeshPositions(cad, positions) {
             // Try the next tolerance.
         }
     }
-    throw new ServerCadError("That shape's mesh is not a closed solid, so it cannot be filleted.");
+    throw new ServerCadError(MESH_NOT_SOLID);
 }
 /**
  * Whether the shape's geometry has to be turned, or arrives already turned.
@@ -183,7 +285,9 @@ export function localSolidForShape(cad, shape) {
  * reads the same predicate.
  *
  * For stored geometry this is the local solid with only its mirror applied:
- * the rotation stays on the shape, which is where it already was.
+ * the rotation stays on the shape, which is where it already was. A resized
+ * bare sketch extrusion is the exception: it is rebuilt at its drawn size
+ * (`resizedSketchExtrusionProfile`), since its stored B-rep is not.
  *
  * Mirrored either way, because the result is stored with the shape's mirror
  * flags cleared. Building it unmirrored handed back the unmirrored shape and
@@ -191,7 +295,7 @@ export function localSolidForShape(cad, shape) {
  */
 export function orientedSolidForShape(cad, shape) {
     if (!rotationIsRebuilt(shape))
-        return mirroredStoredSolid(cad, localSolidForShape(cad, shape), shape);
+        return mirroredStoredSolid(cad, storedOrResizedSolid(cad, shape), shape);
     try {
         return exactSolidForShape(cad, shape);
     }
@@ -391,11 +495,15 @@ export function applyEdgeTreatment(shape, treatment) {
             }
         }
         catch (error) {
-            // OCCT fails when the radius does not fit the geometry, which is the
-            // common mistake: too large a radius for a thin wall or a short edge.
-            throw new ServerCadError(treatment.kind === "fillet"
-                ? "That radius is too large for this shape's edges. Try a smaller one."
-                : "That chamfer is too large for this shape's edges. Try a smaller one.");
+            const message = error instanceof Error ? error.message : String(error);
+            const wasmFault = typeof WebAssembly !== "undefined"
+                && (error instanceof WebAssembly.Exception || error instanceof WebAssembly.RuntimeError);
+            if (wasmFault || /out of memory|memory access out of bounds|allocation failed|wasm.*abort/i.test(message)) {
+                throw error;
+            }
+            // Keep geometric sizing failures actionable without disguising runtime
+            // faults as a user mistake.
+            throw new ServerCadError(`The requested ${treatment.kind} amount ${treatment.amount} could not be applied to ${edges.length} eligible edges. Try a smaller amount.`);
         }
         // Both fillet and chamfer hand back a compound wrapping the result, and
         // OCCT refuses a compound as the input to another treatment -- so storing
@@ -462,6 +570,13 @@ function revolveWithoutExactEdges(shape) {
  * viewport stretches the mesh by.
  */
 function revolveResizeFactors(shape) {
+    if (shape.faceDraftSourceScale) {
+        return {
+            radialX: shape.faceDraftSourceScale.width,
+            radialZ: shape.faceDraftSourceScale.depth,
+            axial: shape.faceDraftSourceScale.height,
+        };
+    }
     const mesh = shape.importedMesh;
     const ratio = (drawn, base) => (base && base > 0 && drawn > 0 ? drawn / base : 1);
     return {
@@ -491,6 +606,145 @@ function exactRevolveSolidForShape(cad, shape) {
     const { radialX, axial } = revolveResizeFactors(shape);
     return exactPlainSketchRevolveSolid(cad, shape.sketchProfile, normalizeSketchRevolveSettings(shape.sketchRevolve), undefined, { radial: radialX, axial });
 }
+/**
+ * Where a stored revolve's axis sits in its mesh's natural frame, or null when
+ * that cannot be known without sweeping it again.
+ *
+ * The mesh is centred on its own box, so the axis is `-revolveAxisOffset`
+ * there (#503). A full turn saved before that offset was recorded is still
+ * symmetric about its axis under every one of its facet rotations, so the
+ * axis is the centroid of its triangles in X and Z -- which is not the box
+ * centre when the facet count is not a multiple of four. A partial sweep with
+ * no recorded axis has neither, and stays tessellated.
+ */
+function storedRevolveAxis(shape, fullTurn) {
+    if (shape.revolveAxisOffset)
+        return { x: -shape.revolveAxisOffset.x, z: -shape.revolveAxisOffset.z };
+    if (!fullTurn)
+        return null;
+    const positions = shape.importedMesh?.positions ?? [];
+    let volume = 0;
+    let x = 0;
+    let z = 0;
+    for (let index = 0; index + 8 < positions.length; index += 9) {
+        const [ax, ay, az, bx, by, bz, cx, cy, cz] = positions.slice(index, index + 9);
+        const tetra = (ax * (by * cz - bz * cy) - ay * (bx * cz - bz * cx) + az * (bx * cy - by * cx)) / 6;
+        volume += tetra;
+        x += tetra * (ax + bx + cx) / 4;
+        z += tetra * (az + bz + cz) / 4;
+    }
+    return Math.abs(volume) > 1e-12 ? { x: x / volume, z: z / volume } : null;
+}
+/**
+ * Whether any profile segment is drawn as a curve.
+ *
+ * The rule `sketchProfileToRevolvePolygons` samples by: a segment that is not
+ * a line and has both its handles (the start point's outgoing one and the end
+ * point's incoming one) is a cubic, sampled into straight pieces; anything
+ * else is drawn straight. A revolve of the samples would be exact about the
+ * axis but still an approximation of the drawn curve, so it is not reported
+ * as exact.
+ */
+function profileHasCurvedSegment(profile) {
+    const points = new Map(profile.points.map((point) => [point.id, point]));
+    return profile.segments.some((segment) => segment.kind !== "line"
+        && Boolean(points.get(segment.startId)?.handleOut) && Boolean(points.get(segment.endId)?.handleIn));
+}
+/**
+ * Why a revolve stored as a mesh is not measured, cut or exported as its exact
+ * solid, or null when it is.
+ *
+ * Wider than the edge listing's rule (`revolveWithoutExactEdges`): a partial
+ * sweep is exact here too, because nothing numbers its edges.
+ */
+function revolveWithoutExactSolid(shape) {
+    if (!isUntreatedSketchRevolve(shape))
+        return "not an untreated sketch revolve";
+    if ((shape.importedMesh?.positions.length ?? 0) < 9)
+        return "no stored sweep to place the solid by";
+    const settings = normalizeSketchRevolveSettings(shape.sketchRevolve);
+    if (settings.pitch !== 0)
+        return "a helical revolve has only its tessellated sweep";
+    if (settings.coreRadius > 0)
+        return "a revolve fused to a core has no exact solid";
+    const { radialX, radialZ } = revolveResizeFactors(shape);
+    if (Math.abs(radialX - radialZ) > 1e-6 * Math.max(radialX, radialZ))
+        return "resized unevenly across its axis, so no revolve describes it";
+    if (shapeHasTaper(shape))
+        return "a taper is applied to the mesh, not to a revolve";
+    const fullTurn = Math.abs(Math.abs(settings.sweepAngle) - 360) <= 1e-6;
+    if (!storedRevolveAxis(shape, fullTurn))
+        return "a partial sweep saved without its axis";
+    if (profileHasCurvedSegment(shape.sketchProfile))
+        return "a curved profile edge is sampled into straight segments, so no exact solid describes it";
+    try {
+        if (cadSketchRegions(revolveSectionProfile(shape.sketchProfile, settings, { radial: 1, axial: 1 })).length !== 1) {
+            return "the profile has several closed regions";
+        }
+    }
+    catch {
+        return "the profile has no closed region";
+    }
+    return null;
+}
+/**
+ * Whether `placedSolidForShape` builds this shape as the exact solid of its
+ * revolve rather than sewing its stored mesh, which is what measuring it
+ * reports as its precision.
+ */
+export function hasExactRevolveSolid(shape) {
+    return revolveWithoutExactSolid(shape) === null;
+}
+/**
+ * The angle a mesh of a result built from these shapes may turn through
+ * between facets, so that it is no coarser than the finest exact revolve
+ * among them, or undefined when none is one.
+ *
+ * Before a revolve was exact, a cut through it was made from its faceted
+ * sweep, so the stored result was exactly as fine as its `sides` asked. The
+ * exact result is meshed at a fixed chord height instead, which on a small
+ * ring is coarser than the sweep it replaced and ignores `sides` altogether.
+ * A group record is searched through, since it is cut as its members.
+ *
+ * Twice the sweep's facet angle, because OCCT's angular deflection bounds the
+ * turn between a facet's normal and the surface's, half a facet each way: at
+ * this value a full circle gets `sides` facets, the sweep's own count, and a
+ * 64-sided ring cut in half meshes to the 260 triangles its sweep gave.
+ */
+export function exactRevolveAngularDeflection(shapes) {
+    let finest = 0;
+    const visit = (shape) => {
+        if (hasExactRevolveSolid(shape)) {
+            finest = Math.max(finest, normalizeSketchRevolveSettings(shape.sketchRevolve).sides);
+        }
+        else if (!shape.importedMesh && !shape.cadBrep) {
+            shape.groupedShapes?.forEach(visit);
+        }
+    };
+    shapes.forEach(visit);
+    return finest > 0 ? (4 * Math.PI) / finest : undefined;
+}
+/**
+ * The exact solid of a plain revolve, full turn or partial sweep, in the frame
+ * its stored mesh is drawn in -- centred on the mesh's box in X and Z, base at
+ * Y=0, at its drawn size -- or null when it has none (#523).
+ *
+ * That frame is what lets the caller place it exactly as the mesh is placed.
+ * The axis comes from the stored record rather than from the solid's own box,
+ * because a faceted partial sweep's box is not the exact sweep's box, and
+ * centring on the wrong one moves the solid off its axis.
+ */
+export function exactRevolveLocalSolid(cad, shape) {
+    if (!hasExactRevolveSolid(shape))
+        return null;
+    const settings = normalizeSketchRevolveSettings(shape.sketchRevolve);
+    const axis = storedRevolveAxis(shape, Math.abs(Math.abs(settings.sweepAngle) - 360) <= 1e-6);
+    const { radialX, radialZ, axial } = revolveResizeFactors(shape);
+    const solid = revolvedSectionSolid(cad, shape.sketchProfile, settings, { radial: radialX, axial });
+    if (!cad.isValid(solid) || !cad.isSolid(solid))
+        throw new ServerCadError("The retained sketch revolve could not be rebuilt as exact CAD geometry.");
+    return cad.translate(solid, axis.x * radialX, 0, axis.z * radialZ);
+}
 /**
  * The solid `GET /edges` numbers and a fillet or chamfer rounds.
  *
@@ -514,16 +768,16 @@ export function isPlainFullTurnSketchRevolve(shape) {
         && (settings.pitch ?? 0) === 0 && (settings.coreRadius ?? 0) === 0
         && Math.abs(Math.abs(settings.sweepAngle) - 360) <= 1e-6;
 }
-/** Build the analytical BREP for a plain, single-region full-turn revolve. */
-export function exactPlainSketchRevolveSolid(cad, sketchProfile, sketchRevolve, targetShape, sectionScale = { radial: 1, axial: 1 }) {
-    if (!sketchRevolve || (sketchRevolve.pitch ?? 0) !== 0 || (sketchRevolve.coreRadius ?? 0) !== 0
-        || Math.abs(Math.abs(sketchRevolve.sweepAngle) - 360) > 1e-6) {
-        throw new ServerCadError("Exact revolve geometry requires a plain full-turn sketch revolve.");
-    }
+/**
+ * A revolve's section as a sketch profile in the OCCT build frame, at the given
+ * section scale: x is the distance from the axis and z runs up it from the
+ * revolve's base, the same polygons the mesh sweep turns.
+ */
+function revolveSectionProfile(sketchProfile, sketchRevolve, sectionScale) {
     const polygons = sketchProfileToRevolvePolygons(sketchProfile, sketchRevolve);
     if (polygons.length === 0)
         throw new ServerCadError("The retained revolve profile has no closed region.");
-    const profile = {
+    return {
         points: polygons.flatMap((polygon, polygonIndex) => polygon.map(([x, z], pointIndex) => ({
             id: `revolve-${polygonIndex}-point-${pointIndex}`,
             x: x * sectionScale.radial,
@@ -536,25 +790,44 @@ export function exactPlainSketchRevolveSolid(cad, sketchProfile, sketchRevolve,
             kind: "line",
         }))),
     };
+}
+/**
+ * The exact solid of a plain revolve's one section region, turned through its
+ * sweep about the Y axis, in the frame the mesh sweep builds before centring.
+ *
+ * Manifold sweeps from +X towards the editor's -Z and then turns the result by
+ * the start angle (or, for a negative sweep, by where the sweep ends), which
+ * is what a positive OCCT rotation about +Y does too, so the two agree for a
+ * partial sweep as well as for a full turn.
+ */
+function revolvedSectionSolid(cad, sketchProfile, sketchRevolve, sectionScale) {
+    const profile = revolveSectionProfile(sketchProfile, sketchRevolve, sectionScale);
     const pathWire = (path) => cad.makeWire(path.steps.map(({ from, to }) => cad.makeLineEdge({ x: from.x, y: from.z, z: 0 }, { x: to.x, y: to.z, z: 0 })));
     const regions = cadSketchRegions(profile);
     if (regions.length !== 1) {
         throw new ServerCadError("Exact revolve geometry requires one closed profile region, and this revolve's profile has several.");
     }
-    const solids = regions.map((region) => {
-        let face = cad.makeFace(pathWire(region.outer));
-        if (region.holes.length)
-            face = cad.addHolesInFace(face, region.holes.map(pathWire));
-        const solid = cad.revolve(face, {
-            point: { x: 0, y: 0, z: 0 },
-            direction: { x: 0, y: 1, z: 0 },
-        }, Math.PI * 2);
-        return Math.abs(sketchRevolve.startAngle) < 1e-8 ? solid : cad.rotate(solid, {
-            point: { x: 0, y: 0, z: 0 },
-            direction: { x: 0, y: 1, z: 0 },
-        }, (sketchRevolve.startAngle * Math.PI) / 180);
-    });
-    let solid = solids[0];
+    const axis = { point: { x: 0, y: 0, z: 0 }, direction: { x: 0, y: 1, z: 0 } };
+    const region = regions[0];
+    let face = cad.makeFace(pathWire(region.outer));
+    if (region.holes.length)
+        face = cad.addHolesInFace(face, region.holes.map(pathWire));
+    const sweep = Math.abs(sketchRevolve.sweepAngle);
+    const solid = cad.revolve(face, axis, Math.abs(sweep - 360) <= 1e-6 ? Math.PI * 2 : (sweep * Math.PI) / 180);
+    const rotation = sketchRevolve.sweepAngle < 0 ? sketchRevolve.startAngle + sketchRevolve.sweepAngle : sketchRevolve.startAngle;
+    return Math.abs(rotation) < 1e-8 ? solid : cad.rotate(solid, axis, (rotation * Math.PI) / 180);
+}
+/** Build the analytical BREP for a plain, single-region full-turn revolve. */
+export function exactPlainSketchRevolveSolid(cad, sketchProfile, sketchRevolve, targetShape, sectionScale = { radial: 1, axial: 1 }) {
+    if (!sketchRevolve || (sketchRevolve.pitch ?? 0) !== 0 || (sketchRevolve.coreRadius ?? 0) !== 0
+        || Math.abs(Math.abs(sketchRevolve.sweepAngle) - 360) > 1e-6) {
+        throw new ServerCadError("Exact revolve geometry requires a plain full-turn sketch revolve.");
+    }
+    // A full turn starts where its start angle says, whichever way it is swept.
+    let solid = revolvedSectionSolid(cad, sketchProfile, { ...sketchRevolve, sweepAngle: 360 }, sectionScale);
+    // Callers that cannot express a resized revolve analytically (for example,
+    // exact face listing of a radially elliptical legacy shape) use this bounds
+    // fit. Face drafting of a supported resize passes profile scales instead.
     if (targetShape?.importedMesh && targetShape.width > 0 && targetShape.depth > 0 && targetShape.height > 0) {
         const bounds = cad.getBoundingBox(solid, false);
         const sx = targetShape.width / Math.max(bounds.xmax - bounds.xmin, 1e-9);
@@ -570,25 +843,6 @@ export function exactPlainSketchRevolveSolid(cad, sketchProfile, sketchRevolve,
         throw new ServerCadError("The retained sketch revolve could not be rebuilt as exact CAD geometry.");
     return solid;
 }
-function scaleRevolveResult(cad, solid, shape) {
-    const mesh = shape.importedMesh;
-    if (!mesh)
-        return solid;
-    const factors = [
-        shape.width / Math.max(mesh.baseWidth ?? shape.width, 1e-9),
-        shape.height / Math.max(mesh.baseHeight ?? shape.height, 1e-9),
-        shape.depth / Math.max(mesh.baseDepth ?? shape.depth, 1e-9),
-    ];
-    if (factors.every((factor) => Math.abs(factor - 1) < 1e-8))
-        return solid;
-    const bounds = cad.getBoundingBox(solid, false);
-    const [sx, sy, sz] = factors;
-    return cad.transform(solid, [
-        sx, 0, 0, -(bounds.xmin + bounds.xmax) * sx / 2,
-        0, sy, 0, -bounds.ymin * sy,
-        0, 0, sz, -(bounds.zmin + bounds.zmax) * sz / 2,
-    ]);
-}
 /** Rebuild the exact CAD representation of an eligible retained revolve. */
 export function exactPlainSketchRevolveResult(shape) {
     if (!shape.sketchProfile || !isPlainFullTurnSketchRevolve(shape)) {
@@ -620,18 +874,15 @@ export function applyDraftPrism(shape, request) {
     if (shape.sketchOperation !== "extrude" || !shape.sketchProfile) {
         return Promise.reject(new ServerCadError("Draft prism requires a sketch extrusion with its source profile retained.", 400));
     }
-    const { points, segments } = shape.sketchProfile;
-    if (points.length < 3 || segments.length !== points.length
-        || segments.some((segment, index) => segment.kind && segment.kind !== "line"
-            || segment.startId !== points[index].id
-            || segment.endId !== points[(index + 1) % points.length].id)
-        || points.some((point) => point.handleIn || point.handleOut || !Number.isFinite(point.x) || !Number.isFinite(point.z))) {
-        return Promise.reject(new ServerCadError("Draft prism currently requires one closed polygonal sketch profile made from straight segments.", 400));
-    }
+    const scale = sketchResizeFactors(shape);
+    const profile = scaledSketchProfile(shape.sketchProfile, scale.width, scale.depth);
+    const loop = draftPrismLoop(profile);
+    if (typeof loop === "string")
+        return Promise.reject(new ServerCadError(loop, 400));
     return withCadKernel((cad) => {
-        const { x: centerX, z: centerZ } = draftPrismProfileOffset(shape.sketchProfile);
-        const edges = points.map((point, index) => {
-            const next = points[(index + 1) % points.length];
+        const { x: centerX, z: centerZ } = draftPrismProfileOffset(profile);
+        const edges = loop.map((point, index) => {
+            const next = loop[(index + 1) % loop.length];
             return cad.makeLineEdge({ x: point.x - centerX, y: 0, z: point.z - centerZ }, { x: next.x - centerX, y: 0, z: next.z - centerZ });
         });
         const face = cad.makeFace(cad.makeWire(edges));
@@ -657,17 +908,42 @@ export function applySketchFaceDraft(shape, request) {
         return Promise.reject(new ServerCadError("The face draft angle must be non-zero and between -45 and 45 degrees.", 400));
     }
     const exactRevolve = isPlainFullTurnSketchRevolve(shape);
+    if (exactRevolve) {
+        const resize = revolveResizeFactors(shape);
+        if (Math.abs(resize.radialX - resize.radialZ) > 1e-6 * Math.max(resize.radialX, resize.radialZ)) {
+            return Promise.reject(new ServerCadError("Face drafting requires an equal resize across the revolve's radial axes; unequal radial resizing makes an elliptical shape that cannot be drafted exactly.", 400));
+        }
+    }
     if ((!exactRevolve && shape.sketchOperation !== "extrude" && shape.sketchOperation !== "sweep")
         || !shape.sketchProfile || (!shape.cadBrep && !exactRevolve)) {
         return Promise.reject(new ServerCadError("Face drafts require an exact retained sketch extrusion, sweep, or plain full-turn revolve.", 400));
     }
     return withCadKernel((cad) => {
-        const solid = exactRevolve
-            ? exactPlainSketchRevolveSolid(cad, shape.sketchProfile, shape.sketchRevolve, shape)
-            : solidFromBrep(cad, shape.cadBrep);
+        let solid;
+        if (exactRevolve) {
+            const resize = revolveResizeFactors(shape);
+            const hasResize = [resize.radialX, resize.radialZ, resize.axial]
+                .some((factor) => Math.abs(factor - 1) > 1e-8);
+            solid = hasResize
+                ? exactPlainSketchRevolveSolid(cad, shape.sketchProfile, shape.sketchRevolve, undefined, {
+                    radial: resize.radialX,
+                    axial: resize.axial,
+                })
+                : exactPlainSketchRevolveSolid(cad, shape.sketchProfile, shape.sketchRevolve, shape);
+        }
+        else {
+            solid = solidFromBrep(cad, shape.cadBrep);
+        }
+        const resize = sketchResizeFactors(shape);
+        if (!exactRevolve && shape.sketchOperation === "extrude" && isResized(resize)) {
+            solid = sketchExtrusionSolid(cad, scaledSketchProfile(shape.sketchProfile, resize.width, resize.depth), shape.height);
+            if (!cadResultIsValid(cad, solid) || !cad.isSolid(solid)) {
+                throw new ServerCadError("The resized sketch extrusion could not be rebuilt as exact CAD geometry.");
+            }
+        }
         const faces = cad.getSubShapes(solid, "face");
         const ids = shape.faceIds?.length === faces.length ? shape.faceIds
-            : exactRevolve && !shape.faceColors ? faces.map((_, index) => `face_${encodeURIComponent(shape.id)}_${index}`)
+            : exactRevolve ? faces.map((_, index) => `face_${encodeURIComponent(shape.id)}_${index}`)
                 : undefined;
         if (!ids || ids.length !== faces.length || new Set(ids).size !== faces.length) {
             throw new ServerCadError("Face drafting requires a complete, unique stable face ID list.");
@@ -684,12 +960,14 @@ export function applySketchFaceDraft(shape, request) {
         if (!cadResultIsValid(cad, drafted) || !cad.isSolid(drafted)) {
             throw new ServerCadError("The face draft did not produce a valid solid.");
         }
-        return meshedCadResult(cad, exactRevolve ? scaleRevolveResult(cad, drafted, shape) : drafted, shape);
+        return meshedCadResult(cad, drafted, shape, undefined, solid);
     });
 }
 /** The exact geometry and a mesh of it, which is what a shape stores after any CAD operation. */
-export function meshedCadResult(cad, result, sourceShape, lineage, sourceSolid) {
-    const mesh = cad.meshShape(result, { linearDeflection: MESH_DEFLECTION });
+export function meshedCadResult(cad, result, sourceShape, lineage, sourceSolid, angularDeflection) {
+    const mesh = cad.meshShape(result, angularDeflection
+        ? { linearDeflection: MESH_DEFLECTION, angularDeflection }
+        : { linearDeflection: MESH_DEFLECTION });
     // The editor stores a flat triangle list, not an indexed mesh, so the
     // indices are expanded here rather than carried.
     const positions = [];
@@ -770,6 +1048,12 @@ export function shapeWithCadResult(shape, result) {
     }));
     return canonicalizeShape({
         ...shape,
+        // A baked rotation can move the bounds away from the source's pivot. The
+        // mesh is rebased to those bounds, so move its project origin by the same
+        // offset. Other results keep the source frame they were built in.
+        x: shape.x + (bakedRotation ? centerX : 0),
+        z: shape.z + (bakedRotation ? centerZ : 0),
+        elevation: (shape.elevation ?? 0) + (bakedRotation ? minY : 0),
         faceIds: result.faceIds,
         faceColors: Object.keys(survivingColors).length ? survivingColors : undefined,
         kind: "mesh",
@@ -816,7 +1100,8 @@ export function shapeWithCadResult(shape, result) {
         // was created -- which is where a test shape sits -- subtracts zero.
         //
         // These are the result's own bounds, which is what the editor's worker
-        // records for exactly the same reason.
+        // records for exactly the same reason, and what both cut writers now
+        // record for a cut's recentred B-rep (#548).
         cadBrepFrame: { x: centerX, z: centerZ, elevation: minY, width, depth, height },
         cadPrimitiveFrame: undefined,
         cadDisplayEdges: undefined,