@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/stair/parametrics.js

@@ -1,4 +1,184 @@
+import { planStairRiseEdit } from '@pascal-app/core';
+import { StairConstructionField } from './construction-controls';
+import { StairRailingField } from './railing-controls';
 export const stairParametrics = {
-    groups: [],
+    groups: [
+        {
+            label: 'Construction',
+            fields: [
+                {
+                    key: 'construction',
+                    kind: 'custom',
+                    component: StairConstructionField,
+                },
+            ],
+        },
+        {
+            label: 'Type',
+            fields: [
+                {
+                    key: 'stairType',
+                    kind: 'enum',
+                    options: ['straight', 'curved', 'spiral'],
+                    display: 'segmented',
+                },
+            ],
+        },
+        {
+            label: 'Opening',
+            fields: [
+                { key: 'fromLevelId', kind: 'ref', label: 'From level', refKind: 'level' },
+                { key: 'toLevelId', kind: 'ref', label: 'To level', refKind: 'level' },
+                {
+                    key: 'slabOpeningMode',
+                    kind: 'enum',
+                    label: 'Auto cutout',
+                    options: ['none', 'destination'],
+                    display: 'segmented',
+                },
+                {
+                    key: 'openingOffset',
+                    kind: 'number',
+                    label: 'Opening offset',
+                    unit: 'm',
+                    step: 0.01,
+                    visibleIf: (node) => node.slabOpeningMode === 'destination',
+                },
+            ],
+        },
+        {
+            label: 'Geometry',
+            fields: [
+                {
+                    key: 'width',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.001,
+                    step: 0.05,
+                    visibleIf: (node) => node.stairType !== 'straight',
+                },
+                {
+                    key: 'stepCount',
+                    kind: 'number',
+                    label: 'Steps',
+                    min: 2,
+                    step: 1,
+                    visibleIf: (node) => node.stairType !== 'straight',
+                },
+                {
+                    key: 'fillToFloor',
+                    kind: 'boolean',
+                    label: 'Fill to floor',
+                    visibleIf: (node) => node.stairType === 'curved',
+                },
+                {
+                    key: 'thickness',
+                    kind: 'number',
+                    unit: 'm',
+                    min: 0.001,
+                    step: 0.01,
+                    visibleIf: (node) => node.stairType === 'spiral' || !node.fillToFloor,
+                },
+                {
+                    key: 'innerRadius',
+                    kind: 'number',
+                    label: 'Inner radius',
+                    unit: 'm',
+                    min: 0.001,
+                    step: 0.05,
+                    visibleIf: (node) => node.stairType !== 'straight',
+                },
+                {
+                    key: 'sweepAngle',
+                    kind: 'number',
+                    label: 'Sweep (rad)',
+                    step: Math.PI / 180,
+                    visibleIf: (node) => node.stairType !== 'straight',
+                },
+                {
+                    key: 'showCenterColumn',
+                    kind: 'boolean',
+                    label: 'Center column',
+                    visibleIf: (node) => node.stairType === 'spiral',
+                },
+                {
+                    key: 'showStepSupports',
+                    kind: 'boolean',
+                    label: 'Step supports',
+                    visibleIf: (node) => node.stairType === 'spiral',
+                },
+                {
+                    key: 'topLandingMode',
+                    kind: 'enum',
+                    label: 'Top landing',
+                    options: ['none', 'integrated'],
+                    display: 'segmented',
+                    visibleIf: (node) => node.stairType === 'spiral',
+                },
+                {
+                    key: 'topLandingDepth',
+                    kind: 'number',
+                    label: 'Landing depth',
+                    unit: 'm',
+                    min: 0.001,
+                    step: 0.05,
+                    visibleIf: (node) => node.stairType === 'spiral' && node.topLandingMode === 'integrated',
+                },
+            ],
+        },
+        {
+            label: 'Position',
+            fields: [
+                { key: 'position', kind: 'vec3' },
+                {
+                    key: 'rotation',
+                    kind: 'number',
+                    label: 'Rotation (rad)',
+                    min: -Math.PI,
+                    max: Math.PI,
+                    step: Math.PI / 36,
+                },
+            ],
+        },
+        {
+            label: 'Railing',
+            fields: [
+                {
+                    key: 'railingStyle',
+                    kind: 'enum',
+                    options: ['balusters', 'post-and-rail', 'cable', 'boards', 'glass', 'metal'],
+                },
+                {
+                    key: 'railingPath',
+                    kind: 'custom',
+                    label: 'Rail layout and handrail',
+                    component: StairRailingField,
+                },
+                {
+                    key: 'railingMode',
+                    kind: 'enum',
+                    options: ['none', 'left', 'right', 'both'],
+                },
+                {
+                    key: 'railingHeight',
+                    kind: 'number',
+                    label: 'Railing height',
+                    unit: 'm',
+                    min: 0.001,
+                    step: 0.02,
+                    visibleIf: (node) => node.railingMode !== 'none',
+                },
+            ],
+        },
+    ],
+    derive: (next, patch, previous) => patch.stairType === 'spiral' && previous?.stairType !== 'spiral'
+        ? {
+            position: [next.position[0], 0, next.position[2]],
+            sweepAngle: (400 * Math.PI) / 180,
+        }
+        : {},
+    reconcile: (previous, next, nodes) => next.totalRise !== previous.totalRise && next.totalRise !== undefined
+        ? planStairRiseEdit(next, next.totalRise, nodes).slice(1)
+        : [],
     customPanel: () => import('./panel'),
 };

package/dist/stair/plan-entry.d.ts

@@ -0,0 +1,31 @@
+import type { Point2D, StairNode, StairSegmentNode } from '@pascal-app/core';
+type FloorplanLineSegment = {
+    start: Point2D;
+    end: Point2D;
+};
+export type FloorplanStairSegmentEntry = {
+    centerLine: FloorplanLineSegment | null;
+    innerPolygon: Point2D[];
+    segment: StairSegmentNode;
+    polygon: Point2D[];
+    treadBars: Point2D[][];
+    treadThickness: number;
+};
+export type FloorplanStairArrowEntry = {
+    head: Point2D[];
+    polyline: Point2D[];
+};
+export type FloorplanStairEntry = {
+    arrow: FloorplanStairArrowEntry | null;
+    hitPolygons: Point2D[][];
+    stair: StairNode;
+    segments: FloorplanStairSegmentEntry[];
+};
+export type StairSegmentTransform = {
+    position: [number, number, number];
+    rotation: number;
+};
+export declare function getFloorplanStairSegmentPolygon(stair: StairNode, segment: StairSegmentNode, transform: StairSegmentTransform, includeNosing?: boolean): Point2D[];
+export declare function buildFloorplanStairEntry(stair: StairNode, segments: StairSegmentNode[], footprintsOnly?: boolean): FloorplanStairEntry | null;
+export {};
+//# sourceMappingURL=plan-entry.d.ts.map

package/dist/stair/plan-entry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"plan-entry.d.ts","sourceRoot":"","sources":["../../src/stair/plan-entry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAoB5E,KAAK,oBAAoB,GAAG;IAAE,KAAK,EAAE,OAAO,CAAC;IAAC,GAAG,EAAE,OAAO,CAAA;CAAE,CAAA;AAC5D,MAAM,MAAM,0BAA0B,GAAG;IACvC,UAAU,EAAE,oBAAoB,GAAG,IAAI,CAAA;IACvC,YAAY,EAAE,OAAO,EAAE,CAAA;IACvB,OAAO,EAAE,gBAAgB,CAAA;IACzB,OAAO,EAAE,OAAO,EAAE,CAAA;IAClB,SAAS,EAAE,OAAO,EAAE,EAAE,CAAA;IACtB,cAAc,EAAE,MAAM,CAAA;CACvB,CAAA;AAED,MAAM,MAAM,wBAAwB,GAAG;IACrC,IAAI,EAAE,OAAO,EAAE,CAAA;IACf,QAAQ,EAAE,OAAO,EAAE,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,mBAAmB,GAAG;IAChC,KAAK,EAAE,wBAAwB,GAAG,IAAI,CAAA;IACtC,WAAW,EAAE,OAAO,EAAE,EAAE,CAAA;IACxB,KAAK,EAAE,SAAS,CAAA;IAChB,QAAQ,EAAE,0BAA0B,EAAE,CAAA;CACvC,CAAA;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,QAAQ,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAClC,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AA8TD,wBAAgB,+BAA+B,CAC7C,KAAK,EAAE,SAAS,EAChB,OAAO,EAAE,gBAAgB,EACzB,SAAS,EAAE,qBAAqB,EAChC,aAAa,UAAO,GACnB,OAAO,EAAE,CA0BX;AAED,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,SAAS,EAChB,QAAQ,EAAE,gBAAgB,EAAE,EAC5B,cAAc,UAAQ,GACrB,mBAAmB,GAAG,IAAI,CAiG5B"}

package/dist/stair/plan-entry.js

@@ -0,0 +1,325 @@
+import { computeSegmentTransforms, measureStairDetail, resolveStairArcDimensions, resolveStairConstruction, resolveStairWalkingPaths, resolveStairWinder, resolveStairWinderFootprint, stairSegmentDetailError, } from '@pascal-app/core';
+import { clampPlanValue, getPlanPointDistance, getThickPlanLinePolygon, interpolatePlanPoint, movePlanPointTowards, rotatePlanVector, } from '@pascal-app/editor';
+const FLOORPLAN_STAIR_OUTLINE_BAND_THICKNESS = 0.05;
+const FLOORPLAN_STAIR_OUTLINE_MAX_FRACTION = 0.18;
+const FLOORPLAN_STAIR_TREAD_BAND_THICKNESS = 0.05 * 0.82;
+const FLOORPLAN_STAIR_TREAD_MIN_THICKNESS = 0.02 * 1.5;
+const FLOORPLAN_STAIR_ARROW_HEAD_MIN_SIZE = 0.14;
+const FLOORPLAN_STAIR_ARROW_HEAD_MAX_SIZE = 0.24;
+function getFloorplanStairSegmentCenterLine(polygon) {
+    if (polygon.length < 4) {
+        return null;
+    }
+    const [backLeft, backRight, frontRight, frontLeft] = polygon;
+    return {
+        start: interpolatePlanPoint(backLeft, backRight, 0.5),
+        end: interpolatePlanPoint(frontLeft, frontRight, 0.5),
+    };
+}
+function getFloorplanStairInnerPolygon(polygon) {
+    if (polygon.length < 4) {
+        return polygon;
+    }
+    const [backLeft, backRight, frontRight, frontLeft] = polygon;
+    const outerWidth = getPlanPointDistance(backLeft, backRight);
+    const outerLength = getPlanPointDistance(backLeft, frontLeft);
+    const widthInset = Math.min(FLOORPLAN_STAIR_OUTLINE_BAND_THICKNESS, outerWidth * FLOORPLAN_STAIR_OUTLINE_MAX_FRACTION);
+    const lengthInset = Math.min(FLOORPLAN_STAIR_OUTLINE_BAND_THICKNESS, outerLength * FLOORPLAN_STAIR_OUTLINE_MAX_FRACTION);
+    const insetBackLeft = movePlanPointTowards(backLeft, frontLeft, lengthInset);
+    const insetBackRight = movePlanPointTowards(backRight, frontRight, lengthInset);
+    const insetFrontLeft = movePlanPointTowards(frontLeft, backLeft, lengthInset);
+    const insetFrontRight = movePlanPointTowards(frontRight, backRight, lengthInset);
+    const innerPolygon = [
+        movePlanPointTowards(insetBackLeft, insetBackRight, widthInset),
+        movePlanPointTowards(insetBackRight, insetBackLeft, widthInset),
+        movePlanPointTowards(insetFrontRight, insetFrontLeft, widthInset),
+        movePlanPointTowards(insetFrontLeft, insetFrontRight, widthInset),
+    ];
+    const innerWidth = getPlanPointDistance(innerPolygon[0], innerPolygon[1]);
+    const innerLength = getPlanPointDistance(innerPolygon[0], innerPolygon[3]);
+    return innerWidth > 0.06 && innerLength > 0.06 ? innerPolygon : polygon;
+}
+function getFloorplanStairTreadLines(segment, innerPolygon) {
+    if (stairSegmentDetailError(segment))
+        return [];
+    if (segment.segmentType !== 'stair' || segment.stepCount <= 1 || innerPolygon.length < 4) {
+        return [];
+    }
+    const [backLeft, backRight, frontRight, frontLeft] = innerPolygon;
+    const treadLines = [];
+    for (let stepIndex = 1; stepIndex < segment.stepCount; stepIndex += 1) {
+        const t = stepIndex / segment.stepCount;
+        treadLines.push({
+            start: interpolatePlanPoint(backLeft, frontLeft, t),
+            end: interpolatePlanPoint(backRight, frontRight, t),
+        });
+    }
+    return treadLines;
+}
+function getFloorplanStairTreadThickness(segment, innerPolygon) {
+    if (segment.segmentType !== 'stair' || segment.stepCount <= 1 || innerPolygon.length < 4) {
+        return 0;
+    }
+    const innerWidth = getPlanPointDistance(innerPolygon[0], innerPolygon[1]);
+    const innerLength = getPlanPointDistance(innerPolygon[0], innerPolygon[3]);
+    const treadRun = innerLength / Math.max(segment.stepCount, 1);
+    return clampPlanValue(Math.min(FLOORPLAN_STAIR_TREAD_BAND_THICKNESS, innerWidth * 0.12, treadRun * 0.44), FLOORPLAN_STAIR_TREAD_MIN_THICKNESS, FLOORPLAN_STAIR_TREAD_BAND_THICKNESS);
+}
+function getFloorplanStairTreadBars(segment, innerPolygon, treadThickness = getFloorplanStairTreadThickness(segment, innerPolygon)) {
+    const treadLines = getFloorplanStairTreadLines(segment, innerPolygon);
+    if (treadLines.length === 0 || treadThickness <= 0) {
+        return [];
+    }
+    return treadLines.map((line) => getThickPlanLinePolygon(line, treadThickness));
+}
+function getFloorplanStairSegmentCenterPoint(segment) {
+    if (segment.centerLine) {
+        return interpolatePlanPoint(segment.centerLine.start, segment.centerLine.end, 0.5);
+    }
+    if (segment.polygon.length < 4) {
+        return null;
+    }
+    const [backLeft, backRight, frontRight, frontLeft] = segment.polygon;
+    return {
+        x: (backLeft.x + backRight.x + frontRight.x + frontLeft.x) / 4,
+        y: (backLeft.y + backRight.y + frontRight.y + frontLeft.y) / 4,
+    };
+}
+function getFloorplanStairSegmentSidePoint(segment, side) {
+    if (segment.polygon.length < 4) {
+        return null;
+    }
+    const [backLeft, backRight, frontRight, frontLeft] = segment.polygon;
+    switch (side) {
+        case 'back':
+            return interpolatePlanPoint(backLeft, backRight, 0.5);
+        case 'front':
+            return interpolatePlanPoint(frontLeft, frontRight, 0.5);
+        case 'left':
+            return interpolatePlanPoint(backLeft, frontLeft, 0.5);
+        case 'right':
+            return interpolatePlanPoint(backRight, frontRight, 0.5);
+    }
+}
+function getFloorplanStairExitSide(nextSegment) {
+    if (!nextSegment) {
+        return 'front';
+    }
+    if (nextSegment.attachmentSide === 'left') {
+        return 'right';
+    }
+    if (nextSegment.attachmentSide === 'right') {
+        return 'left';
+    }
+    return 'front';
+}
+function appendUniquePlanPoint(points, point) {
+    if (!point) {
+        return;
+    }
+    const lastPoint = points[points.length - 1];
+    if (lastPoint && getPlanPointDistance(lastPoint, point) <= 0.001) {
+        return;
+    }
+    points.push(point);
+}
+function getFloorplanArcPoint(center, radius, angle) {
+    return {
+        x: center.x + Math.cos(angle) * radius,
+        y: center.y + Math.sin(angle) * radius,
+    };
+}
+function getFloorplanCurvedStairHitPolygon(stair) {
+    const layout = resolveStairArcDimensions(stair, 0);
+    const { innerRadius, outerRadius, sweepAngle } = layout;
+    const visualSweepAngle = Math.sign(sweepAngle || 1) *
+        Math.min(Math.abs(sweepAngle + layout.landingSweep + layout.nosingSweep), Math.PI * 2);
+    const startAngle = -stair.rotation - sweepAngle / 2 - layout.nosingSweep;
+    const endAngle = startAngle + visualSweepAngle;
+    const center = { x: stair.position[0], y: stair.position[2] };
+    const outerArcLength = Math.abs(visualSweepAngle) * outerRadius;
+    const segmentCount = Math.min(256, Math.max(24, Math.ceil(Math.abs(visualSweepAngle) / (Math.PI / 24)), Math.ceil(outerArcLength / 0.14)));
+    const outerPoints = [];
+    const innerPoints = [];
+    for (let index = 0; index <= segmentCount; index += 1) {
+        const t = index / segmentCount;
+        const angle = startAngle + (endAngle - startAngle) * t;
+        outerPoints.push(getFloorplanArcPoint(center, outerRadius, angle));
+        innerPoints.push(getFloorplanArcPoint(center, innerRadius, angle));
+    }
+    return [...outerPoints, ...innerPoints.reverse()];
+}
+function buildFloorplanStairArrow(segments) {
+    const rawPoints = [];
+    for (let segmentIndex = 0; segmentIndex < segments.length; segmentIndex += 1) {
+        const segment = segments[segmentIndex];
+        const nextSegment = segments[segmentIndex + 1]?.segment;
+        const entryPoint = getFloorplanStairSegmentSidePoint(segment, 'back');
+        const exitPoint = getFloorplanStairSegmentSidePoint(segment, getFloorplanStairExitSide(nextSegment));
+        if (!(entryPoint && exitPoint)) {
+            continue;
+        }
+        appendUniquePlanPoint(rawPoints, entryPoint);
+        const isStraightSegment = getPlanPointDistance(entryPoint, exitPoint) <= 0.001;
+        if (isStraightSegment) {
+            continue;
+        }
+        const exitSide = getFloorplanStairExitSide(nextSegment);
+        if (exitSide === 'front') {
+            appendUniquePlanPoint(rawPoints, exitPoint);
+            continue;
+        }
+        appendUniquePlanPoint(rawPoints, getFloorplanStairSegmentCenterPoint(segment));
+        appendUniquePlanPoint(rawPoints, exitPoint);
+    }
+    if (rawPoints.length < 2) {
+        return null;
+    }
+    const firstPoint = rawPoints[0];
+    const secondPoint = rawPoints[1];
+    const beforeLastPoint = rawPoints[rawPoints.length - 2];
+    const lastPoint = rawPoints[rawPoints.length - 1];
+    const firstLength = getPlanPointDistance(firstPoint, secondPoint);
+    const lastLength = getPlanPointDistance(beforeLastPoint, lastPoint);
+    if (firstLength <= Number.EPSILON || lastLength <= Number.EPSILON) {
+        return null;
+    }
+    const polyline = [
+        movePlanPointTowards(firstPoint, secondPoint, Math.min(0.24, firstLength * 0.18)),
+        ...rawPoints.slice(1, -1),
+        movePlanPointTowards(lastPoint, beforeLastPoint, Math.min(0.3, lastLength * 0.22)),
+    ];
+    const arrowTailPoint = polyline[polyline.length - 2];
+    const arrowTip = polyline[polyline.length - 1];
+    if (!(arrowTailPoint && arrowTip)) {
+        return null;
+    }
+    const arrowBodyLength = getPlanPointDistance(arrowTailPoint, arrowTip);
+    if (arrowBodyLength <= Number.EPSILON) {
+        return null;
+    }
+    const arrowHeadLength = clampPlanValue(arrowBodyLength * 0.72, FLOORPLAN_STAIR_ARROW_HEAD_MIN_SIZE, FLOORPLAN_STAIR_ARROW_HEAD_MAX_SIZE);
+    const arrowHeadBase = movePlanPointTowards(arrowTip, arrowTailPoint, arrowHeadLength);
+    const directionX = arrowTip.x - arrowHeadBase.x;
+    const directionY = arrowTip.y - arrowHeadBase.y;
+    const directionLength = Math.hypot(directionX, directionY);
+    if (directionLength <= Number.EPSILON) {
+        return null;
+    }
+    const normalX = -directionY / directionLength;
+    const normalY = directionX / directionLength;
+    const arrowHeadHalfWidth = arrowHeadLength * 0.34;
+    return {
+        head: [
+            arrowTip,
+            {
+                x: arrowHeadBase.x + normalX * arrowHeadHalfWidth,
+                y: arrowHeadBase.y + normalY * arrowHeadHalfWidth,
+            },
+            {
+                x: arrowHeadBase.x - normalX * arrowHeadHalfWidth,
+                y: arrowHeadBase.y - normalY * arrowHeadHalfWidth,
+            },
+        ],
+        polyline,
+    };
+}
+export function getFloorplanStairSegmentPolygon(stair, segment, transform, includeNosing = true) {
+    const halfWidth = segment.width / 2;
+    const nose = includeNosing && segment.segmentType !== 'landing'
+        ? (resolveStairConstruction(segment, stair)?.nosing ?? 0)
+        : 0;
+    const localCorners = (includeNosing
+        ? resolveStairWinderFootprint(segment, stair)
+        : resolveStairWinder(segment)?.footprint) ?? [
+        [-halfWidth, -nose],
+        [halfWidth, -nose],
+        [halfWidth, segment.length],
+        [-halfWidth, segment.length],
+    ];
+    return localCorners.map(([localX, localY]) => {
+        const [segmentX, segmentY] = rotatePlanVector(localX, localY, transform.rotation);
+        const groupX = transform.position[0] + segmentX;
+        const groupY = transform.position[2] + segmentY;
+        const [worldOffsetX, worldOffsetY] = rotatePlanVector(groupX, groupY, stair.rotation);
+        return {
+            x: stair.position[0] + worldOffsetX,
+            y: stair.position[2] + worldOffsetY,
+        };
+    });
+}
+export function buildFloorplanStairEntry(stair, segments, footprintsOnly = false) {
+    const stairType = stair.stairType ?? 'straight';
+    const detailAllowed = !footprintsOnly && !measureStairDetail(stair, segments).error;
+    if (segments.length === 0 && stairType === 'straight') {
+        return null;
+    }
+    const transforms = computeSegmentTransforms(segments);
+    const segmentEntries = segments.map((segment, index) => {
+        const polygon = getFloorplanStairSegmentPolygon(stair, segment, transforms[index]);
+        const walkingPolygon = getFloorplanStairSegmentPolygon(stair, segment, transforms[index], false);
+        const winder = resolveStairWinder(segment);
+        const transform = transforms[index];
+        const point = ([x, z]) => {
+            const [sx, sz] = rotatePlanVector(x, z, transform.rotation);
+            const [wx, wz] = rotatePlanVector(transform.position[0] + sx, transform.position[2] + sz, stair.rotation);
+            return { x: stair.position[0] + wx, y: stair.position[2] + wz };
+        };
+        const centerLine = winder
+            ? {
+                start: point([winder.walkingLine[0][0], winder.walkingLine[0][2]]),
+                end: point([winder.walkingLine.at(-1)[0], winder.walkingLine.at(-1)[2]]),
+            }
+            : getFloorplanStairSegmentCenterLine(walkingPolygon);
+        const innerPolygon = winder ? polygon : getFloorplanStairInnerPolygon(polygon);
+        const walkingInner = getFloorplanStairInnerPolygon(walkingPolygon);
+        const treadThickness = getFloorplanStairTreadThickness(segment, walkingInner);
+        return {
+            centerLine,
+            innerPolygon,
+            segment,
+            polygon,
+            treadBars: detailAllowed
+                ? winder
+                    ? winder.treads.slice(0, -1).map((tread) => {
+                        const n = tread.polygon.length / 2;
+                        return getThickPlanLinePolygon({ start: point(tread.polygon[n - 1]), end: point(tread.polygon[n]) }, 0.025);
+                    })
+                    : getFloorplanStairTreadBars(segment, walkingInner, treadThickness)
+                : [],
+            treadThickness,
+        };
+    });
+    const visibleEntries = segmentEntries.filter((entry) => entry.segment.visible !== false);
+    const hitPolygons = stairType === 'straight'
+        ? visibleEntries.map(({ polygon }) => polygon)
+        : [getFloorplanCurvedStairHitPolygon(stair)];
+    return {
+        arrow: segments.some((segment) => segment.winder)
+            ? (() => {
+                const path = resolveStairWalkingPaths(stair, segments, segments.reduce((sum, segment) => sum + segment.height, 0)).at(-1);
+                if (!path || path.length < 2)
+                    return null;
+                const polyline = path.map(([x, , z]) => {
+                    const [wx, wz] = rotatePlanVector(x, z, stair.rotation);
+                    return { x: stair.position[0] + wx, y: stair.position[2] + wz };
+                });
+                const tip = polyline.at(-1), prev = polyline.at(-2), length = Math.hypot(tip.x - prev.x, tip.y - prev.y);
+                if (length < 1e-8)
+                    return null;
+                const dx = (tip.x - prev.x) / length, dy = (tip.y - prev.y) / length, size = Math.min(0.2, length * 0.8);
+                return {
+                    polyline,
+                    head: [
+                        tip,
+                        { x: tip.x - dx * size - dy * size * 0.34, y: tip.y - dy * size + dx * size * 0.34 },
+                        { x: tip.x - dx * size + dy * size * 0.34, y: tip.y - dy * size - dx * size * 0.34 },
+                    ],
+                };
+            })()
+            : buildFloorplanStairArrow(visibleEntries),
+        hitPolygons,
+        stair,
+        segments: visibleEntries,
+    };
+}

package/dist/stair/post-and-rail-guard.d.ts

@@ -0,0 +1,31 @@
+/**
+ * One coherent deck post-and-rail guard laid out along a rail path, as oriented
+ * boxes — the AWC Deck Construction Guide (DCA 6) guard in metres: a 4x4 post
+ * at each end (and every bay ≤ 4 ft between), a flat 2x6 cap over them with a
+ * 2x4 top rail on edge under it, a 2x4 bottom rail held off the nosing line,
+ * and 1½ in square pickets between the rails at a gap under the 4 in sphere
+ * (IRC R312.1.3). It shares the path sampling, corner finding and newel/picket
+ * stations in `guard-path.ts` with the baluster guard, 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 guard; only the sections and
+ * joinery differ from the balusters. Pure data — no Three.js, no React.
+ *
+ * `reach` runs the rails 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 PostAndRailGuardOptions = {
+    railHeight: number;
+    /** Metres between posts along the run; omit (or Infinity) for ends only. */
+    postSpacing?: number;
+    topPost?: boolean;
+    postThrough?: boolean;
+    /** Metres the rails run past the top vertex, along the final slope. */
+    reach?: number;
+};
+/** The deck guard's rails, bottom-to-top: a 2x4 bottom rail, a 2x4 top rail on
+ * edge under the cap, and the flat 2x6 cap. Shared with the flight connector. */
+export declare function postAndRailGuardRails(railHeight: number): GuardRail[];
+export declare function buildPostAndRailGuard(points: Vec3[], options: PostAndRailGuardOptions): GuardBox[];
+//# sourceMappingURL=post-and-rail-guard.d.ts.map

package/dist/stair/post-and-rail-guard.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"post-and-rail-guard.d.ts","sourceRoot":"","sources":["../../src/stair/post-and-rail-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;GAeG;AAEH,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,SAAS,EAEd,KAAK,IAAI,EACV,MAAM,cAAc,CAAA;AAErB,MAAM,MAAM,uBAAuB,GAAG;IACpC,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,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAkBD;iFACiF;AACjF,wBAAgB,qBAAqB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,CAMrE;AAED,wBAAgB,qBAAqB,CACnC,MAAM,EAAE,IAAI,EAAE,EACd,OAAO,EAAE,uBAAuB,GAC/B,QAAQ,EAAE,CA4BZ"}

package/dist/stair/post-and-rail-guard.js

@@ -0,0 +1,63 @@
+/**
+ * One coherent deck post-and-rail guard laid out along a rail path, as oriented
+ * boxes — the AWC Deck Construction Guide (DCA 6) guard in metres: a 4x4 post
+ * at each end (and every bay ≤ 4 ft between), a flat 2x6 cap over them with a
+ * 2x4 top rail on edge under it, a 2x4 bottom rail held off the nosing line,
+ * and 1½ in square pickets between the rails at a gap under the 4 in sphere
+ * (IRC R312.1.3). It shares the path sampling, corner finding and newel/picket
+ * stations in `guard-path.ts` with the baluster guard, 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 guard; only the sections and
+ * joinery differ from the balusters. Pure data — no Three.js, no React.
+ *
+ * `reach` runs the rails 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 { buildGuardChassis, guardPickets, } from './guard-path';
+// Dressed deck lumber, in metres.
+const POST = 0.0889; // 4x4
+const POST_EMBED = 0.05; // the post foot runs this far below the nosing line
+const CAP_W = 0.1397; // 2x6 cap, laid flat
+const CAP_T = 0.0381;
+const RAIL_T = 0.0381; // 2x4 rail across the run
+const RAIL_D = 0.0889; // on edge, so this is its vertical depth
+const BOTTOM_CLEAR = 0.0889; // underside of the bottom rail over the nosing line
+const PICKET = 0.0381; // 2x2 picket
+const PICKET_GAP = 0.0889; // 3½ in nominal gap
+/** The widest clear gap left between pickets, in metres (0.1016 m = 4 in sphere). */
+const PICKET_MAX_GAP = 0.1016;
+const POST_ABOVE_CAP = 0.0762; // a through-post stands this far above the cap…
+const POST_CAP_T = 0.0254; // …under a 1 in cap of its own
+const POST_CAP_OVERHANG = 0.0508;
+/** The deck guard's rails, bottom-to-top: a 2x4 bottom rail, a 2x4 top rail on
+ * edge under the cap, and the flat 2x6 cap. Shared with the flight connector. */
+export function postAndRailGuardRails(railHeight) {
+    return [
+        { y: BOTTOM_CLEAR + RAIL_D / 2, across: RAIL_T, vertical: RAIL_D },
+        { y: railHeight - CAP_T - RAIL_D / 2, across: RAIL_T, vertical: RAIL_D },
+        { y: railHeight - CAP_T / 2, across: CAP_W, vertical: CAP_T },
+    ];
+}
+export function buildPostAndRailGuard(points, options) {
+    const { railHeight } = options;
+    const chassis = buildGuardChassis(points, options, postAndRailGuardRails(railHeight), {
+        width: POST,
+        embed: POST_EMBED,
+        top: -CAP_T,
+        throughTop: POST_ABOVE_CAP,
+        capThickness: POST_CAP_T,
+        capOverhang: POST_CAP_OVERHANG,
+    }, {
+        picketPitch: PICKET + PICKET_GAP,
+        picketMinPitch: PICKET + 0.02,
+        picketMaxPitch: PICKET_MAX_GAP + PICKET,
+    });
+    if (!chassis)
+        return [];
+    const { path, boxes } = chassis;
+    if (path.kind === 'pivot')
+        return boxes;
+    boxes.push(...guardPickets(path, PICKET, POST, BOTTOM_CLEAR + RAIL_D, railHeight - CAP_T - RAIL_D));
+    return boxes;
+}

package/dist/stair/railing-controls.d.ts

@@ -0,0 +1,9 @@
+import { type StairNode } from '@pascal-app/core';
+export declare function StairRailingControls({ node, onChange, }: {
+    node: StairNode;
+    onChange: (patch: Partial<StairNode>) => void;
+}): import("react").JSX.Element;
+export declare function StairRailingField({ node }: {
+    node: StairNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=railing-controls.d.ts.map

package/dist/stair/railing-controls.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"railing-controls.d.ts","sourceRoot":"","sources":["../../src/stair/railing-controls.tsx"],"names":[],"mappings":"AACA,OAAO,EAAkB,KAAK,SAAS,EAAY,MAAM,kBAAkB,CAAA;AAS3E,wBAAgB,oBAAoB,CAAC,EACnC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,SAAS,CAAA;IACf,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,IAAI,CAAA;CAC9C,+BAkHA;AACD,wBAAgB,iBAAiB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,+BAO9D"}