@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/stair/railing-controls.js

@@ -1,47 +1,107 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useScene } from '@pascal-app/core';
+import { usePascalI18n, useScene } from '@pascal-app/core';
 import { MetricControl, SegmentedControl, ToggleControl } from '@pascal-app/editor';
 const MODES = [
-    { label: 'None', value: 'none' },
-    { label: 'Left', value: 'left' },
-    { label: 'Right', value: 'right' },
-    { label: 'Both', value: 'both' },
+    { label: /* i18n */ { id: 'node.stair.railingControls.none', message: 'None' }, value: 'none' },
+    { label: /* i18n */ { id: 'node.stair.railingControls.left', message: 'Left' }, value: 'left' },
+    {
+        label: /* i18n */ { id: 'node.stair.railingControls.right', message: 'Right' },
+        value: 'right',
+    },
+    { label: /* i18n */ { id: 'node.stair.railingControls.both', message: 'Both' }, value: 'both' },
 ];
 export function StairRailingControls({ node, onChange, }) {
+    const i18n = usePascalI18n();
     const config = node.handrail;
     return (_jsxs("div", { className: "space-y-3", children: [_jsx(SegmentedControl, { value: node.railingStyle === 'glass' || node.railingStyle === 'metal'
                     ? 'continuous'
                     : (node.railingPath ?? 'original'), options: [
-                    { label: 'Original layout', value: 'original' },
-                    { label: 'Continuous', value: 'continuous' },
+                    {
+                        label: i18n._({
+                            id: 'node.stair.railingControls.originalLayout',
+                            message: 'Original layout',
+                        }),
+                        value: 'original',
+                    },
+                    {
+                        label: i18n._({ id: 'node.stair.railingControls.continuous', message: 'Continuous' }),
+                        value: 'continuous',
+                    },
                 ], onChange: (value) => onChange({
                     railingPath: value,
                     ...(value === 'original' &&
                         (node.railingStyle === 'glass' || node.railingStyle === 'metal')
                         ? { railingStyle: 'balusters' }
                         : {}),
-                }) }), _jsx(ToggleControl, { label: "Separate handrail", checked: !!config, onChange: (checked) => onChange({
+                }) }), _jsx(ToggleControl, { label: i18n._({
+                    id: 'node.stair.railingControls.separateHandrail',
+                    message: 'Separate handrail',
+                }), checked: !!config, onChange: (checked) => onChange({
                     handrail: checked
                         ? { mode: 'both', height: 0.9, diameter: 0.045, offset: 0.06 }
                         : undefined,
-                }) }), config ? (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { value: config.mode, options: [...MODES], onChange: (value) => onChange({ handrail: { ...config, mode: value } }) }), ['height', 'diameter', 'offset'].map((key) => (_jsx(MetricControl, { label: key === 'height'
-                            ? 'Handrail height'
+                }) }), config ? (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { value: config.mode, options: MODES.map((option) => ({ ...option, label: i18n._(option.label) })), onChange: (value) => onChange({ handrail: { ...config, mode: value } }) }), ['height', 'diameter', 'offset'].map((key) => (_jsx(MetricControl, { label: key === 'height'
+                            ? i18n._({
+                                id: 'node.stair.railingControls.handrailHeight',
+                                message: 'Handrail height',
+                            })
                             : key === 'diameter'
-                                ? 'Handrail diameter'
-                                : 'Handrail inset', value: config[key], min: key === 'offset' ? 0 : 0.001, step: 0.005, precision: 3, unit: "m", onChange: (value) => onChange({ handrail: { ...config, [key]: value } }) }, key))), ['bottom', 'top'].map((end) => {
+                                ? i18n._({
+                                    id: 'node.stair.railingControls.handrailDiameter',
+                                    message: 'Handrail diameter',
+                                })
+                                : i18n._({
+                                    id: 'node.stair.railingControls.handrailInset',
+                                    message: 'Handrail inset',
+                                }), value: config[key], min: key === 'offset' ? 0 : 0.001, step: 0.005, precision: 3, unit: "m", onChange: (value) => onChange({ handrail: { ...config, [key]: value } }) }, key))), ['bottom', 'top'].map((end) => {
                         const detail = config[end] ?? {
                             extension: 0,
                             return: 'none',
                             returnLength: 0.1,
                         };
                         const update = (patch) => onChange({ handrail: { ...config, [end]: { ...detail, ...patch } } });
-                        return (_jsxs("div", { className: "space-y-2", children: [_jsx(MetricControl, { label: `${end === 'bottom' ? 'Bottom sloped' : 'Top horizontal'} extension`, value: detail.extension, min: 0, step: 0.05, precision: 3, unit: "m", onChange: (extension) => update({ extension }) }), _jsx(SegmentedControl, { value: detail.return, options: [
-                                        { label: 'No return', value: 'none' },
-                                        { label: 'Wall-facing', value: 'wall' },
-                                        { label: 'Post-facing', value: 'post' },
-                                        { label: 'Floor', value: 'floor' },
-                                    ], onChange: (value) => update({ return: value }) }), detail.return === 'wall' || detail.return === 'post' ? (_jsxs(_Fragment, { children: [_jsx(MetricControl, { label: "Return length", value: detail.returnLength, min: 0, step: 0.01, precision: 3, unit: "m", onChange: (returnLength) => update({ returnLength }) }), _jsx("p", { className: "text-xs text-muted-foreground", children: "Set the length to reach the wall or post." })] })) : null] }, end));
+                        return (_jsxs("div", { className: "space-y-2", children: [_jsx(MetricControl, { label: end === 'bottom'
+                                        ? i18n._({
+                                            id: 'node.stair.railingControls.bottomExtension',
+                                            message: 'Bottom sloped extension',
+                                        })
+                                        : i18n._({
+                                            id: 'node.stair.railingControls.topExtension',
+                                            message: 'Top horizontal extension',
+                                        }), value: detail.extension, min: 0, step: 0.05, precision: 3, unit: "m", onChange: (extension) => update({ extension }) }), _jsx(SegmentedControl, { value: detail.return, options: [
+                                        {
+                                            label: i18n._({
+                                                id: 'node.stair.railingControls.noReturn',
+                                                message: 'No return',
+                                            }),
+                                            value: 'none',
+                                        },
+                                        {
+                                            label: i18n._({
+                                                id: 'node.stair.railingControls.wallFacing',
+                                                message: 'Wall-facing',
+                                            }),
+                                            value: 'wall',
+                                        },
+                                        {
+                                            label: i18n._({
+                                                id: 'node.stair.railingControls.postFacing',
+                                                message: 'Post-facing',
+                                            }),
+                                            value: 'post',
+                                        },
+                                        {
+                                            label: i18n._({ id: 'node.stair.railingControls.floor', message: 'Floor' }),
+                                            value: 'floor',
+                                        },
+                                    ], onChange: (value) => update({ return: value }) }), detail.return === 'wall' || detail.return === 'post' ? (_jsxs(_Fragment, { children: [_jsx(MetricControl, { label: i18n._({
+                                                id: 'node.stair.railingControls.returnLength',
+                                                message: 'Return length',
+                                            }), value: detail.returnLength, min: 0, step: 0.01, precision: 3, unit: "m", onChange: (returnLength) => update({ returnLength }) }), _jsx("p", { className: "text-xs text-muted-foreground", children: i18n._({
+                                                id: 'node.stair.railingControls.setTheLengthToReachThe',
+                                                message: 'Set the length to reach the wall or post.',
+                                            }) })] })) : null] }, end));
                     })] })) : null] }));
 }
 export function StairRailingField({ node }) {

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/stair/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAUL,KAAK,SAAS,EAOf,MAAM,kBAAkB,CAAA;AA2DzB,eAAO,MAAM,aAAa,sBAAuB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCA+JnE,CAAA;eAivCc,aAAa"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/stair/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAUL,KAAK,SAAS,EAQf,MAAM,kBAAkB,CAAA;AA2DzB,eAAO,MAAM,aAAa,sBAAuB;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCA+JnE,CAAA;eAqvCc,aAAa"}

package/dist/stair/renderer.js

@@ -1,6 +1,6 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, 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 { computeSegmentTransforms, measureStairDetail, resolveArcStairConstruction, resolveStairArcLayout, resolveStairRailPaths, resolveStairWalkingPaths, rotateXZ, STAIR_RAILING_SLOT_DEFAULT, stairArcSliceCount, stairStructureConstructionOf, 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';
@@ -41,7 +41,7 @@ export const StairRenderer = ({ node: rawNode }) => {
     useLayoutEffect(() => {
         for (const id of node.children)
             useScene.getState().markDirty(id);
-    }, [node.children, node.construction]);
+    }, [node.children, node.construction, node.structure]);
     const detail = useMemo(() => measureStairDetail(node, segments), [node, segments]);
     const mergedMaterials = useMemo(() => segments.length
         ? segments.flatMap((segment) => resolveStairSegmentMaterials(segment, node, bodyMaterials, sceneMaterials, shading, textures, colorPreset))
@@ -80,14 +80,20 @@ function StairSurfaceTransition({ stair, materials, }) {
         flight?.length ??
         0;
     const segment = flight;
-    const fillToFloor = flightOverride?.fillToFloor ??
-        segment?.fillToFloor ??
-        stair.fillToFloor ??
-        true;
-    const thickness = flightOverride?.thickness ??
-        segment?.thickness ??
-        stair.thickness ??
-        0.25;
+    // a structure fills to the floor when it is poured, and is a tread thick when it is framed
+    const structureBody = stair.construction ? null : stairStructureConstructionOf(stair);
+    const fillToFloor = structureBody
+        ? structureBody.mode === 'solid'
+        : (flightOverride?.fillToFloor ??
+            segment?.fillToFloor ??
+            stair.fillToFloor ??
+            true);
+    const thickness = structureBody
+        ? structureBody.treadThickness + structureBody.finishThickness
+        : (flightOverride?.thickness ??
+            segment?.thickness ??
+            stair.thickness ??
+            0.25);
     const segmentHeight = flightOverride?.height ?? segment?.height ?? 0;
     const profile = useMemo(() => surface
         ? surfaceTransitionProfile(stair, surface, length)

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

@@ -0,0 +1,18 @@
+import { type StairNode, type StairSegmentNode } from '@pascal-app/core';
+/**
+ * How the stair is built (its stringers, with the code's numbers behind them):
+ * wood stringers — stock, cut or housed, a maximum spacing that sets the count (or a count by
+ * hand), treads, risers and treated lumber — a poured concrete flight, or steel channels. The
+ * count it lands on shows under the controls.
+ */
+export declare function StairStructureControls({ node, segments, onUpdate, }: {
+    node: StairNode;
+    segments: readonly StairSegmentNode[];
+    onUpdate: (patch: Partial<StairNode>) => void;
+}): import("react").JSX.Element;
+/** The structure controls in the parametric inspector, over the stair's own flights. */
+export declare function StairStructureField({ node, onUpdate, }: {
+    node: StairNode;
+    onUpdate: (patch: Partial<StairNode>) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=structure-controls.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"structure-controls.d.ts","sourceRoot":"","sources":["../../src/stair/structure-controls.tsx"],"names":[],"mappings":"AAEA,OAAO,EAQL,KAAK,SAAS,EACd,KAAK,gBAAgB,EAMtB,MAAM,kBAAkB,CAAA;AA4GzB;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,EACrC,IAAI,EACJ,QAAQ,EACR,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,SAAS,CAAA;IACf,QAAQ,EAAE,SAAS,gBAAgB,EAAE,CAAA;IACrC,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,IAAI,CAAA;CAC9C,+BA+QA;AAED,wFAAwF;AACxF,wBAAgB,mBAAmB,CAAC,EAClC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,SAAS,CAAA;IACf,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,IAAI,CAAA;CAC9C,+BASA"}

package/dist/stair/structure-controls.js

@@ -0,0 +1,275 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { formatLinearMeasurement, resolveStairStringerLayout, resolveStairStructure, STAIR_STRINGER_SPACINGS_IN, StairStructure, usePascalI18n, useScene, } from '@pascal-app/core';
+import { MetricControl, SelectControl } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useShallow } from 'zustand/react/shallow';
+const IN = 0.0254;
+/** The concrete a poured flight is painted when it carries no paint of its own. */
+const CONCRETE_PRESET = 'library:concrete-raw';
+const STRUCTURE_OPTIONS = [
+    {
+        label: /* i18n */ { id: 'node.stair.structureControls.originalBody', message: 'Original body' },
+        value: 'none',
+    },
+    {
+        label: /* i18n */ {
+            id: 'node.stair.structureControls.woodStringers',
+            message: 'Wood stringers',
+        },
+        value: 'wood-stringers',
+    },
+    {
+        label: /* i18n */ { id: 'node.stair.structureControls.concrete', message: 'Concrete' },
+        value: 'concrete',
+    },
+    {
+        label: /* i18n */ {
+            id: 'node.stair.structureControls.steelStringers',
+            message: 'Steel stringers',
+        },
+        value: 'steel-stringers',
+    },
+];
+/** The lumber a tread is cut from; the trade size is a value, not copy. */
+const TREAD_LABELS = {
+    '2x6-pair': /* i18n */ {
+        id: 'node.stair.structureControls.twoStock',
+        message: 'Two {stock}',
+        values: { stock: '2x6' },
+    },
+    '5/4x6-pair': /* i18n */ {
+        id: 'node.stair.structureControls.twoStock',
+        message: 'Two {stock}',
+        values: { stock: '5/4x6' },
+    },
+    '2x12': /* i18n */ {
+        id: 'node.stair.structureControls.oneStock',
+        message: 'One {stock}',
+        values: { stock: '2x12' },
+    },
+    'plywood-finish': /* i18n */ {
+        id: 'node.stair.structureControls.plywoodFinish',
+        message: 'Plywood + finish',
+    },
+};
+const choiceOf = (value) => value === undefined ? 'auto' : value ? 'yes' : 'no';
+const choiceValue = (choice) => choice === 'auto' ? undefined : choice === 'yes';
+/** A flight's stringers as the status line reads them: `3 stringers at 1' 4" o.c. (auto)`. */
+function stringerLayoutLine(layout, spacing, i18n) {
+    const values = { count: layout.count, spacing };
+    let line;
+    if (layout.steel)
+        line =
+            layout.count > 1
+                ? i18n._({
+                    id: 'node.stair.structureControls.countSteelChannelsAtSpacing',
+                    message: '{count, plural, one {# steel channel at {spacing} o.c.} other {# steel channels at {spacing} o.c.}}',
+                    values,
+                })
+                : i18n._({
+                    id: 'node.stair.structureControls.countSteelChannels',
+                    message: '{count, plural, one {# steel channel} other {# steel channels}}',
+                    values,
+                });
+    else
+        line =
+            layout.count > 1
+                ? i18n._({
+                    id: 'node.stair.structureControls.countStringersAtSpacing',
+                    message: '{count, plural, one {# stringer at {spacing} o.c.} other {# stringers at {spacing} o.c.}}',
+                    values,
+                })
+                : i18n._({
+                    id: 'node.stair.structureControls.countStringers',
+                    message: '{count, plural, one {# stringer} other {# stringers}}',
+                    values,
+                });
+    if (!layout.auto)
+        return line;
+    return i18n._({
+        id: 'node.stair.structureControls.layoutAuto',
+        message: '{layout} (auto)',
+        comment: 'The stringer count was chosen automatically, not set by hand.',
+        values: { layout: line },
+    });
+}
+/**
+ * How the stair is built (its stringers, with the code's numbers behind them):
+ * wood stringers — stock, cut or housed, a maximum spacing that sets the count (or a count by
+ * hand), treads, risers and treated lumber — a poured concrete flight, or steel channels. The
+ * count it lands on shows under the controls.
+ */
+export function StairStructureControls({ node, segments, onUpdate, }) {
+    const i18n = usePascalI18n();
+    const unit = useViewer((state) => state.unit);
+    const metricNotation = useViewer((state) => state.metricNotation);
+    const resolved = resolveStairStructure(node);
+    const stored = node.structure ? StairStructure.safeParse(node.structure) : null;
+    const structure = stored?.success ? stored.data : null;
+    const update = (patch) => onUpdate({ structure: StairStructure.parse({ ...structure, ...patch }) });
+    const setType = (value) => {
+        if (value === 'none') {
+            onUpdate({
+                structure: undefined,
+                ...(node.materialPreset === CONCRETE_PRESET ? { materialPreset: undefined } : {}),
+            });
+            return;
+        }
+        const painted = node.material !== undefined || typeof node.materialPreset === 'string';
+        onUpdate({
+            structure: StairStructure.parse({ ...structure, type: value }),
+            // a poured flight reads as concrete until it is painted otherwise; leaving concrete takes
+            // that paint back off
+            ...(value === 'concrete' && !painted ? { materialPreset: CONCRETE_PRESET } : {}),
+            ...(value !== 'concrete' && node.materialPreset === CONCRETE_PRESET
+                ? { materialPreset: undefined }
+                : {}),
+        });
+    };
+    const flights = segments.filter((segment) => segment.segmentType === 'stair');
+    const widths = flights.length ? flights.map((flight) => flight.width) : [node.width];
+    const layouts = resolved && resolved.type !== 'concrete'
+        ? widths.map((width) => ({ width, layout: resolveStairStringerLayout(width, resolved) }))
+        : [];
+    const first = layouts[0]?.layout;
+    const autoCount = resolved && first
+        ? resolveStairStringerLayout(widths[0], { ...resolved, stringerCount: undefined }).count
+        : 0;
+    const wood = resolved?.type === 'wood-stringers';
+    const spacingIn = structure ? Math.round((structure.stringerSpacing / IN) * 100) / 100 : 16;
+    const spacings = STAIR_STRINGER_SPACINGS_IN.includes(spacingIn)
+        ? [...STAIR_STRINGER_SPACINGS_IN]
+        : [...STAIR_STRINGER_SPACINGS_IN, spacingIn].sort((a, b) => a - b);
+    return (_jsxs("div", { className: "space-y-3", children: [_jsx(SelectControl, { label: i18n._({ id: 'node.stair.structureControls.structure', message: 'Structure' }), value: resolved?.type ?? 'none', options: STRUCTURE_OPTIONS.map((option) => ({ ...option, label: i18n._(option.label) })), onChange: setType }), resolved && structure ? (_jsxs(_Fragment, { children: [wood ? (_jsxs(_Fragment, { children: [_jsx(SelectControl, { label: i18n._({
+                                    id: 'node.stair.structureControls.stringers',
+                                    message: 'Stringers',
+                                }), value: structure.stringerStock, options: [
+                                    { label: '2x12', value: '2x12' },
+                                    { label: '2x10', value: '2x10' },
+                                ], onChange: (stringerStock) => update({ stringerStock }) }), _jsx(SelectControl, { label: i18n._({
+                                    id: 'node.stair.structureControls.stringerType',
+                                    message: 'Stringer type',
+                                }), value: structure.stringerType, options: [
+                                    {
+                                        label: i18n._({ id: 'node.stair.structureControls.cut', message: 'Cut' }),
+                                        value: 'cut',
+                                    },
+                                    {
+                                        label: i18n._({
+                                            id: 'node.stair.structureControls.housedSides',
+                                            message: 'Housed sides',
+                                        }),
+                                        value: 'housed',
+                                    },
+                                ], onChange: (stringerType) => update({ stringerType }) }), _jsx(SelectControl, { label: i18n._({
+                                    id: 'node.stair.structureControls.maxSpacing',
+                                    message: 'Max spacing',
+                                }), value: String(spacingIn), options: spacings.map((inches) => ({
+                                    label: i18n._({
+                                        id: 'node.stair.structureControls.inchesInOC',
+                                        message: '{inches} in o.c.',
+                                        values: { inches },
+                                    }),
+                                    value: String(inches),
+                                })), onChange: (value) => update({ stringerSpacing: Number(value) * IN }) })] })) : null, resolved.type !== 'concrete' && first ? (_jsxs(_Fragment, { children: [_jsx(SelectControl, { label: i18n._({
+                                    id: 'node.stair.structureControls.stringerCount',
+                                    message: 'Stringer count',
+                                }), value: structure.stringerCount === undefined ? 'auto' : String(structure.stringerCount), options: [
+                                    {
+                                        label: i18n._({
+                                            id: 'node.stair.structureControls.autoAutocount',
+                                            message: 'Auto ({autoCount})',
+                                            values: { autoCount },
+                                        }),
+                                        value: 'auto',
+                                    },
+                                    ...[2, 3, 4, 5, 6, 7, 8].map((count) => ({
+                                        label: String(count),
+                                        value: String(count),
+                                    })),
+                                ], onChange: (value) => update({ stringerCount: value === 'auto' ? undefined : Number(value) }) }), _jsx(SelectControl, { label: i18n._({ id: 'node.stair.structureControls.treads', message: 'Treads' }), value: structure.treadStock ?? 'auto', options: [
+                                    {
+                                        label: i18n._({
+                                            id: 'node.stair.structureControls.autoTreads',
+                                            message: 'Auto ({treads})',
+                                            values: { treads: i18n._(TREAD_LABELS[resolved.treadStock]) },
+                                        }),
+                                        value: 'auto',
+                                    },
+                                    ...Object.keys(TREAD_LABELS).map((stock) => ({
+                                        label: i18n._(TREAD_LABELS[stock]),
+                                        value: stock,
+                                    })),
+                                ], onChange: (value) => update({ treadStock: value === 'auto' ? undefined : value }) }), _jsx(SelectControl, { label: i18n._({ id: 'node.stair.structureControls.risers', message: 'Risers' }), value: choiceOf(structure.closedRisers), options: [
+                                    {
+                                        label: resolved.closedRisers
+                                            ? i18n._({
+                                                id: 'node.stair.structureControls.autoClosed',
+                                                message: 'Auto (closed)',
+                                            })
+                                            : i18n._({
+                                                id: 'node.stair.structureControls.autoOpen',
+                                                message: 'Auto (open)',
+                                            }),
+                                        value: 'auto',
+                                    },
+                                    {
+                                        label: i18n._({
+                                            id: 'node.stair.structureControls.closed1x8Boards',
+                                            message: 'Closed (1x8 boards)',
+                                        }),
+                                        value: 'yes',
+                                    },
+                                    {
+                                        label: i18n._({ id: 'node.stair.structureControls.open', message: 'Open' }),
+                                        value: 'no',
+                                    },
+                                ], onChange: (value) => update({ closedRisers: choiceValue(value) }) }), wood ? (_jsx(SelectControl, { label: i18n._({ id: 'node.stair.structureControls.lumber', message: 'Lumber' }), value: choiceOf(structure.treated), options: [
+                                    {
+                                        label: resolved.treated
+                                            ? i18n._({
+                                                id: 'node.stair.structureControls.autoPressureTreated',
+                                                message: 'Auto (pressure-treated)',
+                                            })
+                                            : i18n._({
+                                                id: 'node.stair.structureControls.autoUntreated',
+                                                message: 'Auto (untreated)',
+                                            }),
+                                        value: 'auto',
+                                    },
+                                    {
+                                        label: i18n._({
+                                            id: 'node.stair.structureControls.pressureTreated',
+                                            message: 'Pressure-treated',
+                                        }),
+                                        value: 'yes',
+                                    },
+                                    {
+                                        label: i18n._({
+                                            id: 'node.stair.structureControls.untreated',
+                                            message: 'Untreated',
+                                        }),
+                                        value: 'no',
+                                    },
+                                ], onChange: (value) => update({ treated: choiceValue(value) }) })) : null] })) : null, _jsx(MetricControl, { label: i18n._({ id: 'node.stair.structureControls.nosing', message: 'Nosing' }), min: 0, max: 0.1, value: resolved.nosing, onChange: (nosing) => update({ nosing }), unit: "m", step: 0.005, precision: 3 }), _jsx("div", { role: "status", className: "space-y-1 px-1 text-[11px] text-muted-foreground", children: resolved.type === 'concrete' ? (_jsx("div", { children: i18n._({
+                                id: 'node.stair.structureControls.aSolidPouredFlightOnA',
+                                message: 'A solid poured flight on a footing; risers closed, no stringers.',
+                            }) })) : (layouts.map(({ width, layout }, index) => {
+                            const line = stringerLayoutLine(layout, formatLinearMeasurement(layout.spacing, unit, metricNotation), i18n);
+                            return (_jsx("div", { children: layouts.length > 1
+                                    ? i18n._({
+                                        id: 'node.stair.structureControls.flightLayout',
+                                        message: 'Flight {number}: {layout}',
+                                        values: { number: index + 1, layout: line },
+                                    })
+                                    : line }, `${index}-${width}`));
+                        })) })] })) : null] }));
+}
+/** The structure controls in the parametric inspector, over the stair's own flights. */
+export function StairStructureField({ node, onUpdate, }) {
+    const segments = useScene(useShallow((state) => (node.children ?? [])
+        .map((id) => state.nodes[id])
+        .filter((child) => child?.type === 'stair-segment')));
+    return _jsx(StairStructureControls, { node: node, segments: segments, onUpdate: onUpdate });
+}

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/stair/tool.tsx"],"names":[],"mappings":"AA+TA,MAAM,CAAC,OAAO,UAAU,SAAS,gCA8dhC"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/stair/tool.tsx"],"names":[],"mappings":"AAwUA,MAAM,CAAC,OAAO,UAAU,SAAS,gCA8dhC"}

package/dist/stair/tool.js

@@ -6,6 +6,7 @@ import { useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three';
+import { newStairStructure, pickedStairRailingMode, surfaceFlightRailingMode, } from './placement-defaults.js';
 import { createStairCommitGate, swallowFollowUpBrowserClick } from './stair-click-guard.js';
 const GRID_OFFSET = 0.02;
 /** Figma-style alignment-snap threshold (meters), matching the move tools. */
@@ -66,8 +67,15 @@ function createSeedStairSegment(rise) {
         thickness: DEFAULT_STAIR_THICKNESS,
     });
 }
+/** The railing mode picked for the stair tool, when one is. */
+function pickedRailingMode() {
+    return pickedStairRailingMode(useEditor.getState().toolDefaults.stair?.railingMode);
+}
+/** A deck, porch or patio flight's railing (`surfaceFlightRailingMode`), the tool's pick first. */
+function surfaceSnapRailingMode(snap) {
+    return surfaceFlightRailingMode(snap, pickedRailingMode());
+}
 function createDefaultStairNode({ name, levelId, nextLevelId, position, rotation, segmentId, }) {
-    const railingMode = useEditor.getState().toolDefaults.stair?.railingMode;
     return StairNode.parse({
         name,
         parentId: levelId,
@@ -89,12 +97,8 @@ function createDefaultStairNode({ name, levelId, nextLevelId, position, rotation
         showCenterColumn: DEFAULT_SPIRAL_SHOW_CENTER_COLUMN,
         showStepSupports: DEFAULT_SPIRAL_SHOW_STEP_SUPPORTS,
         railingHeight: DEFAULT_STAIR_RAILING_HEIGHT,
-        railingMode: railingMode === 'none' ||
-            railingMode === 'left' ||
-            railingMode === 'right' ||
-            railingMode === 'both'
-            ? railingMode
-            : DEFAULT_STAIR_RAILING_MODE,
+        railingMode: pickedRailingMode() ?? DEFAULT_STAIR_RAILING_MODE,
+        structure: newStairStructure(useEditor.getState().toolDefaults.stair?.structure),
         children: [segmentId],
     });
 }
@@ -136,7 +140,7 @@ function commitStairPlacement(levelId, position, rotation, supportSurface, surfa
                 stepCount: surfaceSnap.stepCount,
                 slabOpeningMode: 'none',
                 destinationSurfaceId: surfaceSnap.surfaceId,
-                railingMode: 'none',
+                railingMode: surfaceSnapRailingMode(surfaceSnap),
             }
             : {}),
     });
@@ -289,7 +293,7 @@ export default function StairTool() {
                 stair.totalRise = surfaceSnap.totalRise;
                 stair.destinationSurfaceId = surfaceSnap.surfaceId;
                 stair.slabOpeningMode = 'none';
-                stair.railingMode = 'none';
+                stair.railingMode = surfaceSnapRailingMode(surfaceSnap);
                 segment = {
                     ...segment,
                     height: surfaceSnap.totalRise,

package/dist/stair/use-stair-render-data.d.ts

@@ -42,6 +42,11 @@ export declare function useStairRenderData(stair: StairNode): {
                 url: string;
                 repeat?: [number, number] | undefined;
                 scale?: number | undefined;
+                offset?: [number, number] | undefined;
+                normalMap?: string | undefined;
+                normalScale?: number | undefined;
+                bumpMap?: string | undefined;
+                bumpScale?: number | undefined;
             } | undefined;
         } | undefined;
         materialPreset?: string | undefined;
@@ -60,6 +65,11 @@ export declare function useStairRenderData(stair: StairNode): {
                 url: string;
                 repeat?: [number, number] | undefined;
                 scale?: number | undefined;
+                offset?: [number, number] | undefined;
+                normalMap?: string | undefined;
+                normalScale?: number | undefined;
+                bumpMap?: string | undefined;
+                bumpScale?: number | undefined;
             } | undefined;
         } | undefined;
         railingMaterialPreset?: string | undefined;
@@ -78,6 +88,11 @@ export declare function useStairRenderData(stair: StairNode): {
                 url: string;
                 repeat?: [number, number] | undefined;
                 scale?: number | undefined;
+                offset?: [number, number] | undefined;
+                normalMap?: string | undefined;
+                normalScale?: number | undefined;
+                bumpMap?: string | undefined;
+                bumpScale?: number | undefined;
             } | undefined;
         } | undefined;
         treadMaterialPreset?: string | undefined;
@@ -96,6 +111,11 @@ export declare function useStairRenderData(stair: StairNode): {
                 url: string;
                 repeat?: [number, number] | undefined;
                 scale?: number | undefined;
+                offset?: [number, number] | undefined;
+                normalMap?: string | undefined;
+                normalScale?: number | undefined;
+                bumpMap?: string | undefined;
+                bumpScale?: number | undefined;
             } | undefined;
         } | undefined;
         sideMaterialPreset?: string | undefined;
@@ -134,6 +154,17 @@ export declare function useStairRenderData(stair: StairNode): {
             stringerWidth: number;
             stringerDepth: number;
         } | undefined;
+        structure?: {
+            type: "concrete" | "steel-stringers" | "wood-stringers";
+            stringerStock: "2x10" | "2x12";
+            stringerType: "cut" | "housed";
+            stringerSpacing: number;
+            stringerCount?: number | undefined;
+            treadStock?: "2x12" | "2x6-pair" | "5/4x6-pair" | "plywood-finish" | undefined;
+            closedRisers?: boolean | undefined;
+            treated?: boolean | undefined;
+            nosing?: number | undefined;
+        } | undefined;
         innerRadius: number;
         sweepAngle: number;
         topLandingMode: "integrated" | "none";
@@ -206,6 +237,11 @@ export declare function useStairRenderData(stair: StairNode): {
                 url: string;
                 repeat?: [number, number] | undefined;
                 scale?: number | undefined;
+                offset?: [number, number] | undefined;
+                normalMap?: string | undefined;
+                normalScale?: number | undefined;
+                bumpMap?: string | undefined;
+                bumpScale?: number | undefined;
             } | undefined;
         } | undefined;
         materialPreset?: string | undefined;
@@ -280,6 +316,11 @@ export declare function useStairRenderData(stair: StairNode): {
                     url: string;
                     repeat?: [number, number] | undefined;
                     scale?: number | undefined;
+                    offset?: [number, number] | undefined;
+                    normalMap?: string | undefined;
+                    normalScale?: number | undefined;
+                    bumpMap?: string | undefined;
+                    bumpScale?: number | undefined;
                 } | undefined;
             } | undefined;
             materialPreset?: string | undefined;

package/dist/stair/use-stair-render-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"use-stair-render-data.d.ts","sourceRoot":"","sources":["../../src/stair/use-stair-render-data.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AA0BzB,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,UAkCjD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBlD;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAA"}
+{"version":3,"file":"use-stair-render-data.d.ts","sourceRoot":"","sources":["../../src/stair/use-stair-render-data.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AA0BzB,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,UAkCjD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBlD;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAA"}