@pascal-app/nodes 1.0.7 → 1.1.0

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' },
+    ],
+};

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/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"}