@pascal-app/core 1.0.3 → 1.0.5

package/dist/systems/owned-floor-openings.js

@@ -0,0 +1,347 @@
+import { canonicalOpeningRing } from '../lib/canonical-opening-ring.js';
+import { FloorOpeningNode as FloorOpeningSchema } from '../schema/nodes/floor-opening.js';
+import { resolveCeilingHeight } from '../services/level-height.js';
+import { getLevelElevations } from '../services/storey.js';
+import { syncAutoElevatorOpenings } from './elevator/elevator-opening-sync.js';
+import { stairFootprintAABB } from './stair/stair-footprint.js';
+import { syncAutoStairOpenings } from './stair/stair-opening-sync.js';
+import { resolveStairTotalRise } from './stair/stair-rise-query.js';
+const isBox = (box) => {
+    const { minX, minZ, maxX, maxZ } = (box ?? {});
+    return [minX, minZ, maxX, maxZ].every(Number.isFinite) && maxX > minX && maxZ > minZ;
+};
+/** Where `value` falls along `from`, at the same place along `to`. */
+const rescale = (value, from, to) => to[0] + ((value - from[0]) / (from[1] - from[0])) * (to[1] - to[0]);
+function ownerPose(value) {
+    if (!value || typeof value !== 'object')
+        return;
+    const pose = value;
+    if (!Array.isArray(pose.position) ||
+        pose.position.length !== 3 ||
+        !pose.position.every((coordinate) => typeof coordinate === 'number' && Number.isFinite(coordinate)) ||
+        typeof pose.rotation !== 'number' ||
+        !Number.isFinite(pose.rotation) ||
+        typeof pose.width !== 'number' ||
+        !Number.isFinite(pose.width) ||
+        !(pose.width > 0) ||
+        typeof pose.runLength !== 'number' ||
+        !Number.isFinite(pose.runLength) ||
+        !(pose.runLength > 0))
+        return;
+    const { footprint, ...straight } = pose;
+    return isBox(footprint) ? { ...straight, footprint } : straight;
+}
+function hashKey(key) {
+    let hash = 0xcbf29ce484222325n;
+    for (const byte of new TextEncoder().encode(key))
+        hash = BigInt.asUintN(64, (hash ^ BigInt(byte)) * 0x100000001b3n);
+    return `floor-opening_${hash.toString(36).padStart(16, '0')}`;
+}
+function ownerFor(metadata) {
+    return metadata.source === 'stair'
+        ? metadata.stairId
+        : metadata.source === 'elevator'
+            ? metadata.elevatorId
+            : undefined;
+}
+function withoutOwnedCuts(nodes) {
+    const stripped = { ...nodes };
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'slab' && node.type !== 'ceiling')
+            continue;
+        const kept = (node.holes ?? []).flatMap((hole, index) => {
+            const metadata = node.holeMetadata?.[index];
+            if (metadata?.source === 'stair' || metadata?.source === 'elevator')
+                return [];
+            if (metadata?.source === 'floor-opening' && metadata.openingId) {
+                const opening = nodes[metadata.openingId];
+                if (!opening ||
+                    (opening.type === 'floor-opening' &&
+                        (opening.source === 'stair' || opening.source === 'elevator')))
+                    return [];
+            }
+            return [{ hole, metadata: metadata ?? { source: 'manual' } }];
+        });
+        if (kept.length !== (node.holes ?? []).length)
+            stripped[node.id] = {
+                ...node,
+                holes: kept.map((entry) => entry.hole),
+                holeMetadata: kept.map((entry) => entry.metadata),
+            };
+    }
+    return stripped;
+}
+function desiredCuts(nodes) {
+    let draft = withoutOwnedCuts(nodes);
+    for (const derive of [syncAutoElevatorOpenings, syncAutoStairOpenings]) {
+        const updates = derive(draft);
+        if (!updates.length)
+            continue;
+        draft = { ...draft };
+        for (const { id, data } of updates)
+            draft[id] = { ...draft[id], ...data };
+    }
+    return cutsFromSurfaces(draft, nodes);
+}
+function cutsFromSurfaces(surfaces, owners) {
+    const cuts = [];
+    for (const surface of Object.values(surfaces)) {
+        if (surface.type !== 'slab' && surface.type !== 'ceiling')
+            continue;
+        for (const [index, polygon] of (surface.holes ?? []).entries()) {
+            const metadata = surface.holeMetadata?.[index];
+            if (metadata?.source !== 'stair' && metadata?.source !== 'elevator')
+                continue;
+            const ownerId = ownerFor(metadata);
+            if (ownerId && owners[ownerId]?.type === metadata.source)
+                cuts.push({ source: metadata.source, ownerId, surface, polygon });
+        }
+    }
+    return cuts;
+}
+export function planOwnedFloorOpenings(nodes, options = {}) {
+    const values = Object.values(nodes);
+    if (!values.some((node) => node.type === 'stair' ||
+        node.type === 'elevator' ||
+        (node.type === 'floor-opening' && (node.source === 'stair' || node.source === 'elevator'))))
+        return [];
+    const existing = values.filter((node) => node.type === 'floor-opening' &&
+        (node.source === 'stair' || node.source === 'elevator') &&
+        !!node.ownerId &&
+        !!node.surfaceId);
+    const authored = values.filter((node) => node.type === 'floor-opening' &&
+        (node.source === 'stair' || node.source === 'elevator') &&
+        !!node.ownerId &&
+        !node.surfaceId);
+    const eligible = (ownerId) => !options.ownerIds || options.ownerIds.has(ownerId);
+    const byLevel = new Map();
+    const elevations = options.enforceReach === false ? undefined : getLevelElevations(nodes);
+    for (const cut of options.materializedNodes
+        ? cutsFromSurfaces(options.materializedNodes, nodes)
+        : desiredCuts(nodes)) {
+        const owner = nodes[cut.ownerId];
+        if (!eligible(cut.ownerId))
+            continue;
+        const level = cut.surface.parentId ? nodes[cut.surface.parentId] : undefined;
+        if (options.skipExistingSurfaces &&
+            level?.type === 'level' &&
+            level.metadata?.legacyAutoOpeningsMigrated === true &&
+            !existing.some((opening) => opening.ownerId === cut.ownerId && opening.source === cut.source) &&
+            !(nodes[cut.surface.id]?.type === 'slab' || nodes[cut.surface.id]?.type === 'ceiling'
+                ? nodes[cut.surface.id].holeMetadata?.some((metadata) => metadata.source === cut.source && ownerFor(metadata) === cut.ownerId)
+                : false))
+            continue;
+        if (owner?.type === 'stair' && elevations) {
+            const from = elevations.get(owner.fromLevelId ?? owner.parentId ?? '');
+            const target = elevations.get(cut.surface.parentId ?? '');
+            if (from && target && from.buildingId === target.buildingId) {
+                const rise = resolveStairTotalRise(owner, nodes);
+                const surfaceHeight = cut.surface.type === 'slab'
+                    ? (cut.surface.elevation ?? 0.05)
+                    : resolveCeilingHeight(cut.surface, nodes);
+                const targetRise = target.baseY - from.baseY + surfaceHeight - owner.position[1];
+                if (rise + Math.max(0.35, (rise / Math.max(owner.stepCount, 1)) * 2) < targetRise)
+                    continue;
+            }
+        }
+        if (options.skipExistingSurfaces &&
+            existing.some((opening) => opening.ownerId === cut.ownerId && opening.source === cut.source))
+            continue;
+        if (authored.some((opening) => opening.source === cut.source &&
+            opening.ownerId === cut.ownerId &&
+            opening.parentId === cut.surface.parentId) &&
+            !existing.some((opening) => opening.source === cut.source &&
+                opening.ownerId === cut.ownerId &&
+                opening.parentId === cut.surface.parentId))
+            continue;
+        if (owner?.type === 'stair' && (owner.slabOpeningMode ?? 'none') !== 'destination')
+            continue;
+        if (!cut.surface.parentId)
+            continue;
+        const key = JSON.stringify([cut.source, cut.ownerId, cut.surface.parentId]);
+        byLevel.set(key, [...(byLevel.get(key) ?? []), cut]);
+    }
+    const patches = [];
+    const retained = new Set();
+    const addedByLevel = new Map();
+    const deletedByLevel = new Map();
+    for (const opening of authored) {
+        if (!eligible(opening.ownerId))
+            continue;
+        const owner = nodes[opening.ownerId];
+        if (!owner ||
+            owner.type !== opening.source ||
+            existing.some((candidate) => candidate.source === opening.source &&
+                candidate.ownerId === opening.ownerId &&
+                candidate.parentId === opening.parentId)) {
+            patches.push({ op: 'delete', id: opening.id });
+            if (opening.parentId) {
+                const removed = deletedByLevel.get(opening.parentId) ?? new Set();
+                removed.add(opening.id);
+                deletedByLevel.set(opening.parentId, removed);
+            }
+            continue;
+        }
+        if (owner.type !== 'stair')
+            continue;
+        const oldPose = ownerPose(opening.metadata.ownerPose);
+        const segment = owner.children
+            .map((id) => nodes[id])
+            .find((node) => node?.type === 'stair-segment');
+        const runLength = segment?.type === 'stair-segment' ? segment.length : (oldPose?.runLength ?? 1);
+        // With its segments hidden or missing, the stair keeps the footprint it last had.
+        const box = oldPose?.footprint
+            ? (stairFootprintAABB({ ...owner, position: [0, 0, 0], rotation: 0 }, nodes) ??
+                oldPose.footprint)
+            : null;
+        const pose = {
+            position: owner.position,
+            rotation: owner.rotation,
+            width: owner.width,
+            runLength,
+            ...(box ? { footprint: box } : {}),
+        };
+        const target = opening.metadata.ownerOpeningTarget === 'source' || opening.drawnOn === 'ceiling'
+            ? owner.fromLevelId
+            : owner.toLevelId;
+        const parentId = target && nodes[target]?.type === 'level' ? target : opening.parentId;
+        const poseChanged = oldPose && JSON.stringify(oldPose) !== JSON.stringify(pose);
+        const polygon = poseChanged
+            ? canonicalOpeningRing(opening.polygon.map(([x, z]) => {
+                const dx = x - oldPose.position[0];
+                const dz = z - oldPose.position[2];
+                const cosOld = Math.cos(oldPose.rotation);
+                const sinOld = Math.sin(oldPose.rotation);
+                const oldX = dx * cosOld - dz * sinOld;
+                const oldZ = dx * sinOld + dz * cosOld;
+                const was = oldPose.footprint;
+                const [localX, localZ] = was && box
+                    ? [
+                        rescale(oldX, [was.minX, was.maxX], [box.minX, box.maxX]),
+                        rescale(oldZ, [was.minZ, was.maxZ], [box.minZ, box.maxZ]),
+                    ]
+                    : [oldX * (owner.width / oldPose.width), oldZ * (runLength / oldPose.runLength)];
+                const cos = Math.cos(owner.rotation);
+                const sin = Math.sin(owner.rotation);
+                return [
+                    owner.position[0] + localX * cos + localZ * sin,
+                    owner.position[2] - localX * sin + localZ * cos,
+                ];
+            }))
+            : opening.polygon;
+        const metadata = { ...opening.metadata, ownerPose: pose };
+        const data = {};
+        if (JSON.stringify(polygon) !== JSON.stringify(opening.polygon))
+            data.polygon = polygon;
+        if (parentId !== opening.parentId) {
+            data.parentId = parentId;
+            if (opening.parentId) {
+                const removed = deletedByLevel.get(opening.parentId) ?? new Set();
+                removed.add(opening.id);
+                deletedByLevel.set(opening.parentId, removed);
+            }
+            if (parentId)
+                addedByLevel.set(parentId, [...(addedByLevel.get(parentId) ?? []), opening.id]);
+        }
+        if (JSON.stringify(metadata) !== JSON.stringify(opening.metadata))
+            data.metadata = metadata;
+        if (Object.keys(data).length)
+            patches.push({ op: 'update', id: opening.id, data });
+    }
+    for (const [key, cuts] of byLevel) {
+        const [source, ownerId, levelId] = JSON.parse(key);
+        const siblings = existing
+            .filter((node) => node.source === source && node.ownerId === ownerId && node.parentId === levelId)
+            .sort((a, b) => a.id.localeCompare(b.id));
+        cuts.sort((a, b) => Number(b.surface.type === 'slab') - Number(a.surface.type === 'slab') ||
+            a.surface.id.localeCompare(b.surface.id) ||
+            JSON.stringify(a.polygon).localeCompare(JSON.stringify(b.polygon)));
+        const old = siblings[0] ??
+            existing.find((node) => node.source === source &&
+                node.ownerId === ownerId &&
+                node.drawnOn === (cuts[0].surface.type === 'slab' ? 'floor' : 'ceiling') &&
+                !retained.has(node.id) &&
+                !byLevel.has(JSON.stringify([source, ownerId, node.parentId])));
+        const id = old?.id ?? hashKey(JSON.stringify([source, ownerId, levelId]));
+        const legacyPlateCuts = {};
+        const legacyCeilingCuts = {};
+        for (const cut of cuts) {
+            const map = cut.surface.type === 'slab' ? legacyPlateCuts : legacyCeilingCuts;
+            const rings = map[cut.surface.id] ?? [];
+            if (!rings.some((ring) => JSON.stringify(ring) === JSON.stringify(cut.polygon)))
+                map[cut.surface.id] = [...rings, cut.polygon];
+        }
+        const primary = cuts[0];
+        const candidate = FloorOpeningSchema.parse({
+            ...old,
+            id,
+            parentId: levelId,
+            name: source === 'stair' ? 'Stair opening' : 'Elevator opening',
+            polygon: canonicalOpeningRing(primary.polygon),
+            source,
+            ownerId,
+            surfaceId: primary.surface.id,
+            drawnOn: primary.surface.type === 'slab' ? 'floor' : 'ceiling',
+            cutsPrimary: true,
+            cutsAdjacent: false,
+            legacyPlateCuts: Object.keys(legacyPlateCuts).length ? legacyPlateCuts : undefined,
+            legacyCeilingCuts: Object.keys(legacyCeilingCuts).length ? legacyCeilingCuts : undefined,
+        });
+        retained.add(id);
+        if (old) {
+            const data = {};
+            for (const property of [
+                'parentId',
+                'surfaceId',
+                'polygon',
+                'legacyPlateCuts',
+                'legacyCeilingCuts',
+                'drawnOn',
+            ])
+                if (JSON.stringify(old[property]) !==
+                    JSON.stringify(candidate[property]))
+                    data[property] = candidate[property];
+            if (Object.keys(data).length)
+                patches.push({ op: 'update', id: old.id, data: data });
+            if (old.parentId !== candidate.parentId) {
+                if (old.parentId) {
+                    const removed = deletedByLevel.get(old.parentId) ?? new Set();
+                    removed.add(old.id);
+                    deletedByLevel.set(old.parentId, removed);
+                }
+                if (candidate.parentId)
+                    addedByLevel.set(candidate.parentId, [
+                        ...(addedByLevel.get(candidate.parentId) ?? []),
+                        old.id,
+                    ]);
+            }
+        }
+        else {
+            patches.push({ op: 'create', node: candidate });
+            if (candidate.parentId)
+                addedByLevel.set(candidate.parentId, [...(addedByLevel.get(candidate.parentId) ?? []), id]);
+        }
+    }
+    for (const opening of existing) {
+        if (!eligible(opening.ownerId) || retained.has(opening.id) || options.skipExistingSurfaces)
+            continue;
+        patches.push({ op: 'delete', id: opening.id });
+        if (opening.parentId) {
+            const removed = deletedByLevel.get(opening.parentId) ?? new Set();
+            removed.add(opening.id);
+            deletedByLevel.set(opening.parentId, removed);
+        }
+    }
+    for (const levelId of new Set([...addedByLevel.keys(), ...deletedByLevel.keys()])) {
+        const level = nodes[levelId];
+        if (level?.type !== 'level')
+            continue;
+        const children = [
+            ...level.children.filter((id) => !deletedByLevel.get(levelId)?.has(id)),
+            ...(addedByLevel.get(levelId) ?? []),
+        ];
+        if (JSON.stringify(children) !== JSON.stringify(level.children))
+            patches.push({ op: 'update', id: level.id, data: { children } });
+    }
+    return patches;
+}

package/dist/systems/reconcile-owned-floor-openings.d.ts

@@ -0,0 +1,3 @@
+import type { NodePatch, SceneNodes } from '../lib/structure-kernel.js';
+export declare function reconcileOwnedFloorOpeningChanges(before: SceneNodes, changes: NodePatch[]): void;
+//# sourceMappingURL=reconcile-owned-floor-openings.d.ts.map

package/dist/systems/reconcile-owned-floor-openings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"reconcile-owned-floor-openings.d.ts","sourceRoot":"","sources":["../../src/systems/reconcile-owned-floor-openings.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,SAAS,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAA;AAKpE,wBAAgB,iCAAiC,CAAC,MAAM,EAAE,UAAU,EAAE,OAAO,EAAE,SAAS,EAAE,QAkBzF"}

package/dist/systems/reconcile-owned-floor-openings.js

@@ -0,0 +1,25 @@
+import { createFloorOpeningIndex, floorOpeningTargets } from '../lib/floor-opening-intent.js';
+import { applyStructureReconciliation } from '../lib/structure-commit.js';
+import { generateId } from '../schema/base.js';
+import useScene from '../store/use-scene.js';
+export function reconcileOwnedFloorOpeningChanges(before, changes) {
+    const after = useScene.getState().nodes;
+    const oldIndex = createFloorOpeningIndex(before);
+    const newIndex = createFloorOpeningIndex(after);
+    const levels = new Set();
+    for (const change of changes) {
+        const id = change.op === 'create' ? change.node.id : change.id;
+        for (const [nodes, index] of [
+            [before, oldIndex],
+            [after, newIndex],
+        ]) {
+            const opening = nodes[id];
+            if (opening?.type !== 'floor-opening')
+                continue;
+            for (const target of floorOpeningTargets(nodes, opening, index))
+                levels.add(target.levelId);
+        }
+    }
+    if (levels.size)
+        applyStructureReconciliation(useScene, { levelIds: [...levels], mintId: generateId });
+}

package/dist/systems/roof/roof-elevation-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-elevation-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-elevation-system.tsx"],"names":[],"mappings":"AAgCA,wBAAgB,2BAA2B,IAAI,MAAM,IAAI,CAmExD;AAED,wBAAgB,mBAAmB,SAGlC"}
+{"version":3,"file":"roof-elevation-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-elevation-system.tsx"],"names":[],"mappings":"AAiCA,wBAAgB,2BAA2B,IAAI,MAAM,IAAI,CAwExD;AAED,wBAAgB,mBAAmB,SAGlC"}

package/dist/systems/roof/roof-elevation-system.js

@@ -1,5 +1,6 @@
 'use client';
 import { useEffect } from 'react';
+import { roofsKeptOverStorey } from '../../services/roof-move.js';
 import { getSceneHistoryPauseDepth, notifySceneCommit, pauseSceneHistory, resumeSceneHistory, } from '../../store/history-control.js';
 import useScene from '../../store/use-scene.js';
 import { resolveRoofElevation } from './roof-elevation.js';
@@ -20,10 +21,13 @@ export function initializeRoofElevationSync() {
     let disposed = false;
     let queued = false;
     let syncing = false;
-    const schedule = () => {
+    // The nodes before this pass's first change: a roof above its storey keeps its height over it.
+    let changedFrom = null;
+    const schedule = (previous = null) => {
         if (queued)
             return;
         queued = true;
+        changedFrom = previous;
         // Wall bases use the spatial grid, whose listener must finish before this pass.
         queueMicrotask(() => {
             queued = false;
@@ -32,7 +36,9 @@ export function initializeRoofElevationSync() {
             const { nodes, updateNodes, readOnly } = useScene.getState();
             if (readOnly)
                 return;
-            const updates = [];
+            const updates = changedFrom
+                ? roofsKeptOverStorey(changedFrom, nodes)
+                : [];
             for (const node of Object.values(nodes)) {
                 if (node.type !== 'roof' || node.support?.kind !== 'walls')
                     continue;
@@ -77,7 +83,7 @@ export function initializeRoofElevationSync() {
             const next = state.nodes[id];
             const prev = previous.nodes[id];
             if (next !== prev && (isElevationRelevant(next) || isElevationRelevant(prev))) {
-                schedule();
+                schedule(previous.nodes);
                 return;
             }
         }

package/dist/systems/roof/roof-elevation.d.ts

@@ -1,4 +1,9 @@
 import type { AnyNode, LevelNode, RoofNode, WallNode } from '../../schema/index.js';
 export declare function resolveRoofWallTopElevation(targetLevelId: LevelNode['id'], wall: WallNode, nodes: Readonly<Record<string, AnyNode>>, elevations?: Map<string, import("../../index.js").LevelElevation>): number;
 export declare function resolveRoofElevation(roof: RoofNode, nodes: Readonly<Record<string, AnyNode>>): number;
+/**
+ * The tallest top of `levelId`'s walls a roof stands on, from the floor of the level holding the
+ * roof (m); null when it stands on none of them, or has no segments to stand with.
+ */
+export declare function roofWallTop(roof: RoofNode, nodes: Readonly<Record<string, AnyNode>>, levelId: string): number | null;
 //# sourceMappingURL=roof-elevation.d.ts.map

package/dist/systems/roof/roof-elevation.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"roof-elevation.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-elevation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAmB,QAAQ,EAAE,MAAM,cAAc,CAAA;AAM3F,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,EAC9B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,8CAA4B,GACrC,MAAM,CASR;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,CAwFR"}
+{"version":3,"file":"roof-elevation.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-elevation.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAmB,QAAQ,EAAE,MAAM,cAAc,CAAA;AAO3F,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,EAC9B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,8CAA4B,GACrC,MAAM,CAMR;AAqFD,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,CAiCR;AAED;;;GAGG;AACH,wBAAgB,WAAW,CACzB,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,OAAO,EAAE,MAAM,GACd,MAAM,GAAG,IAAI,CAQf"}

package/dist/systems/roof/roof-elevation.js

@@ -1,48 +1,52 @@
-import { getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, } from '../../hooks/spatial-grid/spatial-grid-manager.js';
-import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync.js';
-import { findLevelBelowId, getLevelElevations } from '../../services/storey.js';
+import { resolveLevelId } from '../../lib/node-ancestry.js';
+import { wallSupportForNodes } from '../../lib/opening-floor-datum.js';
+import { coveredStoreyId, servesAsRoofLevel } from '../../services/roof-level.js';
+import { findLevelBelowId, getLevelElevations, getWallTop } from '../../services/storey.js';
 import { wallOverlapsSlabFootprint } from '../slab/slab-support.js';
 import { getWallArcData } from '../wall/wall-curve.js';
 import { resolveRoomRoofFootprintOnLevel } from './roof-footprint.js';
 export function resolveRoofWallTopElevation(targetLevelId, wall, nodes, elevations = getLevelElevations(nodes)) {
-    const sourceLevelY = elevations.get(resolveLevelId(wall, nodes))?.baseY ?? 0;
+    const sourceLevelId = resolveLevelId(wall, nodes);
+    const sourceLevelY = elevations.get(sourceLevelId)?.baseY ?? 0;
     const targetLevelY = elevations.get(targetLevelId)?.baseY ?? 0;
-    return (sourceLevelY +
-        getWallBaseElevationForNodes(wall, nodes) +
-        getWallEffectiveHeightForNodes(wall, nodes) -
-        targetLevelY);
+    const support = wallSupportForNodes(wall, nodes);
+    return sourceLevelY + getWallTop(wall, sourceLevelId, nodes, support.elevation) - targetLevelY;
 }
-export function resolveRoofElevation(roof, nodes) {
-    if (roof.support?.kind !== 'walls')
-        return roof.position[1];
-    const levelId = resolveLevelId(roof, nodes);
-    if (nodes[levelId]?.type !== 'level')
-        return roof.position[1];
-    const elevations = getLevelElevations(nodes);
-    // A roof usually sits on the storey above its walls, but the top floor (or a
-    // roof armed from the walls' own level) keeps roof and walls on one level.
-    const belowId = findLevelBelowId(levelId, elevations);
-    const candidateWallIds = [levelId, belowId]
-        .map((id) => (id ? nodes[id] : undefined))
-        .filter((node) => node?.type === 'level')
-        .flatMap((level) => level.children);
-    const conicalSegments = roof.children
+/**
+ * The walls among `wallIds` a roof stands on: those under its segments' footprints, closed room or
+ * not (a room missing a wall, an L-shaped room whose centre falls outside, or a redrawn enclosure
+ * all still hold the roof up); a cone's, its round wall. Null for a roof with no segments yet.
+ */
+function wallsUnderRoof(roof, nodes, wallIds) {
+    const segments = roof.children
         .map((id) => nodes[id])
-        .filter((node) => node?.type === 'roof-segment' && node.roofType === 'conical');
+        .filter((node) => node?.type === 'roof-segment');
+    if (segments.length === 0)
+        return null;
     const cos = Math.cos(roof.rotation);
     const sin = Math.sin(roof.rotation);
     const toLevel = (x, z) => [
         roof.position[0] + x * cos + z * sin,
         roof.position[2] - x * sin + z * cos,
     ];
-    // Walls under the footprint, closed room or not: a room missing a wall, an
-    // L-shaped room whose centre falls outside, or a redrawn enclosure all still
-    // hold the roof up. The band test is curve- and thickness-aware and
-    // boundary-inclusive, so perimeter walls on the footprint edge count.
-    const footprints = roof.children
-        .map((id) => nodes[id])
-        .filter((node) => node?.type === 'roof-segment')
-        .map((segment) => {
+    const conicalSegments = segments.filter((segment) => segment.roofType === 'conical');
+    if (conicalSegments.length)
+        return wallIds.filter((id) => {
+            const wall = nodes[id];
+            if (wall?.type !== 'wall')
+                return false;
+            const arc = getWallArcData(wall);
+            if (!arc)
+                return false;
+            return conicalSegments.some((segment) => {
+                const [centerX, centerZ] = toLevel(segment.position[0], segment.position[2]);
+                return (Math.hypot(arc.center.x - centerX, arc.center.y - centerZ) <= 1e-4 &&
+                    Math.abs(arc.radius - segment.width / 2) <= 1e-4);
+            });
+        });
+    // The band test is curve- and thickness-aware and boundary-inclusive, so perimeter walls on the
+    // footprint edge count.
+    const footprints = segments.map((segment) => {
         const c = Math.cos(segment.rotation);
         const s = Math.sin(segment.rotation);
         const halfW = segment.width / 2;
@@ -55,41 +59,66 @@ export function resolveRoofElevation(roof, nodes) {
         ];
         return corners.map(([x, z]) => toLevel(segment.position[0] + x * c + z * s, segment.position[2] - x * s + z * c));
     });
-    const wallIds = conicalSegments.length
-        ? candidateWallIds.filter((id) => {
-            const wall = nodes[id];
-            if (wall?.type !== 'wall')
-                return false;
-            const arc = getWallArcData(wall);
-            if (!arc)
-                return false;
-            return conicalSegments.some((segment) => {
-                const [centerX, centerZ] = toLevel(segment.position[0], segment.position[2]);
-                return (Math.hypot(arc.center.x - centerX, arc.center.y - centerZ) <= 1e-4 &&
-                    Math.abs(arc.radius - segment.width / 2) <= 1e-4);
-            });
-        })
-        : footprints.length
-            ? candidateWallIds.filter((id) => {
-                const wall = nodes[id];
-                return (wall?.type === 'wall' &&
-                    footprints.some((polygon) => wallOverlapsSlabFootprint(wall, polygon)));
-            })
-            : ([levelId, belowId]
-                .map((id) => id
-                ? resolveRoomRoofFootprintOnLevel(id, nodes, [
-                    roof.position[0],
-                    roof.position[2],
-                ])
-                : null)
-                .find((target) => target !== null)?.wallIds ?? []);
+    return wallIds.filter((id) => {
+        const wall = nodes[id];
+        return (wall?.type === 'wall' &&
+            footprints.some((polygon) => wallOverlapsSlabFootprint(wall, polygon)));
+    });
+}
+/** The tallest of these walls' tops, from `targetLevelId`'s floor; undefined for none. */
+function highestWallTop(targetLevelId, wallIds, nodes, elevations) {
     let highest;
     for (const id of wallIds) {
         const wall = nodes[id];
         if (wall?.type !== 'wall')
             continue;
-        const top = resolveRoofWallTopElevation(levelId, wall, nodes, elevations);
+        const top = resolveRoofWallTopElevation(targetLevelId, wall, nodes, elevations);
         highest = highest === undefined ? top : Math.max(highest, top);
     }
-    return highest ?? roof.position[1];
+    return highest;
+}
+export function resolveRoofElevation(roof, nodes) {
+    if (roof.support?.kind !== 'walls')
+        return roof.position[1];
+    const levelId = resolveLevelId(roof, nodes);
+    if (nodes[levelId]?.type !== 'level')
+        return roof.position[1];
+    const elevations = getLevelElevations(nodes);
+    // A roof usually sits on the storey above its walls, but the top floor (or a
+    // roof armed from the walls' own level) keeps roof and walls on one level.
+    const belowId = findLevelBelowId(levelId, elevations);
+    // A lower wing's roof on the storey above stands on the walls below only: that storey's own
+    // walls along the wing's edge would lift it to their tops.
+    const level = nodes[levelId];
+    const supportLevelIds = belowId && !servesAsRoofLevel(nodes, level) && coveredStoreyId(nodes, roof) === belowId
+        ? [belowId]
+        : [levelId, belowId];
+    const candidateWallIds = supportLevelIds
+        .map((id) => (id ? nodes[id] : undefined))
+        .filter((node) => node?.type === 'level')
+        .flatMap((level) => level.children);
+    const wallIds = wallsUnderRoof(roof, nodes, candidateWallIds) ??
+        supportLevelIds
+            .map((id) => id
+            ? resolveRoomRoofFootprintOnLevel(id, nodes, [
+                roof.position[0],
+                roof.position[2],
+            ])
+            : null)
+            .find((target) => target !== null)?.wallIds ??
+        [];
+    return highestWallTop(levelId, wallIds, nodes, elevations) ?? roof.position[1];
+}
+/**
+ * The tallest top of `levelId`'s walls a roof stands on, from the floor of the level holding the
+ * roof (m); null when it stands on none of them, or has no segments to stand with.
+ */
+export function roofWallTop(roof, nodes, levelId) {
+    const level = nodes[levelId];
+    if (level?.type !== 'level')
+        return null;
+    const wallIds = wallsUnderRoof(roof, nodes, level.children);
+    if (!wallIds)
+        return null;
+    return (highestWallTop(resolveLevelId(roof, nodes), wallIds, nodes, getLevelElevations(nodes)) ?? null);
 }

package/dist/systems/slab/__fixtures__/doorway-steps.d.ts

@@ -0,0 +1,8 @@
+import { type AnyNode } from '../../../schema/index.js';
+/**
+ * Three rooms in a row, A | B | C, a door in each dividing wall. B is raised,
+ * so it owns a step at each door: one toward A, one toward C. `open` divides B
+ * from C with a separator instead of a wall and door.
+ */
+export declare function doorwayStepsFixture(elevations?: [number, number, number], open?: boolean): Record<string, AnyNode>;
+//# sourceMappingURL=doorway-steps.d.ts.map

package/dist/systems/slab/__fixtures__/doorway-steps.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"doorway-steps.d.ts","sourceRoot":"","sources":["../../../../src/systems/slab/__fixtures__/doorway-steps.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAMb,MAAM,iBAAiB,CAAA;AAGxB;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,UAAU,GAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAqB,EACxD,IAAI,UAAQ,GAgE+C,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CACnF"}