@pascal-app/core 1.0.0-beta.4 → 1.0.0

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

@@ -1,5 +1,7 @@
 import { nodeRegistry } from '../../registry/registry';
-import { AnyNode as AnyNodeSchema, createDefaultRidgeVentsForSegment, getEffectiveWallSurfaceMaterial, getWallSurfaceMaterialSignature, isAutoRidgeVentEnabled, isDefaultRidgeVentNode, } from '../../schema';
+import { AnyNode as AnyNodeSchema, createDefaultGuttersForSegment, createDefaultRidgeVentsForSegment, DownspoutNode as DownspoutNodeSchema, defaultDownspoutMetadata, generateId, getDefaultGutterSide, getEffectiveWallSurfaceMaterial, getWallSurfaceMaterialSignature, isAutoGutterEnabled, isAutoRidgeVentEnabled, isDefaultDownspoutNode, isDefaultGutterNode, isDefaultRidgeVentNode, parseNode, planAutomaticDownspouts, resolveAutomaticDownspoutLength, } from '../../schema';
+import { constrainWallCurveOffsetToAvoidIntersections } from '../../systems/wall/wall-curve';
+import { addActiveSceneCommitNodeIds, runWithSceneCommitNodeIds } from '../history-control';
 const DEFAULT_RIDGE_VENT_REFRESH_FIELDS = new Set([
     'roofType',
     'width',
@@ -14,6 +16,18 @@ const DEFAULT_RIDGE_VENT_REFRESH_FIELDS = new Set([
     'dutchWaistLengthRatio',
     'dutchGabletRake',
 ]);
+const DEFAULT_GUTTER_REFRESH_FIELDS = new Set([
+    'metadata',
+    'position',
+    'rotation',
+    'roofType',
+    'width',
+    'depth',
+    'wallHeight',
+    'pitch',
+    'overhang',
+    'trim',
+]);
 const NUMBER_FORMAT_BOUNDS = {
     safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
     int32: [-2147483648, 2147483647],
@@ -318,21 +332,42 @@ function formatNumericValue(value) {
         return '-Infinity';
     return String(value);
 }
-function numericSanitizeIssuesToMessage(issues) {
-    return issues
-        .map((issue) => {
-        const path = issue.path.map(String).join('.') || '<root>';
-        const to = issue.to === undefined ? '' : ` -> ${formatNumericValue(issue.to)}`;
-        return `${path}: ${formatNumericValue(issue.from)} ${issue.action}${to}`;
-    })
-        .join('; ');
+export function numericSanitizeIssuesToMessage(issues) {
+    if (!Array.isArray(issues))
+        return '';
+    try {
+        return issues
+            .map((issue) => {
+            const path = Array.isArray(issue?.path)
+                ? issue.path.map(String).join('.') || '<root>'
+                : '<unknown>';
+            const to = issue?.to === undefined ? '' : ` -> ${formatNumericValue(issue.to)}`;
+            return `${path}: ${formatNumericValue(issue?.from)} ${issue?.action ?? 'sanitized'}${to}`;
+        })
+            .join('; ');
+    }
+    catch {
+        return '<diagnostic unavailable>';
+    }
 }
 function warnSanitizedNodeMutation(mutation, nodeId, issues) {
-    console.warn(`[Scene] Sanitized invalid numeric node ${mutation}`, nodeId, numericSanitizeIssuesToMessage(issues));
+    let message = '<diagnostic unavailable>';
+    try {
+        message = numericSanitizeIssuesToMessage(issues);
+    }
+    catch {
+        // Reporting must never interrupt a node mutation.
+    }
+    try {
+        console.warn(`[Scene] Sanitized invalid numeric node ${mutation}`, nodeId, message);
+    }
+    catch {
+        // A broken diagnostic sink must not interrupt a node mutation either.
+    }
 }
 function parseCreatedNode(node, parentId) {
     const candidate = { ...node, parentId };
-    const parsed = AnyNodeSchema.safeParse(candidate);
+    const parsed = parseNode(candidate);
     if (parsed.success)
         return parsed.data;
     const schema = getNodeSchemaForType(candidate.type);
@@ -358,7 +393,7 @@ function mergeNodeUpdate(currentNode, patch) {
 }
 function parseUpdatedNode(currentNode, data) {
     const candidate = mergeNodeUpdate(currentNode, data);
-    const parsed = AnyNodeSchema.safeParse(candidate);
+    const parsed = parseNode(candidate);
     if (parsed.success)
         return parsed.data;
     const schema = getNodeSchemaForType(candidate.type);
@@ -397,6 +432,306 @@ function refreshDefaultRidgeVentsForSegment(nextNodes, segment) {
     };
     return nextVents.map((vent) => vent.id);
 }
+function shouldRefreshDefaultGutters(data) {
+    return Object.keys(data).some((key) => DEFAULT_GUTTER_REFRESH_FIELDS.has(key));
+}
+function getLeanToGutterExclusions(nodes, segmentId) {
+    return Object.values(nodes).flatMap((node) => {
+        if (node.type !== 'lean-to-extension' ||
+            node.connectionMode !== 'auto' ||
+            node.hostRoofSegmentId !== segmentId ||
+            !node.hostRoofEdge) {
+            return [];
+        }
+        const range = node.hostRoofEdgeRange ?? [0, 1];
+        return [{ side: node.hostRoofEdge, from: range[0], to: range[1] }];
+    });
+}
+function addLeanToHostRoofId(node, nodes, roofIds) {
+    if (node?.type !== 'lean-to-extension' || !node.hostRoofSegmentId)
+        return;
+    const segment = nodes[node.hostRoofSegmentId];
+    const roofId = segment?.type === 'roof-segment'
+        ? segment.parentId
+        : node.hostRoofId;
+    if (roofId && nodes[roofId]?.type === 'roof')
+        roofIds.add(roofId);
+}
+// When an eave carries several default gutter runs on the same side (e.g. a run
+// split by a lean-to exclusion), reuse the existing node whose plan position is
+// closest to the desired run rather than an arbitrary queue order — otherwise
+// the runs swap positions and their downspouts follow the wrong segment.
+function takeNearestGutterId(candidateIds, desired, nodes) {
+    if (candidateIds.length === 0)
+        return undefined;
+    let bestIndex = 0;
+    let bestDistance = Number.POSITIVE_INFINITY;
+    for (let i = 0; i < candidateIds.length; i++) {
+        const node = nodes[candidateIds[i]];
+        const position = node && 'position' in node ? node.position : undefined;
+        const dx = (position?.[0] ?? 0) - desired.position[0];
+        const dz = (position?.[2] ?? 0) - desired.position[2];
+        const distance = dx * dx + dz * dz;
+        if (distance < bestDistance) {
+            bestDistance = distance;
+            bestIndex = i;
+        }
+    }
+    return candidateIds.splice(bestIndex, 1)[0];
+}
+function refreshDefaultGuttersForSegment(nextNodes, segment, roofSegments) {
+    const childIds = Array.isArray(segment.children) ? segment.children : [];
+    const existingIds = childIds.filter((childId) => isDefaultGutterNode(nextNodes[childId], segment.id));
+    if (!isAutoGutterEnabled(segment, nextNodes) && existingIds.length === 0) {
+        return { dirtyIds: [], deletedIds: [] };
+    }
+    const existingBySide = new Map();
+    for (const id of existingIds) {
+        const side = getDefaultGutterSide(nextNodes[id], segment.id);
+        if (!side)
+            continue;
+        const ids = existingBySide.get(side) ?? [];
+        ids.push(id);
+        existingBySide.set(side, ids);
+    }
+    const desiredGutters = isAutoGutterEnabled(segment, nextNodes)
+        ? createDefaultGuttersForSegment(segment, roofSegments, getLeanToGutterExclusions(nextNodes, segment.id))
+        : [];
+    const desiredChildIds = [];
+    const dirtyIds = [];
+    for (const desired of desiredGutters) {
+        const side = getDefaultGutterSide(desired, segment.id);
+        if (!side)
+            continue;
+        const matchingIds = existingBySide.get(side);
+        const existingId = matchingIds
+            ? takeNearestGutterId(matchingIds, desired, nextNodes)
+            : undefined;
+        if (existingId) {
+            const existing = nextNodes[existingId];
+            nextNodes[existingId] = {
+                ...existing,
+                parentId: segment.id,
+                roofSegmentId: segment.id,
+                position: desired.position,
+                rotation: desired.rotation,
+                length: desired.length,
+            };
+            desiredChildIds.push(existingId);
+            dirtyIds.push(existingId);
+            continue;
+        }
+        const desiredId = desired.id;
+        nextNodes[desiredId] = { ...desired, parentId: segment.id };
+        desiredChildIds.push(desiredId);
+        dirtyIds.push(desiredId);
+    }
+    const retainedIdSet = new Set(desiredChildIds);
+    const deletedIds = existingIds.filter((id) => !retainedIdSet.has(id));
+    const deletedGutterIds = new Set(deletedIds);
+    for (const [nodeId, node] of Object.entries(nextNodes)) {
+        if (node.type === 'downspout' &&
+            node.gutterId &&
+            deletedGutterIds.has(node.gutterId)) {
+            deletedIds.push(nodeId);
+        }
+    }
+    const deletedIdSet = new Set(deletedIds);
+    for (const id of deletedIds)
+        delete nextNodes[id];
+    nextNodes[segment.id] = {
+        ...segment,
+        children: [
+            ...childIds.filter((childId) => !deletedIdSet.has(childId) && !existingIds.includes(childId)),
+            ...desiredChildIds,
+        ],
+    };
+    return { dirtyIds, deletedIds };
+}
+function getRoofSegments(nextNodes, segment) {
+    const roof = segment.parentId ? nextNodes[segment.parentId] : undefined;
+    if (!(roof && roof.type === 'roof'))
+        return [segment];
+    return (roof.children ?? [])
+        .map((childId) => nextNodes[childId])
+        .filter((node) => node?.type === 'roof-segment');
+}
+function refreshDefaultDownspoutsForRoof(nextNodes, roofSegments) {
+    const gutters = roofSegments.flatMap((segment) => {
+        const current = nextNodes[segment.id];
+        if (current?.type !== 'roof-segment')
+            return [];
+        return (current.children ?? [])
+            .map((childId) => nextNodes[childId])
+            .filter((node) => node?.type === 'gutter' && isDefaultGutterNode(node, current.id));
+    });
+    const gutterById = new Map(gutters.map((gutter) => [gutter.id, gutter]));
+    const downspouts = Object.values(nextNodes).filter((node) => node?.type === 'downspout' && Boolean(node.gutterId && gutterById.has(node.gutterId)));
+    const generated = downspouts.filter((downspout) => {
+        if (!isDefaultDownspoutNode(downspout))
+            return false;
+        const gutter = downspout.gutterId ? gutterById.get(downspout.gutterId) : undefined;
+        return gutter?.outlets.some((outlet) => outlet.id === downspout.outletId && outlet.generatedBy === 'default-downspout');
+    });
+    const generatedIds = new Set(generated.map((downspout) => downspout.id));
+    const manual = downspouts.filter((downspout) => !generatedIds.has(downspout.id));
+    const placements = planAutomaticDownspouts({
+        segments: roofSegments,
+        gutters,
+        downspouts: manual,
+    });
+    const segmentById = new Map(roofSegments.map((segment) => [segment.id, segment]));
+    const availableByGutter = new Map();
+    for (const downspout of generated) {
+        if (!downspout.gutterId)
+            continue;
+        const available = availableByGutter.get(downspout.gutterId) ?? [];
+        available.push(downspout);
+        availableByGutter.set(downspout.gutterId, available);
+    }
+    const retainedIds = new Set();
+    const retainedOutletIds = new Set();
+    const dirtyIds = new Set();
+    const deletedIds = [];
+    const outletsByGutter = new Map(gutters.map((gutter) => [gutter.id, [...(gutter.outlets ?? [])]]));
+    for (const placement of placements) {
+        const gutter = gutterById.get(placement.gutterId);
+        if (!gutter?.roofSegmentId)
+            continue;
+        const segment = segmentById.get(gutter.roofSegmentId);
+        if (!segment)
+            continue;
+        const outlets = outletsByGutter.get(gutter.id) ?? [];
+        const available = availableByGutter.get(gutter.id) ?? [];
+        let bestIndex = -1;
+        let bestDistance = Number.POSITIVE_INFINITY;
+        for (let index = 0; index < available.length; index++) {
+            const candidate = available[index];
+            const outlet = outlets.find((entry) => entry.id === candidate.outletId);
+            const distance = outlet ? Math.abs(outlet.offset - placement.offset) : 0;
+            if (distance < bestDistance) {
+                bestDistance = distance;
+                bestIndex = index;
+            }
+        }
+        const existing = bestIndex >= 0 ? available.splice(bestIndex, 1)[0] : undefined;
+        const outletId = existing?.outletId ?? generateId('outlet');
+        const outletIndex = outlets.findIndex((outlet) => outlet.id === outletId);
+        const outlet = {
+            id: outletId,
+            offset: placement.offset,
+            diameter: 0.07,
+            generatedBy: 'default-downspout',
+        };
+        if (outletIndex >= 0)
+            outlets[outletIndex] = { ...outlets[outletIndex], ...outlet };
+        else
+            outlets.push(outlet);
+        outletsByGutter.set(gutter.id, outlets);
+        retainedOutletIds.add(outletId);
+        const length = resolveAutomaticDownspoutLength(nextNodes, segment, gutter, placement.offset);
+        const downspout = existing
+            ? {
+                ...existing,
+                parentId: segment.id,
+                gutterId: gutter.id,
+                outletId,
+                length: existing.lengthMode === 'manual' ? existing.length : length,
+                lengthMode: existing.lengthMode === 'manual' ? 'manual' : 'to-ground',
+            }
+            : DownspoutNodeSchema.parse({
+                name: 'Downspout',
+                parentId: segment.id,
+                gutterId: gutter.id,
+                outletId,
+                length,
+                lengthMode: 'to-ground',
+                diameter: outlet.diameter,
+                metadata: defaultDownspoutMetadata(),
+            });
+        nextNodes[downspout.id] = downspout;
+        retainedIds.add(downspout.id);
+        dirtyIds.add(downspout.id);
+        const currentSegment = nextNodes[segment.id];
+        if (currentSegment?.type === 'roof-segment') {
+            nextNodes[segment.id] = {
+                ...currentSegment,
+                children: Array.from(new Set([...(currentSegment.children ?? []), downspout.id])),
+            };
+            dirtyIds.add(segment.id);
+        }
+    }
+    for (const [gutterId, outlets] of outletsByGutter) {
+        const gutter = nextNodes[gutterId];
+        if (gutter?.type !== 'gutter')
+            continue;
+        nextNodes[gutterId] = {
+            ...gutter,
+            outlets: outlets.filter((outlet) => outlet.generatedBy !== 'default-downspout' || retainedOutletIds.has(outlet.id)),
+        };
+        dirtyIds.add(gutterId);
+    }
+    for (const downspout of generated) {
+        const downspoutId = downspout.id;
+        if (retainedIds.has(downspoutId))
+            continue;
+        const gutter = downspout.gutterId ? nextNodes[downspout.gutterId] : undefined;
+        if (gutter?.type === 'gutter' && downspout.outletId) {
+            nextNodes[gutter.id] = {
+                ...gutter,
+                outlets: (gutter.outlets ?? []).filter((outlet) => outlet.id !== downspout.outletId),
+            };
+            dirtyIds.add(gutter.id);
+        }
+        const parent = downspout.parentId ? nextNodes[downspout.parentId] : undefined;
+        if (parent?.type === 'roof-segment') {
+            nextNodes[parent.id] = {
+                ...parent,
+                children: (parent.children ?? []).filter((childId) => childId !== downspout.id),
+            };
+            dirtyIds.add(parent.id);
+        }
+        delete nextNodes[downspoutId];
+        deletedIds.push(downspoutId);
+    }
+    return { dirtyIds: [...dirtyIds], deletedIds };
+}
+function refreshDefaultGuttersForRoof(nextNodes, segment) {
+    const roofSegments = getRoofSegments(nextNodes, segment);
+    const dirtyIds = [];
+    const deletedIds = [];
+    for (const roofSegment of roofSegments) {
+        const current = nextNodes[roofSegment.id];
+        if (current?.type !== 'roof-segment')
+            continue;
+        const result = refreshDefaultGuttersForSegment(nextNodes, current, roofSegments);
+        dirtyIds.push(...result.dirtyIds);
+        deletedIds.push(...result.deletedIds);
+    }
+    const downspoutResult = refreshDefaultDownspoutsForRoof(nextNodes, roofSegments);
+    dirtyIds.push(...downspoutResult.dirtyIds);
+    deletedIds.push(...downspoutResult.deletedIds);
+    return { dirtyIds, deletedIds };
+}
+function collectDefaultGutterRefresh(result, dirtyIds, deletedIds) {
+    for (const id of result.dirtyIds)
+        dirtyIds.add(id);
+    for (const id of result.deletedIds)
+        deletedIds.add(id);
+}
+function refreshDefaultGuttersForRoofIds(nextNodes, roofIds, dirtyIds, deletedIds) {
+    for (const roofId of new Set(roofIds)) {
+        const roof = nextNodes[roofId];
+        if (roof?.type !== 'roof')
+            continue;
+        const segment = (roof.children ?? [])
+            .map((childId) => nextNodes[childId])
+            .find((child) => child?.type === 'roof-segment');
+        if (!segment)
+            continue;
+        collectDefaultGutterRefresh(refreshDefaultGuttersForRoof(nextNodes, segment), dirtyIds, deletedIds);
+    }
+}
 // Track pending RAF for updateNodesAction to prevent multiple queued callbacks
 let pendingRafId = null;
 let pendingUpdates = new Set();
@@ -547,9 +882,11 @@ function buildWallMergePlans(nodes, idsToDelete) {
     }
     return mergePlans;
 }
-export const createNodesAction = (set, get, ops) => {
+const createNodesActionImpl = (set, get, ops) => {
     if (get().readOnly)
         return;
+    const extraNodesToMarkDirty = new Set();
+    const extraNodesToClearDirty = new Set();
     set((state) => {
         const nextNodes = { ...state.nodes };
         const nextRootIds = [...state.rootNodeIds];
@@ -584,6 +921,16 @@ export const createNodesAction = (set, get, ops) => {
                 }
             }
         }
+        const refreshedRoofIds = new Set();
+        for (const { node } of ops) {
+            const created = nextNodes[node.id];
+            if (created?.type === 'roof-segment' && created.parentId) {
+                refreshedRoofIds.add(created.parentId);
+            }
+            addLeanToHostRoofId(created, nextNodes, refreshedRoofIds);
+        }
+        refreshDefaultGuttersForRoofIds(nextNodes, refreshedRoofIds, extraNodesToMarkDirty, extraNodesToClearDirty);
+        addActiveSceneCommitNodeIds([...extraNodesToMarkDirty, ...extraNodesToClearDirty]);
         return { nodes: nextNodes, rootNodeIds: nextRootIds };
     });
     // 4. System Sync
@@ -594,25 +941,33 @@ export const createNodesAction = (set, get, ops) => {
         else if (node.parentId)
             get().markDirty(node.parentId);
     });
+    for (const id of extraNodesToMarkDirty)
+        get().markDirty(id);
+    for (const id of extraNodesToClearDirty)
+        get().clearDirty(id);
 };
-export const applyNodeChangesAction = (set, get, changes) => {
+const applyNodeChangesActionImpl = (set, get, changes) => {
     if (get().readOnly)
         return;
     const createOps = changes.create ?? [];
     const updateOps = changes.update ?? [];
     const deleteOps = changes.delete ?? [];
     const nodesToMarkDirty = new Set();
+    const nodesToClearDirty = new Set();
     const parentsToMarkDirty = new Set();
     set((state) => {
         const nextNodes = { ...state.nodes };
         const nextCollections = { ...state.collections };
         const nextRootIds = [...state.rootNodeIds];
         let resolvedRootIds = nextRootIds;
+        const roofsToRefresh = new Set();
         for (const { id, data } of updateOps) {
             const currentNode = nextNodes[id];
             if (!currentNode)
                 continue;
+            addLeanToHostRoofId(currentNode, nextNodes, roofsToRefresh);
             const updatedNode = parseUpdatedNode(currentNode, data);
+            addLeanToHostRoofId(updatedNode, nextNodes, roofsToRefresh);
             if (data.parentId !== undefined && data.parentId !== currentNode.parentId) {
                 const oldParentId = currentNode.parentId;
                 if (oldParentId && nextNodes[oldParentId]) {
@@ -639,6 +994,11 @@ export const applyNodeChangesAction = (set, get, changes) => {
                     nodesToMarkDirty.add(ventId);
                 }
             }
+            const currentSegment = nextNodes[id];
+            if (currentSegment?.type === 'roof-segment' && shouldRefreshDefaultGutters(data)) {
+                if (currentSegment.parentId)
+                    roofsToRefresh.add(currentSegment.parentId);
+            }
             nodesToMarkDirty.add(id);
         }
         for (const { node, parentId } of createOps) {
@@ -646,6 +1006,10 @@ export const applyNodeChangesAction = (set, get, changes) => {
             const newNode = parseCreatedNode(node, effectiveParentId);
             nextNodes[newNode.id] = newNode;
             nodesToMarkDirty.add(newNode.id);
+            if (newNode.type === 'roof-segment' && effectiveParentId) {
+                roofsToRefresh.add(effectiveParentId);
+            }
+            addLeanToHostRoofId(newNode, nextNodes, roofsToRefresh);
             if (effectiveParentId && nextNodes[effectiveParentId]) {
                 const parent = nextNodes[effectiveParentId];
                 if ('children' in parent && Array.isArray(parent.children)) {
@@ -675,6 +1039,13 @@ export const applyNodeChangesAction = (set, get, changes) => {
         for (const id of deleteOps) {
             collectDelete(id);
         }
+        for (const id of allIdsToDelete) {
+            const node = nextNodes[id];
+            addLeanToHostRoofId(node, nextNodes, roofsToRefresh);
+            if (node?.type === 'roof-segment' && node.parentId) {
+                roofsToRefresh.add(node.parentId);
+            }
+        }
         for (const id of allIdsToDelete) {
             const node = nextNodes[id];
             if (!node)
@@ -704,11 +1075,21 @@ export const applyNodeChangesAction = (set, get, changes) => {
             }
             delete nextNodes[id];
         }
+        refreshDefaultGuttersForRoofIds(nextNodes, roofsToRefresh, nodesToMarkDirty, nodesToClearDirty);
+        addActiveSceneCommitNodeIds([
+            ...allIdsToDelete,
+            ...nodesToMarkDirty,
+            ...nodesToClearDirty,
+            ...parentsToMarkDirty,
+        ]);
         return { nodes: nextNodes, rootNodeIds: resolvedRootIds, collections: nextCollections };
     });
     for (const id of nodesToMarkDirty) {
         get().markDirty(id);
     }
+    for (const id of nodesToClearDirty) {
+        get().clearDirty(id);
+    }
     for (const id of parentsToMarkDirty) {
         get().markDirty(id);
         const parent = get().nodes[id];
@@ -719,18 +1100,29 @@ export const applyNodeChangesAction = (set, get, changes) => {
         }
     }
 };
-export const updateNodesAction = (set, get, updates) => {
+const updateNodesActionImpl = (set, get, updates) => {
     if (get().readOnly)
         return;
     const parentsToUpdate = new Set();
     const extraNodesToUpdate = new Set();
+    const extraNodesToDelete = new Set();
+    const roofsToRefresh = new Set();
     set((state) => {
         const nextNodes = { ...state.nodes };
         for (const { id, data } of updates) {
             const currentNode = nextNodes[id];
             if (!currentNode)
                 continue;
-            const updatedNode = parseUpdatedNode(currentNode, data);
+            addLeanToHostRoofId(currentNode, nextNodes, roofsToRefresh);
+            const curveOffset = currentNode.type === 'wall' ? data.curveOffset : undefined;
+            const constrainedData = currentNode.type === 'wall' && typeof curveOffset === 'number'
+                ? {
+                    ...data,
+                    curveOffset: constrainWallCurveOffsetToAvoidIntersections(currentNode, curveOffset, Object.values(nextNodes).filter((node) => node.type === 'wall' && node.parentId === currentNode.parentId)),
+                }
+                : data;
+            const updatedNode = parseUpdatedNode(currentNode, constrainedData);
+            addLeanToHostRoofId(updatedNode, nextNodes, roofsToRefresh);
             // Handle Reparenting Logic
             if (data.parentId !== undefined && data.parentId !== currentNode.parentId) {
                 // 1. Remove from old parent
@@ -772,11 +1164,28 @@ export const updateNodesAction = (set, get, updates) => {
                     extraNodesToUpdate.add(ventId);
                 }
             }
+            const currentSegment = nextNodes[id];
+            if (currentSegment?.type === 'roof-segment' && shouldRefreshDefaultGutters(data)) {
+                if (currentSegment.parentId)
+                    roofsToRefresh.add(currentSegment.parentId);
+            }
         }
+        refreshDefaultGuttersForRoofIds(nextNodes, roofsToRefresh, extraNodesToUpdate, extraNodesToDelete);
+        addActiveSceneCommitNodeIds([
+            ...updates.map(({ id }) => id),
+            ...parentsToUpdate,
+            ...extraNodesToUpdate,
+            ...extraNodesToDelete,
+        ]);
         return { nodes: nextNodes };
     });
     // 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
+        // it now so render systems can release collective geometry in that same
+        // frame, including when the host uses render-on-demand.
+        if (u.data.visible !== undefined)
+            get().markDirty(u.id);
         pendingUpdates.add(u.id);
     }
     for (const pId of parentsToUpdate) {
@@ -785,6 +1194,9 @@ export const updateNodesAction = (set, get, updates) => {
     for (const id of extraNodesToUpdate) {
         pendingUpdates.add(id);
     }
+    for (const id of extraNodesToDelete) {
+        get().clearDirty(id);
+    }
     if (pendingRafId !== null) {
         cancelAnimationFrame(pendingRafId);
     }
@@ -796,13 +1208,14 @@ export const updateNodesAction = (set, get, updates) => {
         pendingRafId = null;
     });
 };
-export const deleteNodesAction = (set, get, ids) => {
+const deleteNodesActionImpl = (set, get, ids) => {
     if (get().readOnly)
         return;
     const parentsToMarkDirty = new Set();
     const nodesToMarkDirty = new Set();
     const deletedIds = new Set();
     const mergePlans = buildWallMergePlans(get().nodes, ids);
+    const requestedDeleteIds = new Set(ids);
     set((state) => {
         const nextNodes = { ...state.nodes };
         const nextCollections = { ...state.collections };
@@ -816,7 +1229,9 @@ export const deleteNodesAction = (set, get, ids) => {
             allIds.add(id);
             const node = nextNodes[id];
             const cascadeDeletes = node
-                ? nodeRegistry.get(node.type)?.parametrics?.onDeleteCascade?.(node, nextNodes, allIds)
+                ? nodeRegistry
+                    .get(node.type)
+                    ?.parametrics?.onDeleteCascade?.(node, nextNodes, allIds, requestedDeleteIds)
                 : null;
             if (cascadeDeletes) {
                 for (const companionId of cascadeDeletes)
@@ -832,6 +1247,14 @@ export const deleteNodesAction = (set, get, ids) => {
         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
@@ -845,7 +1268,7 @@ export const deleteNodesAction = (set, get, ids) => {
             const onDelete = nodeRegistry.get(node.type)?.parametrics?.onDelete;
             if (!onDelete)
                 continue;
-            for (const { id: targetId, data } of onDelete(node, nextNodes)) {
+            for (const { id: targetId, data } of onDelete(node, nextNodes, allIds, requestedDeleteIds)) {
                 if (allIds.has(targetId))
                     continue;
                 const target = nextNodes[targetId];
@@ -935,6 +1358,8 @@ export const deleteNodesAction = (set, get, ids) => {
             // 4. Delete the node itself
             delete nextNodes[id];
         }
+        refreshDefaultGuttersForRoofIds(nextNodes, affectedRoofIds, nodesToMarkDirty, deletedIds);
+        addActiveSceneCommitNodeIds([...deletedIds, ...parentsToMarkDirty, ...nodesToMarkDirty]);
         return { nodes: nextNodes, rootNodeIds: nextRootIds, collections: nextCollections };
     });
     // Deleted ids must leave the dirty set: every consumer skips missing
@@ -957,3 +1382,17 @@ export const deleteNodesAction = (set, get, ids) => {
         get().markDirty(id);
     });
 };
+export const createNodesAction = (set, get, ops) => runWithSceneCommitNodeIds(ops.flatMap(({ node, parentId }) => {
+    const effectiveParentId = parentId ?? node.parentId;
+    return effectiveParentId ? [node.id, effectiveParentId] : [node.id];
+}), () => createNodesActionImpl(set, get, ops));
+export const applyNodeChangesAction = (set, get, changes) => 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(set, get, changes));
+export const updateNodesAction = (set, get, updates) => runWithSceneCommitNodeIds(updates.map(({ id }) => id), () => updateNodesActionImpl(set, get, updates));
+export const deleteNodesAction = (set, get, ids) => runWithSceneCommitNodeIds(ids, () => deleteNodesActionImpl(set, get, ids));

package/dist/store/history-control.d.ts

@@ -13,6 +13,7 @@ export type SceneCommit = {
     origin: SceneCommitOrigin;
     before: SceneSnapshot;
     current: SceneSnapshot;
+    changedNodeIds?: ReadonlySet<AnyNodeId>;
 };
 export type SceneCommitListener = (commit: SceneCommit) => void;
 type TemporalStoreLike = {
@@ -33,11 +34,15 @@ type TemporalHistoryStoreLike<TPastState> = {
         }): void;
     };
 };
+export declare function activeSceneCommitNodeIds(): ReadonlySet<AnyNodeId> | undefined;
+export declare function addActiveSceneCommitNodeIds(nodeIds: Iterable<AnyNodeId>): void;
+export declare function runWithSceneCommitNodeIds<TResult>(nodeIds: Iterable<AnyNodeId>, run: () => TResult): TResult;
 export declare function areSceneSnapshotsEqual(left: SceneSnapshot, right: SceneSnapshot): boolean;
 export declare function subscribeSceneCommits(listener: SceneCommitListener): () => void;
 export declare function notifySceneCommit(commit: SceneCommit): void;
 export declare function pauseSceneHistory(sceneStore: TemporalStoreLike): void;
 export declare function resumeSceneHistory(sceneStore: TemporalStoreLike): void;
+export declare function acquireSceneHistoryPause(sceneStore: TemporalStoreLike): () => void;
 export declare function getSceneHistoryPauseDepth(): number;
 export declare function resetSceneHistoryPauseDepth(): void;
 export declare function runAsSingleSceneHistoryStep<TPastState, TResult>(sceneStore: TemporalHistoryStoreLike<TPastState>, run: () => TResult): TResult;