@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/stair/baluster-guard.js

@@ -0,0 +1,71 @@
+/**
+ * One coherent baluster guard laid out along a rail path, as oriented boxes.
+ *
+ * A guard is built the way a joiner builds it: a newel at each end (and, when
+ * a spacing is given, every bay between), a top rail and a bottom rail that
+ * follow the path with a square fitting block closing every interior corner,
+ * and square pickets spanning the two rails. The path sampling, corner finding
+ * and newel/picket stations are the style-agnostic chassis in `guard-path.ts`,
+ * shared with the deck post-and-rail guard; this file only turns those stations
+ * into the baluster style's members. The caller renders the boxes
+ * (`renderer.tsx`) or merges them into one mesh (`continuous-railings.tsx`),
+ * so this stays pure data — no Three.js meshes, no React.
+ *
+ * `pickets` is a metre pitch sampled along the horizontal run, so the density
+ * tracks the run rather than the path's tessellation. Pickets that fall inside
+ * a newel are dropped. `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 newel.
+ */
+import { buildGuardChassis, guardPickets, } from './guard-path';
+// Residential wood balusters, in metres: a 3¼ in newel, a graspable cap on a
+// top rail, a shoe rail off the nosing line, and 1¼ in square pickets between
+// them. The joint block is a newel-less fitting that closes a plan corner.
+const NEWEL = 0.082;
+const NEWEL_CAP_T = 0.028;
+const NEWEL_CAP_OVERHANG = 0.03;
+const NEWEL_EMBED = 0.03;
+const NEWEL_ABOVE = 0.04;
+const POST_THROUGH_RISE = 0.0762;
+/** The two rails' section (`across` the run, `vertical`) and `y` off the nosing line. */
+export const BALUSTER_RAIL_PROFILE = {
+    top: { across: 0.062, vertical: 0.05, y: 0 },
+    bottom: { across: 0.045, vertical: 0.045, y: 0.08 },
+};
+const TOP_RAIL_T = BALUSTER_RAIL_PROFILE.top.vertical;
+const BOTTOM_RAIL_T = BALUSTER_RAIL_PROFILE.bottom.vertical;
+const BOTTOM_RAIL_Y = BALUSTER_RAIL_PROFILE.bottom.y;
+const PICKET = 0.032;
+/** The widest clear gap left between pickets, in metres (0.1016 m = 4 in). */
+const PICKET_MAX_GAP = 0.1016;
+/** A guard's rails as `{ center y off the nosing line, section across, vertical }`,
+ * bottom-to-top. Shared with the flight-to-flight connector so a bridge carries
+ * the same rails as the guards it joins. */
+export function balusterGuardRails(railHeight) {
+    return [
+        { y: railHeight, across: BALUSTER_RAIL_PROFILE.top.across, vertical: TOP_RAIL_T },
+        { y: BOTTOM_RAIL_Y, across: BALUSTER_RAIL_PROFILE.bottom.across, vertical: BOTTOM_RAIL_T },
+    ];
+}
+export function buildBalusterGuard(points, options) {
+    const { railHeight } = options;
+    const chassis = buildGuardChassis(points, options, balusterGuardRails(railHeight), {
+        width: NEWEL,
+        embed: NEWEL_EMBED,
+        top: NEWEL_ABOVE,
+        throughTop: NEWEL_ABOVE + POST_THROUGH_RISE,
+        capThickness: NEWEL_CAP_T,
+        capOverhang: NEWEL_CAP_OVERHANG,
+    }, {
+        picketPitch: options.pickets,
+        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, NEWEL, BOTTOM_RAIL_Y + BOTTOM_RAIL_T / 2, railHeight - TOP_RAIL_T / 2));
+    return boxes;
+}

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

@@ -0,0 +1,37 @@
+/**
+ * One coherent board-infill deck guard laid out along a rail path, as oriented
+ * boxes — the AWC Deck Construction Guide (DCA 6) solid-board guard in metres: a
+ * 4x4 post at each end (and every bay ≤ 4 ft between), a flat 2x6 cap over them,
+ * and a stack of 1x6 boards running flat along the path between the nosing line
+ * and the cap, each course held off the one below by a consistent gap. Every
+ * member — the cap and every board course — follows the same path and gets a
+ * fitting block at a real plan corner, so the courses read as one connected
+ * panel that turns cleanly rather than butting open-ended at a corner.
+ *
+ * It shares the path sampling, corner finding and newel stations in
+ * `guard-path.ts` with the baluster and post-and-rail guards, so a straight
+ * flight, a chained L/U landing turn, a winder, a curved or spiral sweep and an
+ * integrated top landing all read as the same guard; only the sections and the
+ * horizontal board infill differ. Pure data — no Three.js, no React.
+ *
+ * `reach` runs the members 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 BoardsGuardOptions = {
+    railHeight: number;
+    /** Metres between posts along the run; omit (or Infinity) for ends only. */
+    postSpacing?: number;
+    topPost?: boolean;
+    postThrough?: boolean;
+    /** Metres the members run past the top vertex, along the final slope. */
+    reach?: number;
+};
+/** The board guard's members, bottom-to-top: a stack of 1x6 board courses held
+ * off the nosing line by `BOARD_GAP`, then the flat 2x6 cap. Each is a rail that
+ * follows the path, so a corner gets a fitting block per course. Shared with the
+ * flight connector so a bridge carries the same courses as the guards it joins. */
+export declare function boardsGuardRails(railHeight: number): GuardRail[];
+export declare function buildBoardsGuard(points: Vec3[], options: BoardsGuardOptions): GuardBox[];
+//# sourceMappingURL=boards-guard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"boards-guard.d.ts","sourceRoot":"","sources":["../../src/stair/boards-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;GAmBG;AAEH,OAAO,EAAqB,KAAK,QAAQ,EAAE,KAAK,SAAS,EAAE,KAAK,IAAI,EAAE,MAAM,cAAc,CAAA;AAE1F,MAAM,MAAM,kBAAkB,GAAG;IAC/B,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,yEAAyE;IACzE,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAcD;;;mFAGmF;AACnF,wBAAgB,gBAAgB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,CAWhE;AAED,wBAAgB,gBAAgB,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,kBAAkB,GAAG,QAAQ,EAAE,CAqBxF"}

package/dist/stair/boards-guard.js

@@ -0,0 +1,61 @@
+/**
+ * One coherent board-infill deck guard laid out along a rail path, as oriented
+ * boxes — the AWC Deck Construction Guide (DCA 6) solid-board guard in metres: a
+ * 4x4 post at each end (and every bay ≤ 4 ft between), a flat 2x6 cap over them,
+ * and a stack of 1x6 boards running flat along the path between the nosing line
+ * and the cap, each course held off the one below by a consistent gap. Every
+ * member — the cap and every board course — follows the same path and gets a
+ * fitting block at a real plan corner, so the courses read as one connected
+ * panel that turns cleanly rather than butting open-ended at a corner.
+ *
+ * It shares the path sampling, corner finding and newel stations in
+ * `guard-path.ts` with the baluster and post-and-rail guards, so a straight
+ * flight, a chained L/U landing turn, a winder, a curved or spiral sweep and an
+ * integrated top landing all read as the same guard; only the sections and the
+ * horizontal board infill differ. Pure data — no Three.js, no React.
+ *
+ * `reach` runs the members 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 } 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 BOARD_W = 0.019; // 1x6 board on the flat: thin across the run
+const BOARD_D = 0.1397; // its vertical face height
+const BOARD_GAP = 0.0889; // clear gap below the lowest board and between courses
+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 board guard's members, bottom-to-top: a stack of 1x6 board courses held
+ * off the nosing line by `BOARD_GAP`, then the flat 2x6 cap. Each is a rail that
+ * follows the path, so a corner gets a fitting block per course. Shared with the
+ * flight connector so a bridge carries the same courses as the guards it joins. */
+export function boardsGuardRails(railHeight) {
+    const rails = [];
+    const capUnderside = railHeight - CAP_T;
+    for (let bottom = BOARD_GAP; bottom + BOARD_D <= capUnderside + 1e-6; bottom += BOARD_D + BOARD_GAP)
+        rails.push({ y: bottom + BOARD_D / 2, across: BOARD_W, vertical: BOARD_D });
+    rails.push({ y: railHeight - CAP_T / 2, across: CAP_W, vertical: CAP_T });
+    return rails;
+}
+export function buildBoardsGuard(points, options) {
+    const { railHeight } = options;
+    const chassis = buildGuardChassis(points, options, boardsGuardRails(railHeight), {
+        width: POST,
+        embed: POST_EMBED,
+        top: -CAP_T,
+        throughTop: POST_ABOVE_CAP,
+        capThickness: POST_CAP_T,
+        capOverhang: POST_CAP_OVERHANG,
+    }, {});
+    if (!chassis)
+        return [];
+    const { path, boxes } = chassis;
+    if (path.kind === 'pivot')
+        return boxes;
+    return boxes;
+}

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

@@ -0,0 +1,39 @@
+/**
+ * One coherent cable guard laid out along a rail path, as oriented boxes — the
+ * modern metal cable rail in metres: a slim square post at each end (and every
+ * bay ≤ 4 ft between), a flat cap rail following the path over them, and
+ * slender round cables run as straight spans from post to post, with a short
+ * swage sleeve where each cable dies into a terminal post. It shares the path
+ * sampling, corner finding and newel/picket stations in `guard-path.ts` with
+ * the baluster and deck post-and-rail guards, so a straight flight, a chained
+ * L/U landing turn, a winder, a curved or spiral sweep and an integrated top
+ * landing all read as the same cable rail; only the sections and the infill
+ * differ. Pure data — no Three.js, no React.
+ *
+ * The cables are the physical intent of a cable rail, not a fiction: real cable
+ * is pulled taut, so on a curved or spiral sweep it cannot follow the arc. Each
+ * cable level is therefore a run of straight chords between consecutive posts
+ * (the posts are the support stations, spaced by run and so independent of the
+ * tread count), while the cap rail follows the curve. On a straight flight the
+ * collinear posts make those chords read as one line.
+ *
+ * `reach` runs the cap and the top cables 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 CableGuardOptions = {
+    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 cable guard's single flat cap rail. Shared with the flight connector so
+ * a bridge between flights carries the same cap as the guards it joins. */
+export declare function cableGuardRails(railHeight: number): GuardRail[];
+export declare function buildCableGuard(points: Vec3[], options: CableGuardOptions): GuardBox[];
+//# sourceMappingURL=cable-guard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"cable-guard.d.ts","sourceRoot":"","sources":["../../src/stair/cable-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAIL,KAAK,QAAQ,EACb,KAAK,SAAS,EAGd,KAAK,IAAI,EACV,MAAM,cAAc,CAAA;AAErB,MAAM,MAAM,iBAAiB,GAAG;IAC9B,UAAU,EAAE,MAAM,CAAA;IAClB,4EAA4E;IAC5E,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,OAAO,CAAC,EAAE,OAAO,CAAA;IACjB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,uEAAuE;IACvE,KAAK,CAAC,EAAE,MAAM,CAAA;CACf,CAAA;AAiBD;2EAC2E;AAC3E,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,CAE/D;AAUD,wBAAgB,eAAe,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,iBAAiB,GAAG,QAAQ,EAAE,CAkDtF"}

package/dist/stair/cable-guard.js

@@ -0,0 +1,105 @@
+/**
+ * One coherent cable guard laid out along a rail path, as oriented boxes — the
+ * modern metal cable rail in metres: a slim square post at each end (and every
+ * bay ≤ 4 ft between), a flat cap rail following the path over them, and
+ * slender round cables run as straight spans from post to post, with a short
+ * swage sleeve where each cable dies into a terminal post. It shares the path
+ * sampling, corner finding and newel/picket stations in `guard-path.ts` with
+ * the baluster and deck post-and-rail guards, so a straight flight, a chained
+ * L/U landing turn, a winder, a curved or spiral sweep and an integrated top
+ * landing all read as the same cable rail; only the sections and the infill
+ * differ. Pure data — no Three.js, no React.
+ *
+ * The cables are the physical intent of a cable rail, not a fiction: real cable
+ * is pulled taut, so on a curved or spiral sweep it cannot follow the arc. Each
+ * cable level is therefore a run of straight chords between consecutive posts
+ * (the posts are the support stations, spaced by run and so independent of the
+ * tread count), while the cap rail follows the curve. On a straight flight the
+ * collinear posts make those chords read as one line.
+ *
+ * `reach` runs the cap and the top cables 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 { add, barBox, buildGuardChassis, scale, sub, } from './guard-path';
+// Dressed metal cable rail, in metres.
+const POST = 0.0508; // a 2 in slim square post
+const POST_EMBED = 0.05; // the post foot runs this far below the nosing line
+const CAP_W = 0.0635; // a flat 2½ in cap over the posts
+const CAP_T = 0.0381;
+const CABLE_D = 0.0095; // 3⁄8 in round cable
+const CABLE_PITCH = 0.0762; // 3 in on centre (IRC-style infill limit)
+const CABLE_BOTTOM = 0.0762; // the lowest cable sits this far over the nosing line
+const CABLE_CLEAR = 0.025; // the top cable stays this far under the cap underside
+const SLEEVE_D = 0.019; // a 3⁄4 in swage sleeve at a cable's terminal post
+const SLEEVE_LEN = 0.05;
+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.0381;
+/** The cable guard's single flat cap rail. Shared with the flight connector so
+ * a bridge between flights carries the same cap as the guards it joins. */
+export function cableGuardRails(railHeight) {
+    return [{ y: railHeight - CAP_T / 2, across: CAP_W, vertical: CAP_T }];
+}
+/** Cable centreline heights off the nosing line, bottom-to-top. */
+function cableLevels(railHeight) {
+    const top = railHeight - CAP_T - CABLE_CLEAR - CABLE_D / 2;
+    const levels = [];
+    for (let y = CABLE_BOTTOM; y <= top + 1e-9; y += CABLE_PITCH)
+        levels.push(y);
+    return levels;
+}
+export function buildCableGuard(points, options) {
+    const { railHeight } = options;
+    const chassis = buildGuardChassis(points, options, cableGuardRails(railHeight), {
+        width: POST,
+        embed: POST_EMBED,
+        top: -CAP_T,
+        throughTop: POST_ABOVE_CAP,
+        capThickness: POST_CAP_T,
+        capOverhang: POST_CAP_OVERHANG,
+    }, { cornerPosts: true });
+    if (!chassis)
+        return [];
+    const { path, boxes } = chassis;
+    if (path.kind === 'pivot')
+        return boxes;
+    const { railPoints, isCorner, postPositions } = path;
+    // Cables: a run of straight chords between consecutive posts at each level,
+    // with a swage sleeve where the terminal posts anchor the ends.
+    const levels = cableLevels(railHeight);
+    for (const y of levels) {
+        for (let i = 1; i < postPositions.length; i++) {
+            const cable = barBox(add(postPositions[i - 1], [0, y, 0]), add(postPositions[i], [0, y, 0]), CABLE_D, CABLE_D);
+            if (cable)
+                boxes.push({ ...cable, round: true });
+        }
+        for (let i = 1; i < postPositions.length - 1; i++) {
+            const post = postPositions[i];
+            if (railPoints.some((point, index) => isCorner(index) && Math.hypot(...sub(point, post)) < 1e-6)) {
+                boxes.push(terminalSleeve(post, postPositions[i - 1], y));
+                boxes.push(terminalSleeve(post, postPositions[i + 1], y));
+            }
+        }
+        if (postPositions.length >= 2) {
+            boxes.push(terminalSleeve(postPositions[0], postPositions[1], y));
+            boxes.push(terminalSleeve(postPositions.at(-1), postPositions.at(-2), y));
+        }
+    }
+    return boxes;
+}
+/** A short round sleeve sitting at `post` at height `y`, pointing along the
+ * cable toward `toward` — the swage fitting that terminates a cable. */
+function terminalSleeve(post, toward, y) {
+    const along = sub(toward, post);
+    const length = Math.hypot(along[0], along[1], along[2]);
+    const unit = length > 1e-6 ? scale(along, 1 / length) : [0, 0, 1];
+    const base = add(post, [0, y, 0]);
+    return {
+        center: add(base, scale(unit, SLEEVE_LEN / 2)),
+        size: [SLEEVE_D, SLEEVE_D, SLEEVE_LEN],
+        direction: unit,
+        round: true,
+    };
+}

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

@@ -0,0 +1,15 @@
+import { StairConstruction, type StairNode, type StairSegmentNode } from '@pascal-app/core';
+export declare function StairConstructionControls({ node, inherited, onChange, }: {
+    node: StairNode | StairSegmentNode;
+    inherited?: StairConstruction;
+    onChange: (construction: StairConstruction | undefined) => void;
+}): import("react").JSX.Element;
+export declare function StairConstructionField({ node, onUpdate, }: {
+    node: StairNode;
+    onUpdate: (patch: Partial<StairNode>) => void;
+}): import("react").JSX.Element;
+export declare function StairSegmentConstructionField({ node, onUpdate, }: {
+    node: StairSegmentNode;
+    onUpdate: (patch: Partial<StairSegmentNode>) => void;
+}): import("react").JSX.Element;
+//# sourceMappingURL=construction-controls.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"construction-controls.d.ts","sourceRoot":"","sources":["../../src/stair/construction-controls.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,iBAAiB,EACjB,KAAK,SAAS,EACd,KAAK,gBAAgB,EAEtB,MAAM,kBAAkB,CAAA;AAYzB,wBAAgB,yBAAyB,CAAC,EACxC,IAAI,EACJ,SAAS,EACT,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,SAAS,GAAG,gBAAgB,CAAA;IAClC,SAAS,CAAC,EAAE,iBAAiB,CAAA;IAC7B,QAAQ,EAAE,CAAC,YAAY,EAAE,iBAAiB,GAAG,SAAS,KAAK,IAAI,CAAA;CAChE,+BAwGA;AAED,wBAAgB,sBAAsB,CAAC,EACrC,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,SAAS,CAAA;IACf,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,SAAS,CAAC,KAAK,IAAI,CAAA;CAC9C,+BAOA;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,IAAI,EACJ,QAAQ,GACT,EAAE;IACD,IAAI,EAAE,gBAAgB,CAAA;IACtB,QAAQ,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,gBAAgB,CAAC,KAAK,IAAI,CAAA;CACrD,+BAYA"}

package/dist/stair/construction-controls.js

@@ -0,0 +1,29 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { StairConstruction, useScene, } from '@pascal-app/core';
+import { MetricControl, SelectControl, ToggleControl } from '@pascal-app/editor';
+const OPTIONS = [
+    { label: 'Original', value: 'original' },
+    { label: 'Solid', value: 'solid' },
+    { label: 'Waist', value: 'waist' },
+    { label: 'Open', value: 'open' },
+    { label: 'Side stringers', value: 'side-stringers' },
+    { label: 'Center stringer', value: 'center-stringer' },
+];
+export function StairConstructionControls({ node, inherited, onChange, }) {
+    const effective = node.construction ?? inherited;
+    const update = (patch) => onChange(StairConstruction.parse({ ...effective, ...patch }));
+    return (_jsxs("div", { className: "space-y-3", children: [_jsx(SelectControl, { label: "Body", value: node.construction?.mode ?? 'original', options: OPTIONS.map((option) => option.value === 'original' && inherited ? { ...option, label: 'Inherit' } : option), onChange: (mode) => mode === 'original'
+                    ? onChange(undefined)
+                    : update({ mode: mode }) }), effective ? (_jsxs(_Fragment, { children: [effective.mode === 'waist' ? (_jsx(MetricControl, { label: "Waist thickness", min: 0.001, value: effective.waistThickness, onChange: (waistThickness) => update({ waistThickness }), unit: "m", step: 0.01, precision: 3 })) : null, _jsx(MetricControl, { label: "Tread thickness", min: 0.001, value: effective.treadThickness, onChange: (treadThickness) => update({ treadThickness }), unit: "m", step: 0.01, precision: 3 }), _jsx(MetricControl, { label: "Nosing", min: 0, value: effective.nosing, onChange: (nosing) => update({ nosing }), unit: "m", step: 0.005, precision: 3 }), _jsx(MetricControl, { label: "Tread finish", min: 0, value: effective.finishThickness, onChange: (finishThickness) => update({ finishThickness }), unit: "m", step: 0.005, precision: 3 }), effective.mode === 'solid' || effective.mode === 'waist' ? null : (_jsxs(_Fragment, { children: [_jsx(ToggleControl, { label: "Closed risers", checked: effective.closedRisers, onChange: (closedRisers) => update({ closedRisers }) }), effective.closedRisers ? (_jsx(MetricControl, { label: "Riser thickness", min: 0.001, value: effective.riserThickness, onChange: (riserThickness) => update({ riserThickness }), unit: "m", step: 0.005, precision: 3 })) : null] })), effective.mode === 'side-stringers' || effective.mode === 'center-stringer' ? (_jsxs(_Fragment, { children: [_jsx(MetricControl, { label: "Stringer width", min: 0.001, value: effective.stringerWidth, onChange: (stringerWidth) => update({ stringerWidth }), unit: "m", step: 0.01, precision: 3 }), _jsx(MetricControl, { label: "Stringer depth", min: 0.001, value: effective.stringerDepth, onChange: (stringerDepth) => update({ stringerDepth }), unit: "m", step: 0.01, precision: 3 })] })) : null] })) : null] }));
+}
+export function StairConstructionField({ node, onUpdate, }) {
+    return (_jsx(StairConstructionControls, { node: node, onChange: (construction) => onUpdate({ construction }) }));
+}
+export function StairSegmentConstructionField({ node, onUpdate, }) {
+    const inherited = useScene((state) => {
+        const parent = node.parentId ? state.nodes[node.parentId] : undefined;
+        return parent?.type === 'stair' ? parent.construction : undefined;
+    });
+    return (_jsx(StairConstructionControls, { node: node, inherited: inherited, onChange: (construction) => onUpdate({ construction }) }));
+}

package/dist/stair/continuous-railings.d.ts

@@ -0,0 +1,10 @@
+import { type StairNode } from '@pascal-app/core';
+import * as THREE from 'three';
+import type { StairRenderData } from './use-stair-render-data';
+export declare function ContinuousStairRailings({ stair, material, guard, renderData, }: {
+    stair: StairNode;
+    material: THREE.Material;
+    guard?: boolean;
+    renderData: StairRenderData;
+}): import("react").JSX.Element;
+//# sourceMappingURL=continuous-railings.d.ts.map

package/dist/stair/continuous-railings.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"continuous-railings.d.ts","sourceRoot":"","sources":["../../src/stair/continuous-railings.tsx"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAGf,MAAM,kBAAkB,CAAA;AAGzB,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAW9B,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAA;AA2J9D,wBAAgB,uBAAuB,CAAC,EACtC,KAAK,EACL,QAAQ,EACR,KAAY,EACZ,UAAU,GACX,EAAE;IACD,KAAK,EAAE,SAAS,CAAA;IAChB,QAAQ,EAAE,KAAK,CAAC,QAAQ,CAAA;IACxB,KAAK,CAAC,EAAE,OAAO,CAAA;IACf,UAAU,EAAE,eAAe,CAAA;CAC5B,+BA0EA"}

package/dist/stair/continuous-railings.js

@@ -0,0 +1,159 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { resolveStairHandrailPaths, resolveStairRailPaths, resolveStairWalkInside, useScene, } from '@pascal-app/core';
+import { getStairRailingMaterial, useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo } from 'react';
+import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { guardBoxGeometry, metricBox, metricCylinder } from './baluster-geometry';
+import { buildBalusterGuard } from './baluster-guard';
+import { buildBoardsGuard } from './boards-guard';
+import { buildCableGuard } from './cable-guard';
+import { buildGlassGuard } from './glass-guard';
+import { GUARD_PICKET_PITCH, GUARD_POST_SPACING } from './guard-path';
+import { resolveStairSlotMaterial } from './materials';
+import { buildMetalGuard } from './metal-guard';
+import { buildPostAndRailGuard } from './post-and-rail-guard';
+function bar(a, b, width, depth, round = false) {
+    const direction = b.clone().sub(a), length = direction.length();
+    if (length < 1e-8)
+        return null;
+    const geometry = round ? metricCylinder(width, length) : metricBox(length, depth, width);
+    if (round) {
+        geometry.applyQuaternion(new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), direction.clone().normalize()));
+    }
+    else {
+        const x = direction.normalize(), z = new THREE.Vector3().crossVectors(x, new THREE.Vector3(0, 1, 0)).normalize();
+        if (z.lengthSq() < 1e-8)
+            z.set(0, 0, 1);
+        const y = new THREE.Vector3().crossVectors(z, x).normalize();
+        geometry.applyMatrix4(new THREE.Matrix4().makeBasis(x, y, z));
+    }
+    geometry.translate((a.x + b.x) / 2, (a.y + b.y) / 2, (a.z + b.z) / 2);
+    return geometry;
+}
+/** One flat glass pane as a plumb-edged parallelogram of real thickness, with
+ * metre UVs on every face (E-009). Built in a local frame (x along the chord, y
+ * vertical, z the thickness) then yawed to the chord heading and set at its
+ * inset foot, so the pane's edges stay plumb through a sloping flight. */
+function glassPanelGeometry(panel) {
+    const { run, rise, bottom, top, thickness } = panel;
+    const shape = new THREE.Shape()
+        .moveTo(0, bottom)
+        .lineTo(run, rise + bottom)
+        .lineTo(run, rise + top)
+        .lineTo(0, top)
+        .closePath();
+    const geometry = new THREE.ExtrudeGeometry(shape, { depth: thickness, bevelEnabled: false });
+    const position = geometry.getAttribute('position'), normal = geometry.getAttribute('normal'), uv = geometry.getAttribute('uv');
+    for (let i = 0; i < position.count; i++) {
+        const n = new THREE.Vector3(normal.getX(i), normal.getY(i), normal.getZ(i));
+        const axis = Math.abs(n.x) < 0.99 ? new THREE.Vector3(1, 0, 0) : new THREE.Vector3(0, 1, 0);
+        const u = axis.addScaledVector(n, -axis.dot(n)).normalize(), v = new THREE.Vector3().crossVectors(n, u).normalize();
+        const point = new THREE.Vector3(position.getX(i), position.getY(i), position.getZ(i));
+        uv.setXY(i, point.dot(u), point.dot(v));
+    }
+    geometry.translate(0, 0, -thickness / 2);
+    geometry.rotateY(-panel.yaw);
+    geometry.translate(panel.start[0], panel.start[1], panel.start[2]);
+    return geometry;
+}
+function buildRails(stair, paths, handrails, guard, insideWalk) {
+    const parts = [], infill = [];
+    const add = (geometry, glass = false) => {
+        if (geometry)
+            (glass ? infill : parts).push(geometry);
+    };
+    const style = stair.railingStyle ?? 'balusters', height = stair.railingHeight;
+    for (const path of guard ? paths : []) {
+        // The chassis guards (balusters, post-and-rail, cable, boards, glass, metal)
+        // share the path chassis, so the winder/continuous run reads as the same
+        // guard as the per-flight one. Cable then spans straight chords between the
+        // shared posts, not along the curve, so a sweep stays physically honest;
+        // boards run a stack of flat courses along the path; glass hangs one rigid
+        // flat pane per bay between the posts, point-fixed by clamps; metal stands
+        // slim posts on baseplates with slender plumb balusters between its rails.
+        const common = {
+            railHeight: height,
+            postSpacing: GUARD_POST_SPACING,
+            topPost: stair.railingTopPost !== false,
+            postThrough: stair.railingPostThrough === true,
+            reach: stair.railingTopReach ?? 0,
+        };
+        if (style === 'glass') {
+            const { frame, panels } = buildGlassGuard(path.points, { ...common, insideWalk });
+            for (const box of frame)
+                add(guardBoxGeometry(box));
+            for (const panel of panels)
+                add(glassPanelGeometry(panel), true);
+            continue;
+        }
+        const boxes = style === 'post-and-rail'
+            ? buildPostAndRailGuard(path.points, common)
+            : style === 'cable'
+                ? buildCableGuard(path.points, common)
+                : style === 'boards'
+                    ? buildBoardsGuard(path.points, common)
+                    : style === 'metal'
+                        ? buildMetalGuard(path.points, common)
+                        : buildBalusterGuard(path.points, { ...common, pickets: GUARD_PICKET_PITCH });
+        for (const box of boxes)
+            add(guardBoxGeometry(box));
+    }
+    const guardCount = parts.reduce((sum, geometry) => sum + (geometry.index?.count ?? geometry.getAttribute('position').count), 0);
+    const config = stair.handrail;
+    for (const path of config ? handrails : []) {
+        const points = path.points.map((point) => new THREE.Vector3(...point));
+        for (let i = 1; i < points.length; i++) {
+            const a = points[i - 1], b = points[i], direction = b.clone().sub(a);
+            if (direction.length() < 1e-8)
+                continue;
+            add(bar(a
+                .clone()
+                .add(new THREE.Vector3(0, config.height, 0)), b
+                .clone()
+                .add(new THREE.Vector3(0, config.height, 0)), config.diameter, config.diameter, true));
+        }
+    }
+    const merge = (geometries) => {
+        if (!geometries.length)
+            return null;
+        for (const geometry of geometries) {
+            if (!geometry.hasAttribute('uv2'))
+                geometry.setAttribute('uv2', geometry.getAttribute('uv').clone());
+        }
+        const result = mergeGeometries(geometries, false);
+        for (const geometry of geometries)
+            geometry.dispose();
+        return result;
+    };
+    const handrailCount = parts.reduce((sum, geometry) => sum + (geometry.index?.count ?? geometry.getAttribute('position').count), 0) - guardCount;
+    const metal = merge(parts);
+    if (metal)
+        metal.userData.pascalIfcParts = [
+            ...(guardCount ? [{ start: 0, count: guardCount, role: 'railing' }] : []),
+            ...(handrailCount ? [{ start: guardCount, count: handrailCount, role: 'handrail' }] : []),
+        ];
+    return [metal, merge(infill)];
+}
+export function ContinuousStairRailings({ stair, material, guard = true, renderData, }) {
+    const { stair: resolvedStair, nodes: effective } = renderData;
+    const sceneMaterials = useScene((state) => state.materials);
+    const shading = useViewer((state) => state.shading), textures = useViewer((state) => state.textures), colorPreset = useViewer((state) => state.colorPreset);
+    const paths = useMemo(() => (guard ? resolveStairRailPaths(resolvedStair, effective) : []), [resolvedStair, effective, guard]);
+    const handrails = useMemo(() => (resolvedStair.handrail ? resolveStairHandrailPaths(resolvedStair, effective) : []), [resolvedStair, effective]);
+    const insideWalk = useMemo(() => guard && resolvedStair.railingStyle === 'glass'
+        ? resolveStairWalkInside(resolvedStair, effective)
+        : undefined, [resolvedStair, effective, guard]);
+    const geometry = useMemo(() => buildRails(stair, paths, handrails, guard, insideWalk), [stair, paths, handrails, guard, insideWalk]);
+    useEffect(() => () => {
+        for (const part of geometry)
+            part?.dispose();
+    }, [geometry]);
+    const glass = useMemo(() => resolveStairSlotMaterial(stair, 'infill', 'library:preset-glass', getStairRailingMaterial(stair, shading, textures, colorPreset), sceneMaterials, shading, textures), [stair, shading, textures, colorPreset, sceneMaterials]);
+    return (_jsxs("group", { name: "stair-continuous-railing", userData: { pascalIfcRole: 'railing' }, children: [geometry[0] ? (_jsx("mesh", { dispose: null, name: "stair-railing", geometry: geometry[0], material: material, castShadow: true, receiveShadow: true, userData: {
+                    slotId: 'railing',
+                    pascalIfcRole: 'railing',
+                    pascalIfcParts: geometry[0].userData.pascalIfcParts,
+                } })) : null, geometry[1] ? (_jsx("mesh", { dispose: null, name: "stair-railing-infill", geometry: geometry[1], material: glass, castShadow: true, receiveShadow: true, userData: { slotId: 'infill', pascalIfcRole: 'railing' } })) : null] }));
+}

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAQpB,MAAM,kBAAkB,CAAA;AAuZzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAGpC;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAgH5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,cAAc,EAWpB,MAAM,kBAAkB,CAAA;AAiYzB,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAEpC;;;;GAIG;AACH,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAkH5D,CAAA"}