@pascal-app/nodes 1.0.7 → 1.1.0

package/dist/elevator/definition.d.ts

@@ -1,11 +1,118 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { ElevatorNode } from './schema.js';
-/**
- * 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>;
+export declare const elevatorDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`elevator_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"elevator">>;
+    material: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    materialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    width: import("zod").ZodDefault<import("zod").ZodNumber>;
+    depth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shaftWidth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    shaftDepth: import("zod").ZodOptional<import("zod").ZodNumber>;
+    shaftWallThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    shaftStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        glass: "glass";
+        solid: "solid";
+    }>>;
+    cabHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    doorWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    doorHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    doorStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "center-opening": "center-opening";
+        "single-left": "single-left";
+        "single-right": "single-right";
+    }>>;
+    doorPanelStyle: import("zod").ZodDefault<import("zod").ZodEnum<{
+        "glass-frame": "glass-frame";
+        "segmented-panel": "segmented-panel";
+        "solid-panel": "solid-panel";
+    }>>;
+    fromLevelId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    toLevelId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    servedLevelIds: import("zod").ZodOptional<import("zod").ZodArray<import("zod").ZodString>>;
+    disabledLevelIds: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    serviceOnlyLevelIds: import("zod").ZodDefault<import("zod").ZodArray<import("zod").ZodString>>;
+    defaultLevelId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    speed: import("zod").ZodDefault<import("zod").ZodNumber>;
+    doorDurationMs: import("zod").ZodDefault<import("zod").ZodNumber>;
+    dwellMs: import("zod").ZodDefault<import("zod").ZodNumber>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

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

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

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { ElevatorNode } from './schema.js';
+export declare const elevatorEditContribution: NodeEditContribution<typeof ElevatorNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/elevator/definition.edit.ts"],"names":[],"mappings":"AAcA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAMvE,OAAO,KAAK,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAsJ5C,eAAO,MAAM,wBAAwB,EAAE,oBAAoB,CAAC,OAAO,YAAY,CAqC9E,CAAA"}

package/dist/elevator/definition.edit.js

@@ -0,0 +1,177 @@
+import { ELEVATOR_MIN_CAB_DIMENSION, ELEVATOR_MIN_CAB_HEIGHT, getElevatorCabDepth, getElevatorCabWidth, getElevatorShaftDepth, getElevatorShaftWallThickness, getElevatorShaftWidth, normalizeElevatorDimensions, resolveElevatorDimensions, resolveElevatorLevels, } from '@pascal-app/core';
+import { elevatorOuterHalfExtents } from './definition.render.js';
+import { buildElevatorFloorplan } from './floorplan.js';
+import { elevatorResizeAffordance, elevatorRotateAffordance } from './floorplan-affordances.js';
+import { elevatorPaint } from './paint.js';
+import { elevatorParametrics } from './parametrics.js';
+const SIDE_HANDLE_OFFSET = 0.22;
+const HEIGHT_HANDLE_OFFSET = 0.3;
+const MOVE_FRONT_OFFSET = 0.35;
+const MIN_ELEVATOR_DIM = ELEVATOR_MIN_CAB_DIMENSION;
+const MIN_CAB_HEIGHT = ELEVATOR_MIN_CAB_HEIGHT;
+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' ? resolveElevatorDimensions(n).width : resolveElevatorDimensions(n).depth,
+        apply: (n, newValue) => normalizeElevatorDimensions({
+            ...n,
+            ...(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) => normalizeElevatorDimensions({ ...n, 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];
+            },
+        },
+    };
+}
+// 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(),
+];
+export const elevatorEditContribution = {
+    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' },
+    ],
+    capabilities: {
+        paint: elevatorPaint,
+    },
+    tool: () => import('./tool.js'),
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.edit.js'),
+    },
+    parametrics: elevatorParametrics,
+    handles: elevatorHandles,
+    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,
+    },
+};

package/dist/elevator/definition.js

@@ -1,258 +1,4 @@
-import { ElevatorNode as ElevatorNodeSchema, elevatorSlots, getElevatorCabDepth, getElevatorCabWidth, getElevatorShaftDepth, getElevatorShaftWallThickness, getElevatorShaftWidth, resolveElevatorLevels, } from '@pascal-app/core';
-import { buildElevatorFloorplan } from './floorplan.js';
-import { elevatorResizeAffordance, elevatorRotateAffordance } from './floorplan-affordances.js';
-import { elevatorPaint } from './paint.js';
-import { elevatorParametrics } from './parametrics.js';
-import { ElevatorNode } from './schema.js';
-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: {
-        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 },
-        // 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,
-    // 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,
-    },
-    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.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { elevatorEditContribution } from './definition.edit.js';
+import { elevatorRenderDefinition } from './definition.render.js';
+export const elevatorDefinition = composeNodeDefinition(elevatorRenderDefinition, elevatorEditContribution);

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

@@ -0,0 +1,11 @@
+import { type ElevatorNode as ElevatorNodeType } from '@pascal-app/core';
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { ElevatorNode } from './schema.js';
+export declare function elevatorOuterHalfExtents(n: ElevatorNodeType): {
+    halfX: number;
+    halfZ: number;
+};
+export declare const elevatorRenderDefinition: NodeRenderDefinition<typeof ElevatorNode> & {
+    kind: 'elevator';
+};
+//# sourceMappingURL=definition.render.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/elevator/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,YAAY,IAAI,gBAAgB,EAUtC,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,YAAY,EAAE,MAAM,UAAU,CAAA;AAEvC,wBAAgB,wBAAwB,CAAC,CAAC,EAAE,gBAAgB,GAAG;IAAE,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAQ9F;AAED,eAAO,MAAM,wBAAwB,EAAE,oBAAoB,CAAC,OAAO,YAAY,CAAC,GAAG;IACjF,IAAI,EAAE,UAAU,CAAA;CAqFjB,CAAA"}