@pascal-app/nodes 1.0.3 → 1.0.5

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/solar-panel/tool.tsx"],"names":[],"mappings":"AA4BA;;;;;;;GAOG;AACH,QAAA,MAAM,cAAc,mCAoJnB,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/solar-panel/tool.tsx"],"names":[],"mappings":"AA4BA;;;;;;;GAOG;AACH,QAAA,MAAM,cAAc,mCAoJnB,CAAA;eAEc,cAAc"}

package/dist/solar-panel/tool.js

@@ -1,16 +1,16 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { emitter, SolarPanelNode, sceneRegistry, useScene, } from '@pascal-app/core';
 import { triggerSFX, usePlacementPreview } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import * as THREE from 'three';
-import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview';
-import { resolveRoofSegmentHit } from '../shared/roof-segment-hit';
-import { getAnalyticalNormal, surfaceQuatFromNormal } from '../shared/roof-surface';
-import { clearRoofSurfacePlacementGuides, publishRoofSurfacePlacementGuides, roofSurfaceFootprintFromNode, } from '../shared/roof-surface-placement-guides';
-import { solarPanelDefinition } from './definition';
-import SolarPanelPreview from './preview';
+import { RoofAttachmentFallbackPreview } from '../shared/roof-attachment-fallback-preview.js';
+import { resolveRoofSegmentHit } from '../shared/roof-segment-hit.js';
+import { getAnalyticalNormal, surfaceQuatFromNormal } from '../shared/roof-surface.js';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfacePlacementGuides, roofSurfaceFootprintFromNode, } from '../shared/roof-surface-placement-guides.js';
+import { solarPanelDefinition } from './definition.js';
+import SolarPanelPreview from './preview.js';
 const worldPoint = new THREE.Vector3();
 /**
  * Solar panel placement tool. The preview shows the array at the

package/dist/spawn/definition.d.ts

@@ -1,4 +1,4 @@
 import type { NodeDefinition } from '@pascal-app/core';
-import { SpawnNode } from './schema';
+import { SpawnNode } from './schema.js';
 export declare const spawnDefinition: NodeDefinition<typeof SpawnNode>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/spawn/definition.js

@@ -1,8 +1,8 @@
-import { buildSpawnFloorplan } from './floorplan';
-import { spawnRotateAffordance } from './floorplan-affordances';
-import { spawnFloorplanMoveTarget } from './floorplan-move';
-import { spawnParametrics } from './parametrics';
-import { SpawnNode } from './schema';
+import { buildSpawnFloorplan } from './floorplan.js';
+import { spawnRotateAffordance } from './floorplan-affordances.js';
+import { spawnFloorplanMoveTarget } from './floorplan-move.js';
+import { spawnParametrics } from './parametrics.js';
+import { SpawnNode } from './schema.js';
 const SPAWN_FOOTPRINT = 0.6;
 const SPAWN_HANDLE_HEIGHT = 0.46;
 const MOVE_FRONT_OFFSET = 0.35;
@@ -76,7 +76,7 @@ export const spawnDefinition = {
     rendersChildren: false,
     renderer: {
         kind: 'parametric',
-        module: () => import('./renderer'),
+        module: () => import('./renderer.js'),
     },
     // Stage C migration: floor-plan rendering via def.floorplan.
     // floorplan-panel.tsx's `floorplanSpawnEntries` short-circuits to []
@@ -90,7 +90,7 @@ export const spawnDefinition = {
     floorplanAffordances: {
         'spawn-rotate': spawnRotateAffordance,
     },
-    tool: () => import('./tool'),
+    tool: () => import('./tool.js'),
     toolHints: [
         { key: 'Left click', label: 'Place spawn point' },
         { key: 'R / T', label: 'Rotate spawn point' },

package/dist/spawn/floorplan-affordances.js

@@ -1,6 +1,6 @@
 import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { isAngleSnapActive } from '@pascal-app/editor';
-import { rotateAffordanceDelta } from '../shared/rotate-affordance';
+import { rotateAffordanceDelta } from '../shared/rotate-affordance.js';
 export const spawnRotateAffordance = {
     start({ node, initialPlanPoint }) {
         const spawnId = node.id;

package/dist/spawn/floorplan.d.ts

@@ -1,5 +1,5 @@
 import type { FloorplanGeometry, GeometryContext } from '@pascal-app/core';
-import type { SpawnNode } from './schema';
+import type { SpawnNode } from './schema.js';
 /**
  * 2D floor-plan marker for a spawn point. Uses the same footprint icon
  * as the walkthrough-mode control and rotates it toward the spawn's

package/dist/spawn/index.d.ts

@@ -1,3 +1,3 @@
-export { spawnDefinition } from './definition';
-export { SpawnNode } from './schema';
+export { spawnDefinition } from './definition.js';
+export { SpawnNode } from './schema.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/spawn/index.js

@@ -1,2 +1,2 @@
-export { spawnDefinition } from './definition';
-export { SpawnNode } from './schema';
+export { spawnDefinition } from './definition.js';
+export { SpawnNode } from './schema.js';

package/dist/spawn/panel.js

@@ -67,5 +67,5 @@ export default function SpawnPanel() {
         return null;
     const rotationDegrees = Math.round(((draftRotation ?? node.rotation) * 180) / Math.PI);
     const storedRotationDegrees = Math.round((node.rotation * 180) / Math.PI);
-    return (_jsxs(PanelWrapper, { icon: "/icons/spawn-point.webp", onClose: handleClose, title: "Spawn Point", width: 300, children: [_jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: node.position[0] + 2, min: node.position[0] - 2, onChange: (value) => handleUpdate({ position: [value, node.position[1], node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[0] }), _jsx(SliderControl, { label: "Y", max: node.position[1] + 2, min: node.position[1] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], value, node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[1] }), _jsx(SliderControl, { label: "Z", max: node.position[2] + 2, min: node.position[2] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], node.position[1], value] }), precision: 2, step: 0.01, unit: "m", value: node.position[2] })] }), _jsx(PanelSection, { title: "Facing", children: _jsx(SliderControl, { label: "Yaw", max: storedRotationDegrees + 90, min: storedRotationDegrees - 90, onChange: handleRotationChange, onCommit: commitRotation, precision: 0, step: 1, unit: "\u00B0", value: rotationDegrees }) }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-4 w-4" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { className: "border-red-500/40 text-red-200 hover:bg-red-500/15", icon: _jsx(Trash2, { className: "h-4 w-4" }), label: "Delete", onClick: handleDelete })] }) })] }));
+    return (_jsxs(PanelWrapper, { icon: "/icons/spawn-point.webp", onClose: handleClose, title: "Spawn Point", width: 300, children: [_jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: node.position[0] + 2, min: node.position[0] - 2, onChange: (value) => handleUpdate({ position: [value, node.position[1], node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[0] }), _jsx(SliderControl, { label: "Y", max: node.position[1] + 2, min: node.position[1] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], value, node.position[2]] }), precision: 2, step: 0.01, unit: "m", value: node.position[1] }), _jsx(SliderControl, { label: "Z", max: node.position[2] + 2, min: node.position[2] - 2, onChange: (value) => handleUpdate({ position: [node.position[0], node.position[1], value] }), precision: 2, step: 0.01, unit: "m", value: node.position[2] })] }), _jsx(PanelSection, { title: "Facing", children: _jsx(SliderControl, { label: "Yaw", max: storedRotationDegrees + 90, min: storedRotationDegrees - 90, onChange: handleRotationChange, onCommit: commitRotation, precision: 0, step: 1, unit: "\u00B0", value: rotationDegrees }) }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-4 w-4" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { className: "border-red-500/40 text-red-700 dark:text-red-200 hover:bg-red-500/15", icon: _jsx(Trash2, { className: "h-4 w-4" }), label: "Delete", onClick: handleDelete })] }) })] }));
 }

package/dist/spawn/parametrics.d.ts

@@ -1,5 +1,5 @@
 import type { ParametricDescriptor } from '@pascal-app/core';
-import type { SpawnNode } from './schema';
+import type { SpawnNode } from './schema.js';
 /**
  * Inspector descriptor for spawn. Tiny — spawn has only position + rotation,
  * and Phase 4 will auto-render a 3-component vec3 + a yaw scalar from this.

package/dist/spawn/parametrics.js

@@ -19,5 +19,5 @@ export const spawnParametrics = {
     // degrees in the slider and uses `useLiveTransforms` for smooth yaw
     // dragging). Auto-inspector doesn't express the deg ↔ rad
     // transform or the live-yaw preview yet — kept as a custom panel.
-    customPanel: () => import('./panel'),
+    customPanel: () => import('./panel.js'),
 };

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/spawn/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAoGzB,eAAO,MAAM,YAAY,GAAI,kBAAkB;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,gCAElF,CAAA;AAED;;;;;;;;;GASG;AACH,QAAA,MAAM,aAAa,GAAI,UAAU;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCAsBnD,CAAA;AAED,eAAe,aAAa,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/spawn/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAoGzB,eAAO,MAAM,YAAY,qBAAsB;IAAE,MAAM,CAAC,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,SAAS,CAAA;CAAE,gCAElF,CAAA;AAED;;;;;;;;;GASG;AACH,QAAA,MAAM,aAAa,aAAc;IAAE,IAAI,EAAE,SAAS,CAAA;CAAE,gCAsBnD,CAAA;eAEc,aAAa"}

package/dist/spawn/renderer.js

@@ -1,5 +1,5 @@
 'use client';
-import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { useLiveNodeOverrides, useLiveTransforms, useRegistry, } from '@pascal-app/core';
 import { createDefaultMaterial, useNodeEvents, useViewer } from '@pascal-app/viewer';
 import { useMemo, useRef } from 'react';

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/spawn/tool.tsx"],"names":[],"mappings":"AAyCA;;;;;;GAMG;AACH,QAAA,MAAM,SAAS,0CA8Kd,CAAA;AAED,eAAe,SAAS,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/spawn/tool.tsx"],"names":[],"mappings":"AAyCA;;;;;;GAMG;AACH,QAAA,MAAM,SAAS,0CA8Kd,CAAA;eAEc,SAAS"}

package/dist/spawn/tool.js

@@ -4,8 +4,8 @@ import { collectAlignmentAnchors, emitter, resolveSupportSlabPatch, SpawnNode, u
 import { EDITOR_LAYER, getFloorStackPreviewPosition, isAlignmentGuideActive, isGridSnapActive, isMagneticSnapActive, movementSfxStepKey, triggerSFX, useAlignmentGuides, useEditor, usePlacementPreview, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useEffect, useMemo, useRef, useState } from 'react';
-import { getLevelLocalSnappedPosition, resolveAlignedFloorPlacement, } from '../shared/floor-placement';
-import { SpawnPreview } from './renderer';
+import { getLevelLocalSnappedPosition, resolveAlignedFloorPlacement, } from '../shared/floor-placement.js';
+import { SpawnPreview } from './renderer.js';
 const ROTATION_STEP = Math.PI / 4;
 function getExistingSpawnIds() {
     const nodes = useScene.getState().nodes;

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.js';
+/** 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.BoxGeometry | THREE.CylinderGeometry;
+/** 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.js';
+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;aAChC,GAAG;iBAAI,MAAM,EAAE,KAAK;iBAAE,QAAQ,EAAE,IAAI;iBAAE,CAAC,EAAE,CAAC;;aAC1C,MAAM;iBAAI,MAAM,EAAE,KAAK;iBAAE,QAAQ,EAAE,KAAK;iBAAE,CAAC,EAAE,IAAI;;CACzC,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"}

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.js';
+// 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.js';
+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.js';
+// 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.js';
+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"}