@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/stair-segment/panel.js

@@ -1,21 +1,25 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { DEFAULT_LEVEL_HEIGHT, planStairFlightHeightEdit, resolveStairTotalRise, stairSegmentConstructionError, stairSegmentDetailError, useScene, } from '@pascal-app/core';
+import { DEFAULT_LEVEL_HEIGHT, planStairFlightHeightEdit, resolveStairTotalRise, stairSegmentConstructionError, stairSegmentDetailError, usePascalI18n, 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.js';
 const SEGMENT_TYPE_OPTIONS = [
-    { label: 'Flight', value: 'stair' },
-    { label: 'Landing', value: 'landing' },
+    { label: /* i18n */ { id: 'node.stairSegment.panel.flight', message: 'Flight' }, value: 'stair' },
+    {
+        label: /* i18n */ { id: 'node.stairSegment.panel.landing', message: 'Landing' },
+        value: 'landing',
+    },
 ];
 const ATTACHMENT_SIDE_OPTIONS = [
-    { label: 'Front', value: 'front' },
-    { label: 'Left', value: 'left' },
-    { label: 'Right', value: 'right' },
+    { label: /* i18n */ { id: 'node.stairSegment.panel.front', message: 'Front' }, value: 'front' },
+    { label: /* i18n */ { id: 'node.stairSegment.panel.left', message: 'Left' }, value: 'left' },
+    { label: /* i18n */ { id: 'node.stairSegment.panel.right', message: 'Right' }, value: 'right' },
 ];
 export default function StairSegmentPanel() {
+    const i18n = usePascalI18n();
     const selectedId = useViewer((s) => s.selection.selectedIds[0]);
     const setSelection = useViewer((s) => s.setSelection);
     const updateNode = useScene((s) => s.updateNode);
@@ -103,7 +107,8 @@ export default function StairSegmentPanel() {
     }, [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) => {
+    return (_jsxs(PanelWrapper, { icon: "/icons/stairs.webp", onBack: handleBack, onClose: handleClose, title: node.name ||
+            i18n._({ id: 'node.stairSegment.panel.stairSegment', message: 'Stair Segment' }), width: 300, children: [_jsx(PanelSection, { title: i18n._({ id: 'node.stairSegment.panel.type', message: 'Type' }), children: _jsx(SegmentedControl, { onChange: (v) => {
                         const updates = { segmentType: v };
                         if (v === 'landing') {
                             updates.winder = undefined;
@@ -117,7 +122,13 @@ 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 }) })), (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({
+                    }, options: SEGMENT_TYPE_OPTIONS.map((option) => ({
+                        ...option,
+                        label: i18n._(option.label),
+                    })), value: node.segmentType }) }), !isFirstSegment && (_jsx(PanelSection, { title: i18n._({ id: 'node.stairSegment.panel.attachment', message: 'Attachment' }), children: _jsx(SegmentedControl, { onChange: (v) => handleUpdate({ attachmentSide: v }), options: ATTACHMENT_SIDE_OPTIONS.map((option) => ({
+                        ...option,
+                        label: i18n._(option.label),
+                    })), 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: i18n._({ id: 'node.stairSegment.panel.flightShape', message: 'Flight shape' }), children: [_jsx(SegmentedControl, { value: node.winder ? 'winder' : 'straight', onChange: (value) => handleUpdate({
                             winder: value === 'winder'
                                 ? {
                                     turn: 'left',
@@ -127,15 +138,51 @@ export default function StairSegmentPanel() {
                                 }
                                 : undefined,
                         }), options: [
-                            { label: 'Straight', value: 'straight' },
-                            { label: 'Winder', value: 'winder' },
+                            {
+                                label: i18n._({ id: 'node.stairSegment.panel.straight', message: 'Straight' }),
+                                value: 'straight',
+                            },
+                            {
+                                label: i18n._({ id: 'node.stairSegment.panel.winder', message: '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) => {
+                                    {
+                                        label: i18n._({ id: 'node.stairSegment.panel.leftTurn', message: 'Left turn' }),
+                                        value: 'left',
+                                    },
+                                    {
+                                        label: i18n._({
+                                            id: 'node.stairSegment.panel.rightTurn',
+                                            message: 'Right turn',
+                                        }),
+                                        value: 'right',
+                                    },
+                                ] }), _jsx(SliderControl, { label: i18n._({ id: 'node.stairSegment.panel.innerGap', message: '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: i18n._({
+                                    id: 'node.stairSegment.panel.walkingLineOffset',
+                                    message: '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: i18n._({
+                                            id: 'node.stairSegment.panel.equalGoing',
+                                            message: 'Equal going',
+                                        }),
+                                        value: 'equal-going',
+                                    },
+                                    {
+                                        label: i18n._({
+                                            id: 'node.stairSegment.panel.equalAngle',
+                                            message: 'Equal angle',
+                                        }),
+                                        value: 'equal-angle',
+                                    },
+                                ] })] }))] })), _jsxs(PanelSection, { title: i18n._({ id: 'node.stairSegment.panel.dimensions', message: 'Dimensions' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.stairSegment.panel.width', message: 'Width' }), min: 0.001, onChange: (v) => handleUpdate({ width: v }), precision: 2, step: 0.1, unit: "m", value: node.width }), !node.winder && (_jsx(SliderControl, { label: i18n._({ id: 'node.stairSegment.panel.length', message: '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: i18n._({ id: 'node.stairSegment.panel.height', message: '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: i18n._({
+                                    id: 'node.stairSegment.panel.editingSwitchesTheStairToCustom',
+                                    message: 'Editing switches the stair to Custom rise',
+                                }) })), _jsx(SliderControl, { label: i18n._({ id: 'node.stairSegment.panel.steps', message: 'Steps' }), min: 2, onChange: (v) => handleUpdate({ stepCount: Math.round(v) }), precision: 0, step: 1, unit: "", value: node.stepCount })] }))] }), _jsx(PanelSection, { title: i18n._({ id: 'node.stairSegment.panel.structure', message: '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: i18n._({
+                                id: 'node.stairSegment.panel.fillToFloor',
+                                message: 'Fill to floor',
+                            }), onChange: (checked) => handleUpdate({ fillToFloor: checked }) })) : null, !(node.construction ?? parentConstruction) && !node.fillToFloor && (_jsx(SliderControl, { label: i18n._({ id: 'node.stairSegment.panel.thickness', message: 'Thickness' }), min: 0.001, onChange: (v) => handleUpdate({ thickness: v }), precision: 2, step: 0.05, unit: "m", value: node.thickness ?? 0.25 }))] }) }), _jsxs(PanelSection, { title: i18n._({ id: 'node.stairSegment.panel.position', message: 'Position' }), children: [_jsx(SliderControl, { label: "X", onChange: (v) => {
                             const pos = [...node.position];
                             pos[0] = v;
                             handleUpdate({ position: pos });
@@ -147,7 +194,7 @@ export default function StairSegmentPanel() {
                             const pos = [...node.position];
                             pos[2] = v;
                             handleUpdate({ position: pos });
-                        }, precision: 2, step: 0.05, unit: "m", value: node.position[2] }), _jsx(SliderControl, { label: "Rotation", max: 180, min: -180, onChange: (degrees) => {
+                        }, precision: 2, step: 0.05, unit: "m", value: node.position[2] }), _jsx(SliderControl, { label: i18n._({ id: 'node.stairSegment.panel.rotation', message: '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');
@@ -155,5 +202,5 @@ export default function StairSegmentPanel() {
                                 } }), _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-600 dark:text-red-400" }), label: "Delete", onClick: handleDelete })] }) })] }));
+                                } })] })] }), _jsx(PanelSection, { title: i18n._({ id: 'node.stairSegment.panel.actions', message: 'Actions' }), children: _jsxs(ActionGroup, { children: [_jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: i18n._({ id: 'node.stairSegment.panel.move', message: 'Move' }), onClick: handleMove }), _jsx(ActionButton, { icon: _jsx(Copy, { className: "h-3.5 w-3.5" }), label: i18n._({ id: 'node.stairSegment.panel.duplicate', message: 'Duplicate' }), onClick: handleDuplicate }), _jsx(ActionButton, { className: "hover:bg-red-500/20", icon: _jsx(Trash2, { className: "h-3.5 w-3.5 text-red-600 dark:text-red-400" }), label: i18n._({ id: 'node.stairSegment.panel.delete', message: 'Delete' }), onClick: handleDelete })] }) })] }));
 }

package/dist/structural-grid/definition.d.ts

@@ -1,4 +1,51 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { StructuralGridNode } from './schema.js';
-export declare const structuralGridDefinition: NodeDefinition<typeof StructuralGridNode>;
+export declare const structuralGridDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`structural-grid_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"structural-grid">>;
+    start: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    end: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    label: import("zod").ZodDefault<import("zod").ZodString>;
+    showStartBubble: import("zod").ZodDefault<import("zod").ZodBoolean>;
+    showEndBubble: import("zod").ZodDefault<import("zod").ZodBoolean>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

package/dist/structural-grid/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/structural-grid/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AAGtD,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAE7C,eAAO,MAAM,wBAAwB,EAAE,cAAc,CAAC,OAAO,kBAAkB,CAsD9E,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/structural-grid/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,wBAAwB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGpC,CAAA"}

package/dist/structural-grid/definition.edit.d.ts

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { StructuralGridNode } from './schema.js';
+export declare const structuralGridEditContribution: NodeEditContribution<typeof StructuralGridNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

package/dist/structural-grid/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/structural-grid/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAElD,eAAO,MAAM,8BAA8B,EAAE,oBAAoB,CAAC,OAAO,kBAAkB,CAgB1F,CAAA"}

package/dist/structural-grid/definition.edit.js

@@ -0,0 +1,18 @@
+import { buildStructuralGridFloorplan } from './floorplan.js';
+export const structuralGridEditContribution = {
+    extensions: {
+        'pascal:editor/floorplan': {
+            tool: () => import('./floorplan-tool.js'),
+            availableModes: ['expert'],
+            preferredView: '2d',
+        },
+    },
+    snapProfile: 'structural',
+    floorplan: buildStructuralGridFloorplan,
+    toolHints: [
+        { key: 'Left click', label: 'Start grid axis' },
+        { key: 'Left click', label: 'Finish grid axis' },
+        { key: 'Alt', label: 'Bypass snapping' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};

package/dist/structural-grid/definition.js

@@ -1,51 +1,4 @@
-import { buildStructuralGridFloorplan } from './floorplan.js';
-import { StructuralGridNode } from './schema.js';
-export const structuralGridDefinition = {
-    kind: 'structural-grid',
-    bake: 'strip',
-    schemaVersion: 1,
-    schema: StructuralGridNode,
-    category: 'structure',
-    extensions: {
-        'pascal:editor/floorplan': {
-            tool: () => import('./floorplan-tool.js'),
-            availableModes: ['expert'],
-            preferredView: '2d',
-        },
-    },
-    snapProfile: 'structural',
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        start: [0, 0],
-        end: [0, 5],
-        label: '1',
-        showStartBubble: true,
-        showEndBubble: true,
-    }),
-    capabilities: {
-        selectable: { hitVolume: 'bbox' },
-        deletable: true,
-        presettable: false,
-    },
-    dirtyTracking: false,
-    floorplan: buildStructuralGridFloorplan,
-    toolHints: [
-        { key: 'Left click', label: 'Start grid axis' },
-        { key: 'Left click', label: 'Finish grid axis' },
-        { key: 'Alt', label: 'Bypass snapping' },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Structural Grid',
-        description: 'Persistent construction grid axis with identification bubbles.',
-        icon: { kind: 'url', src: '/icons/structural-grid.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 72,
-    },
-    mcp: {
-        description: 'A floor-plan structural datum axis defined by two level-local points and a grid identifier.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { structuralGridEditContribution } from './definition.edit.js';
+import { structuralGridRenderDefinition } from './definition.render.js';
+export const structuralGridDefinition = composeNodeDefinition(structuralGridRenderDefinition, structuralGridEditContribution);

package/dist/structural-grid/definition.render.d.ts

@@ -0,0 +1,6 @@
+import type { NodeRenderDefinition } from '../definition-contributions.js';
+import { StructuralGridNode } from './schema.js';
+export declare const structuralGridRenderDefinition: NodeRenderDefinition<typeof StructuralGridNode> & {
+    kind: 'structural-grid';
+};
+//# sourceMappingURL=definition.render.d.ts.map

package/dist/structural-grid/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/structural-grid/definition.render.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,kBAAkB,EAAE,MAAM,UAAU,CAAA;AAE7C,eAAO,MAAM,8BAA8B,EAAE,oBAAoB,CAAC,OAAO,kBAAkB,CAAC,GAAG;IAC7F,IAAI,EAAE,iBAAiB,CAAA;CAmCxB,CAAA"}

package/dist/structural-grid/definition.render.js

@@ -0,0 +1,35 @@
+import { StructuralGridNode } from './schema.js';
+export const structuralGridRenderDefinition = {
+    kind: 'structural-grid',
+    bake: 'strip',
+    schemaVersion: 1,
+    schema: StructuralGridNode,
+    category: 'structure',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        start: [0, 0],
+        end: [0, 5],
+        label: '1',
+        showStartBubble: true,
+        showEndBubble: true,
+    }),
+    capabilities: {
+        selectable: { hitVolume: 'bbox' },
+        deletable: true,
+        presettable: false,
+    },
+    dirtyTracking: false,
+    presentation: {
+        label: 'Structural Grid',
+        description: 'Persistent construction grid axis with identification bubbles.',
+        icon: { kind: 'url', src: '/icons/structural-grid.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 72,
+    },
+    mcp: {
+        description: 'A floor-plan structural datum axis defined by two level-local points and a grid identifier.',
+    },
+};

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

@@ -1,24 +1,98 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { TurbineVentNode } from './schema.js';
-/**
- * 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>;
+export declare const turbineVentDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`tvent_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"turbine-vent">>;
+    material: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    slots: import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodString>>;
+    materialPreset: import("zod").ZodDefault<import("zod").ZodString>;
+    roofSegmentId: import("zod").ZodOptional<import("zod").ZodString>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    diameter: import("zod").ZodDefault<import("zod").ZodNumber>;
+    height: import("zod").ZodDefault<import("zod").ZodNumber>;
+    neckHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    baseOverhang: import("zod").ZodDefault<import("zod").ZodNumber>;
+    vaneCount: import("zod").ZodDefault<import("zod").ZodNumber>;
+    spinSpeed: import("zod").ZodDefault<import("zod").ZodNumber>;
+    style: import("zod").ZodDefault<import("zod").ZodEnum<{
+        cylinder: "cylinder";
+        globe: "globe";
+    }>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

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

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

@@ -0,0 +1,4 @@
+import type { NodeEditContribution } from '../definition-contributions.js';
+import type { TurbineVentNode } from './schema.js';
+export declare const turbineVentEditContribution: NodeEditContribution<typeof TurbineVentNode>;
+//# sourceMappingURL=definition.edit.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/turbine-vent/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAIvE,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,UAAU,CAAA;AAuD/C,eAAO,MAAM,2BAA2B,EAAE,oBAAoB,CAAC,OAAO,eAAe,CAiBpF,CAAA"}

package/dist/turbine-vent/definition.edit.js

@@ -0,0 +1,66 @@
+import { buildTurbineVentFloorplan } from './floorplan.js';
+import { turbineVentPaint } from './paint.js';
+import { turbineVentParametrics } from './parametrics.js';
+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' }));
+export const turbineVentEditContribution = {
+    snapProfile: 'item',
+    capabilities: {
+        paint: turbineVentPaint,
+    },
+    parametrics: turbineVentParametrics,
+    handles: turbineVentHandles,
+    floorplan: buildTurbineVentFloorplan,
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place turbine vent on roof' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};