@pascal-app/core 0.8.0 → 0.9.1

package/dist/systems/elevator/elevator-runtime.js

@@ -0,0 +1,225 @@
+import { useInteractive } from '../../store/use-interactive';
+import useScene from '../../store/use-scene';
+import { resolveElevatorLevels } from './elevator-service';
+const EPSILON = 0.001;
+function moveToward(current, target, maxDelta) {
+    const delta = target - current;
+    if (Math.abs(delta) <= maxDelta)
+        return target;
+    return current + Math.sign(delta) * maxDelta;
+}
+export function createElevatorInteractiveState(levelId, carY) {
+    return {
+        currentLevelId: levelId,
+        targetLevelId: null,
+        carY,
+        doorOpen: 0,
+        phase: 'idle',
+        phaseStartedAt: null,
+        queue: [],
+        requestedStops: [],
+    };
+}
+function getInitialElevatorState(elevatorId, nodes) {
+    const node = nodes[elevatorId];
+    if (node?.type !== 'elevator')
+        return null;
+    const { defaultEntry } = resolveElevatorLevels(node, nodes);
+    if (!defaultEntry)
+        return null;
+    return createElevatorInteractiveState(defaultEntry.id, defaultEntry.baseY);
+}
+function ensureElevatorState(elevatorId, nodes) {
+    const interactive = useInteractive.getState();
+    const existing = interactive.elevators[elevatorId];
+    if (existing)
+        return existing;
+    const initial = getInitialElevatorState(elevatorId, nodes);
+    if (!initial)
+        return null;
+    interactive.initElevator(elevatorId, initial.currentLevelId, initial.carY);
+    return initial;
+}
+export function queueElevatorRequest(state, levelId) {
+    const isAlreadyQueued = state.queue.includes(levelId) || state.targetLevelId === levelId;
+    if (isAlreadyQueued)
+        return state;
+    return {
+        ...state,
+        queue: [...state.queue, levelId],
+        requestedStops: state.requestedStops.includes(levelId)
+            ? state.requestedStops
+            : [...state.requestedStops, levelId],
+    };
+}
+export function openElevatorDoorState(state) {
+    if (!state.currentLevelId || state.phase === 'moving')
+        return state;
+    return {
+        ...state,
+        phase: 'opening',
+        phaseStartedAt: null,
+    };
+}
+export function requestElevatorLevel(elevatorId, levelId) {
+    const nodes = useScene.getState().nodes;
+    const current = ensureElevatorState(elevatorId, nodes);
+    if (!current)
+        return;
+    const next = queueElevatorRequest(current, levelId);
+    if (next === current)
+        return;
+    useInteractive.getState().setElevatorState(elevatorId, next);
+}
+export function openElevatorDoor(elevatorId) {
+    const nodes = useScene.getState().nodes;
+    const current = ensureElevatorState(elevatorId, nodes);
+    if (!current)
+        return;
+    const next = openElevatorDoorState(current);
+    if (next === current)
+        return;
+    useInteractive.getState().setElevatorState(elevatorId, next);
+}
+export function stepElevatorRuntimeState({ defaultEntry, delta, elevator, entries, now, state, }) {
+    const currentEntry = entries.find((entry) => entry.id === state.currentLevelId) ?? defaultEntry;
+    if (currentEntry.id !== state.currentLevelId) {
+        return {
+            ...state,
+            currentLevelId: currentEntry.id,
+            carY: currentEntry.baseY,
+            targetLevelId: null,
+            phase: 'idle',
+            phaseStartedAt: null,
+            queue: [],
+            requestedStops: [],
+            doorOpen: 0,
+        };
+    }
+    const targetEntry = state.targetLevelId
+        ? entries.find((entry) => entry.id === state.targetLevelId)
+        : state.queue[0]
+            ? entries.find((entry) => entry.id === state.queue[0])
+            : null;
+    const doorDurationMs = Math.max(elevator.doorDurationMs ?? 900, 1);
+    const doorStep = (delta * 1000) / doorDurationMs;
+    switch (state.phase) {
+        case 'idle': {
+            const nextLevelId = state.queue[0] ?? null;
+            if (!nextLevelId) {
+                if (state.doorOpen > EPSILON) {
+                    return {
+                        ...state,
+                        doorOpen: Math.max(0, state.doorOpen - doorStep),
+                    };
+                }
+                if (state.requestedStops.length === 0)
+                    return state;
+                return {
+                    ...state,
+                    requestedStops: [],
+                };
+            }
+            return {
+                ...state,
+                targetLevelId: nextLevelId,
+                phase: state.doorOpen > EPSILON
+                    ? 'closing'
+                    : nextLevelId === state.currentLevelId
+                        ? 'opening'
+                        : 'moving',
+                phaseStartedAt: now,
+            };
+        }
+        case 'closing': {
+            const doorOpen = Math.max(0, state.doorOpen - doorStep);
+            return {
+                ...state,
+                doorOpen,
+                phase: doorOpen <= EPSILON ? (state.targetLevelId ? 'moving' : 'idle') : 'closing',
+                phaseStartedAt: doorOpen <= EPSILON ? now : state.phaseStartedAt,
+            };
+        }
+        case 'moving': {
+            if (!targetEntry) {
+                return {
+                    ...state,
+                    targetLevelId: null,
+                    phase: 'idle',
+                    queue: [],
+                    requestedStops: [],
+                };
+            }
+            const speed = Math.max(elevator.speed ?? 2.2, 0.1);
+            const nextY = moveToward(state.carY, targetEntry.baseY, speed * delta);
+            const arrived = Math.abs(nextY - targetEntry.baseY) <= EPSILON;
+            return {
+                ...state,
+                carY: nextY,
+                currentLevelId: arrived ? targetEntry.id : state.currentLevelId,
+                phase: arrived ? 'opening' : 'moving',
+                phaseStartedAt: arrived ? now : state.phaseStartedAt,
+            };
+        }
+        case 'opening': {
+            const doorOpen = Math.min(1, state.doorOpen + doorStep);
+            return {
+                ...state,
+                doorOpen,
+                phase: doorOpen >= 1 - EPSILON ? 'open' : 'opening',
+                phaseStartedAt: doorOpen >= 1 - EPSILON ? now : state.phaseStartedAt,
+                targetLevelId: doorOpen >= 1 - EPSILON ? null : state.targetLevelId,
+                queue: doorOpen >= 1 - EPSILON && state.queue[0] === state.currentLevelId
+                    ? state.queue.slice(1)
+                    : state.queue,
+            };
+        }
+        case 'open': {
+            const elapsed = now - (state.phaseStartedAt ?? now);
+            if (elapsed < Math.max(elevator.dwellMs ?? 1400, 0))
+                return state;
+            return {
+                ...state,
+                phase: 'closing',
+                phaseStartedAt: now,
+                targetLevelId: state.queue[0] ?? null,
+            };
+        }
+    }
+}
+export function stepElevatorRuntimes(now, delta) {
+    const nodes = useScene.getState().nodes;
+    const interactive = useInteractive.getState();
+    for (const elevatorId of Object.keys(interactive.elevators)) {
+        const typedElevatorId = elevatorId;
+        if (nodes[typedElevatorId]?.type !== 'elevator') {
+            interactive.removeElevator(typedElevatorId);
+        }
+    }
+    for (const node of Object.values(nodes)) {
+        if (node.type !== 'elevator')
+            continue;
+        const elevatorId = node.id;
+        const { entries, defaultEntry } = resolveElevatorLevels(node, nodes);
+        if (!defaultEntry)
+            continue;
+        const state = useInteractive.getState().elevators[elevatorId];
+        if (!state) {
+            useInteractive
+                .getState()
+                .initElevator(elevatorId, defaultEntry.id, defaultEntry.baseY);
+            continue;
+        }
+        const next = stepElevatorRuntimeState({
+            defaultEntry,
+            delta,
+            elevator: node,
+            entries,
+            now,
+            state,
+        });
+        if (next !== state) {
+            useInteractive.getState().setElevatorState(elevatorId, next);
+        }
+    }
+}

package/dist/systems/elevator/elevator-runtime.test.d.ts

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

package/dist/systems/elevator/elevator-runtime.test.d.ts.map

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

package/dist/systems/elevator/elevator-runtime.test.js

@@ -0,0 +1,64 @@
+import { describe, expect, test } from 'bun:test';
+import { ElevatorNode } from '../../schema';
+import { createElevatorInteractiveState, openElevatorDoorState, queueElevatorRequest, stepElevatorRuntimeState, } from './elevator-runtime';
+const groundLevelId = 'level_ground';
+const upperLevelId = 'level_upper';
+const entries = [
+    { id: groundLevelId, label: '0', baseY: 0 },
+    { id: upperLevelId, label: '1', baseY: 2.5 },
+];
+const elevator = ElevatorNode.parse({
+    speed: 10,
+    doorDurationMs: 100,
+    dwellMs: 0,
+});
+describe('elevator runtime helpers', () => {
+    test('queues level requests without duplicating the target', () => {
+        const state = createElevatorInteractiveState(groundLevelId, 0);
+        const queued = queueElevatorRequest(state, upperLevelId);
+        const duplicated = queueElevatorRequest(queued, upperLevelId);
+        expect(queued.queue).toEqual([upperLevelId]);
+        expect(queued.requestedStops).toEqual([upperLevelId]);
+        expect(duplicated.queue).toEqual([upperLevelId]);
+        expect(duplicated.requestedStops).toEqual([upperLevelId]);
+    });
+    test('opens doors only when the elevator is not moving', () => {
+        const idle = createElevatorInteractiveState(groundLevelId, 0);
+        const moving = { ...idle, phase: 'moving' };
+        expect(openElevatorDoorState(idle).phase).toBe('opening');
+        expect(openElevatorDoorState(moving)).toBe(moving);
+    });
+    test('moves to a queued level and clears the served request on arrival', () => {
+        const queued = queueElevatorRequest(createElevatorInteractiveState(groundLevelId, 0), upperLevelId);
+        const moving = stepElevatorRuntimeState({
+            defaultEntry: entries[0],
+            delta: 0.016,
+            elevator,
+            entries,
+            now: 0,
+            state: queued,
+        });
+        const arrived = stepElevatorRuntimeState({
+            defaultEntry: entries[0],
+            delta: 1,
+            elevator,
+            entries,
+            now: 100,
+            state: moving,
+        });
+        const open = stepElevatorRuntimeState({
+            defaultEntry: entries[0],
+            delta: 1,
+            elevator,
+            entries,
+            now: 200,
+            state: arrived,
+        });
+        expect(moving.phase).toBe('moving');
+        expect(arrived.currentLevelId).toBe(upperLevelId);
+        expect(arrived.phase).toBe('opening');
+        expect(open.phase).toBe('open');
+        expect(open.queue).toEqual([]);
+        expect(open.requestedStops).toEqual([upperLevelId]);
+    });
+});

package/dist/systems/elevator/elevator-service.d.ts

@@ -0,0 +1,19 @@
+import type { AnyNode, ElevatorNode, LevelNode } from '../../schema';
+export declare const DEFAULT_ELEVATOR_LEVEL_HEIGHT = 2.5;
+export type ElevatorLevelEntry = {
+    id: LevelNode['id'];
+    label: string;
+    baseY: number;
+};
+export declare function resolveElevatorBuildingLevels(elevator: ElevatorNode, nodes: Record<string, AnyNode>): LevelNode[];
+export declare function resolveElevatorServiceLevelIds(elevator: ElevatorNode, nodes: Record<string, AnyNode>): string[];
+export declare function resolveElevatorServiceLevels(elevator: ElevatorNode, nodes: Record<string, AnyNode>): LevelNode[];
+export declare function getElevatorLevelHeight(levelId: string, nodes: Record<string, AnyNode>): number;
+export declare function resolveElevatorLevels(elevator: ElevatorNode, nodes: Record<string, AnyNode>): {
+    entries: ElevatorLevelEntry[];
+    defaultEntry: ElevatorLevelEntry | null;
+    shaftBaseY: number;
+    shaftTopY: number;
+    totalHeight: number;
+};
+//# sourceMappingURL=elevator-service.d.ts.map

package/dist/systems/elevator/elevator-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elevator-service.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EAGP,YAAY,EACZ,SAAS,EAEV,MAAM,cAAc,CAAA;AAErB,eAAO,MAAM,6BAA6B,MAAM,CAAA;AAEhD,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AA2BD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAEb;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,EAAE,CAEV;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAsBb;AAED,wBAAgB,sBAAsB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAoB9F;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,YAAY,EAAE,kBAAkB,GAAG,IAAI,CAAA;IACvC,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB,CA0CA"}

package/dist/systems/elevator/elevator-service.js

@@ -0,0 +1,111 @@
+export const DEFAULT_ELEVATOR_LEVEL_HEIGHT = 2.5;
+function getBuildingLevels(elevator, nodes) {
+    const building = elevator.parentId && nodes[elevator.parentId]?.type === 'building'
+        ? nodes[elevator.parentId]
+        : null;
+    if (building?.type !== 'building')
+        return [];
+    return building.children
+        .map((childId) => nodes[childId])
+        .filter((node) => node?.type === 'level')
+        .sort((left, right) => left.level - right.level);
+}
+function findLevelIndex(levels, levelId) {
+    if (!levelId)
+        return -1;
+    return levels.findIndex((level) => level.id === levelId);
+}
+function getDefaultToIndex(levels, fromIndex) {
+    if (levels.length === 0)
+        return -1;
+    if (fromIndex < 0)
+        return Math.min(1, levels.length - 1);
+    return Math.min(fromIndex + 1, levels.length - 1);
+}
+export function resolveElevatorBuildingLevels(elevator, nodes) {
+    return getBuildingLevels(elevator, nodes);
+}
+export function resolveElevatorServiceLevelIds(elevator, nodes) {
+    return resolveElevatorServiceLevels(elevator, nodes).map((level) => level.id);
+}
+export function resolveElevatorServiceLevels(elevator, nodes) {
+    const levels = getBuildingLevels(elevator, nodes);
+    if (levels.length === 0)
+        return [];
+    const hasServiceBounds = Boolean(elevator.fromLevelId || elevator.toLevelId);
+    let legacyServedLevels = [];
+    if (!hasServiceBounds && elevator.servedLevelIds && elevator.servedLevelIds.length > 0) {
+        const servedIds = new Set(elevator.servedLevelIds);
+        legacyServedLevels = levels.filter((level) => servedIds.has(level.id));
+    }
+    const legacyFromLevelId = legacyServedLevels[0]?.id ?? null;
+    const legacyToLevelId = legacyServedLevels[legacyServedLevels.length - 1]?.id ?? null;
+    const explicitFromIndex = findLevelIndex(levels, elevator.fromLevelId ?? legacyFromLevelId);
+    const defaultFromIndex = findLevelIndex(levels, elevator.defaultLevelId);
+    const fromIndex = explicitFromIndex >= 0 ? explicitFromIndex : Math.max(defaultFromIndex, 0);
+    const toIndex = findLevelIndex(levels, elevator.toLevelId ?? legacyToLevelId);
+    const resolvedToIndex = toIndex >= 0 ? toIndex : getDefaultToIndex(levels, fromIndex);
+    const minIndex = Math.min(fromIndex, resolvedToIndex);
+    const maxIndex = Math.max(fromIndex, resolvedToIndex);
+    return levels.slice(minIndex, maxIndex + 1);
+}
+export function getElevatorLevelHeight(levelId, nodes) {
+    const level = nodes[levelId];
+    if (!level || level.type !== 'level')
+        return DEFAULT_ELEVATOR_LEVEL_HEIGHT;
+    let maxTop = 0;
+    for (const childId of level.children) {
+        const child = nodes[childId];
+        if (!child)
+            continue;
+        if (child.type === 'ceiling') {
+            const height = child.height ?? DEFAULT_ELEVATOR_LEVEL_HEIGHT;
+            if (height > maxTop)
+                maxTop = height;
+        }
+        else if (child.type === 'wall') {
+            const height = child.height ?? DEFAULT_ELEVATOR_LEVEL_HEIGHT;
+            if (height > maxTop)
+                maxTop = height;
+        }
+    }
+    return maxTop > 0 ? maxTop : DEFAULT_ELEVATOR_LEVEL_HEIGHT;
+}
+export function resolveElevatorLevels(elevator, nodes) {
+    const allLevels = resolveElevatorBuildingLevels(elevator, nodes);
+    const baseYByLevelId = new Map();
+    let cumulativeY = 0;
+    for (const level of allLevels) {
+        baseYByLevelId.set(level.id, cumulativeY);
+        cumulativeY += getElevatorLevelHeight(level.id, nodes);
+    }
+    const serviceLevels = resolveElevatorServiceLevels(elevator, nodes);
+    const entries = serviceLevels.map((level) => ({
+        id: level.id,
+        label: String(level.level),
+        baseY: baseYByLevelId.get(level.id) ?? 0,
+    }));
+    const defaultEntry = entries.find((entry) => entry.id === elevator.defaultLevelId) ??
+        entries.find((entry) => entry.id === elevator.fromLevelId) ??
+        entries[0] ??
+        null;
+    const firstServedLevel = serviceLevels[0] ?? null;
+    const lastServedLevel = serviceLevels[serviceLevels.length - 1] ?? null;
+    const shaftBaseY = firstServedLevel ? (baseYByLevelId.get(firstServedLevel.id) ?? 0) : 0;
+    const lastServedIndex = lastServedLevel
+        ? allLevels.findIndex((level) => level.id === lastServedLevel.id)
+        : -1;
+    const nextLevel = lastServedIndex >= 0 ? allLevels[lastServedIndex + 1] : null;
+    const shaftTopY = nextLevel
+        ? (baseYByLevelId.get(nextLevel.id) ?? cumulativeY)
+        : lastServedLevel
+            ? cumulativeY
+            : elevator.cabHeight + 0.3;
+    return {
+        entries,
+        defaultEntry,
+        shaftBaseY,
+        shaftTopY,
+        totalHeight: Math.max(shaftTopY - shaftBaseY, elevator.cabHeight + 0.3),
+    };
+}

package/dist/systems/stair/stair-footprint.d.ts

@@ -0,0 +1,44 @@
+import type { AnyNode, StairNode, StairSegmentNode } from '../../schema';
+/**
+ * Stair footprint geometry shared by the slab-opening sync and the
+ * alignment-anchor adapters. A stair has no single box footprint: straight
+ * stairs are a cumulative chain of `stair-segment` children, curved / spiral
+ * stairs are an annular sector stored entirely on the parent. Both reduce to
+ * an XZ bounding box here so callers that only need "where does the stair sit
+ * in plan" (alignment guides) don't have to re-walk the geometry.
+ *
+ * All math is in the building-local XZ frame, matching `node.position`.
+ */
+export type StairFootprintAABB = {
+    minX: number;
+    minZ: number;
+    maxX: number;
+    maxZ: number;
+};
+type SegmentTransform = {
+    position: [number, number, number];
+    rotation: number;
+};
+/**
+ * XZ rotation in the stair geometry convention (equivalent to rotating by
+ * `-angle` in standard math): positive `angle` turns local +Z toward +X. Every
+ * stair helper — slab openings, floor-plan emitter, this footprint — shares it,
+ * so anchors line up with the rendered stair.
+ */
+export declare function rotateXZ(x: number, z: number, angle: number): [number, number];
+/**
+ * Cumulative per-segment transforms for a straight (segment-chained) stair.
+ * Each flight attaches to the previous segment's end; `attachmentSide` rotates
+ * the chain ±90° (left / right) or continues straight (front). Positions are in
+ * the stair's local frame (before the stair's own `position` / `rotation`).
+ */
+export declare function computeSegmentTransforms(segments: StairSegmentNode[]): SegmentTransform[];
+/**
+ * XZ bounding box of a stair's plan footprint, or null when it can't be
+ * determined (a straight stair whose segment children aren't in `nodes`).
+ * Straight stairs need the children to walk the flight chain; curved / spiral
+ * stairs are derived from the parent alone, so `nodes` is optional for them.
+ */
+export declare function stairFootprintAABB(stair: StairNode, nodes?: Readonly<Record<string, AnyNode>>): StairFootprintAABB | null;
+export {};
+//# sourceMappingURL=stair-footprint.d.ts.map

package/dist/systems/stair/stair-footprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stair-footprint.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-footprint.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAa,SAAS,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAEnF;;;;;;;;;GASG;AAEH,MAAM,MAAM,kBAAkB,GAAG;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CAAA;AAE3F,KAAK,gBAAgB,GAAG;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,QAAQ,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAI9E;AAED;;;;;GAKG;AACH,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,gBAAgB,EAAE,GAAG,gBAAgB,EAAE,CAkDzF;AA0GD;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,KAAK,EAAE,SAAS,EAChB,KAAK,CAAC,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACxC,kBAAkB,GAAG,IAAI,CAK3B"}

package/dist/systems/stair/stair-footprint.js

@@ -0,0 +1,168 @@
+/**
+ * XZ rotation in the stair geometry convention (equivalent to rotating by
+ * `-angle` in standard math): positive `angle` turns local +Z toward +X. Every
+ * stair helper — slab openings, floor-plan emitter, this footprint — shares it,
+ * so anchors line up with the rendered stair.
+ */
+export function rotateXZ(x, z, angle) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return [x * cos + z * sin, -x * sin + z * cos];
+}
+/**
+ * Cumulative per-segment transforms for a straight (segment-chained) stair.
+ * Each flight attaches to the previous segment's end; `attachmentSide` rotates
+ * the chain ±90° (left / right) or continues straight (front). Positions are in
+ * the stair's local frame (before the stair's own `position` / `rotation`).
+ */
+export function computeSegmentTransforms(segments) {
+    const transforms = [];
+    let currentX = 0;
+    let currentY = 0;
+    let currentZ = 0;
+    let currentRot = 0;
+    for (let index = 0; index < segments.length; index++) {
+        const segment = segments[index];
+        if (!segment)
+            continue;
+        if (index === 0) {
+            transforms.push({ position: [currentX, currentY, currentZ], rotation: currentRot });
+            continue;
+        }
+        const previous = segments[index - 1];
+        if (!previous)
+            continue;
+        let attachX = 0;
+        let attachZ = 0;
+        let rotationDelta = 0;
+        switch (segment.attachmentSide) {
+            case 'front':
+                attachX = 0;
+                attachZ = previous.length;
+                break;
+            case 'left':
+                attachX = previous.width / 2;
+                attachZ = previous.length / 2;
+                rotationDelta = Math.PI / 2;
+                break;
+            case 'right':
+                attachX = -previous.width / 2;
+                attachZ = previous.length / 2;
+                rotationDelta = -Math.PI / 2;
+                break;
+        }
+        const [deltaX, deltaZ] = rotateXZ(attachX, attachZ, currentRot);
+        currentX += deltaX;
+        currentY += previous.height;
+        currentZ += deltaZ;
+        currentRot += rotationDelta;
+        transforms.push({ position: [currentX, currentY, currentZ], rotation: currentRot });
+    }
+    return transforms;
+}
+function emptyBox() {
+    return {
+        minX: Number.POSITIVE_INFINITY,
+        minZ: Number.POSITIVE_INFINITY,
+        maxX: Number.NEGATIVE_INFINITY,
+        maxZ: Number.NEGATIVE_INFINITY,
+    };
+}
+/** Grow `box` to include the world-plan point produced by rotating the
+ *  stair-local point by the stair's rotation and offsetting by its position. */
+function extendByLocal(box, stair, localX, localZ) {
+    const [wx, wz] = rotateXZ(localX, localZ, stair.rotation ?? 0);
+    const x = stair.position[0] + wx;
+    const z = stair.position[2] + wz;
+    if (x < box.minX)
+        box.minX = x;
+    if (x > box.maxX)
+        box.maxX = x;
+    if (z < box.minZ)
+        box.minZ = z;
+    if (z > box.maxZ)
+        box.maxZ = z;
+}
+function finiteBox(box) {
+    return Number.isFinite(box.minX) && Number.isFinite(box.minZ) ? box : null;
+}
+/** Bounding box of a straight stair's segment chain, walking the children. */
+function straightStairAABB(stair, nodes) {
+    const segments = (stair.children ?? [])
+        .map((childId) => nodes[childId])
+        .filter((segment) => segment?.type === 'stair-segment' && segment.visible !== false);
+    if (segments.length === 0)
+        return null;
+    const transforms = computeSegmentTransforms(segments);
+    const box = emptyBox();
+    segments.forEach((segment, index) => {
+        const transform = transforms[index];
+        if (!transform)
+            return;
+        const halfWidth = segment.width / 2;
+        // Segment-local footprint: X across the flight, Z along the run from the
+        // attachment edge (0) to the far edge (length).
+        for (const [cornerX, cornerZ] of [
+            [-halfWidth, 0],
+            [halfWidth, 0],
+            [halfWidth, segment.length],
+            [-halfWidth, segment.length],
+        ]) {
+            const [offsetX, offsetZ] = rotateXZ(cornerX, cornerZ, transform.rotation);
+            extendByLocal(box, stair, transform.position[0] + offsetX, transform.position[2] + offsetZ);
+        }
+    });
+    return finiteBox(box);
+}
+const ARC_SAMPLES = 48;
+/** Bounding box of a curved / spiral stair's annular sector (plus the
+ *  integrated spiral top landing when present). */
+function arcStairAABB(stair) {
+    const isSpiral = stair.stairType === 'spiral';
+    const minInnerRadius = isSpiral ? 0.05 : 0.2;
+    const innerRadius = Math.max(minInnerRadius, stair.innerRadius ?? (isSpiral ? 0.2 : 0.9));
+    const width = Math.max(stair.width ?? 1, 0.4);
+    const outerRadius = innerRadius + width;
+    let sweep = stair.sweepAngle ?? (isSpiral ? Math.PI * 2 : Math.PI / 2);
+    // A full revolution would make the arc degenerate; clamp just under 2π the
+    // same way the floor-plan emitter does so the sampled box stays correct.
+    if (Math.abs(sweep) >= Math.PI * 2)
+        sweep = Math.sign(sweep || 1) * (Math.PI * 2 - 0.001);
+    const half = sweep / 2;
+    const box = emptyBox();
+    // Sample both rims across the sweep — the extremes can fall on either the
+    // arc ends or an axis crossing in between, so we need the full sweep.
+    for (let step = 0; step <= ARC_SAMPLES; step += 1) {
+        const angle = -half + (sweep * step) / ARC_SAMPLES;
+        const cos = Math.cos(angle);
+        const sin = Math.sin(angle);
+        extendByLocal(box, stair, cos * innerRadius, sin * innerRadius);
+        extendByLocal(box, stair, cos * outerRadius, sin * outerRadius);
+    }
+    // Integrated spiral top landing — a rectangle hung off the outer rim.
+    if (isSpiral && stair.topLandingMode === 'integrated') {
+        const depth = Math.max(stair.topLandingDepth ?? 0.9, 0.1);
+        const halfWidth = width / 2;
+        for (const [cornerX, cornerZ] of [
+            [outerRadius, -halfWidth],
+            [outerRadius + depth, -halfWidth],
+            [outerRadius + depth, halfWidth],
+            [outerRadius, halfWidth],
+        ]) {
+            extendByLocal(box, stair, cornerX, cornerZ);
+        }
+    }
+    return finiteBox(box);
+}
+/**
+ * XZ bounding box of a stair's plan footprint, or null when it can't be
+ * determined (a straight stair whose segment children aren't in `nodes`).
+ * Straight stairs need the children to walk the flight chain; curved / spiral
+ * stairs are derived from the parent alone, so `nodes` is optional for them.
+ */
+export function stairFootprintAABB(stair, nodes) {
+    if ((stair.stairType ?? 'straight') === 'straight') {
+        return nodes ? straightStairAABB(stair, nodes) : null;
+    }
+    return arcStairAABB(stair);
+}