@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/slab/panel.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/slab/panel.tsx"],"names":[],"mappings":"AAwCA;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,uCA0cxB;eAEc,SAAS"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/slab/panel.tsx"],"names":[],"mappings":"AA+CA;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,uCA8hBxB;eA0Bc,SAAS"}

package/dist/slab/panel.js

@@ -1,7 +1,8 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { isDerivedNode, MIN_SLAB_THICKNESS, useScene, } from '@pascal-app/core';
-import { ActionButton, ActionGroup, FloorFoundationPanel, holeEditScope, PanelSection, PanelWrapper, SegmentedControl, ShapeChoice, SliderControl, startOpeningDraft, triggerSFX, useEditingHole, useEditor, useInteractionScope, } from '@pascal-app/editor';
+import { formatAreaLabel, formatFixed, getAreaUnitLabel, isDerivedNode, MIN_SLAB_THICKNESS, squareMetersToAreaUnit, usePascalI18n, useScene, } from '@pascal-app/core';
+import { setSlabSurfaceScript } from '@pascal-app/core/agent-operations';
+import { ActionButton, ActionGroup, FloorFoundationPanel, holeEditScope, PanelSection, PanelWrapper, ScriptedFinishRow, SegmentedControl, ShapeChoice, SliderControl, startOpeningDraft, triggerSFX, useEditingHole, useEditor, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Edit, Move, Plus, Trash2 } from 'lucide-react';
 import { useCallback, useEffect, useRef } from 'react';
@@ -18,6 +19,7 @@ import { applySlabAnchorElevationChange, applySlabElevationPreset, applySlabRece
  * into `parametrics.groups`.
  */
 export function SlabPanel() {
+    const i18n = usePascalI18n();
     const selectedId = useViewer((s) => s.selection.selectedIds[0]);
     const unit = useViewer((s) => s.unit);
     const setSelection = useViewer((s) => s.setSelection);
@@ -202,21 +204,61 @@ export function SlabPanel() {
     // for whole-inch offsets.
     const elevationPresets = unit === 'imperial'
         ? [
-            { label: 'Sunken (6")', elevation: -0.1524 },
-            { label: 'Thin (1")', elevation: 0.0254 },
-            { label: 'Standard (2")', elevation: 0.0508 },
-            { label: 'Thick (6")', elevation: 0.1524 },
+            {
+                label: i18n._({ id: 'node.slab.panel.sunken6', message: 'Sunken (6")' }),
+                elevation: -0.1524,
+            },
+            {
+                label: i18n._({ id: 'node.slab.panel.thin1', message: 'Thin (1")' }),
+                elevation: 0.0254,
+            },
+            {
+                label: i18n._({ id: 'node.slab.panel.standard2', message: 'Standard (2")' }),
+                elevation: 0.0508,
+            },
+            {
+                label: i18n._({ id: 'node.slab.panel.thick6', message: 'Thick (6")' }),
+                elevation: 0.1524,
+            },
         ]
         : [
-            { label: 'Sunken (15cm)', elevation: -0.15 },
-            { label: 'Thin (2cm)', elevation: 0.02 },
-            { label: 'Standard (5cm)', elevation: 0.05 },
-            { label: 'Thick (15cm)', elevation: 0.15 },
+            {
+                label: i18n._({ id: 'node.slab.panel.sunken15cm', message: 'Sunken (15cm)' }),
+                elevation: -0.15,
+            },
+            {
+                label: i18n._({ id: 'node.slab.panel.thin2cm', message: 'Thin (2cm)' }),
+                elevation: 0.02,
+            },
+            {
+                label: i18n._({ id: 'node.slab.panel.standard5cm', message: 'Standard (5cm)' }),
+                elevation: 0.05,
+            },
+            {
+                label: i18n._({ id: 'node.slab.panel.thick15cm', message: 'Thick (15cm)' }),
+                elevation: 0.15,
+            },
         ];
-    return (_jsxs(PanelWrapper, { icon: "/icons/floor.webp", onClose: handleClose, title: node.name || 'Slab', width: 320, children: [_jsxs(PanelSection, { title: "Elevation", children: [_jsx(SliderControl, { label: node.recessed ? 'Floor' : 'Surface', max: 20, min: -3, onChange: handleElevationChange, precision: 3, step: 0.01, unit: "m", value: node.elevation }), _jsx(SliderControl, { label: node.recessed ? 'Rim' : 'Base', max: 20, min: -3, onChange: handleAnchorChange, precision: 3, step: 0.01, unit: "m", value: getSlabAnchorElevation(node) }), node.recessed ? (_jsx(SliderControl, { label: "Depth", max: 1000, min: MIN_SLAB_THICKNESS, onChange: handleRecessDepthChange, precision: 2, step: 0.01, unit: "m", value: getSlabRecessDepth(node) })) : (_jsx(SliderControl, { label: "Thickness", max: 1000, min: MIN_SLAB_THICKNESS, onChange: handleThicknessChange, precision: 2, step: 0.01, unit: "m", value: node.thickness ?? 0.05 })), !node.recessed && (_jsxs(_Fragment, { children: [_jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Foundation" }), _jsx(SegmentedControl, { onChange: handleTerrainModeChange, options: [
-                                    { label: 'Fixed', value: 'fixed' },
-                                    { label: 'Follows terrain', value: 'terrain' },
-                                ], value: node.fillToTerrain ? 'terrain' : 'fixed' }), node.fillToTerrain && (_jsx("div", { className: "px-1 text-[11px] text-muted-foreground", children: "Extends the perimeter down to terrain. The flat surface, base, and thickness stay unchanged." }))] })), _jsx("div", { className: "mt-2 grid grid-cols-2 gap-1.5 px-1 pb-1", children: elevationPresets.map((preset) => (_jsx(ActionButton, { label: preset.label, onClick: () => handleElevationPreset(preset.elevation) }, preset.label))) })] }), _jsx(PanelSection, { title: "Info", children: _jsxs("div", { className: "flex items-center justify-between px-2 py-1 text-muted-foreground text-sm", children: [_jsx("span", { children: "Area" }), _jsxs("span", { className: "font-mono text-foreground dark:text-white", children: [area.toFixed(2), " m\u00B2"] })] }) }), _jsxs(PanelSection, { title: "Holes", children: [node.holes && node.holes.length > 0 ? (_jsx("div", { className: "flex flex-col gap-1 pb-2", children: node.holes.map((hole, index) => {
+    return (_jsxs(PanelWrapper, { icon: "/icons/floor.webp", onClose: handleClose, title: node.name || i18n._({ id: 'node.slab.panel.slab', message: 'Slab' }), width: 320, children: [_jsxs(PanelSection, { title: i18n._({ id: 'node.slab.panel.elevation', message: 'Elevation' }), children: [_jsx(SliderControl, { label: node.recessed
+                            ? i18n._({ id: 'node.slab.panel.floor', message: 'Floor' })
+                            : i18n._({ id: 'node.slab.panel.surface', message: 'Surface' }), max: 20, min: -3, onChange: handleElevationChange, precision: 3, step: 0.01, unit: "m", value: node.elevation }), _jsx(SliderControl, { label: node.recessed
+                            ? i18n._({ id: 'node.slab.panel.rim', message: 'Rim' })
+                            : i18n._({ id: 'node.slab.panel.base', message: 'Base' }), max: 20, min: -3, onChange: handleAnchorChange, precision: 3, step: 0.01, unit: "m", value: getSlabAnchorElevation(node) }), node.recessed ? (_jsx(SliderControl, { label: i18n._({ id: 'node.slab.panel.depth', message: 'Depth' }), max: 1000, min: MIN_SLAB_THICKNESS, onChange: handleRecessDepthChange, precision: 2, step: 0.01, unit: "m", value: getSlabRecessDepth(node) })) : (_jsx(SliderControl, { label: i18n._({ id: 'node.slab.panel.thickness', message: 'Thickness' }), max: 1000, min: MIN_SLAB_THICKNESS, onChange: handleThicknessChange, precision: 2, step: 0.01, unit: "m", value: node.thickness ?? 0.05 })), !node.recessed && (_jsxs(_Fragment, { children: [_jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: i18n._({ id: 'node.slab.panel.foundation', message: 'Foundation' }) }), _jsx(SegmentedControl, { onChange: handleTerrainModeChange, options: [
+                                    {
+                                        label: i18n._({ id: 'node.slab.panel.fixed', message: 'Fixed' }),
+                                        value: 'fixed',
+                                    },
+                                    {
+                                        label: i18n._({
+                                            id: 'node.slab.panel.followsTerrain',
+                                            message: 'Follows terrain',
+                                        }),
+                                        value: 'terrain',
+                                    },
+                                ], value: node.fillToTerrain ? 'terrain' : 'fixed' }), node.fillToTerrain && (_jsx("div", { className: "px-1 text-[11px] text-muted-foreground", children: i18n._({
+                                    id: 'node.slab.panel.extendsThePerimeterDownToTerrain',
+                                    message: 'Extends the perimeter down to terrain. The flat surface, base, and thickness stay unchanged.',
+                                }) }))] })), _jsx("div", { className: "mt-2 grid grid-cols-2 gap-1.5 px-1 pb-1", children: elevationPresets.map((preset) => (_jsx(ActionButton, { label: preset.label, onClick: () => handleElevationPreset(preset.elevation) }, preset.label))) })] }), _jsx(PanelSection, { title: i18n._({ id: 'node.slab.panel.info', message: 'Info' }), children: _jsxs("div", { className: "flex items-center justify-between px-2 py-1 text-muted-foreground text-sm", children: [_jsx("span", { children: i18n._({ id: 'node.slab.panel.area', message: 'Area' }) }), _jsx("span", { className: "font-mono text-foreground dark:text-white", children: formatAreaLabel(area, unit, 2) })] }) }), _jsxs(PanelSection, { title: i18n._({ id: 'node.slab.panel.holes', message: 'Holes' }), children: [node.holes && node.holes.length > 0 ? (_jsx("div", { className: "flex flex-col gap-1 pb-2", children: node.holes.map((hole, index) => {
                             const holeArea = calculateArea(hole);
                             const isEditing = editingHole?.nodeId === selectedId && editingHole?.holeIndex === index;
                             const source = node.holeMetadata?.[index]?.source ?? 'manual';
@@ -225,17 +267,51 @@ export function SlabPanel() {
                             const openingId = derived ? node.holeMetadata?.[index]?.openingId : undefined;
                             const isAutoHole = source !== 'manual' || derived;
                             const autoLabel = source === 'elevator'
-                                ? 'Auto elevator cutout'
+                                ? i18n._({ id: 'node.cutout.autoElevator', message: 'Auto elevator cutout' })
                                 : source === 'stair'
-                                    ? 'Auto stair cutout'
+                                    ? i18n._({ id: 'node.cutout.autoStair', message: 'Auto stair cutout' })
                                     : source === 'floor-opening'
-                                        ? 'Opening'
-                                        : 'Room cutout';
+                                        ? i18n._({ id: 'node.cutout.opening', message: 'Opening' })
+                                        : i18n._({ id: 'node.cutout.room', message: 'Room cutout' });
                             return (_jsxs("div", { className: `flex items-center justify-between rounded-lg border p-2 transition-colors ${isEditing
                                     ? 'border-primary/50 bg-primary/10'
-                                    : 'border-transparent hover:bg-accent/30'}`, children: [_jsxs("div", { className: "min-w-0 flex-1", children: [_jsxs("p", { className: `font-medium text-xs ${isEditing ? 'text-primary' : 'text-foreground dark:text-white'}`, children: ["Hole ", index + 1, " ", isEditing && '(Editing)'] }), _jsxs("p", { className: "text-[10px] text-muted-foreground", children: [holeArea.toFixed(2), " m\u00B2 \u00B7 ", hole.length, " pts \u00B7", ' ', isAutoHole ? autoLabel : 'Manual'] })] }), _jsx("div", { className: "flex items-center gap-1", children: isEditing ? (_jsx(ActionButton, { className: "h-7 bg-primary text-primary-foreground hover:bg-primary/90", label: "Done", onClick: () => useInteractionScope
+                                    : 'border-transparent hover:bg-accent/30'}`, children: [_jsxs("div", { className: "min-w-0 flex-1", children: [_jsx("p", { className: `font-medium text-xs ${isEditing ? 'text-primary' : 'text-foreground dark:text-white'}`, children: isEditing
+                                                    ? i18n._({
+                                                        id: 'node.holeEditing',
+                                                        message: 'Hole {number} (Editing)',
+                                                        values: { number: index + 1 },
+                                                    })
+                                                    : i18n._({
+                                                        id: 'node.holeNumber',
+                                                        message: 'Hole {number}',
+                                                        values: { number: index + 1 },
+                                                    }) }), _jsx("p", { className: "text-[10px] text-muted-foreground", children: i18n._({
+                                                    id: 'node.holeSummary',
+                                                    message: '{area} {unit} · {count, plural, one {{points} pt} other {{points} pts}} · {source}',
+                                                    values: {
+                                                        area: formatFixed(squareMetersToAreaUnit(holeArea, unit), 2, i18n.getLocale()),
+                                                        unit: getAreaUnitLabel(unit),
+                                                        count: hole.length,
+                                                        points: String(hole.length),
+                                                        source: isAutoHole
+                                                            ? autoLabel
+                                                            : i18n._({ id: 'node.hole.manual', message: 'Manual' }),
+                                                    },
+                                                }) })] }), _jsx("div", { className: "flex items-center gap-1", children: isEditing ? (_jsx(ActionButton, { className: "h-7 bg-primary text-primary-foreground hover:bg-primary/90", label: i18n._({ id: 'node.slab.panel.done', message: 'Done' }), onClick: () => useInteractionScope
                                                 .getState()
-                                                .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'hole') })) : openingId ? (_jsx("button", { className: "flex h-7 w-7 items-center justify-center rounded-md bg-black/4 dark:bg-[#2C2C2E] text-muted-foreground hover:bg-black/8 dark:hover:bg-[#3e3e3e] hover:text-foreground", "data-slab-hole-opening": openingId, onClick: () => setSelection({ selectedIds: [openingId] }), type: "button", children: _jsx(Edit, { className: "h-3.5 w-3.5" }) })) : isAutoHole ? (_jsx("div", { className: "rounded-md bg-black/4 dark:bg-[#2C2C2E] px-2 py-1 text-[10px] text-muted-foreground", children: "Auto" })) : (_jsxs(_Fragment, { children: [_jsx("button", { className: "flex h-7 w-7 items-center justify-center rounded-md bg-black/4 dark:bg-[#2C2C2E] text-muted-foreground hover:bg-black/8 dark:hover:bg-[#3e3e3e] hover:text-foreground", onClick: () => handleEditHole(index), type: "button", children: _jsx(Edit, { className: "h-3.5 w-3.5" }) }), _jsx("button", { className: "flex h-7 w-7 items-center justify-center rounded-md bg-red-500/10 text-red-600 dark:text-red-400 hover:bg-red-500/20 hover:text-red-700 dark:hover:text-red-300", onClick: () => handleDeleteHole(index), type: "button", children: _jsx(Trash2, { className: "h-3.5 w-3.5" }) })] })) })] }, index));
-                        }) })) : (_jsx("div", { className: "px-2 py-3 text-center text-muted-foreground text-xs", children: "No holes" })), _jsx("div", { className: "px-1 pt-1 pb-1", children: derived ? (_jsx(ShapeChoice, { className: "px-1 text-muted-foreground text-xs", disabled: !openingZoneId, label: node.support === 'open' ? 'Cut hatch' : 'Cut opening', onPick: (shape) => openingZoneId && startOpeningDraft(openingZoneId, 'floor', shape) })) : (_jsx(ActionButton, { className: "w-full", disabled: editingHole?.nodeId === selectedId, icon: _jsx(Plus, { className: "h-3.5 w-3.5" }), label: "Add Hole", onClick: handleAddHole })) })] }), _jsx(ActionGroup, { children: _jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }) })] }));
+                                                .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'hole') })) : openingId ? (_jsx("button", { className: "flex h-7 w-7 items-center justify-center rounded-md bg-black/4 dark:bg-[#2C2C2E] text-muted-foreground hover:bg-black/8 dark:hover:bg-[#3e3e3e] hover:text-foreground", "data-slab-hole-opening": openingId, onClick: () => setSelection({ selectedIds: [openingId] }), type: "button", children: _jsx(Edit, { className: "h-3.5 w-3.5" }) })) : isAutoHole ? (_jsx("div", { className: "rounded-md bg-black/4 dark:bg-[#2C2C2E] px-2 py-1 text-[10px] text-muted-foreground", children: i18n._({ id: 'node.slab.panel.auto', message: 'Auto' }) })) : (_jsxs(_Fragment, { children: [_jsx("button", { className: "flex h-7 w-7 items-center justify-center rounded-md bg-black/4 dark:bg-[#2C2C2E] text-muted-foreground hover:bg-black/8 dark:hover:bg-[#3e3e3e] hover:text-foreground", onClick: () => handleEditHole(index), type: "button", children: _jsx(Edit, { className: "h-3.5 w-3.5" }) }), _jsx("button", { className: "flex h-7 w-7 items-center justify-center rounded-md bg-red-500/10 text-red-600 dark:text-red-400 hover:bg-red-500/20 hover:text-red-700 dark:hover:text-red-300", onClick: () => handleDeleteHole(index), type: "button", children: _jsx(Trash2, { className: "h-3.5 w-3.5" }) })] })) })] }, index));
+                        }) })) : (_jsx("div", { className: "px-2 py-3 text-center text-muted-foreground text-xs", children: i18n._({ id: 'node.slab.panel.noHoles', message: 'No holes' }) })), _jsx("div", { className: "px-1 pt-1 pb-1", children: derived ? (_jsx(ShapeChoice, { className: "px-1 text-muted-foreground text-xs", disabled: !openingZoneId, label: node.support === 'open'
+                                ? i18n._({ id: 'node.slab.panel.cutHatch', message: 'Cut hatch' })
+                                : i18n._({ id: 'node.slab.panel.cutOpening', message: 'Cut opening' }), onPick: (shape) => openingZoneId && startOpeningDraft(openingZoneId, 'floor', shape) })) : (_jsx(ActionButton, { className: "w-full", disabled: editingHole?.nodeId === selectedId, icon: _jsx(Plus, { className: "h-3.5 w-3.5" }), label: i18n._({ id: 'node.slab.panel.addHole', message: 'Add Hole' }), onClick: handleAddHole })) })] }), _jsx(SlabSurfaceScriptRow, { slabId: node.id }), _jsx(ActionGroup, { children: _jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: i18n._({ id: 'node.slab.panel.move', message: 'Move' }), onClick: handleMove }) })] }));
+}
+/** The slab's surface a script builds, with its code to read and a way to take it off. */
+function SlabSurfaceScriptRow({ slabId }) {
+    const sha = useScene((scene) => {
+        const slab = scene.nodes[slabId];
+        return slab?.type === 'slab' ? slab.surfaceScript?.script : undefined;
+    });
+    if (!sha)
+        return null;
+    return (_jsx("div", { className: "border-border/50 border-b px-3 pb-3", children: _jsx(ScriptedFinishRow, { "data-slab-surface-script": slabId, remove: () => setSlabSurfaceScript(useScene.getState().nodes, { slabId, remove: true }, { activeLevelId: null }).changes, sha: sha }) }));
 }
 export default SlabPanel;

package/dist/slab/renderer.d.ts

@@ -0,0 +1,11 @@
+import { type SlabNode } from '@pascal-app/core';
+/**
+ * The slab its geometry builds, and its surface script's build beside it rather than inside: the
+ * slab's group is rebuilt by its geometry and packed into the level's surface batch, which would
+ * freeze or drop a model loaded into it.
+ */
+declare const SlabRenderer: ({ node }: {
+    node: SlabNode;
+}) => import("react").JSX.Element;
+export default SlabRenderer;
+//# sourceMappingURL=renderer.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/slab/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAEL,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AAIzB;;;;GAIG;AACH,QAAA,MAAM,YAAY,aAAc;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAKjD,CAAA;eAac,YAAY"}

package/dist/slab/renderer.js

@@ -0,0 +1,19 @@
+'use client';
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { FLOOR_SCRIPT_LIFT, slabScriptSurface, useScene, } from '@pascal-app/core';
+import { ParametricNodeRenderer } from '@pascal-app/viewer';
+import { FinishScriptModel } from '../shared/finish-script-model.js';
+/**
+ * The slab its geometry builds, and its surface script's build beside it rather than inside: the
+ * slab's group is rebuilt by its geometry and packed into the level's surface batch, which would
+ * freeze or drop a model loaded into it.
+ */
+const SlabRenderer = ({ node }) => (_jsxs(_Fragment, { children: [_jsx(ParametricNodeRenderer, { node: node }), node.surfaceScript ? _jsx(SlabSurfaceScriptModel, { node: node, script: node.surfaceScript }) : null] }));
+/** The slab's surface finish its script built: in the level's plan, its y = 0 on the slab's top. */
+function SlabSurfaceScriptModel({ node, script }) {
+    const surface = useScene((state) => slabScriptSurface(state.nodes, node.id));
+    if (surface === null)
+        return null;
+    return (_jsx("group", { "position-y": surface + FLOOR_SCRIPT_LIFT, visible: node.visible !== false, children: _jsx(FinishScriptModel, { ownerId: node.id, parentId: node.parentId, script: script }) }));
+}
+export default SlabRenderer;

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/slab/system.tsx"],"names":[],"mappings":"AAMA,QAAA,MAAM,WAAW,YAUhB,CAAA;eAEc,WAAW"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/slab/system.tsx"],"names":[],"mappings":"AAOA,QAAA,MAAM,WAAW,YAwBhB,CAAA;eAEc,WAAW"}

package/dist/slab/system.js

@@ -1,5 +1,6 @@
 'use client';
-import { useScene } from '@pascal-app/core';
+import { isDeckSlab, useScene } from '@pascal-app/core';
+import { useViewer } from '@pascal-app/viewer';
 import { useEffect } from 'react';
 import { createSlabDependencyTracker } from './dependency-tracker.js';
 const SlabSystems = () => {
@@ -12,6 +13,16 @@ const SlabSystems = () => {
                 state.markDirty(id);
         });
     }, []);
+    // "Framing only" hides the shell, a deck's boards and frame with it, and draws the frame on its
+    // own: a deck rebuilds when it flips, so no batched copy of it stays drawn over the frame.
+    useEffect(() => useViewer.subscribe((state, previous) => {
+        if (state.framingOnly === previous.framingOnly)
+            return;
+        const scene = useScene.getState();
+        for (const node of Object.values(scene.nodes))
+            if (node.type === 'slab' && isDeckSlab(node, (id) => scene.nodes[id]))
+                scene.markDirty(node.id);
+    }), []);
     return null;
 };
 export default SlabSystems;

package/dist/solar-panel/definition.d.ts

@@ -1,15 +1,146 @@
-import { type NodeDefinition } from '@pascal-app/core';
-import { SolarPanelNode } from './schema.js';
-/**
- * Solar panel array — a grid of photovoltaic panels mounted on a roof
- * segment. Position is segment-local; the surface normal stored on
- * the node orients the array flat to the slope.
- *
- * Three-checkbox model: custom `def.renderer` for the parent-segment
- * lookup + analytical surface normal fallback. No `geometry` (the
- * builder lives in `./geometry` and is shared with the preview), no
- * `system` (the orientation quaternion is computed once per render,
- * not per frame — see renderer notes).
- */
-export declare const solarPanelDefinition: NodeDefinition<typeof SolarPanelNode>;
+export declare const solarPanelDefinition: 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<`solarpanel_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"solar-panel">>;
+    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>>;
+    materialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    panelMaterial: 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>>;
+    panelMaterialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    panelTypePreset: import("zod").ZodOptional<import("zod").ZodEnum<{
+        compact: "compact";
+        frameless: "frameless";
+        residential: "residential";
+        "residential-large": "residential-large";
+    }>>;
+    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>;
+    rows: import("zod").ZodDefault<import("zod").ZodNumber>;
+    columns: import("zod").ZodDefault<import("zod").ZodNumber>;
+    panelWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    panelHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    gapX: import("zod").ZodDefault<import("zod").ZodNumber>;
+    gapY: import("zod").ZodDefault<import("zod").ZodNumber>;
+    mountingType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        flush: "flush";
+        tilted: "tilted";
+    }>>;
+    tiltAngle: import("zod").ZodDefault<import("zod").ZodNumber>;
+    standoffHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    frameThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    frameDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    surfaceNormal: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/solar-panel/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAgNzC;;;;;;;;;;GAUG;AACH,eAAO,MAAM,oBAAoB,EAAE,cAAc,CAAC,OAAO,cAAc,CA2DtE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/solar-panel/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGhC,CAAA"}

package/dist/solar-panel/definition.edit.d.ts

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

package/dist/solar-panel/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/solar-panel/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAGvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAwN9C,eAAO,MAAM,0BAA0B,EAAE,oBAAoB,CAAC,OAAO,cAAc,CAclF,CAAA"}

package/dist/solar-panel/definition.edit.js

@@ -0,0 +1,213 @@
+import { buildSolarPanelFloorplan } from './floorplan.js';
+import { solarPanelParametrics } from './parametrics.js';
+// Handle constants — same scheme as the skylight: edge-to-arrow-center
+// offsets that need to clear half the chevron's body (~13 cm at default
+// scale) plus the frame thickness before the gap reads. 0.35 m matches
+// the skylight's visual cadence; rotate gizmo gets a matching offset +
+// a small +X bump so it sits beside (not on) the +X corner.
+const SIDE_HANDLE_OFFSET = 0.35;
+const ROTATE_CORNER_OFFSET = 0.35;
+const ROTATE_CORNER_X_OFFSET = 0.2;
+const ROTATE_CORNER_Y_OFFSET = 0.18;
+const ROTATE_RING_OFFSET = 0.06;
+const MIN_PANEL_DIM = 0.1;
+const MIN_FRAME_THICKNESS = 0.005;
+const MIN_FRAME_DEPTH = 0.005;
+// Small gap above the current frame top so the chevron stays grabbable
+// when frameDepth collapses near zero and floats above the frame for
+// thicker frames.
+const FRAME_DEPTH_HANDLE_OFFSET = 0.15;
+// Total array footprint (meters). `panelWidth` / `panelHeight` are
+// per-cell dimensions; arrays multiply by columns/rows and add the
+// inter-cell gaps. Handles operate on the TOTAL footprint so the
+// dimension label and drag distance feel intuitive (drag the right edge
+// by 1 m → array grows 1 m on that side, not 1 m per cell).
+function totalArrayWidth(n) {
+    return n.columns * n.panelWidth + Math.max(0, n.columns - 1) * (n.gapX ?? 0);
+}
+function totalArrayHeight(n) {
+    return n.rows * n.panelHeight + Math.max(0, n.rows - 1) * (n.gapY ?? 0);
+}
+// Width arrows on ±X (left / right edges of the array). Asymmetric
+// resize — same pattern as the skylight: anchored edge stays world-fixed,
+// per-cell `panelWidth` is back-solved from the new total width, and
+// `position` shifts by half the actual change along the panel's local
+// +X axis (projected to segment-local via the panel's yaw). Clears
+// `panelTypePreset` since the dimensions no longer match a saved preset.
+function solarPanelWidthHandle(side) {
+    const sign = side === 'right' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'x',
+        anchor: side === 'right' ? 'min' : 'max',
+        min: MIN_PANEL_DIM,
+        currentValue: (n) => totalArrayWidth(n),
+        apply: (initial, newTotalWidth) => {
+            const cols = initial.columns;
+            const gapTotal = Math.max(0, cols - 1) * (initial.gapX ?? 0);
+            const newPanelWidth = Math.max(MIN_PANEL_DIM, (newTotalWidth - gapTotal) / cols);
+            const actualNewTotal = cols * newPanelWidth + gapTotal;
+            const initialTotal = totalArrayWidth(initial);
+            const rotY = initial.rotation ?? 0;
+            const armX = Math.cos(rotY);
+            const armZ = -Math.sin(rotY);
+            const anchorX = initial.position[0] - sign * (initialTotal / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initialTotal / 2) * armZ;
+            const newCenterX = anchorX + sign * (actualNewTotal / 2) * armX;
+            const newCenterZ = anchorZ + sign * (actualNewTotal / 2) * armZ;
+            return {
+                panelWidth: newPanelWidth,
+                position: [newCenterX, initial.position[1], newCenterZ],
+                panelTypePreset: undefined,
+            };
+        },
+        placement: {
+            position: (n) => [sign * (totalArrayWidth(n) / 2 + SIDE_HANDLE_OFFSET), 0, 0],
+            rotationY: () => (side === 'right' ? 0 : Math.PI),
+        },
+        portal: 'grandparent',
+    };
+}
+// Height arrows on ±Z. Same shape as width but acts on `panelHeight`
+// (back-solved from new total height) and projects onto +Z instead of
+// +X. The skylight-axis convention applies: +Z is the dimension along
+// the roof's slope direction.
+function solarPanelHeightHandle(side) {
+    const sign = side === 'top' ? 1 : -1;
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        anchor: side === 'top' ? 'min' : 'max',
+        min: MIN_PANEL_DIM,
+        currentValue: (n) => totalArrayHeight(n),
+        apply: (initial, newTotalHeight) => {
+            const rws = initial.rows;
+            const gapTotal = Math.max(0, rws - 1) * (initial.gapY ?? 0);
+            const newPanelHeight = Math.max(MIN_PANEL_DIM, (newTotalHeight - gapTotal) / rws);
+            const actualNewTotal = rws * newPanelHeight + gapTotal;
+            const initialTotal = totalArrayHeight(initial);
+            const rotY = initial.rotation ?? 0;
+            // Panel-local +Z projects to segment-local (sin r, cos r) —
+            // orthogonal to the panel-local +X basis used for width.
+            const armX = Math.sin(rotY);
+            const armZ = Math.cos(rotY);
+            const anchorX = initial.position[0] - sign * (initialTotal / 2) * armX;
+            const anchorZ = initial.position[2] - sign * (initialTotal / 2) * armZ;
+            const newCenterX = anchorX + sign * (actualNewTotal / 2) * armX;
+            const newCenterZ = anchorZ + sign * (actualNewTotal / 2) * armZ;
+            return {
+                panelHeight: newPanelHeight,
+                position: [newCenterX, initial.position[1], newCenterZ],
+                panelTypePreset: undefined,
+            };
+        },
+        placement: {
+            position: (n) => [0, 0, sign * (totalArrayHeight(n) / 2 + SIDE_HANDLE_OFFSET)],
+            rotationY: () => (side === 'top' ? 0 : Math.PI),
+        },
+        portal: 'grandparent',
+    };
+}
+// Rotate gizmo at the +X+Z corner of the total array footprint, lifted
+// slightly off the surface so it doesn't sink into the frame. Negate
+// the cursor delta to match three.js Y-rotation handedness.
+function solarPanelRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            position: (n) => {
+                const halfX = totalArrayWidth(n) / 2;
+                const halfZ = totalArrayHeight(n) / 2;
+                return [
+                    halfX + ROTATE_CORNER_X_OFFSET,
+                    ROTATE_CORNER_Y_OFFSET,
+                    halfZ + ROTATE_CORNER_OFFSET,
+                ];
+            },
+            rotationY: () => -Math.PI / 4,
+        },
+        decoration: {
+            kind: 'ring',
+            radius: (n) => Math.hypot(totalArrayWidth(n) / 2, totalArrayHeight(n) / 2) + ROTATE_RING_OFFSET,
+            y: () => 0,
+        },
+        portal: 'grandparent',
+    };
+}
+// Frame-depth arrow — vertical chevron above the array, centred on the
+// panel surface. Drag up to grow `frameDepth` (how far the frame sticks
+// out from the surface). axis='y' / anchor='min' so the bottom of the
+// frame stays pinned at the surface (Y=0 in panel-local) and the top
+// follows the cursor. Clears `panelTypePreset` since dimensions no
+// longer match a saved preset.
+function solarPanelFrameDepthHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'y',
+        anchor: 'min',
+        min: MIN_FRAME_DEPTH,
+        currentValue: (n) => n.frameDepth ?? 0.04,
+        apply: (_n, newValue) => ({
+            frameDepth: newValue,
+            panelTypePreset: undefined,
+        }),
+        placement: {
+            position: (n) => [0, (n.frameDepth ?? 0.04) + FRAME_DEPTH_HANDLE_OFFSET, 0],
+        },
+        portal: 'grandparent',
+    };
+}
+// Frame-thickness arrow — diagonal chevron at the -X+Z (top-left) corner,
+// mirroring the skylight handle. axis='z' so dragging outward toward +Z
+// grows the value; rotationY = -π/4 swings the auto-rotated +Z chevron
+// to point along the -X+Z corner bisector. Clears `panelTypePreset`
+// since the frame dimensions no longer match a saved preset.
+function solarPanelFrameThicknessHandle() {
+    return {
+        kind: 'linear-resize',
+        axis: 'z',
+        anchor: 'min',
+        min: MIN_FRAME_THICKNESS,
+        currentValue: (n) => n.frameThickness ?? 0.04,
+        apply: (_n, newValue) => ({
+            frameThickness: newValue,
+            panelTypePreset: undefined,
+        }),
+        placement: {
+            position: (n) => [
+                -(totalArrayWidth(n) / 2) - SIDE_HANDLE_OFFSET,
+                0,
+                totalArrayHeight(n) / 2 + SIDE_HANDLE_OFFSET,
+            ],
+            rotationY: () => -Math.PI / 4,
+        },
+        portal: 'grandparent',
+    };
+}
+const solarPanelHandles = [
+    solarPanelWidthHandle('right'),
+    solarPanelWidthHandle('left'),
+    solarPanelHeightHandle('top'),
+    solarPanelHeightHandle('bottom'),
+    solarPanelFrameDepthHandle(),
+    solarPanelRotateHandle(),
+    solarPanelFrameThicknessHandle(),
+];
+export const solarPanelEditContribution = {
+    snapProfile: 'item',
+    parametrics: solarPanelParametrics,
+    handles: solarPanelHandles,
+    floorplan: buildSolarPanelFloorplan,
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
+    affordanceTools: {
+        move: () => import('./move-tool.js'),
+    },
+    toolHints: [
+        { key: 'Left click', label: 'Place solar panel array on roof' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};