@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/slab/surface-split.js

@@ -0,0 +1,389 @@
+import { containsPoint, difference, floorStepRole, intersection, plateSideRuns, union, } from '@pascal-app/core';
+import { BufferGeometry, Float32BufferAttribute, ShapeUtils, Vector2 } from 'three';
+const TOP_NORMAL_THRESHOLD = 0.5;
+function readTriangles(geometry) {
+    const position = geometry.getAttribute('position');
+    const uv = geometry.getAttribute('uv');
+    const index = geometry.getIndex();
+    // A collapsed slab builds an empty geometry with no position attribute.
+    const count = index ? index.count / 3 : (position?.count ?? 0) / 3;
+    const triangles = [];
+    for (let t = 0; t < count; t += 1) {
+        const corners = [0, 1, 2].map((offset) => {
+            const i = index ? index.getX(t * 3 + offset) : t * 3 + offset;
+            return {
+                x: position.getX(i),
+                y: position.getY(i),
+                z: position.getZ(i),
+                u: uv ? uv.getX(i) : 0,
+                v: uv ? uv.getY(i) : 0,
+            };
+        });
+        triangles.push(corners);
+    }
+    return triangles;
+}
+function faceNormalY(triangle) {
+    const [a, b, c] = triangle;
+    const abx = b.x - a.x;
+    const aby = b.y - a.y;
+    const abz = b.z - a.z;
+    const acx = c.x - a.x;
+    const acy = c.y - a.y;
+    const acz = c.z - a.z;
+    const nx = aby * acz - abz * acy;
+    const ny = abz * acx - abx * acz;
+    const nz = abx * acy - aby * acx;
+    const length = Math.hypot(nx, ny, nz);
+    return length > 1e-12 ? ny / length : 0;
+}
+function buildGeometry(triangles, withUv) {
+    const positions = [];
+    const uvs = [];
+    for (const triangle of triangles) {
+        for (const vertex of triangle) {
+            positions.push(vertex.x, vertex.y, vertex.z);
+            if (withUv)
+                uvs.push(vertex.u, vertex.v);
+        }
+    }
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
+    if (uvs.length > 0) {
+        geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
+        geometry.setAttribute('uv2', new Float32BufferAttribute(uvs.slice(), 2));
+    }
+    geometry.computeVertexNormals();
+    return geometry;
+}
+/**
+ * Rebuild a point of the source triangle from its XZ position. Height and UV
+ * come from the triangle's own plane, so a clipped piece sits exactly where the
+ * original did and keeps the plate's UV mapping.
+ */
+function sampleTriangle(triangle, x, z) {
+    const [a, b, c] = triangle;
+    const v0x = b.x - a.x;
+    const v0z = b.z - a.z;
+    const v1x = c.x - a.x;
+    const v1z = c.z - a.z;
+    const denominator = v0x * v1z - v1x * v0z;
+    if (Math.abs(denominator) < 1e-18)
+        return { x, y: a.y, z, u: a.u, v: a.v };
+    const px = x - a.x;
+    const pz = z - a.z;
+    const beta = (px * v1z - v1x * pz) / denominator;
+    const gamma = (v0x * pz - px * v0z) / denominator;
+    const alpha = 1 - beta - gamma;
+    return {
+        x,
+        z,
+        y: alpha * a.y + beta * b.y + gamma * c.y,
+        u: alpha * a.u + beta * b.u + gamma * c.u,
+        v: alpha * a.v + beta * b.v + gamma * c.v,
+    };
+}
+function triangleRing(triangle) {
+    return triangle.map((vertex) => [vertex.x, vertex.z]);
+}
+function bounds(ring) {
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const [x, z] of ring) {
+        minX = Math.min(minX, x);
+        maxX = Math.max(maxX, x);
+        minZ = Math.min(minZ, z);
+        maxZ = Math.max(maxZ, z);
+    }
+    return { minX, maxX, minZ, maxZ };
+}
+function polygonBounds(polygons) {
+    return bounds(polygons.flatMap((polygon) => polygon.outer));
+}
+function disjoint(a, b) {
+    return a.minX > b.maxX || a.maxX < b.minX || a.minZ > b.maxZ || a.maxZ < b.minZ;
+}
+/** Triangles of `triangle` that fall inside `polygons`, re-triangulated in 2D. */
+function clipTriangleToPolygons(triangle, polygons) {
+    const ring = triangleRing(triangle);
+    const pieces = intersection(union([ring]), polygons);
+    const result = [];
+    for (const piece of pieces) {
+        const contour = piece.outer.map(([x, z]) => new Vector2(x, z));
+        const holes = piece.holes
+            .filter((hole) => hole.length >= 3)
+            .map((hole) => hole.map(([x, z]) => new Vector2(x, z)));
+        const points = [...contour, ...holes.flat()];
+        for (const face of ShapeUtils.triangulateShape(contour, holes)) {
+            const corners = face.map((cornerIndex) => {
+                const point = points[cornerIndex];
+                return sampleTriangle(triangle, point.x, point.y);
+            });
+            // triangulateShape returns the input winding; the source triangle's
+            // orientation is what the renderer culls against, so restore it.
+            result.push(faceNormalY(corners) * faceNormalY(triangle) < 0 ? reverse(corners) : corners);
+        }
+    }
+    return result;
+}
+function reverse(triangle) {
+    return [triangle[0], triangle[2], triangle[1]];
+}
+/**
+ * Clip a triangle to `s >= limit` (or `s <= limit`), where `s` is the distance
+ * along `(dirX, dirZ)` from `origin`. Vertical faces project onto a line, so
+ * this is how one side quad is cut at an exposure boundary.
+ */
+function clipTriangleBySlab(triangle, origin, dirX, dirZ, from, to) {
+    let polygon = [...triangle];
+    for (const [limit, keepGreater] of [
+        [from, true],
+        [to, false],
+    ]) {
+        const next = [];
+        for (const [index, current] of polygon.entries()) {
+            const previous = polygon[(index + polygon.length - 1) % polygon.length];
+            const sPrevious = (previous.x - origin[0]) * dirX + (previous.z - origin[1]) * dirZ - limit;
+            const sCurrent = (current.x - origin[0]) * dirX + (current.z - origin[1]) * dirZ - limit;
+            const insidePrevious = keepGreater ? sPrevious >= 0 : sPrevious <= 0;
+            const insideCurrent = keepGreater ? sCurrent >= 0 : sCurrent <= 0;
+            if (insidePrevious !== insideCurrent) {
+                const t = sPrevious / (sPrevious - sCurrent);
+                next.push({
+                    x: previous.x + (current.x - previous.x) * t,
+                    y: previous.y + (current.y - previous.y) * t,
+                    z: previous.z + (current.z - previous.z) * t,
+                    u: previous.u + (current.u - previous.u) * t,
+                    v: previous.v + (current.v - previous.v) * t,
+                });
+            }
+            if (insideCurrent)
+                next.push(current);
+        }
+        polygon = next;
+        if (polygon.length < 3)
+            return [];
+    }
+    const fan = [];
+    for (let index = 1; index < polygon.length - 1; index += 1) {
+        fan.push([polygon[0], polygon[index], polygon[index + 1]]);
+    }
+    return fan;
+}
+/** The 2D segment a vertical triangle projects onto, longest extent first. */
+function verticalSpan(triangle) {
+    let best = null;
+    for (let index = 0; index < 3; index += 1) {
+        const a = triangle[index];
+        const b = triangle[(index + 1) % 3];
+        const length = Math.hypot(b.x - a.x, b.z - a.z);
+        if (!best || length > best.length)
+            best = { start: [a.x, a.z], end: [b.x, b.z], length };
+    }
+    return best && best.length > 1e-9 ? best : null;
+}
+function push(buckets, role, triangles) {
+    if (role === 'hidden' || !triangles.length)
+        return;
+    const bucket = buckets.get(role);
+    if (bucket)
+        bucket.push(...triangles);
+    else
+        buckets.set(role, [...triangles]);
+}
+/**
+ * Split a slab buffer by face orientation only — the pre-plate behaviour, kept
+ * verbatim for manual slabs so their two meshes and their paint slots never
+ * change.
+ */
+export function splitSlabFacesByFacing(geometry) {
+    const top = [];
+    const side = [];
+    const withUv = geometry.getAttribute('uv') !== undefined;
+    for (const triangle of readTriangles(geometry)) {
+        ;
+        (faceNormalY(triangle) > TOP_NORMAL_THRESHOLD ? top : side).push(triangle);
+    }
+    return { top: buildGeometry(top, withUv), side: buildGeometry(side, withUv) };
+}
+/**
+ * Split a plate buffer into one bucket per rendered role: a top bucket per
+ * partition cell, `edge` / `riser` per exposure run, and `underside`. Buckets
+ * come back in a stable order (cells in partition order, then the sides) so the
+ * mesh order of a plate is the same on every rebuild.
+ */
+export function splitPlateFaces(geometry, partition, slab) {
+    const buckets = new Map();
+    const withUv = geometry.getAttribute('uv') !== undefined;
+    // Cells in partition order, then the sides in a fixed order: a plate's mesh
+    // list is then the same on every rebuild, which is what the node batch's
+    // per-mesh allocation keys are indexed by.
+    // A room-owned riser draws one mesh per doorway, so each paints on its own.
+    const sideRole = (side) => side.zoneId && side.role !== 'hidden'
+        ? side.role === 'riser'
+            ? floorStepRole(side.zoneId, side.stepKey)
+            : `edge:${side.zoneId}`
+        : side.role;
+    const order = [
+        ...new Set([
+            ...partition.cells.map((cell) => cell.role),
+            'edge',
+            'riser',
+            ...partition.sides.map(sideRole),
+            'underside',
+        ]),
+    ];
+    const cellBounds = partition.cells.map((cell) => polygonBounds(cell.polygons));
+    const soffit = slab.elevation - slab.thickness;
+    const downturns = partition.sides.flatMap((side) => {
+        if (side.role === 'hidden' || side.dropTo === undefined || side.dropTo >= soffit - 0.001)
+            return [];
+        const [a, b] = [side.start, side.end];
+        const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        const dx = (-(b[1] - a[1]) / length) * slab.thickness, dz = ((b[0] - a[0]) / length) * slab.thickness;
+        return [
+            {
+                bottom: side.dropTo,
+                polygon: [a, b, [b[0] + dx, b[1] + dz], [a[0] + dx, a[1] + dz]],
+            },
+        ];
+    });
+    const downturnCover = union(downturns.map((d) => d.polygon));
+    for (const triangle of readTriangles(geometry)) {
+        const normalY = faceNormalY(triangle);
+        if (normalY > TOP_NORMAL_THRESHOLD) {
+            if (partition.plainTop) {
+                push(buckets, partition.cells[0]?.role ?? 'surface', [triangle]);
+                continue;
+            }
+            // Area a manual slab already draws belongs to no cell, so it is simply
+            // never emitted — the plate keeps its body and stops z-fighting the top.
+            const triangleBounds = bounds(triangleRing(triangle));
+            for (const [index, cell] of partition.cells.entries()) {
+                if (disjoint(triangleBounds, cellBounds[index]))
+                    continue;
+                push(buckets, cell.role, clipTriangleToPolygons(triangle, cell.polygons));
+            }
+            continue;
+        }
+        if (normalY < -TOP_NORMAL_THRESHOLD) {
+            push(buckets, 'underside', downturnCover.length
+                ? clipTriangleToPolygons(triangle, difference(triangleRing(triangle), downturnCover))
+                : [triangle]);
+        }
+    }
+    const rings = [slab.polygon, ...slab.holes];
+    for (const side of partition.sides) {
+        if (side.role === 'hidden')
+            continue;
+        const bottom = side.bottom ?? side.dropTo ?? slab.elevation - slab.thickness;
+        const top = side.top ?? slab.elevation;
+        const [ax, az] = side.start, [bx, bz] = side.end;
+        const [u0, u1] = sideEdgeUvs(rings, side.start, side.end);
+        const a = { x: ax, y: bottom, z: az, u: u0, v: bottom };
+        const b = { x: bx, y: bottom, z: bz, u: u1, v: bottom };
+        const c = { ...b, y: top, v: top }, d = { ...a, y: top, v: top };
+        push(buckets, sideRole(side), [
+            [a, c, b],
+            [a, d, c],
+        ]);
+    }
+    const levels = [...new Set([...downturns.map((d) => d.bottom), soffit])].sort((a, b) => a - b);
+    let previous = [];
+    for (const [i, low] of levels.slice(0, -1).entries()) {
+        const high = levels[i + 1];
+        const section = union(downturns.filter((d) => d.bottom <= low + 1e-7).map((d) => d.polygon));
+        for (const polygon of difference(section, previous)) {
+            const contour = polygon.outer.map(([x, z]) => new Vector2(x, z));
+            const holes = polygon.holes.map((ring) => ring.map(([x, z]) => new Vector2(x, z)));
+            const points = [...contour, ...holes.flat()];
+            for (const face of ShapeUtils.triangulateShape(contour, holes)) {
+                const triangle = face.map((index) => ({
+                    x: points[index].x,
+                    y: low,
+                    z: points[index].y,
+                    u: points[index].x,
+                    v: points[index].y,
+                }));
+                push(buckets, 'underside', [faceNormalY(triangle) > 0 ? reverse(triangle) : triangle]);
+            }
+        }
+        for (const polygon of section)
+            for (const ring of [polygon.outer, ...polygon.holes])
+                for (const [j, a] of ring.entries()) {
+                    const b = ring[(j + 1) % ring.length];
+                    const dx = b[0] - a[0], dz = b[1] - a[1], length = Math.hypot(dx, dz);
+                    const midpoint = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+                    const exterior = partition.sides.some((side) => {
+                        const sx = side.end[0] - side.start[0], sz = side.end[1] - side.start[1];
+                        const t = ((midpoint[0] - side.start[0]) * sx + (midpoint[1] - side.start[1]) * sz) /
+                            (sx * sx + sz * sz);
+                        return (t >= -1e-6 &&
+                            t <= 1 + 1e-6 &&
+                            Math.abs((midpoint[0] - side.start[0]) * sz - (midpoint[1] - side.start[1]) * sx) <
+                                1e-6);
+                    });
+                    if (exterior)
+                        continue;
+                    const normalInside = containsPoint(section, [
+                        midpoint[0] + (dz / length) * 0.0001,
+                        midpoint[1] - (dx / length) * 0.0001,
+                    ]);
+                    const aa = { x: a[0], y: low, z: a[1], u: 0, v: low }, bb = { x: b[0], y: low, z: b[1], u: length, v: low };
+                    const cc = { ...bb, y: high, v: high }, dd = { ...aa, y: high, v: high };
+                    const faces = [
+                        [aa, cc, bb],
+                        [aa, dd, cc],
+                    ];
+                    push(buckets, 'underside', normalInside ? faces.map(reverse) : faces);
+                }
+        previous = section;
+    }
+    return order
+        .filter((role) => (buckets.get(role)?.length ?? 0) > 0)
+        .map((role) => ({ role, geometry: buildGeometry(buckets.get(role), withUv) }));
+}
+function sideEdgeUvs(rings, start, end) {
+    for (const ring of rings) {
+        for (const [i, a] of ring.entries()) {
+            const b = ring[(i + 1) % ring.length];
+            const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+            if (length < 1e-9)
+                continue;
+            const dx = (b[0] - a[0]) / length;
+            const dz = (b[1] - a[1]) / length;
+            const along = (p) => (p[0] - a[0]) * dx + (p[1] - a[1]) * dz;
+            const onEdge = (p) => Math.abs((p[0] - a[0]) * dz - (p[1] - a[1]) * dx) < 1e-6 &&
+                along(p) >= -1e-6 &&
+                along(p) <= length + 1e-6;
+            if (onEdge(start) && onEdge(end))
+                return [along(start), along(end)];
+        }
+    }
+    const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+    const dx = (end[0] - start[0]) / length;
+    const dz = (end[1] - start[1]) / length;
+    return [start[0] * dx + start[1] * dz, end[0] * dx + end[1] * dz];
+}
+export function clipPlateTerrainFill(geometry, partition) {
+    const triangles = [];
+    for (const triangle of readTriangles(geometry)) {
+        // Keep the terrain-following bottom cap, including steep slopes.
+        if (Math.abs(faceNormalY(triangle)) > 1e-6) {
+            triangles.push(triangle);
+            continue;
+        }
+        const span = verticalSpan(triangle);
+        if (!span)
+            continue;
+        const runs = plateSideRuns(partition, span.start, span.end);
+        for (const run of runs) {
+            if (run.dropTo !== undefined)
+                continue;
+            triangles.push(...clipTriangleBySlab(triangle, span.start, (span.end[0] - span.start[0]) / span.length, (span.end[1] - span.start[1]) / span.length, run.t0 * span.length, run.t1 * span.length));
+        }
+    }
+    return buildGeometry(triangles, geometry.getAttribute('uv') !== undefined);
+}

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/slab/tool.tsx"],"names":[],"mappings":"AA4EA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EA2T5B,CAAA;AAED,eAAe,QAAQ,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/slab/tool.tsx"],"names":[],"mappings":"AA6EA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EA2T5B,CAAA;AAED,eAAe,QAAQ,CAAA"}

package/dist/slab/tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { DEFAULT_ANGLE_STEP, emitter, resolveSlabPlacementElevation, snapPointAlongAngleRay, snapPointToGrid, useScene, } from '@pascal-app/core';
-import { CursorSphere, clearPlacementSurface, clearSlabSnapFeedback, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolveLevelConstructionPlane, resolvePointerSupportSurface, resolveSlabPlanPointSnap, triggerSFX, useEditor, useFloorplanDraftPreview, } from '@pascal-app/editor';
+import { CursorSphere, clearPlacementSurface, clearSlabSnapFeedback, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolveLevelConstructionPlane, resolvePointerSupportSurface, resolveSlabPlanPointSnap, triggerSFX, useEditor, useFloorplanDraftPreview, visibleScene, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useRef, useState } from 'react';
@@ -142,7 +142,7 @@ export const SlabTool = () => {
                 firstPoint &&
                 Math.abs(clickPoint[0] - firstPoint[0]) < 0.25 &&
                 Math.abs(clickPoint[1] - firstPoint[1]) < 0.25) {
-                if (shouldRegistryCommitSlab(useEditor.getState().viewMode, 'grid')) {
+                if (shouldRegistryCommitSlab(visibleScene(useEditor.getState()), 'grid')) {
                     const slabId = commitSlabDrawing(currentLevelId, points, constructionPlaneRef.current?.elevation ?? null);
                     setSelection({ selectedIds: [slabId] });
                 }
@@ -168,7 +168,7 @@ export const SlabTool = () => {
         const finishDrawing = (trigger) => {
             if (points.length < 3)
                 return;
-            if (shouldRegistryCommitSlab(useEditor.getState().viewMode, trigger)) {
+            if (shouldRegistryCommitSlab(visibleScene(useEditor.getState()), trigger)) {
                 const slabId = commitSlabDrawing(currentLevelId, points, constructionPlaneRef.current?.elevation ?? null);
                 setSelection({ selectedIds: [slabId] });
             }

package/dist/solar-panel/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/solar-panel/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAgNzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,OAAO,cAAc,CAyDtE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/solar-panel/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAgNzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,OAAO,cAAc,CA0DtE,CAAA"}

package/dist/solar-panel/definition.js

@@ -235,6 +235,7 @@ export const solarPanelDefinition = {
     parametrics: solarPanelParametrics,
     handles: solarPanelHandles,
     floorplan: buildSolarPanelFloorplan,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/spawn/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAKpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA0CpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAuE5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/spawn/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAKpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA0CpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAwE5D,CAAA"}

package/dist/spawn/definition.js

@@ -73,6 +73,7 @@ export const spawnDefinition = {
     },
     parametrics: spawnParametrics,
     handles: [spawnRotateHandle(), spawnMoveHandle()],
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),

package/dist/stair/baluster-geometry.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Turning the pure `GuardBox` data from `baluster-guard.ts` into Three.js
+ * geometry with metre-scale UVs (E-009): 1 UV unit = 1 m on every face, so a
+ * finish tiles the same on a rail, a newel and a picket. Both the per-flight
+ * guard (`renderer.tsx`) and the continuous guard (`continuous-railings.tsx`)
+ * build their boxes through here, so there is one UV convention to maintain.
+ */
+import * as THREE from 'three';
+import type { GuardBox } from './guard-path';
+/** A box whose UVs run in metres (1 unit = 1 m) on each face. */
+export declare function metricBox(length: number, height: number, depth: number): THREE.BoxGeometry;
+/** A round guard member (a cable or its sleeve) as a metre-UV cylinder laid
+ * along its direction: `size[0]` is the diameter, `size[2]` the length. UVs run
+ * in metres — the circumference across, the length along — so a finish tiles
+ * the same as on a rectangular bar. */
+export declare function metricCylinder(diameter: number, length: number): THREE.CylinderGeometry;
+/** One oriented guard box as a metre-UV geometry, z laid along its direction. */
+export declare function guardBoxGeometry(box: GuardBox): THREE.CylinderGeometry | THREE.BoxGeometry;
+/** Merge a guard's boxes into one metre-UV geometry, or null when empty. */
+export declare function mergeGuardBoxes(boxes: GuardBox[]): THREE.BufferGeometry | null;
+//# sourceMappingURL=baluster-geometry.d.ts.map

package/dist/stair/baluster-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"baluster-geometry.d.ts","sourceRoot":"","sources":["../../src/stair/baluster-geometry.ts"],"names":[],"mappings":"AAAA;;;;;;GAMG;AAEH,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAE5C,iEAAiE;AACjE,wBAAgB,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,qBAetE;AAED;;;uCAGuC;AACvC,wBAAgB,cAAc,CAAC,QAAQ,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,0BAY9D;AAYD,iFAAiF;AACjF,wBAAgB,gBAAgB,CAAC,GAAG,EAAE,QAAQ,8CAW7C;AAED,4EAA4E;AAC5E,wBAAgB,eAAe,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,KAAK,CAAC,cAAc,GAAG,IAAI,CAM9E"}

package/dist/stair/baluster-geometry.js

@@ -0,0 +1,74 @@
+/**
+ * Turning the pure `GuardBox` data from `baluster-guard.ts` into Three.js
+ * geometry with metre-scale UVs (E-009): 1 UV unit = 1 m on every face, so a
+ * finish tiles the same on a rail, a newel and a picket. Both the per-flight
+ * guard (`renderer.tsx`) and the continuous guard (`continuous-railings.tsx`)
+ * build their boxes through here, so there is one UV convention to maintain.
+ */
+import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+/** A box whose UVs run in metres (1 unit = 1 m) on each face. */
+export function metricBox(length, height, depth) {
+    const geometry = new THREE.BoxGeometry(length, height, depth);
+    const position = geometry.getAttribute('position'), normal = geometry.getAttribute('normal'), uv = geometry.getAttribute('uv');
+    for (let i = 0; i < position.count; i++) {
+        const x = position.getX(i), y = position.getY(i), z = position.getZ(i);
+        if (Math.abs(normal.getX(i)) > 0.5)
+            uv.setXY(i, z, y);
+        else if (Math.abs(normal.getY(i)) > 0.5)
+            uv.setXY(i, x, z);
+        else
+            uv.setXY(i, x, y);
+    }
+    geometry.setAttribute('uv2', geometry.getAttribute('uv').clone());
+    return geometry;
+}
+/** A round guard member (a cable or its sleeve) as a metre-UV cylinder laid
+ * along its direction: `size[0]` is the diameter, `size[2]` the length. UVs run
+ * in metres — the circumference across, the length along — so a finish tiles
+ * the same as on a rectangular bar. */
+export function metricCylinder(diameter, length) {
+    const radius = diameter / 2;
+    const geometry = new THREE.CylinderGeometry(radius, radius, length, 12);
+    const position = geometry.getAttribute('position'), normal = geometry.getAttribute('normal'), uv = geometry.getAttribute('uv');
+    for (let i = 0; i < uv.count; i++) {
+        if (Math.abs(normal.getY(i)) > 0.5)
+            uv.setXY(i, position.getX(i), position.getZ(i));
+        else
+            uv.setXY(i, uv.getX(i) * 2 * Math.PI * radius, uv.getY(i) * length);
+    }
+    geometry.setAttribute('uv2', uv.clone());
+    return geometry;
+}
+function roundGuardBoxGeometry(box) {
+    const geometry = metricCylinder(box.size[0], box.size[2]);
+    const direction = new THREE.Vector3(...box.direction).normalize();
+    geometry.applyQuaternion(new THREE.Quaternion().setFromUnitVectors(new THREE.Vector3(0, 1, 0), direction));
+    geometry.translate(box.center[0], box.center[1], box.center[2]);
+    return geometry;
+}
+/** One oriented guard box as a metre-UV geometry, z laid along its direction. */
+export function guardBoxGeometry(box) {
+    if (box.round)
+        return roundGuardBoxGeometry(box);
+    const geometry = metricBox(box.size[0], box.size[1], box.size[2]);
+    const z = new THREE.Vector3(...box.direction).normalize();
+    let x = new THREE.Vector3().crossVectors(new THREE.Vector3(0, 1, 0), z);
+    if (x.lengthSq() < 1e-8)
+        x.set(1, 0, 0);
+    x = x.normalize();
+    const y = new THREE.Vector3().crossVectors(z, x).normalize();
+    geometry.applyMatrix4(new THREE.Matrix4().makeBasis(x, y, z));
+    geometry.translate(box.center[0], box.center[1], box.center[2]);
+    return geometry;
+}
+/** Merge a guard's boxes into one metre-UV geometry, or null when empty. */
+export function mergeGuardBoxes(boxes) {
+    if (!boxes.length)
+        return null;
+    const geometries = boxes.map(guardBoxGeometry);
+    const merged = mergeGeometries(geometries, false);
+    for (const geometry of geometries)
+        geometry.dispose();
+    return merged;
+}

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

@@ -0,0 +1,50 @@
+/**
+ * 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 { type GuardBox, type GuardRail, type Vec3 } from './guard-path';
+export type BalusterGuardOptions = {
+    railHeight: number;
+    /** Metre pitch for pickets, sampled along the horizontal run. */
+    pickets: number;
+    /** Metres between newels 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 two rails' section (`across` the run, `vertical`) and `y` off the nosing line. */
+export declare const BALUSTER_RAIL_PROFILE: {
+    readonly top: {
+        readonly across: 0.062;
+        readonly vertical: 0.05;
+        readonly y: 0;
+    };
+    readonly bottom: {
+        readonly across: 0.045;
+        readonly vertical: 0.045;
+        readonly y: 0.08;
+    };
+};
+/** 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 declare function balusterGuardRails(railHeight: number): GuardRail[];
+export declare function buildBalusterGuard(points: Vec3[], options: BalusterGuardOptions): GuardBox[];
+//# sourceMappingURL=baluster-guard.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"baluster-guard.d.ts","sourceRoot":"","sources":["../../src/stair/baluster-guard.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;GAkBG;AAEH,OAAO,EAEL,KAAK,QAAQ,EACb,KAAK,SAAS,EAEd,KAAK,IAAI,EACV,MAAM,cAAc,CAAA;AAErB,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,iEAAiE;IACjE,OAAO,EAAE,MAAM,CAAA;IACf,6EAA6E;IAC7E,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;AAWD,yFAAyF;AACzF,eAAO,MAAM,qBAAqB;;;;;;;;;;;CAGxB,CAAA;AAQV;;4CAE4C;AAC5C,wBAAgB,kBAAkB,CAAC,UAAU,EAAE,MAAM,GAAG,SAAS,EAAE,CAKlE;AAED,wBAAgB,kBAAkB,CAAC,MAAM,EAAE,IAAI,EAAE,EAAE,OAAO,EAAE,oBAAoB,GAAG,QAAQ,EAAE,CAkC5F"}