@pascal-app/core 1.0.6 → 1.0.7

package/dist/lib/space-detection.js

@@ -1,10 +1,14 @@
 import { ZoneNode, } from '../schema/index.js';
 import { generateId } from '../schema/base.js';
 import { findLevelAboveId, getLevelBelow, getLevelElevations } from '../services/storey.js';
+import { isSettlingDocument } from '../store/document-settling.js';
 import { activeSceneCommitNodeIds, getSceneHistoryPauseDepth, isRestoringSceneHistory, notifySceneCommit, pauseSceneHistory, resumeSceneHistory, subscribeSceneCommits, } from '../store/history-control.js';
+import { currentSceneEnvironment, sceneEnvironmentOf, } from '../store/scene-environment.js';
 import { getClampedWallCurveOffset } from '../systems/wall/wall-curve.js';
 import { changedLevelConstructionDisplacements } from './floor-foundation-stack.js';
 import { createFloorOpeningIndex, floorOpeningTargets } from './floor-opening-intent.js';
+import { porchPartOf, porchPartSignature } from './porch-framing-sync.js';
+import { railingFencedRoomIds, railingWallIds } from './railing-rooms.js';
 import { extractRooms, pointToTuple, polygonSignature, sampleWallPointsForRoomDetection, WALL_JUNCTION_TOLERANCE, } from './room-graph.js';
 import { distanceToSegment, RoomTopologyIndex } from './room-topology-index.js';
 import { applyStructureReconciliation } from './structure-commit.js';
@@ -31,7 +35,12 @@ function wallGeometrySignature(wall, nodes, levelId) {
         // Plane-bound (no stored height) is a distinct state, not a default
         // value: it resolves to the storey plane, so it must not alias an
         // explicit height of the same magnitude in the trigger signature.
-        wall.height == null ? 'plane' : wall.height.toFixed(4),
+        // A legacy height that is not a number still signs, rather than throwing.
+        wall.height == null
+            ? 'plane'
+            : typeof wall.height === 'number'
+                ? wall.height.toFixed(4)
+                : String(wall.height),
         wall.supportSlabId ?? 'elected',
         (wall.supportOffset ?? 0).toFixed(4),
         getClampedWallCurveOffset(wall).toFixed(4),
@@ -74,6 +83,9 @@ function zoneGeometrySignature(zone) {
         zone.wallMaterial,
         zone.wallOverrides,
         zone.seed,
+        // A porch's type and framing settings rebuild its posts and beam.
+        zone.roomType,
+        zone.porchFraming,
         // A drawn zone's outline is intent (it may be adopted); a room's outline is
         // derived, and an edit to it must be re-derived here as the hosted path does.
         // The kernel's own write is not a change: the baseline is taken after it.
@@ -92,11 +104,19 @@ function levelStructureSnapshots(nodes) {
     const zonesByLevel = new Map();
     const slabElevationsByLevel = new Map();
     const coveringUndersidesByLevel = new Map();
+    const porchPartsByLevel = new Map();
     const floorOpenings = [];
     for (const node of Object.values(nodes)) {
         if (!(node && typeof node === 'object' && 'parentId' in node && node.parentId))
             continue;
         const levelId = node.parentId;
+        // A porch's own post or beam moved, resized or deleted by hand hands its framing over.
+        const porchPart = porchPartSignature(node);
+        if (porchPart) {
+            const parts = porchPartsByLevel.get(levelId) ?? [];
+            parts.push(porchPart);
+            porchPartsByLevel.set(levelId, parts);
+        }
         if (node.type === 'stair' && nodes[node.deckSlabId]?.support === 'open') {
             const target = nodes[node.deckSlabId].parentId;
             const arrivals = arrivalsByLevel.get(target) ?? [];
@@ -196,6 +216,7 @@ function levelStructureSnapshots(nodes) {
         ...zonesByLevel.keys(),
         ...separatorsByLevel.keys(),
         ...openingsByLevel.keys(),
+        ...porchPartsByLevel.keys(),
     ]);
     for (const levelId of levelIds) {
         const walls = wallsByLevel.get(levelId) ?? [];
@@ -207,7 +228,7 @@ function levelStructureSnapshots(nodes) {
         const aboveSlabKey = aboveId
             ? (coveringUndersidesByLevel.get(aboveId) ?? []).sort().join(';')
             : '';
-        snapshots.set(levelId, `${(arrivalsByLevel.get(levelId) ?? []).sort().join('|')}#${(separatorsByLevel.get(levelId) ?? []).sort().join('|')}#${storeyKey}#${levelWallSnapshot(walls, nodes, levelId)}##${zones.map(zoneGeometrySignature).sort().join('||')}##${slabKey}##${aboveSlabKey}##${(ceilingIdsByLevel.get(levelId) ?? []).sort().join('|')}##${(openingsByLevel.get(levelId) ?? []).sort().join('|')}`);
+        snapshots.set(levelId, `${(arrivalsByLevel.get(levelId) ?? []).sort().join('|')}#${(separatorsByLevel.get(levelId) ?? []).sort().join('|')}#${storeyKey}#${levelWallSnapshot(walls, nodes, levelId)}##${zones.map(zoneGeometrySignature).sort().join('||')}##${slabKey}##${aboveSlabKey}##${(ceilingIdsByLevel.get(levelId) ?? []).sort().join('|')}##${(openingsByLevel.get(levelId) ?? []).sort().join('|')}##${(porchPartsByLevel.get(levelId) ?? []).sort().join('|')}`);
     }
     return snapshots;
 }
@@ -335,11 +356,17 @@ function fallbackLevelIdsForCandidates(before, current, candidateIds) {
                 if (wall?.parentId)
                     levelIds.add(wall.parentId);
             }
+            else if (porchPartOf(node)) {
+                // A porch's own post or beam edited by hand: the kernel hands its framing over.
+                if (porchPartSignature(before[id]) !== porchPartSignature(current[id]) && node.parentId)
+                    levelIds.add(node.parentId);
+            }
             else if (node.type === 'slab') {
                 const old = before[id], next = current[id];
                 const changed = !old ||
                     !next ||
-                    ['thickness', 'floorHeight', 'polygon', 'holes', 'elevation'].some((field) => JSON.stringify(old[field]) !==
+                    // Everything the covering underside below reads, as well as this level's own floor.
+                    ['thickness', 'floorHeight', 'polygon', 'holes', 'elevation', 'recessed'].some((field) => JSON.stringify(old[field]) !==
                         JSON.stringify(next[field]));
                 addLevelAndLower(node.parentId, nodes, changed);
                 if (node.plateRole === 'base' && changed)
@@ -375,9 +402,12 @@ function detectSpacesFromWalls(levelId, boundaries) {
     const rooms = extractRooms(boundaries);
     const walls = boundaries.filter((boundary) => boundary.type === 'wall');
     const roomPolygons = rooms.map((room) => room.polygon);
+    const spans = rooms.flatMap((room) => room.spans);
+    // A room a railing fences off from the outside (a deck's guard) is outside.
+    const fenced = railingFencedRoomIds(spans, railingWallIds(walls));
     const wallUpdates = walls.map((wall) => ({
         wallId: wall.id,
-        ...classifyWallSides(wall, rooms.flatMap((room) => room.spans)),
+        ...classifyWallSides(wall, spans, fenced),
     }));
     return {
         rooms,
@@ -389,6 +419,48 @@ function detectSpacesFromWalls(levelId, boundaries) {
 export function detectSpacesForLevel(levelId, walls) {
     return detectSpacesFromWalls(levelId, walls);
 }
+/**
+ * Levels whose structure intent differs between two versions of a scene: what a paused batch's
+ * resume (and a detached scene's reconciliation) re-derives.
+ */
+export function changedStructureLevelIds(before, after) {
+    const previous = levelStructureSnapshots(before);
+    const current = levelStructureSnapshots(after);
+    return [...new Set([...previous.keys(), ...current.keys()])].filter((id) => previous.get(id) !== current.get(id));
+}
+/**
+ * Levels whose structure an edit from `before` to `after` asks to re-derive, chosen as space
+ * detection chooses them for a store commit: from the nodes the edit changed (walls by level, and
+ * the fallbacks for levels, stairs, openings, slabs, ceilings, zones and separators), without
+ * signing every level of the scene.
+ */
+export function structureLevelsForChange(before, after) {
+    const candidateIds = new Set();
+    for (const id in after)
+        if (after[id] !== before[id] && !onlyChildrenChanged(before[id], after[id]))
+            candidateIds.add(id);
+    for (const id in before)
+        if (!(id in after))
+            candidateIds.add(id);
+    if (!candidateIds.size)
+        return [];
+    const levels = fallbackLevelIdsForCandidates(before, after, candidateIds);
+    for (const levelId of changedWallIdsByLevel(before, after, candidateIds).keys())
+        levels.add(levelId);
+    return [...levels];
+}
+/**
+ * A parent whose child list alone changed: the children created or deleted are candidates of
+ * their own, so the parent adds nothing (an item placed on a level re-derives no structure).
+ */
+function onlyChildrenChanged(before, after) {
+    if (!(before && after))
+        return false;
+    for (const key of new Set([...Object.keys(before), ...Object.keys(after)]))
+        if (key !== 'children' && before[key] !== after[key])
+            return false;
+    return true;
+}
 function syncSceneStructure(levelIds, sceneStore, previousNodes, mintId) {
     applyStructureReconciliation(sceneStore, { levelIds, previousNodes, mintId });
 }
@@ -402,26 +474,28 @@ function publishSpaces(levelIds, nodes, editorStore) {
     }
     editorStore.getState().setSpaces(nextSpaces);
 }
-// Batch writers pause intermediate topology; the final resume reconciles every
-// level whose intent changed, including batches completed outside a store commit.
-let spaceDetectionPauseDepth = 0;
-const resumeListeners = new Set();
+const SPACE_DETECTION_PAUSE = Symbol('space-detection-pause');
+const pauseOf = (environment = currentSceneEnvironment()) => environment.slot(SPACE_DETECTION_PAUSE, () => ({
+    depth: 0,
+    resumeListeners: new Set(),
+}));
 /** Pause structure reconciliation. Refcounted — pair with `resumeSpaceDetection`. */
 export function pauseSpaceDetection() {
-    spaceDetectionPauseDepth += 1;
+    pauseOf().depth += 1;
 }
 /** Resume structure reconciliation. No-op if not currently paused. */
 export function resumeSpaceDetection() {
-    if (spaceDetectionPauseDepth === 0)
+    const pause = pauseOf();
+    if (pause.depth === 0)
         return;
-    spaceDetectionPauseDepth -= 1;
-    if (spaceDetectionPauseDepth === 0)
-        for (const reconcile of resumeListeners)
+    pause.depth -= 1;
+    if (pause.depth === 0)
+        for (const reconcile of pause.resumeListeners)
             reconcile();
 }
 /** True iff structure reconciliation is currently paused. */
 export function isSpaceDetectionPaused() {
-    return spaceDetectionPauseDepth > 0;
+    return pauseOf().depth > 0;
 }
 export function createRoomTopologyIndex() {
     return new RoomTopologyIndex({
@@ -436,6 +510,7 @@ export function initSpaceDetectionSync(sceneStore, editorStore, options = {}) {
     // scene that merely loaded — rerunning on hydration resurrected auto slabs
     // the user had deleted in an earlier session.
     const initialNodes = sceneStore.getState().nodes;
+    const pause = pauseOf(sceneEnvironmentOf(sceneStore));
     const topologyIndex = new RoomTopologyIndex({
         detectRooms: extractRooms,
         sampleWall: (wall) => sampleWallPointsForRoomDetection(wall).map(pointToTuple),
@@ -459,11 +534,11 @@ export function initSpaceDetectionSync(sceneStore, editorStore, options = {}) {
         previousNodes = nodes;
     };
     adoptSceneBaseline(initialNodes);
-    const unsubscribeCommits = subscribeSceneCommits((commit) => {
+    const unsubscribeCommits = sceneEnvironmentOf(sceneStore).run(() => subscribeSceneCommits((commit) => {
         if (commit.origin === 'local')
             return;
         adoptSceneBaseline(commit.current.nodes);
-    });
+    }));
     // Keep reconciliation in this synchronous store subscription. Zundo emits
     // the originating local SceneCommit only after subscribers return, so the
     // history-paused derived writes below join that commit's current snapshot
@@ -476,11 +551,27 @@ export function initSpaceDetectionSync(sceneStore, editorStore, options = {}) {
             adoptSceneBaseline(state.nodes);
             return;
         }
-        if (getSceneHistoryPauseDepth() > 0 || sceneStore.temporal.getState().isTracking === false)
+        // A settling host derives this edit's structure itself (reconcileDocument): only the topology
+        // and spaces of the levels whose walls it changed are brought up to date here. Its derived
+        // writes are history-paused, so this runs before the pause check: the baseline must take them
+        // in, or the next edit would derive the host's rooms again from before it.
+        if (isSettlingDocument(sceneStore)) {
+            const levels = [
+                ...changedWallIdsByLevel(previousNodes, state.nodes, activeSceneCommitNodeIds()).keys(),
+            ];
+            for (const levelId of levels)
+                topologyIndex.rebuildLevel(levelId, state.nodes);
+            if (levels.length)
+                publishSpaces(levels, state.nodes, editorStore);
+            previousNodes = state.nodes;
+            return;
+        }
+        if (getSceneHistoryPauseDepth(sceneStore) > 0 ||
+            sceneStore.temporal.getState().isTracking === false)
             return;
         const nodes = state.nodes;
         const candidateIds = activeSceneCommitNodeIds();
-        if (spaceDetectionPauseDepth > 0)
+        if (pause.depth > 0)
             return;
         const changedWalls = changedWallIdsByLevel(previousNodes, nodes, candidateIds);
         if (candidateIds && changedWalls.size > 0) {
@@ -563,10 +654,7 @@ export function initSpaceDetectionSync(sceneStore, editorStore, options = {}) {
             return { nodes, rootNodeIds, collections, materials, installedPlugins };
         };
         const beforeCommit = capture();
-        const nodes = beforeCommit.nodes;
-        const before = levelStructureSnapshots(previousNodes);
-        const after = levelStructureSnapshots(nodes);
-        const levels = [...new Set([...before.keys(), ...after.keys()])].filter((id) => before.get(id) !== after.get(id));
+        const levels = changedStructureLevelIds(previousNodes, beforeCommit.nodes);
         if (!levels.length)
             return;
         isProcessing = true;
@@ -586,11 +674,11 @@ export function initSpaceDetectionSync(sceneStore, editorStore, options = {}) {
         // so collaboration receives the originator's ids even for AI/template batches.
         notifySceneCommit({ origin: 'local', before: beforeCommit, current: capture() });
     };
-    resumeListeners.add(reconcilePaused);
+    pause.resumeListeners.add(reconcilePaused);
     return () => {
         unsubscribe();
         unsubscribeCommits();
-        resumeListeners.delete(reconcilePaused);
+        pause.resumeListeners.delete(reconcilePaused);
     };
 }
 export function wallTouchesOthers(wall, otherWalls) {

package/dist/lib/structure-kernel.d.ts

@@ -1,4 +1,4 @@
-import type { AnyNode, AnyNodeId, WallNode } from '../schema/index.js';
+import type { AnyNode, AnyNodeId, SeparatorNode, WallNode } from '../schema/index.js';
 import type { ZoneNode } from '../schema/nodes/zone.js';
 import { type FloorOpeningIndex } from './floor-opening-intent.js';
 import { type Polygon, type Ring } from './polygon-boolean.js';
@@ -33,31 +33,44 @@ export type LevelStructureSnapshot = {
     rooms: StructureRoom[];
 };
 /**
- * The rooms that are outside: without a ceiling, and left without crossing a wall, through a
- * separator no room stands behind or into another such room. A porch made a room for its floor
- * left its wall with no outside: the front door faced the hall. A room that only lost its
- * ceiling is walled in and a kitchen open to a terrace keeps its ceiling, so both stay inside; so
- * does a courtyard walled on every side, a limit of this rule.
+ * The rooms closed off outside the house, and what they are by default: open to the outside across
+ * invisible walls or railings nothing stands behind, along at least as much of their edge as walls
+ * close (a porch on the front, or in a corner of the house). Closed with invisible walls, a porch;
+ * fenced with railings alone, a deck. A room walled on three sides and open on the fourth (a
+ * kitchen open to a terrace, a recessed porch) is not one of them. `lengthOf` is a wall's or a
+ * separator's length; `railingIds` the railing walls.
+ */
+export declare function outsideRoomTypes(rooms: readonly {
+    spans: readonly BoundarySpan[];
+}[], lengthOf: (boundaryId: string) => number, railingIds?: ReadonlySet<string>): Map<string, 'porch' | 'deck'>;
+/**
+ * The rooms that are outside: a porch, deck or patio (`roomType`, outdoors whatever covers it), and
+ * a room without a ceiling left without crossing a wall, through a separator no room stands behind
+ * or into another such room. A porch made a room for its floor left its wall with no outside: the
+ * front door faced the hall. A room that only lost its ceiling is walled in and a kitchen open to a
+ * terrace keeps its ceiling, so both stay inside; so does a courtyard walled on every side, a limit
+ * of this rule.
  */
 export declare function outdoorRoomIds(rooms: readonly {
     spans: readonly BoundarySpan[];
     hasCeiling: boolean;
+    outdoor?: boolean;
 }[]): Set<string>;
 /** A wall face is inside when an indoor room stands on it; an outdoor room's face is outside. */
 export declare function classifyWallSides(wall: WallNode, spans: readonly BoundarySpan[], outdoor?: ReadonlySet<string>): Pick<WallNode, 'frontSide' | 'backSide'>;
 export declare function reconcileLevelStructure(input: Parameters<typeof planLevelStructure>[0]): ReturnType<typeof planLevelStructure>;
-declare function planLevelStructure({ levelId, nodes, mintId, openingIndex, }: {
+declare function planLevelStructure({ levelId, nodes, previousNodes, mintId, openingIndex, }: {
     levelId: string;
     nodes: SceneNodes;
     previousNodes?: SceneNodes;
-    mintId: (kind: 'zone' | 'ceiling' | 'slab' | 'separator') => string;
+    mintId: (kind: 'zone' | 'ceiling' | 'slab' | 'separator' | 'column' | 'beam') => string;
     openingIndex?: FloorOpeningIndex;
 }): {
     patches: NodePatch[];
     snapshot: LevelStructureSnapshot;
     events: StructureEvent[];
 };
-export declare function createLevelStructurePreview(levelId: string, nodes: SceneNodes): (walls: readonly WallNode[]) => {
+export declare function createLevelStructurePreview(levelId: string, nodes: SceneNodes): (walls: readonly WallNode[], separators?: readonly SeparatorNode[]) => {
     op: 'update';
     id: AnyNodeId;
     data: Partial<AnyNode>;

package/dist/lib/structure-kernel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"structure-kernel.d.ts","sourceRoot":"","sources":["../../src/lib/structure-kernel.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"structure-kernel.d.ts","sourceRoot":"","sources":["../../src/lib/structure-kernel.ts"],"names":[],"mappings":"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"}

package/dist/lib/structure-kernel.js

@@ -12,9 +12,12 @@ import { buildFloorPlates, warnPlateFailure } from './floor-plates.js';
 import { floorRoomFaces } from './floor-room-faces.js';
 import { remapFloorStepOverrideKeys } from './floor-step-finish.js';
 import { newZone } from './new-zone.js';
+import { isOutdoorRoom, nextOutdoorRoomName, OUTDOOR_ROOM_DEFAULTS } from './outdoor-room.js';
 import { replacementPlateFor } from './plate-reference.js';
 import { area, containsPoint, difference, intersection, union, } from './polygon-boolean.js';
 import { polygonInteriorPoint } from './polygon-label.js';
+import { reconcilePorchFraming } from './porch-framing-sync.js';
+import { railingFencedRoomIds, railingWallIds } from './railing-rooms.js';
 import { pointFromTuple } from './room-graph.js';
 import { roomNameAllocator } from './room-name.js';
 import { adoptableFace, compareAdoptionFits, compareExistingRooms, existingRoomFace, zoneFaceFits, } from './room-zone-adoption.js';
@@ -61,14 +64,42 @@ function equal(a, b) {
 /** Span overlap below this (a fraction of the boundary) is a shared endpoint, not a shared edge. */
 const SPAN_OVERLAP = 1e-6;
 /**
- * The rooms that are outside: without a ceiling, and left without crossing a wall, through a
- * separator no room stands behind or into another such room. A porch made a room for its floor
- * left its wall with no outside: the front door faced the hall. A room that only lost its
- * ceiling is walled in and a kitchen open to a terrace keeps its ceiling, so both stay inside; so
- * does a courtyard walled on every side, a limit of this rule.
+ * The rooms closed off outside the house, and what they are by default: open to the outside across
+ * invisible walls or railings nothing stands behind, along at least as much of their edge as walls
+ * close (a porch on the front, or in a corner of the house). Closed with invisible walls, a porch;
+ * fenced with railings alone, a deck. A room walled on three sides and open on the fourth (a
+ * kitchen open to a terrace, a recessed porch) is not one of them. `lengthOf` is a wall's or a
+ * separator's length; `railingIds` the railing walls.
  */
-export function outdoorRoomIds(rooms) {
-    const separatorSpans = rooms.flatMap((room) => room.spans.filter((span) => span.kind === 'separator'));
+export function outsideRoomTypes(rooms, lengthOf, railingIds = new Set()) {
+    const railing = (span) => span.kind === 'wall' && railingIds.has(span.boundaryId);
+    const { exposed } = openLineExposure(rooms, (span) => span.kind === 'separator' || railing(span));
+    const spanLength = (span) => (span.t1 - span.t0) * lengthOf(span.boundaryId);
+    const types = new Map();
+    for (const room of rooms) {
+        let open = 0;
+        let walled = 0;
+        let invisible = false;
+        for (const span of room.spans) {
+            if (span.kind === 'wall' && !railing(span))
+                walled += spanLength(span);
+            else if (exposed(span)) {
+                open += spanLength(span);
+                invisible ||= span.kind === 'separator';
+            }
+        }
+        if (room.spans[0] && open > 0 && open >= walled - 1e-6)
+            types.set(room.spans[0].roomId, invisible ? 'porch' : 'deck');
+    }
+    return types;
+}
+/** Each separator span's spans across it, and whether any stretch of it has none. */
+function separatorExposure(rooms) {
+    return openLineExposure(rooms, (span) => span.kind === 'separator');
+}
+/** Each open line's span (`isOpen`): the spans across it, and whether any stretch of it has none. */
+function openLineExposure(rooms, isOpen) {
+    const separatorSpans = rooms.flatMap((room) => room.spans.filter(isOpen));
     const across = (span) => separatorSpans
         .filter((other) => other.boundaryId === span.boundaryId &&
         other.face !== span.face &&
@@ -83,8 +114,25 @@ export function outdoorRoomIds(rooms) {
         }
         return reach < span.t1 - SPAN_OVERLAP;
     };
-    const open = new Map(rooms.flatMap((room) => !room.hasCeiling && room.spans[0] ? [[room.spans[0].roomId, room.spans]] : []));
-    const queue = [...open].flatMap(([id, spans]) => spans.some((span) => span.kind === 'separator' && exposed(span)) ? [id] : []);
+    return { across, exposed };
+}
+/**
+ * The rooms that are outside: a porch, deck or patio (`roomType`, outdoors whatever covers it), and
+ * a room without a ceiling left without crossing a wall, through a separator no room stands behind
+ * or into another such room. A porch made a room for its floor left its wall with no outside: the
+ * front door faced the hall. A room that only lost its ceiling is walled in and a kitchen open to a
+ * terrace keeps its ceiling, so both stay inside; so does a courtyard walled on every side, a limit
+ * of this rule.
+ */
+export function outdoorRoomIds(rooms) {
+    const { across, exposed } = separatorExposure(rooms);
+    const open = new Map(rooms.flatMap((room) => (!room.hasCeiling || room.outdoor) && room.spans[0]
+        ? [[room.spans[0].roomId, room.spans]]
+        : []));
+    const declared = new Set(rooms.flatMap((room) => (room.outdoor && room.spans[0] ? [room.spans[0].roomId] : [])));
+    const queue = [...open].flatMap(([id, spans]) => declared.has(id) || spans.some((span) => span.kind === 'separator' && exposed(span))
+        ? [id]
+        : []);
     const outdoor = new Set(queue);
     for (let id = queue.pop(); id !== undefined; id = queue.pop())
         for (const span of open.get(id))
@@ -122,7 +170,7 @@ export function reconcileLevelStructure(input) {
         return { patches: [], snapshot: { levelId: input.levelId, rooms: [] }, events: [] };
     }
 }
-function planLevelStructure({ levelId, nodes, mintId, openingIndex, }) {
+function planLevelStructure({ levelId, nodes, previousNodes, mintId, openingIndex, }) {
     const snapshot = { levelId, rooms: [] };
     const events = [];
     const level = nodes[levelId];
@@ -200,6 +248,14 @@ function planLevelStructure({ levelId, nodes, mintId, openingIndex, }) {
     const zoneByFace = new Map();
     const retiredTo = new Map();
     const nextRoomName = roomNameAllocator(allZones);
+    // A new room closed off outside the house is a porch, or a deck when railings fence it
+    // (`lib/outdoor-room`).
+    const boundaryLengths = new Map([...walls, ...separators].map((boundary) => [
+        boundary.id,
+        Math.hypot(boundary.end[0] - boundary.start[0], boundary.end[1] - boundary.start[1]),
+    ]));
+    const outsideTypes = outsideRoomTypes(faces, (id) => boundaryLengths.get(id) ?? 0, railingWallIds(walls));
+    const roomNames = allZones.map((zone) => zone.name);
     faces.forEach((face, index) => {
         const rooms = zones
             .filter((zone) => preferred.get(zone.id) === index && !adoptionFits.has(zone.id))
@@ -219,20 +275,37 @@ function planLevelStructure({ levelId, nodes, mintId, openingIndex, }) {
                 .sort((a, b) => scores.get(b.id)[index] - scores.get(a.id)[index] || compareIds(a.id, b.id))[0];
         if (source)
             sourceByFace.set(index, source);
+        const outside = !survivor && !source && face.spans[0] ? outsideTypes.get(face.spans[0].roomId) : undefined;
         const zone = survivor ??
-            newZone({
-                id: mintId('zone'),
-                parentId: levelId,
-                name: nextRoomName(),
-                polygon: face.polygon.outer,
-                floor: source?.floor,
-                wallMaterial: source?.wallMaterial,
-                floorStepFinish: source?.floorStepFinish,
-                floorStepOverrides: source?.floorStepOverrides,
-                floorEdgeFinish: source?.floorEdgeFinish,
-                hasFloor: source?.hasFloor,
-                hasCeiling: source?.hasCeiling,
-            });
+            (outside
+                ? newZone({
+                    id: mintId('zone'),
+                    parentId: levelId,
+                    name: nextOutdoorRoomName(outside, roomNames),
+                    polygon: face.polygon.outer,
+                    roomType: outside,
+                    floor: {
+                        drop: OUTDOOR_ROOM_DEFAULTS[outside].drop,
+                        finish: OUTDOOR_ROOM_DEFAULTS[outside].finish,
+                    },
+                    ...(OUTDOOR_ROOM_DEFAULTS[outside].covered ? {} : { hasCeiling: false }),
+                })
+                : newZone({
+                    id: mintId('zone'),
+                    parentId: levelId,
+                    name: nextRoomName(),
+                    polygon: face.polygon.outer,
+                    floor: source?.floor,
+                    wallMaterial: source?.wallMaterial,
+                    floorStepFinish: source?.floorStepFinish,
+                    floorStepOverrides: source?.floorStepOverrides,
+                    floorEdgeFinish: source?.floorEdgeFinish,
+                    hasFloor: source?.hasFloor,
+                    hasCeiling: source?.hasCeiling,
+                    roomType: source?.roomType,
+                }));
+        if (outside)
+            roomNames.push(zone.name);
         const seed = zone.seed && containsPoint([face.polygon], zone.seed)
             ? zone.seed
             : polygonInteriorPoint({ polygon: face.polygon.outer, holes: face.polygon.holes }, !zone.seed);
@@ -447,6 +520,7 @@ function planLevelStructure({ levelId, nodes, mintId, openingIndex, }) {
                 material: template?.material,
                 materialPreset: template?.materialPreset,
                 slots: template?.slots,
+                buildUp: template?.buildUp,
                 visible: template?.visible,
             });
         const updated = {
@@ -594,11 +668,36 @@ function planLevelStructure({ levelId, nodes, mintId, openingIndex, }) {
     for (const components of ceilingComponentsByFace.values())
         for (const ceiling of components)
             ceiling.children = [...new Set(ceiling.children)].sort();
+    // A covered porch's posts and beam (`lib/porch-framing-sync`).
+    const porchFraming = reconcilePorchFraming({
+        levelId,
+        nodes,
+        previousNodes,
+        zones: [
+            ...new Map([...allZones, ...next.values()].flatMap((zone) => zone.type === 'zone' && !deleted.has(zone.id)
+                ? [[zone.id, (next.get(zone.id) ?? zone)]]
+                : [])).values(),
+        ],
+        plates: floorPlan.plates,
+        current: (id) => next.get(id) ?? nodes[id],
+        mintId,
+    });
+    for (const node of porchFraming.put)
+        put(node);
+    for (const id of porchFraming.delete)
+        deleted.add(id);
     const spans = snapshot.rooms.flatMap((room) => room.spans);
-    const outdoor = outdoorRoomIds([...zoneByFace].map(([index, zone]) => ({
-        spans: faces[index].spans,
-        hasCeiling: (next.get(zone.id) ?? zone).hasCeiling !== false,
-    })));
+    const outdoor = outdoorRoomIds([...zoneByFace].map(([index, zone]) => {
+        const current = (next.get(zone.id) ?? zone);
+        return {
+            spans: faces[index].spans,
+            hasCeiling: current.hasCeiling !== false,
+            outdoor: isOutdoorRoom(current),
+        };
+    }));
+    // A room a railing fences off from the outside (a deck's guard) is outside too.
+    for (const id of railingFencedRoomIds(spans, railingWallIds(walls)))
+        outdoor.add(id);
     for (const wall of walls)
         put({ ...wall, ...next.get(wall.id), ...classifyWallSides(wall, spans, outdoor) });
     for (const ceiling of allCeilings) {
@@ -706,7 +805,12 @@ export function createLevelStructurePreview(levelId, nodes) {
     let wallIds = new Set(Object.values(draft)
         .filter((node) => node.type === 'wall' && node.parentId === levelId)
         .map((node) => node.id));
-    return (walls) => {
+    let separatorIds = new Set(Object.values(draft)
+        .filter((node) => node.type === 'separator' && node.parentId === levelId)
+        .map((node) => node.id));
+    // `separators`, when given, are the level's invisible walls as the gesture
+    // leaves them (an invisible-wall push); left out, the stored ones stand.
+    return (walls, separators) => {
         const currentIds = new Set();
         for (const wall of walls) {
             if (wall.parentId !== levelId)
@@ -720,6 +824,20 @@ export function createLevelStructurePreview(levelId, nodes) {
             if (!currentIds.has(id))
                 delete draft[id];
         wallIds = currentIds;
+        if (separators) {
+            const current = new Set();
+            for (const separator of separators) {
+                if (separator.parentId !== levelId)
+                    continue;
+                current.add(separator.id);
+                if (draft[separator.id] !== separator)
+                    draft[separator.id] = separator;
+            }
+            for (const id of separatorIds)
+                if (!current.has(id))
+                    delete draft[id];
+            separatorIds = current;
+        }
         let id = 0;
         // The stored surfaces are the committed reconciliation; only what the
         // moved walls reshape differs from them.

package/dist/lib/structure-reconcile.d.ts

@@ -1,5 +1,5 @@
 import { type NodePatch, type SceneNodes, type StructureEvent } from './structure-kernel.js';
-export type StructureIdFactory = (kind: 'zone' | 'ceiling' | 'slab' | 'separator') => string;
+export type StructureIdFactory = (kind: 'zone' | 'ceiling' | 'slab' | 'separator' | 'column' | 'beam') => string;
 export type SceneStructureInput = {
     nodes: SceneNodes;
     levelIds?: string[];

package/dist/lib/structure-reconcile.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"structure-reconcile.d.ts","sourceRoot":"","sources":["../../src/lib/structure-reconcile.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,UAAU,EACf,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAA;AAE3B,MAAM,MAAM,kBAAkB,GAAG,CAAC,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,WAAW,KAAK,MAAM,CAAA;AAC5F,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,UAAU,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,MAAM,EAAE,kBAAkB,CAAA;IAC1B,aAAa,CAAC,EAAE,UAAU,CAAA;CAC3B,CAAA;AACD,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,UAAU,CAAA;IACjB,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,MAAM,EAAE,cAAc,EAAE,CAAA;CACzB,CAAA;AAyED,wBAAgB,uBAAuB,CAAC,EACtC,KAAK,EACL,QAAQ,EACR,MAAM,EACN,aAAa,GACd,EAAE,mBAAmB,GAAG,oBAAoB,CA+K5C"}
+{"version":3,"file":"structure-reconcile.d.ts","sourceRoot":"","sources":["../../src/lib/structure-reconcile.ts"],"names":[],"mappings":"AAWA,OAAO,EACL,KAAK,SAAS,EAEd,KAAK,UAAU,EACf,KAAK,cAAc,EACpB,MAAM,oBAAoB,CAAA;AAG3B,MAAM,MAAM,kBAAkB,GAAG,CAC/B,IAAI,EAAE,MAAM,GAAG,SAAS,GAAG,MAAM,GAAG,WAAW,GAAG,QAAQ,GAAG,MAAM,KAChE,MAAM,CAAA;AACX,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,UAAU,CAAA;IACjB,QAAQ,CAAC,EAAE,MAAM,EAAE,CAAA;IACnB,MAAM,EAAE,kBAAkB,CAAA;IAC1B,aAAa,CAAC,EAAE,UAAU,CAAA;CAC3B,CAAA;AACD,MAAM,MAAM,oBAAoB,GAAG;IACjC,KAAK,EAAE,UAAU,CAAA;IACjB,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,MAAM,EAAE,cAAc,EAAE,CAAA;CACzB,CAAA;AAyED,wBAAgB,uBAAuB,CAAC,EACtC,KAAK,EACL,QAAQ,EACR,MAAM,EACN,aAAa,GACd,EAAE,mBAAmB,GAAG,oBAAoB,CAiL5C"}