@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/stair/floorplan-move.js

@@ -1,6 +1,6 @@
-import { collectAlignmentAnchors, movingAlignmentAnchors, snapScalar, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { collectAlignmentAnchors, getFloorStackedPosition, movingAlignmentAnchors, resolveStairSurfaceSnap, snapScalar, useLiveNodeOverrides, } from '@pascal-app/core';
 import { applyFloorplanAlignment, getSegmentGridStep, isGridSnapActive, isMagneticSnapActive, } from '@pascal-app/editor';
-import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
+import { createFloorplanCursorResolver } from '../shared/floorplan-cursor.js';
 /**
  * 2D floor-plan move handler for stair.
  *
@@ -13,7 +13,10 @@ import { createFloorplanCursorResolver } from '../shared/floorplan-cursor';
  * The position previews through the live override store and is written to
  * scene once via `commit()`.
  */
-export const stairFloorplanMoveTarget = ({ node, nodes }) => {
+export const stairFloorplanMoveTarget = ({ node: picked, nodes, sceneApi, }) => {
+    // The stair as the scene holds it now: a surface it sits on may have re-hosted it since
+    // it was picked up.
+    const node = nodes[picked.id] ?? picked;
     const startY = node.position[1];
     const resolveCursor = createFloorplanCursorResolver({
         original: [node.position[0], node.position[2]],
@@ -22,8 +25,12 @@ export const stairFloorplanMoveTarget = ({ node, nodes }) => {
     // Alignment candidates gathered once — the scene is stable during the drag.
     const candidates = collectAlignmentAnchors(nodes, node.id);
     let lastValid = null;
+    const flight = node.children
+        .map((id) => nodes[id])
+        .find((child) => child?.type === 'stair-segment' && child.segmentType === 'stair');
+    let surfaceSnap = null;
     const session = {
-        affectedIds: [node.id],
+        affectedIds: flight ? [node.id, flight.id] : [node.id],
         apply({ planPoint }) {
             const step = isGridSnapActive() ? getSegmentGridStep() : 0;
             const snap = (value) => (step > 0 ? snapScalar(value, step) : value);
@@ -36,17 +43,56 @@ export const stairFloorplanMoveTarget = ({ node, nodes }) => {
                 : [{ nodeId: node.id, kind: 'corner', x: gx, z: gz }], candidates, { applySnap: isMagneticSnapActive() });
             const sx = aligned[0];
             const sz = aligned[1];
-            if (lastValid && lastValid.position[0] === sx && lastValid.position[2] === sz)
+            const sceneNodes = sceneApi?.nodes() ?? nodes;
+            const baseElevation = getFloorStackedPosition({
+                node,
+                nodes: sceneNodes,
+                position: [sx, startY, sz],
+                rotation: node.rotation,
+                levelId: node.parentId,
+            })[1];
+            surfaceSnap = !isMagneticSnapActive()
+                ? null
+                : resolveStairSurfaceSnap(node, sceneNodes, [sx, startY, sz], flight?.length ?? 3, baseElevation, sceneApi?.installedPlugins?.());
+            const position = surfaceSnap?.position ?? [sx, startY, sz];
+            if (lastValid &&
+                lastValid.position[0] === position[0] &&
+                lastValid.position[2] === position[2] &&
+                lastValid.rotation === surfaceSnap?.rotation)
                 return;
-            lastValid = { position: [sx, startY, sz] };
-            useLiveNodeOverrides.getState().set(node.id, lastValid);
-            useScene.getState().markDirty(node.id);
+            lastValid = { position, ...(surfaceSnap ? { rotation: surfaceSnap.rotation } : {}) };
+            if (!surfaceSnap)
+                useLiveNodeOverrides.getState().clear(node.id);
+            useLiveNodeOverrides.getState().set(node.id, {
+                ...lastValid,
+                ...(surfaceSnap
+                    ? {
+                        totalRise: surfaceSnap.totalRise,
+                        stepCount: surfaceSnap.stepCount,
+                        destinationSurfaceId: surfaceSnap.surfaceId,
+                        railingMode: 'none',
+                    }
+                    : { destinationSurfaceId: undefined }),
+            });
+            if (flight) {
+                if (surfaceSnap)
+                    useLiveNodeOverrides.getState().set(flight.id, {
+                        height: surfaceSnap.totalRise,
+                        length: surfaceSnap.length,
+                        stepCount: surfaceSnap.stepCount,
+                    });
+                else
+                    useLiveNodeOverrides.getState().clear(flight.id);
+            }
+            sceneApi?.markDirty(node.id);
+            if (flight)
+                sceneApi?.markDirty(flight.id);
         },
         canCommit() {
             // No overlap / placement rules for stairs in 2D — any pointer-up
             // position commits, as long as we actually moved. Mirrors the 3D
             // move tool which also lets stairs land anywhere on the slab.
-            return lastValid !== null;
+            return lastValid !== null && Boolean(sceneApi?.applyChanges);
         },
         commit() {
             // Own the atomic write so the overlay takes the deterministic
@@ -55,7 +101,41 @@ export const stairFloorplanMoveTarget = ({ node, nodes }) => {
             if (!lastValid)
                 return;
             useLiveNodeOverrides.getState().clear(node.id);
-            useScene.getState().updateNodes([{ id: node.id, data: lastValid }]);
+            if (flight)
+                useLiveNodeOverrides.getState().clear(flight.id);
+            sceneApi?.applyChanges?.({
+                update: [
+                    {
+                        id: node.id,
+                        data: {
+                            ...lastValid,
+                            ...(surfaceSnap
+                                ? {
+                                    totalRise: surfaceSnap.totalRise,
+                                    stepCount: surfaceSnap.stepCount,
+                                    slabOpeningMode: 'none',
+                                    destinationSurfaceId: surfaceSnap.surfaceId,
+                                    railingMode: 'none',
+                                }
+                                : node.destinationSurfaceId
+                                    ? { destinationSurfaceId: undefined }
+                                    : {}),
+                        },
+                    },
+                    ...(surfaceSnap && flight
+                        ? [
+                            {
+                                id: flight.id,
+                                data: {
+                                    height: surfaceSnap.totalRise,
+                                    length: surfaceSnap.length,
+                                    stepCount: surfaceSnap.stepCount,
+                                },
+                            },
+                        ]
+                        : []),
+                ],
+            });
         },
     };
     return session;

package/dist/stair/floorplan.d.ts

@@ -1,26 +1,4 @@
 import type { FloorplanGeometry, GeometryContext, StairNode } from '@pascal-app/core';
-/**
- * Stage C floor-plan emitter for stair. The stair is the parent; its
- * children are the `stair-segment`s whose transforms are *cumulative*
- * (each flight attaches to the previous segment's end via
- * `computeFloorplanStairSegmentTransforms` — `attachmentSide` rotates
- * the chain ±π/2, segment length advances along the chain). Because no
- * individual segment can compute its polygon in isolation, the stair
- * emits the whole stack as one registry entry; `stair-segment` itself
- * has no `def.floorplan` (the registry layer renders the parent here
- * and skips children that don't ship a builder).
- *
- * The actual cumulative walk + segment / arrow / inner-band / tread-bar
- * geometry lives in `editor/src/lib/floorplan/stairs.ts` via
- * `buildFloorplanStairEntry`. We re-export that from `@pascal-app/editor`
- * and emit `FloorplanGeometry` primitives over its output — same shape
- * pattern the legacy `<FloorplanStairLayer>` consumed, minus the
- * per-pixel SVG drawing (the registry's `FloorplanGeometryRenderer`
- * handles that). Curved + spiral stairs fall back to a single curved
- * hit polygon (`buildFloorplanStairEntry` already returns it); the
- * arc-band rendering with steps along the sweep is not yet ported —
- * a follow-up will add either an `arc` primitive or expose the
- * segment-sampler helpers so we can emit a stitched polyline.
- */
-export declare function buildStairFloorplan(stair: StairNode, ctx: GeometryContext): FloorplanGeometry | null;
+/** The stair parent emits its complete cumulative segment chain. */
+export declare function buildStairFloorplan(rawStair: StairNode, ctx: GeometryContext): FloorplanGeometry | null;
 //# sourceMappingURL=floorplan.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAEjB,eAAe,EACf,SAAS,EAEV,MAAM,kBAAkB,CAAA;AAuBzB;;;;;;;;;;;;;;;;;;;;;;GAsBG;AACH,wBAAgB,mBAAmB,CACjC,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAoc1B"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,iBAAiB,EAEjB,eAAe,EACf,SAAS,EAEV,MAAM,kBAAkB,CAAA;AAiCzB,oEAAoE;AACpE,wBAAgB,mBAAmB,CACjC,QAAQ,EAAE,SAAS,EACnB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAoiB1B"}

package/dist/stair/floorplan.js

@@ -1,38 +1,59 @@
+import { computeSegmentTransforms, measureStairDetail, resolveStairArcDimensions, resolveStairHandrailPaths, resolveStairRailPaths, resolveStairWalkingPaths, rotateXZ, } from '@pascal-app/core';
 // Offset from the stair's footprint edge to the rotation chevron's
 // origin. Same magnitude as `STAIR_ROTATE_CORNER_OFFSET` in
 // `definition.ts` so the 2D handle visually lines up with where the 3D
 // curved-arrow gizmo would sit at the matching world point.
 const STAIR_ROTATE_PLAN_OFFSET = 0.4;
-import { buildFloorplanStairEntry, buildSvgAnnularSectorPath, buildSvgArcPath, buildSvgArrowHeadPoints, floorplanGeometryMetadata, getArcPlanPoint, } from '@pascal-app/editor';
-import { buildStairDocumentation, resolveStairPlanDirection, resolveStraightStairDirectionArrow, stairPlanBreakStep, } from './documentation';
-/**
- * Stage C floor-plan emitter for stair. The stair is the parent; its
- * children are the `stair-segment`s whose transforms are *cumulative*
- * (each flight attaches to the previous segment's end via
- * `computeFloorplanStairSegmentTransforms` — `attachmentSide` rotates
- * the chain ±π/2, segment length advances along the chain). Because no
- * individual segment can compute its polygon in isolation, the stair
- * emits the whole stack as one registry entry; `stair-segment` itself
- * has no `def.floorplan` (the registry layer renders the parent here
- * and skips children that don't ship a builder).
- *
- * The actual cumulative walk + segment / arrow / inner-band / tread-bar
- * geometry lives in `editor/src/lib/floorplan/stairs.ts` via
- * `buildFloorplanStairEntry`. We re-export that from `@pascal-app/editor`
- * and emit `FloorplanGeometry` primitives over its output — same shape
- * pattern the legacy `<FloorplanStairLayer>` consumed, minus the
- * per-pixel SVG drawing (the registry's `FloorplanGeometryRenderer`
- * handles that). Curved + spiral stairs fall back to a single curved
- * hit polygon (`buildFloorplanStairEntry` already returns it); the
- * arc-band rendering with steps along the sweep is not yet ported —
- * a follow-up will add either an `arc` primitive or expose the
- * segment-sampler helpers so we can emit a stitched polyline.
- */
-export function buildStairFloorplan(stair, ctx) {
-    const segments = (ctx.children ?? []).filter((child) => child.type === 'stair-segment' && child.visible !== false);
-    const entry = buildFloorplanStairEntry(stair, segments);
+import { buildSvgAnnularSectorPath, buildSvgArcPath, buildSvgArrowHeadPoints, floorplanGeometryMetadata, getArcPlanPoint, } from '@pascal-app/editor';
+import { buildStairDocumentation, resolveStairPlanDirection, resolveStraightStairDirectionArrow, stairPlanBreakStep, } from './documentation.js';
+import { buildFloorplanStairEntry } from './plan-entry.js';
+/** The stair parent emits its complete cumulative segment chain. */
+export function buildStairFloorplan(rawStair, ctx) {
+    const parent = ctx.parent;
+    let stair = rawStair;
+    if (parent && parent.id === rawStair.destinationSurfaceId && parent.position && parent.rotation) {
+        const angle = parent.rotation[1];
+        const c = Math.cos(angle), s = Math.sin(angle);
+        const [x, y, z] = rawStair.position;
+        stair = {
+            ...rawStair,
+            parentId: parent.parentId ?? null,
+            position: [
+                parent.position[0] + c * x + s * z,
+                parent.position[1] + y,
+                parent.position[2] - s * x + c * z,
+            ],
+            rotation: rawStair.rotation + angle,
+        };
+    }
+    const segments = (ctx.children ?? [])
+        .map((child) => ctx.resolve(child.id) ?? child)
+        .filter((child) => child.type === 'stair-segment' && child.visible !== false);
+    const detail = measureStairDetail(stair, segments);
+    const entry = buildFloorplanStairEntry(stair, segments, !!detail.error);
     if (!entry)
         return null;
+    if (detail.error)
+        return {
+            kind: 'group',
+            children: [
+                ...entry.hitPolygons.map((polygon) => ({
+                    kind: 'polygon',
+                    points: toFloorplanPoints(polygon),
+                    fill: 'none',
+                    stroke: '#b45309',
+                    strokeWidth: 0.025,
+                })),
+                {
+                    kind: 'text',
+                    x: stair.position[0],
+                    y: stair.position[2],
+                    text: 'Stair detail unavailable — inspect dimensions',
+                    fontSize: 0.15,
+                    fill: '#b45309',
+                },
+            ],
+        };
     const view = ctx.viewState;
     const palette = view?.palette;
     const isSelected = view?.selected ?? false;
@@ -98,7 +119,23 @@ export function buildStairFloorplan(stair, ctx) {
             // (~lines 235 / 375 of stair-segment-handles.tsx).
             // Skip when the stair is being placed — placement-mode arrows would
             // compete with the cursor follow.
-            if (isSelected && !view?.moving) {
+            if (isSelected && !view?.moving && segmentEntry.segment.winder) {
+                const index = segments.findIndex((segment) => segment.id === segmentEntry.segment.id), transform = computeSegmentTransforms(segments)[index];
+                const angle = stair.rotation + transform.rotation;
+                const [ax, az] = rotateXZ(1, 0, angle);
+                for (const side of ['left', 'right']) {
+                    const [sx, sz] = rotateXZ(((side === 'right' ? 1 : -1) * segmentEntry.segment.width) / 2, 0, transform.rotation);
+                    const [wx, wz] = rotateXZ(transform.position[0] + sx, transform.position[2] + sz, stair.rotation);
+                    children.push({
+                        kind: 'move-arrow',
+                        point: [stair.position[0] + wx, stair.position[2] + wz],
+                        angle: Math.atan2(az, ax) + (side === 'left' ? Math.PI : 0),
+                        affordance: 'segment-width',
+                        payload: { segmentId: segmentEntry.segment.id, side, axisX: [ax, az] },
+                    });
+                }
+            }
+            if (isSelected && !view?.moving && !segmentEntry.segment.winder) {
                 const poly = segmentEntry.polygon;
                 // Polygon corners (from `getFloorplanStairSegmentPolygon`):
                 //   0 back-left   1 back-right
@@ -162,39 +199,25 @@ export function buildStairFloorplan(stair, ctx) {
         }
     }
     else {
-        // Curved / spiral — full arc-band chrome. Mirrors the legacy
-        // `<FloorplanStairLayer>` curved/spiral branches in
-        // floorplan-panel.tsx (~line 285+).
-        const normalizedSweepAngle = getNormalizedFloorplanStairSweepAngle(stair);
-        const sectorStartAngle = -stair.rotation - normalizedSweepAngle / 2;
-        const sectorEndAngle = sectorStartAngle + normalizedSweepAngle;
-        const spiralLandingSweep = getFloorplanSpiralLandingSweep(stair, normalizedSweepAngle);
-        // SVG `A` (arc) draws a single sub-360° segment. Once the base sweep
-        // is near a full turn and we add up to 0.75π of integrated landing
-        // on top, the total `visualSectorEnd - sectorStart` overflows 2π and
-        // the path becomes malformed (the whole stair chrome breaks). Cap
-        // the COMBINED visual sweep to just under a full revolution — past
-        // that, the landing visually overlaps the start of the arc, which
-        // is exactly the multi-turn "stack on top of each other" behaviour
-        // we want for spirals with > 360° rotation.
-        const rawVisualSweep = normalizedSweepAngle + spiralLandingSweep;
-        const sweepCap = Math.PI * 2 - 0.001;
-        const visualSweep = Math.sign(rawVisualSweep || 1) * Math.min(Math.abs(rawVisualSweep), sweepCap);
-        const visualSectorEndAngle = sectorStartAngle + visualSweep;
+        const layout = resolveStairArcDimensions(stair, 0);
+        const normalizedSweepAngle = layout.sweepAngle;
+        const sectorStartAngle = -stair.rotation - layout.sweepAngle / 2;
+        const sectorEndAngle = sectorStartAngle + layout.sweepAngle;
+        const visualSweep = Math.sign(layout.sweepAngle || 1) *
+            Math.min(Math.abs(layout.sweepAngle + layout.landingSweep + layout.nosingSweep), Math.PI * 2);
+        const visualSectorStartAngle = sectorStartAngle - layout.nosingSweep;
+        const visualSectorEndAngle = visualSectorStartAngle + visualSweep;
         const stairCenter = { x: stair.position[0], y: stair.position[2] };
-        const innerRadius = Math.max(stairType === 'spiral' ? 0.05 : 0.2, stair.innerRadius ?? (stairType === 'spiral' ? 0.2 : 0.9));
-        const outerRadius = innerRadius + stair.width;
-        const centerlineRadius = innerRadius + stair.width / 2;
+        const { innerRadius, outerRadius, walkingRadius: centerlineRadius } = layout;
         // Stroke widths are screen pixels (paired with `vectorEffect:
         // 'non-scaling-stroke'` below). World-metre values like 0.02 would
-        // render as sub-pixel — invisible at every zoom. Matches the legacy
-        // `<FloorplanStairLayer>` curved/spiral branches.
+        // render as sub-pixel — invisible at every zoom.
         const outerArcWidth = showSelectedChrome ? 2 : 1.4;
         const innerArcWidth = showSelectedChrome ? 1.7 : 1.2;
         // 1. Annular sector — the filled shaft footprint.
         children.push({
             kind: 'path',
-            d: buildSvgAnnularSectorPath(stairCenter, innerRadius, outerRadius, sectorStartAngle, visualSectorEndAngle),
+            d: buildSvgAnnularSectorPath(stairCenter, innerRadius, outerRadius, visualSectorStartAngle, visualSectorEndAngle),
             fill,
             fillOpacity: 1,
             stroke: 'none',
@@ -203,7 +226,7 @@ export function buildStairFloorplan(stair, ctx) {
         // 2. Outer + inner arcs.
         children.push({
             kind: 'path',
-            d: buildSvgArcPath(stairCenter, outerRadius, sectorStartAngle, visualSectorEndAngle),
+            d: buildSvgArcPath(stairCenter, outerRadius, visualSectorStartAngle, visualSectorEndAngle),
             fill: 'none',
             stroke: stairStroke,
             strokeWidth: outerArcWidth,
@@ -211,16 +234,14 @@ export function buildStairFloorplan(stair, ctx) {
         });
         children.push({
             kind: 'path',
-            d: buildSvgArcPath(stairCenter, innerRadius, sectorStartAngle, visualSectorEndAngle),
+            d: buildSvgArcPath(stairCenter, innerRadius, visualSectorStartAngle, visualSectorEndAngle),
             fill: 'none',
             stroke: stairStroke,
             strokeWidth: innerArcWidth,
             vectorEffect: 'non-scaling-stroke',
         });
         // 3. Step lines (radial spokes).
-        const stepBase = stairType === 'spiral' ? 6 : 4;
-        const stepCount = Math.max(stepBase, Math.round(stair.stepCount ?? 10));
-        const stepSweep = normalizedSweepAngle / stepCount;
+        const { stepCount, stepSweep } = layout;
         const breakStep = stairPlanBreakStep(stepCount);
         for (let index = 0; index <= stepCount; index += 1) {
             if (index >= breakStep && index !== stepCount)
@@ -230,9 +251,7 @@ export function buildStairFloorplan(stair, ctx) {
             const outer = getArcPlanPoint(stairCenter, outerRadius, angle);
             const isLast = index === stepCount;
             const isFirst = index === 0;
-            // Curved: regular stroke everywhere, but both the starting and the
-            // ending step lines are bolded (matches the legacy
-            // `<FloorplanStairLayer>` curved branch).
+            // Curved stairs accent both ascent portals.
             // Spiral: only the last step is accented + bolded.
             const isEmphasised = stairType === 'spiral' ? isLast : isFirst || isLast;
             const stepWidth = stairType === 'spiral' ? (isEmphasised ? 1.8 : 1.15) : isEmphasised ? 1.5 : 1.1;
@@ -278,12 +297,12 @@ export function buildStairFloorplan(stair, ctx) {
         // 6. Direction arrow — head only, at the upper end of the sweep.
         const direction = resolveStairPlanDirection(stair, ctx.parent?.type === 'level' ? ctx.parent.id : stair.parentId);
         const arrowAngle = direction === 'up'
-            ? visualSectorEndAngle - stepSweep * 0.8
+            ? sectorEndAngle + layout.landingSweep - stepSweep * 0.8
             : sectorStartAngle + stepSweep * 0.8;
         const arrowPoint = getArcPlanPoint(stairCenter, centerlineRadius, arrowAngle);
         const sweepDirection = normalizedSweepAngle >= 0 ? 1 : -1;
         const tangentAngle = arrowAngle + sweepDirection * (direction === 'up' ? Math.PI / 2 : -Math.PI / 2);
-        const arrowSize = clamp(stair.width * (stairType === 'spiral' ? 0.18 : 0.16), 0.1, 0.18);
+        const arrowSize = clamp(layout.width * (stairType === 'spiral' ? 0.18 : 0.16), 0.1, 0.18);
         const headPts = buildSvgArrowHeadPoints(arrowPoint, tangentAngle, arrowSize);
         children.push({
             kind: 'polygon',
@@ -378,6 +397,44 @@ export function buildStairFloorplan(stair, ctx) {
             });
         }
     }
+    if (isSelected) {
+        const chain = (ctx.children ?? []).filter((child) => child.type === 'stair-segment');
+        for (const path of resolveStairWalkingPaths(stair, chain, 0)) {
+            children.push({
+                kind: 'polyline',
+                points: path.map(([x, , z]) => [
+                    stair.position[0] + x * Math.cos(stair.rotation) + z * Math.sin(stair.rotation),
+                    stair.position[2] - x * Math.sin(stair.rotation) + z * Math.cos(stair.rotation),
+                ]),
+                fill: 'none',
+                stroke: '#2563eb',
+                strokeWidth: 0.035,
+                strokeDasharray: '0.12 0.08',
+                metadata: floorplanGeometryMetadata({
+                    annotationRole: 'stair-annotation',
+                    renderPass: 'overlay',
+                }),
+            });
+        }
+    }
+    const railNodes = Object.fromEntries([stair, ...ctx.children].map((node) => [node.id, node]));
+    const guardPaths = stair.railingPath === 'continuous' ||
+        stair.railingStyle === 'glass' ||
+        stair.railingStyle === 'metal'
+        ? resolveStairRailPaths(stair, railNodes)
+        : [];
+    for (const path of [...guardPaths, ...resolveStairHandrailPaths(stair, railNodes)])
+        children.push({
+            kind: 'polyline',
+            points: path.points.map(([x, , z]) => [
+                stair.position[0] + x * Math.cos(stair.rotation) + z * Math.sin(stair.rotation),
+                stair.position[2] - x * Math.sin(stair.rotation) + z * Math.cos(stair.rotation),
+            ]),
+            fill: 'none',
+            stroke: stairStroke,
+            strokeWidth: 0.02,
+            metadata: floorplanGeometryMetadata({ annotationRole: 'stair-annotation' }),
+        });
     children.push(...buildStairDocumentation(stair, entry, ctx));
     // Whole-stair rotation handle — sister to the 3D `stairRotateHandle`
     // (arc-resize, curved-arrow). 2D doesn't have a dedicated curved-arrow
@@ -398,13 +455,13 @@ export function buildStairFloorplan(stair, ctx) {
         let localX;
         let localZ;
         if (stairType === 'straight') {
-            const stairWidth = Math.max(stair.width ?? 1, 0.4);
+            const stairWidth = Math.max(stair.width ?? 1, 0.001);
             localX = stairWidth / 2 + STAIR_ROTATE_PLAN_OFFSET;
             localZ = -STAIR_ROTATE_PLAN_OFFSET;
         }
         else {
             const isSpiral = stairType === 'spiral';
-            const innerR = Math.max(isSpiral ? 0.05 : 0.2, stair.innerRadius ?? (isSpiral ? 0.2 : 0.9));
+            const innerR = Math.max(0.001, stair.innerRadius ?? (isSpiral ? 0.2 : 0.9));
             const outerR = innerR + (stair.width ?? 1);
             const sweep = stair.sweepAngle ?? (isSpiral ? Math.PI * 2 : Math.PI / 2);
             const radius = outerR + STAIR_ROTATE_PLAN_OFFSET;
@@ -444,25 +501,3 @@ function toFloorplanPoints(points) {
 function clamp(value, min, max) {
     return Math.min(max, Math.max(min, value));
 }
-// Inlined from `editor/lib/floorplan/stairs.ts` — those are private
-// helpers in the legacy file. Both are pure derivations from the stair
-// node, so they live with the registry-driven emitter.
-function getNormalizedFloorplanStairSweepAngle(stair) {
-    const stairType = stair.stairType ?? 'straight';
-    const baseSweepAngle = stair.sweepAngle ?? (stairType === 'spiral' ? Math.PI * 2 : Math.PI / 2);
-    if (Math.abs(baseSweepAngle) >= Math.PI * 2) {
-        return Math.sign(baseSweepAngle || 1) * (Math.PI * 2 - 0.001);
-    }
-    return baseSweepAngle;
-}
-function getFloorplanSpiralLandingSweep(stair, sweepAngle) {
-    if ((stair.stairType ?? 'straight') !== 'spiral' ||
-        (stair.topLandingMode ?? 'none') !== 'integrated') {
-        return 0;
-    }
-    const innerRadius = Math.max(0.05, stair.innerRadius ?? 0.9);
-    const width = Math.max(stair.width ?? 1, 0.4);
-    const landingDepth = Math.max(0.3, stair.topLandingDepth ?? Math.max(width * 0.9, 0.8));
-    return (Math.min(Math.PI * 0.75, landingDepth / Math.max(innerRadius + width / 2, 0.1)) *
-        Math.sign(sweepAngle || 1));
-}

package/dist/stair/glass-guard.d.ts

@@ -0,0 +1,72 @@
+/**
+ * One coherent glass-panel guard laid out along a rail path — a modern framed
+ * glass balustrade in metres: a slim square post at each end (and every bay
+ * ≤ 4 ft between), a flat cap over them, and one flat tempered-glass panel per
+ * bay, point-fixed to its flanking posts by small edge clamps. It shares the
+ * path sampling, corner finding and post stations in `guard-path.ts` with the
+ * baluster, cable and deck guards, so a straight flight, a chained L/U landing
+ * turn, a winder, a curved or spiral sweep and an integrated top landing all
+ * read as the same glass rail; only the sections and the glass infill differ.
+ *
+ * The panels are the physical intent of a glass rail, not a fiction: a tempered
+ * pane is rigid and flat, so on a curved or spiral sweep it cannot follow the
+ * arc. Each panel is therefore a flat parallelogram spanning the straight chord
+ * between two consecutive posts, with plumb vertical edges inset from each post
+ * by a reveal gap and a top/bottom clearance to the cap and the nosing line.
+ * Adjacent panels meet at a post with twice the reveal between them, never
+ * sharing or crossing a vertex. On a straight flight the collinear posts make
+ * those chords read as one plane.
+ *
+ * A flat chord between two posts on a curve lies inside the rail curve by its
+ * sagitta — on the outer rail that is up to tens of centimetres toward the
+ * treads, so a chord laid on the posts would push the pane well past the guard
+ * line into the walking volume. When the caller supplies `insideWalk` (which
+ * side of a point is the walkable surface), each bay measures how far its flat
+ * chord sags toward that surface and shifts the whole pane — and its clamps —
+ * radially outward by that sag plus the pane's half-thickness, so the pane's
+ * walking-facing face sits at or outside the rail line across the entire bay.
+ * The inner rail's chord sags into the void, away from the walkable surface, so
+ * it is left on the line; a straight run has no sag; neither is shifted. The
+ * frame is pure `GuardBox` data; the panels are the corner parametrics the
+ * renderer extrudes with metre UVs. No Three.js.
+ *
+ * `reach` runs the cap that far past the top vertex along the final slope to die
+ * into a post standing there; `topPost: false` then omits the top post.
+ * `postThrough` runs the posts past the cap with a small cap of their own.
+ */
+import { type GuardBox, type GuardRail, type Vec3 } from './guard-path.js';
+export type GlassGuardOptions = {
+    railHeight: number;
+    /** Metres between posts along the run; omit (or Infinity) for ends only. */
+    postSpacing?: number;
+    topPost?: boolean;
+    postThrough?: boolean;
+    /** Metres the cap runs past the top vertex, along the final slope. */
+    reach?: number;
+    /** Whether a horizontal point (in the path's frame) is on the walkable
+     * surface. When given, a bay whose flat chord sags toward that surface shifts
+     * its pane radially outward to keep the pane's face off the walking volume. */
+    insideWalk?: (x: number, z: number) => boolean;
+};
+/** A flat glass panel spanning one bay, as the parallelogram the renderer
+ * extrudes: `start` is its inset bottom corner on the nosing line, `yaw` the
+ * plan heading of its chord, and the panel rises `rise` over `run` horizontally
+ * with its lower and upper edges `bottom` and `top` above the nosing line. */
+export type GlassPanel = {
+    start: Vec3;
+    yaw: number;
+    run: number;
+    rise: number;
+    bottom: number;
+    top: number;
+    thickness: number;
+};
+export type GlassGuard = {
+    frame: GuardBox[];
+    panels: GlassPanel[];
+};
+/** The glass guard's single flat cap rail. Shared with the flight connector so a
+ * bridge between flights carries the same cap as the guards it joins. */
+export declare function glassGuardRails(railHeight: number): GuardRail[];
+export declare function buildGlassGuard(points: Vec3[], options: GlassGuardOptions): GlassGuard;
+//# sourceMappingURL=glass-guard.d.ts.map

package/dist/stair/glass-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"glass-guard.d.ts","sourceRoot":"","sources":["../../src/stair/glass-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AAEH,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,SAAS,EAId,KAAK,IAAI,EACV,MAAM,cAAc,CAAA;AAErB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,UAAU,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,sEAAsE;IACtE,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;mFAE+E;IAC/E,UAAU,CAAC,EAAE,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,KAAK,OAAO,CAAA;CAC/C,CAAA;AAED;;;8EAG8E;AAC9E,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,IAAI,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,GAAG,EAAE,MAAM,CAAA;IACX,IAAI,EAAE,MAAM,CAAA;IACZ,MAAM,EAAE,MAAM,CAAA;IACd,GAAG,EAAE,MAAM,CAAA;IACX,SAAS,EAAE,MAAM,CAAA;CAClB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IAAE,KAAK,EAAE,QAAQ,EAAE,CAAC;IAAC,MAAM,EAAE,UAAU,EAAE,CAAA;CAAE,CAAA;AAmBpE;yEACyE;AACzE,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,CAE/D;AA4DD,wBAAgB,eAAe,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,iBAAiB,GAAG,UAAU,CAsEtF"}