@pascal-app/core 0.9.1 → 0.9.2

package/dist/services/validate-dwv.d.ts

@@ -0,0 +1,32 @@
+import type { AnyNode, AnyNodeId } from '../schema';
+/**
+ * IPC validators for the DWV (drain-waste-vent) system — the "CodeRule"
+ * primitive from the domain brief. The slope, minimum-size, and
+ * trap-arm rules are all geometric and read straight off the node
+ * fields, so they live here in core (pure logic) where the editor can
+ * surface them and analyses can reuse them.
+ *
+ * Scope is residential IPC, simplified:
+ *   - 704.1 drainage slope by pipe size.
+ *   - 909 trap-arm maximum developed length by trap size.
+ *
+ * These are intentionally conservative approximations, not a certified
+ * plan-check — enough to flag the mistakes a drawing tool invites.
+ */
+/** Drainage findings, worst-first per consumer's sort. */
+export type DwvSeverity = 'error' | 'warning';
+export type DwvFinding = {
+    severity: DwvSeverity;
+    /** Stable rule id, e.g. 'slope-too-flat'. */
+    code: string;
+    /** Human-readable, already-formatted message. */
+    message: string;
+    /** Nodes the finding implicates (usually one). */
+    nodeIds: AnyNodeId[];
+};
+/**
+ * Run every DWV rule over the scene and return the findings. Empty
+ * array = nothing to flag. Pure: no scene/store access, no rendering.
+ */
+export declare function validateDwv(nodes: Readonly<Record<AnyNodeId, AnyNode>>): DwvFinding[];
+//# sourceMappingURL=validate-dwv.d.ts.map

package/dist/services/validate-dwv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-dwv.d.ts","sourceRoot":"","sources":["../../src/services/validate-dwv.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAGnD;;;;;;;;;;;;;GAaG;AAEH,0DAA0D;AAC1D,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,SAAS,CAAA;AAE7C,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,WAAW,CAAA;IACrB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAA;IACf,kDAAkD;IAClD,OAAO,EAAE,SAAS,EAAE,CAAA;CACrB,CAAA;AAuDD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAAG,UAAU,EAAE,CAwErF"}

package/dist/services/validate-dwv.js

@@ -0,0 +1,118 @@
+import { buildPortComponents } from './system-graph';
+/** IPC 704.1 minimum drainage slope (rise/run, dimensionless) by
+ *  nominal pipe size: ¼"/ft (1:48) under 3", ⅛"/ft (1:96) for 3–6",
+ *  1/16"/ft (1:192) at 8"+. */
+function minSlopeFor(diameterIn) {
+    if (diameterIn < 3)
+        return 1 / 48;
+    if (diameterIn < 8)
+        return 1 / 96;
+    return 1 / 192;
+}
+/** IPC Table 909.1 maximum trap-arm developed length (meters) by trap
+ *  size: 30" @ 1¼", 42" @ 1½", 60" @ 2", 72" @ 3", 120" @ 4". */
+const TRAP_ARM_MAX_M = [
+    [1.25, 30 * 0.0254],
+    [1.5, 42 * 0.0254],
+    [2, 60 * 0.0254],
+    [3, 72 * 0.0254],
+    [4, 120 * 0.0254],
+];
+function trapArmMaxFor(diameterIn) {
+    let max = Infinity;
+    for (const [size, lengthM] of TRAP_ARM_MAX_M) {
+        if (diameterIn <= size)
+            return lengthM;
+        max = lengthM;
+    }
+    return max;
+}
+/** Slopes shallower than this fraction of the minimum are flagged
+ *  "too flat" — a small tolerance keeps round-off off the list. */
+const SLOPE_TOLERANCE = 0.9;
+/** Horizontal legs shorter than this (meters) are treated as vertical
+ *  stacks and skipped from the slope check. */
+const VERTICAL_LEG_EPS_M = 0.02;
+function legSlope(a, b) {
+    const horizontalM = Math.hypot(b[0] - a[0], b[2] - a[2]);
+    if (horizontalM < VERTICAL_LEG_EPS_M)
+        return { horizontalM, slope: Infinity };
+    return { horizontalM, slope: Math.abs(a[1] - b[1]) / horizontalM };
+}
+function inchLabel(value) {
+    return `${value}"`;
+}
+/** Per-foot slope as a readable fraction, e.g. 0.0208 → '¼"/ft'. */
+function slopePerFootLabel(slope) {
+    const inchesPerFoot = slope * 12;
+    return `${inchesPerFoot.toFixed(2)}"/ft`;
+}
+/**
+ * Run every DWV rule over the scene and return the findings. Empty
+ * array = nothing to flag. Pure: no scene/store access, no rendering.
+ */
+export function validateDwv(nodes) {
+    const findings = [];
+    // ── Per-segment slope (waste only) ──────────────────────────────
+    for (const node of Object.values(nodes)) {
+        if (node?.type !== 'pipe-segment' || node.system !== 'waste')
+            continue;
+        const path = node.path;
+        const minSlope = minSlopeFor(node.diameter);
+        const maxSlope = node.diameter / 12; // 1 pipe-diameter per foot → siphoning
+        let flaggedFlat = false;
+        let flaggedSteep = false;
+        for (let i = 0; i < path.length - 1; i++) {
+            const { slope } = legSlope(path[i], path[i + 1]);
+            if (slope === Infinity)
+                continue; // vertical stack leg
+            if (!flaggedFlat && slope < minSlope * SLOPE_TOLERANCE) {
+                findings.push({
+                    severity: 'error',
+                    code: 'slope-too-flat',
+                    message: `${inchLabel(node.diameter)} drain slopes ${slopePerFootLabel(slope)} — IPC 704.1 requires at least ${slopePerFootLabel(minSlope)}.`,
+                    nodeIds: [node.id],
+                });
+                flaggedFlat = true;
+            }
+            if (!flaggedSteep && slope > maxSlope) {
+                findings.push({
+                    severity: 'warning',
+                    code: 'slope-too-steep',
+                    message: `${inchLabel(node.diameter)} drain slopes ${slopePerFootLabel(slope)} — over one pipe-diameter per foot risks siphoning the traps.`,
+                    nodeIds: [node.id],
+                });
+                flaggedSteep = true;
+            }
+        }
+    }
+    // ── Component-scoped trap rules ──────────────────────────────────
+    for (const component of buildPortComponents(nodes)) {
+        const traps = [];
+        for (const id of component) {
+            const node = nodes[id];
+            if (!node)
+                continue;
+            if (node.type === 'pipe-trap') {
+                traps.push(node);
+            }
+        }
+        // Trap-arm developed length: trap outlet → its vent, capped by size.
+        // Independent of waste segments — a trap on its own can already be
+        // over-armed.
+        for (const trap of traps) {
+            const t = trap;
+            const armLengthM = t.armLengthM ?? 0;
+            const maxArm = trapArmMaxFor(t.diameter);
+            if (armLengthM > maxArm + 1e-6) {
+                findings.push({
+                    severity: 'error',
+                    code: 'trap-arm-too-long',
+                    message: `${inchLabel(t.diameter)} trap arm runs ${(armLengthM / 0.0254).toFixed(0)}" to its vent — IPC 909.1 caps it at ${(maxArm / 0.0254).toFixed(0)}".`,
+                    nodeIds: [t.id],
+                });
+            }
+        }
+    }
+    return findings;
+}

package/dist/services/validate-dwv.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validate-dwv.test.d.ts.map

package/dist/services/validate-dwv.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-dwv.test.d.ts","sourceRoot":"","sources":["../../src/services/validate-dwv.test.ts"],"names":[],"mappings":""}

package/dist/services/validate-dwv.test.js

@@ -0,0 +1,109 @@
+import { describe, expect, test } from 'bun:test';
+import { registerNode } from '../registry';
+import { validateDwv } from './validate-dwv';
+// The validator reads node fields directly + buildPortComponents (which
+// consults def.ports), so register stub port-providers for the DWV kinds
+// it groups by. Mirrors the system-graph test's approach.
+function stubDef(kind, ports) {
+    registerNode({
+        kind,
+        schemaVersion: 1,
+        schema: {},
+        category: 'utility',
+        defaults: () => ({}),
+        capabilities: {},
+        ports,
+    });
+}
+stubDef('pipe-segment', (node) => {
+    const path = node.path;
+    const diameter = node.diameter;
+    const system = node.system;
+    return [
+        { id: 'start', position: path[0], direction: [-1, 0, 0], diameter, system },
+        {
+            id: 'end',
+            position: path[path.length - 1],
+            direction: [1, 0, 0],
+            diameter,
+            system,
+        },
+    ];
+});
+stubDef('pipe-trap', (node) => {
+    const position = node.position;
+    return [{ id: 'inlet', position, direction: [0, 1, 0], diameter: 1.5, system: 'waste' }];
+});
+let nextId = 0;
+function makeNode(type, fields) {
+    nextId += 1;
+    return { id: `${type}_${nextId}`, type, object: 'node', parentId: null, ...fields };
+}
+function sceneOf(...nodes) {
+    return Object.fromEntries(nodes.map((n) => [n.id, n]));
+}
+/** A waste run from a→b. Drop the end Y to slope it. */
+function waste(path, diameter = 2) {
+    return makeNode('pipe-segment', { path, diameter, system: 'waste' });
+}
+const QUARTER_PER_FOOT = 1 / 48;
+describe('validateDwv — slope', () => {
+    test('flags a flat waste run', () => {
+        const run = waste([
+            [0, 0, 0],
+            [3, 0, 0], // dead level
+        ]);
+        const findings = validateDwv(sceneOf(run));
+        expect(findings.some((f) => f.code === 'slope-too-flat')).toBe(true);
+    });
+    test('passes a run sloped at quarter-inch per foot', () => {
+        const drop = 3 * QUARTER_PER_FOOT;
+        const run = waste([
+            [0, 0, 0],
+            [3, -drop, 0],
+        ]);
+        const findings = validateDwv(sceneOf(run));
+        expect(findings.some((f) => f.code === 'slope-too-flat')).toBe(false);
+    });
+    test('flags an over-steep run (siphoning risk)', () => {
+        // 2" pipe, max slope = 2/12 ≈ 0.167; drop 2m over 1m horizontal.
+        const run = waste([
+            [0, 0, 0],
+            [1, -2, 0],
+        ]);
+        const findings = validateDwv(sceneOf(run));
+        expect(findings.some((f) => f.code === 'slope-too-steep')).toBe(true);
+    });
+    test('ignores vents (level is fine)', () => {
+        const vent = makeNode('pipe-segment', {
+            path: [
+                [0, 0, 0],
+                [0, 3, 0],
+            ],
+            diameter: 2,
+            system: 'vent',
+        });
+        const findings = validateDwv(sceneOf(vent));
+        expect(findings.length).toBe(0);
+    });
+});
+describe('validateDwv — trap arm', () => {
+    test('flags an over-long trap arm', () => {
+        const trap = makeNode('pipe-trap', {
+            position: [0, 0, 0],
+            diameter: 1.5, // max arm 42in = 1.067m
+            armLengthM: 2, // way over
+        });
+        const findings = validateDwv(sceneOf(trap));
+        expect(findings.some((f) => f.code === 'trap-arm-too-long')).toBe(true);
+    });
+    test('passes a trap arm within the limit', () => {
+        const trap = makeNode('pipe-trap', {
+            position: [0, 0, 0],
+            diameter: 2, // max arm 60in = 1.524m
+            armLengthM: 1,
+        });
+        const findings = validateDwv(sceneOf(trap));
+        expect(findings.some((f) => f.code === 'trap-arm-too-long')).toBe(false);
+    });
+});

package/dist/store/actions/node-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAKf,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAG9C,KAAK,YAAY,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAA;AAC3D,KAAK,YAAY,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAC7D,KAAK,YAAY,GAAG,SAAS,CAAA;AAqrB7B,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,YAAY,EAAE,SAkDpB,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAA;CAAE,SAoIvF,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SA2ErD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SAsGjB,CAAA"}
+{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EASf,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAG9C,KAAK,YAAY,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAA;AAC3D,KAAK,YAAY,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAC7D,KAAK,YAAY,GAAG,SAAS,CAAA;AA0uB7B,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,YAAY,EAAE,SAkDpB,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAA;CAAE,SAyIvF,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SAoFrD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SAqIjB,CAAA"}

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

@@ -1,4 +1,19 @@
-import { AnyNode as AnyNodeSchema, getEffectiveWallSurfaceMaterial, getWallSurfaceMaterialSignature, } from '../../schema';
+import { nodeRegistry } from '../../registry/registry';
+import { AnyNode as AnyNodeSchema, createDefaultRidgeVentsForSegment, getEffectiveWallSurfaceMaterial, getWallSurfaceMaterialSignature, isAutoRidgeVentEnabled, isDefaultRidgeVentNode, } from '../../schema';
+const DEFAULT_RIDGE_VENT_REFRESH_FIELDS = new Set([
+    'roofType',
+    'width',
+    'depth',
+    'pitch',
+    'overhang',
+    'wallThickness',
+    'shingleThickness',
+    'gambrelLowerWidthRatio',
+    'mansardSteepWidthRatio',
+    'dutchHipWidthRatio',
+    'dutchWaistLengthRatio',
+    'dutchGabletRake',
+]);
 const NUMBER_FORMAT_BOUNDS = {
     safeint: [Number.MIN_SAFE_INTEGER, Number.MAX_SAFE_INTEGER],
     int32: [-2147483648, 2147483647],
@@ -341,6 +356,34 @@ function parseUpdatedNode(currentNode, data) {
     warnSanitizedNodeMutation('update', currentNode.id, sanitized.issues);
     return { ...currentNode, ...sanitized.value };
 }
+function shouldRefreshDefaultRidgeVents(data) {
+    return Object.keys(data).some((key) => DEFAULT_RIDGE_VENT_REFRESH_FIELDS.has(key));
+}
+function refreshDefaultRidgeVentsForSegment(nextNodes, segment) {
+    const childIds = Array.isArray(segment.children) ? segment.children : [];
+    if (!isAutoRidgeVentEnabled(segment, nextNodes))
+        return [];
+    const defaultIds = childIds.filter((childId) => isDefaultRidgeVentNode(nextNodes[childId], segment.id));
+    const defaultIdSet = new Set(defaultIds);
+    for (const id of defaultIds) {
+        delete nextNodes[id];
+    }
+    const nextVents = createDefaultRidgeVentsForSegment(segment);
+    for (const vent of nextVents) {
+        nextNodes[vent.id] = {
+            ...vent,
+            parentId: segment.id,
+        };
+    }
+    nextNodes[segment.id] = {
+        ...segment,
+        children: [
+            ...childIds.filter((childId) => !defaultIdSet.has(childId)),
+            ...nextVents.map((vent) => vent.id),
+        ],
+    };
+    return nextVents.map((vent) => vent.id);
+}
 // Track pending RAF for updateNodesAction to prevent multiple queued callbacks
 let pendingRafId = null;
 let pendingUpdates = new Set();
@@ -575,6 +618,11 @@ export const applyNodeChangesAction = (set, get, changes) => {
                 }
             }
             nextNodes[id] = updatedNode;
+            if (updatedNode.type === 'roof-segment' && shouldRefreshDefaultRidgeVents(data)) {
+                for (const ventId of refreshDefaultRidgeVentsForSegment(nextNodes, updatedNode)) {
+                    nodesToMarkDirty.add(ventId);
+                }
+            }
             nodesToMarkDirty.add(id);
         }
         for (const { node, parentId } of createOps) {
@@ -659,6 +707,7 @@ export const updateNodesAction = (set, get, updates) => {
     if (get().readOnly)
         return;
     const parentsToUpdate = new Set();
+    const extraNodesToUpdate = new Set();
     set((state) => {
         const nextNodes = { ...state.nodes };
         for (const { id, data } of updates) {
@@ -702,6 +751,11 @@ export const updateNodesAction = (set, get, updates) => {
             }
             // Apply the update
             nextNodes[id] = updatedNode;
+            if (updatedNode.type === 'roof-segment' && shouldRefreshDefaultRidgeVents(data)) {
+                for (const ventId of refreshDefaultRidgeVentsForSegment(nextNodes, updatedNode)) {
+                    extraNodesToUpdate.add(ventId);
+                }
+            }
         }
         return { nodes: nextNodes };
     });
@@ -712,6 +766,9 @@ export const updateNodesAction = (set, get, updates) => {
     for (const pId of parentsToUpdate) {
         pendingUpdates.add(pId);
     }
+    for (const id of extraNodesToUpdate) {
+        pendingUpdates.add(id);
+    }
     if (pendingRafId !== null) {
         cancelAnimationFrame(pendingRafId);
     }
@@ -728,6 +785,7 @@ export const deleteNodesAction = (set, get, ids) => {
         return;
     const parentsToMarkDirty = new Set();
     const nodesToMarkDirty = new Set();
+    const deletedIds = new Set();
     const mergePlans = buildWallMergePlans(get().nodes, ids);
     set((state) => {
         const nextNodes = { ...state.nodes };
@@ -741,6 +799,13 @@ export const deleteNodesAction = (set, get, ids) => {
                 return;
             allIds.add(id);
             const node = nextNodes[id];
+            const cascadeDeletes = node
+                ? nodeRegistry.get(node.type)?.parametrics?.onDeleteCascade?.(node, nextNodes, allIds)
+                : null;
+            if (cascadeDeletes) {
+                for (const companionId of cascadeDeletes)
+                    collect(companionId);
+            }
             if (node && 'children' in node) {
                 for (const cid of node.children)
                     collect(cid);
@@ -751,6 +816,29 @@ export const deleteNodesAction = (set, get, ids) => {
         for (const plan of mergePlans) {
             allIds.add(plan.secondaryWallId);
         }
+        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)) {
+                if (allIds.has(targetId))
+                    continue;
+                const target = nextNodes[targetId];
+                if (!target)
+                    continue;
+                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)) {
@@ -805,6 +893,11 @@ export const deleteNodesAction = (set, get, ids) => {
         }
         return { nodes: nextNodes, rootNodeIds: nextRootIds, collections: nextCollections };
     });
+    // 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
+    // the set (and defeat the consumers' empty-set early exit) forever.
+    for (const id of deletedIds)
+        get().clearDirty(id);
     // Mark affected nodes dirty: parents of deleted nodes and their remaining children
     // (e.g. deleting a slab affects sibling walls via level elevation changes)
     parentsToMarkDirty.forEach((parentId) => {

package/dist/store/actions/ridge-vent-update.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=ridge-vent-update.test.d.ts.map

package/dist/store/actions/ridge-vent-update.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"ridge-vent-update.test.d.ts","sourceRoot":"","sources":["../../../src/store/actions/ridge-vent-update.test.ts"],"names":[],"mappings":""}