@constructorfleet/sketchforge-engine 1.18.0 → 1.20.0

package/dist/engine.js

@@ -14,7 +14,7 @@
  * -- including the project lock, which a macro writing a directory needs and
  * does not have today -- without pulling `next/server` in with it.
  */
-import { applyEdgeTreatment, applyBakedMirror, applyDraftPrism, shapeEdges, shapeWithCadResult, ServerCadError, } from "./serverCadOperations.js";
+import { allEdgeTreatmentEdgeCount, applyEdgeTreatment, applyBakedMirror, applyDraftPrism, applySketchFaceDraft, exactPlainSketchRevolveResult, isPlainFullTurnSketchRevolve, shapeEdges, shapeWithCadResult, ServerCadError, } from "./serverCadOperations.js";
 import { applyShell, shapeFaces, } from "./serverCadShell.js";
 import { measureBetween as measureBetweenEntities, shapeMeasurements, } from "./serverCadMeasure.js";
 import { shapeProperties } from "./serverCadProperties.js";
@@ -31,11 +31,53 @@ import { boundsForShapes as boundsForMirroring, restoreGroupedChildren, separate
 import { serverManifoldRuntime } from "./serverManifoldRuntime.js";
 import { createLocalId } from "./localIds.js";
 import { invalidSketchSweepProfile, sketchSweepShapeFromRequest } from "./sketchSweepRequest.js";
-import { findSketchOutput, recomputeSketchOutput } from "./parametricRecompute.js";
+import { sketchExtrusionShapeFromRequest } from "./sketchExtrusionRequest.js";
+import { findSketchOutput, recomputeSketchOutput, replaySingleAllEdgeTreatment } from "./parametricRecompute.js";
 import { boundsForShapes, footprintCenter, shapeBounds } from "./shapeBounds.js";
 import { REQUESTABLE_SHAPE_KINDS, shapeFromRequest, shapeWithRequestedChanges, SHAPE_PARAMETERS, } from "./shapeRequests.js";
 import { canonicalizeShape, cleanNearZero, cleanRotationDegrees, cloneWorkplaneShapeTreeWithFreshIds, withHoleMode, } from "./workplaneShapes.js";
 const UNIQUE_CURVED_FACE_SURFACES = new Set(["cone", "sphere", "torus", "cylinder"]);
+const FACE_DRAFT_AXES = new Set(["x", "y", "z", "-x", "-y", "-z"]);
+function faceDraftInput(value) {
+    if (!value || typeof value !== "object" || Array.isArray(value))
+        return null;
+    const draft = value;
+    if (typeof draft.sourceFaceId !== "string" || !draft.sourceFaceId.trim()
+        || typeof draft.angle !== "number" || !Number.isFinite(draft.angle) || draft.angle === 0 || Math.abs(draft.angle) >= 45
+        || typeof draft.pullDirection !== "string" || !FACE_DRAFT_AXES.has(draft.pullDirection))
+        return null;
+    return {
+        sourceFaceId: draft.sourceFaceId,
+        angle: draft.angle,
+        pullDirection: draft.pullDirection,
+    };
+}
+function revolveSourceScale(shape) {
+    const mesh = shape.importedMesh;
+    const ratio = (drawn, natural) => natural && natural > 0 ? drawn / natural : 1;
+    return {
+        width: ratio(shape.width, mesh?.baseWidth),
+        depth: ratio(shape.depth, mesh?.baseDepth),
+        height: ratio(shape.height, mesh?.baseHeight),
+    };
+}
+function resizeRebuiltRevolve(shape, scale) {
+    const mesh = shape.importedMesh;
+    if (!mesh)
+        return shape;
+    const width = Math.max(0.01, (mesh.baseWidth ?? shape.width) * scale.width);
+    const depth = Math.max(0.01, (mesh.baseDepth ?? shape.depth) * scale.depth);
+    const height = Math.max(0.01, (mesh.baseHeight ?? shape.height) * scale.height);
+    return { ...shape, width, depth, height, size: Math.max(width, depth) };
+}
+function faceNormalMatches(left, right) {
+    return Math.hypot(left.x - right.x, left.y - right.y, left.z - right.z) <= 1e-5;
+}
+async function findUniqueDraftFace(shape, normal) {
+    const matches = (await shapeFaces(shape)).filter((face) => face.surfaceType === "plane" && face.normal
+        && faceNormalMatches(face.normal, normal));
+    return matches.length === 1 ? matches[0] : null;
+}
 /**
  * Carry face metadata across a parameter edit only when a face has a unique
  * counterpart. Curved faces may change their sampled normal as their defining
@@ -330,13 +372,33 @@ export function createEngine(store) {
         });
     }
     /** The shared tail of `treat` and `shell`: run the kernel, store the result on the shape. */
-    async function cadTreatment(projectId, shapeId, run) {
+    async function cadTreatment(projectId, shapeId, operation, run) {
         return mutating(projectId, async (document) => {
             const found = oneShape(document, shapeId);
             if (!found.ok)
                 return found;
             if (found.value.locked)
                 return failed({ reason: "shape_locked", ids: [shapeId] });
+            const hasEdgeTreatments = (found.value.edgeTreatments?.length ?? 0) > 0
+                || (found.value.edgeTreatmentHistory?.length ?? 0) > 0;
+            const hasDraftPrism = found.value.draftPrismAngle !== undefined;
+            const replayableDraftTreatment = operation === "all-edge-treatment"
+                && !hasEdgeTreatments
+                && found.value.sketchOperation === "extrude"
+                && Boolean(found.value.sketchProfile)
+                && hasDraftPrism;
+            const incompatible = found.value.faceDraft !== undefined
+                || operation === "edge-treatment" && hasDraftPrism
+                || operation === "all-edge-treatment" && hasDraftPrism && !replayableDraftTreatment
+                || operation === "prism-draft" && hasEdgeTreatments
+                || operation === "shell" && (found.value.draftPrismAngle !== undefined || hasEdgeTreatments);
+            if (incompatible) {
+                return failed({
+                    reason: "cad_refused",
+                    message: "Face drafts cannot be combined with edge treatments, prism drafts, or shelling. Draft prisms only support one all-edge treatment on a retained sketch extrusion; shelling cannot be combined with persisted draft or treatment features.",
+                    status: 422,
+                });
+            }
             let changed;
             try {
                 changed = await run(found.value);
@@ -412,11 +474,15 @@ export function createEngine(store) {
         changeShape: (projectId, shapeId, changes) => mutating(projectId, async (document) => {
             const byOutputId = oneShape(document, shapeId);
             // A persisted sketch source is an input node, not a renderable shape.
-            // When a caller edits that node's profile, resolve its dependent sweep
-            // output and rebuild it before the single project write below. The
+            // When a caller edits that node's profile or revolve settings, resolve
+            // its dependent output and rebuild it before the single project write. The
             // output keeps its own stable object ID; SKF export derives the source
             // node from the synchronized profile on that output.
-            const sourceOutputs = !byOutputId.ok && changes.sketchProfile !== undefined
+            const sourceFeatureInputChanged = changes.sketchProfile !== undefined
+                || changes.draftPrismAngle !== undefined
+                || Object.hasOwn(changes, "faceDraft")
+                || REVOLVE_CHANGE_FIELDS.some((field) => changes[field] !== undefined);
+            const sourceOutputs = !byOutputId.ok && sourceFeatureInputChanged
                 ? findSketchOutput(document.shapes, shapeId)
                 : [];
             const sourceSketchTarget = !byOutputId.ok && sourceOutputs.length === 1;
@@ -429,7 +495,9 @@ export function createEngine(store) {
                 return found;
             const existing = found.value;
             if (sourceSketchTarget) {
-                const outputFields = Object.keys(changes).filter((field) => field !== "sketchProfile");
+                const isRevolveSource = isRevolveShape(existing);
+                const outputFields = Object.keys(changes).filter((field) => field !== "sketchProfile" && field !== "draftPrismAngle" && field !== "faceDraft"
+                    && !(isRevolveSource && REVOLVE_CHANGE_FIELDS.includes(field)));
                 if (outputFields.length > 0) {
                     return failed({ reason: "unapplicable_fields", kind: existing.kind, fields: outputFields, because: "not_this_kind" });
                 }
@@ -440,8 +508,48 @@ export function createEngine(store) {
             if (existing.locked && changes.locked !== false)
                 return failed({ reason: "shape_locked", ids: [shapeId] });
             const replacingSketchProfile = changes.sketchProfile !== undefined;
+            const faceDraftChanged = Object.hasOwn(changes, "faceDraft");
+            const clearingFaceDraft = faceDraftChanged && changes.faceDraft === null && existing.faceDraft !== undefined;
+            const requestedFaceDraft = faceDraftChanged
+                ? changes.faceDraft === null ? undefined : faceDraftInput(changes.faceDraft)
+                : existing.faceDraft;
             const isSketchSweep = existing.sketchOperation === "sweep" && Boolean(existing.sketchProfile);
-            if (replacingSketchProfile && !isSketchSweep) {
+            const isSketchExtrusion = existing.sketchOperation === "extrude" && Boolean(existing.sketchProfile);
+            const isSketchRevolve = isRevolveShape(existing);
+            if (faceDraftChanged && changes.faceDraft !== null && !requestedFaceDraft) {
+                return failed({ reason: "invalid_shape_request", message: "A face draft requires a stable source face ID, a non-zero angle below 45 degrees, and a signed local pull axis." });
+            }
+            const isExactSketchRevolve = isPlainFullTurnSketchRevolve(existing);
+            if ((faceDraftChanged || (replacingSketchProfile && existing.faceDraft))
+                && !isSketchExtrusion && !isSketchSweep && !isExactSketchRevolve) {
+                return failed({ reason: "unapplicable_fields", kind: existing.kind, fields: ["faceDraft"], because: "not_this_kind" });
+            }
+            if (requestedFaceDraft
+                && ((existing.edgeTreatments?.length ?? 0) > 0 || (existing.edgeTreatmentHistory?.length ?? 0) > 0
+                    || existing.draftPrismAngle !== undefined)) {
+                return failed({ reason: "invalid_shape_request", message: "Face drafts cannot be combined with prism drafts or edge treatments yet." });
+            }
+            if (faceDraftChanged && existing.faceDraft && requestedFaceDraft
+                && requestedFaceDraft.sourceFaceId !== existing.faceDraft.sourceFaceId) {
+                return failed({ reason: "invalid_shape_request", message: "Clear the existing face draft before selecting a different source face." });
+            }
+            const draftPrismChanged = changes.draftPrismAngle !== undefined;
+            const requestedDraftPrismAngle = typeof changes.draftPrismAngle === "number" ? changes.draftPrismAngle : undefined;
+            if (draftPrismChanged && (!isSketchExtrusion || requestedDraftPrismAngle === undefined || !Number.isFinite(requestedDraftPrismAngle)
+                || requestedDraftPrismAngle === 0 || Math.abs(requestedDraftPrismAngle) >= 45)) {
+                return failed({
+                    reason: "invalid_shape_request",
+                    message: "A draft prism angle must be non-zero and between -45 and 45 degrees on a sketch extrusion.",
+                });
+            }
+            if (draftPrismChanged && requestedFaceDraft) {
+                return failed({ reason: "invalid_shape_request", message: "Face drafts cannot be combined with prism drafts yet." });
+            }
+            if (draftPrismChanged && existing.draftPrismAngle === undefined
+                && ((existing.edgeTreatments?.length ?? 0) > 0 || (existing.edgeTreatmentHistory?.length ?? 0) > 0)) {
+                return failed({ reason: "invalid_shape_request", message: "A prism draft cannot be added after an edge treatment." });
+            }
+            if (replacingSketchProfile && !isSketchSweep && !isSketchExtrusion && !isSketchRevolve) {
                 return failed({ reason: "unapplicable_fields", kind: existing.kind, fields: ["sketchProfile"], because: "no_sweep" });
             }
             const sweptShape = isRevolveShape(existing);
@@ -454,18 +562,100 @@ export function createEngine(store) {
             // leave a thread's pitch readable but not writable.
             const revolveChanges = sweptShape ? REVOLVE_CHANGE_FIELDS.filter((field) => changes[field] !== undefined) : [];
             let swept = existing;
-            if (replacingSketchProfile && isSketchSweep) {
-                const invalidProfile = invalidSketchSweepProfile(changes.sketchProfile);
+            if ((replacingSketchProfile && isSketchExtrusion) || (draftPrismChanged && isSketchExtrusion)
+                || (faceDraftChanged && isSketchExtrusion)) {
+                const sourceFrame = existing.faceDraftSourceFrame ?? existing.draftPrismSourceFrame ?? existing.cadBrepFrame;
+                const sourceHeight = existing.draftPrismSourceHeight ?? existing.faceDraftSourceFrame?.height ?? existing.height;
+                try {
+                    const rebuilt = await sketchExtrusionShapeFromRequest({
+                        id: existing.id,
+                        sketchSourceId: existing.sketchSourceId ?? `sketch/${existing.id}`,
+                        name: existing.name,
+                        color: existing.color,
+                        hole: existing.hole,
+                        profile: replacingSketchProfile ? changes.sketchProfile : existing.sketchProfile,
+                        height: sourceHeight,
+                        x: existing.x - (sourceFrame?.x ?? 0),
+                        z: existing.z - (sourceFrame?.z ?? 0),
+                        elevation: (existing.elevation ?? 0) - (sourceFrame?.elevation ?? 0),
+                        rotation: existing.rotation,
+                        rotationX: existing.rotationX,
+                        rotationZ: existing.rotationZ,
+                    });
+                    const { faceIds: _oldFaceIds, faceColors: _faceColors, edgeTreatments: _edgeTreatments, edgeTreatmentHistory: _edgeTreatmentHistory, cadDisplayEdges: _cadDisplayEdges, cadDisplayEdgesVersion: _cadDisplayEdgesVersion, ...sourceMetadata } = existing;
+                    const draftPrismAngle = draftPrismChanged ? requestedDraftPrismAngle : existing.draftPrismAngle;
+                    const rebuiltSource = {
+                        ...sourceMetadata,
+                        ...rebuilt,
+                        id: existing.id,
+                        sketchSourceId: existing.sketchSourceId ?? rebuilt.sketchSourceId,
+                        faceDraft: undefined,
+                        faceDraftSourceFrame: undefined,
+                        ...(draftPrismAngle === undefined ? {} : {
+                            draftPrismSourceHeight: sourceHeight,
+                            ...(sourceFrame ? { draftPrismSourceFrame: sourceFrame } : {}),
+                        }),
+                    };
+                    const hasRetainedTreatments = (existing.edgeTreatments?.length ?? 0) > 0
+                        || (existing.edgeTreatmentHistory?.length ?? 0) > 0;
+                    const replayDraftAndTreatment = hasRetainedTreatments
+                        && draftPrismAngle !== undefined
+                        && (replacingSketchProfile || clearingFaceDraft || draftPrismChanged);
+                    const replayedSource = (replacingSketchProfile || clearingFaceDraft || draftPrismChanged) && hasRetainedTreatments
+                        ? await replaySingleAllEdgeTreatment(clearingFaceDraft ? { ...existing, faceDraft: undefined } : existing, rebuiltSource, draftPrismChanged ? requestedDraftPrismAngle : undefined)
+                        : rebuiltSource;
+                    if (requestedFaceDraft) {
+                        const priorReference = existing.faceDraft?.sourceFaceId === requestedFaceDraft.sourceFaceId
+                            ? existing.faceDraft.sourceFaceNormal
+                            : undefined;
+                        const selectedOnPrior = priorReference ? undefined
+                            : (await shapeFaces(existing, isExactSketchRevolve ? { topology: "exact" } : undefined))
+                                .find((face) => face.id === requestedFaceDraft.sourceFaceId);
+                        const sourceFaceNormal = priorReference ?? selectedOnPrior?.normal;
+                        if (!sourceFaceNormal || selectedOnPrior && selectedOnPrior.surfaceType !== "plane") {
+                            throw new Error("The selected source face has no stable planar reference.");
+                        }
+                        const currentFace = await findUniqueDraftFace(replayedSource, sourceFaceNormal);
+                        if (!currentFace)
+                            throw new Error("The selected source face is missing or ambiguous after the sketch edit.");
+                        const faceDraft = { ...requestedFaceDraft, sourceFaceNormal };
+                        const result = await applySketchFaceDraft(replayedSource, {
+                            ...requestedFaceDraft,
+                            sourceFaceId: currentFace.id,
+                        });
+                        swept = {
+                            ...shapeWithCadResult(replayedSource, result),
+                            faceDraft,
+                            faceDraftSourceFrame: existing.faceDraftSourceFrame ?? existing.cadBrepFrame,
+                        };
+                    }
+                    else if (draftPrismAngle !== undefined && !replayDraftAndTreatment) {
+                        swept = {
+                            ...shapeWithCadResult(replayedSource, await applyDraftPrism(replayedSource, { angle: draftPrismAngle })),
+                            draftPrismAngle,
+                        };
+                    }
+                    else {
+                        swept = replayedSource;
+                    }
+                }
+                catch (error) {
+                    return failed({ reason: "sweep_failed", message: error instanceof Error ? error.message : "The sketch extrusion could not be rebuilt." });
+                }
+            }
+            if ((replacingSketchProfile || faceDraftChanged) && isSketchSweep) {
+                const profileToBuild = replacingSketchProfile ? changes.sketchProfile : existing.sketchProfile;
+                const invalidProfile = replacingSketchProfile ? invalidSketchSweepProfile(profileToBuild) : undefined;
                 if (invalidProfile)
                     return failed({ reason: "invalid_shape_request", message: invalidProfile });
-                const frame = existing.cadBrepFrame;
+                const frame = existing.faceDraftSourceFrame ?? existing.cadBrepFrame;
                 try {
                     const rebuilt = await sketchSweepShapeFromRequest({
                         id: existing.id,
                         name: existing.name,
                         color: existing.color,
                         hole: existing.hole,
-                        profile: changes.sketchProfile,
+                        profile: profileToBuild,
                         x: existing.x - (frame?.x ?? 0),
                         z: existing.z - (frame?.z ?? 0),
                         elevation: (existing.elevation ?? 0) - (frame?.elevation ?? 0),
@@ -487,14 +677,47 @@ export function createEngine(store) {
                     resized.size = Math.max(resized.width, resized.depth);
                     const refreshedFaceIds = (await shapeFaces(rebuilt))
                         .map((face) => `face_${createLocalId(`${existing.id}-${face.index}`)}`);
-                    const { faceIds: _oldFaceIds, faceColors: _faceColors, edgeTreatments: _edgeTreatments, edgeTreatmentHistory: _edgeTreatmentHistory, cadDisplayEdges: _cadDisplayEdges, cadDisplayEdgesVersion: _cadDisplayEdgesVersion, ...sourceMetadata } = existing;
-                    swept = {
+                    const { faceIds: _oldFaceIds, faceColors: _faceColors, edgeTreatments: _edgeTreatments, edgeTreatmentHistory: _edgeTreatmentHistory, cadDisplayEdges: _cadDisplayEdges, cadDisplayEdgesVersion: _cadDisplayEdgesVersion, faceDraft: _faceDraft, faceDraftSourceFrame: _faceDraftSourceFrame, ...sourceMetadata } = existing;
+                    const rebuiltSweep = {
                         ...sourceMetadata,
                         ...resized,
                         id: existing.id,
                         sketchSourceId: existing.sketchSourceId ?? rebuilt.sketchSourceId,
                         faceIds: refreshedFaceIds,
+                        faceDraft: undefined,
+                        faceDraftSourceFrame: undefined,
                     };
+                    const replayedSource = replacingSketchProfile || clearingFaceDraft
+                        ? await replaySingleAllEdgeTreatment(clearingFaceDraft ? { ...existing, faceDraft: undefined } : existing, rebuiltSweep)
+                        : rebuiltSweep;
+                    if (requestedFaceDraft) {
+                        const priorReference = existing.faceDraft?.sourceFaceId === requestedFaceDraft.sourceFaceId
+                            ? existing.faceDraft.sourceFaceNormal
+                            : undefined;
+                        const selectedOnPrior = priorReference ? undefined
+                            : (await shapeFaces(existing, isExactSketchRevolve ? { topology: "exact" } : undefined))
+                                .find((face) => face.id === requestedFaceDraft.sourceFaceId);
+                        const sourceFaceNormal = priorReference ?? selectedOnPrior?.normal;
+                        if (!sourceFaceNormal || selectedOnPrior && selectedOnPrior.surfaceType !== "plane") {
+                            throw new Error("The selected source face has no stable planar reference.");
+                        }
+                        const currentFace = await findUniqueDraftFace(replayedSource, sourceFaceNormal);
+                        if (!currentFace)
+                            throw new Error("The selected source face is missing or ambiguous after the sketch edit.");
+                        const faceDraft = { ...requestedFaceDraft, sourceFaceNormal };
+                        const result = await applySketchFaceDraft(replayedSource, {
+                            ...requestedFaceDraft,
+                            sourceFaceId: currentFace.id,
+                        });
+                        swept = {
+                            ...shapeWithCadResult(replayedSource, result),
+                            faceDraft,
+                            faceDraftSourceFrame: existing.faceDraftSourceFrame ?? existing.cadBrepFrame,
+                        };
+                    }
+                    else {
+                        swept = replayedSource;
+                    }
                 }
                 catch (error) {
                     return failed({
@@ -503,7 +726,88 @@ export function createEngine(store) {
                     });
                 }
             }
-            if (revolveChanges.length > 0 && sweptShape) {
+            if ((faceDraftChanged || (replacingSketchProfile && existing.faceDraft)
+                || (revolveChanges.length > 0 && existing.faceDraft)) && isSketchRevolve) {
+                try {
+                    const runtime = await serverManifoldRuntime();
+                    const sourceFrame = existing.faceDraftSourceFrame ?? existing.cadBrepFrame;
+                    const rebuildSeed = sourceFrame ? {
+                        ...existing,
+                        x: sourceFrame.x,
+                        z: sourceFrame.z,
+                        elevation: sourceFrame.elevation,
+                    } : existing;
+                    const rebuiltAtNaturalScale = rebuiltRevolveShape(runtime, rebuildSeed, {
+                        profile: (replacingSketchProfile ? changes.sketchProfile : existing.sketchProfile),
+                        settings: revolveChanges.length > 0
+                            ? requestedRevolveSettings(existing.sketchRevolve, changes)
+                            : existing.sketchRevolve,
+                    });
+                    const sourceScale = existing.faceDraftSourceScale ?? revolveSourceScale(existing);
+                    const rebuilt = resizeRebuiltRevolve(rebuiltAtNaturalScale, sourceScale);
+                    if (requestedFaceDraft) {
+                        const exactBase = shapeWithCadResult(rebuilt, await exactPlainSketchRevolveResult(rebuilt));
+                        const priorReference = existing.faceDraft?.sourceFaceId === requestedFaceDraft.sourceFaceId
+                            ? existing.faceDraft.sourceFaceNormal
+                            : undefined;
+                        const selectedOnPrior = priorReference ? undefined
+                            : (await shapeFaces(existing, { topology: "exact" }))
+                                .find((face) => face.id === requestedFaceDraft.sourceFaceId);
+                        const sourceFaceNormal = priorReference ?? selectedOnPrior?.normal;
+                        if (!sourceFaceNormal || selectedOnPrior && selectedOnPrior.surfaceType !== "plane") {
+                            throw new Error("The selected source face has no stable planar reference.");
+                        }
+                        const currentFace = await findUniqueDraftFace(exactBase, sourceFaceNormal);
+                        if (!currentFace)
+                            throw new Error("The selected source face is missing or ambiguous after the sketch edit.");
+                        const faceDraft = { ...requestedFaceDraft, sourceFaceNormal };
+                        const result = await applySketchFaceDraft(exactBase, {
+                            ...requestedFaceDraft,
+                            sourceFaceId: currentFace.id,
+                        });
+                        swept = {
+                            ...shapeWithCadResult(exactBase, result),
+                            faceDraft,
+                            faceDraftSourceFrame: existing.faceDraftSourceFrame ?? existing.cadBrepFrame ?? exactBase.cadBrepFrame,
+                            faceDraftSourceScale: sourceScale,
+                        };
+                    }
+                    else {
+                        const clearedDraft = {
+                            ...rebuilt,
+                            faceDraft: undefined,
+                            faceDraftSourceFrame: undefined,
+                            faceDraftSourceScale: undefined,
+                        };
+                        swept = clearingFaceDraft
+                            ? await replaySingleAllEdgeTreatment({ ...existing, faceDraft: undefined }, clearedDraft)
+                            : clearedDraft;
+                    }
+                }
+                catch (error) {
+                    return failed({
+                        reason: "sweep_failed",
+                        message: error instanceof Error ? error.message : "The sketch revolve could not be rebuilt.",
+                    });
+                }
+            }
+            else if (replacingSketchProfile && isSketchRevolve) {
+                try {
+                    const runtime = await serverManifoldRuntime();
+                    const rebuilt = rebuiltRevolveShape(runtime, existing, {
+                        profile: changes.sketchProfile,
+                        settings: existing.sketchRevolve,
+                    });
+                    swept = await replaySingleAllEdgeTreatment(existing, rebuilt);
+                }
+                catch (error) {
+                    return failed({
+                        reason: "sweep_failed",
+                        message: error instanceof Error ? error.message : "The sketch revolve could not be rebuilt.",
+                    });
+                }
+            }
+            if (revolveChanges.length > 0 && sweptShape && !existing.faceDraft) {
                 const outline = changes.profile ?? changes.outline ?? outlineFromProfile(existing.sketchProfile);
                 if (!outline) {
                     return failed({
@@ -518,10 +822,11 @@ export function createEngine(store) {
                     return failed({ reason: "invalid_shape_request", message: parsed.error });
                 try {
                     const runtime = await serverManifoldRuntime();
-                    swept = rebuiltRevolveShape(runtime, existing, {
+                    const rebuilt = rebuiltRevolveShape(runtime, existing, {
                         profile: parsed.profile,
                         settings: requestedRevolveSettings(existing.sketchRevolve, changes),
                     });
+                    swept = await replaySingleAllEdgeTreatment(existing, rebuilt);
                 }
                 catch (error) {
                     return failed({
@@ -535,6 +840,8 @@ export function createEngine(store) {
             const sweepFields = [
                 ...(sweptShape ? REVOLVE_CHANGE_FIELDS : REVOLVE_ONLY_FIELDS),
                 "sketchProfile",
+                "draftPrismAngle",
+                "faceDraft",
             ];
             // Shape summaries expose the source ID for identity; echoing a full
             // summary into PATCH must not let callers replace that identity.
@@ -779,12 +1086,12 @@ export function createEngine(store) {
                 return failed(cadFailure(error));
             }
         }),
-        faces: (projectId, shapeId) => reading(projectId, async (document) => {
+        faces: (projectId, shapeId, topology) => reading(projectId, async (document) => {
             const found = oneShape(document, shapeId);
             if (!found.ok)
                 return found;
             try {
-                return ok(await shapeFaces(found.value));
+                return ok(await shapeFaces(found.value, topology === "exact" ? { topology } : undefined));
             }
             catch (error) {
                 return failed(cadFailure(error));
@@ -841,8 +1148,44 @@ export function createEngine(store) {
                 return failed(cadFailure(error));
             }
         }),
-        treat: (projectId, shapeId, treatment) => cadTreatment(projectId, shapeId, async (shape) => (shapeWithCadResult(shape, await applyEdgeTreatment(shape, treatment)))),
-        draftPrism: (projectId, shapeId, angle) => cadTreatment(projectId, shapeId, async (shape) => (shapeWithCadResult(shape, await applyDraftPrism(shape, { angle })))),
+        treat: (projectId, shapeId, treatment) => cadTreatment(projectId, shapeId, (treatment.edges === undefined || treatment.edges.length === 0)
+            && (treatment.kind === "fillet" || treatment.angle === undefined || Math.abs(treatment.angle - 45) < 0.001)
+            ? "all-edge-treatment"
+            : "edge-treatment", async (shape) => {
+            const treated = shapeWithCadResult(shape, await applyEdgeTreatment(shape, treatment));
+            if (shape.draftPrismAngle === undefined)
+                return treated;
+            const feature = {
+                kind: treatment.kind,
+                amount: treatment.amount,
+                edgeCount: await allEdgeTreatmentEdgeCount(shape, treatment.kind),
+                allEdges: true,
+                ...(treatment.kind === "chamfer" ? { chamferAngle: treatment.angle ?? 45 } : {}),
+            };
+            const history = shape.edgeTreatmentHistory ?? [];
+            return {
+                ...treated,
+                edgeTreatments: [...(shape.edgeTreatments ?? []), feature],
+                edgeTreatmentHistory: [
+                    ...history,
+                    {
+                        id: createLocalId("edge-history"),
+                        createdAt: Date.now(),
+                        feature,
+                        before: structuredClone(shape),
+                    },
+                ],
+            };
+        }),
+        draftPrism: (projectId, shapeId, angle) => cadTreatment(projectId, shapeId, "prism-draft", async (shape) => {
+            const sourceFrame = shape.draftPrismSourceFrame ?? shape.cadBrepFrame;
+            return {
+                ...shapeWithCadResult(shape, await applyDraftPrism(shape, { angle })),
+                draftPrismAngle: angle,
+                draftPrismSourceHeight: shape.draftPrismSourceHeight ?? shape.height,
+                ...(sourceFrame ? { draftPrismSourceFrame: sourceFrame } : {}),
+            };
+        }),
         mirrorBaked: (projectId, ids, axis) => mutating(projectId, async (document) => {
             if (ids.length < 1)
                 return failed({ reason: "selection_too_small", needed: 1, given: 0 });
@@ -872,7 +1215,7 @@ export function createEngine(store) {
                 revision: await writeShapes(projectId, document, shapes),
             });
         }),
-        shell: (projectId, shapeId, request) => cadTreatment(projectId, shapeId, async (shape) => (shapeWithCadResult(shape, await applyShell(shape, request)))),
+        shell: (projectId, shapeId, request) => cadTreatment(projectId, shapeId, "shell", async (shape) => (shapeWithCadResult(shape, await applyShell(shape, request)))),
     };
 }
 //# sourceMappingURL=engine.js.map