@pascal-app/core 0.8.0 → 0.9.2

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

@@ -0,0 +1,12 @@
+import type { AnyNode, AnyNodeId } from '../../schema';
+import type { ElevatorInteractiveState } from '../../store/use-interactive';
+type ElevatorRuntimeMap = Record<AnyNodeId, ElevatorInteractiveState>;
+type ResolveElevatorDispatchTargetArgs = {
+    elevators: ElevatorRuntimeMap;
+    levelId: AnyNodeId;
+    nodes: Record<string, AnyNode>;
+    requestedElevatorId: AnyNodeId;
+};
+export declare function resolveElevatorDispatchTarget({ elevators, levelId, nodes, requestedElevatorId, }: ResolveElevatorDispatchTargetArgs): AnyNodeId;
+export {};
+//# sourceMappingURL=elevator-dispatch.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"elevator-dispatch.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-dispatch.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAgB,MAAM,cAAc,CAAA;AACpE,OAAO,KAAK,EAAE,wBAAwB,EAAE,MAAM,6BAA6B,CAAA;AAG3E,KAAK,kBAAkB,GAAG,MAAM,CAAC,SAAS,EAAE,wBAAwB,CAAC,CAAA;AAErE,KAAK,iCAAiC,GAAG;IACvC,SAAS,EAAE,kBAAkB,CAAA;IAC7B,OAAO,EAAE,SAAS,CAAA;IAClB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,mBAAmB,EAAE,SAAS,CAAA;CAC/B,CAAA;AAsCD,wBAAgB,6BAA6B,CAAC,EAC5C,SAAS,EACT,OAAO,EACP,KAAK,EACL,mBAAmB,GACpB,EAAE,iCAAiC,GAAG,SAAS,CAmC/C"}

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

@@ -0,0 +1,57 @@
+import { resolveElevatorServiceLevels } from './elevator-service';
+function getRuntimeLevelId(runtime, elevator) {
+    return runtime?.currentLevelId ?? elevator.defaultLevelId ?? elevator.fromLevelId ?? null;
+}
+function scoreDispatchCandidate({ elevator, elevators, levelId, nodes, }) {
+    if ((elevator.disabledLevelIds ?? []).includes(levelId))
+        return null;
+    if ((elevator.serviceOnlyLevelIds ?? []).includes(levelId))
+        return null;
+    const serviceLevels = resolveElevatorServiceLevels(elevator, nodes);
+    const targetIndex = serviceLevels.findIndex((level) => level.id === levelId);
+    if (targetIndex < 0)
+        return null;
+    const runtime = elevators[elevator.id];
+    const runtimeLevelId = getRuntimeLevelId(runtime, elevator);
+    const currentIndex = runtimeLevelId
+        ? serviceLevels.findIndex((level) => level.id === runtimeLevelId)
+        : -1;
+    const resolvedCurrentIndex = currentIndex >= 0 ? currentIndex : 0;
+    const distance = Math.abs(targetIndex - resolvedCurrentIndex);
+    const queuePenalty = (runtime?.queue.length ?? 0) * 2 + (runtime?.targetLevelId ? 1 : 0);
+    const motionPenalty = runtime?.phase === 'moving' || runtime?.phase === 'closing' ? 0.5 : 0;
+    const openPenalty = runtime?.phase === 'open' || runtime?.phase === 'opening' ? 0.2 : 0;
+    return distance + queuePenalty + motionPenalty + openPenalty;
+}
+export function resolveElevatorDispatchTarget({ elevators, levelId, nodes, requestedElevatorId, }) {
+    const requestedElevator = nodes[requestedElevatorId];
+    if (!(requestedElevator?.type === 'elevator' && requestedElevator.parentId)) {
+        return requestedElevatorId;
+    }
+    const building = nodes[requestedElevator.parentId];
+    if (building?.type !== 'building') {
+        return requestedElevatorId;
+    }
+    let bestElevatorId = null;
+    let bestScore = Number.POSITIVE_INFINITY;
+    for (const childId of building.children) {
+        const candidate = nodes[childId];
+        if (!(candidate?.type === 'elevator' && candidate.visible !== false))
+            continue;
+        const score = scoreDispatchCandidate({
+            elevator: candidate,
+            elevators,
+            levelId,
+            nodes,
+        });
+        if (score === null)
+            continue;
+        const tieBreaker = candidate.id === requestedElevatorId ? -0.01 : 0;
+        const finalScore = score + tieBreaker;
+        if (finalScore < bestScore) {
+            bestScore = finalScore;
+            bestElevatorId = candidate.id;
+        }
+    }
+    return bestElevatorId ?? requestedElevatorId;
+}

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

@@ -0,0 +1,15 @@
+import type { ElevatorDoorPanelStyle, ElevatorDoorStyle, ElevatorNode, ElevatorShaftStyle } from '../../schema';
+export type ElevatorDoorSide = 'left' | 'right';
+export declare function getResolvedElevatorDoorStyle(doorStyle: ElevatorNode['doorStyle'] | undefined): ElevatorDoorStyle;
+export declare function getResolvedElevatorDoorPanelStyle(doorPanelStyle: ElevatorNode['doorPanelStyle'] | undefined): ElevatorDoorPanelStyle;
+export declare function getResolvedElevatorShaftStyle(shaftStyle: ElevatorNode['shaftStyle'] | undefined): ElevatorShaftStyle;
+export declare function getElevatorDoorLeafSides(doorStyle: ElevatorNode['doorStyle'] | undefined): ElevatorDoorSide[];
+export declare function getElevatorDoorLeafX(side: ElevatorDoorSide, openingWidth: number, doorOpen: number, doorStyle: ElevatorNode['doorStyle'] | undefined): number;
+export declare function getElevatorDoorLeafWidth(openingWidth: number, doorStyle: ElevatorNode['doorStyle'] | undefined): number;
+export declare function getElevatorCabWidth(node: ElevatorNode): number;
+export declare function getElevatorCabDepth(node: ElevatorNode): number;
+export declare function getElevatorShaftWallThickness(node: ElevatorNode): number;
+export declare function getElevatorShaftWidth(node: ElevatorNode, cabWidth?: number): number;
+export declare function getElevatorShaftDepth(node: ElevatorNode, cabDepth?: number): number;
+export declare function getElevatorCabCenterZ(node: ElevatorNode): number;
+//# sourceMappingURL=elevator-geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"elevator-geometry.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,sBAAsB,EACtB,iBAAiB,EACjB,YAAY,EACZ,kBAAkB,EACnB,MAAM,cAAc,CAAA;AAErB,MAAM,MAAM,gBAAgB,GAAG,MAAM,GAAG,OAAO,CAAA;AAI/C,wBAAgB,4BAA4B,CAC1C,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS,GAC/C,iBAAiB,CAEnB;AAED,wBAAgB,iCAAiC,CAC/C,cAAc,EAAE,YAAY,CAAC,gBAAgB,CAAC,GAAG,SAAS,GACzD,sBAAsB,CAExB;AAED,wBAAgB,6BAA6B,CAC3C,UAAU,EAAE,YAAY,CAAC,YAAY,CAAC,GAAG,SAAS,GACjD,kBAAkB,CAEpB;AAED,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS,GAC/C,gBAAgB,EAAE,CAKpB;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,gBAAgB,EACtB,YAAY,EAAE,MAAM,EACpB,QAAQ,EAAE,MAAM,EAChB,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS,UAUjD;AAED,wBAAgB,wBAAwB,CACtC,YAAY,EAAE,MAAM,EACpB,SAAS,EAAE,YAAY,CAAC,WAAW,CAAC,GAAG,SAAS,UAKjD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,UAErD;AAED,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,YAAY,UAErD;AAED,wBAAgB,6BAA6B,CAAC,IAAI,EAAE,YAAY,UAE/D;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,SAA4B,UAE7F;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,EAAE,QAAQ,SAA4B,UAE7F;AAED,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,YAAY,UAEvD"}

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

@@ -0,0 +1,50 @@
+const DEFAULT_ELEVATOR_SHAFT_WALL_THICKNESS = 0.09;
+export function getResolvedElevatorDoorStyle(doorStyle) {
+    return doorStyle ?? 'center-opening';
+}
+export function getResolvedElevatorDoorPanelStyle(doorPanelStyle) {
+    return doorPanelStyle ?? 'glass-frame';
+}
+export function getResolvedElevatorShaftStyle(shaftStyle) {
+    return shaftStyle ?? 'solid';
+}
+export function getElevatorDoorLeafSides(doorStyle) {
+    const resolvedDoorStyle = getResolvedElevatorDoorStyle(doorStyle);
+    if (resolvedDoorStyle === 'single-left')
+        return ['left'];
+    if (resolvedDoorStyle === 'single-right')
+        return ['right'];
+    return ['left', 'right'];
+}
+export function getElevatorDoorLeafX(side, openingWidth, doorOpen, doorStyle) {
+    const resolvedDoorStyle = getResolvedElevatorDoorStyle(doorStyle);
+    if (resolvedDoorStyle === 'center-opening') {
+        const direction = side === 'left' ? -1 : 1;
+        return direction * (openingWidth / 4 + doorOpen * openingWidth * 0.34);
+    }
+    const direction = resolvedDoorStyle === 'single-left' ? -1 : 1;
+    return direction * doorOpen * openingWidth * 0.68;
+}
+export function getElevatorDoorLeafWidth(openingWidth, doorStyle) {
+    return getResolvedElevatorDoorStyle(doorStyle) === 'center-opening'
+        ? Math.max(openingWidth / 2 - 0.018, 0.12)
+        : Math.max(openingWidth - 0.018, 0.18);
+}
+export function getElevatorCabWidth(node) {
+    return Math.max(node.width, 0.8);
+}
+export function getElevatorCabDepth(node) {
+    return Math.max(node.depth, 0.8);
+}
+export function getElevatorShaftWallThickness(node) {
+    return Math.max(node.shaftWallThickness ?? DEFAULT_ELEVATOR_SHAFT_WALL_THICKNESS, 0.04);
+}
+export function getElevatorShaftWidth(node, cabWidth = getElevatorCabWidth(node)) {
+    return Math.max(node.shaftWidth ?? cabWidth, cabWidth, 0.8);
+}
+export function getElevatorShaftDepth(node, cabDepth = getElevatorCabDepth(node)) {
+    return Math.max(node.shaftDepth ?? cabDepth, cabDepth, 0.8);
+}
+export function getElevatorCabCenterZ(node) {
+    return -getElevatorShaftDepth(node) / 2 + getElevatorCabDepth(node) / 2;
+}

package/dist/systems/elevator/elevator-opening-sync.d.ts

@@ -0,0 +1,6 @@
+import type { AnyNode, AnyNodeId, CeilingNode, SlabNode } from '../../schema';
+export declare function syncAutoElevatorOpenings(nodes: Record<string, AnyNode>): {
+    id: AnyNodeId;
+    data: Partial<SlabNode | CeilingNode>;
+}[];
+//# sourceMappingURL=elevator-opening-sync.d.ts.map

package/dist/systems/elevator/elevator-opening-sync.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elevator-opening-sync.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-sync.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,WAAW,EAEX,QAAQ,EAET,MAAM,cAAc,CAAA;AA8JrB,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC;QAQ1C,SAAS;UAAQ,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC;IAmG5E"}

package/dist/systems/elevator/elevator-opening-sync.js

@@ -0,0 +1,218 @@
+import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
+import { resolveElevatorServiceLevels } from './elevator-service';
+const ELEVATOR_OPENING_PADDING = 0.08;
+const DEFAULT_ELEVATOR_SHAFT_WALL_THICKNESS = 0.09;
+function pointsEqual(a, b, tolerance = 1e-5) {
+    const dx = a[0] - b[0];
+    const dz = a[1] - b[1];
+    return dx * dx + dz * dz <= tolerance * tolerance;
+}
+function polygonsEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((polygon, polygonIndex) => {
+        const other = right[polygonIndex];
+        if (!(other && polygon.length === other.length))
+            return false;
+        return polygon.every((point, pointIndex) => {
+            const otherPoint = other[pointIndex];
+            if (!otherPoint)
+                return false;
+            return pointsEqual(point, otherPoint);
+        });
+    });
+}
+function metadataEqual(left, right) {
+    if (left.length !== right.length)
+        return false;
+    return left.every((entry, index) => entry.source === right[index]?.source &&
+        (entry.elevatorId ?? null) === (right[index]?.elevatorId ?? null) &&
+        (entry.stairId ?? null) === (right[index]?.stairId ?? null));
+}
+function normalizeExistingMetadata(holes, metadata) {
+    return holes.map((_, index) => metadata?.[index] ?? { source: 'manual' });
+}
+function rotateXZ(x, z, angle) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return [x * cos + z * sin, -x * sin + z * cos];
+}
+function pointOnSegment(point, a, b, tolerance = 1e-6) {
+    const cross = (point[1] - a[1]) * (b[0] - a[0]) - (point[0] - a[0]) * (b[1] - a[1]);
+    if (Math.abs(cross) > tolerance)
+        return false;
+    const dot = (point[0] - a[0]) * (b[0] - a[0]) + (point[1] - a[1]) * (b[1] - a[1]);
+    if (dot < -tolerance)
+        return false;
+    const lenSq = (b[0] - a[0]) ** 2 + (b[1] - a[1]) ** 2;
+    return dot <= lenSq + tolerance;
+}
+function pointInPolygon(point, polygon) {
+    if (polygon.length < 3)
+        return false;
+    let inside = false;
+    const [x, z] = point;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const a = polygon[i];
+        const b = polygon[j];
+        if (pointOnSegment(point, a, b))
+            return true;
+        const intersects = a[1] > z !== b[1] > z && x < ((b[0] - a[0]) * (z - a[1])) / (b[1] - a[1]) + a[0];
+        if (intersects)
+            inside = !inside;
+    }
+    return inside;
+}
+function polygonContainsPolygon(outer, inner) {
+    return inner.every((point) => pointInPolygon(point, outer));
+}
+function isCoveredByExistingHole(existingHoles, autoHole) {
+    return existingHoles.some((existingHole) => polygonContainsPolygon(existingHole, autoHole));
+}
+function getServedLevelRange(elevator, nodes) {
+    const servedLevels = resolveElevatorServiceLevels(elevator, nodes);
+    if (servedLevels.length < 2)
+        return null;
+    const levelNumbers = servedLevels.map((level) => level.level);
+    return {
+        max: Math.max(...levelNumbers),
+        min: Math.min(...levelNumbers),
+        sortedServedLevels: servedLevels,
+    };
+}
+function getLevelNumber(levelId, nodes) {
+    if (!levelId)
+        return undefined;
+    const node = nodes[levelId];
+    return node?.type === 'level' ? node.level : undefined;
+}
+function shouldApplyElevatorToSlab(elevator, slabLevelId, nodes) {
+    const range = getServedLevelRange(elevator, nodes);
+    if (!range)
+        return false;
+    const slabLevel = getLevelNumber(slabLevelId, nodes);
+    if (slabLevel !== undefined) {
+        return slabLevel > range.min && slabLevel <= range.max;
+    }
+    const servedIndex = range.sortedServedLevels.findIndex((level) => level.id === slabLevelId);
+    return servedIndex > 0;
+}
+function shouldApplyElevatorToCeiling(elevator, ceilingLevelId, nodes) {
+    const range = getServedLevelRange(elevator, nodes);
+    if (!range)
+        return false;
+    const ceilingLevel = getLevelNumber(ceilingLevelId, nodes);
+    if (ceilingLevel !== undefined) {
+        return ceilingLevel >= range.min && ceilingLevel < range.max;
+    }
+    const servedIndex = range.sortedServedLevels.findIndex((level) => level.id === ceilingLevelId);
+    return servedIndex >= 0 && servedIndex < range.sortedServedLevels.length - 1;
+}
+function getElevatorOpeningPolygon(elevator) {
+    const wallThickness = Math.max(elevator.shaftWallThickness ?? DEFAULT_ELEVATOR_SHAFT_WALL_THICKNESS, 0.04);
+    const shaftWidth = Math.max(elevator.shaftWidth ?? elevator.width, elevator.width, 0.8);
+    const shaftDepth = Math.max(elevator.shaftDepth ?? elevator.depth, elevator.depth, 0.8);
+    const halfWidth = shaftWidth / 2 + wallThickness + ELEVATOR_OPENING_PADDING;
+    const halfDepth = shaftDepth / 2 + wallThickness + ELEVATOR_OPENING_PADDING;
+    const corners = [
+        [-halfWidth, -halfDepth],
+        [halfWidth, -halfDepth],
+        [halfWidth, halfDepth],
+        [-halfWidth, halfDepth],
+    ];
+    return corners.map(([x, z]) => {
+        const [rotatedX, rotatedZ] = rotateXZ(x, z, elevator.rotation ?? 0);
+        return [elevator.position[0] + rotatedX, elevator.position[2] + rotatedZ];
+    });
+}
+export function syncAutoElevatorOpenings(nodes) {
+    const elevators = Object.values(nodes).filter((node) => node.type === 'elevator' && node.visible !== false);
+    const slabs = Object.values(nodes).filter((node) => node.type === 'slab');
+    const ceilings = Object.values(nodes).filter((node) => node.type === 'ceiling');
+    const updates = [];
+    for (const slab of slabs) {
+        const slabLevelId = resolveLevelId(slab, nodes);
+        const existingHoles = slab.holes ?? [];
+        const existingMetadata = normalizeExistingMetadata(existingHoles, slab.holeMetadata);
+        const preservedHoles = existingHoles
+            .map((polygon, index) => ({ metadata: existingMetadata[index], polygon }))
+            .filter((entry) => entry.metadata.source !== 'elevator');
+        const manualHoles = preservedHoles.filter((entry) => entry.metadata.source !== 'stair');
+        const stairHoles = preservedHoles.filter((entry) => entry.metadata.source === 'stair');
+        const preservedHolePolygons = preservedHoles.map((entry) => entry.polygon);
+        const elevatorHoles = elevators
+            .filter((elevator) => shouldApplyElevatorToSlab(elevator, slabLevelId, nodes))
+            .map((elevator) => ({
+            polygon: getElevatorOpeningPolygon(elevator),
+            metadata: {
+                elevatorId: elevator.id,
+                source: 'elevator',
+            },
+        }))
+            .filter((hole) => polygonContainsPolygon(slab.polygon, hole.polygon))
+            .filter((hole) => !isCoveredByExistingHole(preservedHolePolygons, hole.polygon));
+        const nextHoles = [
+            ...manualHoles.map((hole) => hole.polygon),
+            ...elevatorHoles.map((hole) => hole.polygon),
+            ...stairHoles.map((hole) => hole.polygon),
+        ];
+        const nextMetadata = [
+            ...manualHoles.map((hole) => ({ ...hole.metadata })),
+            ...elevatorHoles.map((hole) => hole.metadata),
+            ...stairHoles.map((hole) => ({ ...hole.metadata })),
+        ];
+        if (!polygonsEqual(existingHoles, nextHoles) ||
+            !metadataEqual(existingMetadata, nextMetadata)) {
+            updates.push({
+                id: slab.id,
+                data: {
+                    holes: nextHoles,
+                    holeMetadata: nextMetadata,
+                },
+            });
+        }
+    }
+    for (const ceiling of ceilings) {
+        const ceilingLevelId = resolveLevelId(ceiling, nodes);
+        const existingHoles = ceiling.holes ?? [];
+        const existingMetadata = normalizeExistingMetadata(existingHoles, ceiling.holeMetadata);
+        const preservedHoles = existingHoles
+            .map((polygon, index) => ({ metadata: existingMetadata[index], polygon }))
+            .filter((entry) => entry.metadata.source !== 'elevator');
+        const manualHoles = preservedHoles.filter((entry) => entry.metadata.source !== 'stair');
+        const stairHoles = preservedHoles.filter((entry) => entry.metadata.source === 'stair');
+        const preservedHolePolygons = preservedHoles.map((entry) => entry.polygon);
+        const elevatorHoles = elevators
+            .filter((elevator) => shouldApplyElevatorToCeiling(elevator, ceilingLevelId, nodes))
+            .map((elevator) => ({
+            polygon: getElevatorOpeningPolygon(elevator),
+            metadata: {
+                elevatorId: elevator.id,
+                source: 'elevator',
+            },
+        }))
+            .filter((hole) => polygonContainsPolygon(ceiling.polygon, hole.polygon))
+            .filter((hole) => !isCoveredByExistingHole(preservedHolePolygons, hole.polygon));
+        const nextHoles = [
+            ...manualHoles.map((hole) => hole.polygon),
+            ...elevatorHoles.map((hole) => hole.polygon),
+            ...stairHoles.map((hole) => hole.polygon),
+        ];
+        const nextMetadata = [
+            ...manualHoles.map((hole) => ({ ...hole.metadata })),
+            ...elevatorHoles.map((hole) => hole.metadata),
+            ...stairHoles.map((hole) => ({ ...hole.metadata })),
+        ];
+        if (!polygonsEqual(existingHoles, nextHoles) ||
+            !metadataEqual(existingMetadata, nextMetadata)) {
+            updates.push({
+                id: ceiling.id,
+                data: {
+                    holes: nextHoles,
+                    holeMetadata: nextMetadata,
+                },
+            });
+        }
+    }
+    return updates;
+}

package/dist/systems/elevator/elevator-opening-sync.test.d.ts

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

package/dist/systems/elevator/elevator-opening-sync.test.d.ts.map

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

package/dist/systems/elevator/elevator-opening-sync.test.js

@@ -0,0 +1,146 @@
+import { describe, expect, test } from 'bun:test';
+import { BuildingNode, CeilingNode, ElevatorNode, LevelNode, SlabNode } from '../../schema';
+import { syncAutoElevatorOpenings } from './elevator-opening-sync';
+describe('syncAutoElevatorOpenings', () => {
+    test('does not add elevator holes when a manual surface hole already covers them', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const elevator = ElevatorNode.parse({
+            name: 'Elevator',
+            parentId: building.id,
+            position: [2, 0, 1.5],
+            width: 1.6,
+            depth: 1.6,
+        });
+        const buildingWithChildren = {
+            ...building,
+            children: [ground.id, upper.id, elevator.id],
+        };
+        const manualOpening = [
+            [1, 0.5],
+            [3, 0.5],
+            [3, 2.5],
+            [1, 2.5],
+        ];
+        const sourceCeiling = CeilingNode.parse({
+            name: 'Source Ceiling',
+            parentId: ground.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [manualOpening],
+            holeMetadata: [{ source: 'manual' }],
+        });
+        const upperSlab = SlabNode.parse({
+            name: 'Upper Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [manualOpening],
+            holeMetadata: [{ source: 'manual' }],
+        });
+        const nodes = Object.fromEntries([buildingWithChildren, ground, upper, elevator, sourceCeiling, upperSlab].map((node) => [
+            node.id,
+            node,
+        ]));
+        const updates = syncAutoElevatorOpenings(nodes);
+        expect(updates.find((update) => update.id === upperSlab.id)).toBeUndefined();
+        expect(updates.find((update) => update.id === sourceCeiling.id)).toBeUndefined();
+    });
+    test('adds elevator holes when an existing manual hole is too small', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const elevator = ElevatorNode.parse({
+            name: 'Elevator',
+            parentId: building.id,
+            position: [2, 0, 1.5],
+            width: 1.6,
+            depth: 1.6,
+        });
+        const buildingWithChildren = {
+            ...building,
+            children: [ground.id, upper.id, elevator.id],
+        };
+        const smallManualOpening = [
+            [1.7, 1.2],
+            [2.3, 1.2],
+            [2.3, 1.8],
+            [1.7, 1.8],
+        ];
+        const upperSlab = SlabNode.parse({
+            name: 'Upper Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [smallManualOpening],
+            holeMetadata: [{ source: 'manual' }],
+        });
+        const nodes = Object.fromEntries([buildingWithChildren, ground, upper, elevator, upperSlab].map((node) => [node.id, node]));
+        const updates = syncAutoElevatorOpenings(nodes);
+        const slabUpdate = updates.find((update) => update.id === upperSlab.id);
+        expect(slabUpdate?.data.holes).toHaveLength(2);
+        expect(slabUpdate?.data.holes?.[0]).toEqual(smallManualOpening);
+        expect(slabUpdate?.data.holeMetadata).toEqual([
+            { source: 'manual' },
+            { source: 'elevator', elevatorId: elevator.id },
+        ]);
+    });
+    test('removes stale auto elevator holes when a manual hole overlaps the elevator opening', () => {
+        const building = BuildingNode.parse({ name: 'Building' });
+        const ground = LevelNode.parse({ name: 'Ground', level: 0, parentId: building.id });
+        const upper = LevelNode.parse({ name: 'Upper', level: 1, parentId: building.id });
+        const elevator = ElevatorNode.parse({
+            name: 'Elevator',
+            parentId: building.id,
+            position: [2, 0, 1.5],
+            width: 1.6,
+            depth: 1.6,
+        });
+        const buildingWithChildren = {
+            ...building,
+            children: [ground.id, upper.id, elevator.id],
+        };
+        const manualOpening = [
+            [1, 0.5],
+            [3, 0.5],
+            [3, 2.5],
+            [1, 2.5],
+        ];
+        const staleAutoOpening = [
+            [1.12, 0.62],
+            [2.88, 0.62],
+            [2.88, 2.38],
+            [1.12, 2.38],
+        ];
+        const upperSlab = SlabNode.parse({
+            name: 'Upper Slab',
+            parentId: upper.id,
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            holes: [manualOpening, staleAutoOpening],
+            holeMetadata: [{ source: 'manual' }, { source: 'elevator', elevatorId: elevator.id }],
+        });
+        const nodes = Object.fromEntries([buildingWithChildren, ground, upper, elevator, upperSlab].map((node) => [node.id, node]));
+        const updates = syncAutoElevatorOpenings(nodes);
+        const slabUpdate = updates.find((update) => update.id === upperSlab.id);
+        expect(slabUpdate?.data.holes).toEqual([manualOpening]);
+        expect(slabUpdate?.data.holeMetadata).toEqual([{ source: 'manual' }]);
+    });
+});

package/dist/systems/elevator/elevator-opening-system.d.ts

@@ -0,0 +1,2 @@
+export declare const ElevatorOpeningSystem: () => null;
+//# sourceMappingURL=elevator-opening-system.d.ts.map

package/dist/systems/elevator/elevator-opening-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"elevator-opening-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-opening-system.tsx"],"names":[],"mappings":"AAkCA,eAAO,MAAM,qBAAqB,YAuBjC,CAAA"}

package/dist/systems/elevator/elevator-opening-system.js

@@ -0,0 +1,48 @@
+'use client';
+import { useEffect, useRef } from 'react';
+import useScene from '../../store/use-scene';
+import { syncAutoElevatorOpenings } from './elevator-opening-sync';
+function isOpeningRelevantNode(node) {
+    return (node?.type === 'building' ||
+        node?.type === 'ceiling' ||
+        node?.type === 'elevator' ||
+        node?.type === 'level' ||
+        node?.type === 'slab');
+}
+function hasOpeningRelevantNodeChange(nextNodes, prevNodes) {
+    if (nextNodes === prevNodes)
+        return false;
+    const ids = new Set([...Object.keys(nextNodes), ...Object.keys(prevNodes)]);
+    for (const id of ids) {
+        const nextNode = nextNodes[id];
+        const prevNode = prevNodes[id];
+        if (nextNode === prevNode)
+            continue;
+        if (isOpeningRelevantNode(nextNode) || isOpeningRelevantNode(prevNode))
+            return true;
+    }
+    return false;
+}
+export const ElevatorOpeningSystem = () => {
+    const syncingAutoOpeningsRef = useRef(false);
+    useEffect(() => {
+        const applyUpdates = (updates) => {
+            if (updates.length === 0)
+                return;
+            syncingAutoOpeningsRef.current = true;
+            useScene.getState().updateNodes(updates);
+            queueMicrotask(() => {
+                syncingAutoOpeningsRef.current = false;
+            });
+        };
+        applyUpdates(syncAutoElevatorOpenings(useScene.getState().nodes));
+        return useScene.subscribe((state, prevState) => {
+            if (syncingAutoOpeningsRef.current)
+                return;
+            if (!hasOpeningRelevantNodeChange(state.nodes, prevState.nodes))
+                return;
+            applyUpdates(syncAutoElevatorOpenings(state.nodes));
+        });
+    }, []);
+    return null;
+};

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

@@ -0,0 +1,2 @@
+export declare function ElevatorRuntimeSystem(): null;
+//# sourceMappingURL=elevator-runtime-system.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"elevator-runtime-system.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-runtime-system.tsx"],"names":[],"mappings":"AAGA,wBAAgB,qBAAqB,SAMpC"}

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

@@ -0,0 +1,8 @@
+import { useFrame } from '@react-three/fiber';
+import { stepElevatorRuntimes } from './elevator-runtime';
+export function ElevatorRuntimeSystem() {
+    useFrame(({ clock }, delta) => {
+        stepElevatorRuntimes(clock.getElapsedTime() * 1000, delta);
+    }, 2);
+    return null;
+}

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

@@ -0,0 +1,18 @@
+import type { AnyNodeId, ElevatorNode } from '../../schema';
+import { type ElevatorInteractiveState } from '../../store/use-interactive';
+import { type ElevatorLevelEntry } from './elevator-service';
+export declare function createElevatorInteractiveState(levelId: AnyNodeId, carY: number): ElevatorInteractiveState;
+export declare function queueElevatorRequest(state: ElevatorInteractiveState, levelId: AnyNodeId): ElevatorInteractiveState;
+export declare function openElevatorDoorState(state: ElevatorInteractiveState): ElevatorInteractiveState;
+export declare function requestElevatorLevel(elevatorId: AnyNodeId, levelId: AnyNodeId): void;
+export declare function openElevatorDoor(elevatorId: AnyNodeId): void;
+export declare function stepElevatorRuntimeState({ defaultEntry, delta, elevator, entries, now, state, }: {
+    defaultEntry: ElevatorLevelEntry;
+    delta: number;
+    elevator: ElevatorNode;
+    entries: ElevatorLevelEntry[];
+    now: number;
+    state: ElevatorInteractiveState;
+}): ElevatorInteractiveState;
+export declare function stepElevatorRuntimes(now: number, delta: number): void;
+//# sourceMappingURL=elevator-runtime.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"elevator-runtime.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-runtime.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAW,SAAS,EAAE,YAAY,EAAE,MAAM,cAAc,CAAA;AACpE,OAAO,EAAE,KAAK,wBAAwB,EAAkB,MAAM,6BAA6B,CAAA;AAE3F,OAAO,EAAE,KAAK,kBAAkB,EAAyB,MAAM,oBAAoB,CAAA;AAUnF,wBAAgB,8BAA8B,CAC5C,OAAO,EAAE,SAAS,EAClB,IAAI,EAAE,MAAM,GACX,wBAAwB,CAW1B;AA8BD,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,wBAAwB,EAC/B,OAAO,EAAE,SAAS,GACjB,wBAAwB,CAW1B;AAED,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,wBAAwB,GAAG,wBAAwB,CAQ/F;AAED,wBAAgB,oBAAoB,CAAC,UAAU,EAAE,SAAS,EAAE,OAAO,EAAE,SAAS,QAS7E;AAED,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,SAAS,QASrD;AAED,wBAAgB,wBAAwB,CAAC,EACvC,YAAY,EACZ,KAAK,EACL,QAAQ,EACR,OAAO,EACP,GAAG,EACH,KAAK,GACN,EAAE;IACD,YAAY,EAAE,kBAAkB,CAAA;IAChC,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,YAAY,CAAA;IACtB,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,GAAG,EAAE,MAAM,CAAA;IACX,KAAK,EAAE,wBAAwB,CAAA;CAChC,GAAG,wBAAwB,CAmH3B;AAED,wBAAgB,oBAAoB,CAAC,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,QAsC9D"}