@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/stair/glass-guard.js

@@ -0,0 +1,167 @@
+/**
+ * One coherent glass-panel guard laid out along a rail path — a modern framed
+ * glass balustrade in metres: a slim square post at each end (and every bay
+ * ≤ 4 ft between), a flat cap over them, and one flat tempered-glass panel per
+ * bay, point-fixed to its flanking posts by small edge clamps. It shares the
+ * path sampling, corner finding and post stations in `guard-path.ts` with the
+ * baluster, cable and deck guards, so a straight flight, a chained L/U landing
+ * turn, a winder, a curved or spiral sweep and an integrated top landing all
+ * read as the same glass rail; only the sections and the glass infill differ.
+ *
+ * The panels are the physical intent of a glass rail, not a fiction: a tempered
+ * pane is rigid and flat, so on a curved or spiral sweep it cannot follow the
+ * arc. Each panel is therefore a flat parallelogram spanning the straight chord
+ * between two consecutive posts, with plumb vertical edges inset from each post
+ * by a reveal gap and a top/bottom clearance to the cap and the nosing line.
+ * Adjacent panels meet at a post with twice the reveal between them, never
+ * sharing or crossing a vertex. On a straight flight the collinear posts make
+ * those chords read as one plane.
+ *
+ * A flat chord between two posts on a curve lies inside the rail curve by its
+ * sagitta — on the outer rail that is up to tens of centimetres toward the
+ * treads, so a chord laid on the posts would push the pane well past the guard
+ * line into the walking volume. When the caller supplies `insideWalk` (which
+ * side of a point is the walkable surface), each bay measures how far its flat
+ * chord sags toward that surface and shifts the whole pane — and its clamps —
+ * radially outward by that sag plus the pane's half-thickness, so the pane's
+ * walking-facing face sits at or outside the rail line across the entire bay.
+ * The inner rail's chord sags into the void, away from the walkable surface, so
+ * it is left on the line; a straight run has no sag; neither is shifted. The
+ * frame is pure `GuardBox` data; the panels are the corner parametrics the
+ * renderer extrudes with metre UVs. No Three.js.
+ *
+ * `reach` runs the cap that far past the top vertex along the final slope to die
+ * into a post standing there; `topPost: false` then omits the top post.
+ * `postThrough` runs the posts past the cap with a small cap of their own.
+ */
+import { add, barBox, buildGuardChassis, horizontalLength, scale, sub, } from './guard-path.js';
+// Dressed glass balustrade, in metres.
+const POST = 0.0381; // a slim 1½ in square stainless 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 PANEL_T = 0.0127; // ½ in tempered glass
+const PANEL_REVEAL = 0.015; // the pane is held this far off each post, plan
+const PANEL_FOOT = 0.075; // the glass sits this far over the nosing line
+const PANEL_HEAD = 0.01; // and this far under the cap underside
+const CLAMP_W = 0.05; // a point clamp straddling the pane edge
+const CLAMP_T = 0.03;
+const CLAMP_LEN = 0.05;
+const CLAMP_LEVELS = [0.22, 0.78]; // clamp heights, as a fraction of pane height
+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 glass guard's single flat cap rail. Shared with the flight connector so a
+ * bridge between flights carries the same cap as the guards it joins. */
+export function glassGuardRails(railHeight) {
+    return [{ y: railHeight - CAP_T / 2, across: CAP_W, vertical: CAP_T }];
+}
+/** A clamp block straddling the pane edge at height `y`, pointing along the
+ * chord toward the post — the point fixing that ties the pane to the frame. */
+function clamp(edge, alongH, y, post) {
+    const paneAnchor = add(edge, [0, y, 0]);
+    const postAnchor = [post[0], paneAnchor[1], post[2]];
+    const bridge = barBox(postAnchor, paneAnchor, CLAMP_W, CLAMP_T);
+    if (bridge) {
+        return { ...bridge, size: [CLAMP_W, CLAMP_T, bridge.size[2] + CLAMP_LEN] };
+    }
+    return {
+        center: add(edge, [0, y, 0]),
+        size: [CLAMP_W, CLAMP_T, CLAMP_LEN],
+        direction: alongH,
+    };
+}
+/** The horizontal fractions of a bay sampled to find the chord's deepest sag;
+ * a convex arc sags most near the middle, so the quarter points bracket it. */
+const SAG_SAMPLES = [0.25, 0.5, 0.75];
+/**
+ * How far, and which way, to shift a bay's pane off the walking volume. The rail
+ * point at the bay's middle sits on the walkable boundary, so a small probe to
+ * either side of it along the chord normal names the outward (non-walkable)
+ * side; the pane is then pushed out by the deepest the flat chord sags past the
+ * rail curve toward the walkable side, plus a half-thickness so the face clears.
+ * Returns the zero vector when the side is unknown, the bay is straight, or the
+ * chord sags into the void (the inner rail) rather than toward the walking side.
+ */
+function paneOffset(a, b, alongH, sa, sb, pointAt, insideWalk) {
+    if (!insideWalk || sb <= sa)
+        return [0, 0, 0];
+    const normal = [-alongH[2], 0, alongH[0]];
+    const railMid = pointAt((sa + sb) / 2);
+    const probe = 0.01;
+    const plusIn = insideWalk(railMid[0] + normal[0] * probe, railMid[2] + normal[2] * probe);
+    const minusIn = insideWalk(railMid[0] - normal[0] * probe, railMid[2] - normal[2] * probe);
+    if (plusIn === minusIn)
+        return [0, 0, 0];
+    const out = plusIn ? scale(normal, -1) : normal;
+    let sag = 0;
+    for (const f of SAG_SAMPLES) {
+        const rail = pointAt(sa + (sb - sa) * f);
+        const chordX = a[0] + (b[0] - a[0]) * f;
+        const chordZ = a[2] + (b[2] - a[2]) * f;
+        const inward = (rail[0] - chordX) * out[0] + (rail[2] - chordZ) * out[2];
+        if (inward > sag)
+            sag = inward;
+    }
+    if (sag <= 1e-6)
+        return [0, 0, 0];
+    return scale(out, sag + PANEL_T / 2);
+}
+export function buildGlassGuard(points, options) {
+    const { railHeight } = options;
+    const chassis = buildGuardChassis(points, options, glassGuardRails(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 { frame: [], panels: [] };
+    const { path, boxes } = chassis;
+    if (path.kind === 'pivot')
+        return { frame: boxes, panels: [] };
+    const frame = boxes;
+    const { postPositions, postStations, pointAt } = path;
+    // One flat pane per bay, inset from both posts, with edge clamps. The pane top
+    // sits under the cap underside; the foot clears the nosing line.
+    const top = railHeight - CAP_T - PANEL_HEAD;
+    const bottom = PANEL_FOOT;
+    const panels = [];
+    if (top > bottom + 1e-6) {
+        for (let i = 1; i < postPositions.length; i++) {
+            const a = postPositions[i - 1];
+            const b = postPositions[i];
+            const span = horizontalLength(sub(b, a));
+            if (span < 1e-4)
+                continue;
+            const reveal = Math.min(PANEL_REVEAL, span * 0.2);
+            const run = span - 2 * reveal;
+            if (run < 1e-4)
+                continue;
+            const alongH = scale([b[0] - a[0], 0, b[2] - a[2]], 1 / span);
+            const yaw = Math.atan2(alongH[2], alongH[0]);
+            // Shift the pane off the walking volume by however far its flat chord sags
+            // past the rail curve toward that side, plus a half-thickness so the pane's
+            // face — not just its mid-plane — clears the rail line. A straight run and
+            // the inner (into-the-void) rail measure no inward sag and stay on the line.
+            const shift = paneOffset(a, b, alongH, postStations[i - 1], postStations[i], pointAt, options.insideWalk);
+            const foot = (s) => [
+                a[0] + alongH[0] * s + shift[0],
+                a[1] + ((b[1] - a[1]) * s) / span,
+                a[2] + alongH[2] * s + shift[2],
+            ];
+            const start = foot(reveal);
+            const rise = foot(span - reveal)[1] - start[1];
+            panels.push({ start, yaw, run, rise, bottom, top, thickness: PANEL_T });
+            for (const [edge, post] of [
+                [foot(reveal), a],
+                [foot(span - reveal), b],
+            ])
+                for (const level of CLAMP_LEVELS)
+                    frame.push(clamp(edge, alongH, bottom + level * (top - bottom), post));
+        }
+    }
+    return { frame, panels };
+}

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

@@ -0,0 +1,119 @@
+/**
+ * The style-agnostic chassis a stair guard is laid out on, as pure data (no
+ * Three.js, no React). A guard — baluster (`baluster-guard.ts`) or deck
+ * post-and-rail (`post-and-rail-guard.ts`) — differs only in the sections and
+ * y of its rails, its newel and its infill; where those members *go* is the
+ * same problem for both: sample the rail path by run so density tracks the run
+ * rather than the path's tessellation, extend it `reach` past the top vertex,
+ * stand newels by spacing, and close a plan corner with a fitting block. That
+ * shared geometry lives here so there is one path/corner/station convention to
+ * maintain and no duplicated arc sampling between the styles.
+ */
+export type Vec3 = [number, number, number];
+/** An oriented box in the guard's frame; see `GuardBox`'s consumers for UVs. */
+export type GuardBox = {
+    /** Box centre. */
+    center: Vec3;
+    /** Local box size: x across the run, y vertical, z along the run. */
+    size: Vec3;
+    /** Unit direction the box's z axis runs along (for sloped/plan-turned bars). */
+    direction: Vec3;
+    /** Render as a round member (a cylinder about `direction`); `size[0]` is its
+     * diameter. Cables and their terminal sleeves set this; everything else is a
+     * rectangular bar. */
+    round?: boolean;
+};
+export declare const UP: Vec3;
+export declare const add: (a: Vec3, b: Vec3) => Vec3;
+export declare const sub: (a: Vec3, b: Vec3) => Vec3;
+export declare const scale: (a: Vec3, s: number) => Vec3;
+export declare const lerp: (a: Vec3, b: Vec3, t: number) => Vec3;
+export declare const horizontalLength: (d: Vec3) => number;
+/** An oriented bar between two points; `width` is across the run, `depth` vertical. */
+export declare function barBox(a: Vec3, b: Vec3, width: number, depth: number): GuardBox | null;
+/** A plumb box standing from `base` up `height`, square section `width`. */
+export declare function postBox(base: Vec3, height: number, width: number): GuardBox;
+/** A guard rail: its centre `y` off the nosing line and its section (`across`
+ * the run, `vertical`), bottom-to-top. */
+export type GuardRail = {
+    y: number;
+    across: number;
+    vertical: number;
+};
+/** The rails of a guard following `railPoints`, with a cube fitting block
+ * closing every real plan corner — the shared joinery for both guard styles. */
+export declare function railBars(railPoints: Vec3[], isCorner: (i: number) => boolean, rails: GuardRail[]): GuardBox[];
+/** A plan direction change past this at an interior vertex gets a corner fitting
+ * block; collinear points and curve tessellation stay under it, so a dense path
+ * does not bulge a block at every vertex. */
+export declare const CORNER_MIN_TURN: number;
+export type GuardPathOptions = {
+    /** Metres between newels along the run; omit (or Infinity) for ends only. */
+    postSpacing?: number;
+    cornerPosts?: boolean;
+    topPost?: boolean;
+    /** Metres the rails run past the top vertex, along the final slope. */
+    reach?: number;
+    /** The requested infill pitch, clamped into [min, max] below. */
+    picketPitch?: number;
+    picketMinPitch?: number;
+    picketMaxPitch?: number;
+};
+export type GuardPath = 
+/** A path with no horizontal run — a zero-radius winder's inner pivot: the
+ * caller stands one plumb newel over the vertical rise `lo`→`hi`. */
+{
+    kind: 'pivot';
+    lo: Vec3;
+    hi: Vec3;
+} | {
+    kind: 'path';
+    /** Total horizontal run, including `reach`. */
+    run: number;
+    /** The vertices the rails follow, extended `reach` past the top. */
+    railPoints: Vec3[];
+    /** The point at horizontal station `s` along the run. */
+    pointAt: (s: number) => Vec3;
+    /** Whether interior vertex `i` of `railPoints` is a real plan corner. */
+    isCorner: (i: number) => boolean;
+    /** Newel foot positions, bottom-to-top along the run. */
+    postPositions: Vec3[];
+    /** Horizontal stations of `postPositions`, bottom-to-top. */
+    postStations: number[];
+    /** Infill (picket) foot positions, newel clashes left to the caller. */
+    picketStations: Vec3[];
+};
+/**
+ * Resolve the shared chassis for a guard laid along `points` (bottom first).
+ * Returns `null` for a degenerate path (fewer than two points, or a vertical
+ * run with no rise). The caller turns the stations into its own members.
+ */
+export declare function resolveGuardPath(points: Vec3[], options: GuardPathOptions): GuardPath | null;
+export declare const GUARD_POST_SPACING = 1.2192;
+export declare const GUARD_PICKET_PITCH = 0.127;
+export type GuardOptions = {
+    railHeight: number;
+    postSpacing?: number;
+    topPost?: boolean;
+    postThrough?: boolean;
+    reach?: number;
+};
+type PostProfile = {
+    width: number;
+    embed: number;
+    top: number;
+    throughTop: number;
+    capThickness: number;
+    capOverhang: number;
+    foot?: (x: number, y: number, z: number) => GuardBox;
+};
+/** Posts, caps and the vertical-pivot case have the same assembly in every style. */
+export declare function buildGuardChassis(points: Vec3[], options: GuardOptions, rails: GuardRail[], profile: PostProfile, sampling?: Pick<GuardPathOptions, 'cornerPosts' | 'picketPitch' | 'picketMinPitch' | 'picketMaxPitch'>): {
+    path: GuardPath;
+    boxes: GuardBox[];
+} | null;
+export declare function guardPickets(path: Extract<GuardPath, {
+    kind: 'path';
+}>, width: number, postWidth: number, bottom: number, top: number): GuardBox[];
+export {};
+//# sourceMappingURL=guard-path.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"guard-path.d.ts","sourceRoot":"","sources":["../../src/stair/guard-path.ts"],"names":[],"mappings":"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"}

package/dist/stair/guard-path.js

@@ -0,0 +1,208 @@
+/**
+ * The style-agnostic chassis a stair guard is laid out on, as pure data (no
+ * Three.js, no React). A guard — baluster (`baluster-guard.ts`) or deck
+ * post-and-rail (`post-and-rail-guard.ts`) — differs only in the sections and
+ * y of its rails, its newel and its infill; where those members *go* is the
+ * same problem for both: sample the rail path by run so density tracks the run
+ * rather than the path's tessellation, extend it `reach` past the top vertex,
+ * stand newels by spacing, and close a plan corner with a fitting block. That
+ * shared geometry lives here so there is one path/corner/station convention to
+ * maintain and no duplicated arc sampling between the styles.
+ */
+export const UP = [0, 1, 0];
+export const add = (a, b) => [a[0] + b[0], a[1] + b[1], a[2] + b[2]];
+export const sub = (a, b) => [a[0] - b[0], a[1] - b[1], a[2] - b[2]];
+export const scale = (a, s) => [a[0] * s, a[1] * s, a[2] * s];
+export const lerp = (a, b, t) => add(a, scale(sub(b, a), t));
+export const horizontalLength = (d) => Math.hypot(d[0], d[2]);
+/** An oriented bar between two points; `width` is across the run, `depth` vertical. */
+export function barBox(a, b, width, depth) {
+    const d = sub(b, a);
+    const length = Math.hypot(d[0], d[1], d[2]);
+    if (length < 1e-6)
+        return null;
+    return {
+        center: lerp(a, b, 0.5),
+        size: [width, depth, length],
+        direction: scale(d, 1 / length),
+    };
+}
+/** A plumb box standing from `base` up `height`, square section `width`. */
+export function postBox(base, height, width) {
+    return {
+        center: [base[0], base[1] + height / 2, base[2]],
+        size: [width, width, height],
+        direction: UP,
+    };
+}
+/** The rails of a guard following `railPoints`, with a cube fitting block
+ * closing every real plan corner — the shared joinery for both guard styles. */
+export function railBars(railPoints, isCorner, rails) {
+    const boxes = [];
+    for (const rail of rails) {
+        for (let i = 1; i < railPoints.length; i++) {
+            const bar = barBox(add(railPoints[i - 1], [0, rail.y, 0]), add(railPoints[i], [0, rail.y, 0]), rail.across, rail.vertical);
+            if (bar)
+                boxes.push(bar);
+        }
+        for (let i = 1; i < railPoints.length - 1; i++) {
+            if (!isCorner(i))
+                continue;
+            const block = Math.max(rail.across, rail.vertical);
+            boxes.push({
+                center: add(railPoints[i], [0, rail.y, 0]),
+                size: [block, block, block],
+                direction: UP,
+            });
+        }
+    }
+    return boxes;
+}
+/** A plan direction change past this at an interior vertex gets a corner fitting
+ * block; collinear points and curve tessellation stay under it, so a dense path
+ * does not bulge a block at every vertex. */
+export const CORNER_MIN_TURN = Math.PI / 8;
+/**
+ * Resolve the shared chassis for a guard laid along `points` (bottom first).
+ * Returns `null` for a degenerate path (fewer than two points, or a vertical
+ * run with no rise). The caller turns the stations into its own members.
+ */
+export function resolveGuardPath(points, options) {
+    if (points.length < 2)
+        return null;
+    const topPost = options.topPost !== false;
+    const reach = Math.max(options.reach ?? 0, 0);
+    const postSpacing = options.postSpacing && Number.isFinite(options.postSpacing) && options.postSpacing > 0
+        ? options.postSpacing
+        : Number.POSITIVE_INFINITY;
+    const cumulative = [0];
+    for (let i = 1; i < points.length; i++)
+        cumulative.push(cumulative[i - 1] + horizontalLength(sub(points[i], points[i - 1])));
+    const run = cumulative.at(-1);
+    if (run < 1e-4) {
+        const lo = points.reduce((low, p) => (p[1] < low[1] ? p : low));
+        const hi = points.reduce((high, p) => (p[1] > high[1] ? p : high));
+        if (hi[1] - lo[1] < 1e-4)
+            return null;
+        return { kind: 'pivot', lo, hi };
+    }
+    const pointAt = (s) => {
+        const clamped = Math.min(Math.max(s, 0), run);
+        for (let i = 1; i < points.length; i++) {
+            if (clamped <= cumulative[i] || i === points.length - 1) {
+                const span = cumulative[i] - cumulative[i - 1];
+                const t = span > 1e-9 ? (clamped - cumulative[i - 1]) / span : 0;
+                return lerp(points[i - 1], points[i], t);
+            }
+        }
+        return points[0];
+    };
+    // The top vertex, extended `reach` along the final slope.
+    const lastEdge = sub(points.at(-1), points.at(-2));
+    const lastLen = Math.hypot(lastEdge[0], lastEdge[1], lastEdge[2]);
+    const railEnd = reach > 0 && lastLen > 1e-6
+        ? add(points.at(-1), scale(lastEdge, reach / lastLen))
+        : points.at(-1);
+    const railPoints = reach > 0 ? [...points, railEnd] : [...points];
+    // A fitting block belongs only at a real corner. A tessellated curve or a
+    // spiral turns a similar amount at every vertex, so a sharp turn is a corner
+    // only when it stands out from its neighbours; collinear points never turn.
+    const horizontalDir = (a, b) => {
+        const dx = b[0] - a[0], dz = b[2] - a[2];
+        const length = Math.hypot(dx, dz);
+        return length < 1e-6 ? null : [dx / length, dz / length];
+    };
+    const turnAt = (i) => {
+        if (i < 1 || i > railPoints.length - 2)
+            return null;
+        const incoming = horizontalDir(railPoints[i - 1], railPoints[i]);
+        const outgoing = horizontalDir(railPoints[i], railPoints[i + 1]);
+        if (!incoming || !outgoing)
+            return null;
+        const dot = Math.min(Math.max(incoming[0] * outgoing[0] + incoming[1] * outgoing[1], -1), 1);
+        return Math.acos(dot);
+    };
+    const isCorner = (i) => {
+        const turn = turnAt(i);
+        if (turn === null || turn <= CORNER_MIN_TURN)
+            return false;
+        // Cable runs need anchors at consecutive sharp turns as well as isolated corners.
+        if (options.cornerPosts && turn >= Math.PI / 6)
+            return true;
+        const neighbour = Math.max(turnAt(i - 1) ?? 0, turnAt(i + 1) ?? 0);
+        return neighbour < turn * 0.5;
+    };
+    const postStations = new Set([0]);
+    if (topPost)
+        postStations.add(run);
+    if (Number.isFinite(postSpacing)) {
+        const bays = Math.max(1, Math.ceil(run / postSpacing));
+        for (let i = 1; i < bays; i++)
+            postStations.add((run * i) / bays);
+    }
+    if (options.cornerPosts) {
+        for (let i = 1; i < points.length - 1; i++) {
+            if (isCorner(i))
+                postStations.add(cumulative[i]);
+        }
+    }
+    const sortedStations = [...postStations].sort((a, b) => a - b);
+    const postPositions = sortedStations.map(pointAt);
+    const picketStations = [];
+    if (options.picketPitch !== undefined) {
+        const pitch = Math.min(Math.max(options.picketPitch, options.picketMinPitch ?? options.picketPitch), options.picketMaxPitch ?? options.picketPitch);
+        const bays = Math.max(2, Math.ceil(run / pitch));
+        for (let i = 1; i < bays; i++)
+            picketStations.push(pointAt((run * i) / bays));
+    }
+    return {
+        kind: 'path',
+        run,
+        railPoints,
+        pointAt,
+        isCorner,
+        postPositions,
+        postStations: sortedStations,
+        picketStations,
+    };
+}
+export const GUARD_POST_SPACING = 1.2192;
+export const GUARD_PICKET_PITCH = 0.127;
+/** Posts, caps and the vertical-pivot case have the same assembly in every style. */
+export function buildGuardChassis(points, options, rails, profile, sampling = {}) {
+    const path = resolveGuardPath(points, { ...options, ...sampling });
+    if (!path)
+        return null;
+    const rise = options.railHeight + (options.postThrough ? profile.throughTop : profile.top);
+    const boxes = path.kind === 'pivot' ? [] : railBars(path.railPoints, path.isCorner, rails);
+    const posts = path.kind === 'pivot' ? [path.lo] : path.postPositions;
+    for (const p of posts) {
+        const height = rise + profile.embed + (path.kind === 'pivot' ? path.hi[1] - path.lo[1] : 0);
+        const base = add(p, [0, -profile.embed, 0]);
+        boxes.push(postBox(base, height, profile.width));
+        if (profile.foot)
+            boxes.push(profile.foot(p[0], p[1], p[2]));
+        if (options.postThrough)
+            boxes.push({
+                center: [p[0], base[1] + height + profile.capThickness / 2, p[2]],
+                size: [
+                    profile.width + profile.capOverhang,
+                    profile.capThickness,
+                    profile.width + profile.capOverhang,
+                ],
+                direction: UP,
+            });
+    }
+    return { path, boxes };
+}
+export function guardPickets(path, width, postWidth, bottom, top) {
+    const boxes = [];
+    for (const p of path.picketStations) {
+        if (!path.postPositions.every((post) => Math.hypot(post[0] - p[0], post[2] - p[2]) > postWidth / 2 + width / 2))
+            continue;
+        const picket = barBox([p[0], p[1] + bottom, p[2]], [p[0], p[1] + top, p[2]], width, width);
+        if (picket)
+            boxes.push(picket);
+    }
+    return boxes;
+}

package/dist/stair/index.d.ts

@@ -1,2 +1,2 @@
-export { stairDefinition } from './definition';
+export { stairDefinition } from './definition.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/stair/index.js

@@ -1 +1 @@
-export { stairDefinition } from './definition';
+export { stairDefinition } from './definition.js';

package/dist/stair/materials.d.ts

@@ -0,0 +1,11 @@
+import type { StairNode, StairSegmentNode } from '@pascal-app/core';
+import { type StairSlotId } from '@pascal-app/core';
+import { getStraightStairSegmentBodyMaterials, resolveMaterialRef, type StairBodyMaterials } from '@pascal-app/viewer';
+import type * as THREE from 'three';
+type SceneMaterials = Parameters<typeof resolveMaterialRef>[1];
+type ViewerShading = Parameters<typeof resolveMaterialRef>[2];
+export declare function resolveStairSlotMaterial(node: StairNode, slotId: StairSlotId, defaultRef: string, baseMaterial: THREE.Material, sceneMaterials: SceneMaterials, shading: ViewerShading, textures: boolean): THREE.Material;
+export declare function resolveStairSegmentMaterials(segment: StairSegmentNode, parent: StairNode | undefined, parentMaterials: StairBodyMaterials | undefined, sceneMaterials: SceneMaterials, shading: ViewerShading, textures: boolean, colorPreset: Parameters<typeof getStraightStairSegmentBodyMaterials>[4]): StairBodyMaterials;
+export declare function resolveStairBodySlotMaterials(stair: StairNode, base: StairBodyMaterials, sceneMaterials: SceneMaterials, shading: ViewerShading, textures: boolean): StairBodyMaterials;
+export {};
+//# sourceMappingURL=materials.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"materials.d.ts","sourceRoot":"","sources":["../../src/stair/materials.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AACnE,OAAO,EAGL,KAAK,WAAW,EACjB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EACL,oCAAoC,EACpC,kBAAkB,EAElB,KAAK,kBAAkB,EACxB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,KAAK,KAAK,KAAK,MAAM,OAAO,CAAA;AAEnC,KAAK,cAAc,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAA;AAC9D,KAAK,aAAa,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAC,CAAC,CAAC,CAAA;AAkB7D,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,SAAS,EACf,MAAM,EAAE,WAAW,EACnB,UAAU,EAAE,MAAM,EAClB,YAAY,EAAE,KAAK,CAAC,QAAQ,EAC5B,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,OAAO,GAChB,KAAK,CAAC,QAAQ,CAShB;AAED,wBAAgB,4BAA4B,CAC1C,OAAO,EAAE,gBAAgB,EACzB,MAAM,EAAE,SAAS,GAAG,SAAS,EAC7B,eAAe,EAAE,kBAAkB,GAAG,SAAS,EAC/C,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,OAAO,EACjB,WAAW,EAAE,UAAU,CAAC,OAAO,oCAAoC,CAAC,CAAC,CAAC,CAAC,GACtE,kBAAkB,CAgBpB;AAED,wBAAgB,6BAA6B,CAC3C,KAAK,EAAE,SAAS,EAChB,IAAI,EAAE,kBAAkB,EACxB,cAAc,EAAE,cAAc,EAC9B,OAAO,EAAE,aAAa,EACtB,QAAQ,EAAE,OAAO,GAChB,kBAAkB,CAqBpB"}

package/dist/stair/materials.js

@@ -0,0 +1,51 @@
+import { STAIR_BODY_SLOT_DEFAULT, STAIR_TREADS_SLOT_DEFAULT, } from '@pascal-app/core';
+import { getStraightStairSegmentBodyMaterials, resolveMaterialRef, resolveSlotDefaultMaterial, } from '@pascal-app/viewer';
+function hasMaterialSpec(material, materialPreset) {
+    return material !== undefined || typeof materialPreset === 'string';
+}
+function hasLegacyStairSlotMaterial(node, slotId) {
+    if (slotId === 'infill')
+        return false;
+    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;
+}
+export 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);
+}
+export function resolveStairSegmentMaterials(segment, parent, parentMaterials, sceneMaterials, shading, textures, colorPreset) {
+    const hasOverride = hasMaterialSpec(segment.material, segment.materialPreset);
+    const base = !hasOverride && !parentMaterials && textures
+        ? [
+            resolveSlotDefaultMaterial(STAIR_TREADS_SLOT_DEFAULT, shading),
+            resolveSlotDefaultMaterial(STAIR_BODY_SLOT_DEFAULT, shading),
+        ]
+        : hasOverride || !parentMaterials
+            ? getStraightStairSegmentBodyMaterials(segment, parent, shading, textures, colorPreset)
+            : parentMaterials;
+    if (!textures)
+        return base;
+    return [
+        resolveMaterialRef(segment.slots?.treads, sceneMaterials, shading) ?? base[0],
+        resolveMaterialRef(segment.slots?.body, sceneMaterials, shading) ?? base[1],
+    ];
+}
+export function resolveStairBodySlotMaterials(stair, base, sceneMaterials, shading, textures) {
+    return [
+        resolveStairSlotMaterial(stair, 'treads', STAIR_TREADS_SLOT_DEFAULT, base[0], sceneMaterials, shading, textures),
+        resolveStairSlotMaterial(stair, 'body', STAIR_BODY_SLOT_DEFAULT, base[1], sceneMaterials, shading, textures),
+    ];
+}

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

@@ -0,0 +1,38 @@
+/**
+ * One coherent metal guard laid out along a rail path, as oriented boxes — a
+ * fabricated steel guardrail in metres: a slim square post at each end (and
+ * every bay ≤ 4 ft between), welded to a flat baseplate that mounts it to the
+ * tread rather than embedding below it, a flat top rail and a bottom rail that
+ * follow the path with a fitting block closing every interior corner, and
+ * slender square balusters spanning the two rails. It shares the path sampling,
+ * corner finding and newel/picket stations in `guard-path.ts` with the baluster,
+ * deck post-and-rail, cable, boards and glass 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, the surface-mounted
+ * feet and the slim infill differ. Pure data — no Three.js, no React.
+ *
+ * Unlike the wood guards, a steel post is not sunk into the structure: it stands
+ * on the nosing line on a baseplate, the mounting foot that grounds it. The
+ * infill is plumb slender bars spanning rail to rail, so nothing crosses the
+ * walking volume on a slope and every member meets another.
+ *
+ * `reach` runs the rails that far past the top vertex along the final slope to
+ * die into a post standing there; `topPost: false` then omits the top post.
+ * `postThrough` runs the posts past the top rail with a small cap of their own.
+ */
+import { type GuardBox, type GuardRail, type Vec3 } from './guard-path.js';
+export type MetalGuardOptions = {
+    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 metal guard's two rails, bottom-to-top: a slim bottom rail held off the
+ * nosing line and a flat top rail with its top at the guard height. Shared with
+ * the flight connector so a bridge carries the same rails as the guards it joins. */
+export declare function metalGuardRails(railHeight: number): GuardRail[];
+export declare function buildMetalGuard(points: Vec3[], options: MetalGuardOptions): GuardBox[];
+//# sourceMappingURL=metal-guard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"metal-guard.d.ts","sourceRoot":"","sources":["../../src/stair/metal-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;GAqBG;AAEH,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,SAAS,EAEd,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;AAmBD;;qFAEqF;AACrF,wBAAgB,eAAe,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,CAK/D;AAWD,wBAAgB,eAAe,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,iBAAiB,GAAG,QAAQ,EAAE,CA6BtF"}