@pascal-app/nodes 0.1.1

package/dist/solar-panel/definition.js

@@ -0,0 +1,260 @@
+import { SolarPanelNode as SolarPanelNodeSchema, } from '@pascal-app/core';
+import { buildSolarPanelFloorplan } from './floorplan';
+import { solarPanelParametrics } from './parametrics';
+import { SolarPanelNode } from './schema';
+// 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: {
+        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,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer'),
+    },
+    tool: () => import('./tool'),
+    affordanceTools: {
+        move: () => import('./move-tool'),
+    },
+    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/roof.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/floorplan.d.ts

@@ -0,0 +1,21 @@
+import type { FloorplanGeometry, GeometryContext, SolarPanelNode } from '@pascal-app/core';
+/**
+ * Floor-plan builder for a solar-panel array — a grid of photovoltaic
+ * modules mounted on a roof segment. Seen from above it reads as its
+ * `rows × columns` grid of dark module rectangles with gaps between them.
+ *
+ * Coordinate frame mirrors the 3D transform stack
+ * (roof → roof-segment → panel), same as the chimney builder. The array's
+ * `position` is segment-local (X = width axis, Z = depth axis; Y is
+ * ignored — the 3D renderer anchors it to the slope). `rotation` is yaw.
+ * Rotations are negated for the floor plan's y-down convention (see
+ * `buildRoofSegmentFloorplan`).
+ *
+ * The per-module layout matches `buildSolarPanelGeometry` exactly: the
+ * array is centred at the origin, modules step by `panel + gap` along each
+ * axis (columns along X, rows along Z). A tilted array foreshortens
+ * slightly in 3D, but the plan shows its full mounting footprint — that's
+ * what matters for roof layout.
+ */
+export declare function buildSolarPanelFloorplan(node: SolarPanelNode, ctx: GeometryContext): FloorplanGeometry | null;
+//# sourceMappingURL=floorplan.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/solar-panel/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iBAAiB,EAEjB,eAAe,EAGf,cAAc,EACf,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,cAAc,EACpB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA8G1B"}

package/dist/solar-panel/floorplan.js

@@ -0,0 +1,120 @@
+/**
+ * Floor-plan builder for a solar-panel array — a grid of photovoltaic
+ * modules mounted on a roof segment. Seen from above it reads as its
+ * `rows × columns` grid of dark module rectangles with gaps between them.
+ *
+ * Coordinate frame mirrors the 3D transform stack
+ * (roof → roof-segment → panel), same as the chimney builder. The array's
+ * `position` is segment-local (X = width axis, Z = depth axis; Y is
+ * ignored — the 3D renderer anchors it to the slope). `rotation` is yaw.
+ * Rotations are negated for the floor plan's y-down convention (see
+ * `buildRoofSegmentFloorplan`).
+ *
+ * The per-module layout matches `buildSolarPanelGeometry` exactly: the
+ * array is centred at the origin, modules step by `panel + gap` along each
+ * axis (columns along X, rows along Z). A tilted array foreshortens
+ * slightly in 3D, but the plan shows its full mounting footprint — that's
+ * what matters for roof layout.
+ */
+export function buildSolarPanelFloorplan(node, ctx) {
+    const segment = ctx.parent;
+    if (segment?.type !== 'roof-segment')
+        return null;
+    const roofId = segment.parentId;
+    const roof = roofId ? ctx.resolve(roofId) : undefined;
+    if (roof?.type !== 'roof')
+        return null;
+    // Compose roof → segment → panel in plan coords. Each rotation is
+    // negated so SVG's y-down CW matches Three.js' top-down CCW.
+    const cosR = Math.cos(-roof.rotation);
+    const sinR = Math.sin(-roof.rotation);
+    const segCx = roof.position[0] + segment.position[0] * cosR - segment.position[2] * sinR;
+    const segCz = roof.position[2] + segment.position[0] * sinR + segment.position[2] * cosR;
+    const segRot = -(roof.rotation + segment.rotation);
+    const cosS = Math.cos(segRot);
+    const sinS = Math.sin(segRot);
+    const cx = segCx + node.position[0] * cosS - node.position[2] * sinS;
+    const cz = segCz + node.position[0] * sinS + node.position[2] * cosS;
+    const rot = -(roof.rotation + segment.rotation + node.rotation);
+    const cos = Math.cos(rot);
+    const sin = Math.sin(rot);
+    const toPlan = (lx, lz) => [
+        cx + lx * cos - lz * sin,
+        cz + lx * sin + lz * cos,
+    ];
+    const view = ctx.viewState;
+    const palette = view?.palette;
+    const isSelected = view?.selected ?? false;
+    const isHighlighted = view?.highlighted ?? false;
+    const isHovered = view?.hovered ?? false;
+    const showSelectedChrome = isSelected || isHighlighted;
+    // Photovoltaic modules — dark glass with a thin frame. Accent on select,
+    // light blue on hover.
+    const baseInk = '#1e293b';
+    const stroke = showSelectedChrome && palette
+        ? palette.selectedStroke
+        : isHovered && palette
+            ? palette.wallHoverStroke
+            : baseInk;
+    const moduleFill = showSelectedChrome ? '#fed7aa' : '#334155';
+    const moduleFillOpacity = showSelectedChrome ? 0.5 : 0.85;
+    const lineWidth = showSelectedChrome ? 0.028 : 0.016;
+    // Grid params — guarded + clamped to the schema's ranges so a malformed
+    // or un-migrated node can't NaN the layout or blow up the module loop.
+    const rows = Math.max(1, Math.min(20, Math.floor(node.rows ?? 1)));
+    const columns = Math.max(1, Math.min(20, Math.floor(node.columns ?? 1)));
+    const panelW = Math.max(0.05, node.panelWidth ?? 1);
+    const panelH = Math.max(0.05, node.panelHeight ?? 1);
+    const gapX = Math.max(0, node.gapX ?? 0);
+    const gapY = Math.max(0, node.gapY ?? 0);
+    const totalW = columns * panelW + (columns - 1) * gapX;
+    const totalH = rows * panelH + (rows - 1) * gapY;
+    const originX = -totalW / 2;
+    const originZ = -totalH / 2;
+    const halfW = totalW / 2;
+    const halfH = totalH / 2;
+    const children = [
+        // One transparent hit-target across the whole array so clicking a gap
+        // (or any module) selects the array.
+        {
+            kind: 'polygon',
+            points: [
+                toPlan(-halfW, -halfH),
+                toPlan(halfW, -halfH),
+                toPlan(halfW, halfH),
+                toPlan(-halfW, halfH),
+            ],
+            fill: stroke,
+            fillOpacity: 0,
+            stroke: 'none',
+            strokeWidth: 0,
+            pointerEvents: 'all',
+        },
+    ];
+    // One filled rectangle per module — same loop as `buildSolarPanelGeometry`
+    // (columns along X, rows along Z), so the plan grid matches the 3D array.
+    const hw = panelW / 2;
+    const hh = panelH / 2;
+    for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < columns; c++) {
+            const mcx = originX + c * (panelW + gapX) + panelW / 2;
+            const mcz = originZ + r * (panelH + gapY) + panelH / 2;
+            children.push({
+                kind: 'polygon',
+                points: [
+                    toPlan(mcx - hw, mcz - hh),
+                    toPlan(mcx + hw, mcz - hh),
+                    toPlan(mcx + hw, mcz + hh),
+                    toPlan(mcx - hw, mcz + hh),
+                ],
+                fill: moduleFill,
+                fillOpacity: moduleFillOpacity,
+                stroke,
+                strokeWidth: lineWidth,
+                strokeLinejoin: 'miter',
+                pointerEvents: 'none',
+            });
+        }
+    }
+    return { kind: 'group', children };
+}

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

@@ -0,0 +1,29 @@
+import type { RoofSegmentNode, SolarPanelNode } from '@pascal-app/core';
+import * as THREE from 'three';
+export declare function createSolarPanelTexture(): THREE.CanvasTexture | null;
+export declare function getDefaultPanelMaterial(): THREE.Material;
+/**
+ * Pure builder for a solar panel array. Generates one merged
+ * BufferGeometry containing every cell of the rows × columns grid,
+ * with two render groups so the frame (group 0) and the glass
+ * (group 1) can carry distinct materials.
+ *
+ * Pure: no React, no scene access, no store mutation. The renderer
+ * places this geometry in segment-local space with the surface tilt
+ * applied as an outer JSX rotation.
+ */
+export declare function buildSolarPanelGeometry(node: SolarPanelNode): THREE.BufferGeometry | null;
+/**
+ * Return the rows/columns that fit the array edge-to-edge on the slope
+ * the panel is sitting on. Returns null when nothing fits. Capped at
+ * the schema's hard limit of 20.
+ */
+export declare function computeAutoFit(segment: RoofSegmentNode, panel: SolarPanelNode): {
+    rows: number;
+    columns: number;
+} | null;
+export declare function flippedPanelDims(panel: SolarPanelNode): {
+    panelWidth: number;
+    panelHeight: number;
+};
+//# sourceMappingURL=geometry.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/solar-panel/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACvE,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAS9B,wBAAgB,uBAAuB,IAAI,KAAK,CAAC,aAAa,GAAG,IAAI,CAoEpE;AAGD,wBAAgB,uBAAuB,IAAI,KAAK,CAAC,QAAQ,CAaxD;AAED;;;;;;;;;GASG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE,cAAc,GAAG,KAAK,CAAC,cAAc,GAAG,IAAI,CAoFzF;AAqBD;;;;GAIG;AACH,wBAAgB,cAAc,CAC5B,OAAO,EAAE,eAAe,EACxB,KAAK,EAAE,cAAc,GACpB;IAAE,IAAI,EAAE,MAAM,CAAC;IAAC,OAAO,EAAE,MAAM,CAAA;CAAE,GAAG,IAAI,CAW1C;AAED,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,cAAc,GAAG;IACvD,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;CACpB,CAEA"}

package/dist/solar-panel/geometry.js

@@ -0,0 +1,196 @@
+import * as THREE from 'three';
+import { mergeGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
+import { MeshStandardNodeMaterial } from 'three/webgpu';
+const SOLAR_CELL_SIZE_M = 0.16;
+// Procedurally generated cell texture used by the default panel material.
+// Drawn once into an offscreen canvas, wrapped, and tiled per cell by the
+// stretched UVs assigned in `buildSolarPanelGeometry`.
+export function createSolarPanelTexture() {
+    if (typeof document === 'undefined')
+        return null;
+    const size = 256;
+    const canvas = document.createElement('canvas');
+    canvas.width = size;
+    canvas.height = size;
+    const ctx = canvas.getContext('2d');
+    if (!ctx)
+        return null;
+    ctx.fillStyle = '#dde3ec';
+    ctx.fillRect(0, 0, size, size);
+    const pad = size * 0.04;
+    const x = pad;
+    const y = pad;
+    const cellW = size - pad * 2;
+    const cellH = size - pad * 2;
+    const chamfer = cellW * 0.16;
+    ctx.beginPath();
+    ctx.moveTo(x + chamfer, y);
+    ctx.lineTo(x + cellW - chamfer, y);
+    ctx.lineTo(x + cellW, y + chamfer);
+    ctx.lineTo(x + cellW, y + cellH - chamfer);
+    ctx.lineTo(x + cellW - chamfer, y + cellH);
+    ctx.lineTo(x + chamfer, y + cellH);
+    ctx.lineTo(x, y + cellH - chamfer);
+    ctx.lineTo(x, y + chamfer);
+    ctx.closePath();
+    const grad = ctx.createLinearGradient(x, y, x + cellW, y + cellH);
+    grad.addColorStop(0, '#0f1b3a');
+    grad.addColorStop(1, '#162546');
+    ctx.fillStyle = grad;
+    ctx.fill();
+    ctx.save();
+    ctx.clip();
+    ctx.strokeStyle = 'rgba(120, 150, 200, 0.10)';
+    ctx.lineWidth = 0.5;
+    const fingers = 16;
+    for (let f = 1; f < fingers; f++) {
+        const fx = x + (cellW * f) / fingers;
+        ctx.beginPath();
+        ctx.moveTo(fx, y);
+        ctx.lineTo(fx, y + cellH);
+        ctx.stroke();
+    }
+    ctx.strokeStyle = 'rgba(200, 210, 225, 0.35)';
+    ctx.lineWidth = Math.max(1, cellH * 0.008);
+    for (let b = 1; b <= 2; b++) {
+        const by = y + (cellH * b) / 3;
+        ctx.beginPath();
+        ctx.moveTo(x, by);
+        ctx.lineTo(x + cellW, by);
+        ctx.stroke();
+    }
+    ctx.restore();
+    const tex = new THREE.CanvasTexture(canvas);
+    tex.colorSpace = THREE.SRGBColorSpace;
+    tex.wrapS = THREE.RepeatWrapping;
+    tex.wrapT = THREE.RepeatWrapping;
+    tex.anisotropy = 8;
+    tex.needsUpdate = true;
+    return tex;
+}
+let _defaultPanelMaterial = null;
+export function getDefaultPanelMaterial() {
+    if (_defaultPanelMaterial)
+        return _defaultPanelMaterial;
+    const map = createSolarPanelTexture();
+    // MeshStandardNodeMaterial: WebGPU-native — avoids the "writeMask not zero"
+    // MRT error that fires when MeshStandardMaterial is used in the WebGPU pass.
+    const mat = new MeshStandardNodeMaterial({
+        color: new THREE.Color(map ? 0xffffff : 0x0c0c1f),
+        roughness: 0.22,
+        metalness: 0.35,
+    });
+    if (map)
+        mat.map = map;
+    _defaultPanelMaterial = mat;
+    return _defaultPanelMaterial;
+}
+/**
+ * Pure builder for a solar panel array. Generates one merged
+ * BufferGeometry containing every cell of the rows × columns grid,
+ * with two render groups so the frame (group 0) and the glass
+ * (group 1) can carry distinct materials.
+ *
+ * Pure: no React, no scene access, no store mutation. The renderer
+ * places this geometry in segment-local space with the surface tilt
+ * applied as an outer JSX rotation.
+ */
+export function buildSolarPanelGeometry(node) {
+    const { rows, columns, panelWidth, panelHeight, gapX, gapY, frameThickness, frameDepth, standoffHeight, } = node;
+    const frameGeos = [];
+    const panelGeos = [];
+    const totalW = columns * panelWidth + (columns - 1) * gapX;
+    const totalH = rows * panelHeight + (rows - 1) * gapY;
+    const originX = -totalW / 2;
+    const originZ = -totalH / 2;
+    for (let r = 0; r < rows; r++) {
+        for (let c = 0; c < columns; c++) {
+            const cx = originX + c * (panelWidth + gapX) + panelWidth / 2;
+            const cz = originZ + r * (panelHeight + gapY) + panelHeight / 2;
+            const y = standoffHeight + frameDepth / 2;
+            const glassW = panelWidth - 2 * frameThickness;
+            const glassH = panelHeight - 2 * frameThickness;
+            if (glassW > 0 && glassH > 0) {
+                const glass = new THREE.BoxGeometry(glassW, frameDepth * 0.6, glassH);
+                glass.translate(cx, y + frameDepth * 0.2, cz);
+                // Stretch the cell UVs so a tiled cell texture reads correctly
+                // regardless of the panel's aspect ratio.
+                const cellsU = Math.max(1, Math.round(glassW / SOLAR_CELL_SIZE_M));
+                const cellsV = Math.max(1, Math.round(glassH / SOLAR_CELL_SIZE_M));
+                const uv = glass.getAttribute('uv');
+                for (let i = 0; i < uv.count; i++) {
+                    uv.setXY(i, uv.getX(i) * cellsU, uv.getY(i) * cellsV);
+                }
+                uv.needsUpdate = true;
+                panelGeos.push(glass);
+            }
+            const ft = frameThickness;
+            const fd = frameDepth;
+            const left = new THREE.BoxGeometry(ft, fd, panelHeight);
+            left.translate(cx - panelWidth / 2 + ft / 2, y, cz);
+            frameGeos.push(left);
+            const right = new THREE.BoxGeometry(ft, fd, panelHeight);
+            right.translate(cx + panelWidth / 2 - ft / 2, y, cz);
+            frameGeos.push(right);
+            const top = new THREE.BoxGeometry(panelWidth - 2 * ft, fd, ft);
+            top.translate(cx, y, cz - panelHeight / 2 + ft / 2);
+            frameGeos.push(top);
+            const bottom = new THREE.BoxGeometry(panelWidth - 2 * ft, fd, ft);
+            bottom.translate(cx, y, cz + panelHeight / 2 - ft / 2);
+            frameGeos.push(bottom);
+        }
+    }
+    if (frameGeos.length === 0)
+        return null;
+    const frameMerged = mergeGeometries(frameGeos, false);
+    const panelMerged = panelGeos.length > 0 ? mergeGeometries(panelGeos, false) : null;
+    for (const g of frameGeos)
+        g.dispose();
+    for (const g of panelGeos)
+        g.dispose();
+    if (!frameMerged)
+        return null;
+    if (panelMerged) {
+        const combined = mergeGeometries([frameMerged, panelMerged], true);
+        frameMerged.dispose();
+        panelMerged.dispose();
+        return combined;
+    }
+    frameMerged.clearGroups();
+    frameMerged.addGroup(0, frameMerged.index?.count ?? frameMerged.attributes.position.count, 0);
+    return frameMerged;
+}
+// ─── Layout helpers (used by the inspector / placement tool) ─────────
+function getSlopeDepthBounds(segment, panelLocalZ) {
+    const halfD = segment.depth / 2;
+    switch (segment.roofType) {
+        case 'gable':
+        case 'gambrel':
+        case 'dutch':
+        case 'mansard':
+        case 'hip':
+            return panelLocalZ >= 0 ? { minZ: 0, maxZ: halfD } : { minZ: -halfD, maxZ: 0 };
+        default:
+            return { minZ: -halfD, maxZ: halfD };
+    }
+}
+/**
+ * Return the rows/columns that fit the array edge-to-edge on the slope
+ * the panel is sitting on. Returns null when nothing fits. Capped at
+ * the schema's hard limit of 20.
+ */
+export function computeAutoFit(segment, panel) {
+    const { minZ, maxZ } = getSlopeDepthBounds(segment, panel.position[2] ?? 0);
+    const usableW = segment.width;
+    const usableD = maxZ - minZ;
+    if (usableW <= 0 || usableD <= 0)
+        return null;
+    const columns = Math.floor((usableW + panel.gapX) / (panel.panelWidth + panel.gapX));
+    const rows = Math.floor((usableD + panel.gapY) / (panel.panelHeight + panel.gapY));
+    if (columns < 1 || rows < 1)
+        return null;
+    return { rows: Math.min(rows, 20), columns: Math.min(columns, 20) };
+}
+export function flippedPanelDims(panel) {
+    return { panelWidth: panel.panelHeight, panelHeight: panel.panelWidth };
+}

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

@@ -0,0 +1,5 @@
+export { getAnalyticalNormal, getSurfaceY, surfaceQuatFromNormal } from '../shared/roof-surface';
+export { solarPanelDefinition } from './definition';
+export { buildSolarPanelGeometry, computeAutoFit, flippedPanelDims } from './geometry';
+export { SolarPanelNode } from './schema';
+//# sourceMappingURL=index.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/solar-panel/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,WAAW,EAAE,qBAAqB,EAAE,MAAM,wBAAwB,CAAA;AAChG,OAAO,EAAE,oBAAoB,EAAE,MAAM,cAAc,CAAA;AACnD,OAAO,EAAE,uBAAuB,EAAE,cAAc,EAAE,gBAAgB,EAAE,MAAM,YAAY,CAAA;AACtF,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA"}

package/dist/solar-panel/index.js

@@ -0,0 +1,4 @@
+export { getAnalyticalNormal, getSurfaceY, surfaceQuatFromNormal } from '../shared/roof-surface';
+export { solarPanelDefinition } from './definition';
+export { buildSolarPanelGeometry, computeAutoFit, flippedPanelDims } from './geometry';
+export { SolarPanelNode } from './schema';

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

@@ -0,0 +1,5 @@
+import { type SolarPanelNode } from '@pascal-app/core';
+export default function MoveSolarPanelTool({ node }: {
+    node: SolarPanelNode;
+}): import("react").JSX.Element;
+//# sourceMappingURL=move-tool.d.ts.map

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

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