@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/stair/definition.js

@@ -1,10 +1,8 @@
-import { resolveStairTotalRise, StairNode as StairNodeSchema, stairFootprintAABB, useScene, } 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;
+import { planStairSweepEdit, resolveStairTotalRise, resolveStairWinder, StairNode as StairNodeSchema, stairFootprintAABB, stairSlots, useScene, } from '@pascal-app/core';
+const MIN_CURVED_RISE = 0.001;
+const MIN_CURVED_WIDTH = 0.001;
+const MIN_CURVED_INNER_RADIUS_SPIRAL = 0.001;
+const MIN_CURVED_INNER_RADIUS_CURVED = 0.001;
 const CURVED_RISE_OFFSET = 0.35;
 const CURVED_WIDTH_HANDLE_OFFSET = 0.5;
 const CURVED_RADIAL_OFFSET = 0.16;
@@ -22,7 +20,7 @@ const STAIR_ROTATE_CORNER_OFFSET = 0.4;
 const STAIR_ROTATE_RING_OFFSET = 0.08;
 const STAIR_MOVE_FRONT_OFFSET = 0.35;
 function readTotalRise(node) {
-    return Math.max(resolveStairTotalRise(node, useScene.getState().nodes), 0.1);
+    return Math.max(resolveStairTotalRise(node, useScene.getState().nodes), 0.001);
 }
 function readCurvedStairGeometry(node) {
     const isSpiral = node.stairType === 'spiral';
@@ -84,12 +82,13 @@ function readStraightStairMoveBounds(node, sceneApi) {
         if (!transform)
             return;
         const halfWidth = segment.width / 2;
-        const corners = [
-            [-halfWidth, 0],
-            [halfWidth, 0],
-            [-halfWidth, segment.length],
-            [halfWidth, segment.length],
-        ];
+        const corners = resolveStairWinder(segment)?.footprint ??
+            [
+                [-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);
@@ -204,26 +203,7 @@ function curvedSweepHandle(end) {
         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,
-            };
-        },
+        apply: (initial, delta) => planStairSweepEdit(initial, delta, end),
         placement: {
             position: (n) => {
                 const g = readCurvedStairGeometry(n);
@@ -331,14 +311,13 @@ function stairHandles(node) {
     handles.push(stairRotateHandle(), stairMoveHandle());
     return handles;
 }
-import { computeStairSegmentFloorStackTransforms, getStairFloorPlacedFootprints, } from './floor-stack';
+import { computeStairSegmentFloorStackTransforms, getStairFloorPlacedFootprints, } from '@pascal-app/core';
 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
@@ -346,7 +325,7 @@ import { stairSlots } from './slots';
  */
 export const stairDefinition = {
     kind: 'stair',
-    schemaVersion: 1,
+    schemaVersion: 2,
     schema: StairNode,
     category: 'structure',
     extensions: {
@@ -375,6 +354,7 @@ export const stairDefinition = {
         return rest;
     },
     capabilities: {
+        surfacePlacement: 'floor-only',
         selectable: { hitVolume: 'bbox' },
         // A stair has no centred box footprint: straight = a cumulative
         // `stair-segment` chain, curved / spiral = an annular sector. Hand the
@@ -401,6 +381,7 @@ export const stairDefinition = {
     },
     parametrics: stairParametrics,
     handles: stairHandles,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/stair/documentation.d.ts

@@ -1,5 +1,5 @@
 import { type FloorplanGeometry, type GeometryContext, type StairNode } from '@pascal-app/core';
-import type { FloorplanStairArrowEntry, FloorplanStairEntry } from '@pascal-app/editor';
+import type { FloorplanStairArrowEntry, FloorplanStairEntry } from './plan-entry';
 export type StairPlanDirection = 'up' | 'down';
 export declare function resolveStairPlanDirection(stair: StairNode, activeLevelId: string | null | undefined): StairPlanDirection;
 export declare function resolveStraightStairDirectionArrow(entry: FloorplanStairEntry, direction: StairPlanDirection): FloorplanStairArrowEntry | null;

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

@@ -1 +1 @@
-{"version":3,"file":"documentation.d.ts","sourceRoot":"","sources":["../../src/stair/documentation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAGpB,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EAEpB,MAAM,oBAAoB,CAAA;AAgB3B,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG,MAAM,CAAA;AAE9C,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,EAChB,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACvC,kBAAkB,CAUpB;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,mBAAmB,EAC1B,SAAS,EAAE,kBAAkB,GAC5B,wBAAwB,GAAG,IAAI,CA0BjC;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,eAAe,GACnB,iBAAiB,EAAE,CAYrB"}
+{"version":3,"file":"documentation.d.ts","sourceRoot":"","sources":["../../src/stair/documentation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAKpB,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AAOzB,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EAEpB,MAAM,cAAc,CAAA;AAUrB,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG,MAAM,CAAA;AAE9C,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,EAChB,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACvC,kBAAkB,CAUpB;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,mBAAmB,EAC1B,SAAS,EAAE,kBAAkB,GAC5B,wBAAwB,GAAG,IAAI,CA0BjC;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,eAAe,GACnB,iBAAiB,EAAE,CAYrB"}

package/dist/stair/documentation.js

@@ -1,4 +1,4 @@
-import { resolveStairTotalRise, useScene, } from '@pascal-app/core';
+import { resolveStairArcDimensions, resolveStairTotalRise, resolveStairWinder, useScene, } from '@pascal-app/core';
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
 import { formatConstructionLength, } from '../shared/construction-length';
 const ANNOTATION_OFFSET = 0.28;
@@ -80,6 +80,12 @@ function buildStraightDocumentation(stair, entry, direction, unit, profile, metr
     for (const segmentEntry of entry.segments) {
         if (segmentEntry.segment.segmentType !== 'stair')
             continue;
+        if (segmentEntry.segment.winder) {
+            const segment = segmentEntry.segment, layout = resolveStairWinder(segment);
+            const anchor = segmentEntry.polygon[0];
+            geometries.push(annotationText({ x: anchor.x + 0.18, y: anchor.y + 0.18 }, `${segment.stepCount} R @ ${formatConstructionLength(segment.height / segment.stepCount, unit, profile, { metricNotation })} · WINDER T ${formatConstructionLength(layout.going, unit, profile, { metricNotation })} · CLR W ${formatConstructionLength(segment.width, unit, profile, { metricNotation })}`, ANNOTATION_FONT_SIZE, stroke));
+            continue;
+        }
         const frame = segmentFrame(segmentEntry);
         if (!frame)
             continue;
@@ -104,16 +110,10 @@ function buildStraightDocumentation(stair, entry, direction, unit, profile, metr
     return geometries;
 }
 function buildCurvedDocumentation(stair, direction, unit, profile, metricNotation, stroke) {
-    const stairType = stair.stairType === 'spiral' ? 'spiral' : 'curved';
-    const stepCount = Math.max(stairType === 'spiral' ? 6 : 4, Math.round(stair.stepCount));
-    const sweep = normalizedSweep(stair);
+    const layout = resolveStairArcDimensions(stair, resolveStairTotalRise(stair, useScene.getState().nodes));
+    const { stepCount, sweepAngle: sweep, innerRadius, outerRadius, walkingRadius, riserHeight, going: treadDepth, } = layout;
     const startAngle = -stair.rotation - sweep / 2;
     const endAngle = startAngle + sweep;
-    const innerRadius = Math.max(stairType === 'spiral' ? 0.05 : 0.2, stair.innerRadius);
-    const outerRadius = innerRadius + stair.width;
-    const walkingRadius = innerRadius + stair.width / 2;
-    const riserHeight = resolveStairTotalRise(stair, useScene.getState().nodes) / stepCount;
-    const treadDepth = (Math.abs(sweep) * walkingRadius) / stepCount;
     const center = { x: stair.position[0], y: stair.position[2] };
     const noteAngle = (startAngle + endAngle) / 2;
     const notePoint = arcPoint(center, outerRadius + ANNOTATION_OFFSET, noteAngle);
@@ -121,7 +121,7 @@ function buildCurvedDocumentation(stair, direction, unit, profile, metricNotatio
     const directionPoint = arcPoint(center, walkingRadius, directionAngle);
     const breakAngle = startAngle + sweep * BREAK_POSITION;
     const geometries = [
-        annotationText(notePoint, `${stepCount} R @ ${formatConstructionLength(riserHeight, unit, profile, { metricNotation })} · T(CL) ${formatConstructionLength(treadDepth, unit, profile, { metricNotation })} · CLR W ${formatConstructionLength(stair.width, unit, profile, { metricNotation })}`, ANNOTATION_FONT_SIZE, stroke),
+        annotationText(notePoint, `${stepCount} R @ ${formatConstructionLength(riserHeight, unit, profile, { metricNotation })} · T(CL) ${formatConstructionLength(treadDepth, unit, profile, { metricNotation })} · CLR W ${formatConstructionLength(layout.width, unit, profile, { metricNotation })}`, ANNOTATION_FONT_SIZE, stroke),
         annotationText(directionPoint, direction === 'up' ? 'UP' : 'DN', DIRECTION_FONT_SIZE, stroke),
         buildCurvedBreakLine(center, innerRadius, outerRadius, breakAngle, stroke),
     ];
@@ -212,13 +212,6 @@ function segmentFrame(segmentEntry) {
         rightMid: interpolate(backRight, frontRight, 0.5),
     };
 }
-function normalizedSweep(stair) {
-    const defaultSweep = stair.stairType === 'spiral' ? Math.PI * 2 : Math.PI / 2;
-    const sweep = stair.sweepAngle ?? defaultSweep;
-    if (Math.abs(sweep) < Math.PI * 2)
-        return sweep;
-    return Math.sign(sweep || 1) * (Math.PI * 2 - 0.001);
-}
 function arcPoint(center, radius, angle) {
     return { x: center.x + Math.cos(angle) * radius, y: center.y + Math.sin(angle) * radius };
 }

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

@@ -1 +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,EAIf,MAAM,kBAAkB,CAAA;AAwCzB;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,SAAS,CAiCjE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,SAAS,CAgClE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CA+BrE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,EAAE,mBAAmB,CAAC,SAAS,CAiD3E,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CAgChE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CAkDrE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAGxB,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAmCzB;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,SAAS,CAiCjE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,SAAS,CAgClE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CA+BrE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,EAAE,mBAAmB,CAAC,SAAS,CAiD3E,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CAgChE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CAyCrE,CAAA"}

package/dist/stair/floorplan-affordances.js

@@ -1,16 +1,11 @@
-import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { createAngleAccumulator, planStairSweepEdit, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { isAngleSnapActive } from '@pascal-app/editor';
 import { rotateAffordanceDelta } from '../shared/rotate-affordance';
-// Minimums + max sweep mirror the 3D handles in
-// `packages/editor/src/components/editor/stair-segment-handles.tsx` so a 2D
-// drag can't push a stair past what the 3D drag would allow.
-const MIN_SEGMENT_WIDTH = 0.4;
-const MIN_SEGMENT_LENGTH = 0.4;
-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 MIN_SEGMENT_WIDTH = 0.001;
+const MIN_SEGMENT_LENGTH = 0.001;
+const MIN_CURVED_WIDTH = 0.001;
+const MIN_CURVED_INNER_RADIUS_SPIRAL = 0.001;
+const MIN_CURVED_INNER_RADIUS_CURVED = 0.001;
 function noopSession() {
     return {
         affectedIds: [],
@@ -241,30 +236,19 @@ export const curvedStairSweepAffordance = {
         const { end } = payload;
         const stairId = node.id;
         const initialSweep = node.sweepAngle ?? (node.stairType === 'spiral' ? Math.PI * 2 : Math.PI / 2);
-        const sweepSign = Math.sign(initialSweep) || 1;
         const initialRotation = node.rotation;
         const cx = node.position[0];
         const cz = node.position[2];
         const initialAngle = Math.atan2(initialPlanPoint[1] - cz, initialPlanPoint[0] - cx);
+        const accumulateAngle = createAngleAccumulator(initialAngle);
         let lastSweep = initialSweep;
         let lastRotation = initialRotation;
         return {
             affectedIds: [stairId],
             apply({ planPoint }) {
                 const currentAngle = Math.atan2(planPoint[1] - cz, planPoint[0] - cx);
-                let delta = currentAngle - initialAngle;
-                // Wrap to [-π, π] so a drag crossing ±π doesn't flip sign mid-gesture.
-                while (delta > Math.PI)
-                    delta -= 2 * Math.PI;
-                while (delta < -Math.PI)
-                    delta += 2 * Math.PI;
-                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;
-                const rotationShift = end === 'end' ? -appliedDelta / 2 : appliedDelta / 2;
-                const newRotation = initialRotation + rotationShift;
+                const delta = accumulateAngle(currentAngle);
+                const { sweepAngle: newSweep, rotation: newRotation } = planStairSweepEdit({ sweepAngle: initialSweep, rotation: initialRotation }, delta, end);
                 lastSweep = newSweep;
                 lastRotation = newRotation;
                 useLiveNodeOverrides.getState().set(stairId, {

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.
- */
+/** The stair parent emits its complete cumulative segment chain. */
 export declare function buildStairFloorplan(stair: 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,KAAK,EAAE,SAAS,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA8gB1B"}

package/dist/stair/floorplan.js

@@ -1,38 +1,40 @@
+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 { 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.
- */
+import { buildFloorplanStairEntry } from './plan-entry';
+/** The stair parent emits its complete cumulative segment chain. */
 export function buildStairFloorplan(stair, ctx) {
-    const segments = (ctx.children ?? []).filter((child) => child.type === 'stair-segment' && child.visible !== false);
-    const entry = buildFloorplanStairEntry(stair, segments);
+    const segments = (ctx.children ?? []).filter((child) => child.type === 'stair-segment');
+    const detail = measureStairDetail(stair, (ctx.children ?? []).filter((child) => child.type === 'stair-segment'));
+    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 +100,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 +180,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 +207,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 +215,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 +232,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 +278,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 +378,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 +436,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 +482,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';
+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