@pascal-app/nodes 0.1.1

package/dist/stair/schema.d.ts

@@ -0,0 +1,2 @@
+export { StairNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/stair/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/stair/schema.js

@@ -0,0 +1 @@
+export { StairNode } from '@pascal-app/core';

package/dist/stair/slots.d.ts

@@ -0,0 +1,7 @@
+import type { SlotDeclaration, StairNode } from '@pascal-app/core';
+export type StairSlotId = 'treads' | 'body' | 'railing';
+export declare const STAIR_TREADS_SLOT_DEFAULT = "library:wood-woodplank48";
+export declare const STAIR_BODY_SLOT_DEFAULT = "library:preset-lightgrey";
+export declare const STAIR_RAILING_SLOT_DEFAULT = "library:metal-steel";
+export declare function stairSlots(node: StairNode): SlotDeclaration[];
+//# sourceMappingURL=slots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/stair/slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAElE,MAAM,MAAM,WAAW,GAAG,QAAQ,GAAG,MAAM,GAAG,SAAS,CAAA;AAEvD,eAAO,MAAM,yBAAyB,6BAA6B,CAAA;AACnE,eAAO,MAAM,uBAAuB,6BAA6B,CAAA;AACjE,eAAO,MAAM,0BAA0B,wBAAwB,CAAA;AAE/D,wBAAgB,UAAU,CAAC,IAAI,EAAE,SAAS,GAAG,eAAe,EAAE,CAW7D"}

package/dist/stair/slots.js

@@ -0,0 +1,13 @@
+export const STAIR_TREADS_SLOT_DEFAULT = 'library:wood-woodplank48';
+export const STAIR_BODY_SLOT_DEFAULT = 'library:preset-lightgrey';
+export const STAIR_RAILING_SLOT_DEFAULT = 'library:metal-steel';
+export function stairSlots(node) {
+    const slots = [
+        { slotId: 'treads', label: 'Treads', default: STAIR_TREADS_SLOT_DEFAULT },
+        { slotId: 'body', label: 'Body', default: STAIR_BODY_SLOT_DEFAULT },
+    ];
+    if (node.railingMode && node.railingMode !== 'none') {
+        slots.push({ slotId: 'railing', label: 'Railing', default: STAIR_RAILING_SLOT_DEFAULT });
+    }
+    return slots;
+}

package/dist/stair/system.d.ts

@@ -0,0 +1,3 @@
+import { StairSystem } from '@pascal-app/viewer';
+export default StairSystem;
+//# sourceMappingURL=system.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/stair/system.tsx"],"names":[],"mappings":"AAEA,OAAO,EAAE,WAAW,EAAE,MAAM,oBAAoB,CAAA;AAEhD,eAAe,WAAW,CAAA"}

package/dist/stair/system.js

@@ -0,0 +1,3 @@
+'use client';
+import { StairSystem } from '@pascal-app/viewer';
+export default StairSystem;

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

@@ -0,0 +1,8 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { StairSegmentNode } from './schema';
+/**
+ * Stair segment — Stage A. Child of a stair node; per-flight geometry.
+ * Built by `StairSystem` registered on the parent stair definition.
+ */
+export declare const stairSegmentDefinition: NodeDefinition<typeof StairSegmentNode>;
+//# sourceMappingURL=definition.d.ts.map

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

@@ -0,0 +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"}

package/dist/stair-segment/definition.js

@@ -0,0 +1,133 @@
+import { StairSegmentNode as StairSegmentNodeSchema, } from '@pascal-app/core';
+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;
+// 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 stairSegmentWidthHandle(side) {
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        // 'min' factor=+1 / 'max' factor=-1 lets each arrow grow the value
+        // when dragged outward (right edge: drag +X grows; left edge: drag -X
+        // grows). Matches the legacy `widthDelta = sign * pointerDelta`.
+        anchor: side === 'right' ? 'min' : 'max',
+        min: MIN_SEGMENT_WIDTH,
+        currentValue: (n) => n.width,
+        apply: (_n, newValue) => ({ width: newValue }),
+        placement: {
+            position: (n) => [
+                (side === 'right' ? 1 : -1) * (n.width / 2 + SIDE_HANDLE_OFFSET),
+                n.height / 2,
+                n.length / 2,
+            ],
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+        portal: 'grandparent',
+    };
+}
+// Length: segment's back-face (Z = length) anchors against the chain end,
+// so the run simply extends toward +Z as length grows. anchor='min' →
+// drag +Z grows length 1:1.
+//
+// `rotationY` is intentionally omitted. The generic linear-arrow renderer
+// already auto-rotates `axis: 'z'` chevrons by `-π/2` so the local +X tip
+// faces +Z (see `axisRotationY` in `node-arrow-handles.tsx`). Adding our
+// own `-π/2` here stacks to `-π`, which spins the tip to `-X` and the
+// chevron reads as sideways across the front edge instead of pointing
+// forward off the run. Shelf / roof-segment depth handles match this —
+// neither sets `rotationY` for their `axis: 'z'` arrow.
+function stairSegmentLengthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        anchor: 'min',
+        min: MIN_SEGMENT_LENGTH,
+        currentValue: (n) => n.length,
+        apply: (_n, newValue) => ({ length: newValue }),
+        placement: {
+            position: (n) => [0, n.height / 2, n.length + LENGTH_HANDLE_OFFSET],
+        },
+        portal: 'grandparent',
+    };
+}
+// Height applies only to step-flight segments (landings are flat). The
+// segment's floor is at Y=0; dragging the top grows height upward.
+function stairSegmentHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_SEGMENT_HEIGHT,
+        currentValue: (n) => n.height,
+        apply: (_n, newValue) => ({ height: newValue }),
+        placement: {
+            position: (n) => [0, n.height + HEIGHT_HANDLE_OFFSET, n.length / 2],
+        },
+        portal: 'grandparent',
+    };
+}
+function stairSegmentHandles(node) {
+    const handles = [
+        stairSegmentWidthHandle('left'),
+        stairSegmentWidthHandle('right'),
+        stairSegmentLengthHandle(),
+    ];
+    if (node.segmentType === 'stair') {
+        handles.push(stairSegmentHeightHandle());
+    }
+    return handles;
+}
+/**
+ * Stair segment — Stage A. Child of a stair node; per-flight geometry.
+ * Built by `StairSystem` registered on the parent stair definition.
+ */
+export const stairSegmentDefinition = {
+    kind: 'stair-segment',
+    schemaVersion: 1,
+    schema: StairSegmentNode,
+    category: 'structure',
+    surfaceRole: 'joinery',
+    defaults: () => {
+        const stub = StairSegmentNodeSchema.parse({
+            id: 'stair-segment_default',
+            type: 'stair-segment',
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: false,
+        deletable: true,
+    },
+    // Bespoke move shared with roof / roof-segment / stair via
+    // `shared/move-roof-tool` — routed through `MoveTool`'s registry-
+    // affordance lookup rather than a hardcoded dispatcher arm.
+    affordanceTools: {
+        move: () => import('../shared/move-roof-tool'),
+    },
+    parametrics: stairSegmentParametrics,
+    handles: stairSegmentHandles,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    presentation: {
+        label: 'Stair Segment',
+        description: 'A single flight of a parent stair.',
+        icon: { kind: 'url', src: '/icons/stairs.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 111,
+    },
+    mcp: {
+        description: 'A single stair flight with run + rise + tread parameters.',
+    },
+};

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/stair-segment/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,sBAAsB,EAAE,MAAM,cAAc,CAAA"}

package/dist/stair-segment/index.js

@@ -0,0 +1 @@
+export { stairSegmentDefinition } from './definition';

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

@@ -0,0 +1,2 @@
+export default function StairSegmentPanel(): import("react").JSX.Element | null;
+//# sourceMappingURL=panel.d.ts.map

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

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

package/dist/stair-segment/panel.js

@@ -0,0 +1,126 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { StairSegmentNode as StairSegmentNodeSchema, useScene, } from '@pascal-app/core';
+import { ActionButton, ActionGroup, 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';
+const SEGMENT_TYPE_OPTIONS = [
+    { label: 'Flight', value: 'stair' },
+    { label: 'Landing', value: 'landing' },
+];
+const ATTACHMENT_SIDE_OPTIONS = [
+    { label: 'Front', value: 'front' },
+    { label: 'Left', value: 'left' },
+    { label: 'Right', value: 'right' },
+];
+export default function StairSegmentPanel() {
+    const selectedId = useViewer((s) => s.selection.selectedIds[0]);
+    const setSelection = useViewer((s) => s.setSelection);
+    const updateNode = useScene((s) => s.updateNode);
+    const setMovingNode = useEditor((s) => s.setMovingNode);
+    const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
+    // Boolean selector — re-renders only when this segment's position among the
+    // parent stair's children flips to/from "first".
+    const isFirstSegment = useScene((s) => {
+        if (!node?.parentId)
+            return true;
+        const parent = s.nodes[node.parentId];
+        if (parent?.type !== 'stair')
+            return true;
+        const children = parent.children ?? [];
+        return children[0] === node.id;
+    });
+    const handleUpdate = useCallback((updates) => {
+        if (!selectedId)
+            return;
+        updateNode(selectedId, updates);
+    }, [selectedId, updateNode]);
+    const handleClose = useCallback(() => {
+        setSelection({ selectedIds: [] });
+    }, [setSelection]);
+    const handleBack = useCallback(() => {
+        if (node?.parentId) {
+            setSelection({ selectedIds: [node.parentId] });
+        }
+    }, [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]);
+    const handleMove = useCallback(() => {
+        if (node) {
+            triggerSFX('sfx:item-pick');
+            setMovingNode(node);
+            setSelection({ selectedIds: [] });
+        }
+    }, [node, setMovingNode, setSelection]);
+    const handleDelete = useCallback(() => {
+        if (!(selectedId && node))
+            return;
+        triggerSFX('sfx:item-delete');
+        const parentId = node.parentId;
+        useScene.getState().deleteNode(selectedId);
+        if (parentId) {
+            useScene.getState().dirtyNodes.add(parentId);
+            setSelection({ selectedIds: [parentId] });
+        }
+        else {
+            setSelection({ selectedIds: [] });
+        }
+    }, [selectedId, node, setSelection]);
+    if (!(node && node.type === 'stair-segment' && selectedId))
+        return null;
+    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.height = 0;
+                            updates.stepCount = 0;
+                            updates.length = 1.0;
+                        }
+                        else {
+                            updates.height = 2.5;
+                            updates.stepCount = 10;
+                            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: 5, min: 0.5, onChange: (v) => handleUpdate({ width: v }), precision: 2, step: 0.1, unit: "m", value: Math.round(node.width * 100) / 100 }), _jsx(SliderControl, { label: "Length", max: 10, min: 0.5, onChange: (v) => handleUpdate({ length: v }), precision: 2, step: 0.1, unit: "m", value: Math.round(node.length * 100) / 100 }), node.segmentType === 'stair' && (_jsxs(_Fragment, { children: [_jsx(SliderControl, { label: "Height", max: 10, min: 0.5, onChange: (v) => handleUpdate({ height: v }), precision: 2, step: 0.1, unit: "m", value: Math.round(node.height * 100) / 100 }), _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: 1, min: 0.05, onChange: (v) => handleUpdate({ thickness: v }), precision: 2, step: 0.05, unit: "m", value: Math.round((node.thickness ?? 0.25) * 100) / 100 }))] }) }), _jsxs(PanelSection, { title: "Position", children: [_jsx(SliderControl, { label: "X", max: 50, min: -50, onChange: (v) => {
+                            const pos = [...node.position];
+                            pos[0] = v;
+                            handleUpdate({ position: pos });
+                        }, precision: 2, step: 0.05, unit: "m", value: Math.round(node.position[0] * 100) / 100 }), _jsx(SliderControl, { label: "Y", max: 50, min: -50, onChange: (v) => {
+                            const pos = [...node.position];
+                            pos[1] = v;
+                            handleUpdate({ position: pos });
+                        }, precision: 2, step: 0.05, unit: "m", value: Math.round(node.position[1] * 100) / 100 }), _jsx(SliderControl, { label: "Z", max: 50, min: -50, onChange: (v) => {
+                            const pos = [...node.position];
+                            pos[2] = v;
+                            handleUpdate({ position: pos });
+                        }, precision: 2, step: 0.05, unit: "m", value: Math.round(node.position[2] * 100) / 100 }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (degrees) => {
+                            handleUpdate({ rotation: (degrees * Math.PI) / 180 });
+                        }, precision: 0, step: 1, unit: "\u00B0", value: Math.round((node.rotation * 180) / Math.PI) }), _jsxs("div", { className: "flex gap-1.5 px-1 pt-2 pb-1", children: [_jsx(ActionButton, { label: "-45\u00B0", onClick: () => {
+                                    triggerSFX('sfx:item-rotate');
+                                    handleUpdate({ rotation: node.rotation - Math.PI / 4 });
+                                } }), _jsx(ActionButton, { label: "+45\u00B0", onClick: () => {
+                                    triggerSFX('sfx:item-rotate');
+                                    handleUpdate({ rotation: node.rotation + Math.PI / 4 });
+                                } })] })] }), _jsx(PanelSection, { title: "Actions", children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: "Duplicate", onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-400" }), label: "Delete", onClick: handleDelete })] }) })] }));
+}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/stair-segment/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA;AAE9E,eAAO,MAAM,uBAAuB,EAAE,oBAAoB,CAAC,gBAAgB,CAG1E,CAAA"}

package/dist/stair-segment/parametrics.js

@@ -0,0 +1,4 @@
+export const stairSegmentParametrics = {
+    groups: [],
+    customPanel: () => import('./panel'),
+};

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

@@ -0,0 +1,6 @@
+import { type StairSegmentNode } from '@pascal-app/core';
+export declare const StairSegmentRenderer: ({ node }: {
+    node: StairSegmentNode;
+}) => import("react").JSX.Element;
+export default StairSegmentRenderer;
+//# sourceMappingURL=renderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/stair-segment/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,gBAAgB,EAGtB,MAAM,kBAAkB,CAAA;AAMzB,eAAO,MAAM,oBAAoB,GAAI,UAAU;IAAE,IAAI,EAAE,gBAAgB,CAAA;CAAE,gCAgExE,CAAA;AAED,eAAe,oBAAoB,CAAA"}

package/dist/stair-segment/renderer.js

@@ -0,0 +1,55 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useRegistry, useScene, } from '@pascal-app/core';
+import { getStraightStairSegmentBodyMaterials, useNodeEvents, useViewer } from '@pascal-app/viewer';
+import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
+import { createPlaceholderGeometry } from '../shared/placeholder-geometry';
+export const StairSegmentRenderer = ({ node }) => {
+    const ref = useRef(null);
+    const nodes = useScene((state) => state.nodes);
+    useRegistry(node.id, 'stair-segment', ref);
+    useLayoutEffect(() => {
+        useScene.getState().markDirty(node.id);
+    }, [node.id]);
+    const handlers = useNodeEvents(node, 'stair-segment');
+    const shading = useViewer((s) => s.shading);
+    const textures = useViewer((s) => s.textures);
+    const colorPreset = useViewer((s) => s.colorPreset);
+    const parentNode = node.parentId
+        ? nodes[node.parentId]
+        : undefined;
+    const material = useMemo(() => {
+        return getStraightStairSegmentBodyMaterials(node, parentNode, shading, textures, colorPreset);
+    }, [
+        shading,
+        textures,
+        colorPreset,
+        node.materialPreset,
+        node.material,
+        node.material?.preset,
+        node.material?.properties,
+        node.material?.texture,
+        parentNode?.materialPreset,
+        parentNode?.material,
+        parentNode?.material?.preset,
+        parentNode?.material?.properties,
+        parentNode?.material?.texture,
+        parentNode?.railingMaterialPreset,
+        parentNode?.railingMaterial,
+        parentNode?.sideMaterialPreset,
+        parentNode?.sideMaterial,
+        parentNode?.treadMaterialPreset,
+        parentNode?.treadMaterial,
+        node,
+        parentNode,
+    ]);
+    // 2 groups map 1:1 to the stair segment's 2-material array (body + tread).
+    const placeholderGeometry = useMemo(() => createPlaceholderGeometry(2), []);
+    useEffect(() => {
+        return () => {
+            placeholderGeometry.dispose();
+        };
+    }, [placeholderGeometry]);
+    return (_jsx("mesh", { geometry: placeholderGeometry, material: material, position: node.position, ref: ref, "rotation-y": node.rotation, visible: node.visible, ...handlers }));
+};
+export default StairSegmentRenderer;

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

@@ -0,0 +1,2 @@
+export { StairSegmentNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/stair-segment/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/stair-segment/schema.js

@@ -0,0 +1 @@
+export { StairSegmentNode } from '@pascal-app/core';

package/dist/turbine-vent/definition.d.ts

@@ -0,0 +1,24 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { TurbineVentNode } from './schema';
+/**
+ * Turbine vent (whirlybird) — a wind-driven spinning exhaust vent that
+ * sits on a roof slope. Parented to a `roof-segment`; position is
+ * segment-local; rotation rotates the vent around the segment's vertical
+ * axis after the slope tilt is applied.
+ *
+ * Composition (three-checkbox model):
+ *  - **`renderer` (custom)** — like the box vent, the turbine needs the
+ *    parent segment's transform + slope to position itself, which the
+ *    registry-era roof-segment renderer doesn't auto-nest. The custom
+ *    renderer reads the segment from `useScene`, applies the transform
+ *    stack, and — uniquely among vents — drives the head's idle spin via
+ *    `useFrame`. The spin lives in the renderer (not a `def.system`)
+ *    because it's purely cosmetic: no cross-node cascade, no shared
+ *    animation state, and it must not perturb the handle frame.
+ *  - **no `geometry`** — geometry is created inside the renderer via the
+ *    shared pure builders in `./geometry` (split base / head so the head
+ *    can spin independently), matching box-vent's mount semantics.
+ *  - **no `system`** — see above; the spin is renderer-local.
+ */
+export declare const turbineVentDefinition: NodeDefinition<typeof TurbineVentNode>;
+//# sourceMappingURL=definition.d.ts.map

package/dist/turbine-vent/definition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAIzB,OAAO,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAoD1C;;;;;;;;;;;;;;;;;;;GAmBG;AACH,eAAO,MAAM,qBAAqB,EAAE,cAAc,CAAC,OAAO,eAAe,CAwDxE,CAAA"}

package/dist/turbine-vent/definition.js

@@ -0,0 +1,119 @@
+import { TurbineVentNode as TurbineVentNodeSchema, } from '@pascal-app/core';
+import { surfacePaintCapability } from '../shared/surface-paint';
+import { buildTurbineVentFloorplan } from './floorplan';
+import { turbineVentParametrics } from './parametrics';
+import { TurbineVentNode } from './schema';
+const SIDE_HANDLE_OFFSET = 0.25;
+const HEIGHT_HANDLE_OFFSET = 0.2;
+const MIN_DIM = 0.12;
+const MIN_HEIGHT = 0.12;
+function getBodyMidY(n) {
+    return Math.max(0.001, n.height) / 2;
+}
+// Diameter arrow on the +X side. The turbine is radially symmetric, so a
+// single symmetric chevron (anchor 'center') grows the whole head from
+// the centre — no left/right asymmetry to preserve.
+function turbineVentDiameterHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: 'center',
+        min: MIN_DIM,
+        currentValue: (n) => n.diameter,
+        apply: (_n, newValue) => ({ diameter: Math.max(MIN_DIM, newValue) }),
+        placement: {
+            position: (n) => [n.diameter / 2 + SIDE_HANDLE_OFFSET, getBodyMidY(n), 0],
+        },
+    };
+}
+// Height arrow above the top. anchor='min' pins the flange base to the
+// slope at vent-local y=0 and the top follows the pointer.
+function turbineVentHeightHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_HEIGHT,
+        currentValue: (n) => n.height,
+        apply: (_n, newValue) => ({ height: Math.max(MIN_HEIGHT, newValue) }),
+        placement: {
+            position: (n) => [0, Math.max(n.height, MIN_HEIGHT) + HEIGHT_HANDLE_OFFSET, 0],
+        },
+    };
+}
+// `portal: 'grandparent'` on every handle — see box-vent's note. The vent
+// rides the roof→segment→node frame chain, so the handle rig must too, or
+// the handles render offset from the vent.
+const turbineVentHandles = [
+    turbineVentDiameterHandle(),
+    turbineVentHeightHandle(),
+].map((h) => ({ ...h, portal: 'grandparent' }));
+/**
+ * Turbine vent (whirlybird) — a wind-driven spinning exhaust vent that
+ * sits on a roof slope. Parented to a `roof-segment`; position is
+ * segment-local; rotation rotates the vent around the segment's vertical
+ * axis after the slope tilt is applied.
+ *
+ * Composition (three-checkbox model):
+ *  - **`renderer` (custom)** — like the box vent, the turbine needs the
+ *    parent segment's transform + slope to position itself, which the
+ *    registry-era roof-segment renderer doesn't auto-nest. The custom
+ *    renderer reads the segment from `useScene`, applies the transform
+ *    stack, and — uniquely among vents — drives the head's idle spin via
+ *    `useFrame`. The spin lives in the renderer (not a `def.system`)
+ *    because it's purely cosmetic: no cross-node cascade, no shared
+ *    animation state, and it must not perturb the handle frame.
+ *  - **no `geometry`** — geometry is created inside the renderer via the
+ *    shared pure builders in `./geometry` (split base / head so the head
+ *    can spin independently), matching box-vent's mount semantics.
+ *  - **no `system`** — see above; the spin is renderer-local.
+ */
+export const turbineVentDefinition = {
+    kind: 'turbine-vent',
+    schemaVersion: 1,
+    schema: TurbineVentNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = TurbineVentNodeSchema.parse({ id: 'tvent_default', type: 'turbine-vent' });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Single painted surface — registry-driven paint dispatch (see chimney).
+        paint: surfacePaintCapability,
+        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
+        // slope — no `buildCut`, just the dirty cascade so the parent roof's
+        // merged shell rebuilds when the vent moves / resizes.
+        roofAccessory: {},
+    },
+    parametrics: turbineVentParametrics,
+    handles: turbineVentHandles,
+    floorplan: buildTurbineVentFloorplan,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    preview: () => import('./preview'),
+    tool: () => import('./tool'),
+    affordanceTools: {
+        move: () => import('./move-tool'),
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place turbine vent on roof' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+    presentation: {
+        label: 'Turbine Vent',
+        description: 'Wind-driven spinning whirlybird exhaust vent for a roof slope.',
+        icon: { kind: 'url', src: '/icons/roof.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 121,
+    },
+    mcp: {
+        description: 'A spinning turbine (whirlybird) vent on a roof segment. Style: globe / cylinder. Parametric diameter/height/neckHeight/vaneCount and idle spinSpeed.',
+    },
+};

package/dist/turbine-vent/floorplan.d.ts

@@ -0,0 +1,13 @@
+import type { FloorplanGeometry, GeometryContext, TurbineVentNode } from '@pascal-app/core';
+/**
+ * Floor-plan builder for a turbine vent — seen from above it reads as the
+ * round flange flashing with the head circle inside and short radial ticks
+ * suggesting the vanes.
+ *
+ * Coordinate frame mirrors the 3D transform stack
+ * (roof → roof-segment → vent), same as the box-vent builder. `position`
+ * is segment-local; `rotation` is yaw; rotations are negated for the floor
+ * plan's y-down convention.
+ */
+export declare function buildTurbineVentFloorplan(node: TurbineVentNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

package/dist/turbine-vent/floorplan.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iBAAiB,EAEjB,eAAe,EAGf,eAAe,EAChB,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;GASG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,eAAe,EACrB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+G1B"}