@pascal-app/nodes 1.0.3 → 1.0.4

package/dist/stair/renderer.js

@@ -1,11 +1,19 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { resolveStairTotalRise, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
-import { getStairBodyMaterials, getStairRailingMaterial, NodeRenderer, resolveMaterialRef, resolveSlotDefaultMaterial, useNodeEvents, useViewer, } from '@pascal-app/viewer';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { computeSegmentTransforms, measureStairDetail, resolveArcStairConstruction, resolveStairArcLayout, resolveStairRailPaths, resolveStairWalkingPaths, rotateXZ, STAIR_RAILING_SLOT_DEFAULT, stairArcSliceCount, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { getStairBodyMaterials, getStairRailingMaterial, NodeRenderer, OVERLAY_LAYER, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three';
 import { createPlaceholderGeometry } from '../shared/placeholder-geometry';
-import { STAIR_BODY_SLOT_DEFAULT, STAIR_RAILING_SLOT_DEFAULT, STAIR_TREADS_SLOT_DEFAULT, } from './slots';
+import { mergeGuardBoxes } from './baluster-geometry';
+import { balusterGuardRails, buildBalusterGuard } from './baluster-guard';
+import { boardsGuardRails, buildBoardsGuard } from './boards-guard';
+import { buildCableGuard, cableGuardRails } from './cable-guard';
+import { ContinuousStairRailings } from './continuous-railings';
+import { barBox, GUARD_PICKET_PITCH, GUARD_POST_SPACING, } from './guard-path';
+import { resolveStairBodySlotMaterials, resolveStairSegmentMaterials, resolveStairSlotMaterial, } from './materials';
+import { buildPostAndRailGuard, postAndRailGuardRails } from './post-and-rail-guard';
+import { useStairRenderData } from './use-stair-render-data';
 export const StairRenderer = ({ node: rawNode }) => {
     const ref = useRef(null);
     // Merge any live drag override into the node so curved/spiral geometry
@@ -26,227 +34,255 @@ export const StairRenderer = ({ node: rawNode }) => {
     const colorPreset = useViewer((s) => s.colorPreset);
     const sceneMaterials = useScene((s) => s.materials);
     const baseBodyMaterials = useMemo(() => getStairBodyMaterials(node, shading, textures, colorPreset), [node, shading, textures, colorPreset]);
-    const bodyMaterials = useMemo(() => [
-        resolveStairSlotMaterial(node, 'treads', STAIR_TREADS_SLOT_DEFAULT, baseBodyMaterials[STAIR_TREAD_MATERIAL_INDEX], sceneMaterials, shading, textures),
-        resolveStairSlotMaterial(node, 'body', STAIR_BODY_SLOT_DEFAULT, baseBodyMaterials[STAIR_SIDE_MATERIAL_INDEX], sceneMaterials, shading, textures),
-    ], [baseBodyMaterials, node, sceneMaterials, shading, textures]);
+    const bodyMaterials = useMemo(() => resolveStairBodySlotMaterials(node, baseBodyMaterials, sceneMaterials, shading, textures), [baseBodyMaterials, node, sceneMaterials, shading, textures]);
+    const renderData = useStairRenderData(node);
+    const { segments, totalRise } = renderData;
+    useLayoutEffect(() => {
+        for (const id of node.children)
+            useScene.getState().markDirty(id);
+    }, [node.children, node.construction]);
+    const detail = useMemo(() => measureStairDetail(node, segments), [node, segments]);
+    const mergedMaterials = useMemo(() => segments.length
+        ? segments.flatMap((segment) => resolveStairSegmentMaterials(segment, node, bodyMaterials, sceneMaterials, shading, textures, colorPreset))
+        : bodyMaterials, [segments, node, bodyMaterials, sceneMaterials, shading, textures, colorPreset]);
+    const mergedSlotData = useMemo(() => ({
+        surfaceNodeIds: segments.flatMap((segment) => [segment.id, segment.id]),
+        segmentIds: segments.flatMap((segment) => [segment.id, segment.id]),
+        slotIds: Array.from({ length: Math.max(1, segments.length) }, () => [
+            'treads',
+            'body',
+        ]).flat(),
+    }), [segments]);
     const baseRailingMaterial = useMemo(() => getStairRailingMaterial(node, shading, textures, colorPreset), [node, shading, textures, colorPreset]);
     const railingMaterial = useMemo(() => resolveStairSlotMaterial(node, 'railing', STAIR_RAILING_SLOT_DEFAULT, baseRailingMaterial, sceneMaterials, shading, textures), [baseRailingMaterial, node, sceneMaterials, shading, textures]);
-    // 2 groups map 1:1 to the stair body's 2-material array (treads + body).
+    // Each flight contributes tread and body material groups to the merged mesh.
     const straightPlaceholderGeometry = useMemo(() => createPlaceholderGeometry(2), []);
     useEffect(() => {
         return () => {
             straightPlaceholderGeometry.dispose();
         };
     }, [straightPlaceholderGeometry]);
-    return (_jsxs("group", { "position-x": node.position[0], "position-z": node.position[2], ref: ref, "rotation-y": node.rotation, visible: node.visible, ...handlers, children: [isSegmentBasedStair ? (_jsx("mesh", { castShadow: true, geometry: straightPlaceholderGeometry, material: bodyMaterials, name: "merged-stair", receiveShadow: true, userData: STAIR_BODY_SLOT_USER_DATA })) : null, isSegmentBasedStair ? null : _jsx(CurvedStairBody, { bodyMaterials: bodyMaterials, stair: node }), _jsx(StairRailings, { material: railingMaterial, stair: node }), isSegmentBasedStair ? (_jsx("group", { name: "segments-wrapper", visible: false, children: (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))) })) : null] }));
+    return (_jsxs("group", { "position-x": node.position[0], "position-z": node.position[2], ref: ref, "rotation-y": node.rotation, visible: node.visible, userData: { pascalExportRefusal: detail.error }, ...handlers, children: [isSegmentBasedStair ? (_jsx("mesh", { castShadow: true, geometry: straightPlaceholderGeometry, material: mergedMaterials, name: "merged-stair", receiveShadow: true, userData: mergedSlotData })) : null, isSegmentBasedStair || detail.error ? null : (_jsx(CurvedStairBody, { bodyMaterials: bodyMaterials, stair: node, rise: totalRise })), detail.error ? null : segments.some((segment) => segment.winder) ||
+                node.railingPath === 'continuous' ||
+                node.railingStyle === 'glass' ||
+                node.railingStyle === 'metal' ? (_jsx(ContinuousStairRailings, { material: railingMaterial, stair: node, renderData: renderData })) : (_jsxs(_Fragment, { children: [_jsx(StairRailings, { material: railingMaterial, stair: node, renderData: renderData }), node.handrail ? (_jsx(ContinuousStairRailings, { material: railingMaterial, stair: node, renderData: renderData, guard: false })) : null] })), _jsx(StairWalkingLine, { stair: node, segments: segments, totalRise: totalRise }), isSegmentBasedStair && !detail.error ? (_jsx("group", { name: "segments-wrapper", visible: false, children: (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, childId))) })) : null] }));
 };
-function StairRailings({ stair, material }) {
-    const nodes = useScene((state) => state.nodes);
-    // Stair segments' width/length/height arrow handles publish drag values to
-    // `useLiveNodeOverrides` and only commit to zustand on release. Subscribing
-    // here and merging each child segment's override means the railing tracks
-    // the drag in real time instead of freezing at the pre-drag values.
-    const overrides = useLiveNodeOverrides((s) => s.overrides);
-    const segments = useMemo(() => (stair.children ?? [])
-        .map((childId) => {
-        const base = nodes[childId];
-        if (!base)
-            return undefined;
-        const override = overrides.get(childId);
-        return (override ? { ...base, ...override } : base);
-    })
-        .filter((node) => node?.type === 'stair-segment' && node.visible !== false), [nodes, overrides, stair.children]);
-    const railPaths = useMemo(() => buildStairRailPaths(segments, stair.railingMode ?? 'none'), [segments, stair.railingMode]);
+function StairWalkingLine({ stair, segments, totalRise, }) {
+    const selected = useViewer((state) => state.selection.selectedIds.includes(stair.id));
+    const lines = useMemo(() => {
+        if (!selected)
+            return [];
+        return resolveStairWalkingPaths(stair, segments, totalRise).map((points) => {
+            const geometry = new THREE.BufferGeometry().setFromPoints(points.map(([x, y, z]) => new THREE.Vector3(x, y + 0.02, z)));
+            const line = new THREE.Line(geometry, new THREE.LineBasicMaterial({ color: '#2563eb', depthTest: false }));
+            line.name = 'stair-walking-line';
+            line.layers.set(OVERLAY_LAYER);
+            line.userData.pascalExport = 'strip';
+            line.raycast = () => { };
+            return line;
+        });
+    }, [selected, stair, segments, totalRise]);
+    useEffect(() => () => {
+        for (const line of lines) {
+            line.geometry.dispose();
+            line.material.dispose();
+        }
+    }, [lines]);
+    return (_jsx("group", { name: "stair-walking-lines", children: lines.map((line) => (_jsx("primitive", { object: line, dispose: null }, line.uuid))) }));
+}
+function StairRailings({ stair, material, renderData, }) {
+    const { stair: resolvedStair, segments, nodes } = renderData;
+    const railPaths = useMemo(() => buildStairRailPaths(segments, stair.railingMode ?? 'none')
+        .map((path, index) => ({
+        ...path,
+        connectFromPrevious: path.connectFromPrevious && segments[index - 1]?.visible !== false,
+    }))
+        .filter((path) => path.layout.segment.visible !== false), [segments, stair.railingMode]);
     const railHeight = stair.railingHeight ?? 0.92;
-    const midRailHeight = Math.max(railHeight * 0.45, 0.35);
-    const railRadius = 0.022;
-    const balusterRadius = 0.018;
+    const style = stair.railingStyle ?? 'balusters';
+    // Every style — balusters, post-and-rail, cable and the board-infill deck
+    // guard — is a merged `GuardMesh` built on the shared path chassis, so each
+    // reads as one coherent guard across straight, chained, winder, curved and
+    // spiral layouts.
     if ((stair.railingMode ?? 'none') === 'none') {
         return null;
     }
     if (stair.stairType === 'curved' || stair.stairType === 'spiral') {
-        const stepCount = Math.max(2, Math.round(stair.stepCount ?? 10));
-        const sweepAngle = stair.sweepAngle ?? (stair.stairType === 'spiral' ? Math.PI * 2 : Math.PI / 2);
-        const stepSweep = sweepAngle / stepCount;
-        const stepHeight = Math.max(resolveStairTotalRise(stair, nodes), 0.1) / stepCount;
-        const innerRadius = Math.max(stair.stairType === 'spiral' ? 0.05 : 0.2, stair.innerRadius ?? 0.9);
-        const outerRadius = innerRadius + Math.max(stair.width ?? 1, 0.4);
-        const leftRadius = sweepAngle >= 0 ? innerRadius + 0.04 : outerRadius - 0.04;
-        const rightRadius = sweepAngle >= 0 ? outerRadius - 0.04 : innerRadius + 0.04;
-        const radii = stair.railingMode === 'both'
-            ? [leftRadius, rightRadius]
-            : stair.railingMode === 'left'
-                ? [leftRadius]
-                : stair.railingMode === 'right'
-                    ? [rightRadius]
-                    : [];
-        return (_jsx("group", { name: "stair-railing", children: radii.map((radius, sideIndex) => {
-                const sidePoints = Array.from({ length: stepCount }).map((_, index) => {
-                    const angle = -sweepAngle / 2 + stepSweep * index + stepSweep / 2;
-                    return [
-                        Math.cos(angle) * radius,
-                        stair.stairType === 'spiral'
-                            ? stepHeight * index + Math.max(stair.thickness ?? 0.25, 0.02)
-                            : stepHeight * (index + 1),
-                        Math.sin(angle) * radius,
-                    ];
-                });
-                return (_jsxs("group", { children: [sidePoints.map((point, pointIndex) => (_jsx("mesh", { castShadow: true, geometry: BALUSTER_GEOMETRY, material: material, name: "stair-railing-baluster", position: [point[0], point[1] + railHeight / 2, point[2]], receiveShadow: true, scale: [balusterRadius, railHeight, balusterRadius], userData: STAIR_RAILING_SLOT_USER_DATA }, `${stair.id}-curved-baluster-${sideIndex}-${pointIndex}`))), sidePoints.slice(0, -1).map((point, pointIndex) => {
-                            const nextPoint = sidePoints[pointIndex + 1];
-                            if (!nextPoint)
-                                return null;
-                            return (_jsxs("group", { children: [_jsx(RailSegment, { end: [nextPoint[0], nextPoint[1] + railHeight, nextPoint[2]], material: material, radius: railRadius, start: [point[0], point[1] + railHeight, point[2]] }), _jsx(RailSegment, { end: [nextPoint[0], nextPoint[1] + midRailHeight, nextPoint[2]], material: material, radius: railRadius * 0.8, start: [point[0], point[1] + midRailHeight, point[2]] })] }, `${stair.id}-curved-rail-${sideIndex}-${pointIndex}`));
-                        })] }, `${stair.id}-curved-railing-${sideIndex}`));
-            }) }));
+        // The arc rail follows the same analytic ≤5° path the continuous guard and
+        // the exporters read (`resolveStairRailPaths`): one shared source for the
+        // signed, possibly multi-turn sweep, the inner/outer radius per side and the
+        // integrated landing arrival — not a per-step polyline that facets the curve
+        // and drops the landing. `GuardMesh` then spaces pickets by run, so the
+        // density tracks the arc length instead of the step count — for the deck
+        // post-and-rail guard as well as the balusters.
+        const arcPaths = resolveStairRailPaths(resolvedStair, nodes, stair.railingMode ?? 'none');
+        if (arcPaths.length === 0)
+            return null;
+        return (_jsx("group", { name: "stair-railing", userData: { pascalIfcRole: 'railing' }, children: arcPaths.map((path, index) => (_jsx(GuardMesh, { material: material, points: path.points, postThrough: stair.railingPostThrough === true, railHeight: railHeight, reach: stair.railingTopReach ?? 0, style: style, topPost: stair.railingTopPost !== false }, `${stair.id}-arc-railing-${path.side}-${index}`))) }));
     }
     if (railPaths.length === 0) {
         return null;
     }
-    return (_jsxs("group", { name: "stair-railing", children: [railPaths.map((segmentPath, index) => (_jsx("group", { position: [
+    // `topPost`/`reach` describe the top of the whole stair, so they apply only
+    // to the flight whose guard reaches the highest point; the rest keep their
+    // newel at the junction with the next flight.
+    const topY = Math.max(...railPaths.flatMap((segmentPath) => segmentPath.sidePaths.map((sidePath) => segmentPath.layout.elevation + Math.max(...sidePath.points.map((point) => point[1])))));
+    // The rails bridging consecutive flights, as metre-UV boxes in the stair's
+    // local frame, merged into one mesh (E-009) like the per-flight guards. The
+    // bridge carries the same rails as the guard style it joins.
+    const connectorRails = style === 'post-and-rail'
+        ? postAndRailGuardRails(railHeight)
+        : style === 'cable'
+            ? cableGuardRails(railHeight)
+            : style === 'boards'
+                ? boardsGuardRails(railHeight)
+                : balusterGuardRails(railHeight);
+    const connectorBoxes = railPaths.slice(1).flatMap((segmentPath, index) => {
+        const previousPath = railPaths[index];
+        if (!(previousPath && segmentPath.connectFromPrevious))
+            return [];
+        if (previousPath.layout.segment.segmentType === 'landing')
+            return [];
+        if (segmentPath.layout.segment.segmentType === 'landing')
+            return [];
+        return segmentPath.sidePaths.flatMap((sidePath) => {
+            const currentPoint = sidePath.points[0];
+            if (!currentPoint)
+                return [];
+            const currentWorldPoint = toWorldRailPoint(segmentPath.layout, currentPoint);
+            const previousSidePath = [...previousPath.sidePaths]
+                .map((entry) => {
+                const lastPoint = entry.points[entry.points.length - 1];
+                return {
+                    entry,
+                    distance: lastPoint
+                        ? distance3(toWorldRailPoint(previousPath.layout, lastPoint), currentWorldPoint)
+                        : Number.POSITIVE_INFINITY,
+                };
+            })
+                .sort((left, right) => left.distance - right.distance)[0]?.entry;
+            const previousPoint = previousSidePath?.points.length
+                ? previousSidePath.points[previousSidePath.points.length - 1]
+                : null;
+            if (!previousPoint)
+                return [];
+            const previousWorldPoint = toWorldRailPoint(previousPath.layout, previousPoint);
+            return connectorRails
+                .map((rail) => barBox([previousWorldPoint[0], previousWorldPoint[1] + rail.y, previousWorldPoint[2]], [currentWorldPoint[0], currentWorldPoint[1] + rail.y, currentWorldPoint[2]], rail.across, rail.vertical))
+                .filter((box) => box !== null);
+        });
+    });
+    return (_jsxs("group", { name: "stair-railing", userData: { pascalIfcRole: 'railing' }, children: [railPaths.map((segmentPath) => (_jsx("group", { position: [
                     segmentPath.layout.center[0],
                     segmentPath.layout.elevation,
                     segmentPath.layout.center[1],
-                ], "rotation-y": segmentPath.layout.rotation, children: segmentPath.sidePaths.map((sidePath, sideIndex) => (_jsxs("group", { children: [sidePath.points.map((point, pointIndex) => (_jsx("mesh", { castShadow: true, geometry: BALUSTER_GEOMETRY, material: material, name: "stair-railing-baluster", position: [point[2], point[1] + railHeight / 2, point[0]], receiveShadow: true, scale: [balusterRadius, railHeight, balusterRadius], userData: STAIR_RAILING_SLOT_USER_DATA }, `${segmentPath.layout.segment.id}-${sidePath.side}-baluster-${pointIndex}`))), sidePath.points.slice(0, -1).map((point, pointIndex) => {
-                            const nextPoint = sidePath.points[pointIndex + 1];
-                            if (!nextPoint)
-                                return null;
-                            return (_jsxs("group", { children: [_jsx(RailSegment, { end: [nextPoint[2], nextPoint[1] + railHeight, nextPoint[0]], material: material, radius: railRadius, start: [point[2], point[1] + railHeight, point[0]] }), _jsx(RailSegment, { end: [nextPoint[2], nextPoint[1] + midRailHeight, nextPoint[0]], material: material, radius: railRadius * 0.8, start: [point[2], point[1] + midRailHeight, point[0]] })] }, `${segmentPath.layout.segment.id}-${sidePath.side}-rail-${pointIndex}`));
-                        })] }, `${segmentPath.layout.segment.id}-${sidePath.side}-${sideIndex}`))) }, `${segmentPath.layout.segment.id}-railing`))), railPaths.slice(1).map((segmentPath, index) => {
-                const previousPath = railPaths[index];
-                if (!(previousPath && segmentPath.connectFromPrevious))
-                    return null;
-                if (previousPath.layout.segment.segmentType === 'landing')
-                    return null;
-                if (segmentPath.layout.segment.segmentType === 'landing')
-                    return null;
-                return segmentPath.sidePaths.map((sidePath, sideIndex) => {
-                    const currentPoint = sidePath.points[0];
-                    if (!currentPoint)
-                        return null;
-                    const currentWorldPoint = toWorldRailPoint(segmentPath.layout, currentPoint);
-                    const previousSidePath = [...previousPath.sidePaths]
-                        .map((entry) => {
-                        const lastPoint = entry.points[entry.points.length - 1];
-                        return {
-                            entry,
-                            distance: lastPoint
-                                ? distance3(toWorldRailPoint(previousPath.layout, lastPoint), currentWorldPoint)
-                                : Number.POSITIVE_INFINITY,
-                        };
-                    })
-                        .sort((left, right) => left.distance - right.distance)[0]?.entry;
-                    const previousPoint = previousSidePath?.points.length
-                        ? previousSidePath.points[previousSidePath.points.length - 1]
-                        : null;
-                    if (!(previousPoint && currentPoint)) {
-                        return null;
-                    }
-                    const previousWorldPoint = toWorldRailPoint(previousPath.layout, previousPoint);
-                    return (_jsxs("group", { children: [_jsx(RailSegment, { end: [
-                                    currentWorldPoint[0],
-                                    currentWorldPoint[1] + railHeight,
-                                    currentWorldPoint[2],
-                                ], material: material, radius: railRadius, start: [
-                                    previousWorldPoint[0],
-                                    previousWorldPoint[1] + railHeight,
-                                    previousWorldPoint[2],
-                                ] }), _jsx(RailSegment, { end: [
-                                    currentWorldPoint[0],
-                                    currentWorldPoint[1] + midRailHeight,
-                                    currentWorldPoint[2],
-                                ], material: material, radius: railRadius * 0.8, start: [
-                                    previousWorldPoint[0],
-                                    previousWorldPoint[1] + midRailHeight,
-                                    previousWorldPoint[2],
-                                ] })] }, `${previousPath.layout.segment.id}-${segmentPath.layout.segment.id}-${sideIndex}`));
-                });
-            })] }));
+                ], "rotation-y": segmentPath.layout.rotation, children: segmentPath.sidePaths.map((sidePath, sideIndex) => {
+                    const points = sidePath.points.map((p) => [p[2], p[1], p[0]]);
+                    const guardTopY = segmentPath.layout.elevation + Math.max(...points.map((p) => p[1]));
+                    const terminal = guardTopY >= topY - 1e-4;
+                    // The builder treats the last point as the run's top, so a terminal
+                    // flight whose points descend is reversed before `reach`/`topPost`.
+                    const oriented = terminal && (points[0]?.[1] ?? 0) > (points.at(-1)?.[1] ?? 0)
+                        ? [...points].reverse()
+                        : points;
+                    return (_jsx(GuardMesh, { material: material, points: oriented, postThrough: stair.railingPostThrough === true, railHeight: railHeight, reach: terminal ? (stair.railingTopReach ?? 0) : 0, style: style, topPost: terminal ? stair.railingTopPost !== false : true }, `${segmentPath.layout.segment.id}-${sidePath.side}-${sideIndex}`));
+                }) }, `${segmentPath.layout.segment.id}-railing`))), _jsx(ConnectorRails, { boxes: connectorBoxes, material: material })] }));
 }
-const BALUSTER_GEOMETRY = new THREE.CylinderGeometry(1, 1, 1, 8);
-const RAIL_GEOMETRY = new THREE.CylinderGeometry(1, 1, 1, 8);
+// Shared, module-level geometries: every mesh that uses one carries
+// `dispose={null}` — R3F disposes a mesh's geometry on unmount, and a
+// regenerated house unmounts its stairs, after which the next stair drew a
+// disposed buffer (WebGPU: "Vertex buffer slot 0 … was not set").
 const STAIR_TREAD_MATERIAL_INDEX = 0;
 const STAIR_SIDE_MATERIAL_INDEX = 1;
 const STAIR_BODY_SLOT_IDS = ['treads', 'body'];
 const STAIR_BODY_SLOT_USER_DATA = { slotIds: STAIR_BODY_SLOT_IDS };
 const STAIR_BODY_SINGLE_SLOT_USER_DATA = { slotId: 'body' };
 const STAIR_RAILING_SLOT_USER_DATA = { slotId: 'railing' };
-function hasMaterialSpec(material, materialPreset) {
-    return material !== undefined || typeof materialPreset === 'string';
-}
-function hasLegacyStairSlotMaterial(node, slotId) {
-    const hasWhole = hasMaterialSpec(node.material, node.materialPreset);
-    const hasTread = hasMaterialSpec(node.treadMaterial, node.treadMaterialPreset);
-    const hasSide = hasMaterialSpec(node.sideMaterial, node.sideMaterialPreset);
-    const hasRailing = hasMaterialSpec(node.railingMaterial, node.railingMaterialPreset);
-    if (slotId === 'treads')
-        return hasTread || hasSide || hasWhole;
-    if (slotId === 'body')
-        return hasSide || hasTread || hasWhole;
-    return hasRailing || hasTread || hasSide || hasWhole;
-}
-function resolveStairSlotMaterial(node, slotId, defaultRef, baseMaterial, sceneMaterials, shading, textures) {
-    if (!textures)
-        return baseMaterial;
-    const slotMaterial = resolveMaterialRef(node.slots?.[slotId], sceneMaterials, shading);
-    if (slotMaterial)
-        return slotMaterial;
-    if (hasLegacyStairSlotMaterial(node, slotId))
-        return baseMaterial;
-    return resolveSlotDefaultMaterial(defaultRef, shading);
+/**
+ * A guard for one rail path — a run of posts, rails and infill spaced by run
+ * length (not one per path vertex), merged into a single metre-UV mesh (E-009)
+ * so a finish tiles the same as the continuous guard and the whole guard is one
+ * draw call. `style` picks the members: 'post-and-rail' and 'boards' build the
+ * DCA 6 deck guard (4x4 posts, a flat cap) with square pickets or a stack of
+ * flat board courses respectively, 'cable' spans chords between the posts, and
+ * every other style builds the balusters. Spacing by run keeps the infill
+ * density coherent whether the path is a straight flight's nosing line or a
+ * densely sampled arc. `topPost`/`reach` describe the run's terminal end
+ * and so are passed only on the flight that reaches the top of the stair; every
+ * other flight keeps its post where it meets the next.
+ */
+function GuardMesh({ points, railHeight, postThrough, topPost = true, reach = 0, style, material, }) {
+    const geometry = useMemo(() => mergeGuardBoxes(style === 'post-and-rail'
+        ? buildPostAndRailGuard(points, {
+            railHeight,
+            postSpacing: GUARD_POST_SPACING,
+            postThrough,
+            topPost,
+            reach,
+        })
+        : style === 'cable'
+            ? buildCableGuard(points, {
+                railHeight,
+                postSpacing: GUARD_POST_SPACING,
+                postThrough,
+                topPost,
+                reach,
+            })
+            : style === 'boards'
+                ? buildBoardsGuard(points, {
+                    railHeight,
+                    postSpacing: GUARD_POST_SPACING,
+                    postThrough,
+                    topPost,
+                    reach,
+                })
+                : buildBalusterGuard(points, {
+                    railHeight,
+                    pickets: GUARD_PICKET_PITCH,
+                    postSpacing: GUARD_POST_SPACING,
+                    postThrough,
+                    topPost,
+                    reach,
+                })), [points, railHeight, postThrough, topPost, reach, style]);
+    useEffect(() => () => geometry?.dispose(), [geometry]);
+    if (!geometry)
+        return null;
+    return (_jsx("mesh", { castShadow: true, dispose: null, geometry: geometry, material: material, name: style === 'post-and-rail'
+            ? 'stair-railing-post-and-rail'
+            : style === 'cable'
+                ? 'stair-railing-cable'
+                : style === 'boards'
+                    ? 'stair-railing-boards'
+                    : 'stair-railing-baluster', receiveShadow: true, userData: STAIR_RAILING_SLOT_USER_DATA }));
 }
-function RailSegment({ start, end, radius, material, }) {
-    const startVector = useMemo(() => new THREE.Vector3(...start), [start]);
-    const endVector = useMemo(() => new THREE.Vector3(...end), [end]);
-    const direction = useMemo(() => endVector.clone().sub(startVector), [endVector, startVector]);
-    const length = Math.max(direction.length(), 0.01);
-    const quaternion = useMemo(() => new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), direction.clone().normalize()), [direction]);
-    const midpoint = useMemo(() => startVector.clone().add(endVector).multiplyScalar(0.5), [endVector, startVector]);
-    return (_jsx("mesh", { castShadow: true, geometry: RAIL_GEOMETRY, material: material, name: "stair-railing-rail", position: [midpoint.x, midpoint.y, midpoint.z], quaternion: quaternion, receiveShadow: true, scale: [Math.max(radius, 0.01), length, Math.max(radius, 0.01)], userData: STAIR_RAILING_SLOT_USER_DATA }));
+/** The rails bridging consecutive flights, merged into one metre-UV mesh. */
+function ConnectorRails({ boxes, material }) {
+    const geometry = useMemo(() => mergeGuardBoxes(boxes), [boxes]);
+    useEffect(() => () => geometry?.dispose(), [geometry]);
+    if (!geometry)
+        return null;
+    return (_jsx("mesh", { castShadow: true, dispose: null, geometry: geometry, material: material, name: "stair-railing-baluster", receiveShadow: true, userData: STAIR_RAILING_SLOT_USER_DATA }));
 }
-function CurvedStairBody({ stair, bodyMaterials, }) {
-    const nodes = useScene((state) => state.nodes);
+function CurvedStairBody({ stair, bodyMaterials, rise, }) {
     const sideMaterial = bodyMaterials[1];
-    const stepCount = Math.max(2, Math.round(stair.stepCount ?? 10));
-    const totalRise = Math.max(resolveStairTotalRise(stair, nodes), 0.1);
-    const stepHeight = totalRise / stepCount;
+    const totalRise = Math.max(rise, 0.001);
     const isSpiral = stair.stairType === 'spiral';
-    const innerRadius = Math.max(isSpiral ? 0.05 : 0.2, stair.innerRadius ?? 0.9);
-    const outerRadius = innerRadius + Math.max(stair.width ?? 1, 0.4);
-    const sweepAngle = stair.sweepAngle ?? (isSpiral ? Math.PI * 2 : Math.PI / 2);
-    const stepSweep = sweepAngle / stepCount;
-    const thickness = Math.max(stair.thickness ?? 0.25, 0.02);
-    const fillToFloor = stair.fillToFloor ?? true;
-    const spiralColumnRadius = Math.max(0.05, Math.min(innerRadius * 0.72, innerRadius - 0.03));
+    const layout = resolveStairArcLayout(stair, totalRise);
+    const { innerRadius, outerRadius, thickness } = layout;
+    const spiralColumnRadius = Math.min(innerRadius * 0.72, Math.max(innerRadius - 0.03, innerRadius * 0.5));
     const spiralColumnHeight = totalRise + thickness;
-    const spiralLandingDepth = Math.max(0.3, stair.topLandingDepth ?? Math.max((stair.width ?? 1) * 0.9, 0.8));
-    const spiralLandingSweep = isSpiral && (stair.topLandingMode ?? 'none') === 'integrated'
-        ? Math.min(Math.PI * 0.75, spiralLandingDepth / Math.max(innerRadius + (stair.width ?? 1) / 2, 0.1)) * Math.sign(sweepAngle || 1)
-        : 0;
-    const spiralLastStepTop = stepHeight * Math.max(stepCount - 1, 0) + thickness;
-    const spiralLandingThickness = isSpiral && (stair.topLandingMode ?? 'none') === 'integrated'
-        ? Math.max(0.02, totalRise - spiralLastStepTop)
-        : 0;
-    return (_jsxs("group", { name: isSpiral ? 'spiral-stair' : 'curved-stair', children: [isSpiral && (stair.showCenterColumn ?? true) ? (_jsx(SpiralColumnMesh, { height: spiralColumnHeight, material: sideMaterial, radius: spiralColumnRadius })) : null, Array.from({ length: stepCount }).map((_, index) => {
-                const currentHeight = stepHeight * (index + 1);
-                const actualStepHeight = isSpiral
-                    ? thickness
-                    : fillToFloor
-                        ? Math.max(currentHeight, thickness)
-                        : thickness;
-                const startAngle = -sweepAngle / 2 + stepSweep * index;
-                const endAngle = startAngle + stepSweep;
-                const stepY = isSpiral
-                    ? stepHeight * index
-                    : fillToFloor
-                        ? 0
-                        : Math.max(currentHeight - thickness, 0);
-                const midAngle = startAngle + stepSweep / 2;
-                return (_jsxs("group", { "position-y": stepY, children: [isSpiral && (stair.showStepSupports ?? true) ? (_jsx(SpiralStepSupportMesh, { innerRadius: innerRadius, material: sideMaterial, midAngle: midAngle, spiralColumnRadius: spiralColumnRadius, thickness: thickness })) : null, _jsx(CurvedStepMesh, { endAngle: endAngle, innerRadius: innerRadius, material: bodyMaterials, outerRadius: outerRadius, positionY: 0, startAngle: startAngle, stepHeight: actualStepHeight, thickness: thickness })] }, `${stair.id}-${isSpiral ? 'spiral' : 'curved'}-step-${index}`));
-            }), isSpiral && (stair.topLandingMode ?? 'none') === 'integrated' ? (_jsx(CurvedStepMesh, { endAngle: sweepAngle / 2 + spiralLandingSweep, innerRadius: innerRadius, material: bodyMaterials, outerRadius: outerRadius, positionY: spiralLastStepTop, startAngle: sweepAngle / 2, stepHeight: spiralLandingThickness, thickness: spiralLandingThickness })) : null] }));
+    const explicitPieces = resolveArcStairConstruction(stair, totalRise);
+    return (_jsxs("group", { name: isSpiral ? 'spiral-stair' : 'curved-stair', children: [isSpiral && (stair.showCenterColumn ?? true) ? (_jsx(SpiralColumnMesh, { height: spiralColumnHeight, material: sideMaterial, radius: spiralColumnRadius })) : null, explicitPieces ? (_jsxs(_Fragment, { children: [explicitPieces.map((piece, index) => (_jsx(CurvedStepMesh, { innerRadius: piece.innerRadius, outerRadius: piece.outerRadius, startAngle: piece.startAngle, endAngle: piece.endAngle, positionY: piece.bottomStart, stepHeight: piece.top - piece.bottomStart, bottomDelta: piece.bottomEnd - piece.bottomStart, ifcRole: piece.index === layout.stepCount ? 'landing' : undefined, surfaceRole: piece.role, material: bodyMaterials }, `${stair.id}-construction-${index}`))), isSpiral && (stair.showStepSupports ?? true)
+                        ? layout.steps.map((step, index) => (_jsx("group", { "position-y": step.top -
+                                (stair.construction.finishThickness + stair.construction.treadThickness), children: _jsx(SpiralStepSupportMesh, { innerRadius: innerRadius, spiralColumnRadius: spiralColumnRadius, midAngle: (step.startAngle + step.endAngle) / 2, thickness: stair.construction.treadThickness, material: sideMaterial }) }, `${stair.id}-support-${index}`)))
+                        : null] })) : (layout.steps.map((step, index) => {
+                const { startAngle, endAngle } = step;
+                const midAngle = (startAngle + endAngle) / 2;
+                return (_jsxs("group", { "position-y": step.bottom, children: [isSpiral && (stair.showStepSupports ?? true) ? (_jsx(SpiralStepSupportMesh, { innerRadius: innerRadius, material: sideMaterial, midAngle: midAngle, spiralColumnRadius: spiralColumnRadius, thickness: thickness })) : null, _jsx(CurvedStepMesh, { endAngle: endAngle, innerRadius: innerRadius, material: bodyMaterials, outerRadius: outerRadius, positionY: 0, startAngle: startAngle, stepHeight: step.top - step.bottom })] }, `${stair.id}-${isSpiral ? 'spiral' : 'curved'}-step-${index}`));
+            })), layout.landing && !explicitPieces ? (_jsx(CurvedStepMesh, { ifcRole: "landing", endAngle: layout.landing.endAngle, innerRadius: innerRadius, material: bodyMaterials, outerRadius: outerRadius, positionY: layout.landing.bottom, startAngle: layout.landing.startAngle, stepHeight: thickness })) : null] }));
 }
-function CurvedStepMesh({ innerRadius, outerRadius, startAngle, endAngle, stepHeight, thickness, positionY, material, }) {
-    const geometry = useMemo(() => buildCurvedStepGeometry(innerRadius, outerRadius, startAngle, endAngle, Math.max(stepHeight, thickness)), [endAngle, innerRadius, outerRadius, startAngle, stepHeight, thickness]);
+function CurvedStepMesh({ innerRadius, outerRadius, startAngle, endAngle, stepHeight, positionY, material, bottomDelta = 0, surfaceRole = 'mixed', ifcRole, }) {
+    const geometry = useMemo(() => buildCurvedStepGeometry(innerRadius, outerRadius, startAngle, endAngle, stepHeight, bottomDelta, surfaceRole), [endAngle, innerRadius, outerRadius, startAngle, stepHeight, bottomDelta, surfaceRole]);
     // Dispose the prior BufferGeometry as soon as a new one supersedes it.
     // Resize drags (in 2D or 3D) rebuild this geometry every pointer move;
     // without explicit disposal, WebGPU keeps a stale pipeline reference to
@@ -256,7 +292,7 @@ function CurvedStepMesh({ innerRadius, outerRadius, startAngle, endAngle, stepHe
     useEffect(() => () => {
         geometry.dispose();
     }, [geometry]);
-    return (_jsx("mesh", { castShadow: true, geometry: geometry, material: material, "position-y": positionY, receiveShadow: true, userData: STAIR_BODY_SLOT_USER_DATA }));
+    return (_jsx("mesh", { castShadow: true, geometry: geometry, material: material, "position-y": positionY, receiveShadow: true, userData: { ...STAIR_BODY_SLOT_USER_DATA, ...(ifcRole ? { pascalIfcRole: ifcRole } : {}) } }));
 }
 /**
  * Spiral center column. The cylinder is rebuilt whenever
@@ -291,36 +327,34 @@ function SpiralStepSupportMesh({ innerRadius, spiralColumnRadius, midAngle, thic
     const radial = spiralColumnRadius + sizeX / 2 - 0.02;
     return (_jsx("mesh", { castShadow: true, geometry: geometry, material: material, name: "stair-side", position: [Math.cos(midAngle) * radial, sizeY / 2, Math.sin(midAngle) * radial], receiveShadow: true, "rotation-y": -midAngle, userData: STAIR_BODY_SINGLE_SLOT_USER_DATA }));
 }
-function buildCurvedStepGeometry(innerRadius, outerRadius, startAngle, endAngle, height) {
-    const clampedHeight = Math.max(height, 0.02);
+function buildCurvedStepGeometry(innerRadius, outerRadius, startAngle, authoredEndAngle, height, bottomDelta = 0, surfaceRole = 'mixed') {
+    const clampedHeight = Math.max(height, Number.EPSILON);
     const y0 = 0;
     const y1 = clampedHeight;
+    const endAngle = startAngle +
+        Math.sign(authoredEndAngle - startAngle || 1) *
+            Math.min(Math.abs(authoredEndAngle - startAngle), Math.PI * 2);
     const sweepAngle = endAngle - startAngle;
     const sweepDirection = Math.sign(sweepAngle) || 1;
-    const segmentCount = Math.max(4, Math.min(24, Math.ceil(Math.abs(sweepAngle) / (Math.PI / 18) + Math.max(0, (outerRadius - innerRadius) * 3))));
+    const segmentCount = stairArcSliceCount(innerRadius, outerRadius, sweepAngle);
     const positions = [];
     const normals = [];
     const uvs = [];
     const triangleMaterialIndices = [];
     const pointOnArc = (radius, angle, y) => new THREE.Vector3(Math.cos(angle) * radius, y, Math.sin(angle) * radius);
-    const pushUv = (point, normal, materialIndex) => {
-        if (materialIndex === STAIR_TREAD_MATERIAL_INDEX) {
-            const angle = Math.atan2(point.z, point.x);
-            const arcOffset = (angle - startAngle) * Math.max((innerRadius + outerRadius) * 0.5, 0.01);
-            uvs.push(arcOffset, Math.sqrt(point.x * point.x + point.z * point.z) - innerRadius);
-            return;
-        }
-        const absX = Math.abs(normal.x);
-        const absY = Math.abs(normal.y);
-        const absZ = Math.abs(normal.z);
-        if (absY >= absX && absY >= absZ) {
+    const pushUv = (point, normal) => {
+        if (normal.y > 0.999999) {
             uvs.push(point.x, point.z);
         }
-        else if (absX >= absZ) {
-            uvs.push(point.z, point.y);
+        else if (normal.y < -0.000001) {
+            // Each faceted underside triangle has its own physical plane.
+            const u = new THREE.Vector3(1, 0, 0).addScaledVector(normal, -normal.x).normalize();
+            const v = new THREE.Vector3().crossVectors(normal, u).normalize();
+            uvs.push(point.dot(u), point.dot(v));
         }
         else {
-            uvs.push(point.x, point.y);
+            const u = new THREE.Vector3(normal.z, 0, -normal.x).normalize();
+            uvs.push(point.dot(u), point.y);
         }
     };
     const pushTriangle = (a, b, c, normal, materialIndex) => {
@@ -330,10 +364,17 @@ function buildCurvedStepGeometry(innerRadius, outerRadius, startAngle, endAngle,
         const ordered = faceNormal.dot(normal) >= 0 ? [a, b, c] : [a, c, b];
         for (const point of ordered) {
             positions.push(point.x, point.y, point.z);
-            normals.push(normal.x, normal.y, normal.z);
-            pushUv(point, normal, materialIndex);
+            const shadingNormal = normal.y < 0
+                ? faceNormal.normalize().multiplyScalar(faceNormal.dot(normal) < 0 ? -1 : 1)
+                : normal;
+            normals.push(shadingNormal.x, shadingNormal.y, shadingNormal.z);
+            pushUv(point, shadingNormal);
         }
-        triangleMaterialIndices.push(materialIndex);
+        triangleMaterialIndices.push(surfaceRole === 'mixed'
+            ? materialIndex
+            : surfaceRole === 'tread'
+                ? STAIR_TREAD_MATERIAL_INDEX
+                : STAIR_SIDE_MATERIAL_INDEX);
     };
     const pushQuad = (a, b, c, d, normal, materialIndex) => {
         pushTriangle(a, b, c, normal, materialIndex);
@@ -347,10 +388,10 @@ function buildCurvedStepGeometry(innerRadius, outerRadius, startAngle, endAngle,
         const segStart = startAngle + sweepAngle * t0;
         const segEnd = startAngle + sweepAngle * t1;
         const midAngle = (segStart + segEnd) / 2;
-        const innerStartBottom = pointOnArc(innerRadius, segStart, y0);
-        const innerEndBottom = pointOnArc(innerRadius, segEnd, y0);
-        const outerStartBottom = pointOnArc(outerRadius, segStart, y0);
-        const outerEndBottom = pointOnArc(outerRadius, segEnd, y0);
+        const innerStartBottom = pointOnArc(innerRadius, segStart, y0 + bottomDelta * t0);
+        const innerEndBottom = pointOnArc(innerRadius, segEnd, y0 + bottomDelta * t1);
+        const outerStartBottom = pointOnArc(outerRadius, segStart, y0 + bottomDelta * t0);
+        const outerEndBottom = pointOnArc(outerRadius, segEnd, y0 + bottomDelta * t1);
         const innerStartTop = pointOnArc(innerRadius, segStart, y1);
         const innerEndTop = pointOnArc(innerRadius, segEnd, y1);
         const outerStartTop = pointOnArc(outerRadius, segStart, y1);
@@ -366,8 +407,8 @@ function buildCurvedStepGeometry(innerRadius, outerRadius, startAngle, endAngle,
     const startOuterBottom = pointOnArc(outerRadius, startAngle, y0);
     const startInnerTop = pointOnArc(innerRadius, startAngle, y1);
     const startOuterTop = pointOnArc(outerRadius, startAngle, y1);
-    const endInnerBottom = pointOnArc(innerRadius, endAngle, y0);
-    const endOuterBottom = pointOnArc(outerRadius, endAngle, y0);
+    const endInnerBottom = pointOnArc(innerRadius, endAngle, y0 + bottomDelta);
+    const endOuterBottom = pointOnArc(outerRadius, endAngle, y0 + bottomDelta);
     const endInnerTop = pointOnArc(innerRadius, endAngle, y1);
     const endOuterTop = pointOnArc(outerRadius, endAngle, y1);
     const startNormal = new THREE.Vector3(sweepDirection * Math.sin(startAngle), 0, -sweepDirection * Math.cos(startAngle)).normalize();
@@ -621,47 +662,6 @@ function toWorldRailPoint(layout, point) {
     const [offsetX, offsetZ] = rotateXZ(localZ, localX, layout.rotation);
     return [layout.center[0] + offsetX, layout.elevation + localY, layout.center[1] + offsetZ];
 }
-function computeSegmentTransforms(segments) {
-    const transforms = [];
-    let currentPos = new THREE.Vector3(0, 0, 0);
-    let currentRot = 0;
-    for (let i = 0; i < segments.length; i++) {
-        const segment = segments[i];
-        if (i === 0) {
-            transforms.push({
-                position: [currentPos.x, currentPos.y, currentPos.z],
-                rotation: currentRot,
-            });
-            continue;
-        }
-        const prev = segments[i - 1];
-        const localAttachPos = new THREE.Vector3();
-        let rotChange = 0;
-        switch (segment.attachmentSide) {
-            case 'front':
-                localAttachPos.set(0, prev.height, prev.length);
-                break;
-            case 'left':
-                localAttachPos.set(prev.width / 2, prev.height, prev.length / 2);
-                rotChange = Math.PI / 2;
-                break;
-            case 'right':
-                localAttachPos.set(-prev.width / 2, prev.height, prev.length / 2);
-                rotChange = -Math.PI / 2;
-                break;
-        }
-        localAttachPos.applyAxisAngle(new THREE.Vector3(0, 1, 0), currentRot);
-        currentPos = currentPos.clone().add(localAttachPos);
-        currentRot += rotChange;
-        transforms.push({ position: [currentPos.x, currentPos.y, currentPos.z], rotation: currentRot });
-    }
-    return transforms;
-}
-function rotateXZ(x, z, angle) {
-    const cos = Math.cos(angle);
-    const sin = Math.sin(angle);
-    return [x * cos + z * sin, -x * sin + z * cos];
-}
 function distance3(a, b) {
     return Math.hypot(a[0] - b[0], a[1] - b[1], a[2] - b[2]);
 }