@pascal-app/nodes 1.0.3 → 1.0.5

package/dist/slab/surface-split.js

@@ -0,0 +1,389 @@
+import { containsPoint, difference, floorStepRole, intersection, plateSideRuns, union, } from '@pascal-app/core';
+import { BufferGeometry, Float32BufferAttribute, ShapeUtils, Vector2 } from 'three';
+const TOP_NORMAL_THRESHOLD = 0.5;
+function readTriangles(geometry) {
+    const position = geometry.getAttribute('position');
+    const uv = geometry.getAttribute('uv');
+    const index = geometry.getIndex();
+    // A collapsed slab builds an empty geometry with no position attribute.
+    const count = index ? index.count / 3 : (position?.count ?? 0) / 3;
+    const triangles = [];
+    for (let t = 0; t < count; t += 1) {
+        const corners = [0, 1, 2].map((offset) => {
+            const i = index ? index.getX(t * 3 + offset) : t * 3 + offset;
+            return {
+                x: position.getX(i),
+                y: position.getY(i),
+                z: position.getZ(i),
+                u: uv ? uv.getX(i) : 0,
+                v: uv ? uv.getY(i) : 0,
+            };
+        });
+        triangles.push(corners);
+    }
+    return triangles;
+}
+function faceNormalY(triangle) {
+    const [a, b, c] = triangle;
+    const abx = b.x - a.x;
+    const aby = b.y - a.y;
+    const abz = b.z - a.z;
+    const acx = c.x - a.x;
+    const acy = c.y - a.y;
+    const acz = c.z - a.z;
+    const nx = aby * acz - abz * acy;
+    const ny = abz * acx - abx * acz;
+    const nz = abx * acy - aby * acx;
+    const length = Math.hypot(nx, ny, nz);
+    return length > 1e-12 ? ny / length : 0;
+}
+function buildGeometry(triangles, withUv) {
+    const positions = [];
+    const uvs = [];
+    for (const triangle of triangles) {
+        for (const vertex of triangle) {
+            positions.push(vertex.x, vertex.y, vertex.z);
+            if (withUv)
+                uvs.push(vertex.u, vertex.v);
+        }
+    }
+    const geometry = new BufferGeometry();
+    geometry.setAttribute('position', new Float32BufferAttribute(positions, 3));
+    if (uvs.length > 0) {
+        geometry.setAttribute('uv', new Float32BufferAttribute(uvs, 2));
+        geometry.setAttribute('uv2', new Float32BufferAttribute(uvs.slice(), 2));
+    }
+    geometry.computeVertexNormals();
+    return geometry;
+}
+/**
+ * Rebuild a point of the source triangle from its XZ position. Height and UV
+ * come from the triangle's own plane, so a clipped piece sits exactly where the
+ * original did and keeps the plate's UV mapping.
+ */
+function sampleTriangle(triangle, x, z) {
+    const [a, b, c] = triangle;
+    const v0x = b.x - a.x;
+    const v0z = b.z - a.z;
+    const v1x = c.x - a.x;
+    const v1z = c.z - a.z;
+    const denominator = v0x * v1z - v1x * v0z;
+    if (Math.abs(denominator) < 1e-18)
+        return { x, y: a.y, z, u: a.u, v: a.v };
+    const px = x - a.x;
+    const pz = z - a.z;
+    const beta = (px * v1z - v1x * pz) / denominator;
+    const gamma = (v0x * pz - px * v0z) / denominator;
+    const alpha = 1 - beta - gamma;
+    return {
+        x,
+        z,
+        y: alpha * a.y + beta * b.y + gamma * c.y,
+        u: alpha * a.u + beta * b.u + gamma * c.u,
+        v: alpha * a.v + beta * b.v + gamma * c.v,
+    };
+}
+function triangleRing(triangle) {
+    return triangle.map((vertex) => [vertex.x, vertex.z]);
+}
+function bounds(ring) {
+    let minX = Number.POSITIVE_INFINITY;
+    let maxX = Number.NEGATIVE_INFINITY;
+    let minZ = Number.POSITIVE_INFINITY;
+    let maxZ = Number.NEGATIVE_INFINITY;
+    for (const [x, z] of ring) {
+        minX = Math.min(minX, x);
+        maxX = Math.max(maxX, x);
+        minZ = Math.min(minZ, z);
+        maxZ = Math.max(maxZ, z);
+    }
+    return { minX, maxX, minZ, maxZ };
+}
+function polygonBounds(polygons) {
+    return bounds(polygons.flatMap((polygon) => polygon.outer));
+}
+function disjoint(a, b) {
+    return a.minX > b.maxX || a.maxX < b.minX || a.minZ > b.maxZ || a.maxZ < b.minZ;
+}
+/** Triangles of `triangle` that fall inside `polygons`, re-triangulated in 2D. */
+function clipTriangleToPolygons(triangle, polygons) {
+    const ring = triangleRing(triangle);
+    const pieces = intersection(union([ring]), polygons);
+    const result = [];
+    for (const piece of pieces) {
+        const contour = piece.outer.map(([x, z]) => new Vector2(x, z));
+        const holes = piece.holes
+            .filter((hole) => hole.length >= 3)
+            .map((hole) => hole.map(([x, z]) => new Vector2(x, z)));
+        const points = [...contour, ...holes.flat()];
+        for (const face of ShapeUtils.triangulateShape(contour, holes)) {
+            const corners = face.map((cornerIndex) => {
+                const point = points[cornerIndex];
+                return sampleTriangle(triangle, point.x, point.y);
+            });
+            // triangulateShape returns the input winding; the source triangle's
+            // orientation is what the renderer culls against, so restore it.
+            result.push(faceNormalY(corners) * faceNormalY(triangle) < 0 ? reverse(corners) : corners);
+        }
+    }
+    return result;
+}
+function reverse(triangle) {
+    return [triangle[0], triangle[2], triangle[1]];
+}
+/**
+ * Clip a triangle to `s >= limit` (or `s <= limit`), where `s` is the distance
+ * along `(dirX, dirZ)` from `origin`. Vertical faces project onto a line, so
+ * this is how one side quad is cut at an exposure boundary.
+ */
+function clipTriangleBySlab(triangle, origin, dirX, dirZ, from, to) {
+    let polygon = [...triangle];
+    for (const [limit, keepGreater] of [
+        [from, true],
+        [to, false],
+    ]) {
+        const next = [];
+        for (const [index, current] of polygon.entries()) {
+            const previous = polygon[(index + polygon.length - 1) % polygon.length];
+            const sPrevious = (previous.x - origin[0]) * dirX + (previous.z - origin[1]) * dirZ - limit;
+            const sCurrent = (current.x - origin[0]) * dirX + (current.z - origin[1]) * dirZ - limit;
+            const insidePrevious = keepGreater ? sPrevious >= 0 : sPrevious <= 0;
+            const insideCurrent = keepGreater ? sCurrent >= 0 : sCurrent <= 0;
+            if (insidePrevious !== insideCurrent) {
+                const t = sPrevious / (sPrevious - sCurrent);
+                next.push({
+                    x: previous.x + (current.x - previous.x) * t,
+                    y: previous.y + (current.y - previous.y) * t,
+                    z: previous.z + (current.z - previous.z) * t,
+                    u: previous.u + (current.u - previous.u) * t,
+                    v: previous.v + (current.v - previous.v) * t,
+                });
+            }
+            if (insideCurrent)
+                next.push(current);
+        }
+        polygon = next;
+        if (polygon.length < 3)
+            return [];
+    }
+    const fan = [];
+    for (let index = 1; index < polygon.length - 1; index += 1) {
+        fan.push([polygon[0], polygon[index], polygon[index + 1]]);
+    }
+    return fan;
+}
+/** The 2D segment a vertical triangle projects onto, longest extent first. */
+function verticalSpan(triangle) {
+    let best = null;
+    for (let index = 0; index < 3; index += 1) {
+        const a = triangle[index];
+        const b = triangle[(index + 1) % 3];
+        const length = Math.hypot(b.x - a.x, b.z - a.z);
+        if (!best || length > best.length)
+            best = { start: [a.x, a.z], end: [b.x, b.z], length };
+    }
+    return best && best.length > 1e-9 ? best : null;
+}
+function push(buckets, role, triangles) {
+    if (role === 'hidden' || !triangles.length)
+        return;
+    const bucket = buckets.get(role);
+    if (bucket)
+        bucket.push(...triangles);
+    else
+        buckets.set(role, [...triangles]);
+}
+/**
+ * Split a slab buffer by face orientation only — the pre-plate behaviour, kept
+ * verbatim for manual slabs so their two meshes and their paint slots never
+ * change.
+ */
+export function splitSlabFacesByFacing(geometry) {
+    const top = [];
+    const side = [];
+    const withUv = geometry.getAttribute('uv') !== undefined;
+    for (const triangle of readTriangles(geometry)) {
+        ;
+        (faceNormalY(triangle) > TOP_NORMAL_THRESHOLD ? top : side).push(triangle);
+    }
+    return { top: buildGeometry(top, withUv), side: buildGeometry(side, withUv) };
+}
+/**
+ * Split a plate buffer into one bucket per rendered role: a top bucket per
+ * partition cell, `edge` / `riser` per exposure run, and `underside`. Buckets
+ * come back in a stable order (cells in partition order, then the sides) so the
+ * mesh order of a plate is the same on every rebuild.
+ */
+export function splitPlateFaces(geometry, partition, slab) {
+    const buckets = new Map();
+    const withUv = geometry.getAttribute('uv') !== undefined;
+    // Cells in partition order, then the sides in a fixed order: a plate's mesh
+    // list is then the same on every rebuild, which is what the node batch's
+    // per-mesh allocation keys are indexed by.
+    // A room-owned riser draws one mesh per doorway, so each paints on its own.
+    const sideRole = (side) => side.zoneId && side.role !== 'hidden'
+        ? side.role === 'riser'
+            ? floorStepRole(side.zoneId, side.stepKey)
+            : `edge:${side.zoneId}`
+        : side.role;
+    const order = [
+        ...new Set([
+            ...partition.cells.map((cell) => cell.role),
+            'edge',
+            'riser',
+            ...partition.sides.map(sideRole),
+            'underside',
+        ]),
+    ];
+    const cellBounds = partition.cells.map((cell) => polygonBounds(cell.polygons));
+    const soffit = slab.elevation - slab.thickness;
+    const downturns = partition.sides.flatMap((side) => {
+        if (side.role === 'hidden' || side.dropTo === undefined || side.dropTo >= soffit - 0.001)
+            return [];
+        const [a, b] = [side.start, side.end];
+        const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+        const dx = (-(b[1] - a[1]) / length) * slab.thickness, dz = ((b[0] - a[0]) / length) * slab.thickness;
+        return [
+            {
+                bottom: side.dropTo,
+                polygon: [a, b, [b[0] + dx, b[1] + dz], [a[0] + dx, a[1] + dz]],
+            },
+        ];
+    });
+    const downturnCover = union(downturns.map((d) => d.polygon));
+    for (const triangle of readTriangles(geometry)) {
+        const normalY = faceNormalY(triangle);
+        if (normalY > TOP_NORMAL_THRESHOLD) {
+            if (partition.plainTop) {
+                push(buckets, partition.cells[0]?.role ?? 'surface', [triangle]);
+                continue;
+            }
+            // Area a manual slab already draws belongs to no cell, so it is simply
+            // never emitted — the plate keeps its body and stops z-fighting the top.
+            const triangleBounds = bounds(triangleRing(triangle));
+            for (const [index, cell] of partition.cells.entries()) {
+                if (disjoint(triangleBounds, cellBounds[index]))
+                    continue;
+                push(buckets, cell.role, clipTriangleToPolygons(triangle, cell.polygons));
+            }
+            continue;
+        }
+        if (normalY < -TOP_NORMAL_THRESHOLD) {
+            push(buckets, 'underside', downturnCover.length
+                ? clipTriangleToPolygons(triangle, difference(triangleRing(triangle), downturnCover))
+                : [triangle]);
+        }
+    }
+    const rings = [slab.polygon, ...slab.holes];
+    for (const side of partition.sides) {
+        if (side.role === 'hidden')
+            continue;
+        const bottom = side.bottom ?? side.dropTo ?? slab.elevation - slab.thickness;
+        const top = side.top ?? slab.elevation;
+        const [ax, az] = side.start, [bx, bz] = side.end;
+        const [u0, u1] = sideEdgeUvs(rings, side.start, side.end);
+        const a = { x: ax, y: bottom, z: az, u: u0, v: bottom };
+        const b = { x: bx, y: bottom, z: bz, u: u1, v: bottom };
+        const c = { ...b, y: top, v: top }, d = { ...a, y: top, v: top };
+        push(buckets, sideRole(side), [
+            [a, c, b],
+            [a, d, c],
+        ]);
+    }
+    const levels = [...new Set([...downturns.map((d) => d.bottom), soffit])].sort((a, b) => a - b);
+    let previous = [];
+    for (const [i, low] of levels.slice(0, -1).entries()) {
+        const high = levels[i + 1];
+        const section = union(downturns.filter((d) => d.bottom <= low + 1e-7).map((d) => d.polygon));
+        for (const polygon of difference(section, previous)) {
+            const contour = polygon.outer.map(([x, z]) => new Vector2(x, z));
+            const holes = polygon.holes.map((ring) => ring.map(([x, z]) => new Vector2(x, z)));
+            const points = [...contour, ...holes.flat()];
+            for (const face of ShapeUtils.triangulateShape(contour, holes)) {
+                const triangle = face.map((index) => ({
+                    x: points[index].x,
+                    y: low,
+                    z: points[index].y,
+                    u: points[index].x,
+                    v: points[index].y,
+                }));
+                push(buckets, 'underside', [faceNormalY(triangle) > 0 ? reverse(triangle) : triangle]);
+            }
+        }
+        for (const polygon of section)
+            for (const ring of [polygon.outer, ...polygon.holes])
+                for (const [j, a] of ring.entries()) {
+                    const b = ring[(j + 1) % ring.length];
+                    const dx = b[0] - a[0], dz = b[1] - a[1], length = Math.hypot(dx, dz);
+                    const midpoint = [(a[0] + b[0]) / 2, (a[1] + b[1]) / 2];
+                    const exterior = partition.sides.some((side) => {
+                        const sx = side.end[0] - side.start[0], sz = side.end[1] - side.start[1];
+                        const t = ((midpoint[0] - side.start[0]) * sx + (midpoint[1] - side.start[1]) * sz) /
+                            (sx * sx + sz * sz);
+                        return (t >= -1e-6 &&
+                            t <= 1 + 1e-6 &&
+                            Math.abs((midpoint[0] - side.start[0]) * sz - (midpoint[1] - side.start[1]) * sx) <
+                                1e-6);
+                    });
+                    if (exterior)
+                        continue;
+                    const normalInside = containsPoint(section, [
+                        midpoint[0] + (dz / length) * 0.0001,
+                        midpoint[1] - (dx / length) * 0.0001,
+                    ]);
+                    const aa = { x: a[0], y: low, z: a[1], u: 0, v: low }, bb = { x: b[0], y: low, z: b[1], u: length, v: low };
+                    const cc = { ...bb, y: high, v: high }, dd = { ...aa, y: high, v: high };
+                    const faces = [
+                        [aa, cc, bb],
+                        [aa, dd, cc],
+                    ];
+                    push(buckets, 'underside', normalInside ? faces.map(reverse) : faces);
+                }
+        previous = section;
+    }
+    return order
+        .filter((role) => (buckets.get(role)?.length ?? 0) > 0)
+        .map((role) => ({ role, geometry: buildGeometry(buckets.get(role), withUv) }));
+}
+function sideEdgeUvs(rings, start, end) {
+    for (const ring of rings) {
+        for (const [i, a] of ring.entries()) {
+            const b = ring[(i + 1) % ring.length];
+            const length = Math.hypot(b[0] - a[0], b[1] - a[1]);
+            if (length < 1e-9)
+                continue;
+            const dx = (b[0] - a[0]) / length;
+            const dz = (b[1] - a[1]) / length;
+            const along = (p) => (p[0] - a[0]) * dx + (p[1] - a[1]) * dz;
+            const onEdge = (p) => Math.abs((p[0] - a[0]) * dz - (p[1] - a[1]) * dx) < 1e-6 &&
+                along(p) >= -1e-6 &&
+                along(p) <= length + 1e-6;
+            if (onEdge(start) && onEdge(end))
+                return [along(start), along(end)];
+        }
+    }
+    const length = Math.hypot(end[0] - start[0], end[1] - start[1]);
+    const dx = (end[0] - start[0]) / length;
+    const dz = (end[1] - start[1]) / length;
+    return [start[0] * dx + start[1] * dz, end[0] * dx + end[1] * dz];
+}
+export function clipPlateTerrainFill(geometry, partition) {
+    const triangles = [];
+    for (const triangle of readTriangles(geometry)) {
+        // Keep the terrain-following bottom cap, including steep slopes.
+        if (Math.abs(faceNormalY(triangle)) > 1e-6) {
+            triangles.push(triangle);
+            continue;
+        }
+        const span = verticalSpan(triangle);
+        if (!span)
+            continue;
+        const runs = plateSideRuns(partition, span.start, span.end);
+        for (const run of runs) {
+            if (run.dropTo !== undefined)
+                continue;
+            triangles.push(...clipTriangleBySlab(triangle, span.start, (span.end[0] - span.start[0]) / span.length, (span.end[1] - span.start[1]) / span.length, run.t0 * span.length, run.t1 * span.length));
+        }
+    }
+    return buildGeometry(triangles, geometry.getAttribute('uv') !== undefined);
+}

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

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

package/dist/slab/system.js

@@ -1,7 +1,7 @@
 'use client';
 import { useScene } from '@pascal-app/core';
 import { useEffect } from 'react';
-import { createSlabDependencyTracker } from './dependency-tracker';
+import { createSlabDependencyTracker } from './dependency-tracker.js';
 const SlabSystems = () => {
     useEffect(() => {
         const changedSlabs = createSlabDependencyTracker(useScene.getState().nodes);

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/slab/tool.tsx"],"names":[],"mappings":"AA4EA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EA2T5B,CAAA;AAED,eAAe,QAAQ,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/slab/tool.tsx"],"names":[],"mappings":"AA8EA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EA4T5B,CAAA;eAEc,QAAQ"}

package/dist/slab/tool.js

@@ -1,13 +1,13 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { DEFAULT_ANGLE_STEP, emitter, resolveSlabPlacementElevation, snapPointAlongAngleRay, snapPointToGrid, useScene, } from '@pascal-app/core';
-import { CursorSphere, clearPlacementSurface, clearSlabSnapFeedback, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolveLevelConstructionPlane, resolvePointerSupportSurface, resolveSlabPlanPointSnap, triggerSFX, useEditor, useFloorplanDraftPreview, } from '@pascal-app/editor';
+import { CursorSphere, clearPlacementSurface, clearSlabSnapFeedback, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, isTypingTarget, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolveLevelConstructionPlane, resolvePointerSupportSurface, resolveSlabPlanPointSnap, triggerSFX, useEditor, useFloorplanDraftPreview, visibleScene, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { BufferGeometry, DoubleSide, Shape, Vector3 } from 'three';
-import { shouldRegistryCommitSlab } from './placement-ownership';
-import { SlabNode } from './schema';
+import { shouldRegistryCommitSlab } from './placement-ownership.js';
+import { SlabNode } from './schema.js';
 /**
  * Phase 5 Stage D — slab placement tool (kind-owned via `def.tool`).
  *
@@ -142,7 +142,7 @@ export const SlabTool = () => {
                 firstPoint &&
                 Math.abs(clickPoint[0] - firstPoint[0]) < 0.25 &&
                 Math.abs(clickPoint[1] - firstPoint[1]) < 0.25) {
-                if (shouldRegistryCommitSlab(useEditor.getState().viewMode, 'grid')) {
+                if (shouldRegistryCommitSlab(visibleScene(useEditor.getState()), 'grid')) {
                     const slabId = commitSlabDrawing(currentLevelId, points, constructionPlaneRef.current?.elevation ?? null);
                     setSelection({ selectedIds: [slabId] });
                 }
@@ -168,7 +168,7 @@ export const SlabTool = () => {
         const finishDrawing = (trigger) => {
             if (points.length < 3)
                 return;
-            if (shouldRegistryCommitSlab(useEditor.getState().viewMode, trigger)) {
+            if (shouldRegistryCommitSlab(visibleScene(useEditor.getState()), trigger)) {
                 const slabId = commitSlabDrawing(currentLevelId, points, constructionPlaneRef.current?.elevation ?? null);
                 setSelection({ selectedIds: [slabId] });
             }
@@ -183,6 +183,8 @@ export const SlabTool = () => {
             resetDraft();
         };
         const onKeyDown = (e) => {
+            if (isTypingTarget(e.target))
+                return;
             if (e.key === 'Enter') {
                 e.preventDefault();
                 finishDrawing('keyboard');

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

@@ -1,5 +1,5 @@
 import { type NodeDefinition } from '@pascal-app/core';
-import { SolarPanelNode } from './schema';
+import { SolarPanelNode } from './schema.js';
 /**
  * Solar panel array — a grid of photovoltaic panels mounted on a roof
  * segment. Position is segment-local; the surface normal stored on

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

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

package/dist/solar-panel/definition.js

@@ -1,7 +1,7 @@
 import { SolarPanelNode as SolarPanelNodeSchema, } from '@pascal-app/core';
-import { buildSolarPanelFloorplan } from './floorplan';
-import { solarPanelParametrics } from './parametrics';
-import { SolarPanelNode } from './schema';
+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
@@ -224,6 +224,7 @@ export const solarPanelDefinition = {
         return rest;
     },
     capabilities: {
+        exterior: true,
         selectable: { hitVolume: 'bbox' },
         duplicable: true,
         deletable: true,
@@ -238,12 +239,12 @@ export const solarPanelDefinition = {
     rendersChildren: false,
     renderer: {
         kind: 'parametric',
-        module: () => import('./renderer'),
+        module: () => import('./renderer.js'),
     },
-    preview: () => import('./preview'),
-    tool: () => import('./tool'),
+    preview: () => import('./preview.js'),
+    tool: () => import('./tool.js'),
     affordanceTools: {
-        move: () => import('./move-tool'),
+        move: () => import('./move-tool.js'),
     },
     toolHints: [
         { key: 'Left click', label: 'Place solar panel array on roof' },

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

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

package/dist/solar-panel/index.js

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

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

@@ -4,9 +4,9 @@ import { emitter, sceneRegistry, useScene, } from '@pascal-app/core';
 import { consumePlacementDragRelease, EDITOR_LAYER, markToolCancelConsumed, 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';
-import { getAnalyticalNormal, surfaceQuatFromNormal } from '../shared/roof-surface';
-import { clearRoofSurfacePlacementGuides, publishRoofSurfaceNodePlacementGuides, snapRoofSurfaceNodeTarget, } from '../shared/roof-surface-placement-guides';
+import { createRelativeRoofDrag, roofSegmentLocalToBuildingLocal, snapRelativeRoofDragTarget, } from '../shared/relative-roof-drag.js';
+import { getAnalyticalNormal, surfaceQuatFromNormal } from '../shared/roof-surface.js';
+import { clearRoofSurfacePlacementGuides, publishRoofSurfaceNodePlacementGuides, snapRoofSurfaceNodeTarget, } from '../shared/roof-surface-placement-guides.js';
 // MeshBasicMaterial: avoids the WebGPU "Color target has no corresponding
 // fragment stage output / writeMask not zero" error that fires when
 // MeshStandardMaterial (which writes to the MRT normal/roughness targets)

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,uCAmUtC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/solar-panel/panel.tsx"],"names":[],"mappings":"AAyDA,MAAM,CAAC,OAAO,UAAU,eAAe,uCAqUtC"}

package/dist/solar-panel/panel.js

@@ -5,7 +5,7 @@ import { ActionButton, ActionGroup, PanelSection, PanelWrapper, SegmentedControl
 import { useViewer } from '@pascal-app/viewer';
 import { LayoutGrid, Trash2 } from 'lucide-react';
 import { useCallback, useEffect, useState } from 'react';
-import { computeAutoFit, flippedPanelDims } from './geometry';
+import { computeAutoFit, flippedPanelDims } from './geometry.js';
 const cn = (...classes) => classes.filter(Boolean).join(' ');
 // Editing any of these clears panelTypePreset back to undefined ("Custom"),
 // keeping the schema invariant: a present preset always matches the table.
@@ -138,9 +138,9 @@ export default function SolarPanelPanel() {
                             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-[#2C2C2E] text-muted-foreground 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-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: [
+                                    : '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-400" }), label: "Delete", onClick: handleDelete }) }) })] }));
+                        ], 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 }) }) })] }));
 }

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

@@ -1,4 +1,4 @@
 import type { ParametricDescriptor } from '@pascal-app/core';
-import type { SolarPanelNode } from './schema';
+import type { SolarPanelNode } from './schema.js';
 export declare const solarPanelParametrics: ParametricDescriptor<SolarPanelNode>;
 //# sourceMappingURL=parametrics.d.ts.map

package/dist/solar-panel/parametrics.js

@@ -2,7 +2,7 @@ export const solarPanelParametrics = {
     // Bespoke panel ported from the archive — preset cards, auto-fit,
     // and flip orientation can't be expressed by auto-derived groups.
     // `groups` stays declared so the MCP path keeps a structured view.
-    customPanel: () => import('./panel'),
+    customPanel: () => import('./panel.js'),
     groups: [
         {
             label: 'Grid',

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

@@ -1,4 +1,4 @@
-import type { SolarPanelNode } from './schema';
+import type { SolarPanelNode } from './schema.js';
 declare const SolarPanelPreview: ({ node, invalid }: {
     node: SolarPanelNode;
     invalid?: boolean;

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

@@ -1 +1 @@
-{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/solar-panel/preview.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAsB9C,QAAA,MAAM,iBAAiB,GAAI,mBAAmB;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,uCAgCxF,CAAA;AAED,eAAe,iBAAiB,CAAA"}
+{"version":3,"file":"preview.d.ts","sourceRoot":"","sources":["../../src/solar-panel/preview.tsx"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAsB9C,QAAA,MAAM,iBAAiB,sBAAuB;IAAE,IAAI,EAAE,cAAc,CAAC;IAAC,OAAO,CAAC,EAAE,OAAO,CAAA;CAAE,uCAgCxF,CAAA;eAEc,iBAAiB"}

package/dist/solar-panel/preview.js

@@ -2,8 +2,8 @@
 import { jsx as _jsx } from "react/jsx-runtime";
 import { useEffect, useMemo } from 'react';
 import * as THREE from 'three';
-import { INVALID_GHOST_COLOR } from '../shared/ghost-materials';
-import { buildSolarPanelGeometry } from './geometry';
+import { INVALID_GHOST_COLOR } from '../shared/ghost-materials.js';
+import { buildSolarPanelGeometry } from './geometry.js';
 const ghostMaterial = new THREE.MeshStandardMaterial({
     color: 0xff_ff_ff,
     emissive: 0xff_ff_ff,

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/solar-panel/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AAoCzB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,QAAA,MAAM,kBAAkB,GAAI,qBAAqB;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,uCAqKxE,CAAA;AAED,eAAe,kBAAkB,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/solar-panel/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAGL,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AAoCzB;;;;;;;;;;;;;;;;;;;GAmBG;AACH,QAAA,MAAM,kBAAkB,wBAAyB;IAAE,IAAI,EAAE,cAAc,CAAA;CAAE,uCAqKxE,CAAA;eAEc,kBAAkB"}

package/dist/solar-panel/renderer.js

@@ -5,9 +5,9 @@ import { createMaterial, createMaterialFromPresetRef, createSurfaceRoleMaterial,
 import { useEffect, useMemo, useRef } from 'react';
 import * as THREE from 'three';
 import { MeshStandardNodeMaterial } from 'three/webgpu';
-import { surfaceQuatFromNormal } from '../shared/roof-surface';
-import { useSegmentTrimClippedGeometry } from '../shared/use-segment-trim-clip';
-import { buildSolarPanelGeometry, getDefaultPanelMaterial } from './geometry';
+import { surfaceQuatFromNormal } from '../shared/roof-surface.js';
+import { useSegmentTrimClippedGeometry } from '../shared/use-segment-trim-clip.js';
+import { buildSolarPanelGeometry, getDefaultPanelMaterial } from './geometry.js';
 // Module-scope scratch vectors and quaternions for composing the panel's
 // local orientation each render — surfaceQuat · Y(rotation) · X(tilt).
 // Reused so we don't allocate four objects per frame.