@pascal-app/nodes 0.1.1

package/dist/duct-terminal/tool.js

@@ -0,0 +1,360 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { DuctTerminalNode, emitter, pointInPolygon, resolveLevelId, sceneRegistry, useScene, } from '@pascal-app/core';
+import { CursorSphere, getFloorStackPreviewPosition, isGridSnapActive, isMagneticSnapActive, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { Html } from '@react-three/drei';
+import { useThree } from '@react-three/fiber';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { Euler, Matrix3, Matrix4, Plane, Quaternion, Raycaster, Vector2, Vector3 } from 'three';
+import { alignDrawPoint, clearDrawAlignment } from '../shared/draw-alignment';
+import { LevelOffsetGroup } from '../shared/level-offset-group';
+import { collectScenePorts, DUCT_PORT_SYSTEMS, findNearestPortXZ } from '../shared/ports';
+import { ductTerminalDefinition } from './definition';
+import { buildDuctTerminalGeometry } from './geometry';
+import { COLLAR_LENGTH, mountQuaternion } from './ports';
+const PREVIEW_OPACITY = 0.55;
+/** R/T yaw step — 45°. */
+const ROTATE_STEP_RAD = Math.PI / 4;
+/** Fallback height (meters) for a ceiling node that carries no `height`. */
+const DEFAULT_CEILING_HEIGHT = 2.5;
+/** Snap radius (meters) for mating the collar onto a nearby duct port. */
+const PORT_SNAP_RADIUS_M = 0.5;
+const MOUNT_CYCLE = ['floor', 'ceiling', 'wall'];
+function snap(value, step) {
+    if (step <= 0)
+        return value;
+    return Math.round(value / step) * step;
+}
+/**
+ * Collar-port offset from the node origin for a given mount + yaw, in
+ * level-local meters — the same transform `def.ports` applies, so the
+ * placement tool can predict where the collar lands and shift the whole
+ * terminal to mate it onto a duct port.
+ */
+function collarOffset(mount, yaw) {
+    const transform = new Quaternion()
+        .setFromEuler(new Euler(0, yaw, 0))
+        .multiply(mountQuaternion(mount));
+    return new Vector3(0, -COLLAR_LENGTH, 0).applyQuaternion(transform);
+}
+/** The active level's mesh, or null. Carries the building transform plus the
+ *  level's stacked elevation — the frame terminals are stored and parented in,
+ *  so cursor hits resolve to true level-local coords on every floor. */
+function activeLevelMesh() {
+    const levelId = useViewer.getState().selection.levelId;
+    return levelId ? (sceneRegistry.nodes.get(levelId) ?? null) : null;
+}
+/** Direction is "vertical" when its Y component dominates this much. */
+const VERTICAL_DOT = 0.7;
+/**
+ * Pick the mount that makes a collar mate onto a duct port pointing
+ * `dir` (the port's outward direction). The collar leaves the face along
+ * −Y in the canonical frame, so the mount rotation must turn −Y to face
+ * *into* the port (i.e. opposite `dir`):
+ *   - port pointing up (a riser top) → collar must point down → **floor**
+ *   - port pointing down (a ceiling drop) → collar points up → **ceiling**
+ *   - port horizontal (a wall stub) → **wall**, yawed so the collar runs
+ *     back along the port. `lockYaw` is set only for wall (floor / ceiling
+ *     yaw is free — the user keeps spinning the face with R/T).
+ */
+function inferMountFromPort(dir) {
+    const v = new Vector3(dir[0], dir[1], dir[2]);
+    if (v.lengthSq() < 1e-8)
+        return { mount: 'floor', lockYaw: null };
+    v.normalize();
+    if (v.y > VERTICAL_DOT)
+        return { mount: 'floor', lockYaw: null };
+    if (v.y < -VERTICAL_DOT)
+        return { mount: 'ceiling', lockYaw: null };
+    // Wall collar dir after mount + yaw is (−sin yaw, 0, −cos yaw); set it
+    // opposite the port so the collar runs back into the wall stub.
+    return { mount: 'wall', lockYaw: Math.atan2(v.x, v.z) };
+}
+/**
+ * If a duct port is within snap range of `position` (XZ — ports hang at
+ * duct height, the grid hit rides the floor), mate the register onto it:
+ * the port's direction *picks the mount* (floor / ceiling / wall) and, for
+ * walls, the yaw; the whole terminal then hops so its collar lands exactly
+ * on the port. Null when nothing is in range. `fallbackYaw` keeps the
+ * user's R/T face orientation for floor / ceiling mounts.
+ */
+function resolvePortSnap(position, fallbackYaw) {
+    const port = findNearestPortXZ(position, collectScenePorts({ systems: DUCT_PORT_SYSTEMS }), PORT_SNAP_RADIUS_M);
+    if (!port)
+        return null;
+    const { mount, lockYaw } = inferMountFromPort(port.direction);
+    const yaw = lockYaw ?? fallbackYaw;
+    const offset = collarOffset(mount, yaw);
+    return {
+        position: [
+            port.position[0] - offset.x,
+            port.position[1] - offset.y,
+            port.position[2] - offset.z,
+        ],
+        mount,
+        yaw,
+    };
+}
+/**
+ * Click-place tool for duct terminals (registers / diffusers / grilles).
+ *
+ * **Mount drives the target surface** (cycle with **M**): a floor register
+ * snaps to the floor grid, a ceiling diffuser snaps to a horizontal plane at
+ * ceiling height (derived from the level's ceilings/walls), and a wall
+ * register snaps flush onto whichever wall the cursor is over, its face
+ * oriented along the wall's outward normal. **R / T** rotate the floor/ceiling
+ * yaw ±45°; wall yaw is fixed by the wall it mates to.
+ */
+const DuctTerminalTool = () => {
+    const { camera, gl } = useThree();
+    const activeLevelId = useViewer((s) => s.selection.levelId);
+    const [mount, setMount] = useState('floor');
+    const [placement, setPlacement] = useState(null);
+    const mountRef = useRef('floor');
+    const yawRef = useRef(0);
+    const raycaster = useRef(new Raycaster());
+    const pointer = useRef(new Vector2());
+    // The ghost mirrors whatever mount will actually be committed: a snap can
+    // override the manual M selection (port direction picks floor / ceiling /
+    // wall), so the preview must show the inferred mount, not the toolbar one.
+    const effectiveMount = placement?.mount ?? mount;
+    const previewNode = useMemo(() => DuctTerminalNode.parse({
+        ...ductTerminalDefinition.defaults(),
+        name: 'Register',
+        mount: effectiveMount,
+    }), [effectiveMount]);
+    const ghost = useMemo(() => {
+        const group = buildDuctTerminalGeometry(previewNode);
+        group.traverse((child) => {
+            const mesh = child;
+            if (mesh.material) {
+                mesh.material.transparent = true;
+                mesh.material.opacity = PREVIEW_OPACITY;
+            }
+        });
+        return group;
+    }, [previewNode]);
+    useEffect(() => {
+        if (!activeLevelId)
+            return;
+        const canvas = gl.domElement;
+        /**
+         * Intersect the cursor ray with a level-local horizontal plane at `y`.
+         * The ray is transformed into level-local space first (building transform
+         * plus the floor's stacked elevation), so the hit is already in the frame
+         * terminals are stored and parented in — accurate on every floor.
+         */
+        const hitLocalPlane = (nativeEvent, y) => {
+            const rect = canvas.getBoundingClientRect();
+            pointer.current.x = ((nativeEvent.clientX - rect.left) / rect.width) * 2 - 1;
+            pointer.current.y = -((nativeEvent.clientY - rect.top) / rect.height) * 2 + 1;
+            raycaster.current.setFromCamera(pointer.current, camera);
+            const level = activeLevelMesh();
+            const ray = raycaster.current.ray.clone();
+            if (level) {
+                const inv = new Matrix4().copy(level.matrixWorld).invert();
+                ray.applyMatrix4(inv);
+            }
+            const plane = new Plane(new Vector3(0, 1, 0), -y);
+            const hit = new Vector3();
+            return ray.intersectPlane(plane, hit) ? hit : null;
+        };
+        /**
+         * Ceiling mount only lands where the cursor ray actually hits a real
+         * ceiling. Walk the active level's ceiling nodes, raycast each against a
+         * plane at its own height, and keep the lowest one whose polygon (minus
+         * holes) contains the hit — the surface you'd see looking up. Null when
+         * the ray misses every ceiling, so a ceiling register never drops onto a
+         * fixed virtual plane; the height comes from the ceiling itself.
+         */
+        const resolveCeilingHit = (nativeEvent) => {
+            const nodes = useScene.getState().nodes;
+            let best = null;
+            for (const node of Object.values(nodes)) {
+                if (node?.type !== 'ceiling')
+                    continue;
+                if (resolveLevelId(node, nodes) !== activeLevelId)
+                    continue;
+                const ceiling = node;
+                const height = ceiling.height ?? DEFAULT_CEILING_HEIGHT;
+                const hit = hitLocalPlane(nativeEvent, height);
+                if (!hit)
+                    continue;
+                if (!pointInPolygon(hit.x, hit.z, ceiling.polygon))
+                    continue;
+                if (ceiling.holes?.some((h) => h.length >= 3 && pointInPolygon(hit.x, hit.z, h)))
+                    continue;
+                if (!best || height < best.height)
+                    best = { hit, height };
+            }
+            return best;
+        };
+        const resolvePlanar = (nativeEvent) => {
+            // Floor sits on the grid (y=0; the slab lift is applied to the committed
+            // mesh by FloorElevationSystem). Ceiling resolves the real ceiling the
+            // ray hits and takes that surface's height — no fixed fallback plane.
+            let hit;
+            let y;
+            if (mountRef.current === 'ceiling') {
+                const ceiling = resolveCeilingHit(nativeEvent);
+                if (!ceiling)
+                    return null;
+                hit = ceiling.hit;
+                y = ceiling.height;
+            }
+            else {
+                y = 0;
+                hit = hitLocalPlane(nativeEvent, y);
+            }
+            if (!hit)
+                return null;
+            const step = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+            // Grid-snap, then layer Figma-style alignment so a floor / ceiling
+            // register lines up with ducts, equipment, and items. Grid + lines
+            // follow the active snapping mode (the contextual HUD chip — Shift
+            // cycles it); `'off'` is the no-snap bypass.
+            const position = alignDrawPoint([snap(hit.x, step), y, snap(hit.z, step)], {
+                applySnap: isMagneticSnapActive(),
+                bypass: false,
+            });
+            // Magnetic port snap: if a duct run end / fitting collar is in range,
+            // the port's direction picks the mount (floor / ceiling / wall) and
+            // hops the whole register so its collar mates exactly onto it. Takes
+            // precedence over grid / alignment and the manual M mount; the
+            // raw-cursor `'off'` mode bypasses it.
+            const snapEnabled = isGridSnapActive() || isMagneticSnapActive();
+            if (snapEnabled) {
+                const mated = resolvePortSnap(position, yawRef.current);
+                if (mated) {
+                    return { position: mated.position, yaw: mated.yaw, mount: mated.mount, snapped: true };
+                }
+            }
+            return { position, yaw: yawRef.current, mount: mountRef.current };
+        };
+        const commit = (p) => {
+            const terminal = DuctTerminalNode.parse({
+                ...ductTerminalDefinition.defaults(),
+                name: 'Register',
+                mount: p.mount,
+                position: p.position,
+                rotation: p.yaw,
+            });
+            useScene.getState().createNode(terminal, activeLevelId);
+            useViewer.getState().setSelection({ selectedIds: [terminal.id] });
+            triggerSFX('sfx:item-place');
+        };
+        // ---- Floor / ceiling: own raycast against a horizontal plane ----
+        const onPointerMove = (e) => {
+            if (mountRef.current === 'wall')
+                return;
+            setPlacement(resolvePlanar(e));
+        };
+        const onCanvasClick = (e) => {
+            if (mountRef.current === 'wall')
+                return;
+            if (useViewer.getState().cameraDragging)
+                return;
+            if (e.button !== undefined && e.button !== 0)
+                return;
+            const p = resolvePlanar(e);
+            if (p)
+                commit(p);
+        };
+        // ---- Wall: consume wall hover/click events, orient to the wall ----
+        const resolveWall = (event) => {
+            if (!event.normal)
+                return null;
+            // Wall faces are the ±Z faces in wall-local space; skip the thin
+            // top / end caps so the terminal only mounts onto a real face.
+            if (Math.abs(event.normal[2]) <= 0.7)
+                return null;
+            const worldNormal = new Vector3(event.normal[0], event.normal[1], event.normal[2])
+                .applyNormalMatrix(new Matrix3().getNormalMatrix(event.object.matrixWorld))
+                .normalize();
+            // Face normal after the wall mount + yaw is (sin yaw, 0, cos yaw);
+            // align it with the wall's outward world normal.
+            const yaw = Math.atan2(worldNormal.x, worldNormal.z);
+            const world = new Vector3(event.position[0], event.position[1], event.position[2]);
+            const level = activeLevelMesh();
+            const local = level ? level.worldToLocal(world.clone()) : world;
+            return { position: [local.x, local.y, local.z], yaw, mount: 'wall' };
+        };
+        const onWallMove = (event) => {
+            if (mountRef.current !== 'wall')
+                return;
+            // Wall-mounted terminals snap flush to the wall — no plan alignment.
+            clearDrawAlignment();
+            const p = resolveWall(event);
+            if (p)
+                setPlacement(p);
+        };
+        const onWallClick = (event) => {
+            if (mountRef.current !== 'wall')
+                return;
+            if (useViewer.getState().cameraDragging)
+                return;
+            const p = resolveWall(event);
+            if (p)
+                commit(p);
+        };
+        const onKeyDown = (e) => {
+            const tag = e.target?.tagName;
+            if (tag === 'INPUT' || tag === 'TEXTAREA')
+                return;
+            const key = e.key;
+            if (key === 'm' || key === 'M') {
+                e.preventDefault();
+                e.stopPropagation();
+                const next = MOUNT_CYCLE[(MOUNT_CYCLE.indexOf(mountRef.current) + 1) % MOUNT_CYCLE.length];
+                mountRef.current = next;
+                setMount(next);
+                // Wall placement only resolves over a wall; clear the stale ghost.
+                if (next === 'wall')
+                    setPlacement(null);
+                triggerSFX('sfx:item-rotate');
+                return;
+            }
+            if (key !== 'r' && key !== 'R' && key !== 't' && key !== 'T')
+                return;
+            // Wall yaw is dictated by the wall, so R/T only apply to planar mounts.
+            if (mountRef.current === 'wall')
+                return;
+            e.preventDefault();
+            e.stopPropagation();
+            const steps = key === 't' || key === 'T' || e.shiftKey ? -1 : 1;
+            yawRef.current += steps * ROTATE_STEP_RAD;
+            setPlacement((prev) => (prev ? { ...prev, yaw: yawRef.current } : prev));
+            triggerSFX('sfx:item-rotate');
+        };
+        canvas.addEventListener('pointermove', onPointerMove);
+        canvas.addEventListener('click', onCanvasClick);
+        emitter.on('wall:move', onWallMove);
+        emitter.on('wall:click', onWallClick);
+        window.addEventListener('keydown', onKeyDown, true);
+        return () => {
+            canvas.removeEventListener('pointermove', onPointerMove);
+            canvas.removeEventListener('click', onCanvasClick);
+            emitter.off('wall:move', onWallMove);
+            emitter.off('wall:click', onWallClick);
+            window.removeEventListener('keydown', onKeyDown, true);
+            clearDrawAlignment();
+        };
+    }, [activeLevelId, camera, gl]);
+    if (!activeLevelId || !placement)
+        return null;
+    const mountLabel = effectiveMount.charAt(0).toUpperCase() + effectiveMount.slice(1);
+    // The committed mesh's slab lift is applied by FloorElevationSystem, but the
+    // ghost renders here directly — preview it on the slab top too so a floor
+    // register doesn't appear to sink in before the click.
+    const previewPosition = effectiveMount === 'floor'
+        ? getFloorStackPreviewPosition({
+            node: previewNode,
+            position: placement.position,
+            rotation: placement.yaw,
+            levelId: activeLevelId,
+        })
+        : placement.position;
+    return (_jsxs(LevelOffsetGroup, { children: [_jsx(CursorSphere, { position: previewPosition }), _jsx("group", { position: previewPosition, rotation: [0, placement.yaw, 0], children: _jsx("primitive", { object: ghost }) }), _jsx(Html, { center: true, position: [previewPosition[0], previewPosition[1] + 1.45, previewPosition[2]], style: { pointerEvents: 'none', userSelect: 'none' }, zIndexRange: [100, 0], children: _jsxs("div", { className: "flex items-center gap-2 whitespace-nowrap rounded-full border border-border/60 bg-background/90 px-4 py-1.5 text-xs tabular-nums shadow-sm backdrop-blur", children: [placement.snapped && (_jsxs(_Fragment, { children: [_jsx("span", { className: "font-medium text-primary", children: "Snapped to duct" }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" })] })), _jsxs("span", { className: "font-medium text-foreground", children: ["Mount ", mountLabel] }), _jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "M surface" }), effectiveMount !== 'wall' && (_jsxs(_Fragment, { children: [_jsx("span", { "aria-hidden": true, className: "text-muted-foreground", children: "\u00B7" }), _jsx("span", { className: "text-muted-foreground", children: "R/T rotate" })] }))] }) })] }));
+};
+export default DuctTerminalTool;

package/dist/elevator/definition.d.ts

@@ -0,0 +1,11 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { ElevatorNode } from './schema';
+/**
+ * Elevator — Stage A registration. Wrap-exports the legacy renderer +
+ * the three legacy systems (runtime / interaction / opening) bundled
+ * as one `def.system`. Move / inspector still go through legacy
+ * (`MoveElevatorTool`, `<ElevatorPanel>`) via panel-manager's
+ * hardcoded switch.
+ */
+export declare const elevatorDefinition: NodeDefinition<typeof ElevatorNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/elevator/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EASL,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AAKzB,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAsJvC;;;;;;GAMG;AACH,eAAO,MAAM,kBAAkB,EAAE,cAAc,CAAC,OAAO,YAAY,CA2GlE,CAAA"}

package/dist/elevator/definition.js

@@ -0,0 +1,255 @@
+import { ElevatorNode as ElevatorNodeSchema, getElevatorCabDepth, getElevatorCabWidth, getElevatorShaftDepth, getElevatorShaftWallThickness, getElevatorShaftWidth, resolveElevatorLevels, } from '@pascal-app/core';
+import { buildElevatorFloorplan } from './floorplan';
+import { elevatorResizeAffordance, elevatorRotateAffordance } from './floorplan-affordances';
+import { elevatorPaint } from './paint';
+import { elevatorParametrics } from './parametrics';
+import { ElevatorNode } from './schema';
+import { elevatorSlots } from './slots';
+const SIDE_HANDLE_OFFSET = 0.22;
+const HEIGHT_HANDLE_OFFSET = 0.3;
+const MOVE_FRONT_OFFSET = 0.35;
+const MIN_ELEVATOR_DIM = 0.6;
+const MIN_CAB_HEIGHT = 1.4;
+const ROTATE_CORNER_OFFSET = 0.4;
+const ROTATE_RING_OFFSET = 0.08;
+// Symmetric width / depth arrows around the cab footprint. The descriptor
+// edits the CAB dimension (`width` / `depth`) — but the arrow must sit
+// outside the SHAFT shell so it doesn't disappear inside the rendered
+// elevator. Placement uses the shaft's outer extent + wall thickness +
+// padding so the arrow clears the visible body on both `solid` and
+// `glass` shafts. `anchor: 'center'` means dragging outward grows the
+// full span 2× the pointer delta; node.position stays put.
+function elevatorAxisHandle(axis) {
+    return {
+        kind: 'linear-resize',
+        axis,
+        anchor: 'center',
+        min: MIN_ELEVATOR_DIM,
+        currentValue: (n) => (axis === 'x' ? n.width : n.depth),
+        apply: (_n, newValue) => (axis === 'x' ? { width: newValue } : { depth: newValue }),
+        placement: {
+            position: (n) => {
+                const cabWidth = getElevatorCabWidth(n);
+                const cabDepth = getElevatorCabDepth(n);
+                const wallThickness = getElevatorShaftWallThickness(n);
+                const outerHalf = axis === 'x'
+                    ? getElevatorShaftWidth(n, cabWidth) / 2 + wallThickness
+                    : getElevatorShaftDepth(n, cabDepth) / 2 + wallThickness;
+                const yMid = Math.max(n.cabHeight, MIN_CAB_HEIGHT) / 2;
+                return axis === 'x'
+                    ? [outerHalf + SIDE_HANDLE_OFFSET, yMid, 0]
+                    : [0, yMid, outerHalf + SIDE_HANDLE_OFFSET];
+            },
+        },
+    };
+}
+// Cab-height arrow — `anchor: 'min'` keeps the cab floor fixed and grows
+// the cab upward. The arrow itself sits above the full SHAFT top (not
+// just the cab) so a multi-level elevator's arrow appears outside the
+// rendered body rather than buried inside the shaft. `resolveElevatorLevels`
+// walks the building's level chain to find shaftTopY; the fallback
+// (cabHeight + 0.3) matches the renderer's own when no service levels
+// are configured yet.
+function elevatorCabHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_CAB_HEIGHT,
+        currentValue: (n) => Math.max(n.cabHeight, MIN_CAB_HEIGHT),
+        apply: (_n, newValue) => ({ cabHeight: newValue }),
+        placement: {
+            position: (n, scene) => {
+                const { shaftTopY } = resolveElevatorLevels(n, scene.nodes());
+                const cabTop = Math.max(n.cabHeight, MIN_CAB_HEIGHT) + 0.3;
+                const top = Math.max(shaftTopY, cabTop);
+                return [0, top + HEIGHT_HANDLE_OFFSET, 0];
+            },
+        },
+    };
+}
+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,
+    };
+}
+// Rotation handle — sits at the front-right corner of the shaft
+// footprint. `arc-resize` does the angular drag math (raycasts a
+// horizontal plane at the arrow's Y, measures cursor angle around the
+// elevator's local origin, returns the delta to apply). On hover or
+// drag the decoration ring traces the shaft's bounding circle through
+// all four corners — same idiom as the column radius ring.
+function elevatorRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        // The cursor delta `atan2(hit.z - center.z, hit.x - center.x)` ticks
+        // up in the opposite handedness from three.js's Y-rotation (positive
+        // Ry takes +X → -Z, while atan2(z,x) increases as we go +X → +Z).
+        // Negate so dragging the cursor CCW around the elevator (as seen
+        // from above) actually rotates the elevator CCW.
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            // Offset along +Z only so the gizmo sticks out the front of the
+            // shaft rather than diagonally at the corner — matches the column's
+            // one-direction rotate placement.
+            position: (n) => {
+                const { halfX, halfZ } = elevatorOuterHalfExtents(n);
+                const yMid = Math.max(n.cabHeight, MIN_CAB_HEIGHT) / 2;
+                return [halfX, yMid, halfZ + ROTATE_CORNER_OFFSET];
+            },
+            // Fixed −45° tilt — leans the curve clockwise (as seen from above)
+            // toward the shaft's front face.
+            rotationY: () => -Math.PI / 4,
+        },
+        decoration: {
+            kind: 'ring',
+            // Bounding circle through the shaft corners — drawn slightly larger
+            // so it sits outside the visible shell.
+            radius: (n) => {
+                const { halfX, halfZ } = elevatorOuterHalfExtents(n);
+                return Math.hypot(halfX, halfZ) + ROTATE_RING_OFFSET;
+            },
+            y: (n) => Math.max(n.cabHeight, MIN_CAB_HEIGHT) / 2,
+        },
+    };
+}
+function elevatorMoveHandle() {
+    return {
+        // Tap-to-engage: hand the elevator to its move tool (same path the
+        // floating action menu's Move button takes via `setMovingNode`) so the
+        // 3D grip and the floating-UI button share one move flow — green
+        // bounding box, alignment guides, R/T rotation, click-to-commit.
+        kind: 'tap-action',
+        shape: 'move-cross',
+        cursor: 'move',
+        onActivate: (node, _scene, editor) => editor.engageMove(node),
+        placement: {
+            position: (n) => {
+                const { halfZ } = elevatorOuterHalfExtents(n);
+                return [0, 0.02, halfZ + MOVE_FRONT_OFFSET];
+            },
+        },
+    };
+}
+const elevatorHandles = [
+    elevatorAxisHandle('x'),
+    elevatorAxisHandle('z'),
+    elevatorCabHeightHandle(),
+    elevatorRotateHandle(),
+    elevatorMoveHandle(),
+];
+/**
+ * Elevator — Stage A registration. Wrap-exports the legacy renderer +
+ * the three legacy systems (runtime / interaction / opening) bundled
+ * as one `def.system`. Move / inspector still go through legacy
+ * (`MoveElevatorTool`, `<ElevatorPanel>`) via panel-manager's
+ * hardcoded switch.
+ */
+export const elevatorDefinition = {
+    kind: 'elevator',
+    schemaVersion: 1,
+    schema: ElevatorNode,
+    category: 'structure',
+    snapProfile: 'structural',
+    // Placed as a footprint (R/T rotates), not a directional draw → no angle-lock
+    // mode. The toolHints presence routes it through the contextual HUD so the
+    // snapping chip shows during placement.
+    snapDraftDirectional: false,
+    toolHints: [
+        { key: 'Left click', label: 'Place elevator' },
+        { key: 'R / T', label: 'Rotate' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    surfaceRole: 'joinery',
+    defaults: () => {
+        const stub = ElevatorNodeSchema.parse({ id: 'elevator_default', type: 'elevator' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        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 },
+        // 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 = Math.max(e.cabHeight, 1.4);
+            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),
+        paint: elevatorPaint,
+    },
+    parametrics: elevatorParametrics,
+    handles: elevatorHandles,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    system: {
+        module: () => import('./system'),
+        priority: 3,
+    },
+    floorplan: buildElevatorFloorplan,
+    // Elevators are parented to the building (siblings of levels), so the
+    // floor-plan layer's level-rooted DFS never reaches them. Declaring
+    // `floorplanScope: 'building'` tells `FloorplanRegistryLayer` to walk
+    // building-scoped kinds separately and synthesise `ctx.parent` as the
+    // active level — that's what `buildElevatorFloorplan` reads via
+    // `ctx.parent?.id` to decide whether this floor is in the elevator's
+    // service range.
+    floorplanScope: 'building',
+    // 2D drag affordance for the rotate-arrow emitted at the elevator's
+    // front-right corner. Body move uses the generic move-arrow / move-
+    // handle path emitted by the floor-plan builder.
+    floorplanAffordances: {
+        'elevator-resize': elevatorResizeAffordance,
+        'elevator-rotate': elevatorRotateAffordance,
+    },
+    presentation: {
+        label: 'Elevator',
+        description: 'A multi-level elevator shaft with configurable openings per level.',
+        icon: { kind: 'url', src: '/icons/wallcut.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 80,
+    },
+    mcp: {
+        description: 'A multi-level elevator with shaft + openings per level.',
+    },
+};

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

@@ -0,0 +1,21 @@
+import { type ElevatorNode, type FloorplanAffordance } from '@pascal-app/core';
+/**
+ * Elevator width / depth drag (floor-plan). Mirrors the 3D
+ * `linear-resize` handles declared in `definition.ts` — `anchor: 'center'`
+ * means dragging outward on either +X or -X edge grows `width` by 2×
+ * the elevator-local cursor offset while `position` stays put. Same for
+ * +Z / -Z and `depth`. Writes directly to scene each tick (door pattern);
+ * the registry dispatcher snapshots / pauses history at start so the
+ * per-tick writes collapse into one undoable entry on commit.
+ */
+export declare const elevatorResizeAffordance: FloorplanAffordance<ElevatorNode>;
+/**
+ * Elevator rotation drag (floor-plan). Sister to the 3D `arc-resize`
+ * handle declared in `definition.ts`. Same `- delta` sign convention as
+ * the 3D path so dragging the cursor in the same direction in both views
+ * produces the same rotation. Writes directly to scene during the drag;
+ * the registry dispatcher captures a snapshot first and re-applies the
+ * single tracked update on pointer-up.
+ */
+export declare const elevatorRotateAffordance: FloorplanAffordance<ElevatorNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -0,0 +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,EAEzB,MAAM,kBAAkB,CAAA;AAOzB;;;;;;;;GAQG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,YAAY,CA4CtE,CAAA;AAED;;;;;;;GAOG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,YAAY,CA8BtE,CAAA"}