@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/solar-panel/definition.js

@@ -1,263 +1,4 @@
-import { SolarPanelNode as SolarPanelNodeSchema, } from '@pascal-app/core';
-import { buildSolarPanelFloorplan } from './floorplan.js';
-import { solarPanelParametrics } from './parametrics.js';
-import { SolarPanelNode } from './schema.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(),
-];
-/**
- * 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 const solarPanelDefinition = {
-    kind: 'solar-panel',
-    schemaVersion: 1,
-    schema: SolarPanelNode,
-    category: 'structure',
-    surfaceRole: 'roof',
-    defaults: () => {
-        const stub = SolarPanelNodeSchema.parse({
-            id: 'solarpanel_default',
-            type: 'solar-panel',
-        });
-        const { id: _id, type: _type, ...rest } = stub;
-        return rest;
-    },
-    capabilities: {
-        exterior: true,
-        selectable: { hitVolume: 'bbox' },
-        duplicable: true,
-        deletable: true,
-        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
-        // shell — no `buildCut`, just the dirty cascade so the parent
-        // roof's merged shell rebuilds when the array moves / resizes.
-        roofAccessory: {},
-    },
-    parametrics: solarPanelParametrics,
-    handles: solarPanelHandles,
-    floorplan: buildSolarPanelFloorplan,
-    rendersChildren: false,
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    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' },
-    ],
-    presentation: {
-        label: 'Solar Panel',
-        description: 'Grid of photovoltaic panels mounted on a roof segment.',
-        icon: { kind: 'url', src: '/icons/solar-panel.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 123,
-    },
-    mcp: {
-        description: 'A solar panel array on a roof segment. rows × columns grid of individual panels with configurable size, gap, mounting (flush / tilted), and frame.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { solarPanelEditContribution } from './definition.edit.js';
+import { solarPanelRenderDefinition } from './definition.render.js';
+export const solarPanelDefinition = composeNodeDefinition(solarPanelRenderDefinition, solarPanelEditContribution);

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/solar-panel/definition.render.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AACvE,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAEzC,eAAO,MAAM,0BAA0B,EAAE,oBAAoB,CAAC,OAAO,cAAc,CAAC,GAAG;IACrF,IAAI,EAAE,aAAa,CAAA;CAyCpB,CAAA"}

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

@@ -0,0 +1,42 @@
+import { SolarPanelNode as SolarPanelNodeSchema } from '@pascal-app/core';
+import { SolarPanelNode } from './schema.js';
+export const solarPanelRenderDefinition = {
+    kind: 'solar-panel',
+    schemaVersion: 1,
+    schema: SolarPanelNode,
+    category: 'structure',
+    surfaceRole: 'roof',
+    defaults: () => {
+        const stub = SolarPanelNodeSchema.parse({
+            id: 'solarpanel_default',
+            type: 'solar-panel',
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        exterior: true,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        // Mounts on a roof segment via `roofSegmentId`. Sits ON TOP of the
+        // shell — no `buildCut`, just the dirty cascade so the parent
+        // roof's merged shell rebuilds when the array moves / resizes.
+        roofAccessory: {},
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    presentation: {
+        label: 'Solar Panel',
+        description: 'Grid of photovoltaic panels mounted on a roof segment.',
+        icon: { kind: 'url', src: '/icons/solar-panel.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 123,
+    },
+    mcp: {
+        description: 'A solar panel array on a roof segment. rows × columns grid of individual panels with configurable size, gap, mounting (flush / tilted), and frame.',
+    },
+};

package/dist/solar-panel/move-tool.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/solar-panel/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAmCzB,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,+BAiR5E"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/solar-panel/move-tool.tsx"],"names":[],"mappings":"AAEA,OAAO,EAML,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAsCzB,MAAM,CAAC,OAAO,UAAU,kBAAkB,CAAC,EAAE,IAAI,EAAE,EAAE;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,+BAqR5E"}

package/dist/solar-panel/move-tool.js

@@ -1,7 +1,7 @@
 'use client';
 import { jsx as _jsx } from "react/jsx-runtime";
 import { emitter, sceneRegistry, useScene, } from '@pascal-app/core';
-import { consumePlacementDragRelease, EDITOR_LAYER, markToolCancelConsumed, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { consumePlacementDragRelease, EDITOR_LAYER, isGridSnapActive, isMagneticSnapActive, markToolCancelConsumed, stripPlacementMetadataFlags, triggerSFX, useEditor, } from '@pascal-app/editor';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import * as THREE from 'three';
 import { createRelativeRoofDrag, roofSegmentLocalToBuildingLocal, snapRelativeRoofDragTarget, } from '../shared/relative-roof-drag.js';
@@ -81,9 +81,9 @@ export default function MoveSolarPanelTool({ node }) {
             if (!rawTarget)
                 return null;
             return snapRoofSurfaceNodeTarget({
-                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.shiftKey === true),
+                target: snapRelativeRoofDragTarget(rawTarget, event.nativeEvent?.altKey === true),
                 node,
-                bypass: event.nativeEvent?.shiftKey === true,
+                bypass: !isMagneticSnapActive() || event.nativeEvent?.altKey === true,
             });
         };
         const updateGhost = (event) => {
@@ -95,7 +95,9 @@ export default function MoveSolarPanelTool({ node }) {
             lastTarget = target;
             const sx = Math.round(target.localX * 20) / 20;
             const sz = Math.round(target.localZ * 20) / 20;
-            if (event.nativeEvent?.shiftKey !== true && (sx !== lastSnapX || sz !== lastSnapZ)) {
+            if (isGridSnapActive() &&
+                event.nativeEvent?.altKey !== true &&
+                (sx !== lastSnapX || sz !== lastSnapZ)) {
                 triggerSFX('sfx:grid-snap');
                 lastSnapX = sx;
                 lastSnapZ = sz;
@@ -153,7 +155,7 @@ export default function MoveSolarPanelTool({ node }) {
                 // semantics so the renderer's surfaceQuat is in the correct frame.
                 surfaceNormal: [segLocalNormal.x, segLocalNormal.y, segLocalNormal.z],
                 visible: true,
-                metadata: {},
+                metadata: stripPlacementMetadataFlags(original.metadata),
             });
             if (original.roofSegmentId && original.roofSegmentId !== targetSegmentId) {
                 const oldSeg = st.nodes[original.roofSegmentId];

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/solar-panel/panel.tsx"],"names":[],"mappings":"AAyDA,MAAM,CAAC,OAAO,UAAU,eAAe,uCAqUtC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/solar-panel/panel.tsx"],"names":[],"mappings":"AA2EA,MAAM,CAAC,OAAO,UAAU,eAAe,uCAoWtC"}

package/dist/solar-panel/panel.js

@@ -1,6 +1,6 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { SOLAR_PANEL_PRESET_LABELS, SOLAR_PANEL_PRESETS, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { formatFixed, SOLAR_PANEL_PRESETS, useLiveNodeOverrides, usePascalI18n, useScene, } from '@pascal-app/core';
 import { ActionButton, ActionGroup, PanelSection, PanelWrapper, SegmentedControl, SliderControl, triggerSFX, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { LayoutGrid, Trash2 } from 'lucide-react';
@@ -15,11 +15,27 @@ const PRESET_OWNED_FIELDS = [
     'frameThickness',
     'frameDepth',
 ];
+// Preset names in the UI language; core's `SOLAR_PANEL_PRESET_LABELS` stay English.
 const PRESET_CARDS = [
-    { key: 'residential', label: SOLAR_PANEL_PRESET_LABELS.residential },
-    { key: 'residential-large', label: SOLAR_PANEL_PRESET_LABELS['residential-large'] },
-    { key: 'compact', label: SOLAR_PANEL_PRESET_LABELS.compact },
-    { key: 'frameless', label: SOLAR_PANEL_PRESET_LABELS.frameless },
+    {
+        key: 'residential',
+        label: /* i18n */ { id: 'node.solarPanel.preset.residential', message: 'Residential' },
+    },
+    {
+        key: 'residential-large',
+        label: /* i18n */ {
+            id: 'node.solarPanel.preset.residentialLarge',
+            message: 'Residential Large',
+        },
+    },
+    {
+        key: 'compact',
+        label: /* i18n */ { id: 'node.solarPanel.preset.compact', message: 'Compact' },
+    },
+    {
+        key: 'frameless',
+        label: /* i18n */ { id: 'node.solarPanel.preset.frameless', message: 'Frameless' },
+    },
 ];
 function dimsTouchedByUpdate(updates) {
     for (const field of PRESET_OWNED_FIELDS) {
@@ -32,6 +48,7 @@ function num(value, fallback) {
     return typeof value === 'number' && Number.isFinite(value) ? value : fallback;
 }
 export default function SolarPanelPanel() {
+    const i18n = usePascalI18n();
     const selectedId = useViewer((s) => s.selection.selectedIds[0]);
     const setSelection = useViewer((s) => s.setSelection);
     const updateNode = useScene((s) => s.updateNode);
@@ -100,12 +117,15 @@ export default function SolarPanelPanel() {
             return;
         const fit = computeAutoFit(segment, node);
         if (!fit) {
-            setAutoFitMessage('Setbacks too large to fit a panel.');
+            setAutoFitMessage(i18n._({
+                id: 'node.solarPanel.panel.setbacksTooLarge',
+                message: 'Setbacks too large to fit a panel.',
+            }));
             return;
         }
         updateNode(selectedId, { rows: fit.rows, columns: fit.columns });
         setAutoFitMessage(null);
-    }, [selectedId, node, segment, updateNode]);
+    }, [selectedId, node, segment, updateNode, i18n]);
     const handleDelete = useCallback(() => {
         if (!(selectedId && node))
             return;
@@ -132,15 +152,30 @@ export default function SolarPanelPanel() {
     if (!(node && node.type === 'solar-panel' && selectedId))
         return null;
     const activePreset = node.panelTypePreset;
-    const formatDims = (w, h) => `${w.toFixed(2)} × ${h.toFixed(2)} m`;
-    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: node.roofSegmentId ? handleBack : undefined, onClose: handleClose, title: node.name || 'Solar Panel', width: 300, children: [_jsxs(PanelSection, { title: "Preset", children: [_jsx("div", { className: "grid grid-cols-2 gap-1.5 px-1 pt-1", children: PRESET_CARDS.map((card) => {
+    const formatDims = (w, h) => `${formatFixed(w, 2, i18n.getLocale())} × ${formatFixed(h, 2, i18n.getLocale())} m`;
+    return (_jsxs(PanelWrapper, { icon: "/icons/roof.webp", onBack: node.roofSegmentId ? handleBack : undefined, onClose: handleClose, title: node.name || i18n._({ id: 'node.solarPanel.panel.solarPanel', message: 'Solar Panel' }), width: 300, children: [_jsxs(PanelSection, { title: i18n._({ id: 'node.solarPanel.panel.preset', message: 'Preset' }), children: [_jsx("div", { className: "grid grid-cols-2 gap-1.5 px-1 pt-1", children: PRESET_CARDS.map((card) => {
                             const dims = SOLAR_PANEL_PRESETS[card.key];
                             const isSelected = activePreset === card.key;
                             return (_jsxs("button", { className: cn('flex min-h-14 flex-col items-start gap-0.5 rounded-lg border px-2.5 py-2 text-left text-xs transition-colors', isSelected
                                     ? 'border-orange-400/60 bg-orange-400/10 text-foreground'
-                                    : 'border-border/50 bg-black/4 dark:bg-[#2C2C2E] text-muted-foreground hover:bg-black/8 dark:hover:bg-[#3e3e3e] hover:text-foreground'), onClick: () => handlePresetChange(card.key), type: "button", children: [_jsxs("span", { className: "flex items-center gap-1.5 font-medium", children: [_jsx(LayoutGrid, { className: "h-3.5 w-3.5 shrink-0" }), _jsx("span", { className: "truncate", children: card.label })] }), _jsx("span", { className: "pl-[20px] text-[10px] tabular-nums opacity-70", children: formatDims(dims.panelWidth, dims.panelHeight) })] }, card.key));
-                        }) }), !activePreset && (_jsx("p", { className: "px-1 pt-1 text-[11px] text-muted-foreground", children: "Custom \u2014 dimensions don't match any preset" }))] }), _jsxs(PanelSection, { title: "Array", children: [_jsx(SliderControl, { label: "Rows", max: 20, min: 1, onChange: (v) => previewProp({ rows: Math.round(v) }), onCommit: (v) => commitProp({ rows: Math.round(v) }), precision: 0, restoreOnCommit: false, step: 1, value: num(node.rows, 4) }), _jsx(SliderControl, { label: "Columns", max: 20, min: 1, onChange: (v) => previewProp({ columns: Math.round(v) }), onCommit: (v) => commitProp({ columns: Math.round(v) }), precision: 0, restoreOnCommit: false, step: 1, value: num(node.columns, 5) }), _jsx(SliderControl, { label: "Gap X", max: 0.2, min: 0, onChange: (v) => previewProp({ gapX: v }), onCommit: (v) => commitProp({ gapX: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: num(node.gapX, 0.02) }), _jsx(SliderControl, { label: "Gap Y", max: 0.2, min: 0, onChange: (v) => previewProp({ gapY: v }), onCommit: (v) => commitProp({ gapY: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: num(node.gapY, 0.02) }), _jsx(ActionGroup, { children: _jsx(ActionButton, { disabled: !segment, label: "Auto-fit to roof", onClick: handleAutoFit }) }), autoFitMessage ? (_jsx("p", { className: "px-1 text-amber-700 dark:text-amber-400 text-xs", children: autoFitMessage })) : null] }), _jsxs(PanelSection, { title: "Panel", children: [_jsx(SliderControl, { label: "Width", max: 1000, min: 0.3, onChange: (v) => previewProp({ panelWidth: v }), onCommit: (v) => commitProp({ panelWidth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: num(node.panelWidth, 1) }), _jsx(SliderControl, { label: "Height", max: 1000, min: 0.3, onChange: (v) => previewProp({ panelHeight: v }), onCommit: (v) => commitProp({ panelHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: num(node.panelHeight, 1.65) }), _jsx(ActionGroup, { children: _jsx(ActionButton, { label: "Flip orientation", onClick: handleFlip }) }), _jsx(SliderControl, { label: "Frame thickness", max: 0.1, min: 0.005, onChange: (v) => previewProp({ frameThickness: v }), onCommit: (v) => commitProp({ frameThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: num(node.frameThickness, 0.04) }), _jsx(SliderControl, { label: "Frame depth", max: 0.1, min: 0.005, onChange: (v) => previewProp({ frameDepth: v }), onCommit: (v) => commitProp({ frameDepth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: num(node.frameDepth, 0.04) })] }), _jsxs(PanelSection, { title: "Mounting", children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ mountingType: v }), options: [
-                            { label: 'Flush', value: 'flush' },
-                            { label: 'Tilted', value: 'tilted' },
-                        ], value: node.mountingType ?? 'flush' }), node.mountingType === 'tilted' && (_jsx(SliderControl, { label: "Tilt angle", max: 45, min: 0, onChange: (v) => previewProp({ tiltAngle: v }), onCommit: (v) => commitProp({ tiltAngle: v }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(num(node.tiltAngle, 15)) })), _jsx(SliderControl, { label: "Standoff", max: 0.3, min: 0, onChange: (v) => previewProp({ standoffHeight: v }), onCommit: (v) => commitProp({ standoffHeight: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: num(node.standoffHeight, 0.05) })] }), _jsx(PanelSection, { title: "Actions", children: _jsx(ActionGroup, { children: _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 }) }) })] }));
+                                    : 'border-border/50 bg-black/4 dark:bg-[#2C2C2E] text-muted-foreground hover:bg-black/8 dark:hover:bg-[#3e3e3e] hover:text-foreground'), onClick: () => handlePresetChange(card.key), type: "button", children: [_jsxs("span", { className: "flex items-center gap-1.5 font-medium", children: [_jsx(LayoutGrid, { className: "h-3.5 w-3.5 shrink-0" }), _jsx("span", { className: "min-w-0 break-words", children: i18n._(card.label) })] }), _jsx("span", { className: "pl-[20px] text-[10px] tabular-nums opacity-70", children: formatDims(dims.panelWidth, dims.panelHeight) })] }, card.key));
+                        }) }), !activePreset && (_jsx("p", { className: "px-1 pt-1 text-[11px] text-muted-foreground", children: i18n._({
+                            id: 'node.solarPanel.panel.customDimensionsDonTMatchAny',
+                            message: "Custom — dimensions don't match any preset",
+                        }) }))] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.solarPanel.panel.array', message: 'Array' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.solarPanel.panel.rows', message: 'Rows' }), max: 20, min: 1, onChange: (v) => previewProp({ rows: Math.round(v) }), onCommit: (v) => commitProp({ rows: Math.round(v) }), precision: 0, restoreOnCommit: false, step: 1, value: num(node.rows, 4) }), _jsx(SliderControl, { label: i18n._({ id: 'node.solarPanel.panel.columns', message: 'Columns' }), max: 20, min: 1, onChange: (v) => previewProp({ columns: Math.round(v) }), onCommit: (v) => commitProp({ columns: Math.round(v) }), precision: 0, restoreOnCommit: false, step: 1, value: num(node.columns, 5) }), _jsx(SliderControl, { label: i18n._({ id: 'node.solarPanel.panel.gapX', message: 'Gap X' }), max: 0.2, min: 0, onChange: (v) => previewProp({ gapX: v }), onCommit: (v) => commitProp({ gapX: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: num(node.gapX, 0.02) }), _jsx(SliderControl, { label: i18n._({ id: 'node.solarPanel.panel.gapY', message: 'Gap Y' }), max: 0.2, min: 0, onChange: (v) => previewProp({ gapY: v }), onCommit: (v) => commitProp({ gapY: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: num(node.gapY, 0.02) }), _jsx(ActionGroup, { children: _jsx(ActionButton, { disabled: !segment, label: i18n._({
+                                id: 'node.solarPanel.panel.autoFitToRoof',
+                                message: 'Auto-fit to roof',
+                            }), onClick: handleAutoFit }) }), autoFitMessage ? (_jsx("p", { className: "px-1 text-amber-700 dark:text-amber-400 text-xs", children: autoFitMessage })) : null] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.solarPanel.panel.panel', message: 'Panel' }), children: [_jsx(SliderControl, { label: i18n._({ id: 'node.solarPanel.panel.width', message: 'Width' }), max: 1000, min: 0.3, onChange: (v) => previewProp({ panelWidth: v }), onCommit: (v) => commitProp({ panelWidth: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: num(node.panelWidth, 1) }), _jsx(SliderControl, { label: i18n._({ id: 'node.solarPanel.panel.height', message: 'Height' }), max: 1000, min: 0.3, onChange: (v) => previewProp({ panelHeight: v }), onCommit: (v) => commitProp({ panelHeight: v }), precision: 2, restoreOnCommit: false, step: 0.05, unit: "m", value: num(node.panelHeight, 1.65) }), _jsx(ActionGroup, { children: _jsx(ActionButton, { label: i18n._({
+                                id: 'node.solarPanel.panel.flipOrientation',
+                                message: 'Flip orientation',
+                            }), onClick: handleFlip }) }), _jsx(SliderControl, { label: i18n._({ id: 'node.solarPanel.panel.frameThickness', message: 'Frame thickness' }), max: 0.1, min: 0.005, onChange: (v) => previewProp({ frameThickness: v }), onCommit: (v) => commitProp({ frameThickness: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: num(node.frameThickness, 0.04) }), _jsx(SliderControl, { label: i18n._({ id: 'node.solarPanel.panel.frameDepth', message: 'Frame depth' }), max: 0.1, min: 0.005, onChange: (v) => previewProp({ frameDepth: v }), onCommit: (v) => commitProp({ frameDepth: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: num(node.frameDepth, 0.04) })] }), _jsxs(PanelSection, { title: i18n._({ id: 'node.solarPanel.panel.mounting', message: 'Mounting' }), children: [_jsx(SegmentedControl, { onChange: (v) => handleUpdate({ mountingType: v }), options: [
+                            {
+                                label: i18n._({ id: 'node.solarPanel.panel.flush', message: 'Flush' }),
+                                value: 'flush',
+                            },
+                            {
+                                label: i18n._({ id: 'node.solarPanel.panel.tilted', message: 'Tilted' }),
+                                value: 'tilted',
+                            },
+                        ], value: node.mountingType ?? 'flush' }), node.mountingType === 'tilted' && (_jsx(SliderControl, { label: i18n._({ id: 'node.solarPanel.panel.tiltAngle', message: 'Tilt angle' }), max: 45, min: 0, onChange: (v) => previewProp({ tiltAngle: v }), onCommit: (v) => commitProp({ tiltAngle: v }), precision: 0, restoreOnCommit: false, step: 1, unit: "\u00B0", value: Math.round(num(node.tiltAngle, 15)) })), _jsx(SliderControl, { label: i18n._({ id: 'node.solarPanel.panel.standoff', message: 'Standoff' }), max: 0.3, min: 0, onChange: (v) => previewProp({ standoffHeight: v }), onCommit: (v) => commitProp({ standoffHeight: v }), precision: 3, restoreOnCommit: false, step: 0.005, unit: "m", value: num(node.standoffHeight, 0.05) })] }), _jsx(PanelSection, { title: i18n._({ id: 'node.solarPanel.panel.actions', message: 'Actions' }), children: _jsx(ActionGroup, { children: _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.solarPanel.panel.delete', message: 'Delete' }), onClick: handleDelete }) }) })] }));
 }

package/dist/spawn/definition.d.ts

@@ -1,4 +1,49 @@
-import type { NodeDefinition } from '@pascal-app/core';
-import { SpawnNode } from './schema.js';
-export declare const spawnDefinition: NodeDefinition<typeof SpawnNode>;
+export declare const spawnDefinition: 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<`spawn_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"spawn">>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    supportSlabId: import("zod").ZodOptional<import("zod").ZodString>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/spawn/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAKpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA0CpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAwE5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/spawn/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,eAAe;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAAsE,CAAA"}

package/dist/spawn/definition.edit.d.ts

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

package/dist/spawn/definition.edit.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/spawn/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAKvE,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA8CzC,eAAO,MAAM,qBAAqB,EAAE,oBAAoB,CAAC,OAAO,SAAS,CAsBxE,CAAA"}

package/dist/spawn/definition.edit.js

@@ -0,0 +1,64 @@
+import { buildSpawnFloorplan } from './floorplan.js';
+import { spawnRotateAffordance } from './floorplan-affordances.js';
+import { spawnFloorplanMoveTarget } from './floorplan-move.js';
+import { spawnParametrics } from './parametrics.js';
+const SPAWN_FOOTPRINT = 0.6;
+const SPAWN_HANDLE_HEIGHT = 0.46;
+const MOVE_FRONT_OFFSET = 0.35;
+const ROTATE_CORNER_OFFSET = 0.32;
+const ROTATE_RING_OFFSET = 0.04;
+function spawnRotateHandle() {
+    return {
+        kind: 'arc-resize',
+        axis: 'angular',
+        shape: 'rotate',
+        apply: (initial, delta) => ({ rotation: (initial.rotation ?? 0) - delta }),
+        placement: {
+            position: () => [
+                SPAWN_FOOTPRINT / 2,
+                SPAWN_HANDLE_HEIGHT,
+                SPAWN_FOOTPRINT / 2 + ROTATE_CORNER_OFFSET,
+            ],
+            rotationY: () => -Math.PI / 4,
+        },
+        decoration: {
+            kind: 'ring',
+            radius: () => Math.hypot(SPAWN_FOOTPRINT / 2, SPAWN_FOOTPRINT / 2) + ROTATE_RING_OFFSET,
+            y: () => SPAWN_HANDLE_HEIGHT,
+        },
+    };
+}
+function spawnMoveHandle() {
+    return {
+        kind: 'translate',
+        placement: {
+            // Low to the floor at the front edge (matches the item move grip).
+            position: () => [0, 0.02, SPAWN_FOOTPRINT / 2 + MOVE_FRONT_OFFSET],
+        },
+        apply: (_n, pos) => ({ position: [pos[0], pos[1], pos[2]] }),
+        snapExtents: () => [SPAWN_FOOTPRINT, SPAWN_FOOTPRINT],
+    };
+}
+export const spawnEditContribution = {
+    snapProfile: 'item',
+    parametrics: spawnParametrics,
+    handles: [spawnRotateHandle(), spawnMoveHandle()],
+    // Stage C migration: floor-plan rendering via def.floorplan.
+    // floorplan-panel.tsx's `floorplanSpawnEntries` short-circuits to []
+    // when `nodeRegistry.has('spawn')`, so this builder is the single
+    // path. FloorplanRegistryLayer renders + handles click-to-select;
+    // FloorplanRegistryActionMenu handles move / duplicate (disabled) /
+    // delete. Legacy spawn click handlers in FloorplanNodeLayer become
+    // dead code once Phase 6 cleanup removes the [] entries path.
+    floorplan: buildSpawnFloorplan,
+    floorplanMoveTarget: spawnFloorplanMoveTarget,
+    floorplanAffordances: {
+        'spawn-rotate': spawnRotateAffordance,
+    },
+    tool: () => import('./tool.js'),
+    toolHints: [
+        { key: 'Left click', label: 'Place spawn point' },
+        { key: 'R / T', label: 'Rotate spawn point' },
+        { key: 'Esc', label: 'Cancel' },
+    ],
+};