@pascal-app/core 1.0.3 → 1.0.4

package/dist/store/actions/node-actions.js

@@ -1,8 +1,13 @@
+import { planWallDeletion } from '../../commands/structure/plan-wall-deletion.js';
+import { withoutFloorStepOverrideKeys } from '../../lib/floor-step-finish.js';
+import { isSpaceDetectionPaused } from '../../lib/space-detection.js';
 import { nodeRegistry } from '../../registry/registry.js';
 import { validateNodeRelations } from '../../registry/validate-relations.js';
 import { AnyNode as AnyNodeSchema, createDefaultGuttersForSegment, createDefaultRidgeVentsForSegment, DownspoutNode as DownspoutNodeSchema, defaultDownspoutMetadata, generateId, getDefaultGutterSide, isAutoGutterEnabled, isAutoRidgeVentEnabled, isDefaultDownspoutNode, isDefaultGutterNode, isDefaultRidgeVentNode, parseNode, planAutomaticDownspouts, resolveAutomaticDownspoutLength, } from '../../schema/index.js';
+import { Provenance } from '../../schema/provenance.js';
 import { constrainWallCurveOffsetToAvoidIntersections } from '../../systems/wall/wall-curve.js';
-import { areWallStylesCompatible, areWallsCollinearAcrossPoint, buildMergedWallAttachmentUpdates, getWallEndpointAtPoint, resolveMergedWallEndpoints, } from '../../systems/wall/wall-merge.js';
+import { areWallStylesCompatible, areWallsCollinearAcrossPoint, buildMergedWallAttachmentUpdates, getWallEndpointAtPoint, mergeWallFaceRegions, planMergedZoneReferences, resolveMergedWallEndpoints, } from '../../systems/wall/wall-merge.js';
+import { convertDerivedPlateHoleWrites, DERIVED_WRITER_TOKEN, derivedDeletionIntent, derivedDetachPatch, filterDerivedNodeWrites, isDerivedNode, } from '../derived-node-guard.js';
 import { activeSceneCommitNodeIds, addActiveSceneCommitNodeIds, runWithSceneCommitNodeIds, } from '../history-control.js';
 const DEFAULT_RIDGE_VENT_REFRESH_FIELDS = new Set([
     'roofType',
@@ -367,12 +372,42 @@ function warnSanitizedNodeMutation(mutation, nodeId, issues) {
         // A broken diagnostic sink must not interrupt a node mutation either.
     }
 }
+/**
+ * Source ids cannot be repaired the way the numeric fallback repairs a value:
+ * any fix would drop or rewrite them (D5). A write that sets an invalid
+ * `provenance` throws, whatever the node's kind (a plain plugin kind never
+ * reaches a schema that knows the field), so the mutation applies nothing.
+ */
+function assertProvenanceWrite(nodeId, value) {
+    if (value === undefined)
+        return;
+    const parsed = Provenance.safeParse(value);
+    if (parsed.success)
+        return;
+    const issue = parsed.error.issues[0];
+    const at = ['provenance', ...(issue?.path ?? [])].join('.');
+    throw new Error(`Node "${nodeId}": provenance refused at ${at}: ${issue?.message}`);
+}
+/**
+ * A strict kind parses everything but `provenance`, which core checks on write
+ * and carries verbatim: a stored over-cap value (kept at load) must not make
+ * the node uneditable, and a schema that never declared the base field must
+ * not drop it.
+ */
+function parseStrict(schema, candidate) {
+    if (!Object.hasOwn(candidate, 'provenance'))
+        return schema.parse(candidate);
+    const { provenance, ...rest } = candidate;
+    const parsed = schema.parse(rest);
+    return provenance === undefined ? parsed : { ...parsed, provenance };
+}
 function parseCreatedNode(node, parentId) {
     const candidate = { ...node, parentId };
+    assertProvenanceWrite(candidate.id, candidate.provenance);
     const registered = nodeRegistry.get(candidate.type)?.schema;
     // Generated definitions must reject invalid geometry instead of retaining a failed parse.
     if (registered?.meta?.()?.strictMutations === true)
-        return registered.parse(candidate);
+        return parseStrict(registered, candidate);
     const parsed = parseNode(candidate);
     if (parsed.success)
         return parsed.data;
@@ -398,6 +433,9 @@ function mergeNodeUpdate(currentNode, patch) {
     return merged;
 }
 function parseUpdatedNode(currentNode, data) {
+    // Only a write of the field is checked: a stored over-cap value stays editable.
+    if (Object.hasOwn(data, 'provenance'))
+        assertProvenanceWrite(currentNode.id, data.provenance);
     const candidate = mergeNodeUpdate(currentNode, data);
     // Graph links survive schemas that omit children; only an explicit patch may change them.
     const preserveChildren = (updated) => !Object.hasOwn(data, 'children') &&
@@ -408,7 +446,7 @@ function parseUpdatedNode(currentNode, data) {
     const registered = nodeRegistry.get(currentNode.type)?.schema;
     // Generated definitions must reject invalid geometry instead of retaining a failed parse.
     if (registered?.meta?.()?.strictMutations === true)
-        return preserveChildren(registered.parse(candidate));
+        return preserveChildren(parseStrict(registered, candidate));
     const parsed = parseNode(candidate);
     if (parsed.success)
         return preserveChildren(parsed.data);
@@ -788,6 +826,11 @@ function buildWallMergePlans(nodes, idsToDelete) {
                 continue;
             }
             const { start, end } = resolveMergedWallEndpoints(primary, secondary, junction);
+            // A heal that would repaint a room or overflow a side's regions leaves the walls split.
+            const mergedFaceRegions = mergeWallFaceRegions([primary, secondary], start, end);
+            const zoneUpdates = planMergedZoneReferences(nodes, primary, secondary, start, end);
+            if (!(mergedFaceRegions && zoneUpdates))
+                continue;
             const mergedChildren = Array.from(new Set([...(primary.children ?? []), ...(secondary.children ?? [])]));
             const attachmentUpdates = buildMergedWallAttachmentUpdates(primary, secondary, primary.id, start, end, nodes);
             mergePlans.push({
@@ -796,7 +839,9 @@ function buildWallMergePlans(nodes, idsToDelete) {
                 mergedStart: start,
                 mergedEnd: end,
                 mergedChildren,
+                mergedFaceRegions: mergedFaceRegions.length > 0 ? mergedFaceRegions : undefined,
                 attachmentUpdates,
+                zoneUpdates,
             });
             usedWallIds.add(primary.id);
             usedWallIds.add(secondary.id);
@@ -804,17 +849,21 @@ function buildWallMergePlans(nodes, idsToDelete) {
     }
     return mergePlans;
 }
-const createNodesActionImpl = (set, get, ops) => {
+const createNodesActionImpl = (set, get, ops, options) => {
     if (get().readOnly)
         return;
+    ops = filterDerivedNodeWrites(get().nodes, { create: ops }, options).create;
+    if (!ops.length)
+        return;
     const extraNodesToMarkDirty = new Set();
     const extraNodesToClearDirty = new Set();
     set((state) => {
         const nextNodes = { ...state.nodes };
         const nextRootIds = [...state.rootNodeIds];
-        for (const { node, parentId } of ops) {
+        const nextCollections = { ...state.collections };
+        for (const { node, parentId, collectionIds } of ops) {
             const effectiveParentId = parentId ?? node.parentId ?? null;
-            const newNode = parseCreatedNode(node, effectiveParentId);
+            const newNode = joinCollections(nextCollections, parseCreatedNode(node, effectiveParentId), collectionIds);
             nextNodes[newNode.id] = newNode;
             // 2. Update the Parent's children list. We append to ANY container
             // parent (kind has `children` in its schema) — if the field is
@@ -853,7 +902,12 @@ const createNodesActionImpl = (set, get, ops) => {
         }
         refreshDefaultGuttersForRoofIds(nextNodes, refreshedRoofIds, extraNodesToMarkDirty, extraNodesToClearDirty);
         addActiveSceneCommitNodeIds([...extraNodesToMarkDirty, ...extraNodesToClearDirty]);
-        return { nodes: nextNodes, rootNodeIds: nextRootIds };
+        const joined = Object.entries(nextCollections).some(([id, collection]) => state.collections[id] !== collection);
+        return {
+            nodes: nextNodes,
+            rootNodeIds: nextRootIds,
+            ...(joined && { collections: nextCollections }),
+        };
     });
     // 4. System Sync
     ops.forEach(({ node, parentId }) => {
@@ -868,11 +922,55 @@ const createNodesActionImpl = (set, get, ops) => {
     for (const id of extraNodesToClearDirty)
         get().clearDirty(id);
 };
-const applyNodeChangesActionImpl = (set, get, changes) => {
+/**
+ * A created node joins the collections it is given, or an item those its mirror
+ * names, so a duplicate or a same-project paste stays a member; ids of
+ * collections this scene lacks (a paste from another project) are dropped.
+ * Writes the joined collections into `collections` and returns the node, an
+ * item with its mirror set to what it joined.
+ */
+export function joinCollections(collections, node, requested = node.type === 'item' ? node.collectionIds : undefined) {
+    const collectionIds = (requested ?? []).filter((id) => collections[id]);
+    for (const id of collectionIds) {
+        const collection = collections[id];
+        if (!collection.nodeIds.includes(node.id))
+            collections[id] = { ...collection, nodeIds: [...collection.nodeIds, node.id] };
+    }
+    if (node.type !== 'item' || sameIds(node.collectionIds ?? [], collectionIds))
+        return node;
+    return { ...node, collectionIds };
+}
+function sameIds(left, right) {
+    return left.length === right.length && left.every((id, index) => right[index] === id);
+}
+/** The collections `id` belongs to: membership lives on the collection for every kind. */
+export function collectionIdsOf(collections, id) {
+    return Object.values(collections)
+        .filter((collection) => collection.nodeIds.includes(id))
+        .map((collection) => collection.id);
+}
+/** Membership lives on the collection; only items mirror it, so every collection is checked. */
+function removeFromCollections(collections, id) {
+    for (const [collectionId, collection] of Object.entries(collections)) {
+        if (collection.nodeIds.includes(id))
+            collections[collectionId] = {
+                ...collection,
+                nodeIds: collection.nodeIds.filter((nodeId) => nodeId !== id),
+            };
+    }
+}
+const applyNodeChangesActionImpl = (set, get, changes, options) => {
     if (get().readOnly)
         return;
+    changes = convertDerivedPlateHoleWrites(get().nodes, changes, options);
+    changes = filterDerivedNodeWrites(get().nodes, changes, options);
+    if (!changes.create?.length && !changes.update?.length && !changes.delete?.length)
+        return;
     const createOps = changes.create ?? [];
-    const updateOps = changes.update ?? [];
+    const deletionIntent = options?.derivedWriter === DERIVED_WRITER_TOKEN
+        ? []
+        : derivedDeletionIntent(get().nodes, changes.delete ?? []);
+    const updateOps = [...(changes.update ?? []), ...deletionIntent];
     const deleteOps = changes.delete ?? [];
     const nodesToMarkDirty = new Set();
     const nodesToClearDirty = new Set();
@@ -923,9 +1021,9 @@ const applyNodeChangesActionImpl = (set, get, changes) => {
             }
             nodesToMarkDirty.add(id);
         }
-        for (const { node, parentId } of createOps) {
+        for (const { node, parentId, collectionIds } of createOps) {
             const effectiveParentId = parentId ?? node.parentId ?? null;
-            const newNode = parseCreatedNode(node, effectiveParentId);
+            const newNode = joinCollections(nextCollections, parseCreatedNode(node, effectiveParentId), collectionIds);
             nextNodes[newNode.id] = newNode;
             nodesToMarkDirty.add(newNode.id);
             if (newNode.type === 'roof-segment' && effectiveParentId) {
@@ -984,17 +1082,7 @@ const applyNodeChangesActionImpl = (set, get, changes) => {
                 }
             }
             resolvedRootIds = resolvedRootIds.filter((rootId) => rootId !== id);
-            if ('collectionIds' in node && node.collectionIds) {
-                for (const collectionId of node.collectionIds) {
-                    const collection = nextCollections[collectionId];
-                    if (collection) {
-                        nextCollections[collectionId] = {
-                            ...collection,
-                            nodeIds: collection.nodeIds.filter((nodeId) => nodeId !== id),
-                        };
-                    }
-                }
-            }
+            removeFromCollections(nextCollections, id);
             delete nextNodes[id];
         }
         refreshDefaultGuttersForRoofIds(nextNodes, roofsToRefresh, nodesToMarkDirty, nodesToClearDirty);
@@ -1022,9 +1110,17 @@ const applyNodeChangesActionImpl = (set, get, changes) => {
         }
     }
 };
-const updateNodesActionImpl = (set, get, updates) => {
+const updateNodesActionImpl = (set, get, updates, options, deferDirty = true) => {
     if (get().readOnly)
         return;
+    const converted = convertDerivedPlateHoleWrites(get().nodes, { update: updates }, options);
+    if (converted.create?.length || converted.delete?.length) {
+        applyNodeChangesActionImpl(set, get, converted, options);
+        return;
+    }
+    updates = filterDerivedNodeWrites(get().nodes, { update: converted.update ?? [] }, options).update;
+    if (!updates.length)
+        return;
     const parentsToUpdate = new Set();
     const extraNodesToUpdate = new Set();
     const extraNodesToDelete = new Set();
@@ -1101,6 +1197,13 @@ const updateNodesActionImpl = (set, get, updates) => {
         ]);
         return { nodes: nextNodes };
     });
+    if (!deferDirty) {
+        for (const id of [...updates.map((u) => u.id), ...parentsToUpdate, ...extraNodesToUpdate])
+            get().markDirty(id);
+        for (const id of extraNodesToDelete)
+            get().clearDirty(id);
+        return;
+    }
     // Batch dirty-marking into a single RAF to avoid redundant callbacks during rapid updates
     for (const u of updates) {
         // Visibility is applied by React before the deferred dirty callback. Mark
@@ -1130,175 +1233,309 @@ const updateNodesActionImpl = (set, get, updates) => {
         pendingRafId = null;
     });
 };
-const deleteNodesActionImpl = (set, get, ids) => {
-    if (get().readOnly)
-        return;
+/**
+ * The delete store action's planner, without committing: the requested ids,
+ * their `children` subtrees and kind `onDeleteCascade` companions, collinear
+ * walls merged across a deleted junction, the separators that keep two rooms
+ * apart when the wall between them goes, derived-construction deletion intent,
+ * neighbour patches, support and unit cleanup, and the default gutter and
+ * downspout refresh.
+ *
+ * The refresh mints gutters, downspouts and outlets with random ids, and which
+ * existing defaults it keeps can depend on them. With `mintDefaults: false`
+ * (a preview, such as the MCP patch dry run) the refresh does not run: the
+ * existing defaults it would touch are listed in `unsettledIds`, and the plan
+ * is deterministic and equals the commit for every other existing id. The
+ * delete action mints.
+ */
+export function planNodeDeletion(scene, ids, { mintDefaults = true, options, wallDeletionPlan, } = {}) {
     const parentsToMarkDirty = new Set();
     const nodesToMarkDirty = new Set();
     const deletedIds = new Set();
-    const mergePlans = buildWallMergePlans(get().nodes, ids);
+    const mergePlans = buildWallMergePlans(scene.nodes, ids);
     const requestedDeleteIds = new Set(ids);
-    set((state) => {
-        const nextNodes = { ...state.nodes };
-        const nextCollections = { ...state.collections };
-        let nextRootIds = [...state.rootNodeIds];
-        // Collect all ids to delete (the requested ids + all their descendants) before
-        // mutating anything, so the recursive walk reads consistent state.
-        const allIds = new Set();
-        const collect = (id) => {
-            if (allIds.has(id))
-                return;
-            allIds.add(id);
-            const node = nextNodes[id];
-            const cascadeDeletes = node
-                ? nodeRegistry
-                    .get(node.type)
-                    ?.parametrics?.onDeleteCascade?.(node, nextNodes, allIds, requestedDeleteIds)
-                : null;
-            if (cascadeDeletes) {
-                for (const companionId of cascadeDeletes)
-                    collect(companionId);
+    // Deleting derived construction is an intent edit ("this room has no
+    // ceiling"), not a refusal — the reconciler must not rebuild it.
+    const deletionIntent = options?.derivedWriter === DERIVED_WRITER_TOKEN ? [] : derivedDeletionIntent(scene.nodes, ids);
+    // A preview names the separators a room-preserving delete adds without random ids.
+    let previewCount = 0;
+    const previewId = (kind) => {
+        let id;
+        do
+            id = `${kind}_preview${++previewCount}`;
+        while (id in scene.nodes);
+        return id;
+    };
+    const nextNodes = { ...scene.nodes };
+    const nextCollections = { ...scene.collections };
+    let nextRootIds = [...scene.rootNodeIds];
+    // Collect all ids to delete (the requested ids + all their descendants) before
+    // mutating anything, so the recursive walk reads consistent state.
+    const allIds = new Set();
+    const collect = (id) => {
+        if (allIds.has(id))
+            return;
+        allIds.add(id);
+        const node = nextNodes[id];
+        const cascadeDeletes = node
+            ? nodeRegistry
+                .get(node.type)
+                ?.parametrics?.onDeleteCascade?.(node, nextNodes, allIds, requestedDeleteIds)
+            : null;
+        if (cascadeDeletes) {
+            for (const companionId of cascadeDeletes)
+                collect(companionId);
+        }
+        if (node && 'children' in node) {
+            for (const cid of node.children)
+                collect(cid);
+        }
+    };
+    for (const id of ids)
+        collect(id);
+    if (wallDeletionPlan ||
+        (options?.derivedWriter !== DERIVED_WRITER_TOKEN && !isSpaceDetectionPaused())) {
+        const plan = wallDeletionPlan ??
+            planWallDeletion(scene.nodes, {
+                nodeIds: [...allIds],
+                mintId: mintDefaults ? generateId : previewId,
+            });
+        for (const change of plan.changes) {
+            if (change.op === 'delete')
+                collect(change.id);
+            else if (change.op === 'update') {
+                const current = nextNodes[change.id];
+                if (current)
+                    nextNodes[change.id] = parseUpdatedNode(current, change.data);
+                nodesToMarkDirty.add(change.id);
             }
-            if (node && 'children' in node) {
-                for (const cid of node.children)
-                    collect(cid);
+            else {
+                const node = change.node;
+                nextNodes[node.id] = node;
+                nodesToMarkDirty.add(node.id);
+                const parent = node.parentId ? nextNodes[node.parentId] : undefined;
+                if (parent && 'children' in parent && Array.isArray(parent.children)) {
+                    nextNodes[parent.id] = { ...parent, children: [...parent.children, node.id] };
+                    parentsToMarkDirty.add(parent.id);
+                }
             }
-        };
-        for (const id of ids)
-            collect(id);
-        for (const plan of mergePlans) {
-            allIds.add(plan.secondaryWallId);
         }
-        const affectedRoofIds = new Set();
-        for (const id of allIds) {
-            const node = nextNodes[id];
-            addLeanToHostRoofId(node, nextNodes, affectedRoofIds);
-            if (node?.type === 'roof-segment' && node.parentId) {
-                affectedRoofIds.add(node.parentId);
-            }
+    }
+    for (const plan of mergePlans) {
+        allIds.add(plan.secondaryWallId);
+    }
+    const affectedRoofIds = new Set();
+    for (const id of allIds) {
+        const node = nextNodes[id];
+        addLeanToHostRoofId(node, nextNodes, affectedRoofIds);
+        if (node?.type === 'roof-segment' && node.parentId) {
+            affectedRoofIds.add(node.parentId);
         }
-        for (const id of allIds)
-            deletedIds.add(id);
-        // Let each deleted kind undo what it imposed on its neighbours (e.g. an
-        // auto-inserted elbow re-extends the duct runs it trimmed back onto the
-        // corner it replaced). Read against pre-deletion `nextNodes`; skip
-        // patches that target a node also being deleted.
-        for (const id of allIds) {
-            const node = nextNodes[id];
-            if (!node)
+    }
+    for (const id of allIds)
+        deletedIds.add(id);
+    // Let each deleted kind undo what it imposed on its neighbours (e.g. an
+    // auto-inserted elbow re-extends the duct runs it trimmed back onto the
+    // corner it replaced). Read against pre-deletion `nextNodes`; skip
+    // patches that target a node also being deleted.
+    for (const id of allIds) {
+        const node = nextNodes[id];
+        if (!node)
+            continue;
+        const onDelete = nodeRegistry.get(node.type)?.parametrics?.onDelete;
+        if (!onDelete)
+            continue;
+        for (const { id: targetId, data } of onDelete(node, nextNodes, allIds, requestedDeleteIds)) {
+            if (allIds.has(targetId))
                 continue;
-            const onDelete = nodeRegistry.get(node.type)?.parametrics?.onDelete;
-            if (!onDelete)
+            const target = nextNodes[targetId];
+            if (!target)
                 continue;
-            for (const { id: targetId, data } of onDelete(node, nextNodes, allIds, requestedDeleteIds)) {
-                if (allIds.has(targetId))
-                    continue;
-                const target = nextNodes[targetId];
-                if (!target)
-                    continue;
-                nextNodes[targetId] = { ...target, ...data };
-                nodesToMarkDirty.add(targetId);
-            }
+            nextNodes[targetId] = { ...target, ...data };
+            nodesToMarkDirty.add(targetId);
         }
-        for (const plan of mergePlans) {
-            const primaryWall = nextNodes[plan.primaryWallId];
-            if (!(primaryWall && primaryWall.type === 'wall') || allIds.has(plan.primaryWallId)) {
+    }
+    for (const plan of mergePlans) {
+        const primaryWall = nextNodes[plan.primaryWallId];
+        if (!(primaryWall && primaryWall.type === 'wall') || allIds.has(plan.primaryWallId)) {
+            continue;
+        }
+        const { faceRegions: _regions, ...keptWall } = primaryWall;
+        nextNodes[plan.primaryWallId] = {
+            ...keptWall,
+            ...(plan.mergedFaceRegions ? { faceRegions: plan.mergedFaceRegions } : {}),
+            start: plan.mergedStart,
+            end: plan.mergedEnd,
+            children: plan.mergedChildren,
+        };
+        nodesToMarkDirty.add(plan.primaryWallId);
+        for (const update of plan.zoneUpdates) {
+            if (allIds.has(update.id))
                 continue;
-            }
-            nextNodes[plan.primaryWallId] = {
-                ...primaryWall,
-                start: plan.mergedStart,
-                end: plan.mergedEnd,
-                children: plan.mergedChildren,
-            };
-            nodesToMarkDirty.add(plan.primaryWallId);
-            for (const update of plan.attachmentUpdates) {
-                if (allIds.has(update.id))
-                    continue;
-                const child = nextNodes[update.id];
-                if (!child)
-                    continue;
-                nextNodes[update.id] = { ...child, ...update.data };
-                nodesToMarkDirty.add(update.id);
-            }
+            const zone = nextNodes[update.id];
+            if (zone)
+                nextNodes[update.id] = { ...zone, ...update.data };
         }
-        // Deleting a slab strips `supportSlabId` / `deckSlabId` references from
-        // surviving nodes in the same undo commit (mirrors the collectionIds
-        // cleanup below), so those nodes re-elect their support / re-derive
-        // their rise. Deletion is the ONLY writer — a host merely reshaped away
-        // keeps the field and the read path falls back, letting hosting resume
-        // if the slab returns.
-        const deletedSlabIds = new Set();
-        for (const id of allIds) {
-            if (nextNodes[id]?.type === 'slab')
-                deletedSlabIds.add(id);
+        for (const update of plan.attachmentUpdates) {
+            if (allIds.has(update.id))
+                continue;
+            const child = nextNodes[update.id];
+            if (!child)
+                continue;
+            nextNodes[update.id] = { ...child, ...update.data };
+            nodesToMarkDirty.add(update.id);
         }
-        if (deletedSlabIds.size > 0) {
-            for (const [nodeId, node] of Object.entries(nextNodes)) {
-                if (allIds.has(nodeId))
-                    continue;
-                const patch = {};
-                const hostId = node.supportSlabId;
-                if (hostId && deletedSlabIds.has(hostId))
-                    patch.supportSlabId = undefined;
-                const deckId = node.deckSlabId;
-                if (deckId && deletedSlabIds.has(deckId))
-                    patch.deckSlabId = undefined;
-                if (Object.keys(patch).length > 0) {
-                    nextNodes[nodeId] = { ...node, ...patch };
-                    nodesToMarkDirty.add(nodeId);
-                }
+    }
+    // Deleting a slab strips `supportSlabId` / `deckSlabId` references from
+    // surviving nodes in the same undo commit (mirrors the collectionIds
+    // cleanup below), so those nodes re-elect their support / re-derive
+    // their rise. Deletion is the ONLY writer — a host merely reshaped away
+    // keeps the field and the read path falls back, letting hosting resume
+    // if the slab returns.
+    const deletedSlabIds = new Set();
+    for (const id of allIds) {
+        if (nextNodes[id]?.type === 'slab')
+            deletedSlabIds.add(id);
+    }
+    if (deletedSlabIds.size > 0) {
+        for (const [nodeId, node] of Object.entries(nextNodes)) {
+            if (allIds.has(nodeId))
+                continue;
+            const patch = {};
+            const hostId = node.supportSlabId;
+            if (hostId && deletedSlabIds.has(hostId))
+                patch.supportSlabId = undefined;
+            const deckId = node.deckSlabId;
+            if (deckId && deletedSlabIds.has(deckId))
+                patch.deckSlabId = undefined;
+            if (Object.keys(patch).length > 0) {
+                nextNodes[nodeId] = { ...node, ...patch };
+                nodesToMarkDirty.add(nodeId);
             }
         }
-        const deletedZoneIds = new Set();
-        for (const id of allIds) {
-            if (nextNodes[id]?.type === 'zone')
-                deletedZoneIds.add(id);
+    }
+    // A deleted door takes its step paint with it, in the same undo step; every
+    // other doorway keeps its own.
+    for (const node of Object.values(nextNodes)) {
+        if (node.type !== 'zone' || allIds.has(node.id))
+            continue;
+        const pruned = withoutFloorStepOverrideKeys(node, allIds);
+        if (!pruned)
+            continue;
+        nextNodes[node.id] = pruned;
+        nodesToMarkDirty.add(node.id);
+    }
+    const deletedZoneIds = new Set();
+    for (const id of allIds) {
+        if (nextNodes[id]?.type === 'zone')
+            deletedZoneIds.add(id);
+    }
+    if (deletedZoneIds.size > 0) {
+        for (const node of Object.values(nextNodes)) {
+            if (node.type !== 'unit' || allIds.has(node.id))
+                continue;
+            const members = node.members.filter((id) => !deletedZoneIds.has(id));
+            if (members.length === node.members.length)
+                continue;
+            nextNodes[node.id] = { ...node, members };
+            nodesToMarkDirty.add(node.id);
         }
-        if (deletedZoneIds.size > 0) {
-            for (const node of Object.values(nextNodes)) {
-                if (node.type !== 'unit' || allIds.has(node.id))
-                    continue;
-                const members = node.members.filter((id) => !deletedZoneIds.has(id));
-                if (members.length === node.members.length)
-                    continue;
-                nextNodes[node.id] = { ...node, members };
-                nodesToMarkDirty.add(node.id);
+    }
+    for (const id of allIds) {
+        const node = nextNodes[id];
+        if (!node)
+            continue;
+        // Legacy graphs can link children without a reciprocal parentId.
+        const parentId = (node.parentId ??
+            Object.values(nextNodes).find((candidate) => 'children' in candidate && candidate.children?.some((childId) => childId === id))?.id);
+        if (parentId && nextNodes[parentId] && !allIds.has(parentId)) {
+            const parent = nextNodes[parentId];
+            if (parent.children) {
+                nextNodes[parent.id] = {
+                    ...parent,
+                    children: parent.children.filter((cid) => cid !== id),
+                };
+                parentsToMarkDirty.add(parent.id);
             }
         }
-        for (const id of allIds) {
-            const node = nextNodes[id];
-            if (!node)
+        // 2. Remove from root list
+        nextRootIds = nextRootIds.filter((rid) => rid !== id);
+        // 3. Remove from any collections it belongs to
+        removeFromCollections(nextCollections, id);
+        // 4. Delete the node itself
+        delete nextNodes[id];
+    }
+    for (const { id, data } of deletionIntent) {
+        const zone = nextNodes[id];
+        if (!zone)
+            continue;
+        nextNodes[id] = { ...zone, ...data };
+        nodesToMarkDirty.add(id);
+    }
+    const unsettledIds = new Set();
+    const regeneratedHostIds = new Set();
+    if (mintDefaults) {
+        refreshDefaultGuttersForRoofIds(nextNodes, affectedRoofIds, nodesToMarkDirty, deletedIds);
+    }
+    else {
+        collectRefreshedDefaults(nextNodes, affectedRoofIds, unsettledIds, regeneratedHostIds);
+    }
+    return {
+        nodes: nextNodes,
+        rootNodeIds: nextRootIds,
+        collections: nextCollections,
+        deletedIds,
+        parentsToMarkDirty,
+        nodesToMarkDirty,
+        unsettledIds,
+        regeneratedHostIds,
+    };
+}
+/**
+ * The existing nodes the default gutter refresh of `roofIds` may keep, move or
+ * replace: each roof's default gutters and the downspouts on them. Which of
+ * them survive depends on the gutters the refresh mints, whose ids are random.
+ * `hosts` receives the roof segments whose `children` the refresh rewrites.
+ */
+function collectRefreshedDefaults(nodes, roofIds, out, hosts) {
+    const gutterIds = new Set();
+    for (const roofId of new Set(roofIds)) {
+        const roof = nodes[roofId];
+        if (roof?.type !== 'roof')
+            continue;
+        for (const segmentId of roof.children ?? []) {
+            const segment = nodes[segmentId];
+            if (segment?.type !== 'roof-segment')
                 continue;
-            // 1. Remove reference from parent — only if the parent itself is NOT also being deleted
-            const parentId = node.parentId;
-            if (parentId && nextNodes[parentId] && !allIds.has(parentId)) {
-                const parent = nextNodes[parentId];
-                if (parent.children) {
-                    nextNodes[parent.id] = {
-                        ...parent,
-                        children: parent.children.filter((cid) => cid !== id),
-                    };
-                    parentsToMarkDirty.add(parent.id);
-                }
-            }
-            // 2. Remove from root list
-            nextRootIds = nextRootIds.filter((rid) => rid !== id);
-            // 3. Remove from any collections it belongs to
-            if ('collectionIds' in node && node.collectionIds) {
-                for (const cid of node.collectionIds) {
-                    const col = nextCollections[cid];
-                    if (col) {
-                        nextCollections[cid] = { ...col, nodeIds: col.nodeIds.filter((nid) => nid !== id) };
-                    }
+            hosts.add(segment.id);
+            for (const childId of segment.children ?? []) {
+                if (isDefaultGutterNode(nodes[childId], segment.id)) {
+                    gutterIds.add(childId);
                 }
             }
-            // 4. Delete the node itself
-            delete nextNodes[id];
         }
-        refreshDefaultGuttersForRoofIds(nextNodes, affectedRoofIds, nodesToMarkDirty, deletedIds);
+    }
+    for (const id of gutterIds)
+        out.add(id);
+    for (const node of Object.values(nodes)) {
+        if (node?.type === 'downspout' && node.gutterId && gutterIds.has(node.gutterId)) {
+            out.add(node.id);
+        }
+    }
+}
+const deleteNodesActionImpl = (set, get, ids, options, wallDeletionPlan) => {
+    if (get().readOnly)
+        return;
+    let deletedIds = new Set();
+    let parentsToMarkDirty = new Set();
+    let nodesToMarkDirty = new Set();
+    set((state) => {
+        const plan = planNodeDeletion(state, ids, { options, wallDeletionPlan });
+        deletedIds = plan.deletedIds;
+        parentsToMarkDirty = plan.parentsToMarkDirty;
+        nodesToMarkDirty = plan.nodesToMarkDirty;
         addActiveSceneCommitNodeIds([...deletedIds, ...parentsToMarkDirty, ...nodesToMarkDirty]);
-        return { nodes: nextNodes, rootNodeIds: nextRootIds, collections: nextCollections };
+        return { nodes: plan.nodes, rootNodeIds: plan.rootNodeIds, collections: plan.collections };
     });
     // Deleted ids must leave the dirty set: every consumer skips missing
     // nodes without clearing them, so a mark on a deleted node would sit in
@@ -1328,17 +1565,101 @@ function validatedSet(set) {
         return patch;
     });
 }
-export const createNodesAction = (set, get, ops) => runWithSceneCommitNodeIds(ops.flatMap(({ node, parentId }) => {
+/** Runs the same deletion hooks and update constraints for headless scene owners. */
+export function planSceneNodeChanges(snapshot, changes) {
+    const dirtyIds = new Set();
+    let state = {
+        ...snapshot,
+        readOnly: false,
+        markDirty: (id) => {
+            dirtyIds.add(id);
+        },
+        clearDirty: (id) => {
+            dirtyIds.delete(id);
+        },
+    };
+    const set = (update) => {
+        state = { ...state, ...update(state) };
+    };
+    if (changes.update?.length)
+        updateNodesActionImpl(set, () => state, changes.update, undefined, false);
+    if (changes.delete?.length)
+        deleteNodesActionImpl(set, () => state, changes.delete, undefined, changes.wallDeletionPlan);
+    return {
+        nodes: state.nodes,
+        rootNodeIds: state.rootNodeIds,
+        collections: state.collections,
+        dirtyIds: [...dirtyIds],
+    };
+}
+export const createNodesAction = (set, get, ops, options) => runWithSceneCommitNodeIds(ops.flatMap(({ node, parentId }) => {
     const effectiveParentId = parentId ?? node.parentId;
     return effectiveParentId ? [node.id, effectiveParentId] : [node.id];
-}), () => createNodesActionImpl(validatedSet(set), get, ops));
-export const applyNodeChangesAction = (set, get, changes) => runWithSceneCommitNodeIds([
+}), () => createNodesActionImpl(validatedSet(set), get, ops, options));
+export const applyNodeChangesAction = (set, get, changes, options) => runWithSceneCommitNodeIds([
     ...(changes.create ?? []).flatMap(({ node, parentId }) => {
         const effectiveParentId = parentId ?? node.parentId;
         return effectiveParentId ? [node.id, effectiveParentId] : [node.id];
     }),
     ...(changes.update ?? []).map(({ id }) => id),
     ...(changes.delete ?? []),
-], () => applyNodeChangesActionImpl(validatedSet(set), get, changes));
-export const updateNodesAction = (set, get, updates) => runWithSceneCommitNodeIds(updates.map(({ id }) => id), () => updateNodesActionImpl(validatedSet(set), get, updates));
-export const deleteNodesAction = (set, get, ids) => runWithSceneCommitNodeIds(ids, () => deleteNodesActionImpl(validatedSet(set), get, ids));
+], () => applyNodeChangesActionImpl(validatedSet(set), get, changes, options));
+export const updateNodesAction = (set, get, updates, options) => runWithSceneCommitNodeIds(updates.map(({ id }) => id), () => updateNodesActionImpl(validatedSet(set), get, updates, options));
+export const deleteNodesAction = (set, get, ids, options) => runWithSceneCommitNodeIds(ids, () => deleteNodesActionImpl(validatedSet(set), get, ids, options));
+/**
+ * The sanctioned conversion from derived construction to an authored surface:
+ * the boundary editors' polygon edit, a 2D reshape, a manual move. Clears the
+ * derived markers (and the zone link) in the same update that carries the
+ * caller's own change, so the reconciler stops owning the surface from this
+ * commit on.
+ */
+export const detachDerivedNodeAction = (set, get, id, data) => {
+    const node = get().nodes[id];
+    if (!node)
+        return;
+    // An automatic ceiling draws its room's paint regions; once it is its own it
+    // keeps them on itself.
+    const zone = node.type === 'ceiling' && node.zoneId ? get().nodes[node.zoneId] : null;
+    const keptRegions = node.type === 'ceiling' &&
+        isDerivedNode(node) &&
+        zone?.type === 'zone' &&
+        zone.ceiling?.regions?.length &&
+        !(data && 'regions' in data)
+        ? { regions: zone.ceiling.regions }
+        : {};
+    // Spread through a plain record: merging two `Partial<AnyNode>` unions
+    // explodes into a union TypeScript cannot represent.
+    const patch = {
+        ...data,
+        ...keptRegions,
+        ...(isDerivedNode(node) ? derivedDetachPatch(node) : {}),
+        ...(node.type === 'slab' && isDerivedNode(node)
+            ? { associatedZoneIds: node.zoneIds ?? [] }
+            : {}),
+    };
+    if (Object.keys(patch).length === 0)
+        return;
+    const ownerUpdates = node.type === 'slab' && isDerivedNode(node)
+        ? (node.zoneIds ?? []).flatMap((zoneId) => {
+            const zone = get().nodes[zoneId];
+            return zone?.type === 'zone'
+                ? [{ id: zone.id, data: { floor: { ...zone.floor, sourceSlabId: node.id } } }]
+                : [];
+        })
+        : [];
+    runWithSceneCommitNodeIds([id, ...ownerUpdates.map(({ id }) => id)], () => updateNodesActionImpl(validatedSet(set), get, [{ id, data: patch }, ...ownerUpdates], {
+        derivedWriter: DERIVED_WRITER_TOKEN,
+    }));
+};
+/**
+ * What the default gutter refresh of `roofIds` would touch, without running
+ * it: the existing default gutters and downspouts it may keep or replace, and
+ * the roof segments whose `children` it rewrites. For previews of edits that
+ * trigger the refresh (a roof segment update, a delete).
+ */
+export function previewDefaultGutterRefresh(nodes, roofIds) {
+    const unsettledIds = new Set();
+    const regeneratedHostIds = new Set();
+    collectRefreshedDefaults(nodes, roofIds, unsettledIds, regeneratedHostIds);
+    return { unsettledIds, regeneratedHostIds };
+}