@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/elevator/presets.js

@@ -0,0 +1,52 @@
+import { ElevatorNode, normalizeElevatorDimensions } from '@pascal-app/core';
+export const ELEVATOR_PRESETS = {
+    passenger: {
+        label: /* i18n */ { id: 'node.elevator.preset.passenger', message: 'Passenger' },
+        width: 1.84,
+        depth: 1.84,
+        cabHeight: 2.35,
+        doorWidth: 0.95,
+        doorHeight: 2.1,
+        shaftStyle: 'solid',
+        doorStyle: 'center-opening',
+        doorPanelStyle: 'solid-panel',
+    },
+    service: {
+        label: /* i18n */ { id: 'node.elevator.preset.service', message: 'Service' },
+        width: 2.4,
+        depth: 3,
+        cabHeight: 2.7,
+        doorWidth: 1.4,
+        doorHeight: 2.4,
+        shaftStyle: 'solid',
+        doorStyle: 'single-left',
+        doorPanelStyle: 'segmented-panel',
+    },
+    glass: {
+        label: /* i18n */ { id: 'node.elevator.preset.glass', message: 'Glass' },
+        width: 1.84,
+        depth: 1.84,
+        cabHeight: 2.35,
+        doorWidth: 0.95,
+        doorHeight: 2.1,
+        shaftStyle: 'glass',
+        doorStyle: 'center-opening',
+        doorPanelStyle: 'glass-frame',
+    },
+};
+export function elevatorPresetPatch(node, id) {
+    const { label: _label, ...preset } = ELEVATOR_PRESETS[id];
+    const next = { ...node, ...preset, shaftWidth: undefined, shaftDepth: undefined };
+    return { ...preset, ...normalizeElevatorDimensions(next) };
+}
+export const ELEVATOR_SECTION_FIELDS = {
+    Cab: ['width', 'depth', 'cabHeight'],
+    Shaft: ['shaftWidth', 'shaftDepth', 'shaftStyle', 'shaftWallThickness'],
+    Doors: ['doorWidth', 'doorHeight', 'doorStyle', 'doorPanelStyle'],
+    Motion: ['speed', 'doorDurationMs', 'dwellMs'],
+};
+export function elevatorSectionReset(node, section) {
+    const defaults = ElevatorNode.parse({});
+    const patch = Object.fromEntries((ELEVATOR_SECTION_FIELDS[section] ?? []).map((key) => [key, defaults[key]]));
+    return { ...patch, ...normalizeElevatorDimensions({ ...node, ...patch }) };
+}

package/dist/elevator/renderer.d.ts

@@ -1,6 +1,7 @@
 import { type ElevatorNode } from '@pascal-app/core';
-export declare const ElevatorRenderer: ({ node }: {
+export declare const ElevatorRenderer: ({ node, interactionEnabled, }: {
     node: ElevatorNode;
+    interactionEnabled?: boolean;
 }) => import("react").JSX.Element;
 export default ElevatorRenderer;
 //# sourceMappingURL=renderer.d.ts.map

package/dist/elevator/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/elevator/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAQL,KAAK,YAAY,EAmBlB,MAAM,kBAAkB,CAAA;AAypCzB,eAAO,MAAM,gBAAgB,aAAc;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,gCA6YhE,CAAA;eAEc,gBAAgB"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/elevator/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAQL,KAAK,YAAY,EAelB,MAAM,kBAAkB,CAAA;AA+yCzB,eAAO,MAAM,gBAAgB,kCAG1B;IACD,IAAI,EAAE,YAAY,CAAA;IAClB,kBAAkB,CAAC,EAAE,OAAO,CAAA;CAC7B,gCA8cA,CAAA;eAEc,gBAAgB"}

package/dist/elevator/renderer.edit.d.ts

@@ -0,0 +1,5 @@
+import type { ElevatorNode } from '@pascal-app/core';
+export default function EditorElevatorRenderer({ node }: {
+    node: ElevatorNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=renderer.edit.d.ts.map

package/dist/elevator/renderer.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.edit.d.ts","sourceRoot":"","sources":["../../src/elevator/renderer.edit.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,kBAAkB,CAAA;AAIpD,MAAM,CAAC,OAAO,UAAU,sBAAsB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,YAAY,CAAA;CAAE,+BAG9E"}

package/dist/elevator/renderer.edit.js

@@ -0,0 +1,8 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useEditor } from '@pascal-app/editor';
+import ElevatorRenderer from './renderer.js';
+export default function EditorElevatorRenderer({ node }) {
+    const interactionEnabled = useEditor((state) => state.mode === 'select' || state.isPreviewMode);
+    return _jsx(ElevatorRenderer, { node: node, interactionEnabled: interactionEnabled });
+}

package/dist/elevator/renderer.js

@@ -1,11 +1,13 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { ELEVATOR_CAB_SLOT_DEFAULT, ELEVATOR_DOORS_SLOT_DEFAULT, ELEVATOR_GLASS_SLOT_DEFAULT, ELEVATOR_SHAFT_SLOT_DEFAULT, getElevatorCabDepth, getElevatorCabWidth, getElevatorDoorLeafSides, getElevatorDoorLeafWidth, getElevatorDoorLeafX, getElevatorShaftDepth, getElevatorShaftWallThickness, getElevatorShaftWidth, getResolvedElevatorDoorPanelStyle as getResolvedDoorPanelStyle, getResolvedElevatorDoorStyle as getResolvedDoorStyle, getResolvedElevatorShaftStyle as getResolvedShaftStyle, resolveElevatorLevels, useInteractive, useLiveNodeOverrides, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
+import { ELEVATOR_CAB_SLOT_DEFAULT, ELEVATOR_DOORS_SLOT_DEFAULT, ELEVATOR_GLASS_SLOT_DEFAULT, ELEVATOR_SHAFT_SLOT_DEFAULT, getElevatorDoorLeafSides, getElevatorDoorLeafWidth, getElevatorDoorLeafX, getResolvedElevatorDoorPanelStyle as getResolvedDoorPanelStyle, getResolvedElevatorDoorStyle as getResolvedDoorStyle, getResolvedElevatorShaftStyle as getResolvedShaftStyle, resolveElevatorDimensions, resolveElevatorLevels, useInteractive, useLiveNodeOverrides, useLiveTransforms, useRegistry, useScene, } from '@pascal-app/core';
 import { createDefaultMaterial, createSurfaceRoleMaterial, materialCastsShadow, resolveMaterialRef, resolveSlotDefaultMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useFrame } from '@react-three/fiber';
-import { createContext, useCallback, useContext, useLayoutEffect, useMemo, useRef } from 'react';
-import { BoxGeometry, CylinderGeometry, Object3D, TorusGeometry, } from 'three';
+import { Children, createContext, isValidElement, useCallback, useContext, useEffect, useLayoutEffect, useMemo, useRef, } from 'react';
+import { BoxGeometry, CylinderGeometry, Matrix4, Object3D, TorusGeometry, Vector3, } from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { useShallow } from 'zustand/react/shallow';
+import { ElevatorInspectionOverlay, useElevatorInspection } from './inspection.js';
 const DEFAULT_STRUCTURE_WHITE = '#f2f0ed';
 const SHAFT_WALL_COLOR = DEFAULT_STRUCTURE_WHITE;
 const SHAFT_SIDE_COLOR = DEFAULT_STRUCTURE_WHITE;
@@ -15,9 +17,9 @@ const GLASS_COLOR = '#f8fafc';
 const DOOR_COLOR = '#8e98a6';
 const PANEL_COLOR = '#1f2937';
 const UNIT_BOX_GEOMETRY = new BoxGeometry(1, 1, 1);
-const BUTTON_FACE_GEOMETRY = new CylinderGeometry(1, 0.92, 1, 24);
-const BUTTON_GLOW_GEOMETRY = new CylinderGeometry(1.42, 1.42, 1, 24);
-const BUTTON_RING_GEOMETRY = new TorusGeometry(1.12, 0.12, 8, 24);
+const BUTTON_FACE_GEOMETRY = new CylinderGeometry(1, 0.92, 1, 12);
+const BUTTON_GLOW_GEOMETRY = new CylinderGeometry(1.42, 1.42, 1, 12);
+const BUTTON_RING_GEOMETRY = new TorusGeometry(1.12, 0.12, 6, 12);
 const LABEL_MATRIX_DUMMY = new Object3D();
 const SHAFT_TOP_FRAME_CLEARANCE = 0.006;
 function createElevatorMaterial(params, shading) {
@@ -213,8 +215,8 @@ function getElevatorMaterials(shading, textures = true, colorPreset = 'clay') {
     elevatorMaterialsCache.set(cacheKey, materials);
     return materials;
 }
-function resolveElevatorFinishMaterial(node, slotId, slotDefault, sceneMaterials, shading, roughness) {
-    const ref = node.slots?.[slotId];
+function resolveElevatorFinishMaterial(slots, slotId, slotDefault, sceneMaterials, shading, roughness) {
+    const ref = slots?.[slotId];
     if (ref) {
         const resolved = resolveMaterialRef(ref, sceneMaterials, shading);
         if (resolved)
@@ -225,19 +227,19 @@ function resolveElevatorFinishMaterial(node, slotId, slotDefault, sceneMaterials
 function withElevatorGlassTransparency(material) {
     const glass = material.clone();
     glass.depthWrite = false;
-    glass.opacity = 0.2;
+    glass.opacity = material.opacity < 1 ? material.opacity : 0.2;
     glass.transparent = true;
     glass.needsUpdate = true;
     return glass;
 }
-function getResolvedElevatorMaterials(node, shading, textures, colorPreset, sceneMaterials) {
+function getResolvedElevatorMaterials(slots, shading, textures, colorPreset, sceneMaterials) {
     const materials = getElevatorMaterials(shading, textures, colorPreset);
     if (!textures)
         return materials;
-    const cab = resolveElevatorFinishMaterial(node, 'cab', ELEVATOR_CAB_SLOT_DEFAULT, sceneMaterials, shading, 0.48);
-    const doors = resolveElevatorFinishMaterial(node, 'doors', ELEVATOR_DOORS_SLOT_DEFAULT, sceneMaterials, shading, 0.34);
-    const shaft = resolveElevatorFinishMaterial(node, 'shaft', ELEVATOR_SHAFT_SLOT_DEFAULT, sceneMaterials, shading, 0.56);
-    const glass = withElevatorGlassTransparency(resolveElevatorFinishMaterial(node, 'glass', ELEVATOR_GLASS_SLOT_DEFAULT, sceneMaterials, shading, 0.08));
+    const cab = resolveElevatorFinishMaterial(slots, 'cab', ELEVATOR_CAB_SLOT_DEFAULT, sceneMaterials, shading, 0.48);
+    const doors = resolveElevatorFinishMaterial(slots, 'doors', ELEVATOR_DOORS_SLOT_DEFAULT, sceneMaterials, shading, 0.34);
+    const shaft = resolveElevatorFinishMaterial(slots, 'shaft', ELEVATOR_SHAFT_SLOT_DEFAULT, sceneMaterials, shading, 0.56);
+    const glass = withElevatorGlassTransparency(resolveElevatorFinishMaterial(slots, 'glass', ELEVATOR_GLASS_SLOT_DEFAULT, sceneMaterials, shading, 0.08));
     return {
         ...materials,
         SHAFT_WALL_MATERIAL: shaft,
@@ -282,8 +284,79 @@ const SEGMENT_PROPS = {
     upperLeft: { position: [-0.32, 0.22, 0], size: [0.11, 0.42, 0.018] },
     upperRight: { position: [0.32, 0.22, 0], size: [0.11, 0.42, 0.018] },
 };
+function createElevatorBox(width, height, depth) {
+    const box = new BoxGeometry(width, height, depth);
+    const uv = box.getAttribute('uv');
+    const faceSpans = [
+        [depth, height],
+        [depth, height],
+        [width, depth],
+        [width, depth],
+        [width, height],
+        [width, height],
+    ];
+    for (let face = 0; face < 6; face++) {
+        const [u, v] = faceSpans[face];
+        for (let vertex = face * 4; vertex < face * 4 + 4; vertex++) {
+            uv.setXY(vertex, uv.getX(vertex) * u, uv.getY(vertex) * v);
+        }
+    }
+    return box;
+}
+const ElevatorCutawayContext = createContext(false);
+function StaticBoxes({ children }) {
+    const cutaway = useContext(ElevatorCutawayContext);
+    const boxes = Children.toArray(children)
+        .filter(isValidElement)
+        .map((child) => child.props);
+    const signature = JSON.stringify(boxes.map((box) => ({ ...box, material: box.material.uuid })));
+    const batches = useMemo(() => {
+        const groups = new Map();
+        for (const box of JSON.parse(signature)) {
+            const key = [box.material, box.slotId, box.castShadow, box.receiveShadow].join(':');
+            let group = groups.get(key);
+            if (!group) {
+                group = {
+                    parts: [],
+                    material: box.material,
+                    slotId: box.slotId,
+                    castShadow: !!box.castShadow,
+                    receiveShadow: !!box.receiveShadow,
+                };
+                groups.set(key, group);
+            }
+            const geometry = createElevatorBox(...box.scale);
+            geometry.applyMatrix4(new Matrix4().makeTranslation(...(box.position ?? [0, 0, 0])));
+            group.parts.push(geometry);
+        }
+        return [...groups.values()].map(({ parts, ...group }) => {
+            const geometry = mergeGeometries(parts);
+            for (const part of parts)
+                part.dispose();
+            return { ...group, geometry };
+        });
+    }, [signature]);
+    useEffect(() => () => {
+        for (const batch of batches)
+            batch.geometry.dispose();
+    }, [batches]);
+    return (_jsx("group", { name: "elevator-static-batch", children: batches.map((batch) => {
+            const material = boxes.find((box) => box.material.uuid === batch.material).material;
+            return (_jsx("mesh", { visible: !(cutaway && (batch.slotId === 'shaft' || batch.slotId === 'glass')), geometry: batch.geometry, material: material, dispose: null, castShadow: batch.castShadow && materialCastsShadow(material), receiveShadow: batch.receiveShadow, userData: ELEVATOR_SLOT_USER_DATA[batch.slotId] }, batch.slotId + batch.material));
+        }) }));
+}
 function BoxPrimitive({ castShadow = false, material, position, receiveShadow = false, rotation, scale, slotId, }) {
-    return (_jsx("mesh", { castShadow: castShadow && materialCastsShadow(material), dispose: null, geometry: UNIT_BOX_GEOMETRY, material: material, position: position, receiveShadow: receiveShadow, rotation: rotation, scale: scale, userData: slotId ? ELEVATOR_SLOT_USER_DATA[slotId] : undefined }));
+    const [width, height, depth] = scale;
+    const geometry = useMemo(() => {
+        if (!slotId)
+            return UNIT_BOX_GEOMETRY;
+        return createElevatorBox(width, height, depth);
+    }, [width, height, depth, slotId]);
+    useEffect(() => () => {
+        if (geometry !== UNIT_BOX_GEOMETRY)
+            geometry.dispose();
+    }, [geometry]);
+    return (_jsx("mesh", { castShadow: castShadow && materialCastsShadow(material), dispose: null, geometry: geometry, material: material, position: position, receiveShadow: receiveShadow, rotation: rotation, scale: slotId ? undefined : scale, userData: slotId ? ELEVATOR_SLOT_USER_DATA[slotId] : undefined }));
 }
 function MeshButtonLabel({ faceSign = 1, label, material, position, scale, }) {
     const ref = useRef(null);
@@ -347,7 +420,21 @@ function ElevatorFloorIndicator({ active, direction, faceSign = -1, label, posit
 function DoorOpenGlyph({ material, positionZ, scale, }) {
     return (_jsxs("group", { position: [0, 0, positionZ], children: [_jsx(BoxPrimitive, { material: material, position: [-0.014 * scale, 0, 0], scale: [0.006 * scale, 0.052 * scale, 0.012] }), _jsx(BoxPrimitive, { material: material, position: [0.014 * scale, 0, 0], scale: [0.006 * scale, 0.052 * scale, 0.012] }), _jsx(BoxPrimitive, { material: material, position: [-0.033 * scale, 0, 0], rotation: [0, 0, Math.PI / 4], scale: [0.026 * scale, 0.005 * scale, 0.012] }), _jsx(BoxPrimitive, { material: material, position: [-0.033 * scale, 0, 0], rotation: [0, 0, -Math.PI / 4], scale: [0.026 * scale, 0.005 * scale, 0.012] }), _jsx(BoxPrimitive, { material: material, position: [0.033 * scale, 0, 0], rotation: [0, 0, Math.PI / 4], scale: [0.026 * scale, 0.005 * scale, 0.012] }), _jsx(BoxPrimitive, { material: material, position: [0.033 * scale, 0, 0], rotation: [0, 0, -Math.PI / 4], scale: [0.026 * scale, 0.005 * scale, 0.012] })] }));
 }
-function ElevatorMeshButton({ action = 'request-level', active, buttonKind, disabled = false, elevatorId, faceSign = -1, glyph, label, levelId, position, queued, radius = 0.055, }) {
+function ElevatorMeshButton({ action = 'request-level', active, buttonKind, disabled = false, elevatorId, faceSign = -1, interactionEnabled = true, glyph, label, levelId, position, queued, radius = 0.055, }) {
+    const detailRef = useRef(null);
+    const detailPosition = useMemo(() => new Vector3(), []);
+    const cameraPosition = useMemo(() => new Vector3(), []);
+    useFrame(({ camera }) => {
+        const detail = detailRef.current;
+        if (!detail)
+            return;
+        detail.getWorldPosition(detailPosition);
+        camera.getWorldPosition(cameraPosition);
+        const orthographic = camera;
+        detail.visible = orthographic.isOrthographicCamera
+            ? orthographic.zoom * radius >= 0.5
+            : cameraPosition.distanceToSquared(detailPosition) < 18 * 18;
+    });
     const { BUTTON_FACE_MATERIALS, BUTTON_GLOW_MATERIALS, BUTTON_LABEL_MATERIALS, BUTTON_RING_MATERIALS, } = useElevatorMaterialSet();
     const state = disabled ? 'disabled' : active ? 'active' : queued ? 'queued' : 'idle';
     const depth = active ? 0.028 : 0.04;
@@ -360,13 +447,14 @@ function ElevatorMeshButton({ action = 'request-level', active, buttonKind, disa
     const userData = useMemo(() => ({
         elevatorButton: {
             action,
-            disabled,
+            // Gate input without changing the physical button state or its appearance.
+            disabled: disabled || !interactionEnabled,
             elevatorId,
             kind: buttonKind,
             levelId,
         },
-    }), [action, buttonKind, disabled, elevatorId, levelId]);
-    return (_jsxs("group", { position: position, userData: userData, children: [!disabled && (active || queued) && (_jsx("mesh", { dispose: null, geometry: BUTTON_GLOW_GEOMETRY, material: active ? BUTTON_GLOW_MATERIALS.active : BUTTON_GLOW_MATERIALS.queued, position: [0, 0, faceSign * (depth + 0.004)], receiveShadow: true, "rotation-x": Math.PI / 2, scale: [radius, 0.012, radius] })), _jsx("mesh", { castShadow: true, dispose: null, geometry: BUTTON_RING_GEOMETRY, material: BUTTON_RING_MATERIALS[state], position: [0, 0, faceSign * (depth / 2 + 0.003)], receiveShadow: true, scale: [radius, radius, radius] }), _jsx("mesh", { castShadow: true, dispose: null, geometry: BUTTON_FACE_GEOMETRY, material: BUTTON_FACE_MATERIALS[state], receiveShadow: true, "rotation-x": Math.PI / 2, scale: [radius, depth, radius] }), label && (_jsx(MeshButtonLabel, { faceSign: faceSign, label: label, material: labelMaterial, position: [0, 0, faceZ], scale: radius * 0.72 })), glyph === 'door-open' && (_jsx(DoorOpenGlyph, { material: labelMaterial, positionZ: faceZ, scale: radius / 0.055 }))] }));
+    }), [action, buttonKind, disabled, elevatorId, interactionEnabled, levelId]);
+    return (_jsxs("group", { position: position, userData: userData, children: [_jsx("mesh", { castShadow: true, dispose: null, geometry: BUTTON_FACE_GEOMETRY, material: BUTTON_FACE_MATERIALS[state], receiveShadow: true, "rotation-x": Math.PI / 2, scale: [radius, depth, radius] }), _jsxs("group", { ref: detailRef, children: [!disabled && (active || queued) && (_jsx("mesh", { dispose: null, geometry: BUTTON_GLOW_GEOMETRY, material: active ? BUTTON_GLOW_MATERIALS.active : BUTTON_GLOW_MATERIALS.queued, position: [0, 0, faceSign * (depth + 0.004)], receiveShadow: true, "rotation-x": Math.PI / 2, scale: [radius, 0.012, radius] })), _jsx("mesh", { castShadow: true, dispose: null, geometry: BUTTON_RING_GEOMETRY, material: BUTTON_RING_MATERIALS[state], position: [0, 0, faceSign * (depth / 2 + 0.003)], receiveShadow: true, scale: [radius, radius, radius] }), label && (_jsx(MeshButtonLabel, { faceSign: faceSign, label: label, material: labelMaterial, position: [0, 0, faceZ], scale: radius * 0.72 })), glyph === 'door-open' && (_jsx(DoorOpenGlyph, { material: labelMaterial, positionZ: faceZ, scale: radius / 0.055 }))] })] }));
 }
 function getElevatorLevelContextNodes(elevator, nodes) {
     const result = {};
@@ -381,7 +469,7 @@ function getElevatorLevelContextNodes(elevator, nodes) {
         result[level.id] = level;
         for (const levelChildId of level.children) {
             const child = nodes[levelChildId];
-            if (child?.type === 'ceiling' || child?.type === 'wall') {
+            if (child?.type === 'ceiling' || child?.type === 'wall' || child?.type === 'slab') {
                 result[child.id] = child;
             }
         }
@@ -413,27 +501,30 @@ function DoorLeaf({ animated, doorOpen, doorPanelStyle, doorStyle, height, side,
                 : 0;
         ref.current.position.x = getLeafX(nextDoorOpen);
     }, 2.6);
-    return (_jsx("group", { ref: ref, position: [getLeafX(doorOpen), y + height / 2, z], children: resolvedPanelStyle === 'glass-frame' ? (_jsxs(_Fragment, { children: [_jsx(BoxPrimitive, { castShadow: true, material: DOOR_MATERIAL, position: [0, height / 2 - railHeight / 2, 0], receiveShadow: true, scale: [leafWidth, railHeight, 0.05], slotId: "doors" }), _jsx(BoxPrimitive, { castShadow: true, material: DOOR_MATERIAL, position: [0, -height / 2 + railHeight / 2, 0], receiveShadow: true, scale: [leafWidth, railHeight, 0.05], slotId: "doors" }), _jsx(BoxPrimitive, { castShadow: true, material: DOOR_MATERIAL, position: [-leafWidth / 2 + stileWidth / 2, 0, 0], receiveShadow: true, scale: [stileWidth, height, 0.05], slotId: "doors" }), _jsx(BoxPrimitive, { castShadow: true, material: DOOR_MATERIAL, position: [leafWidth / 2 - stileWidth / 2, 0, 0], receiveShadow: true, scale: [stileWidth, height, 0.05], slotId: "doors" }), _jsx(BoxPrimitive, { material: GLASS_MATERIAL, position: [0, 0, -0.004], scale: [glassWidth, glassHeight, 0.012], slotId: "glass" })] })) : (_jsxs(_Fragment, { children: [_jsx(BoxPrimitive, { castShadow: true, material: DOOR_MATERIAL, position: [0, 0, 0], receiveShadow: true, scale: [leafWidth, height, 0.05], slotId: "doors" }), _jsx(BoxPrimitive, { material: DOOR_GROOVE_MATERIAL, position: [0, 0, -0.028], scale: [0.018, panelInsetHeight, 0.01], slotId: "doors" }), resolvedPanelStyle === 'segmented-panel'
+    return (_jsx("group", { name: `${animated?.kind ?? 'landing'}-door-${side}`, ref: ref, position: [getLeafX(doorOpen), y + height / 2, z], children: resolvedPanelStyle === 'glass-frame' ? (_jsxs(_Fragment, { children: [_jsx(BoxPrimitive, { castShadow: true, material: DOOR_MATERIAL, position: [0, height / 2 - railHeight / 2, 0], receiveShadow: true, scale: [leafWidth, railHeight, 0.05], slotId: "doors" }), _jsx(BoxPrimitive, { castShadow: true, material: DOOR_MATERIAL, position: [0, -height / 2 + railHeight / 2, 0], receiveShadow: true, scale: [leafWidth, railHeight, 0.05], slotId: "doors" }), _jsx(BoxPrimitive, { castShadow: true, material: DOOR_MATERIAL, position: [-leafWidth / 2 + stileWidth / 2, 0, 0], receiveShadow: true, scale: [stileWidth, height, 0.05], slotId: "doors" }), _jsx(BoxPrimitive, { castShadow: true, material: DOOR_MATERIAL, position: [leafWidth / 2 - stileWidth / 2, 0, 0], receiveShadow: true, scale: [stileWidth, height, 0.05], slotId: "doors" }), _jsx(BoxPrimitive, { material: GLASS_MATERIAL, position: [0, 0, -0.004], scale: [glassWidth, glassHeight, 0.012], slotId: "glass" })] })) : (_jsxs(_Fragment, { children: [_jsx(BoxPrimitive, { castShadow: true, material: DOOR_MATERIAL, position: [0, 0, 0], receiveShadow: true, scale: [leafWidth, height, 0.05], slotId: "doors" }), _jsx(BoxPrimitive, { material: DOOR_GROOVE_MATERIAL, position: [0, 0, -0.028], scale: [0.018, panelInsetHeight, 0.01], slotId: "doors" }), resolvedPanelStyle === 'segmented-panel'
                     ? Array.from({ length: segmentCount - 1 }).map((_, index) => (_jsx(BoxPrimitive, { material: DOOR_GROOVE_MATERIAL, position: [0, -panelInsetHeight / 2 + segmentSpacing * (index + 1), -0.03], scale: [panelInsetWidth, 0.018, 0.012], slotId: "doors" }, index)))
                     : null, _jsx(BoxPrimitive, { material: DOOR_GROOVE_MATERIAL, position: [0, panelInsetHeight / 2, -0.029], scale: [panelInsetWidth, 0.012, 0.01], slotId: "doors" }), _jsx(BoxPrimitive, { material: DOOR_GROOVE_MATERIAL, position: [0, -panelInsetHeight / 2, -0.029], scale: [panelInsetWidth, 0.012, 0.01], slotId: "doors" })] })) }));
 }
 function ElevatorDoorLeaves({ animated, doorOpen, doorPanelStyle, doorStyle, height, width, y, z, }) {
     return (_jsx(_Fragment, { children: getElevatorDoorLeafSides(doorStyle).map((side) => (_jsx(DoorLeaf, { animated: animated, doorOpen: doorOpen, doorPanelStyle: doorPanelStyle, doorStyle: doorStyle, height: height, side: side, width: width, y: y, z: z }, side))) }));
 }
-function LandingDoorFrame({ doorHeight, doorWidth, levelTopY, levelY, shaftWidth, z, }) {
+function LandingDoorFrame({ doorHeight, doorWidth, levelTopY, levelY, shaftWidth, wallDepth, z, }) {
     const { SHAFT_TRIM_MATERIAL, SHAFT_WALL_MATERIAL } = useElevatorMaterialSet();
-    const wallDepth = 0.09;
     const levelHeight = Math.max(levelTopY - levelY, 0.01);
     const jambWidth = Math.max((shaftWidth - doorWidth) / 2, 0.08);
     const jambCenterOffset = doorWidth / 2 + jambWidth / 2;
     const headerHeight = Math.max(levelTopY - (levelY + doorHeight), 0);
     const trim = 0.055;
-    return (_jsxs(_Fragment, { children: [_jsx(BoxPrimitive, { castShadow: true, material: SHAFT_WALL_MATERIAL, position: [-jambCenterOffset, levelY + levelHeight / 2, z], receiveShadow: true, scale: [jambWidth, levelHeight, wallDepth], slotId: "shaft" }), _jsx(BoxPrimitive, { castShadow: true, material: SHAFT_WALL_MATERIAL, position: [jambCenterOffset, levelY + levelHeight / 2, z], receiveShadow: true, scale: [jambWidth, levelHeight, wallDepth], slotId: "shaft" }), headerHeight > 0.01 && (_jsx(BoxPrimitive, { castShadow: true, material: SHAFT_WALL_MATERIAL, position: [0, levelY + doorHeight + headerHeight / 2, z], receiveShadow: true, scale: [shaftWidth, headerHeight, wallDepth], slotId: "shaft" })), _jsx(BoxPrimitive, { castShadow: true, material: SHAFT_TRIM_MATERIAL, position: [0, levelY + trim / 2, z - 0.006], receiveShadow: true, scale: [doorWidth + trim * 2, trim, wallDepth * 1.12], slotId: "shaft" }), _jsx(BoxPrimitive, { castShadow: true, material: SHAFT_TRIM_MATERIAL, position: [-doorWidth / 2 - trim / 2, levelY + doorHeight / 2, z - 0.006], receiveShadow: true, scale: [trim, doorHeight, wallDepth * 1.12], slotId: "shaft" }), _jsx(BoxPrimitive, { castShadow: true, material: SHAFT_TRIM_MATERIAL, position: [doorWidth / 2 + trim / 2, levelY + doorHeight / 2, z - 0.006], receiveShadow: true, scale: [trim, doorHeight, wallDepth * 1.12], slotId: "shaft" }), _jsx(BoxPrimitive, { castShadow: true, material: SHAFT_TRIM_MATERIAL, position: [0, levelY + doorHeight + trim / 2, z - 0.006], receiveShadow: true, scale: [doorWidth + trim * 2, trim, wallDepth * 1.12], slotId: "shaft" })] }));
+    const pocketDepth = 0.07;
+    const faceDepth = (wallDepth - pocketDepth) / 2;
+    const faceOffset = (pocketDepth + faceDepth) / 2;
+    return (_jsxs(StaticBoxes, { children: [[-1, 1].flatMap((side) => [-1, 1].map((face) => (_jsx(BoxPrimitive, { castShadow: true, material: SHAFT_WALL_MATERIAL, position: [side * jambCenterOffset, levelY + levelHeight / 2, z + face * faceOffset], receiveShadow: true, scale: [jambWidth, levelHeight, faceDepth], slotId: "shaft" }, `${side}:${face}`)))), headerHeight > 0.01 && (_jsx(BoxPrimitive, { castShadow: true, material: SHAFT_WALL_MATERIAL, position: [0, levelY + doorHeight + headerHeight / 2, z], receiveShadow: true, scale: [shaftWidth, headerHeight, wallDepth], slotId: "shaft" })), _jsx(BoxPrimitive, { castShadow: true, material: SHAFT_TRIM_MATERIAL, position: [0, levelY + trim / 2, z - 0.006], receiveShadow: true, scale: [doorWidth + trim * 2, trim, wallDepth * 1.12], slotId: "shaft" }), _jsx(BoxPrimitive, { castShadow: true, material: SHAFT_TRIM_MATERIAL, position: [-doorWidth / 2 - trim / 2, levelY + doorHeight / 2, z - 0.006], receiveShadow: true, scale: [trim, doorHeight, wallDepth * 1.12], slotId: "shaft" }), _jsx(BoxPrimitive, { castShadow: true, material: SHAFT_TRIM_MATERIAL, position: [doorWidth / 2 + trim / 2, levelY + doorHeight / 2, z - 0.006], receiveShadow: true, scale: [trim, doorHeight, wallDepth * 1.12], slotId: "shaft" }), _jsx(BoxPrimitive, { castShadow: true, material: SHAFT_TRIM_MATERIAL, position: [0, levelY + doorHeight + trim / 2, z - 0.006], receiveShadow: true, scale: [doorWidth + trim * 2, trim, wallDepth * 1.12], slotId: "shaft" })] }));
 }
 function LandingDoor({ animated, doorPanelStyle, doorStyle, elevatorId, doorOpen, doorHeight, doorWidth, levelId, levelY, z, }) {
     return (_jsx(ElevatorDoorLeaves, { animated: animated ? { elevatorId, kind: 'landing', levelId } : undefined, doorOpen: doorOpen, doorPanelStyle: doorPanelStyle, doorStyle: doorStyle, height: doorHeight, width: doorWidth, y: levelY, z: z }));
 }
-export const ElevatorRenderer = ({ node }) => {
+export const ElevatorRenderer = ({ node, interactionEnabled = true, }) => {
+    const cutaway = useElevatorInspection((state) => state.nodeId === node.id && state.cutaway);
     const ref = useRef(null);
     const cabRef = useRef(null);
     const handlers = useNodeEvents(node, 'elevator');
@@ -445,7 +536,11 @@ export const ElevatorRenderer = ({ node }) => {
     const liveTransform = useLiveTransforms((state) => state.get(node.id));
     const renderNode = useMemo(() => (liveOverrides ? { ...node, ...liveOverrides } : node), [liveOverrides, node]);
     const levelContextNodes = useScene(useShallow((state) => getElevatorLevelContextNodes(renderNode, state.nodes)));
-    const materials = useMemo(() => getResolvedElevatorMaterials(renderNode, shading, textures, colorPreset, sceneMaterials), [colorPreset, renderNode, sceneMaterials, shading, textures]);
+    const materials = useMemo(() => getResolvedElevatorMaterials(renderNode.slots, shading, textures, colorPreset, sceneMaterials), [colorPreset, renderNode.slots, sceneMaterials, shading, textures]);
+    useEffect(() => () => {
+        if (textures)
+            materials.GLASS_MATERIAL.dispose();
+    }, [materials, textures]);
     const { CAB_MATERIAL, GLASS_MATERIAL, LANDING_PANEL_MATERIAL, PANEL_MATERIAL, QUEUE_STRIP_MATERIALS, SHAFT_SIDE_MATERIAL, SHAFT_TRIM_MATERIAL, } = materials;
     useRegistry(node.id, 'elevator', ref);
     const { entries, defaultEntry, shaftBaseY, totalHeight } = useMemo(() => resolveElevatorLevels(renderNode, levelContextNodes), [renderNode, levelContextNodes]);
@@ -469,14 +564,7 @@ export const ElevatorRenderer = ({ node }) => {
             return;
         cabRef.current.position.y = runtime.carY;
     }, 2.6);
-    const cabWidth = getElevatorCabWidth(renderNode);
-    const cabDepth = getElevatorCabDepth(renderNode);
-    const shaftWidth = getElevatorShaftWidth(renderNode, cabWidth);
-    const shaftDepth = getElevatorShaftDepth(renderNode, cabDepth);
-    const cabHeight = Math.max(renderNode.cabHeight, 1.4);
-    const shaftWallThickness = getElevatorShaftWallThickness(renderNode);
-    const doorWidth = Math.min(Math.max(renderNode.doorWidth, 0.45), cabWidth - 0.18, shaftWidth - 0.18);
-    const doorHeight = Math.min(Math.max(renderNode.doorHeight, 1.2), cabHeight - 0.1);
+    const { width: cabWidth, depth: cabDepth, shaftWidth, shaftDepth, cabHeight, shaftWallThickness, doorWidth, doorHeight, } = resolveElevatorDimensions(renderNode);
     const doorPanelStyle = getResolvedDoorPanelStyle(renderNode.doorPanelStyle);
     const doorStyle = getResolvedDoorStyle(renderNode.doorStyle);
     const shaftStyle = getResolvedShaftStyle(renderNode.shaftStyle);
@@ -531,16 +619,23 @@ export const ElevatorRenderer = ({ node }) => {
         runtimeSnapshot?.phase === 'opening' ||
         runtimeStatus?.phase === 'open' ||
         runtimeSnapshot?.phase === 'open';
-    const frontWallZ = -shaftDepth / 2 - shaftWallThickness / 2;
-    const frontZ = frontWallZ - shaftWallThickness / 2 - 0.018;
-    const landingPanelX = Math.min(shaftWidth / 2 - 0.16, doorWidth / 2 + 0.18);
+    const frontWallDepth = Math.max(shaftWallThickness, 0.13);
+    const frontWallZ = -shaftDepth / 2 - frontWallDepth / 2;
+    const landingDoorZ = frontWallZ;
+    const cabDoorZ = -shaftDepth / 2 + 0.055;
+    const frontZ = -shaftDepth / 2 - frontWallDepth;
+    const jambWidth = (shaftWidth - doorWidth) / 2;
+    const landingPanelWidth = Math.min(0.18, jambWidth - 0.02);
+    const landingPanelX = (shaftWidth + doorWidth) / 4;
+    const cabReturnWidth = (cabWidth - doorWidth) / 2;
     const cabCenterZ = -shaftDepth / 2 + cabDepth / 2;
     const cabPanelX = cabWidth / 2 - 0.075;
     const cabPanelZ = cabCenterZ - cabDepth / 2 + 0.36;
-    const cabButtonColumns = entries.length > 1 ? 2 : 1;
+    const maxButtonRows = Math.max(1, Math.floor((cabHeight - 0.65) / 0.15));
+    const cabButtonColumns = Math.max(entries.length > 1 ? 2 : 1, Math.ceil(entries.length / maxButtonRows));
     const cabButtonRows = Math.max(1, Math.ceil(entries.length / cabButtonColumns));
-    const cabButtonSpacingX = 0.14;
-    const cabButtonSpacingY = 0.15;
+    const cabButtonSpacingX = Math.min(0.14, Math.max(0.035, (cabDepth - 0.65) / (cabButtonColumns + 1)));
+    const cabButtonSpacingY = Math.min(0.15, (cabHeight - 0.65) / (cabButtonRows + 1));
     const cabDoorButtonOffsetX = 0.17;
     const cabFloorButtonOffsetX = entries.length > 0 ? -cabDoorButtonOffsetX / 2 : 0;
     const cabDoorButtonX = cabFloorButtonOffsetX + ((cabButtonColumns - 1) / 2) * cabButtonSpacingX + cabDoorButtonOffsetX;
@@ -558,25 +653,29 @@ export const ElevatorRenderer = ({ node }) => {
             levelTopY: nextEntry ? targetTopY : Math.min(targetTopY, shaftFrameTopY),
         };
     }), [doorHeight, entries, shaftFrameTopY]);
-    return (_jsx(ElevatorMaterialsContext.Provider, { value: materials, children: _jsxs("group", { position: liveTransform?.position ?? renderNode.position, ref: ref, "rotation-y": liveTransform?.rotation ?? renderNode.rotation, visible: renderNode.visible, ...handlers, children: [_jsx(BoxPrimitive, { castShadow: true, material: shaftShellMaterial, position: [0, shaftBodyCenterY, shaftDepth / 2 + shaftWallThickness / 2], receiveShadow: true, scale: [shaftWidth + shaftWallThickness * 2, shaftBodyHeight, shaftWallThickness], slotId: shaftShellSlotId }), _jsx(BoxPrimitive, { castShadow: true, material: shaftShellMaterial, position: [-shaftWidth / 2 - shaftWallThickness / 2, shaftBodyCenterY, 0], receiveShadow: true, scale: [shaftWallThickness, shaftBodyHeight, shaftDepth + shaftWallThickness * 2], slotId: shaftShellSlotId }), _jsx(BoxPrimitive, { castShadow: true, material: shaftShellMaterial, position: [shaftWidth / 2 + shaftWallThickness / 2, shaftBodyCenterY, 0], receiveShadow: true, scale: [shaftWallThickness, shaftBodyHeight, shaftDepth + shaftWallThickness * 2], slotId: shaftShellSlotId }), _jsx(BoxPrimitive, { castShadow: true, material: shaftTopMaterial, position: [0, shaftBaseY + shaftHeight - shaftWallThickness / 2, 0], receiveShadow: true, scale: [
-                        shaftWidth + shaftWallThickness * 2,
-                        shaftWallThickness,
-                        shaftDepth + shaftWallThickness * 2,
-                    ], slotId: "shaft" }), _jsxs("group", { ref: cabRef, position: [0, cabBaseY, 0], children: [_jsx(BoxPrimitive, { castShadow: true, material: CAB_MATERIAL, position: [0, 0.04, cabCenterZ], receiveShadow: true, scale: [cabWidth, 0.08, cabDepth], slotId: "cab" }), _jsx(BoxPrimitive, { castShadow: true, material: CAB_MATERIAL, position: [0, cabHeight - 0.04, cabCenterZ], receiveShadow: true, scale: [cabWidth, 0.08, cabDepth], slotId: "cab" }), _jsx(BoxPrimitive, { castShadow: true, material: CAB_MATERIAL, position: [0, cabHeight / 2, cabCenterZ + cabDepth / 2 - 0.04], receiveShadow: true, scale: [cabWidth, cabHeight, 0.08], slotId: "cab" }), _jsx(BoxPrimitive, { castShadow: true, material: CAB_MATERIAL, position: [-cabWidth / 2 + 0.04, cabHeight / 2, cabCenterZ], receiveShadow: true, scale: [0.08, cabHeight, cabDepth], slotId: "cab" }), _jsx(BoxPrimitive, { castShadow: true, material: CAB_MATERIAL, position: [cabWidth / 2 - 0.04, cabHeight / 2, cabCenterZ], receiveShadow: true, scale: [0.08, cabHeight, cabDepth], slotId: "cab" }), _jsx(ElevatorDoorLeaves, { animated: { elevatorId, kind: 'cab' }, doorOpen: doorOpen, doorPanelStyle: doorPanelStyle, doorStyle: doorStyle, height: doorHeight, width: doorWidth, y: 0, z: frontZ }), _jsx(ElevatorFloorIndicator, { active: indicatorActive, direction: indicatorDirection, faceSign: 1, label: indicatorEntry?.label ?? '-', position: [0, doorHeight + 0.13, frontZ + 0.055], scale: 0.78 }), _jsxs("group", { position: [cabPanelX, cabPanelY, cabPanelZ], "rotation-y": -Math.PI / 2, children: [_jsx(BoxPrimitive, { castShadow: true, material: PANEL_MATERIAL, receiveShadow: true, scale: [cabPanelWidth, cabPanelHeight, 0.045] }), entries.map((entry, index) => {
-                                    const column = index % cabButtonColumns;
-                                    const row = Math.floor(index / cabButtonColumns);
-                                    const isDisabledLevel = disabledLevelIds.has(entry.id);
-                                    const x = cabFloorButtonOffsetX + (column - (cabButtonColumns - 1) / 2) * cabButtonSpacingX;
-                                    const y = (row - (cabButtonRows - 1) / 2) * cabButtonSpacingY;
-                                    return (_jsx(ElevatorMeshButton, { active: !isDisabledLevel && activeLevelId === entry.id, buttonKind: "cab", disabled: isDisabledLevel, elevatorId: elevatorId, faceSign: 1, label: entry.label, levelId: entry.id, position: [x, y, 0.045], queued: !isDisabledLevel && queuedLevelIds.has(entry.id) }, entry.id));
-                                }), _jsx(ElevatorMeshButton, { action: "open-door", active: doorOpenButtonActive, buttonKind: "cab", elevatorId: elevatorId, faceSign: 1, glyph: "door-open", position: [cabDoorButtonX, cabDoorButtonY, 0.045], queued: false, radius: 0.047 })] })] }), entrySpans.map(({ entry, levelTopY }) => {
-                    const isCurrentLevel = activeLevelId === entry.id;
-                    const isDisabledLevel = disabledLevelIds.has(entry.id);
-                    const isServiceOnlyLevel = serviceOnlyLevelIds.has(entry.id);
-                    const isQueuedLevel = !isDisabledLevel && queuedLevelIds.has(entry.id);
-                    const isPendingLevel = pendingLevelId === entry.id;
-                    const showLandingReadout = isCurrentLevel || isPendingLevel || isQueuedLevel;
-                    return (_jsxs("group", { children: [_jsx(LandingDoorFrame, { doorHeight: doorHeight, doorWidth: doorWidth, levelTopY: levelTopY, levelY: entry.baseY, shaftWidth: shaftWidth, z: frontWallZ }), _jsx(LandingDoor, { animated: isCurrentLevel, doorPanelStyle: doorPanelStyle, doorStyle: doorStyle, elevatorId: elevatorId, doorHeight: doorHeight, doorOpen: isCurrentLevel ? doorOpen : 0, doorWidth: doorWidth, levelId: entry.id, levelY: entry.baseY, z: frontZ - 0.02 }), _jsx(ElevatorFloorIndicator, { active: showLandingReadout, direction: showLandingReadout ? indicatorDirection : null, label: entry.label, position: [0, entry.baseY + doorHeight + 0.16, frontZ - 0.055], scale: 0.62, showReadout: showLandingReadout }), _jsxs("group", { position: [landingPanelX, entry.baseY + panelRelativeY, frontZ - 0.035], children: [_jsx(BoxPrimitive, { castShadow: true, material: LANDING_PANEL_MATERIAL, receiveShadow: true, scale: [0.18, 0.42, 0.04] }), _jsx(ElevatorMeshButton, { active: !isDisabledLevel && !isServiceOnlyLevel && isCurrentLevel && doorOpen > 0.5, buttonKind: "landing", disabled: isDisabledLevel || isServiceOnlyLevel, elevatorId: elevatorId, levelId: entry.id, position: [0, 0.06, -0.045], queued: isQueuedLevel, radius: 0.045 }), _jsx(BoxPrimitive, { material: isQueuedLevel ? QUEUE_STRIP_MATERIALS.queued : QUEUE_STRIP_MATERIALS.idle, position: [0, -0.12, -0.035], scale: [0.095, 0.025, 0.012] })] })] }, entry.id));
-                })] }) }));
+    return (_jsx(ElevatorMaterialsContext.Provider, { value: materials, children: _jsxs(ElevatorCutawayContext.Provider, { value: cutaway, children: [_jsxs("group", { position: liveTransform?.position ?? renderNode.position, ref: ref, "rotation-y": liveTransform?.rotation ?? renderNode.rotation, visible: renderNode.visible, ...handlers, children: [_jsxs(StaticBoxes, { children: [_jsx(BoxPrimitive, { castShadow: true, material: shaftShellMaterial, position: [0, shaftBodyCenterY, shaftDepth / 2 + shaftWallThickness / 2], receiveShadow: true, scale: [shaftWidth + shaftWallThickness * 2, shaftBodyHeight, shaftWallThickness], slotId: shaftShellSlotId }), _jsx(BoxPrimitive, { castShadow: true, material: shaftShellMaterial, position: [-shaftWidth / 2 - shaftWallThickness / 2, shaftBodyCenterY, 0], receiveShadow: true, scale: [shaftWallThickness, shaftBodyHeight, shaftDepth + shaftWallThickness * 2], slotId: shaftShellSlotId }), _jsx(BoxPrimitive, { castShadow: true, material: shaftShellMaterial, position: [shaftWidth / 2 + shaftWallThickness / 2, shaftBodyCenterY, 0], receiveShadow: true, scale: [shaftWallThickness, shaftBodyHeight, shaftDepth + shaftWallThickness * 2], slotId: shaftShellSlotId }), _jsx(BoxPrimitive, { castShadow: true, material: shaftTopMaterial, position: [0, shaftBaseY + shaftHeight - shaftWallThickness / 2, 0], receiveShadow: true, scale: [
+                                        shaftWidth + shaftWallThickness * 2,
+                                        shaftWallThickness,
+                                        shaftDepth + shaftWallThickness * 2,
+                                    ], slotId: "shaft" })] }), _jsxs("group", { ref: cabRef, position: [0, cabBaseY, 0], children: [_jsxs(StaticBoxes, { children: [_jsx(BoxPrimitive, { castShadow: true, material: CAB_MATERIAL, position: [0, 0.04, cabCenterZ], receiveShadow: true, scale: [cabWidth, 0.08, cabDepth], slotId: "cab" }), _jsx(BoxPrimitive, { castShadow: true, material: CAB_MATERIAL, position: [0, cabHeight - 0.04, cabCenterZ], receiveShadow: true, scale: [cabWidth, 0.08, cabDepth], slotId: "cab" }), _jsx(BoxPrimitive, { castShadow: true, material: CAB_MATERIAL, position: [0, cabHeight / 2, cabCenterZ + cabDepth / 2 - 0.04], receiveShadow: true, scale: [cabWidth, cabHeight, 0.08], slotId: "cab" }), _jsx(BoxPrimitive, { castShadow: true, material: CAB_MATERIAL, position: [-cabWidth / 2 + 0.04, cabHeight / 2, cabCenterZ], receiveShadow: true, scale: [0.08, cabHeight, cabDepth], slotId: "cab" }), _jsx(BoxPrimitive, { castShadow: true, material: CAB_MATERIAL, position: [cabWidth / 2 - 0.04, cabHeight / 2, cabCenterZ], receiveShadow: true, scale: [0.08, cabHeight, cabDepth], slotId: "cab" })] }), _jsx("group", { name: "cab-door-surround", children: _jsxs(StaticBoxes, { children: [[-1, 1].map((side) => (_jsx(BoxPrimitive, { castShadow: true, material: CAB_MATERIAL, position: [
+                                                    side * (doorWidth / 2 + cabReturnWidth / 2),
+                                                    cabHeight / 2,
+                                                    cabDoorZ + 0.065,
+                                                ], receiveShadow: true, scale: [cabReturnWidth, cabHeight, 0.025], slotId: "cab" }, side))), _jsx(BoxPrimitive, { castShadow: true, material: CAB_MATERIAL, position: [0, (doorHeight + cabHeight) / 2, cabDoorZ + 0.065], receiveShadow: true, scale: [doorWidth, cabHeight - doorHeight, 0.025], slotId: "cab" })] }) }), _jsx(ElevatorDoorLeaves, { animated: { elevatorId, kind: 'cab' }, doorOpen: doorOpen, doorPanelStyle: doorPanelStyle, doorStyle: doorStyle, height: doorHeight, width: doorWidth, y: 0, z: cabDoorZ }), _jsx(ElevatorFloorIndicator, { active: indicatorActive, direction: indicatorDirection, faceSign: 1, label: indicatorEntry?.label ?? '-', position: [0, doorHeight + 0.13, cabDoorZ + 0.075], scale: 0.78 }), _jsxs("group", { position: [cabPanelX, cabPanelY, cabPanelZ], "rotation-y": -Math.PI / 2, children: [_jsx(BoxPrimitive, { castShadow: true, material: PANEL_MATERIAL, receiveShadow: true, scale: [cabPanelWidth, cabPanelHeight, 0.045] }), entries.map((entry, index) => {
+                                            const column = index % cabButtonColumns;
+                                            const row = Math.floor(index / cabButtonColumns);
+                                            const isDisabledLevel = disabledLevelIds.has(entry.id);
+                                            const x = cabFloorButtonOffsetX + (column - (cabButtonColumns - 1) / 2) * cabButtonSpacingX;
+                                            const y = (row - (cabButtonRows - 1) / 2) * cabButtonSpacingY;
+                                            return (_jsx(ElevatorMeshButton, { interactionEnabled: interactionEnabled, active: !isDisabledLevel && activeLevelId === entry.id, buttonKind: "cab", disabled: isDisabledLevel, elevatorId: elevatorId, faceSign: 1, label: entry.label, levelId: entry.id, position: [x, y, 0.045], queued: !isDisabledLevel && queuedLevelIds.has(entry.id), radius: Math.min(0.055, cabButtonSpacingX * 0.36, cabButtonSpacingY * 0.36) }, entry.id));
+                                        }), _jsx(ElevatorMeshButton, { interactionEnabled: interactionEnabled, action: "open-door", active: doorOpenButtonActive, buttonKind: "cab", elevatorId: elevatorId, faceSign: 1, glyph: "door-open", position: [cabDoorButtonX, cabDoorButtonY, 0.045], queued: false, radius: 0.047 })] })] }), entrySpans.map(({ entry, levelTopY }) => {
+                            const isCurrentLevel = activeLevelId === entry.id;
+                            const isDisabledLevel = disabledLevelIds.has(entry.id);
+                            const isServiceOnlyLevel = serviceOnlyLevelIds.has(entry.id);
+                            const isQueuedLevel = !isDisabledLevel && queuedLevelIds.has(entry.id);
+                            const isPendingLevel = pendingLevelId === entry.id;
+                            const showLandingReadout = isCurrentLevel || isPendingLevel || isQueuedLevel;
+                            return (_jsxs("group", { children: [_jsx(LandingDoorFrame, { doorHeight: doorHeight, doorWidth: doorWidth, levelTopY: levelTopY, levelY: entry.baseY, shaftWidth: shaftWidth, wallDepth: frontWallDepth, z: frontWallZ }), _jsx(LandingDoor, { animated: isCurrentLevel, doorPanelStyle: doorPanelStyle, doorStyle: doorStyle, elevatorId: elevatorId, doorHeight: doorHeight, doorOpen: isCurrentLevel ? doorOpen : 0, doorWidth: doorWidth, levelId: entry.id, levelY: entry.baseY, z: landingDoorZ }), _jsx(ElevatorFloorIndicator, { active: showLandingReadout, direction: showLandingReadout ? indicatorDirection : null, label: entry.label, position: [0, entry.baseY + doorHeight + 0.16, frontZ - 0.055], scale: 0.62, showReadout: showLandingReadout }), _jsxs("group", { name: "landing-call-panel", position: [landingPanelX, entry.baseY + panelRelativeY, frontZ - 0.035], children: [_jsx(BoxPrimitive, { castShadow: true, material: LANDING_PANEL_MATERIAL, receiveShadow: true, scale: [landingPanelWidth, 0.42, 0.04] }), _jsx(ElevatorMeshButton, { interactionEnabled: interactionEnabled, active: !isDisabledLevel && !isServiceOnlyLevel && isCurrentLevel && doorOpen > 0.5, buttonKind: "landing", disabled: isDisabledLevel || isServiceOnlyLevel, elevatorId: elevatorId, levelId: entry.id, position: [0, 0.06, -0.045], queued: isQueuedLevel, radius: Math.min(0.045, landingPanelWidth * 0.3) }), _jsx(BoxPrimitive, { material: isQueuedLevel ? QUEUE_STRIP_MATERIALS.queued : QUEUE_STRIP_MATERIALS.idle, position: [0, -0.12, -0.035], scale: [Math.min(0.095, landingPanelWidth * 0.6), 0.025, 0.012] })] })] }, entry.id));
+                        })] }), _jsx(ElevatorInspectionOverlay, { node: renderNode, source: ref })] }) }));
 };
 export default ElevatorRenderer;

package/dist/elevator/tool.d.ts

@@ -0,0 +1,2 @@
+export default function ElevatorTool(): import("react").JSX.Element;
+//# sourceMappingURL=tool.d.ts.map

package/dist/elevator/tool.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/elevator/tool.tsx"],"names":[],"mappings":"AAsIA,MAAM,CAAC,OAAO,UAAU,YAAY,gCAyPnC"}