@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/stair/cable-guard.js

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

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

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

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

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

package/dist/stair/construction-controls.js

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

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

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

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

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

package/dist/stair/continuous-railings.js

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

package/dist/stair/definition.d.ts

@@ -1,5 +1,5 @@
 import { type NodeDefinition } from '@pascal-app/core';
-import { StairNode } from './schema';
+import { StairNode } from './schema.js';
 /**
  * Stair — Stage A. Composite node like roof: owns overall framing,
  * `stair-segment` children own per-flight geometry. Wrap-exports the

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

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

package/dist/stair/definition.js

@@ -1,10 +1,8 @@
-import { resolveStairTotalRise, StairNode as StairNodeSchema, stairFootprintAABB, useScene, } from '@pascal-app/core';
-const MIN_CURVED_RISE = 0.3;
-const MIN_CURVED_WIDTH = 0.4;
-const MIN_CURVED_INNER_RADIUS_SPIRAL = 0.05;
-const MIN_CURVED_INNER_RADIUS_CURVED = 0.2;
-const MIN_CURVED_SWEEP = Math.PI / 12;
-const MAX_CURVED_SWEEP = Math.PI * 2 - 0.05;
+import { planStairSweepEdit, resolveStairTotalRise, resolveStairWinder, StairNode as StairNodeSchema, stairFootprintAABB, stairSlots, useScene, } from '@pascal-app/core';
+const MIN_CURVED_RISE = 0.001;
+const MIN_CURVED_WIDTH = 0.001;
+const MIN_CURVED_INNER_RADIUS_SPIRAL = 0.001;
+const MIN_CURVED_INNER_RADIUS_CURVED = 0.001;
 const CURVED_RISE_OFFSET = 0.35;
 const CURVED_WIDTH_HANDLE_OFFSET = 0.5;
 const CURVED_RADIAL_OFFSET = 0.16;
@@ -22,7 +20,7 @@ const STAIR_ROTATE_CORNER_OFFSET = 0.4;
 const STAIR_ROTATE_RING_OFFSET = 0.08;
 const STAIR_MOVE_FRONT_OFFSET = 0.35;
 function readTotalRise(node) {
-    return Math.max(resolveStairTotalRise(node, useScene.getState().nodes), 0.1);
+    return Math.max(resolveStairTotalRise(node, useScene.getState().nodes), 0.001);
 }
 function readCurvedStairGeometry(node) {
     const isSpiral = node.stairType === 'spiral';
@@ -84,12 +82,13 @@ function readStraightStairMoveBounds(node, sceneApi) {
         if (!transform)
             return;
         const halfWidth = segment.width / 2;
-        const corners = [
-            [-halfWidth, 0],
-            [halfWidth, 0],
-            [-halfWidth, segment.length],
-            [halfWidth, segment.length],
-        ];
+        const corners = resolveStairWinder(segment)?.footprint ??
+            [
+                [-halfWidth, 0],
+                [halfWidth, 0],
+                [-halfWidth, segment.length],
+                [halfWidth, segment.length],
+            ];
         for (const [x, z] of corners) {
             const [rx, rz] = rotateLocalXZ(x, z, transform.rotation);
             minX = Math.min(minX, transform.position[0] + rx);
@@ -204,26 +203,7 @@ function curvedSweepHandle(end) {
         kind: 'arc-resize',
         axis: 'angular',
         end,
-        apply: (initial, delta) => {
-            const initialSweep = initial.sweepAngle ?? Math.PI / 2;
-            const initialRotation = initial.rotation ?? 0;
-            const sweepSign = Math.sign(initialSweep) || 1;
-            // END handle: cursor angle delta IS the sweep delta.
-            // START handle: cursor angle delta is the negation of the sweep delta.
-            const sweepDelta = end === 'end' ? delta : -delta;
-            const targetSweep = initialSweep + sweepDelta;
-            const clampedAbs = Math.min(MAX_CURVED_SWEEP, Math.max(MIN_CURVED_SWEEP, Math.abs(targetSweep)));
-            const newSweep = sweepSign * clampedAbs;
-            const appliedDelta = newSweep - initialSweep;
-            // Re-orient the stair so the OPPOSITE edge stays world-fixed:
-            //   END  fixed-start: ΔR = −ΔS / 2
-            //   START fixed-end : ΔR = +ΔS / 2
-            const rotationShift = end === 'end' ? -appliedDelta / 2 : appliedDelta / 2;
-            return {
-                sweepAngle: newSweep,
-                rotation: initialRotation + rotationShift,
-            };
-        },
+        apply: (initial, delta) => planStairSweepEdit(initial, delta, end),
         placement: {
             position: (n) => {
                 const g = readCurvedStairGeometry(n);
@@ -331,14 +311,13 @@ function stairHandles(node) {
     handles.push(stairRotateHandle(), stairMoveHandle());
     return handles;
 }
-import { computeStairSegmentFloorStackTransforms, getStairFloorPlacedFootprints, } from './floor-stack';
-import { buildStairFloorplan } from './floorplan';
-import { curvedStairInnerRadiusAffordance, curvedStairSweepAffordance, curvedStairWidthAffordance, segmentLengthAffordance, segmentWidthAffordance, stairRotateAffordance, } from './floorplan-affordances';
-import { stairFloorplanMoveTarget } from './floorplan-move';
-import { stairPaint } from './paint';
-import { stairParametrics } from './parametrics';
-import { StairNode } from './schema';
-import { stairSlots } from './slots';
+import { computeStairSegmentFloorStackTransforms, getStairFloorPlacedFootprints, } from '@pascal-app/core';
+import { buildStairFloorplan } from './floorplan.js';
+import { curvedStairInnerRadiusAffordance, curvedStairSweepAffordance, curvedStairWidthAffordance, segmentLengthAffordance, segmentWidthAffordance, stairRotateAffordance, } from './floorplan-affordances.js';
+import { stairFloorplanMoveTarget } from './floorplan-move.js';
+import { stairPaint } from './paint.js';
+import { stairParametrics } from './parametrics.js';
+import { StairNode } from './schema.js';
 /**
  * Stair — Stage A. Composite node like roof: owns overall framing,
  * `stair-segment` children own per-flight geometry. Wrap-exports the
@@ -346,7 +325,7 @@ import { stairSlots } from './slots';
  */
 export const stairDefinition = {
     kind: 'stair',
-    schemaVersion: 1,
+    schemaVersion: 2,
     schema: StairNode,
     category: 'structure',
     extensions: {
@@ -375,6 +354,19 @@ export const stairDefinition = {
         return rest;
     },
     capabilities: {
+        reveal: { phase: 'circulation', style: 'drop', height: 2.5 },
+        revealOnEdit: [
+            'stairType',
+            'width',
+            'totalRise',
+            'stepCount',
+            'thickness',
+            'innerRadius',
+            'sweepAngle',
+            'railingMode',
+            'topLandingDepth',
+        ],
+        hostRefFields: ['destinationSurfaceId'],
         surfacePlacement: 'floor-only',
         selectable: { hitVolume: 'bbox' },
         // A stair has no centred box footprint: straight = a cumulative
@@ -398,17 +390,18 @@ export const stairDefinition = {
     // `shared/move-roof-tool` — routed through `MoveTool`'s registry-
     // affordance lookup rather than a hardcoded dispatcher arm.
     affordanceTools: {
-        move: () => import('../shared/move-roof-tool'),
+        move: () => import('../shared/move-roof-tool.js'),
     },
+    tool: () => import('./tool.js'),
     parametrics: stairParametrics,
     handles: stairHandles,
     rendersChildren: false,
     renderer: {
         kind: 'parametric',
-        module: () => import('./renderer'),
+        module: () => import('./renderer.js'),
     },
     system: {
-        module: () => import('./system'),
+        module: () => import('./system.js'),
         priority: 3,
     },
     // Stage C — stair is the parent; it walks its `stair-segment` children

package/dist/stair/documentation.d.ts

@@ -1,5 +1,5 @@
 import { type FloorplanGeometry, type GeometryContext, type StairNode } from '@pascal-app/core';
-import type { FloorplanStairArrowEntry, FloorplanStairEntry } from '@pascal-app/editor';
+import type { FloorplanStairArrowEntry, FloorplanStairEntry } from './plan-entry.js';
 export type StairPlanDirection = 'up' | 'down';
 export declare function resolveStairPlanDirection(stair: StairNode, activeLevelId: string | null | undefined): StairPlanDirection;
 export declare function resolveStraightStairDirectionArrow(entry: FloorplanStairEntry, direction: StairPlanDirection): FloorplanStairArrowEntry | null;

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

@@ -1 +1 @@
-{"version":3,"file":"documentation.d.ts","sourceRoot":"","sources":["../../src/stair/documentation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAGpB,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AACzB,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EAEpB,MAAM,oBAAoB,CAAA;AAgB3B,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG,MAAM,CAAA;AAE9C,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,EAChB,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACvC,kBAAkB,CAUpB;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,mBAAmB,EAC1B,SAAS,EAAE,kBAAkB,GAC5B,wBAAwB,GAAG,IAAI,CA0BjC;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,eAAe,GACnB,iBAAiB,EAAE,CAYrB"}
+{"version":3,"file":"documentation.d.ts","sourceRoot":"","sources":["../../src/stair/documentation.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAKpB,KAAK,SAAS,EAEf,MAAM,kBAAkB,CAAA;AAOzB,OAAO,KAAK,EACV,wBAAwB,EACxB,mBAAmB,EAEpB,MAAM,cAAc,CAAA;AAUrB,MAAM,MAAM,kBAAkB,GAAG,IAAI,GAAG,MAAM,CAAA;AAE9C,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,SAAS,EAChB,aAAa,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,GACvC,kBAAkB,CAUpB;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,mBAAmB,EAC1B,SAAS,EAAE,kBAAkB,GAC5B,wBAAwB,GAAG,IAAI,CA0BjC;AAED,wBAAgB,kBAAkB,CAAC,SAAS,EAAE,MAAM,GAAG,MAAM,CAE5D;AAED,wBAAgB,uBAAuB,CACrC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,mBAAmB,EAC1B,GAAG,EAAE,eAAe,GACnB,iBAAiB,EAAE,CAYrB"}

package/dist/stair/documentation.js

@@ -1,6 +1,6 @@
-import { resolveStairTotalRise, useScene, } from '@pascal-app/core';
+import { resolveStairArcDimensions, resolveStairTotalRise, resolveStairWinder, useScene, } from '@pascal-app/core';
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
-import { formatConstructionLength, } from '../shared/construction-length';
+import { formatConstructionLength, } from '../shared/construction-length.js';
 const ANNOTATION_OFFSET = 0.28;
 const ANNOTATION_FONT_SIZE = 0.125;
 const DIRECTION_FONT_SIZE = 0.16;
@@ -80,6 +80,12 @@ function buildStraightDocumentation(stair, entry, direction, unit, profile, metr
     for (const segmentEntry of entry.segments) {
         if (segmentEntry.segment.segmentType !== 'stair')
             continue;
+        if (segmentEntry.segment.winder) {
+            const segment = segmentEntry.segment, layout = resolveStairWinder(segment);
+            const anchor = segmentEntry.polygon[0];
+            geometries.push(annotationText({ x: anchor.x + 0.18, y: anchor.y + 0.18 }, `${segment.stepCount} R @ ${formatConstructionLength(segment.height / segment.stepCount, unit, profile, { metricNotation })} · WINDER T ${formatConstructionLength(layout.going, unit, profile, { metricNotation })} · CLR W ${formatConstructionLength(segment.width, unit, profile, { metricNotation })}`, ANNOTATION_FONT_SIZE, stroke));
+            continue;
+        }
         const frame = segmentFrame(segmentEntry);
         if (!frame)
             continue;
@@ -104,16 +110,10 @@ function buildStraightDocumentation(stair, entry, direction, unit, profile, metr
     return geometries;
 }
 function buildCurvedDocumentation(stair, direction, unit, profile, metricNotation, stroke) {
-    const stairType = stair.stairType === 'spiral' ? 'spiral' : 'curved';
-    const stepCount = Math.max(stairType === 'spiral' ? 6 : 4, Math.round(stair.stepCount));
-    const sweep = normalizedSweep(stair);
+    const layout = resolveStairArcDimensions(stair, resolveStairTotalRise(stair, useScene.getState().nodes));
+    const { stepCount, sweepAngle: sweep, innerRadius, outerRadius, walkingRadius, riserHeight, going: treadDepth, } = layout;
     const startAngle = -stair.rotation - sweep / 2;
     const endAngle = startAngle + sweep;
-    const innerRadius = Math.max(stairType === 'spiral' ? 0.05 : 0.2, stair.innerRadius);
-    const outerRadius = innerRadius + stair.width;
-    const walkingRadius = innerRadius + stair.width / 2;
-    const riserHeight = resolveStairTotalRise(stair, useScene.getState().nodes) / stepCount;
-    const treadDepth = (Math.abs(sweep) * walkingRadius) / stepCount;
     const center = { x: stair.position[0], y: stair.position[2] };
     const noteAngle = (startAngle + endAngle) / 2;
     const notePoint = arcPoint(center, outerRadius + ANNOTATION_OFFSET, noteAngle);
@@ -121,7 +121,7 @@ function buildCurvedDocumentation(stair, direction, unit, profile, metricNotatio
     const directionPoint = arcPoint(center, walkingRadius, directionAngle);
     const breakAngle = startAngle + sweep * BREAK_POSITION;
     const geometries = [
-        annotationText(notePoint, `${stepCount} R @ ${formatConstructionLength(riserHeight, unit, profile, { metricNotation })} · T(CL) ${formatConstructionLength(treadDepth, unit, profile, { metricNotation })} · CLR W ${formatConstructionLength(stair.width, unit, profile, { metricNotation })}`, ANNOTATION_FONT_SIZE, stroke),
+        annotationText(notePoint, `${stepCount} R @ ${formatConstructionLength(riserHeight, unit, profile, { metricNotation })} · T(CL) ${formatConstructionLength(treadDepth, unit, profile, { metricNotation })} · CLR W ${formatConstructionLength(layout.width, unit, profile, { metricNotation })}`, ANNOTATION_FONT_SIZE, stroke),
         annotationText(directionPoint, direction === 'up' ? 'UP' : 'DN', DIRECTION_FONT_SIZE, stroke),
         buildCurvedBreakLine(center, innerRadius, outerRadius, breakAngle, stroke),
     ];
@@ -212,13 +212,6 @@ function segmentFrame(segmentEntry) {
         rightMid: interpolate(backRight, frontRight, 0.5),
     };
 }
-function normalizedSweep(stair) {
-    const defaultSweep = stair.stairType === 'spiral' ? Math.PI * 2 : Math.PI / 2;
-    const sweep = stair.sweepAngle ?? defaultSweep;
-    if (Math.abs(sweep) < Math.PI * 2)
-        return sweep;
-    return Math.sign(sweep || 1) * (Math.PI * 2 - 0.001);
-}
 function arcPoint(center, radius, angle) {
     return { x: center.x + Math.cos(angle) * radius, y: center.y + Math.sin(angle) * radius };
 }

package/dist/stair/floorplan-affordances.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAExB,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAwCzB;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,SAAS,CAiCjE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,SAAS,CAgClE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CA+BrE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,EAAE,mBAAmB,CAAC,SAAS,CAiD3E,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CAgChE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CAkDrE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAGxB,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AAmCzB;;;;;;;GAOG;AACH,eAAO,MAAM,sBAAsB,EAAE,mBAAmB,CAAC,SAAS,CAiCjE,CAAA;AAED;;;;;GAKG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,SAAS,CAgClE,CAAA;AAED;;;;;;GAMG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CA+BrE,CAAA;AAED;;;;GAIG;AACH,eAAO,MAAM,gCAAgC,EAAE,mBAAmB,CAAC,SAAS,CAiD3E,CAAA;AAED;;;;;;;;;GASG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,SAAS,CAgChE,CAAA;AAED;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,EAAE,mBAAmB,CAAC,SAAS,CAyCrE,CAAA"}

package/dist/stair/floorplan-affordances.js

@@ -1,16 +1,11 @@
-import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { createAngleAccumulator, planStairSweepEdit, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { isAngleSnapActive } from '@pascal-app/editor';
-import { rotateAffordanceDelta } from '../shared/rotate-affordance';
-// Minimums + max sweep mirror the 3D handles in
-// `packages/editor/src/components/editor/stair-segment-handles.tsx` so a 2D
-// drag can't push a stair past what the 3D drag would allow.
-const MIN_SEGMENT_WIDTH = 0.4;
-const MIN_SEGMENT_LENGTH = 0.4;
-const MIN_CURVED_WIDTH = 0.4;
-const MIN_CURVED_INNER_RADIUS_SPIRAL = 0.05;
-const MIN_CURVED_INNER_RADIUS_CURVED = 0.2;
-const MIN_CURVED_SWEEP = Math.PI / 12;
-const MAX_CURVED_SWEEP = Math.PI * 2 - 0.05;
+import { rotateAffordanceDelta } from '../shared/rotate-affordance.js';
+const MIN_SEGMENT_WIDTH = 0.001;
+const MIN_SEGMENT_LENGTH = 0.001;
+const MIN_CURVED_WIDTH = 0.001;
+const MIN_CURVED_INNER_RADIUS_SPIRAL = 0.001;
+const MIN_CURVED_INNER_RADIUS_CURVED = 0.001;
 function noopSession() {
     return {
         affectedIds: [],
@@ -241,30 +236,19 @@ export const curvedStairSweepAffordance = {
         const { end } = payload;
         const stairId = node.id;
         const initialSweep = node.sweepAngle ?? (node.stairType === 'spiral' ? Math.PI * 2 : Math.PI / 2);
-        const sweepSign = Math.sign(initialSweep) || 1;
         const initialRotation = node.rotation;
         const cx = node.position[0];
         const cz = node.position[2];
         const initialAngle = Math.atan2(initialPlanPoint[1] - cz, initialPlanPoint[0] - cx);
+        const accumulateAngle = createAngleAccumulator(initialAngle);
         let lastSweep = initialSweep;
         let lastRotation = initialRotation;
         return {
             affectedIds: [stairId],
             apply({ planPoint }) {
                 const currentAngle = Math.atan2(planPoint[1] - cz, planPoint[0] - cx);
-                let delta = currentAngle - initialAngle;
-                // Wrap to [-π, π] so a drag crossing ±π doesn't flip sign mid-gesture.
-                while (delta > Math.PI)
-                    delta -= 2 * Math.PI;
-                while (delta < -Math.PI)
-                    delta += 2 * Math.PI;
-                const sweepDelta = end === 'end' ? delta : -delta;
-                const targetSweep = initialSweep + sweepDelta;
-                const clampedAbs = Math.min(MAX_CURVED_SWEEP, Math.max(MIN_CURVED_SWEEP, Math.abs(targetSweep)));
-                const newSweep = sweepSign * clampedAbs;
-                const appliedDelta = newSweep - initialSweep;
-                const rotationShift = end === 'end' ? -appliedDelta / 2 : appliedDelta / 2;
-                const newRotation = initialRotation + rotationShift;
+                const delta = accumulateAngle(currentAngle);
+                const { sweepAngle: newSweep, rotation: newRotation } = planStairSweepEdit({ sweepAngle: initialSweep, rotation: initialRotation }, delta, end);
                 lastSweep = newSweep;
                 lastRotation = newRotation;
                 useLiveNodeOverrides.getState().set(stairId, {

package/dist/stair/floorplan-move.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAGxB,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AASzB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CAoDnE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/stair/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAKxB,KAAK,SAAS,EAKf,MAAM,kBAAkB,CAAA;AASzB;;;;;;;;;;;GAWG;AACH,eAAO,MAAM,wBAAwB,EAAE,mBAAmB,CAAC,SAAS,CAiJnE,CAAA"}