@pascal-app/nodes 0.1.1

package/dist/elevator/floorplan-affordances.js

@@ -0,0 +1,94 @@
+import { useScene, } from '@pascal-app/core';
+import { rotateAffordanceDelta } from '../shared/rotate-affordance';
+const MIN_ELEVATOR_DIM = 0.6;
+/**
+ * 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 const elevatorResizeAffordance = {
+    start({ node, payload, initialPlanPoint }) {
+        const { axis, side } = payload;
+        const elevatorId = node.id;
+        const initialValue = axis === 'x' ? node.width : node.depth;
+        const cx = node.position[0];
+        const cz = node.position[2];
+        const rotation = node.rotation ?? 0;
+        const cos = Math.cos(rotation);
+        const sin = Math.sin(rotation);
+        // Inverse of the elevator's local→plan rotation. The plan-space
+        // matrix is `[c, s; -s, c]`; its inverse is `[c, -s; s, c]`.
+        const projectLocalAxis = (px, pz) => {
+            const lx = (px - cx) * cos - (pz - cz) * sin;
+            const ly = (px - cx) * sin + (pz - cz) * cos;
+            return axis === 'x' ? lx : ly;
+        };
+        const initialLocal = projectLocalAxis(initialPlanPoint[0], initialPlanPoint[1]);
+        let lastValue = initialValue;
+        return {
+            affectedIds: [elevatorId],
+            apply({ planPoint }) {
+                const currentLocal = projectLocalAxis(planPoint[0], planPoint[1]);
+                // `side` is +1 for the +axis arrow, -1 for the -axis arrow.
+                // Pointer delta along the arrow's outward direction grows the
+                // full span 2× (centre anchor).
+                const delta = (currentLocal - initialLocal) * side;
+                const newValue = Math.max(MIN_ELEVATOR_DIM, initialValue + 2 * delta);
+                lastValue = newValue;
+                useScene
+                    .getState()
+                    .updateNode(elevatorId, axis === 'x' ? { width: newValue } : { depth: newValue });
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene
+                    .getState()
+                    .updateNode(elevatorId, axis === 'x' ? { width: lastValue } : { depth: lastValue });
+            },
+        };
+    },
+};
+/**
+ * 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 const elevatorRotateAffordance = {
+    start({ node, initialPlanPoint }) {
+        const elevatorId = node.id;
+        const initialRotation = node.rotation ?? 0;
+        const cx = node.position[0];
+        const cz = node.position[2];
+        const initialAngle = Math.atan2(initialPlanPoint[1] - cz, initialPlanPoint[0] - cx);
+        let lastRotation = initialRotation;
+        return {
+            affectedIds: [elevatorId],
+            apply({ planPoint, modifiers }) {
+                const delta = rotateAffordanceDelta({
+                    center: [cx, cz],
+                    initialAngle,
+                    planPoint,
+                    free: modifiers.shiftKey,
+                });
+                const newRotation = initialRotation - delta;
+                lastRotation = newRotation;
+                useScene.getState().updateNode(elevatorId, { rotation: newRotation });
+            },
+            canCommit() {
+                return true;
+            },
+            commit() {
+                useScene.getState().updateNode(elevatorId, { rotation: lastRotation });
+            },
+        };
+    },
+};

package/dist/elevator/floorplan.d.ts

@@ -0,0 +1,3 @@
+import { type ElevatorNode, type FloorplanGeometry, type GeometryContext } from '@pascal-app/core';
+export declare function buildElevatorFloorplan(node: ElevatorNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +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"}

package/dist/elevator/floorplan.js

@@ -0,0 +1,360 @@
+import { resolveElevatorServiceLevelIds, useInteractive, useLiveNodeOverrides, } 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.
+ */
+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);
+    const display = overrides ? { ...node, ...overrides } : node;
+    // Service-level gate. If the active level isn't one the elevator
+    // serves, render nothing — legacy behaviour. The level id comes via
+    // `ctx.parent` (the elevator's parent in the tree is the level it's
+    // 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) {
+        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 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);
+    const innerHalfD = Math.max(0.05, shaftDepth / 2);
+    const center = { x: display.position[0], y: display.position[2] };
+    const cos = Math.cos(display.rotation);
+    const sin = Math.sin(display.rotation);
+    const rotate = (lx, ly) => {
+        // Negated-rotation matrix (equivalent to rotating by `-rotation`)
+        // so SVG's CW-with-y-down `rotate` direction visually matches
+        // Three.js Y-rotation (CCW from a top-down view). Column / shelf /
+        // roof-segment do the same thing explicitly via `-node.rotation`
+        // passed to `rotatePlanVector`; this is the inline version.
+        return [lx * cos + ly * sin, -lx * sin + ly * cos];
+    };
+    const toPlan = (lx, ly) => {
+        const [rx, ry] = rotate(lx, ly);
+        return [center.x + rx, center.y + ry];
+    };
+    const rectPoints = (halfW, halfD) => [
+        toPlan(-halfW, -halfD),
+        toPlan(halfW, -halfD),
+        toPlan(halfW, halfD),
+        toPlan(-halfW, halfD),
+    ];
+    // Runtime state — current level / target level / queued.
+    const runtime = useInteractive.getState().elevators[node.id];
+    const isCarOnLevel = parentLevelId ? runtime?.currentLevelId === parentLevelId : false;
+    const isTargetLevel = parentLevelId ? runtime?.targetLevelId === parentLevelId : false;
+    const isQueuedLevel = parentLevelId
+        ? (runtime?.queue.includes(parentLevelId) ?? false)
+        : false;
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const isSelected = view?.selected ?? false;
+    const isHighlighted = view?.highlighted ?? false;
+    const showSelectedChrome = isSelected || isHighlighted;
+    // Base ink: near-black architectural outline. Selection switches to
+    // the palette accent. Runtime state (car-on-level, target, queued)
+    // is conveyed via the served-level chip column when selected, not
+    // the main outline — so the floor-plan symbol stays neutral and
+    // matches the line weight of the other architectural elements.
+    const baseInk = '#111111';
+    const stroke = showSelectedChrome && palette ? palette.selectedStroke : baseInk;
+    const cabMarkInk = stroke;
+    const children = [];
+    // Invisible hit-target — closed polygon over the full outer
+    // footprint so clicks anywhere inside the elevator (not just on the
+    // stroked outlines) select the node. The outer outline below is a
+    // polyline with `fill='none'`, so without this layer the interior
+    // would fall through to whatever sits beneath.
+    children.push({
+        kind: 'polygon',
+        points: rectPoints(outerHalfW, outerHalfD),
+        fill: stroke,
+        fillOpacity: 0,
+        stroke: 'none',
+        strokeWidth: 0,
+        pointerEvents: 'all',
+    });
+    // Door geometry. The jambs are little U-shaped notches that hang
+    // BELOW the outer wall's bottom edge on either side of the door
+    // opening; the outer outline traces around them and breaks for the
+    // door in the middle.
+    const doorY = -outerHalfD;
+    const effectiveDoorWidth = Math.min(doorWidth, innerHalfW * 2 - 0.16);
+    const jambInnerX = effectiveDoorWidth / 2;
+    const jambWidth = Math.max(0.08, Math.min(wallThickness * 2.2, (outerHalfW - jambInnerX) * 0.55));
+    const jambOuterX = Math.min(jambInnerX + jambWidth, outerHalfW - 0.04);
+    const jambStubDepth = Math.max(0.06, wallThickness * 1.05);
+    // Outer outline — single polyline that traces clockwise from the
+    // left edge of the door opening, around the left jamb stub, along
+    // the bottom-left segment, up the left side, across the top, down
+    // the right side, along the bottom-right segment, around the right
+    // jamb stub, ending at the right edge of the door opening. The two
+    // endpoints frame the door gap; SVG `polyline` doesn't close.
+    const outerOutline = [
+        toPlan(-jambInnerX, doorY),
+        toPlan(-jambInnerX, doorY - jambStubDepth),
+        toPlan(-jambOuterX, doorY - jambStubDepth),
+        toPlan(-jambOuterX, doorY),
+        toPlan(-outerHalfW, doorY),
+        toPlan(-outerHalfW, outerHalfD),
+        toPlan(outerHalfW, outerHalfD),
+        toPlan(outerHalfW, doorY),
+        toPlan(jambOuterX, doorY),
+        toPlan(jambOuterX, doorY - jambStubDepth),
+        toPlan(jambInnerX, doorY - jambStubDepth),
+        toPlan(jambInnerX, doorY),
+    ];
+    children.push({
+        kind: 'polyline',
+        points: outerOutline,
+        fill: 'none',
+        stroke,
+        strokeWidth: showSelectedChrome ? 0.035 : 0.025,
+        strokeLinejoin: 'miter',
+        strokeLinecap: 'butt',
+    });
+    // Inner outline — closed rectangle, the inner face of the shaft.
+    // The X diagonals terminate at its corners.
+    children.push({
+        kind: 'polygon',
+        points: rectPoints(innerHalfW, innerHalfD),
+        fill: 'none',
+        stroke,
+        strokeWidth: 0.02,
+        strokeLinejoin: 'miter',
+    });
+    // Dashed X across the shaft interior — corner-to-corner of the
+    // inner rectangle, the universal elevator-cab mark.
+    const diagonals = [
+        [toPlan(-innerHalfW, -innerHalfD), toPlan(innerHalfW, innerHalfD)],
+        [toPlan(innerHalfW, -innerHalfD), toPlan(-innerHalfW, innerHalfD)],
+    ];
+    for (const [start, end] of diagonals) {
+        children.push({
+            kind: 'line',
+            x1: start[0],
+            y1: start[1],
+            x2: end[0],
+            y2: end[1],
+            stroke: cabMarkInk,
+            strokeWidth: 0.018,
+            strokeDasharray: '0.08 0.06',
+            strokeLinecap: 'butt',
+            opacity: 0.85,
+        });
+    }
+    // Dashed door line — sits on the outer wall line, spanning the gap
+    // between the two jamb stubs.
+    const doorStart = toPlan(-jambInnerX, doorY);
+    const doorEnd = toPlan(jambInnerX, doorY);
+    children.push({
+        kind: 'line',
+        x1: doorStart[0],
+        y1: doorStart[1],
+        x2: doorEnd[0],
+        y2: doorEnd[1],
+        stroke: cabMarkInk,
+        strokeWidth: 0.02,
+        strokeDasharray: '0.08 0.06',
+        strokeLinecap: 'butt',
+        opacity: 0.9,
+    });
+    // Served-level chips — vertical column of marker circles + level
+    // numbers to the right of the shaft, only when selected and the
+    // elevator serves more than one level. Mirrors the legacy
+    // `<FloorplanElevatorLayer>` chip rendering (~line 6423 in
+    // floorplan-panel.tsx).
+    if (isSelected && parentLevelId) {
+        const sceneNodes = collectAllNodes(ctx);
+        const serviceLevelIds = resolveElevatorServiceLevelIds(display, sceneNodes);
+        if (serviceLevelIds.length > 1) {
+            const disabledLevelIds = new Set(display.disabledLevelIds ?? []);
+            const serviceOnlyLevelIds = new Set(display.serviceOnlyLevelIds ?? []);
+            const rangeStep = 0.18;
+            const rangeHeight = Math.max(0, (serviceLevelIds.length - 1) * rangeStep);
+            const [rangeOffsetX, rangeOffsetY] = rotate(outerHalfW + 0.38, 0);
+            const rangeX = center.x + rangeOffsetX;
+            const rangeBottomY = center.y + rangeOffsetY + rangeHeight / 2;
+            const rangeTopY = center.y + rangeOffsetY - rangeHeight / 2;
+            // Connector spine — single vertical line tying the chips to the
+            // shaft. Sky blue, semi-transparent.
+            children.push({
+                kind: 'line',
+                x1: rangeX,
+                y1: rangeTopY,
+                x2: rangeX,
+                y2: rangeBottomY,
+                stroke: '#0ea5e9',
+                strokeOpacity: 0.52,
+                strokeWidth: 0.018,
+                strokeLinecap: 'round',
+                vectorEffect: 'non-scaling-stroke',
+            });
+            // One chip per served level. Lowest level at the bottom of the
+            // column, index increases upward — matches legacy ordering.
+            serviceLevelIds.forEach((levelId, index) => {
+                const isCurrent = runtime?.currentLevelId === levelId;
+                const isTarget = runtime?.targetLevelId === levelId;
+                // `resolveElevatorServiceLevelIds` returns plain `string[]`, but
+                // the runtime queue is `AnyNodeId[]` (branded). The values agree
+                // at runtime — narrowing through `as never` keeps the includes
+                // call type-safe without dragging the brand into the helper's
+                // public return type.
+                const isQueued = runtime?.queue.includes(levelId) ?? false;
+                const isDisabled = disabledLevelIds.has(levelId);
+                const isServiceOnly = serviceOnlyLevelIds.has(levelId);
+                const isUnavailable = isDisabled || isServiceOnly;
+                const markerFill = isCurrent
+                    ? '#22c55e'
+                    : isTarget || isQueued
+                        ? '#38bdf8'
+                        : isUnavailable
+                            ? '#94a3b8'
+                            : '#ffffff';
+                const markerStroke = isUnavailable ? '#64748b' : '#0369a1';
+                const labelColor = isUnavailable ? '#64748b' : '#075985';
+                const y = rangeBottomY - index * rangeStep;
+                children.push({
+                    kind: 'circle',
+                    cx: rangeX,
+                    cy: y,
+                    r: 0.055,
+                    fill: markerFill,
+                    fillOpacity: isUnavailable ? 0.72 : 0.95,
+                    stroke: markerStroke,
+                    strokeWidth: 0.012,
+                });
+                children.push({
+                    kind: 'text',
+                    x: rangeX + 0.11,
+                    y,
+                    text: String(index + 1),
+                    fontSize: 0.13,
+                    fontWeight: 700,
+                    fill: labelColor,
+                    textAnchor: 'start',
+                    dominantBaseline: 'middle',
+                });
+            });
+        }
+    }
+    // Selection chrome — orange move-handle dot at the centre, four
+    // perpendicular side resize-arrows ringing the outer shaft, and a
+    // rotate-arrow at the front-right corner. Side arrows drive `width`
+    // (X-axis) and `depth` (Z-axis) through `elevatorResizeAffordance`
+    // with `anchor: 'center'` — sister of the 3D `linear-resize` handles
+    // in `definition.ts`. Body move is reached via the centroid dot or
+    // the floating action menu's Move button.
+    if (isSelected) {
+        children.push({
+            kind: 'move-handle',
+            point: [display.position[0], display.position[2]],
+        });
+        const sideArrowOffset = 0.12;
+        const rotateCornerOffset = 0.22;
+        const cx = display.position[0];
+        const cz = display.position[2];
+        const sides = [
+            { local: [outerHalfW + sideArrowOffset, 0], localAngle: 0, axis: 'x', side: 1 },
+            { local: [-(outerHalfW + sideArrowOffset), 0], localAngle: Math.PI, axis: 'x', side: -1 },
+            { local: [0, outerHalfD + sideArrowOffset], localAngle: Math.PI / 2, axis: 'z', side: 1 },
+            {
+                local: [0, -(outerHalfD + sideArrowOffset)],
+                localAngle: -Math.PI / 2,
+                axis: 'z',
+                side: -1,
+            },
+        ];
+        for (const side of sides) {
+            const [ox, oz] = rotate(side.local[0], side.local[1]);
+            const [tx, tz] = rotate(Math.cos(side.localAngle), Math.sin(side.localAngle));
+            children.push({
+                kind: 'move-arrow',
+                point: [cx + ox, cz + oz],
+                angle: Math.atan2(tz, tx),
+                affordance: 'elevator-resize',
+                payload: { axis: side.axis, side: side.side },
+            });
+        }
+        // Rotate-arrow at the +X / +Z corner. `localAngle = π/4` puts the
+        // curved arrow's bow at the diagonal corner so it reads as a
+        // rotation gizmo around the elevator centre.
+        const cornerLocalX = outerHalfW + rotateCornerOffset;
+        const cornerLocalZ = outerHalfD + rotateCornerOffset;
+        const [cornerX, cornerZ] = rotate(cornerLocalX, cornerLocalZ);
+        const [radialX, radialZ] = rotate(1, 1);
+        children.push({
+            kind: 'rotate-arrow',
+            point: [cx + cornerX, cz + cornerZ],
+            angle: Math.atan2(radialZ, radialX),
+            affordance: 'elevator-rotate',
+            pivot: [cx, cz],
+        });
+    }
+    return { kind: 'group', children };
+}
+/**
+ * `ctx` exposes `resolve` and `children` / `siblings` / `parent`, but
+ * not the full nodes map. `resolveElevatorServiceLevelIds` wants a
+ * `Record<id, AnyNode>`; we rebuild it by walking the chain we DO have
+ * access to. For the elevator's service-level check we only need the
+ * elevator's parent (the level), its building, and any level siblings.
+ * This is the minimum graph the resolver needs.
+ *
+ * If a future use needs the full nodes map for a builder, we'd surface
+ * it through ctx — but doing so leaks the whole scene store into every
+ * `def.floorplan` call. Narrow opt-in is the better default.
+ */
+function collectAllNodes(ctx) {
+    // We need the building → levels graph for service-level resolution.
+    // Walk up from the elevator: parent (level) → its parent (building) →
+    // building.children (all levels). That's enough for the resolver.
+    const out = {};
+    const level = ctx.parent;
+    if (level) {
+        out[level.id] = level;
+        const building = level.parentId
+            ? ctx.resolve(level.parentId)
+            : undefined;
+        if (building) {
+            out[building.id] = building;
+            const childIds = building.children;
+            if (Array.isArray(childIds)) {
+                for (const cid of childIds) {
+                    const child = ctx.resolve(cid);
+                    if (child)
+                        out[child.id] = child;
+                }
+            }
+        }
+    }
+    return out;
+}

package/dist/elevator/index.d.ts

@@ -0,0 +1,2 @@
+export { elevatorDefinition } from './definition';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/elevator/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,kBAAkB,EAAE,MAAM,cAAc,CAAA"}

package/dist/elevator/index.js

@@ -0,0 +1 @@
+export { elevatorDefinition } from './definition';

package/dist/elevator/paint.d.ts

@@ -0,0 +1,2 @@
+export declare const elevatorPaint: import("@pascal-app/core").PaintCapability;
+//# sourceMappingURL=paint.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/elevator/paint.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,aAAa,4CAIxB,CAAA"}

package/dist/elevator/paint.js

@@ -0,0 +1,6 @@
+import { createSlotPaintCapability, previewSlotByUserData } from '../shared/slot-paint';
+export const elevatorPaint = createSlotPaintCapability({
+    resolveRole: (args) => args.hitObject?.userData?.slotId ?? null,
+    applyPreview: previewSlotByUserData,
+    legacyEffective: () => null,
+});

package/dist/elevator/panel.d.ts

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/elevator/panel.tsx"],"names":[],"mappings":"AA+JA,MAAM,CAAC,OAAO,UAAU,aAAa,uCAywBpC"}