@constructorfleet/sketchforge-engine 1.27.0 → 1.28.0

package/dist/serverCadOperations.d.ts

@@ -12,7 +12,9 @@
  * 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 type { EvolutionData, OcctKernel, ShapeHandle } from "occt-wasm";
 import type { SketchProfile, WorkplaneShape } from "./domain/sketchforge.js";
@@ -48,6 +50,28 @@ export declare class ServerCadError extends Error {
     constructor(message: string, status?: number);
 }
 export type { SketchFaceDraftRequest } from "./sketchFaceDraftKernel.js";
+/**
+ * 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 declare function sketchResizeFactors(shape: WorkplaneShape): {
+    width: number;
+    depth: number;
+    height: number;
+};
+/**
+ * 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 declare function resizedSketchExtrusionProfile(shape: WorkplaneShape): SketchProfile | null;
 /**
  * Whether the kernel considers a shape sound.
  *
@@ -58,8 +82,17 @@ export type { SketchFaceDraftRequest } from "./sketchFaceDraftKernel.js";
  * own check, so the two paths agree about what a usable result is.
  */
 export declare function cadResultIsValid(cad: OcctKernel, shape: ShapeHandle): boolean;
-/** 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 declare function solidFromMeshPositions(cad: OcctKernel, positions: number[]): ShapeHandle;
+/** The exact path's refusal for a mesh error the kernel-free measures throw; anything else unchanged. */
+export declare function asServerCadError(error: unknown): unknown;
 /**
  * Whether a treated result has the shape's rotation baked into its geometry.
  *
@@ -97,7 +130,9 @@ export declare function localSolidForShape(cad: OcctKernel, shape: WorkplaneShap
  * 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
@@ -137,6 +172,40 @@ export declare function applyBakedMirror(shape: WorkplaneShape, axis: "x" | "y"
 export declare function applyEdgeTreatment(shape: WorkplaneShape, treatment: ServerCadTreatment): Promise<ServerCadResult>;
 /** Count currently chamferable/filletable edges without preserving topology indexes. */
 export declare function allEdgeTreatmentEdgeCount(shape: WorkplaneShape, _kind: ServerCadTreatment["kind"]): Promise<number>;
+/**
+ * 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 declare function hasExactRevolveSolid(shape: WorkplaneShape): boolean;
+/**
+ * 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 declare function exactRevolveAngularDeflection(shapes: readonly WorkplaneShape[]): number | 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 declare function exactRevolveLocalSolid(cad: OcctKernel, shape: WorkplaneShape): ShapeHandle | null;
 /**
  * The solid `GET /edges` numbers and a fillet or chamfer rounds.
  *
@@ -174,7 +243,7 @@ export declare function applySketchFaceDraft(shape: WorkplaneShape, request: Ske
 export declare function meshedCadResult(cad: OcctKernel, result: ShapeHandle, sourceShape?: WorkplaneShape, lineage?: {
     sourceFaceHashes: number[];
     evolution: EvolutionData;
-}, sourceSolid?: ShapeHandle): ServerCadResult;
+}, sourceSolid?: ShapeHandle, angularDeflection?: number): ServerCadResult;
 /**
  * The shape as it stands after a treatment.
  *

package/dist/serverCadOperations.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"serverCadOperations.d.ts","sourceRoot":"","sources":["../src/serverCadOperations.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"serverCadOperations.d.ts","sourceRoot":"","sources":["../src/serverCadOperations.ts"],"names":[],"mappings":"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"}

package/dist/serverCadOperations.js

@@ -12,17 +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;
@@ -35,9 +40,16 @@ 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;
-function sketchResizeFactors(shape) {
+/**
+ * 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;
-    if (shape.faceDraftSourceScale)
+    // 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 {
@@ -60,6 +72,39 @@ function scaledSketchProfile(profile, width, 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;
@@ -117,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))
@@ -139,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.
@@ -209,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
@@ -217,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);
     }
@@ -417,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
@@ -524,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.
  *
@@ -547,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,
@@ -569,25 +790,41 @@ 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.
@@ -639,18 +876,13 @@ export function applyDraftPrism(shape, request) {
     }
     const scale = sketchResizeFactors(shape);
     const profile = scaledSketchProfile(shape.sketchProfile, scale.width, scale.depth);
-    const { points, segments } = profile;
-    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 loop = draftPrismLoop(profile);
+    if (typeof loop === "string")
+        return Promise.reject(new ServerCadError(loop, 400));
     return withCadKernel((cad) => {
         const { x: centerX, z: centerZ } = draftPrismProfileOffset(profile);
-        const edges = points.map((point, index) => {
-            const next = points[(index + 1) % points.length];
+        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));
@@ -703,8 +935,7 @@ export function applySketchFaceDraft(shape, request) {
             solid = solidFromBrep(cad, shape.cadBrep);
         }
         const resize = sketchResizeFactors(shape);
-        if (!exactRevolve && shape.sketchOperation === "extrude"
-            && [resize.width, resize.depth, resize.height].some((factor) => Math.abs(factor - 1) > 1e-8)) {
+        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.");
@@ -712,7 +943,7 @@ export function applySketchFaceDraft(shape, request) {
         }
         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.");
@@ -733,8 +964,10 @@ export function applySketchFaceDraft(shape, request) {
     });
 }
 /** 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 = [];
@@ -867,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,