@constructorfleet/sketchforge-engine 1.26.0 → 1.28.0

package/dist/engine.js

@@ -14,8 +14,8 @@
  * -- including the project lock, which a macro writing a directory needs and
  * does not have today -- without pulling `next/server` in with it.
  */
-import { allEdgeTreatmentEdgeCount, applyEdgeTreatment, applyBakedMirror, applyDraftPrism, applySketchFaceDraft, exactPlainSketchRevolveResult, isPlainFullTurnSketchRevolve, orientedSolidForShape, shapeEdges, shapeWithCadResult, ServerCadError, } from "./serverCadOperations.js";
-import { resolveRetainedFaceDraft, retainedFaceDraftFields, retainedPrismDraftFields } from "./sketchFaceDraftKernel.js";
+import { allEdgeTreatmentEdgeCount, applyEdgeTreatment, applyBakedMirror, applyDraftPrism, applySketchFaceDraft, exactPlainSketchRevolveResult, isPlainFullTurnSketchRevolve, orientedSolidForShape, shapeEdges, shapeWithCadResult, sketchResizeFactors, ServerCadError, } from "./serverCadOperations.js";
+import { resolveRetainedFaceDraft, retainedDraftSourcePlacement, retainedFaceDraftFields, retainedPrismDraftFields, } from "./sketchFaceDraftKernel.js";
 import { withCadKernel } from "./serverCadKernel.js";
 import { cadSketchRegions, cadSketchSweepPaths } from "./sketchCadProfile.js";
 import { applyShell, shapeFaces, } from "./serverCadShell.js";
@@ -35,9 +35,10 @@ import { serverManifoldRuntime } from "./serverManifoldRuntime.js";
 import { createLocalId } from "./localIds.js";
 import { invalidSketchSweepProfile, sketchSweepShapeFromRequest } from "./sketchSweepRequest.js";
 import { sketchExtrusionShapeFromRequest } from "./sketchExtrusionRequest.js";
+import { sketchSourceEdgesForEdgeIndexes } from "./sketchEdgeSegmentLineage.js";
 import { edgeTreatmentAppliedFrame, 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 { REQUESTABLE_SHAPE_KINDS, shapeFromRequest, shapeWithRequestedChanges, SHAPE_PARAMETERS, withResultAttributes, } 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"]);
@@ -98,6 +99,12 @@ async function findUniqueDraftFace(shape, normal) {
         && faceNormalMatches(face.normal, normal));
     return matches.length === 1 ? matches[0] : null;
 }
+function unmirroredDraftSource(shape) {
+    return { ...shape, mirrorX: undefined, mirrorY: undefined, mirrorZ: undefined };
+}
+function retainDraftSourceMirrors(result, source) {
+    return { ...result, mirrorX: source.mirrorX, mirrorY: source.mirrorY, mirrorZ: source.mirrorZ };
+}
 /**
  * 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
@@ -250,11 +257,12 @@ function alignEntry(shape, axis) {
             : { min: bounds.minY, max: bounds.maxY };
     return { id: shape.id, ...span, locked: shape.locked };
 }
-/** `ServerCadError` keeps its own wording and status; anything else has none to keep. */
+/** `ServerCadError` keeps its own wording; unexpected kernel errors stay visible in server logs. */
 function cadFailure(error) {
-    return error instanceof ServerCadError
-        ? { reason: "cad_refused", message: error.message, status: error.status }
-        : { reason: "cad_failed" };
+    if (error instanceof ServerCadError)
+        return { reason: "cad_refused", message: error.message, status: error.status };
+    console.error("Unexpected CAD kernel failure", error);
+    return { reason: "cad_failed" };
 }
 /**
  * One shape from one request, built before any lock is taken.
@@ -270,17 +278,6 @@ function cadFailure(error) {
  * and there is no reason to hold a project busy for it.
  */
 async function builtShape(request, index) {
-    if (request.kind === "sketchSweep") {
-        const invalidProfile = invalidSketchSweepProfile(request.profile);
-        if (invalidProfile)
-            return failed({ reason: "invalid_shape_request", index, message: invalidProfile });
-        try {
-            return ok(await sketchSweepShapeFromRequest(request));
-        }
-        catch (error) {
-            return failed({ reason: "sweep_failed", index, message: error instanceof Error ? error.message : "The sketch sweep could not be built." });
-        }
-    }
     if (request.kind === "sketchSweep") {
         const invalidProfile = invalidSketchSweepProfile(request.profile);
         if (invalidProfile)
@@ -365,7 +362,7 @@ export function createEngine(store) {
      * them off the stored shapes, `booleans` is told which operands to treat as
      * holes. `holes` being undefined is the former.
      */
-    async function combine(projectId, ids, holes) {
+    async function combine(projectId, ids, holes, attributes = {}) {
         return mutating(projectId, async (document) => {
             const resolved = shapesByIds(document, ids);
             if (!resolved.ok)
@@ -386,9 +383,10 @@ export function createEngine(store) {
             // from success. The editor treats the same case as a failed cut.
             if (outcome.cutRemovedNothing)
                 return failed({ reason: "cut_removed_nothing" });
+            const group = withResultAttributes(outcome.group, attributes);
             const consumed = new Set(ids);
-            const shapes = [...document.shapes.filter((shape) => !consumed.has(shape.id)), outcome.group];
-            return ok({ shape: outcome.group, revision: await writeShapes(projectId, document, shapes) });
+            const shapes = [...document.shapes.filter((shape) => !consumed.has(shape.id)), group];
+            return ok({ shape: group, revision: await writeShapes(projectId, document, shapes) });
         });
     }
     /** The shared tail of `treat` and `shell`: run the kernel, store the result on the shape. */
@@ -595,7 +593,13 @@ export function createEngine(store) {
             }
             if (faceDraftChanged && existing.faceDraft && requestedFaceDraft
                 && requestedFaceDraft.sourceFaceId !== existing.faceDraft.sourceFaceId) {
-                const currentOutputFaces = await shapeFaces(existing);
+                let currentOutputFaces;
+                try {
+                    currentOutputFaces = await shapeFaces(existing);
+                }
+                catch (error) {
+                    return failed(cadFailure(error));
+                }
                 if (!canReselectUntreatedExtrusionFace
                     || !existing.faceDraftSourceFaceIds?.includes(requestedFaceDraft.sourceFaceId)
                     || currentOutputFaces.filter((face) => face.id === requestedFaceDraft.sourceFaceId && face.surfaceType === "plane").length !== 1) {
@@ -633,8 +637,47 @@ export function createEngine(store) {
             let swept = existing;
             if ((replacingSketchProfile && isSketchExtrusion) || (draftPrismChanged && isSketchExtrusion)
                 || (faceDraftChanged && isSketchExtrusion)) {
+                // A treatment is built from the extrusion at the size it was shown
+                // (#539), and its record keeps that shape as `before`. Replaying it on
+                // a new profile rebuilds at that same resize, or the edit would hand
+                // back the treatment at the size the sketch was first drawn.
+                const treatmentSource = existing.edgeTreatmentHistory?.[0]?.before;
+                const recordedTreatmentScale = hasExistingTreatment && !existing.faceDraft && existing.draftPrismAngle === undefined
+                    && treatmentSource?.sketchOperation === "extrude" && treatmentSource.cadBrep
+                    ? sketchResizeFactors(treatmentSource)
+                    : undefined;
+                // A treatment recorded before #539 kept the resize in `before` but was
+                // built, and stored, at the drawn size. Its shape is nearer that drawn
+                // size than the resized one on every resized axis, and its edit keeps
+                // the old behaviour: rebuilt at the profile's own size.
+                const nearerResized = (current, resized, factor) => Math.abs(factor - 1) < 1e-8 || Math.abs(current - resized) < Math.abs(current - resized / factor);
+                const treatmentSourceScale = recordedTreatmentScale && treatmentSource
+                    && nearerResized(existing.width, treatmentSource.width, recordedTreatmentScale.width)
+                    && nearerResized(existing.depth, treatmentSource.depth, recordedTreatmentScale.depth)
+                    && nearerResized(existing.height, treatmentSource.height, recordedTreatmentScale.height)
+                    ? recordedTreatmentScale
+                    : undefined;
                 const sourceFrame = existing.faceDraftSourceFrame ?? existing.draftPrismSourceFrame ?? existing.cadBrepFrame;
-                const sourceHeight = existing.draftPrismSourceHeight ?? existing.faceDraftSourceFrame?.height ?? existing.height;
+                const ratio = (drawn, source) => source && source > 0 && drawn > 0 ? drawn / source : 1;
+                const faceDraftSourceScale = (existing.faceDraft ? existing.faceDraftSourceScale : undefined) ?? (existing.faceDraft ? {
+                    // Editor-written drafts predate this field. Their output bounds
+                    // include the taper, so they cannot be used to infer the source
+                    // resize ratio; these shapes were only retained before resize support.
+                    width: 1, depth: 1, height: 1,
+                } : {
+                    width: ratio(existing.width, sourceFrame?.width ?? existing.importedMesh?.baseWidth),
+                    depth: ratio(existing.depth, sourceFrame?.depth ?? existing.importedMesh?.baseDepth),
+                    height: ratio(existing.height, sourceFrame?.height ?? existing.importedMesh?.baseHeight),
+                });
+                const rebuildScale = existing.faceDraft || faceDraftChanged
+                    ? faceDraftSourceScale
+                    : treatmentSourceScale ?? { width: 1, depth: 1, height: 1 };
+                // The extrusion is rebuilt at the height it was drawn and then scaled
+                // by `rebuildScale`, as its width is. Rebuilding a height-resized
+                // extrusion at its shown height applied that resize twice (#546).
+                const sourceHeight = existing.draftPrismSourceHeight ?? existing.faceDraftSourceFrame?.height
+                    ?? (treatmentSourceScale ? treatmentSource.height / treatmentSourceScale.height
+                        : existing.height / rebuildScale.height);
                 try {
                     const rebuilt = await sketchExtrusionShapeFromRequest({
                         id: existing.id,
@@ -644,9 +687,9 @@ export function createEngine(store) {
                         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),
+                        x: 0,
+                        z: 0,
+                        elevation: 0,
                         rotation: existing.rotation,
                         rotationX: existing.rotationX,
                         rotationZ: existing.rotationZ,
@@ -656,6 +699,17 @@ export function createEngine(store) {
                     const rebuiltSource = {
                         ...sourceMetadata,
                         ...rebuilt,
+                        mirrorX: existing.mirrorX,
+                        mirrorY: existing.mirrorY,
+                        mirrorZ: existing.mirrorZ,
+                        ...retainedDraftSourcePlacement(existing, rebuilt.cadBrepFrame, existing.faceDraft && !hasExistingTreatment ? existing.cadBrepFrame : undefined),
+                        // A cleared draft's resize is not kept: the bounds carry it from here.
+                        faceDraftSourceScale: clearingFaceDraft ? undefined
+                            : existing.faceDraft || faceDraftChanged ? faceDraftSourceScale : existing.faceDraftSourceScale,
+                        width: rebuilt.width * rebuildScale.width,
+                        depth: rebuilt.depth * rebuildScale.depth,
+                        height: rebuilt.height * rebuildScale.height,
+                        size: Math.max(rebuilt.width * rebuildScale.width, rebuilt.depth * rebuildScale.depth),
                         id: existing.id,
                         sketchSourceId: existing.sketchSourceId ?? rebuilt.sketchSourceId,
                         faceDraft: undefined,
@@ -699,20 +753,29 @@ export function createEngine(store) {
                             source: replayedSource,
                             request: requestedFaceDraft,
                             profileChanged: replacingSketchProfile,
-                        }, (kernel, shape) => orientedSolidForShape(kernel, shape)));
+                        }, (kernel, shape) => orientedSolidForShape(kernel, unmirroredDraftSource(shape))));
                         const result = await applySketchFaceDraft(replayedSource, {
                             ...requestedFaceDraft,
                             sourceFaceId: currentFaceId,
                         });
                         // The same record the editor writes for a draft it makes (#384).
+                        const drafted = shapeWithCadResult(replayedSource, result);
                         swept = {
-                            ...shapeWithCadResult(replayedSource, result),
+                            ...retainDraftSourceMirrors(drafted, replayedSource),
+                            ...(!replayedSource.mirrorX && !replayedSource.mirrorY && !replayedSource.mirrorZ
+                                ? retainedDraftSourcePlacement({
+                                    ...replayedSource,
+                                    faceDraftSourceFrame: undefined,
+                                    draftPrismSourceFrame: undefined,
+                                }, drafted.cadBrepFrame)
+                                : {}),
                             ...retainedFaceDraftFields(replayedSource.faceIds, existing, { faceId: currentFaceId, normal: sourceFaceNormal, segmentMatch }, requestedFaceDraft),
+                            faceDraftSourceScale,
                         };
                     }
                     else if (draftPrismAngle !== undefined && !replayDraftAndTreatment) {
                         swept = {
-                            ...shapeWithCadResult(replayedSource, await applyDraftPrism(replayedSource, { angle: draftPrismAngle })),
+                            ...retainDraftSourceMirrors(shapeWithCadResult(replayedSource, await applyDraftPrism(replayedSource, { angle: draftPrismAngle })), replayedSource),
                             draftPrismAngle,
                         };
                     }
@@ -762,6 +825,9 @@ export function createEngine(store) {
                     const rebuiltSweep = {
                         ...sourceMetadata,
                         ...resized,
+                        mirrorX: existing.mirrorX,
+                        mirrorY: existing.mirrorY,
+                        mirrorZ: existing.mirrorZ,
                         id: existing.id,
                         sketchSourceId: existing.sketchSourceId ?? rebuilt.sketchSourceId,
                         faceIds: refreshedFaceIds,
@@ -790,13 +856,13 @@ export function createEngine(store) {
                             ? existing.faceDraft.sourceFaceNormal
                             : undefined;
                         const selectedOnPrior = priorReference ? undefined
-                            : (await shapeFaces(existing, isExactSketchRevolve ? { topology: "exact" } : undefined))
+                            : (await shapeFaces(unmirroredDraftSource(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);
+                        const currentFace = await findUniqueDraftFace(unmirroredDraftSource(replayedSource), sourceFaceNormal);
                         if (!currentFace)
                             throw new Error("The selected source face is missing or ambiguous after the sketch edit.");
                         const faceDraft = { ...requestedFaceDraft, sourceFaceNormal };
@@ -805,7 +871,7 @@ export function createEngine(store) {
                             sourceFaceId: currentFace.id,
                         });
                         swept = {
-                            ...shapeWithCadResult(replayedSource, result),
+                            ...retainDraftSourceMirrors(shapeWithCadResult(replayedSource, result), replayedSource),
                             faceDraft,
                             faceDraftSourceFrame: existing.faceDraftSourceFrame ?? existing.cadBrepFrame,
                         };
@@ -841,18 +907,21 @@ export function createEngine(store) {
                     const sourceScale = existing.faceDraftSourceScale ?? revolveSourceScale(existing);
                     const rebuilt = resizeRebuiltRevolve(rebuiltAtNaturalScale, sourceScale);
                     if (requestedFaceDraft) {
-                        const exactBase = shapeWithCadResult(rebuilt, await exactPlainSketchRevolveResult(rebuilt));
+                        const exactBase = {
+                            ...retainDraftSourceMirrors(shapeWithCadResult(rebuilt, await exactPlainSketchRevolveResult(rebuilt)), rebuilt),
+                            faceDraftSourceScale: sourceScale,
+                        };
                         const priorReference = existing.faceDraft?.sourceFaceId === requestedFaceDraft.sourceFaceId
                             ? existing.faceDraft.sourceFaceNormal
                             : undefined;
                         const selectedOnPrior = priorReference ? undefined
-                            : (await shapeFaces(existing, { topology: "exact" }))
+                            : (await shapeFaces(unmirroredDraftSource(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);
+                        const currentFace = await findUniqueDraftFace(unmirroredDraftSource(exactBase), sourceFaceNormal);
                         if (!currentFace)
                             throw new Error("The selected source face is missing or ambiguous after the sketch edit.");
                         const faceDraft = { ...requestedFaceDraft, sourceFaceNormal };
@@ -861,7 +930,7 @@ export function createEngine(store) {
                             sourceFaceId: currentFace.id,
                         });
                         swept = {
-                            ...shapeWithCadResult(exactBase, result),
+                            ...retainDraftSourceMirrors(shapeWithCadResult(exactBase, result), exactBase),
                             faceDraft,
                             faceDraftSourceFrame: existing.faceDraftSourceFrame ?? existing.cadBrepFrame ?? exactBase.cadBrepFrame,
                             faceDraftSourceScale: sourceScale,
@@ -1119,8 +1188,8 @@ export function createEngine(store) {
             const { revision } = await store.write(projectId, { ...document, assets }, shapes);
             return ok({ shape: imported.shape, revision });
         }),
-        cut: (projectId, request) => combine(projectId, [...request.solidIds, ...request.holeIds], new Set(request.holeIds)),
-        group: (projectId, ids) => combine(projectId, ids, undefined),
+        cut: (projectId, request) => combine(projectId, [...request.solidIds, ...request.holeIds], new Set(request.holeIds), request),
+        group: (projectId, ids, result) => combine(projectId, ids, undefined, result),
         ungroup: (projectId, shapeId) => mutating(projectId, async (document) => {
             const found = oneShape(document, shapeId);
             if (!found.ok)
@@ -1244,47 +1313,56 @@ export function createEngine(store) {
                 return failed(cadFailure(error));
             }
         }),
-        treat: (projectId, shapeId, treatment) => cadTreatment(projectId, shapeId, (treatment.edges === undefined || treatment.edges.length === 0)
-            && treatment.kind === "chamfer" && (treatment.angle === undefined || Math.abs(treatment.angle - 45) < 0.001)
-            ? "all-edge-chamfer-treatment"
-            : (treatment.edges === undefined || treatment.edges.length === 0)
-                && treatment.kind === "fillet"
-                ? "all-edge-treatment"
-                : "edge-treatment", async (shape) => {
-            const treated = shapeWithCadResult(shape, await applyEdgeTreatment(shape, treatment));
-            // Every treatment is recorded, as the editor records its own. A source
-            // edit rebuilds the solid from the sketch and replays this record; with
-            // no record it rebuilt a bare solid and silently dropped the treatment.
-            // A selected-edge or non-45-degree chamfer record cannot be replayed,
-            // so a later source edit is refused rather than lossy.
-            const allEdges = treatment.edges === undefined || treatment.edges.length === 0;
-            const feature = {
-                kind: treatment.kind,
-                amount: treatment.amount,
-                edgeCount: allEdges ? await allEdgeTreatmentEdgeCount(shape, treatment.kind) : treatment.edges.length,
-                ...(allEdges ? { allEdges: true } : {}),
-                ...(treatment.kind === "chamfer" ? { chamferAngle: treatment.angle ?? 45 } : {}),
-            };
-            // The snapshot drops its own history, as the editor's does, so each
-            // treatment does not nest a copy of every earlier one.
-            const { edgeTreatmentHistory: _ownHistory, ...before } = shape;
-            return {
-                ...treated,
-                edgeTreatments: [...(shape.edgeTreatments ?? []), feature],
-                edgeTreatmentHistory: [
-                    ...(shape.edgeTreatmentHistory ?? []),
-                    {
-                        id: createLocalId("edge-history"),
-                        createdAt: Date.now(),
-                        feature,
-                        before: structuredClone(before),
-                        appliedFrame: edgeTreatmentAppliedFrame(treated),
-                    },
-                ],
-            };
-        }),
+        treat: (projectId, shapeId, requested) => {
+            // An edge named twice is one edge: rounding it once is what the caller
+            // gets, so it is counted, and recorded, once.
+            const treatment = requested.edges ? { ...requested, edges: [...new Set(requested.edges)] } : requested;
+            return cadTreatment(projectId, shapeId, (treatment.edges === undefined || treatment.edges.length === 0)
+                && treatment.kind === "chamfer" && (treatment.angle === undefined || Math.abs(treatment.angle - 45) < 0.001)
+                ? "all-edge-chamfer-treatment"
+                : (treatment.edges === undefined || treatment.edges.length === 0)
+                    && treatment.kind === "fillet"
+                    ? "all-edge-treatment"
+                    : "edge-treatment", async (shape) => {
+                const treated = shapeWithCadResult(shape, await applyEdgeTreatment(shape, treatment));
+                // Every treatment is recorded, as the editor records its own. A source
+                // edit rebuilds the solid from the sketch and replays this record; with
+                // no record it rebuilt a bare solid and silently dropped the treatment.
+                // Selected edges are recorded by sketch lineage -- segment and cap --
+                // when every one of them has exactly one, never by their transient
+                // indexes (#350). A selected-edge record without lineage cannot be
+                // replayed, so a later source edit is refused rather than lossy.
+                const allEdges = treatment.edges === undefined || treatment.edges.length === 0;
+                const lineage = allEdges ? undefined : await sketchSourceEdgesForEdgeIndexes(shape, treatment.edges);
+                const feature = {
+                    kind: treatment.kind,
+                    amount: treatment.amount,
+                    edgeCount: allEdges ? await allEdgeTreatmentEdgeCount(shape, treatment.kind) : treatment.edges.length,
+                    ...(allEdges ? { allEdges: true } : {}),
+                    ...(treatment.kind === "chamfer" ? { chamferAngle: treatment.angle ?? 45 } : {}),
+                    ...(lineage?.status === "matched" ? { sourceEdges: lineage.sourceEdges } : {}),
+                };
+                // The snapshot drops its own history, as the editor's does, so each
+                // treatment does not nest a copy of every earlier one.
+                const { edgeTreatmentHistory: _ownHistory, ...before } = shape;
+                return {
+                    ...treated,
+                    edgeTreatments: [...(shape.edgeTreatments ?? []), feature],
+                    edgeTreatmentHistory: [
+                        ...(shape.edgeTreatmentHistory ?? []),
+                        {
+                            id: createLocalId("edge-history"),
+                            createdAt: Date.now(),
+                            feature,
+                            before: structuredClone(before),
+                            appliedFrame: edgeTreatmentAppliedFrame(treated),
+                        },
+                    ],
+                };
+            });
+        },
         draftPrism: (projectId, shapeId, angle) => cadTreatment(projectId, shapeId, "prism-draft", async (shape) => ({
-            ...shapeWithCadResult(shape, await applyDraftPrism(shape, { angle })),
+            ...retainDraftSourceMirrors(shapeWithCadResult(shape, await applyDraftPrism(shape, { angle })), shape),
             ...retainedPrismDraftFields(shape, angle),
         })),
         mirrorBaked: (projectId, ids, axis) => mutating(projectId, async (document) => {