@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/elevator/definition.render.js

@@ -0,0 +1,96 @@
+import { ElevatorNode as ElevatorNodeSchema, elevatorSlots, getElevatorCabDepth, getElevatorCabWidth, getElevatorShaftDepth, getElevatorShaftWallThickness, getElevatorShaftWidth, resolveElevatorDimensions, resolveElevatorLevels, resolveElevatorNodeSupportY, } from '@pascal-app/core';
+import { ElevatorNode } from './schema.js';
+export function elevatorOuterHalfExtents(n) {
+    const cabWidth = getElevatorCabWidth(n);
+    const cabDepth = getElevatorCabDepth(n);
+    const wallThickness = getElevatorShaftWallThickness(n);
+    return {
+        halfX: getElevatorShaftWidth(n, cabWidth) / 2 + wallThickness,
+        halfZ: getElevatorShaftDepth(n, cabDepth) / 2 + wallThickness,
+    };
+}
+export const elevatorRenderDefinition = {
+    kind: 'elevator',
+    schemaVersion: 1,
+    schema: ElevatorNode,
+    category: 'structure',
+    surfaceRole: 'joinery',
+    defaults: () => {
+        const stub = ElevatorNodeSchema.parse({ id: 'elevator_default', type: 'elevator' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        surfacePlacement: 'floor-only',
+        selectable: { hitVolume: 'bbox' },
+        // Generic XZ translate so the floating action menu's Move button
+        // (and the side move-arrows emitted from `def.floorplan`) drive the
+        // 2D body-move flow through `FloorplanRegistryMoveOverlay`'s
+        // Path 2 — position[0] / position[2] update with a 0.5m grid snap.
+        movable: {
+            axes: ['x', 'z'],
+            gridSnap: true,
+            resolvePosition: ({ node, position, nodes }) => [
+                position[0],
+                resolveElevatorNodeSupportY(node, position, nodes),
+                position[2],
+            ],
+        },
+        // Align by the OUTER SHAFT (shaft + wall — what's drawn in plan and 3D),
+        // not the cab `width × depth`: the cab is inset by the shaft wall +
+        // clearance, so cab corners sit ~9 cm inside the visible edge — past the
+        // 8 cm snap, which is why the elevator never surfaced a guide. A `box`
+        // shape (not `aabb`) because the elevator is `movable`, so the anchor
+        // bridge relocates this same footprint to the drag point.
+        alignmentFootprint: (node) => {
+            const e = node;
+            const { halfX, halfZ } = elevatorOuterHalfExtents(e);
+            return {
+                shape: 'box',
+                dimensions: [halfX * 2, 1, halfZ * 2],
+                rotation: [0, e.rotation ?? 0, 0],
+            };
+        },
+        // Drag box wraps just the OUTER SHAFT × full shaft height — same footprint
+        // alignment uses, same height the rendered shell occupies. Without this
+        // override, `DragBoundingBox` would measure the whole mesh tree (per-level
+        // landing assemblies, cab interior, buttons) and the box would feel
+        // vertically off-centre when the elevator's lowest served level isn't the
+        // building origin.
+        dragBounds: (node, nodes) => {
+            const e = node;
+            const { halfX, halfZ } = elevatorOuterHalfExtents(e);
+            const { shaftBaseY, totalHeight } = resolveElevatorLevels(e, nodes ?? {});
+            const cabHeight = resolveElevatorDimensions(e).cabHeight;
+            const shaftHeight = Math.max(totalHeight, cabHeight + 0.3);
+            return {
+                size: [halfX * 2, shaftHeight, halfZ * 2],
+                centerY: shaftBaseY + shaftHeight / 2,
+            };
+        },
+        duplicable: true,
+        deletable: true,
+        slots: (node) => elevatorSlots(node),
+    },
+    // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
+    dirtyTracking: false,
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        priority: 3,
+    },
+    presentation: {
+        label: 'Elevator',
+        description: 'A multi-level elevator shaft with configurable openings per level.',
+        icon: { kind: 'url', src: '/icons/elevator.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 80,
+    },
+    mcp: {
+        description: 'A multi-level elevator with shaft + openings per level.',
+    },
+};

package/dist/elevator/floorplan-affordances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/elevator/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EAGzB,MAAM,kBAAkB,CAAA;AAQzB;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,YAAY,CA8CtE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,YAAY,CAgCtE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/elevator/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,YAAY,EACjB,KAAK,mBAAmB,EAKzB,MAAM,kBAAkB,CAAA;AAQzB;;;;;;GAMG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,YAAY,CAuDtE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,YAAY,CAgCtE,CAAA"}

package/dist/elevator/floorplan-affordances.js

@@ -1,7 +1,7 @@
-import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { ELEVATOR_MIN_CAB_DIMENSION, normalizeElevatorDimensions, resolveElevatorDimensions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { isAngleSnapActive } from '@pascal-app/editor';
 import { rotateAffordanceDelta } from '../shared/rotate-affordance.js';
-const MIN_ELEVATOR_DIM = 0.6;
+const MIN_ELEVATOR_DIM = ELEVATOR_MIN_CAB_DIMENSION;
 /**
  * Elevator width / depth drag (floor-plan). Mirrors the 3D
  * `linear-resize` handles declared in `definition.ts` — `anchor: 'center'`
@@ -13,7 +13,7 @@ export const elevatorResizeAffordance = {
     start({ node, payload, initialPlanPoint }) {
         const { axis, side } = payload;
         const elevatorId = node.id;
-        const initialValue = axis === 'x' ? node.width : node.depth;
+        const initialValue = axis === 'x' ? resolveElevatorDimensions(node).width : resolveElevatorDimensions(node).depth;
         const cx = node.position[0];
         const cz = node.position[2];
         const rotation = node.rotation ?? 0;
@@ -38,9 +38,10 @@ export const elevatorResizeAffordance = {
                 const delta = (currentLocal - initialLocal) * side;
                 const newValue = Math.max(MIN_ELEVATOR_DIM, initialValue + 2 * delta);
                 lastValue = newValue;
-                useLiveNodeOverrides
-                    .getState()
-                    .set(elevatorId, axis === 'x' ? { width: newValue } : { depth: newValue });
+                useLiveNodeOverrides.getState().set(elevatorId, normalizeElevatorDimensions({
+                    ...node,
+                    ...(axis === 'x' ? { width: newValue } : { depth: newValue }),
+                }));
                 useScene.getState().markDirty(elevatorId);
             },
             canCommit() {
@@ -48,9 +49,10 @@ export const elevatorResizeAffordance = {
             },
             commit() {
                 useLiveNodeOverrides.getState().clear(elevatorId);
-                useScene
-                    .getState()
-                    .updateNode(elevatorId, axis === 'x' ? { width: lastValue } : { depth: lastValue });
+                useScene.getState().updateNode(elevatorId, normalizeElevatorDimensions({
+                    ...node,
+                    ...(axis === 'x' ? { width: lastValue } : { depth: lastValue }),
+                }));
             },
         };
     },

package/dist/elevator/floorplan.d.ts

@@ -1,3 +1,22 @@
 import { type ElevatorNode, type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
+/**
+ * Stage C floor-plan emitter for elevator. Architectural symbol style:
+ *
+ *  - **Outer shaft outline** — outer face of the shaft wall.
+ *  - **Inner shaft outline** — inner face of the shaft wall, offset
+ *    inward by `shaftWallThickness`. The two outlines together read as
+ *    a hollow wall in plan.
+ *  - **Dashed X** — two diagonals across the shaft interior, the
+ *    universal architectural mark for an elevator cab.
+ *  - **Door opening** — two small jamb stubs flanking the opening at
+ *    the front face, with a dashed line spanning the opening (the
+ *    closed door).
+ *  - **Selection / runtime chrome** — selected → palette stroke;
+ *    cab-on-level → green tint on the X; target/queued → sky accent.
+ *
+ * Reads live overrides (`useLiveNodeOverrides`) and runtime cab state
+ * (`useInteractive.elevators[id]`) non-reactively; the registry layer
+ * subscribes to both stores so this builder re-runs on change.
+ */
 export declare function buildElevatorFloorplan(node: ElevatorNode, ctx: GeometryContext): FloorplanGeometry | null;
 //# sourceMappingURL=floorplan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/elevator/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIrB,MAAM,kBAAkB,CAAA;AAwBzB,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAwU1B"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/elevator/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,EACjB,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAKrB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;;;;;;GAkBG;AAEH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,YAAY,EAClB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAwU1B"}

package/dist/elevator/floorplan.js

@@ -1,4 +1,4 @@
-import { resolveElevatorServiceLevelIds, useInteractive, useLiveNodeOverrides, } from '@pascal-app/core';
+import { resolveElevatorDimensions, resolveElevatorServiceLevelIds, useInteractive, useLiveNodeOverrides, } from '@pascal-app/core';
 /**
  * Stage C floor-plan emitter for elevator. Architectural symbol style:
  *
@@ -18,7 +18,6 @@ import { resolveElevatorServiceLevelIds, useInteractive, useLiveNodeOverrides, }
  * (`useInteractive.elevators[id]`) non-reactively; the registry layer
  * subscribes to both stores so this builder re-runs on change.
  */
-const STAGE_LEVEL_FILTER_HIDE = false;
 export function buildElevatorFloorplan(node, ctx) {
     // Merge in any live overrides (inspector edits not yet committed).
     const overrides = useLiveNodeOverrides.getState().get(node.id);
@@ -29,19 +28,14 @@ export function buildElevatorFloorplan(node, ctx) {
     // hosted on, which is the active level when the registry layer walks
     // from `levelId`).
     const parentLevelId = ctx.parent?.id;
-    if (STAGE_LEVEL_FILTER_HIDE && parentLevelId) {
+    if (parentLevelId) {
         const sceneNodes = collectAllNodes(ctx);
         const serviceLevelIds = resolveElevatorServiceLevelIds(display, sceneNodes);
         if (!serviceLevelIds.includes(parentLevelId)) {
             return null;
         }
     }
-    const wallThickness = Math.max(display.shaftWallThickness ?? 0.09, 0.04);
-    const cabWidth = Math.max(display.width, 0.8);
-    const cabDepth = Math.max(display.depth, 0.8);
-    const shaftWidth = Math.max(display.shaftWidth ?? display.width, cabWidth, 0.8);
-    const shaftDepth = Math.max(display.shaftDepth ?? display.depth, cabDepth, 0.8);
-    const doorWidth = Math.min(Math.max(display.doorWidth, 0.45), shaftWidth - 0.24);
+    const { shaftWallThickness: wallThickness, shaftWidth, shaftDepth, doorWidth, } = resolveElevatorDimensions(display);
     const outerHalfW = Math.max(0.1, shaftWidth / 2 + wallThickness);
     const outerHalfD = Math.max(0.1, shaftDepth / 2 + wallThickness);
     const innerHalfW = Math.max(0.05, shaftWidth / 2);

package/dist/elevator/inspection.d.ts

@@ -0,0 +1,17 @@
+import type { AnyNodeId, ElevatorNode, ElevatorSlotId } from '@pascal-app/core';
+import { type ReactNode, type RefObject } from 'react';
+import { type Group } from 'three';
+export declare const useElevatorInspection: import("zustand").UseBoundStore<import("zustand").StoreApi<{
+    nodeId: AnyNodeId | null;
+    cutaway: boolean;
+    part: ElevatorSlotId | null;
+}>>;
+export declare function ElevatorInspectorHover({ nodeId, children, }: {
+    nodeId: AnyNodeId;
+    children: ReactNode;
+}): import("react").JSX.Element;
+export declare function ElevatorInspectionOverlay({ node, source, }: {
+    node: ElevatorNode;
+    source: RefObject<Group | null>;
+}): import("react").JSX.Element;
+//# sourceMappingURL=inspection.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"inspection.d.ts","sourceRoot":"","sources":["../../src/elevator/inspection.tsx"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,YAAY,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAG/E,OAAO,EAAE,KAAK,SAAS,EAAE,KAAK,SAAS,EAAqB,MAAM,OAAO,CAAA;AACzE,OAAO,EAAE,KAAK,KAAK,EAAiB,MAAM,OAAO,CAAA;AAIjD,eAAO,MAAM,qBAAqB;YACxB,SAAS,GAAG,IAAI;aACf,OAAO;UACV,cAAc,GAAG,IAAI;GAC2B,CAAA;AAExD,wBAAgB,sBAAsB,CAAC,EACrC,MAAM,EACN,QAAQ,GACT,EAAE;IACD,MAAM,EAAE,SAAS,CAAA;IACjB,QAAQ,EAAE,SAAS,CAAA;CACpB,+BAmCA;AAED,wBAAgB,yBAAyB,CAAC,EACxC,IAAI,EACJ,MAAM,GACP,EAAE;IACD,IAAI,EAAE,YAAY,CAAA;IAClB,MAAM,EAAE,SAAS,CAAC,KAAK,GAAG,IAAI,CAAC,CAAA;CAChC,+BA+CA"}

package/dist/elevator/inspection.js

@@ -0,0 +1,78 @@
+import { jsx as _jsx } from "react/jsx-runtime";
+import { OVERLAY_LAYER } from '@pascal-app/viewer';
+import { useFrame } from '@react-three/fiber';
+import { useEffect, useRef } from 'react';
+import { Matrix4, Mesh } from 'three';
+import { MeshBasicNodeMaterial } from 'three/webgpu';
+import { create } from 'zustand';
+export const useElevatorInspection = create(() => ({ nodeId: null, cutaway: false, part: null }));
+export function ElevatorInspectorHover({ nodeId, children, }) {
+    useEffect(() => {
+        useElevatorInspection.setState({ nodeId, part: null, cutaway: false });
+        const clear = () => useElevatorInspection.setState({ part: null });
+        const onEscape = (event) => {
+            if (event.key === 'Escape')
+                clear();
+        };
+        window.addEventListener('blur', clear);
+        window.addEventListener('keydown', onEscape);
+        return () => {
+            window.removeEventListener('blur', clear);
+            window.removeEventListener('keydown', onEscape);
+            useElevatorInspection.setState({ nodeId: null, part: null, cutaway: false });
+        };
+    }, [nodeId]);
+    const highlight = (element) => {
+        const slot = element instanceof Element
+            ? element.closest('[data-elevator-part]')?.dataset.elevatorPart
+            : undefined;
+        useElevatorInspection.setState({
+            part: slot === 'cab' || slot === 'doors' || slot === 'shaft' || slot === 'glass' ? slot : null,
+        });
+    };
+    return (_jsx("div", { onPointerOver: (event) => highlight(event.target), onPointerLeave: () => highlight(null), onFocusCapture: (event) => highlight(event.target), onBlurCapture: (event) => highlight(event.relatedTarget), children: children }));
+}
+export function ElevatorInspectionOverlay({ node, source, }) {
+    const ref = useRef(null);
+    const part = useElevatorInspection((state) => (state.nodeId === node.id ? state.part : null));
+    const copies = useRef([]);
+    useEffect(() => {
+        if (!part || !ref.current || !source.current || !node.id)
+            return;
+        const target = ref.current;
+        const fill = new MeshBasicNodeMaterial({
+            color: '#38bdf8',
+            opacity: 0.3,
+            transparent: true,
+            depthWrite: false,
+            depthTest: false,
+        });
+        source.current.traverse((object) => {
+            if (!(object instanceof Mesh) || object.userData.slotId !== part)
+                return;
+            const copy = new Mesh(object.geometry, fill);
+            copy.matrixAutoUpdate = false;
+            copy.layers.set(OVERLAY_LAYER);
+            copy.raycast = () => { };
+            copy.userData.pascalExport = 'strip';
+            target.add(copy);
+            copies.current.push({ source: object, copy });
+        });
+        return () => {
+            target.clear();
+            copies.current = [];
+            fill.dispose();
+        };
+    }, [part, source, node]);
+    useFrame(() => {
+        if (!part || !ref.current)
+            return;
+        ref.current.updateWorldMatrix(true, false);
+        const inverse = new Matrix4().copy(ref.current.matrixWorld).invert();
+        for (const pair of copies.current) {
+            pair.source.updateWorldMatrix(true, false);
+            pair.copy.matrix.multiplyMatrices(inverse, pair.source.matrixWorld);
+        }
+    });
+    return (_jsx("group", { ref: ref, name: "elevator-inspector-highlight", userData: { pascalExport: 'strip' }, dispose: null }));
+}

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/elevator/panel.tsx"],"names":[],"mappings":"AAqJA,MAAM,CAAC,OAAO,UAAU,aAAa,uCAkvBpC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/elevator/panel.tsx"],"names":[],"mappings":"AAwOA,MAAM,CAAC,OAAO,UAAU,aAAa,uCAk5BpC"}