@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/stair/use-stair-render-data.d.ts

@@ -0,0 +1,317 @@
+import { type StairNode } from '@pascal-app/core';
+export declare function useStairTotalRise(stair: StairNode): number;
+export declare function useStairRenderData(stair: StairNode): {
+    stair: {
+        object: "node";
+        parentId: string | null;
+        visible: boolean;
+        metadata: Record<string, unknown>;
+        id: `stair_${string}`;
+        type: "stair";
+        position: [number, number, number];
+        rotation: number;
+        stairType: "curved" | "straight" | "spiral";
+        fromLevelId: string | null;
+        toLevelId: string | null;
+        slabOpeningMode: "none" | "destination";
+        openingOffset: number;
+        width: number;
+        stepCount: number;
+        thickness: number;
+        fillToFloor: boolean;
+        innerRadius: number;
+        sweepAngle: number;
+        topLandingMode: "none" | "integrated";
+        topLandingDepth: number;
+        showCenterColumn: boolean;
+        showStepSupports: boolean;
+        railingMode: "left" | "right" | "none" | "both";
+        railingHeight: number;
+        children: `sseg_${string}`[];
+        name?: string | undefined;
+        camera?: {
+            position: [number, number, number];
+            target: [number, number, number];
+            mode: "perspective" | "orthographic";
+            fov?: number | undefined;
+            zoom?: number | undefined;
+        } | undefined;
+        provenance?: {
+            refs: {
+                id: string;
+                ns?: string | undefined;
+                role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+            }[];
+            lineage?: {
+                op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+                fromIds: string[];
+            } | undefined;
+        } | undefined;
+        material?: {
+            id?: string | undefined;
+            preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "front" | "back" | "double";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        materialPreset?: string | undefined;
+        railingMaterial?: {
+            id?: string | undefined;
+            preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "front" | "back" | "double";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        railingMaterialPreset?: string | undefined;
+        treadMaterial?: {
+            id?: string | undefined;
+            preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "front" | "back" | "double";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        treadMaterialPreset?: string | undefined;
+        sideMaterial?: {
+            id?: string | undefined;
+            preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "front" | "back" | "double";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        sideMaterialPreset?: string | undefined;
+        slots?: Record<string, string> | undefined;
+        supportSlabId?: string | undefined;
+        deckSlabId?: string | undefined;
+        totalRise?: number | undefined;
+        designTargets?: {
+            maxRiserHeight: number;
+            minimumGoing: number;
+            targetGoing: number;
+            minimumHeadroom: number;
+        } | undefined;
+        uniformRisers?: boolean | undefined;
+        construction?: {
+            mode: "solid" | "open" | "waist" | "side-stringers" | "center-stringer";
+            waistThickness: number;
+            treadThickness: number;
+            riserThickness: number;
+            nosing: number;
+            finishThickness: number;
+            closedRisers: boolean;
+            stringerWidth: number;
+            stringerDepth: number;
+        } | undefined;
+        railingStyle?: "glass" | "metal" | "balusters" | "cable" | "boards" | "post-and-rail" | undefined;
+        railingPath?: "continuous" | "original" | undefined;
+        handrail?: {
+            mode: "left" | "right" | "none" | "both";
+            height: number;
+            diameter: number;
+            offset: number;
+            bottom?: {
+                extension: number;
+                return: "wall" | "none" | "floor" | "post";
+                returnLength: number;
+            } | undefined;
+            top?: {
+                extension: number;
+                return: "wall" | "none" | "floor" | "post";
+                returnLength: number;
+            } | undefined;
+        } | undefined;
+        railingTopPost?: boolean | undefined;
+        railingTopReach?: number | undefined;
+        railingPostThrough?: boolean | undefined;
+    };
+    segments: {
+        object: "node";
+        parentId: string | null;
+        visible: boolean;
+        metadata: Record<string, unknown>;
+        id: `sseg_${string}`;
+        type: "stair-segment";
+        position: [number, number, number];
+        rotation: number;
+        segmentType: "stair" | "landing";
+        width: number;
+        length: number;
+        height: number;
+        stepCount: number;
+        attachmentSide: "front" | "left" | "right";
+        fillToFloor: boolean;
+        thickness: number;
+        name?: string | undefined;
+        camera?: {
+            position: [number, number, number];
+            target: [number, number, number];
+            mode: "perspective" | "orthographic";
+            fov?: number | undefined;
+            zoom?: number | undefined;
+        } | undefined;
+        provenance?: {
+            refs: {
+                id: string;
+                ns?: string | undefined;
+                role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+            }[];
+            lineage?: {
+                op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+                fromIds: string[];
+            } | undefined;
+        } | undefined;
+        material?: {
+            id?: string | undefined;
+            preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+            properties?: {
+                color: string;
+                roughness: number;
+                metalness: number;
+                opacity: number;
+                transparent: boolean;
+                side: "front" | "back" | "double";
+            } | undefined;
+            texture?: {
+                url: string;
+                repeat?: [number, number] | undefined;
+                scale?: number | undefined;
+            } | undefined;
+        } | undefined;
+        materialPreset?: string | undefined;
+        slots?: Record<string, string> | undefined;
+        construction?: {
+            mode: "solid" | "open" | "waist" | "side-stringers" | "center-stringer";
+            waistThickness: number;
+            treadThickness: number;
+            riserThickness: number;
+            nosing: number;
+            finishThickness: number;
+            closedRisers: boolean;
+            stringerWidth: number;
+            stringerDepth: number;
+        } | undefined;
+        winder?: {
+            turn: "left" | "right";
+            innerGap: number;
+            walkingLineOffset: number;
+            division: "equal-going" | "equal-angle";
+        } | undefined;
+    }[];
+    nodes: {
+        [k: string]: {
+            object: "node";
+            parentId: string | null;
+            visible: boolean;
+            metadata: Record<string, unknown>;
+            id: `sseg_${string}`;
+            type: "stair-segment";
+            position: [number, number, number];
+            rotation: number;
+            segmentType: "stair" | "landing";
+            width: number;
+            length: number;
+            height: number;
+            stepCount: number;
+            attachmentSide: "front" | "left" | "right";
+            fillToFloor: boolean;
+            thickness: number;
+            name?: string | undefined;
+            camera?: {
+                position: [number, number, number];
+                target: [number, number, number];
+                mode: "perspective" | "orthographic";
+                fov?: number | undefined;
+                zoom?: number | undefined;
+            } | undefined;
+            provenance?: {
+                refs: {
+                    id: string;
+                    ns?: string | undefined;
+                    role?: "primary" | "piece" | "absorbed" | "alias" | "derived" | undefined;
+                }[];
+                lineage?: {
+                    op: "import" | "split" | "merge" | "duplicate" | "convert" | "promote" | "make-independent" | "attach";
+                    fromIds: string[];
+                } | undefined;
+            } | undefined;
+            material?: {
+                id?: string | undefined;
+                preset?: "custom" | "white" | "brick" | "concrete" | "wood" | "glass" | "metal" | "plaster" | "tile" | "marble" | undefined;
+                properties?: {
+                    color: string;
+                    roughness: number;
+                    metalness: number;
+                    opacity: number;
+                    transparent: boolean;
+                    side: "front" | "back" | "double";
+                } | undefined;
+                texture?: {
+                    url: string;
+                    repeat?: [number, number] | undefined;
+                    scale?: number | undefined;
+                } | undefined;
+            } | undefined;
+            materialPreset?: string | undefined;
+            slots?: Record<string, string> | undefined;
+            construction?: {
+                mode: "solid" | "open" | "waist" | "side-stringers" | "center-stringer";
+                waistThickness: number;
+                treadThickness: number;
+                riserThickness: number;
+                nosing: number;
+                finishThickness: number;
+                closedRisers: boolean;
+                stringerWidth: number;
+                stringerDepth: number;
+            } | undefined;
+            winder?: {
+                turn: "left" | "right";
+                innerGap: number;
+                walkingLineOffset: number;
+                division: "equal-going" | "equal-angle";
+            } | undefined;
+        };
+    };
+    totalRise: number;
+};
+export type StairRenderData = ReturnType<typeof useStairRenderData>;
+//# sourceMappingURL=use-stair-render-data.d.ts.map

package/dist/stair/use-stair-render-data.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-stair-render-data.d.ts","sourceRoot":"","sources":["../../src/stair/use-stair-render-data.ts"],"names":[],"mappings":"AAEA,OAAO,EAIL,KAAK,SAAS,EAIf,MAAM,kBAAkB,CAAA;AA0BzB,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,SAAS,UAkCjD;AAED,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EAyBlD;AAED,MAAM,MAAM,eAAe,GAAG,UAAU,CAAC,OAAO,kBAAkB,CAAC,CAAA"}

package/dist/stair/use-stair-render-data.js

@@ -0,0 +1,73 @@
+'use client';
+import { resolveStairTotalRise, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { useMemo, useSyncExternalStore } from 'react';
+import { useShallow } from 'zustand/react/shallow';
+const effectiveNodesMemo = new WeakMap();
+function effectiveRiseNodes(nodes, overrides) {
+    if (!overrides.size)
+        return nodes;
+    let cache = effectiveNodesMemo.get(nodes);
+    if (!cache) {
+        cache = new WeakMap();
+        effectiveNodesMemo.set(nodes, cache);
+    }
+    const cached = cache.get(overrides);
+    if (cached)
+        return cached;
+    const effective = { ...nodes };
+    for (const [id, override] of overrides) {
+        const node = nodes[id];
+        if (node)
+            effective[id] = { ...node, ...override };
+    }
+    cache.set(overrides, effective);
+    return effective;
+}
+export function useStairTotalRise(stair) {
+    const selector = useMemo(() => {
+        let lastNodes;
+        let rise = 0;
+        const snapshot = () => {
+            if (stair.totalRise !== undefined)
+                return stair.totalRise;
+            const nodes = effectiveRiseNodes(useScene.getState().nodes, useLiveNodeOverrides.getState().overrides);
+            if (nodes !== lastNodes) {
+                rise = resolveStairTotalRise(stair, nodes);
+                lastNodes = nodes;
+            }
+            return rise;
+        };
+        const subscribe = (onChange) => {
+            let previous = snapshot();
+            const check = () => {
+                const current = snapshot();
+                if (Object.is(previous, current))
+                    return;
+                previous = current;
+                onChange();
+            };
+            const scene = useScene.subscribe(check);
+            const live = useLiveNodeOverrides.subscribe(check);
+            return () => {
+                scene();
+                live();
+            };
+        };
+        return { snapshot, subscribe };
+    }, [stair]);
+    return useSyncExternalStore(selector.subscribe, selector.snapshot, selector.snapshot);
+}
+export function useStairRenderData(stair) {
+    const children = useScene(useShallow((state) => stair.children.map((id) => state.nodes[id])));
+    const overrides = useLiveNodeOverrides(useShallow((state) => stair.children.map((id) => state.overrides.get(id))));
+    const segments = useMemo(() => children
+        .map((child, index) => {
+        const override = overrides[index];
+        return child && override ? { ...child, ...override } : child;
+    })
+        .filter((child) => child?.type === 'stair-segment'), [children, overrides]);
+    const totalRise = useStairTotalRise(stair);
+    const resolvedStair = useMemo(() => (stair.totalRise === totalRise ? stair : { ...stair, totalRise }), [stair, totalRise]);
+    const nodes = useMemo(() => Object.fromEntries(segments.map((segment) => [segment.id, segment])), [segments]);
+    return { stair: resolvedStair, segments, nodes, totalRise };
+}

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AA2F3C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAgD1E,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/stair-segment/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAOpB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,gBAAgB,EAAE,MAAM,UAAU,CAAA;AA6H3C;;;GAGG;AACH,eAAO,MAAM,sBAAsB,EAAE,cAAc,CAAC,OAAO,gBAAgB,CAuD1E,CAAA"}

package/dist/stair-segment/definition.js

@@ -1,16 +1,37 @@
-import { StairSegmentNode as StairSegmentNodeSchema, } from '@pascal-app/core';
+import { planStairFlightHeightEdit, resolveStairWinder, STAIR_BODY_SLOT_DEFAULT, STAIR_TREADS_SLOT_DEFAULT, StairSegmentNode as StairSegmentNodeSchema, } from '@pascal-app/core';
+import { stairSegmentPaint } from '../stair/paint';
 import { stairSegmentParametrics } from './parametrics';
 import { StairSegmentNode } from './schema';
 const SIDE_HANDLE_OFFSET = 0.24;
 const LENGTH_HANDLE_OFFSET = 0.24;
 const HEIGHT_HANDLE_OFFSET = 0.24;
-const MIN_SEGMENT_WIDTH = 0.4;
-const MIN_SEGMENT_LENGTH = 0.4;
-const MIN_SEGMENT_HEIGHT = 0.1;
+const MIN_SEGMENT_WIDTH = 0.001;
+const MIN_SEGMENT_LENGTH = 0.001;
+const MIN_SEGMENT_HEIGHT = 0.001;
 // Width grows symmetrically around the chain centerline — the chain owns
 // segment.position so writing a new center here would be clobbered next
 // frame by `syncSegmentMeshTransforms`. We just write `width` and let the
 // chain re-center.
+function footprintBounds(node) {
+    let footprint;
+    try {
+        footprint = resolveStairWinder(node)?.footprint;
+    }
+    catch (error) {
+        if (!(error instanceof RangeError))
+            throw error;
+    }
+    footprint ??= [
+        [-node.width / 2, 0],
+        [node.width / 2, node.length],
+    ];
+    return {
+        minX: Math.min(...footprint.map(([x]) => x)),
+        maxX: Math.max(...footprint.map(([x]) => x)),
+        minZ: Math.min(...footprint.map(([, z]) => z)),
+        maxZ: Math.max(...footprint.map(([, z]) => z)),
+    };
+}
 function stairSegmentWidthHandle(side) {
     return {
         kind: 'linear-resize',
@@ -24,9 +45,11 @@ function stairSegmentWidthHandle(side) {
         apply: (_n, newValue) => ({ width: newValue }),
         placement: {
             position: (n) => [
-                (side === 'right' ? 1 : -1) * (n.width / 2 + SIDE_HANDLE_OFFSET),
+                side === 'right'
+                    ? footprintBounds(n).maxX + SIDE_HANDLE_OFFSET
+                    : footprintBounds(n).minX - SIDE_HANDLE_OFFSET,
                 n.height / 2,
-                n.length / 2,
+                (footprintBounds(n).minZ + footprintBounds(n).maxZ) / 2,
             ],
             rotationY: () => (side === 'right' ? 0 : Math.PI),
         },
@@ -68,8 +91,21 @@ function stairSegmentHeightHandle() {
         min: MIN_SEGMENT_HEIGHT,
         currentValue: (n) => n.height,
         apply: (_n, newValue) => ({ height: newValue }),
+        previewOverrides: (node, height, scene) => planStairFlightHeightEdit(node, height, scene.nodes())
+            .slice(1)
+            .map(({ id, data }) => [id, data]),
+        commit: (node, patch, scene) => {
+            if (patch.height === undefined)
+                return;
+            const updates = planStairFlightHeightEdit(node, patch.height, scene.nodes());
+            scene.applyChanges?.({ update: updates });
+        },
         placement: {
-            position: (n) => [0, n.height + HEIGHT_HANDLE_OFFSET, n.length / 2],
+            position: (n) => [
+                (footprintBounds(n).minX + footprintBounds(n).maxX) / 2,
+                n.height + HEIGHT_HANDLE_OFFSET,
+                (footprintBounds(n).minZ + footprintBounds(n).maxZ) / 2,
+            ],
         },
         portal: 'grandparent',
     };
@@ -78,7 +114,7 @@ function stairSegmentHandles(node) {
     const handles = [
         stairSegmentWidthHandle('left'),
         stairSegmentWidthHandle('right'),
-        stairSegmentLengthHandle(),
+        ...(node.winder ? [] : [stairSegmentLengthHandle()]),
     ];
     if (node.segmentType === 'stair') {
         handles.push(stairSegmentHeightHandle());
@@ -91,7 +127,7 @@ function stairSegmentHandles(node) {
  */
 export const stairSegmentDefinition = {
     kind: 'stair-segment',
-    schemaVersion: 1,
+    schemaVersion: 2,
     schema: StairSegmentNode,
     category: 'structure',
     surfaceRole: 'joinery',
@@ -107,6 +143,11 @@ export const stairSegmentDefinition = {
         selectable: { hitVolume: 'bbox' },
         duplicable: false,
         deletable: true,
+        slots: () => [
+            { slotId: 'treads', label: 'Treads', default: STAIR_TREADS_SLOT_DEFAULT },
+            { slotId: 'body', label: 'Body', default: STAIR_BODY_SLOT_DEFAULT },
+        ],
+        paint: stairSegmentPaint,
     },
     // Bespoke move shared with roof / roof-segment / stair via
     // `shared/move-roof-tool` — routed through `MoveTool`'s registry-
@@ -116,6 +157,7 @@ export const stairSegmentDefinition = {
     },
     parametrics: stairSegmentParametrics,
     handles: stairSegmentHandles,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),
@@ -128,6 +170,6 @@ export const stairSegmentDefinition = {
         paletteOrder: 111,
     },
     mcp: {
-        description: 'A single stair flight with run + rise + tread parameters.',
+        description: 'A straight flight, landing or quarter-turn winder. Winders use an inner gap, walking-line offset and equal-going or equal-angle division; length applies only to straight flights.',
     },
 };

package/dist/stair-segment/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/stair-segment/panel.tsx"],"names":[],"mappings":"AAwCA,MAAM,CAAC,OAAO,UAAU,iBAAiB,uCAmUxC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/stair-segment/panel.tsx"],"names":[],"mappings":"AA2CA,MAAM,CAAC,OAAO,UAAU,iBAAiB,uCAqXxC"}

package/dist/stair-segment/panel.js

@@ -1,10 +1,11 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { DEFAULT_LEVEL_HEIGHT, resolveStairTotalRise, runAsSingleSceneHistoryStep, StairSegmentNode as StairSegmentNodeSchema, useScene, } from '@pascal-app/core';
-import { ActionButton, ActionGroup, PanelSection, PanelWrapper, SegmentedControl, SliderControl, ToggleControl, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { DEFAULT_LEVEL_HEIGHT, planStairFlightHeightEdit, resolveStairTotalRise, stairSegmentConstructionError, stairSegmentDetailError, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, duplicateNodeAndPickUp, PanelSection, PanelWrapper, SegmentedControl, SliderControl, ToggleControl, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Copy, Move, Trash2 } from 'lucide-react';
 import { useCallback } from 'react';
+import { StairConstructionControls } from '../stair/construction-controls';
 const SEGMENT_TYPE_OPTIONS = [
     { label: 'Flight', value: 'stair' },
     { label: 'Landing', value: 'landing' },
@@ -20,6 +21,11 @@ export default function StairSegmentPanel() {
     const updateNode = useScene((s) => s.updateNode);
     const setMovingNode = useEditor((s) => s.setMovingNode);
     const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
+    const parentStair = useScene((state) => {
+        const parent = node?.parentId ? state.nodes[node.parentId] : undefined;
+        return parent?.type === 'stair' ? parent : undefined;
+    });
+    const parentConstruction = parentStair?.construction;
     // Boolean selector — re-renders only when this segment's position among the
     // parent stair's children flips to/from "first".
     const isFirstSegment = useScene((s) => {
@@ -49,25 +55,12 @@ export default function StairSegmentPanel() {
     const handleFlightHeightChange = useCallback((height) => {
         if (!node)
             return;
-        const sceneNodes = useScene.getState().nodes;
-        const parent = node.parentId ? sceneNodes[node.parentId] : undefined;
-        if (parent?.type !== 'stair') {
-            handleUpdate({ height });
+        const scene = useScene.getState();
+        const current = scene.nodes[node.id];
+        if (current?.type !== 'stair-segment')
             return;
-        }
-        const totalRise = parent.children.reduce((sum, childId) => {
-            const child = sceneNodes[childId];
-            if (child?.type !== 'stair-segment')
-                return sum;
-            return sum + (child.id === node.id ? height : child.height);
-        }, 0);
-        runAsSingleSceneHistoryStep(useScene, () => {
-            useScene.getState().updateNodes([
-                { id: node.id, data: { height } },
-                { id: parent.id, data: { totalRise } },
-            ]);
-        });
-    }, [node, handleUpdate]);
+        scene.updateNodes(planStairFlightHeightEdit(current, height, scene.nodes));
+    }, [node]);
     // Turning a landing back into a flight seeds the rise the parent stair
     // resolves — a fixed 2.5 m stops halfway up a tall storey, and for a
     // follows-mode stair it is what `syncStairRises` would converge to anyway.
@@ -84,27 +77,9 @@ export default function StairSegmentPanel() {
         }
     }, [node?.parentId, setSelection]);
     const handleDuplicate = useCallback(() => {
-        if (!node?.parentId)
-            return;
-        triggerSFX('sfx:item-pick');
-        let duplicateInfo = structuredClone(node);
-        delete duplicateInfo.id;
-        duplicateInfo.metadata = { ...duplicateInfo.metadata, isNew: true };
-        duplicateInfo.position = [
-            duplicateInfo.position[0] + 1,
-            duplicateInfo.position[1],
-            duplicateInfo.position[2] + 1,
-        ];
-        try {
-            const duplicate = StairSegmentNodeSchema.parse(duplicateInfo);
-            useScene.getState().createNode(duplicate, duplicate.parentId);
-            setSelection({ selectedIds: [] });
-            setMovingNode(duplicate);
-        }
-        catch (e) {
-            console.error('Failed to duplicate stair segment', e);
-        }
-    }, [node, setSelection, setMovingNode]);
+        if (node)
+            duplicateNodeAndPickUp(node);
+    }, [node]);
     const handleMove = useCallback(() => {
         if (node) {
             triggerSFX('sfx:item-pick');
@@ -131,6 +106,7 @@ export default function StairSegmentPanel() {
     return (_jsxs(PanelWrapper, { icon: "/icons/stairs.webp", onBack: handleBack, onClose: handleClose, title: node.name || 'Stair Segment', width: 300, children: [_jsx(PanelSection, { title: "Type", children: _jsx(SegmentedControl, { onChange: (v) => {
                         const updates = { segmentType: v };
                         if (v === 'landing') {
+                            updates.winder = undefined;
                             updates.height = 0;
                             updates.stepCount = 0;
                             updates.length = 1.0;
@@ -141,7 +117,25 @@ export default function StairSegmentPanel() {
                             updates.length = 3.0;
                         }
                         handleUpdate(updates);
-                    }, options: SEGMENT_TYPE_OPTIONS, value: node.segmentType }) }), !isFirstSegment && (_jsx(PanelSection, { title: "Attachment", children: _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ attachmentSide: v }), options: ATTACHMENT_SIDE_OPTIONS, value: node.attachmentSide }) })), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Width", max: 1000, min: 0.5, onChange: (v) => handleUpdate({ width: v }), precision: 2, step: 0.1, unit: "m", value: node.width }), _jsx(SliderControl, { label: "Length", max: 1000, min: 0.5, onChange: (v) => handleUpdate({ length: v }), precision: 2, step: 0.1, unit: "m", value: node.length }), node.segmentType === 'stair' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Height", max: 1000, min: 0.5, onChange: handleFlightHeightChange, precision: 2, step: 0.1, unit: "m", value: node.height }), parentFollowsLevel && (_jsx("div", { className: "px-1 text-[11px] text-muted-foreground", children: "Editing switches the stair to Custom rise" })), _jsx(SliderControl, { label: "Steps", max: 30, min: 2, onChange: (v) => handleUpdate({ stepCount: Math.round(v) }), precision: 0, step: 1, unit: "", value: node.stepCount })] }))] }), _jsx(PanelSection, { title: "Structure", children: _jsxs("div", { className: "space-y-3", children: [_jsx(ToggleControl, { checked: node.fillToFloor, label: "Fill to floor", onChange: (checked) => handleUpdate({ fillToFloor: checked }) }), !node.fillToFloor && (_jsx(SliderControl, { label: "Thickness", max: 1000, min: 0.05, onChange: (v) => handleUpdate({ thickness: v }), precision: 2, step: 0.05, unit: "m", value: node.thickness ?? 0.25 }))] }) }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", onChange: (v) => {
+                    }, options: SEGMENT_TYPE_OPTIONS, value: node.segmentType }) }), !isFirstSegment && (_jsx(PanelSection, { title: "Attachment", children: _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ attachmentSide: v }), options: ATTACHMENT_SIDE_OPTIONS, value: node.attachmentSide }) })), (stairSegmentDetailError(node) ?? stairSegmentConstructionError(node, parentStair)) ? (_jsx("div", { role: "alert", className: "px-3 text-xs", children: stairSegmentDetailError(node) ?? stairSegmentConstructionError(node, parentStair) })) : null, node.segmentType === 'stair' && (_jsxs(PanelSection, { title: "Flight shape", children: [_jsx(SegmentedControl, { value: node.winder ? 'winder' : 'straight', onChange: (value) => handleUpdate({
+                            winder: value === 'winder'
+                                ? {
+                                    turn: 'left',
+                                    innerGap: 0,
+                                    walkingLineOffset: Math.min(0.5, node.width),
+                                    division: 'equal-going',
+                                }
+                                : undefined,
+                        }), options: [
+                            { label: 'Straight', value: 'straight' },
+                            { label: 'Winder', value: 'winder' },
+                        ] }), node.winder && (_jsxs(_Fragment, { children: [_jsx(SegmentedControl, { value: node.winder.turn, onChange: (turn) => handleUpdate({ winder: { ...node.winder, turn } }), options: [
+                                    { label: 'Left turn', value: 'left' },
+                                    { label: 'Right turn', value: 'right' },
+                                ] }), _jsx(SliderControl, { label: "Inner gap", unit: "m", min: 0, precision: 2, step: 0.05, value: node.winder.innerGap, onChange: (innerGap) => handleUpdate({ winder: { ...node.winder, innerGap } }) }), _jsx(SliderControl, { label: "Walking line offset", unit: "m", min: 0.001, max: node.width, precision: 2, step: 0.05, value: node.winder.walkingLineOffset, onChange: (walkingLineOffset) => handleUpdate({ winder: { ...node.winder, walkingLineOffset } }) }), _jsx(SegmentedControl, { value: node.winder.division, onChange: (division) => handleUpdate({ winder: { ...node.winder, division } }), options: [
+                                    { label: 'Equal going', value: 'equal-going' },
+                                    { label: 'Equal angle', value: 'equal-angle' },
+                                ] })] }))] })), _jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Width", min: 0.001, onChange: (v) => handleUpdate({ width: v }), precision: 2, step: 0.1, unit: "m", value: node.width }), !node.winder && (_jsx(SliderControl, { label: "Length", min: 0.001, onChange: (v) => handleUpdate({ length: v }), precision: 2, step: 0.1, unit: "m", value: node.length })), node.segmentType === 'stair' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Height", min: 0.001, onChange: handleFlightHeightChange, precision: 2, step: 0.1, unit: "m", value: node.height }), parentFollowsLevel && (_jsx("div", { className: "px-1 text-[11px] text-muted-foreground", children: "Editing switches the stair to Custom rise" })), _jsx(SliderControl, { label: "Steps", min: 2, onChange: (v) => handleUpdate({ stepCount: Math.round(v) }), precision: 0, step: 1, unit: "", value: node.stepCount })] }))] }), _jsx(PanelSection, { title: "Structure", children: _jsxs("div", { className: "space-y-3", children: [_jsx(StairConstructionControls, { node: node, inherited: parentConstruction, onChange: (construction) => handleUpdate({ construction }) }), !(node.construction ?? parentConstruction) ? (_jsx(ToggleControl, { checked: node.fillToFloor, label: "Fill to floor", onChange: (checked) => handleUpdate({ fillToFloor: checked }) })) : null, !(node.construction ?? parentConstruction) && !node.fillToFloor && (_jsx(SliderControl, { label: "Thickness", min: 0.001, onChange: (v) => handleUpdate({ thickness: v }), precision: 2, step: 0.05, unit: "m", value: node.thickness ?? 0.25 }))] }) }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", onChange: (v) => {
                             const pos = [...node.position];
                             pos[0] = v;
                             handleUpdate({ position: pos });

package/dist/stair-segment/parametrics.d.ts

@@ -1,3 +1,3 @@
-import type { ParametricDescriptor, StairSegmentNode } from '@pascal-app/core';
+import { type ParametricDescriptor, type StairSegmentNode } from '@pascal-app/core';
 export declare const stairSegmentParametrics: ParametricDescriptor<StairSegmentNode>;
 //# sourceMappingURL=parametrics.d.ts.map