@pascal-app/nodes 0.1.1

package/dist/stair/definition.js

@@ -0,0 +1,440 @@
+import { StairNode as StairNodeSchema, stairFootprintAABB, } from '@pascal-app/core';
+const MIN_CURVED_RISE = 0.3;
+const MIN_CURVED_WIDTH = 0.4;
+const MIN_CURVED_INNER_RADIUS_SPIRAL = 0.05;
+const MIN_CURVED_INNER_RADIUS_CURVED = 0.2;
+const MIN_CURVED_SWEEP = Math.PI / 12;
+const MAX_CURVED_SWEEP = Math.PI * 2 - 0.05;
+const CURVED_RISE_OFFSET = 0.35;
+const CURVED_WIDTH_HANDLE_OFFSET = 0.5;
+const CURVED_RADIAL_OFFSET = 0.16;
+const CURVED_SWEEP_RADIAL_OFFSET = 0.3;
+const CURVED_SWEEP_LATERAL_OFFSET = 0.24;
+// Guide rings — outer hugs just outside the rim, inner sits inside the
+// pillar. Clamp inner so a tiny innerRadius (spiral default 0.05) doesn't
+// push the ring through the axis.
+const CURVED_OUTER_RING_OFFSET = 0.2;
+const CURVED_INNER_RING_OFFSET = 0.2;
+const CURVED_INNER_RING_MIN = 0.05;
+// Whole-stair rotation gizmo — curved two-headed arrow at a corner of
+// the footprint. Same pattern as elevator / column / shelf / roof-segment.
+const STAIR_ROTATE_CORNER_OFFSET = 0.4;
+const STAIR_ROTATE_RING_OFFSET = 0.08;
+const STAIR_MOVE_FRONT_OFFSET = 0.35;
+function readCurvedStairGeometry(node) {
+    const isSpiral = node.stairType === 'spiral';
+    const stepCount = Math.max(2, Math.round(node.stepCount ?? 10));
+    const totalRise = Math.max(node.totalRise ?? 2.5, 0.1);
+    const width = Math.max(node.width ?? 1, MIN_CURVED_WIDTH);
+    const minInnerRadius = isSpiral ? MIN_CURVED_INNER_RADIUS_SPIRAL : MIN_CURVED_INNER_RADIUS_CURVED;
+    const innerRadius = Math.max(minInnerRadius, node.innerRadius ?? 0.9);
+    const outerRadius = innerRadius + width;
+    const sweepAngle = node.sweepAngle ?? (isSpiral ? Math.PI * 2 : Math.PI / 2);
+    const stepSweep = sweepAngle / stepCount;
+    return {
+        isSpiral,
+        stepCount,
+        totalRise,
+        innerRadius,
+        outerRadius,
+        width,
+        sweepAngle,
+        stepSweep,
+        midRadius: (innerRadius + outerRadius) / 2,
+        topAngle: sweepAngle / 2 - stepSweep / 2,
+        minInnerRadius,
+    };
+}
+function isCurvedOrSpiral(node) {
+    return node.stairType === 'curved' || node.stairType === 'spiral';
+}
+function rotateLocalXZ(x, z, angle) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return [x * cos + z * sin, -x * sin + z * cos];
+}
+function fallbackStraightStairMoveBounds(node) {
+    const width = Math.max(node.width ?? 1, MIN_CURVED_WIDTH);
+    const depth = Math.max(width, 1);
+    return {
+        minX: -width / 2,
+        maxX: width / 2,
+        minZ: 0,
+        maxZ: depth,
+        height: Math.max(node.totalRise ?? 2.5, 0.1),
+    };
+}
+function readStraightStairMoveBounds(node, sceneApi) {
+    const segments = (node.children ?? [])
+        .map((childId) => sceneApi.get(childId))
+        .filter((child) => child?.type === 'stair-segment');
+    if (segments.length === 0)
+        return fallbackStraightStairMoveBounds(node);
+    const transforms = computeStairSegmentFloorStackTransforms(segments);
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    let height = 0;
+    segments.forEach((segment, index) => {
+        const transform = transforms[index];
+        if (!transform)
+            return;
+        const halfWidth = segment.width / 2;
+        const corners = [
+            [-halfWidth, 0],
+            [halfWidth, 0],
+            [-halfWidth, segment.length],
+            [halfWidth, segment.length],
+        ];
+        for (const [x, z] of corners) {
+            const [rx, rz] = rotateLocalXZ(x, z, transform.rotation);
+            minX = Math.min(minX, transform.position[0] + rx);
+            maxX = Math.max(maxX, transform.position[0] + rx);
+            minZ = Math.min(minZ, transform.position[2] + rz);
+            maxZ = Math.max(maxZ, transform.position[2] + rz);
+        }
+        height = Math.max(height, transform.position[1] + Math.max(segment.height, segment.thickness, 0.01));
+    });
+    if (![minX, maxX, minZ, maxZ].every(Number.isFinite)) {
+        return fallbackStraightStairMoveBounds(node);
+    }
+    return { minX, maxX, minZ, maxZ, height: Math.max(height, 0.1) };
+}
+function readStairMoveBounds(node, sceneApi) {
+    if (!isCurvedOrSpiral(node))
+        return readStraightStairMoveBounds(node, sceneApi);
+    const g = readCurvedStairGeometry(node);
+    return {
+        minX: -g.outerRadius,
+        maxX: g.outerRadius,
+        minZ: -g.outerRadius,
+        maxZ: g.outerRadius,
+        height: g.totalRise,
+    };
+}
+function curvedRiseHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_CURVED_RISE,
+        currentValue: (n) => Math.max(n.totalRise ?? 2.5, 0.1),
+        apply: (_n, newRise) => ({ totalRise: newRise }),
+        placement: {
+            position: (n) => {
+                const g = readCurvedStairGeometry(n);
+                // Spiral: over the central pillar. Curved: above the upper step's
+                // midline so the arrow sits where users read "top of the run".
+                const x = g.isSpiral ? 0 : g.midRadius * Math.cos(g.topAngle);
+                const z = g.isSpiral ? 0 : g.midRadius * Math.sin(g.topAngle);
+                return [x, g.totalRise + CURVED_RISE_OFFSET, z];
+            },
+        },
+    };
+}
+function curvedWidthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: 'min',
+        min: MIN_CURVED_WIDTH,
+        currentValue: (n) => Math.max(n.width ?? 1, MIN_CURVED_WIDTH),
+        apply: (_n, newWidth) => ({ width: newWidth }),
+        placement: {
+            position: (n) => {
+                const g = readCurvedStairGeometry(n);
+                return [g.outerRadius + CURVED_WIDTH_HANDLE_OFFSET, g.totalRise / 2, 0];
+            },
+        },
+        // Outer guide ring — traces the rim while the user interacts with the
+        // width arrow so it's obvious which edge the drag affects.
+        decoration: {
+            kind: 'ring',
+            radius: (n) => readCurvedStairGeometry(n).outerRadius + CURVED_OUTER_RING_OFFSET,
+            y: (n) => readCurvedStairGeometry(n).totalRise / 2,
+        },
+    };
+}
+function curvedInnerRadiusHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: 'min',
+        min: (n) => n.stairType === 'spiral' ? MIN_CURVED_INNER_RADIUS_SPIRAL : MIN_CURVED_INNER_RADIUS_CURVED,
+        currentValue: (n) => {
+            const minIR = n.stairType === 'spiral' ? MIN_CURVED_INNER_RADIUS_SPIRAL : MIN_CURVED_INNER_RADIUS_CURVED;
+            return Math.max(minIR, n.innerRadius ?? 0.9);
+        },
+        // Adjusting innerRadius alone would also push outerRadius outward,
+        // visually moving the outside of the stair. Compensate by reducing
+        // width by the same amount so the outer rim stays put.
+        apply: (initial, newInner) => {
+            const g = readCurvedStairGeometry(initial);
+            const delta = newInner - g.innerRadius;
+            return {
+                innerRadius: newInner,
+                width: Math.max(MIN_CURVED_WIDTH, g.width - delta),
+            };
+        },
+        placement: {
+            position: (n) => {
+                const g = readCurvedStairGeometry(n);
+                return [g.innerRadius - CURVED_RADIAL_OFFSET, g.totalRise / 2, 0];
+            },
+            rotationY: () => Math.PI,
+        },
+        // Inner guide ring — traces the central pillar. Clamped so a tiny
+        // innerRadius doesn't pull the ring through the axis.
+        decoration: {
+            kind: 'ring',
+            radius: (n) => {
+                const g = readCurvedStairGeometry(n);
+                return Math.max(g.innerRadius - CURVED_INNER_RING_OFFSET, CURVED_INNER_RING_MIN);
+            },
+            y: (n) => readCurvedStairGeometry(n).totalRise / 2,
+        },
+    };
+}
+function curvedSweepHandle(end) {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        end,
+        apply: (initial, delta) => {
+            const initialSweep = initial.sweepAngle ?? Math.PI / 2;
+            const initialRotation = initial.rotation ?? 0;
+            const sweepSign = Math.sign(initialSweep) || 1;
+            // END handle: cursor angle delta IS the sweep delta.
+            // START handle: cursor angle delta is the negation of the sweep delta.
+            const sweepDelta = end === 'end' ? delta : -delta;
+            const targetSweep = initialSweep + sweepDelta;
+            const clampedAbs = Math.min(MAX_CURVED_SWEEP, Math.max(MIN_CURVED_SWEEP, Math.abs(targetSweep)));
+            const newSweep = sweepSign * clampedAbs;
+            const appliedDelta = newSweep - initialSweep;
+            // Re-orient the stair so the OPPOSITE edge stays world-fixed:
+            //   END  fixed-start: ΔR = −ΔS / 2
+            //   START fixed-end : ΔR = +ΔS / 2
+            const rotationShift = end === 'end' ? -appliedDelta / 2 : appliedDelta / 2;
+            return {
+                sweepAngle: newSweep,
+                rotation: initialRotation + rotationShift,
+            };
+        },
+        placement: {
+            position: (n) => {
+                const g = readCurvedStairGeometry(n);
+                const sweepSign = Math.sign(g.sweepAngle) || 1;
+                const z = end === 'end'
+                    ? sweepSign * CURVED_SWEEP_LATERAL_OFFSET
+                    : -sweepSign * CURVED_SWEEP_LATERAL_OFFSET;
+                return [g.outerRadius + CURVED_SWEEP_RADIAL_OFFSET, g.totalRise / 2, z];
+            },
+            rotationY: (n) => {
+                const sweepSign = Math.sign(n.sweepAngle ?? Math.PI / 2) || 1;
+                return end === 'end' ? -sweepSign * (Math.PI / 2) : sweepSign * (Math.PI / 2);
+            },
+        },
+    };
+}
+// Whole-stair rotation gizmo. Lives on the stair parent so it rotates
+// straight + curved + spiral kinds the same way. For straight stairs the
+// gizmo anchors just outside the +X corner of the run start (the stair's
+// root sits at the bottom of the first segment, with the chain extending
+// along +Z). For curved / spiral the gizmo sits at the outer rim, at the
+// sweep-start side, where there's no other handle in the way. apply()
+// negates the cursor delta so dragging CCW (atan2 ticks +) rotates the
+// stair CCW around Y — same convention as elevator / column.
+function stairRotateGizmoPosition(n) {
+    if (isCurvedOrSpiral(n)) {
+        const g = readCurvedStairGeometry(n);
+        const radius = g.outerRadius + STAIR_ROTATE_CORNER_OFFSET;
+        // Sweep-start side in node-local frame. Sector is centred on
+        // local +X (sweep bisector = 0), so start = -sweep/2.
+        const angle = -g.sweepAngle / 2;
+        return [radius * Math.cos(angle), g.totalRise / 2, radius * Math.sin(angle)];
+    }
+    const width = Math.max(n.width ?? 1, MIN_CURVED_WIDTH);
+    const yMid = Math.max(n.totalRise ?? 2.5, 0.1) / 2;
+    return [width / 2 + STAIR_ROTATE_CORNER_OFFSET, yMid, -STAIR_ROTATE_CORNER_OFFSET];
+}
+function stairRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            position: stairRotateGizmoPosition,
+            // The curved-arrow geometry's bow points along its local +X. Rotate
+            // the icon so the bow points radially outward — away from the
+            // stair's center — so the curve hugs the body's outline at the
+            // gizmo's corner instead of cutting into it. rotateY(−α) maps local
+            // +X to the outward radial direction (same handedness rule as
+            // elevator / column, but here the gizmo lands in different
+            // quadrants per stair kind so the tilt is position-derived rather
+            // than a fixed −π/4).
+            rotationY: (n) => {
+                const [px, , pz] = stairRotateGizmoPosition(n);
+                return -Math.atan2(pz, px);
+            },
+        },
+        decoration: {
+            kind: 'ring',
+            radius: (n) => {
+                if (isCurvedOrSpiral(n)) {
+                    const g = readCurvedStairGeometry(n);
+                    return g.outerRadius + STAIR_ROTATE_CORNER_OFFSET + STAIR_ROTATE_RING_OFFSET;
+                }
+                const width = Math.max(n.width ?? 1, MIN_CURVED_WIDTH);
+                return (Math.hypot(width / 2 + STAIR_ROTATE_CORNER_OFFSET, STAIR_ROTATE_CORNER_OFFSET) +
+                    STAIR_ROTATE_RING_OFFSET);
+            },
+            y: (n) => Math.max(n.totalRise ?? 2.5, 0.1) / 2,
+        },
+    };
+}
+function stairMoveHandle() {
+    return {
+        // Tap-to-engage: hand the stair to its `MoveRoofTool` (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: {
+            // Low to the floor at the front edge (matches the item move grip) so it
+            // reads as a floor-move grip and stays clear of the body resize / rotate
+            // handles that sit at mid-height.
+            position: (n, sceneApi) => {
+                const bounds = readStairMoveBounds(n, sceneApi);
+                return [(bounds.minX + bounds.maxX) / 2, 0.02, bounds.maxZ + STAIR_MOVE_FRONT_OFFSET];
+            },
+        },
+    };
+}
+function stairHandles(node) {
+    // Straight stairs have no parent-level shape arrows — the segment
+    // children each render their own (width / length / height). Curved +
+    // spiral stairs use 5 arrows directly on the parent (no segments).
+    // The whole-stair rotation gizmo is universal: every stair kind
+    // exposes the same curved-arrow rotate handle.
+    const handles = [];
+    if (isCurvedOrSpiral(node)) {
+        handles.push(curvedRiseHandle(), curvedWidthHandle(), curvedInnerRadiusHandle(), curvedSweepHandle('start'), curvedSweepHandle('end'));
+    }
+    handles.push(stairRotateHandle(), stairMoveHandle());
+    return handles;
+}
+import { computeStairSegmentFloorStackTransforms, getStairFloorPlacedFootprints, } from './floor-stack';
+import { buildStairFloorplan } from './floorplan';
+import { curvedStairInnerRadiusAffordance, curvedStairSweepAffordance, curvedStairWidthAffordance, segmentLengthAffordance, segmentWidthAffordance, stairRotateAffordance, } from './floorplan-affordances';
+import { stairFloorplanMoveTarget } from './floorplan-move';
+import { stairPaint } from './paint';
+import { stairParametrics } from './parametrics';
+import { StairNode } from './schema';
+import { stairSlots } from './slots';
+/**
+ * Stair — Stage A. Composite node like roof: owns overall framing,
+ * `stair-segment` children own per-flight geometry. Wrap-exports the
+ * legacy `StairRenderer` + `StairSystem`.
+ */
+export const stairDefinition = {
+    kind: 'stair',
+    schemaVersion: 1,
+    schema: StairNode,
+    category: 'structure',
+    snapProfile: 'structural',
+    // A footprint with a clear front: you approach a stair from the low end,
+    // which sits on the -Z side of the run (the run ascends along +Z). Show the
+    // floor facing triangle there, pointing out of the entry, while placing/moving.
+    facingIndicator: { reversed: true },
+    // 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 stairs' },
+        { key: 'R / T', label: 'Rotate' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    surfaceRole: 'joinery',
+    defaults: () => {
+        const stub = StairNodeSchema.parse({ id: 'stair_default', type: 'stair' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        // A stair has no centred box footprint: straight = a cumulative
+        // `stair-segment` chain, curved / spiral = an annular sector. Hand the
+        // alignment bridge the resolved plan `aabb` directly (not a `box`) — the
+        // moving-anchor helper can relocate the same shape when a stair is being
+        // placed or dragged.
+        alignmentFootprint: (node, nodes) => {
+            const aabb = stairFootprintAABB(node, nodes);
+            return aabb ? { shape: 'aabb', ...aabb } : null;
+        },
+        duplicable: true,
+        deletable: true,
+        floorPlaced: {
+            footprints: (node, ctx) => ctx ? getStairFloorPlacedFootprints(node, ctx.nodes) : [],
+        },
+        slots: (node) => stairSlots(node),
+        paint: stairPaint,
+    },
+    // Bespoke move shared with roof / roof-segment / stair-segment via
+    // `shared/move-roof-tool` — routed through `MoveTool`'s registry-
+    // affordance lookup rather than a hardcoded dispatcher arm.
+    affordanceTools: {
+        move: () => import('../shared/move-roof-tool'),
+    },
+    parametrics: stairParametrics,
+    handles: stairHandles,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    system: {
+        module: () => import('./system'),
+        priority: 3,
+    },
+    // Stage C — stair is the parent; it walks its `stair-segment` children
+    // via `ctx.children` and emits the whole stack as one registry entry.
+    // Each flight's transform depends on every prior sibling's
+    // `length` / `height` / `attachmentSide`, so individual segments can't
+    // compute their own polygon in isolation. See
+    // `nodes/src/stair/floorplan.ts` for the emitter.
+    floorplan: buildStairFloorplan,
+    floorplanMoveTarget: stairFloorplanMoveTarget,
+    // 2D drag affordances mirror the 3D in-world arrows on selected stairs:
+    //   - `segment-width` / `segment-length` drive per-segment side & length
+    //     arrows on straight stairs (sister to `StairSegmentSideArrow` /
+    //     `StairSegmentLengthArrow` in stair-segment-handles.tsx).
+    //   - `curved-width` / `curved-inner-radius` / `curved-sweep` drive the
+    //     parent-stair arrows for curved & spiral kinds (sister to
+    //     `CurvedStairWidthArrow` / `CurvedStairInnerRadiusArrow` /
+    //     `CurvedStairSweepArrow`).
+    // Height / rise arrows from the 3D set don't translate — no vertical axis
+    // in the plan view.
+    floorplanAffordances: {
+        'segment-width': segmentWidthAffordance,
+        'segment-length': segmentLengthAffordance,
+        'curved-width': curvedStairWidthAffordance,
+        'curved-inner-radius': curvedStairInnerRadiusAffordance,
+        'curved-sweep': curvedStairSweepAffordance,
+        'stair-rotate': stairRotateAffordance,
+    },
+    presentation: {
+        label: 'Stair',
+        description: 'A stair composed of one or more flights with configurable treads, risers, railings.',
+        icon: { kind: 'url', src: '/icons/stairs.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 110,
+    },
+    mcp: {
+        description: 'A multi-flight stair with segmented geometry.',
+    },
+};

package/dist/stair/floor-stack.d.ts

@@ -0,0 +1,10 @@
+import type { AnyNode, AnyNodeId, FloorPlacedFootprint, StairNode, StairSegmentNode } from '@pascal-app/core';
+type SegmentTransform = {
+    position: [number, number, number];
+    rotation: number;
+};
+export declare function getStairFloorPlacedFootprints(stair: StairNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>): FloorPlacedFootprint[];
+export declare function getStairSegmentFloorPlacedFootprints(stair: StairNode, segments: readonly StairSegmentNode[]): FloorPlacedFootprint[];
+export declare function computeStairSegmentFloorStackTransforms(segments: readonly StairSegmentNode[]): SegmentTransform[];
+export {};
+//# sourceMappingURL=floor-stack.d.ts.map

package/dist/stair/floor-stack.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floor-stack.d.ts","sourceRoot":"","sources":["../../src/stair/floor-stack.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,OAAO,EACP,SAAS,EACT,oBAAoB,EACpB,SAAS,EACT,gBAAgB,EACjB,MAAM,kBAAkB,CAAA;AAEzB,KAAK,gBAAgB,GAAG;IACtB,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,oBAAoB,EAAE,CAMxB;AAED,wBAAgB,oCAAoC,CAClD,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,oBAAoB,EAAE,CA4BxB;AAED,wBAAgB,uCAAuC,CACrD,QAAQ,EAAE,SAAS,gBAAgB,EAAE,GACpC,gBAAgB,EAAE,CAgDpB"}

package/dist/stair/floor-stack.js

@@ -0,0 +1,77 @@
+export function getStairFloorPlacedFootprints(stair, nodes) {
+    const segments = (stair.children ?? [])
+        .map((childId) => nodes[childId])
+        .filter((node) => node?.type === 'stair-segment');
+    return getStairSegmentFloorPlacedFootprints(stair, segments);
+}
+export function getStairSegmentFloorPlacedFootprints(stair, segments) {
+    const transforms = computeStairSegmentFloorStackTransforms(segments);
+    return segments.map((segment, index) => {
+        const transform = transforms[index];
+        const [centerOffsetX, centerOffsetZ] = rotateXZ(0, segment.length / 2, transform.rotation);
+        const centerInGroupX = transform.position[0] + centerOffsetX;
+        const centerInGroupZ = transform.position[2] + centerOffsetZ;
+        const [centerOffsetWorldX, centerOffsetWorldZ] = rotateXZ(centerInGroupX, centerInGroupZ, stair.rotation);
+        return {
+            position: [
+                stair.position[0] + centerOffsetWorldX,
+                stair.position[1] + transform.position[1],
+                stair.position[2] + centerOffsetWorldZ,
+            ],
+            dimensions: [
+                segment.width,
+                Math.max(segment.height, segment.thickness, 0.01),
+                segment.length,
+            ],
+            rotation: [0, stair.rotation + transform.rotation, 0],
+        };
+    });
+}
+export function computeStairSegmentFloorStackTransforms(segments) {
+    const transforms = [];
+    let currentX = 0;
+    let currentY = 0;
+    let currentZ = 0;
+    let currentRot = 0;
+    for (let index = 0; index < segments.length; index += 1) {
+        const segment = segments[index];
+        if (index > 0) {
+            const previous = segments[index - 1];
+            let attachX = 0;
+            let attachZ = 0;
+            let rotationDelta = 0;
+            switch (segment.attachmentSide) {
+                case 'front':
+                    attachX = 0;
+                    attachZ = previous.length;
+                    rotationDelta = 0;
+                    break;
+                case 'left':
+                    attachX = previous.width / 2;
+                    attachZ = previous.length / 2;
+                    rotationDelta = Math.PI / 2;
+                    break;
+                case 'right':
+                    attachX = -previous.width / 2;
+                    attachZ = previous.length / 2;
+                    rotationDelta = -Math.PI / 2;
+                    break;
+            }
+            const [rotatedX, rotatedZ] = rotateXZ(attachX, attachZ, currentRot);
+            currentX += rotatedX;
+            currentY += previous.height;
+            currentZ += rotatedZ;
+            currentRot += rotationDelta;
+        }
+        transforms.push({
+            position: [currentX, currentY, currentZ],
+            rotation: currentRot,
+        });
+    }
+    return transforms;
+}
+function rotateXZ(x, z, angle) {
+    const cos = Math.cos(angle);
+    const sin = Math.sin(angle);
+    return [x * cos + z * sin, -x * sin + z * cos];
+}

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

@@ -0,0 +1,53 @@
+import { type FloorplanAffordance, type StairNode } from '@pascal-app/core';
+/**
+ * Straight-stair segment side arrow → segment `width`. Sister to the 3D
+ * `StairSegmentSideArrow` width drag (~line 235 of stair-segment-handles.tsx).
+ * Width grows symmetrically around the segment centerline — the chain
+ * rebuilds from the segment's `width` field, no opposite-edge anchor write
+ * required. `axisX` is the segment-local +X axis in plan coords, captured
+ * at emit-time so the projection stays valid through the drag.
+ */
+export declare const segmentWidthAffordance: FloorplanAffordance<StairNode>;
+/**
+ * Straight-stair segment length arrow → segment `length`. Sister to the 3D
+ * `StairSegmentLengthArrow` drag. The chain anchors each segment's back
+ * face, so length simply extends/contracts the front. `axisZ` is the
+ * segment-local +Z (run) direction in plan coords.
+ */
+export declare const segmentLengthAffordance: FloorplanAffordance<StairNode>;
+/**
+ * Curved / spiral width arrow → stair `width`. Drag radially outward grows
+ * the body, anchored at the inner radius (matches the 3D
+ * `CurvedStairWidthArrow`). The sweep bisector matches the existing
+ * floor-plan emitter (`sectorStartAngle = -rotation - sweep/2`, bisector
+ * = -rotation).
+ */
+export declare const curvedStairWidthAffordance: FloorplanAffordance<StairNode>;
+/**
+ * Curved / spiral inner-radius arrow → stair `innerRadius` + `width`. Keeps
+ * the outer edge pinned (width absorbs the radial delta) so dragging only
+ * shifts the inner rim, matching the 3D `CurvedStairInnerRadiusArrow`.
+ */
+export declare const curvedStairInnerRadiusAffordance: FloorplanAffordance<StairNode>;
+/**
+ * Whole-stair rotation gizmo → stair `rotation`. Mirrors the 3D
+ * `stairRotateHandle` (arc-resize, curved-arrow shape). Angular drag
+ * around the stair's plan-space pivot — atan2 ticks CW visually, the
+ * stored `rotation` field is the schema's Y-axis radians, and the
+ * floorplan plots sectors at `-rotation`, so a positive cursor delta
+ * (CCW around the centre in standard math coords / CW on screen given
+ * inverted Y) should DECREASE `rotation`. Same `- delta` convention the
+ * 3D handle uses; cursor handedness across both views matches.
+ */
+export declare const stairRotateAffordance: FloorplanAffordance<StairNode>;
+/**
+ * Curved / spiral sweep arrows → stair `sweepAngle` + `rotation`. Anchors
+ * the opposite edge world-fixed by nudging `rotation` by half the applied
+ * sweep delta — mirror of the 3D `CurvedStairSweepArrow`. Sign math derives
+ * from the floorplan convention `sectorStartAngle = -rotation - sweep/2`:
+ *
+ *   END handle  (sweep += Δ, fix start): ΔR = -Δ/2
+ *   START handle (sweep -= Δ, fix end):  ΔR = +Δ/2
+ */
+export declare const curvedStairSweepAffordance: FloorplanAffordance<StairNode>;
+//# sourceMappingURL=floorplan-affordances.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAExB,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AAuCzB;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,SAAS,CA+BjE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,SAAS,CA8BlE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CA6BrE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,EAAE,mBAAmB,CAAC,SAAS,CA4C3E,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CA8BhE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CA6CrE,CAAA"}