@pascal-app/core 0.8.0 → 0.9.2

package/dist/services/system-graph.js

@@ -0,0 +1,164 @@
+import { nodeRegistry } from '../registry';
+/**
+ * The "System" primitive: connected components over the port graph.
+ *
+ * Two nodes are joined when a port of one coincides in space with a port
+ * of the other — the same mated-joint relationship `port-connectivity`
+ * uses for drag propagation, read here at whole-scene scope. A component
+ * is one distribution system: a furnace, its trunk, the tees, branches,
+ * and registers hanging off it.
+ *
+ * Pure logic (def.ports + arithmetic), no rendering — lives in core so
+ * the editor (badges, schedules) and analyses (sizing, code checks) can
+ * share it.
+ */
+/** Distance (meters) under which two ports count as the same joint —
+ *  matches port-connectivity's tolerance for hand-placed joints. */
+const COINCIDENT_EPS_M = 0.05;
+function collectPorts(nodes) {
+    const result = [];
+    for (const node of Object.values(nodes)) {
+        if (!node)
+            continue;
+        const ports = nodeRegistry.get(node.type)?.ports?.(node);
+        if (!ports)
+            continue;
+        for (const port of ports) {
+            result.push({
+                nodeId: node.id,
+                x: port.position[0],
+                y: port.position[1],
+                z: port.position[2],
+                system: port.system,
+            });
+        }
+    }
+    return result;
+}
+/** Union-find over node ids. */
+class Components {
+    parent = new Map();
+    find(id) {
+        let root = this.parent.get(id) ?? id;
+        if (root !== id) {
+            root = this.find(root);
+            this.parent.set(id, root);
+        }
+        return root;
+    }
+    union(a, b) {
+        const ra = this.find(a);
+        const rb = this.find(b);
+        if (ra !== rb)
+            this.parent.set(rb, ra);
+    }
+}
+function pathLength(path) {
+    let total = 0;
+    for (let i = 0; i < path.length - 1; i++) {
+        const a = path[i];
+        const b = path[i + 1];
+        total += Math.hypot(b[0] - a[0], b[1] - a[1], b[2] - a[2]);
+    }
+    return total;
+}
+/**
+ * Group every port-bearing node into connected components via coinciding
+ * ports. Nodes with ports but no joints form singleton components; nodes
+ * without `def.ports` don't participate at all.
+ */
+export function buildPortComponents(nodes) {
+    const ports = collectPorts(nodes);
+    const components = new Components();
+    const epsSq = COINCIDENT_EPS_M * COINCIDENT_EPS_M;
+    for (let i = 0; i < ports.length; i++) {
+        const a = ports[i];
+        for (let j = i + 1; j < ports.length; j++) {
+            const b = ports[j];
+            if (a.nodeId === b.nodeId)
+                continue;
+            const dx = a.x - b.x;
+            const dy = a.y - b.y;
+            const dz = a.z - b.z;
+            if (dx * dx + dy * dy + dz * dz <= epsSq)
+                components.union(a.nodeId, b.nodeId);
+        }
+    }
+    const grouped = new Map();
+    const seen = new Set();
+    for (const port of ports) {
+        if (seen.has(port.nodeId))
+            continue;
+        seen.add(port.nodeId);
+        const root = components.find(port.nodeId);
+        const group = grouped.get(root);
+        if (group)
+            group.push(port.nodeId);
+        else
+            grouped.set(root, [port.nodeId]);
+    }
+    return [...grouped.values()];
+}
+function summarize(nodeIds, nodes) {
+    const systems = new Set();
+    let runCount = 0;
+    let runLengthM = 0;
+    let fittingCount = 0;
+    let terminalCount = 0;
+    let equipmentCount = 0;
+    for (const id of nodeIds) {
+        const node = nodes[id];
+        if (!node)
+            continue;
+        const role = nodeRegistry.get(node.type)?.distributionRole;
+        const fields = node;
+        if (role === 'run') {
+            runCount += 1;
+            if (fields.path)
+                runLengthM += pathLength(fields.path);
+            // Linesets carry refrigerant; duct / pipe runs name their own loop.
+            systems.add(fields.system ?? 'refrigerant');
+        }
+        else if (role === 'fitting') {
+            fittingCount += 1;
+            if (fields.system)
+                systems.add(fields.system);
+        }
+        else if (role === 'terminal') {
+            terminalCount += 1;
+            systems.add(fields.terminalType === 'return-grille' ? 'return' : 'supply');
+        }
+        else if (role === 'equipment') {
+            equipmentCount += 1;
+        }
+    }
+    return {
+        nodeIds,
+        systems: [...systems].sort(),
+        runCount,
+        runLengthM,
+        fittingCount,
+        terminalCount,
+        equipmentCount,
+        connectedToEquipment: equipmentCount > 0,
+    };
+}
+/**
+ * Summary of the system the given node belongs to, or null when the node
+ * has no ports (not a distribution kind). A node with ports but no
+ * joints yet still gets a (singleton) summary — `connectedToEquipment:
+ * false` is the interesting signal there.
+ */
+export function summarizeSystemFor(nodeId, nodes) {
+    const node = nodes[nodeId];
+    if (!node)
+        return null;
+    const ports = nodeRegistry.get(node.type)?.ports?.(node);
+    if (!ports || ports.length === 0)
+        return null;
+    for (const component of buildPortComponents(nodes)) {
+        if (component.includes(nodeId))
+            return summarize(component, nodes);
+    }
+    return summarize([nodeId], nodes);
+}

package/dist/services/system-graph.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=system-graph.test.d.ts.map

package/dist/services/system-graph.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"system-graph.test.d.ts","sourceRoot":"","sources":["../../src/services/system-graph.test.ts"],"names":[],"mappings":""}

package/dist/services/system-graph.test.js

@@ -0,0 +1,138 @@
+import { describe, expect, test } from 'bun:test';
+import { registerNode } from '../registry';
+import { buildPortComponents, summarizeSystemFor } from './system-graph';
+// Stub registrations: the graph consults `def.ports` for the connectivity
+// graph and `def.distributionRole` to classify each node. Mirrors the real
+// kinds' port + role conventions (duct runs expose start/end, equipment a
+// supply collar, terminals one collar) without importing the nodes package.
+function stubDef(kind, distributionRole, ports) {
+    registerNode({
+        kind,
+        schemaVersion: 1,
+        schema: {},
+        category: 'utility',
+        distributionRole,
+        defaults: () => ({}),
+        capabilities: {},
+        ports,
+    });
+}
+stubDef('duct-segment', 'run', (node) => {
+    const path = node.path;
+    const system = node.system;
+    return [
+        { id: 'start', position: path[0], direction: [-1, 0, 0], diameter: 6, system },
+        {
+            id: 'end',
+            position: path[path.length - 1],
+            direction: [1, 0, 0],
+            diameter: 6,
+            system,
+        },
+    ];
+});
+stubDef('hvac-equipment', 'equipment', (node) => {
+    const position = node.position;
+    return [{ id: 'supply', position, direction: [0, 1, 0], diameter: 12, system: 'supply' }];
+});
+stubDef('duct-terminal', 'terminal', (node) => {
+    const position = node.position;
+    return [{ id: 'collar', position, direction: [0, -1, 0], diameter: 6, system: 'supply' }];
+});
+let nextId = 0;
+function makeNode(type, fields) {
+    nextId += 1;
+    return { id: `${type}_${nextId}`, type, object: 'node', parentId: null, ...fields };
+}
+function sceneOf(...nodes) {
+    return Object.fromEntries(nodes.map((n) => [n.id, n]));
+}
+function run(path, system = 'supply') {
+    return makeNode('duct-segment', { path, system, diameter: 6 });
+}
+describe('buildPortComponents', () => {
+    test('chained runs land in one component; a distant run is separate', () => {
+        const a = run([
+            [0, 0, 0],
+            [3, 0, 0],
+        ]);
+        const b = run([
+            [3, 0, 0],
+            [3, 0, 4],
+        ]); // shares a's end
+        const c = run([
+            [20, 0, 0],
+            [24, 0, 0],
+        ]); // far away
+        const components = buildPortComponents(sceneOf(a, b, c));
+        expect(components.length).toBe(2);
+        const joined = components.find((g) => g.length === 2);
+        expect(new Set(joined)).toEqual(new Set([a.id, b.id]));
+    });
+    test('joints within tolerance still join; outside do not', () => {
+        const a = run([
+            [0, 0, 0],
+            [3, 0, 0],
+        ]);
+        const near = run([
+            [3.03, 0, 0],
+            [6, 0, 0],
+        ]); // 3 cm — joined
+        const far = run([
+            [3.2, 0, 4],
+            [6, 0, 4],
+        ]); // 20 cm in another row — separate
+        const components = buildPortComponents(sceneOf(a, near, far));
+        expect(components.length).toBe(2);
+    });
+    test('nodes without ports do not participate', () => {
+        const wall = makeNode('wall', {});
+        const a = run([
+            [0, 0, 0],
+            [3, 0, 0],
+        ]);
+        const components = buildPortComponents(sceneOf(wall, a));
+        expect(components.length).toBe(1);
+        expect(components[0]).toEqual([a.id]);
+    });
+});
+describe('summarizeSystemFor', () => {
+    test('full tree: equipment → run → terminal, stats add up', () => {
+        const furnace = makeNode('hvac-equipment', { position: [0, 0, 0] });
+        const trunk = run([
+            [0, 0, 0],
+            [4, 0, 0],
+        ]);
+        const branch = run([
+            [4, 0, 0],
+            [4, 0, 3],
+        ]);
+        const register = makeNode('duct-terminal', {
+            position: [4, 0, 3],
+            terminalType: 'supply-register',
+        });
+        const scene = sceneOf(furnace, trunk, branch, register);
+        const summary = summarizeSystemFor(register.id, scene);
+        expect(summary.nodeIds.length).toBe(4);
+        expect(summary.connectedToEquipment).toBe(true);
+        expect(summary.runCount).toBe(2);
+        expect(summary.runLengthM).toBeCloseTo(7, 6);
+        expect(summary.terminalCount).toBe(1);
+        expect(summary.equipmentCount).toBe(1);
+        expect(summary.systems).toEqual(['supply']);
+    });
+    test('orphaned run reports no equipment', () => {
+        const lonely = run([
+            [10, 0, 10],
+            [14, 0, 10],
+        ]);
+        const summary = summarizeSystemFor(lonely.id, sceneOf(lonely));
+        expect(summary.connectedToEquipment).toBe(false);
+        expect(summary.runCount).toBe(1);
+        expect(summary.runLengthM).toBeCloseTo(4, 6);
+    });
+    test('port-less node → null', () => {
+        const wall = makeNode('wall', {});
+        expect(summarizeSystemFor(wall.id, sceneOf(wall))).toBeNull();
+    });
+});

package/dist/services/validate-dwv.d.ts

@@ -0,0 +1,32 @@
+import type { AnyNode, AnyNodeId } from '../schema';
+/**
+ * IPC validators for the DWV (drain-waste-vent) system — the "CodeRule"
+ * primitive from the domain brief. The slope, minimum-size, and
+ * trap-arm rules are all geometric and read straight off the node
+ * fields, so they live here in core (pure logic) where the editor can
+ * surface them and analyses can reuse them.
+ *
+ * Scope is residential IPC, simplified:
+ *   - 704.1 drainage slope by pipe size.
+ *   - 909 trap-arm maximum developed length by trap size.
+ *
+ * These are intentionally conservative approximations, not a certified
+ * plan-check — enough to flag the mistakes a drawing tool invites.
+ */
+/** Drainage findings, worst-first per consumer's sort. */
+export type DwvSeverity = 'error' | 'warning';
+export type DwvFinding = {
+    severity: DwvSeverity;
+    /** Stable rule id, e.g. 'slope-too-flat'. */
+    code: string;
+    /** Human-readable, already-formatted message. */
+    message: string;
+    /** Nodes the finding implicates (usually one). */
+    nodeIds: AnyNodeId[];
+};
+/**
+ * Run every DWV rule over the scene and return the findings. Empty
+ * array = nothing to flag. Pure: no scene/store access, no rendering.
+ */
+export declare function validateDwv(nodes: Readonly<Record<AnyNodeId, AnyNode>>): DwvFinding[];
+//# sourceMappingURL=validate-dwv.d.ts.map

package/dist/services/validate-dwv.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-dwv.d.ts","sourceRoot":"","sources":["../../src/services/validate-dwv.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAGnD;;;;;;;;;;;;;GAaG;AAEH,0DAA0D;AAC1D,MAAM,MAAM,WAAW,GAAG,OAAO,GAAG,SAAS,CAAA;AAE7C,MAAM,MAAM,UAAU,GAAG;IACvB,QAAQ,EAAE,WAAW,CAAA;IACrB,6CAA6C;IAC7C,IAAI,EAAE,MAAM,CAAA;IACZ,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAA;IACf,kDAAkD;IAClD,OAAO,EAAE,SAAS,EAAE,CAAA;CACrB,CAAA;AAuDD;;;GAGG;AACH,wBAAgB,WAAW,CAAC,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAAG,UAAU,EAAE,CAwErF"}

package/dist/services/validate-dwv.js

@@ -0,0 +1,118 @@
+import { buildPortComponents } from './system-graph';
+/** IPC 704.1 minimum drainage slope (rise/run, dimensionless) by
+ *  nominal pipe size: ¼"/ft (1:48) under 3", ⅛"/ft (1:96) for 3–6",
+ *  1/16"/ft (1:192) at 8"+. */
+function minSlopeFor(diameterIn) {
+    if (diameterIn < 3)
+        return 1 / 48;
+    if (diameterIn < 8)
+        return 1 / 96;
+    return 1 / 192;
+}
+/** IPC Table 909.1 maximum trap-arm developed length (meters) by trap
+ *  size: 30" @ 1¼", 42" @ 1½", 60" @ 2", 72" @ 3", 120" @ 4". */
+const TRAP_ARM_MAX_M = [
+    [1.25, 30 * 0.0254],
+    [1.5, 42 * 0.0254],
+    [2, 60 * 0.0254],
+    [3, 72 * 0.0254],
+    [4, 120 * 0.0254],
+];
+function trapArmMaxFor(diameterIn) {
+    let max = Infinity;
+    for (const [size, lengthM] of TRAP_ARM_MAX_M) {
+        if (diameterIn <= size)
+            return lengthM;
+        max = lengthM;
+    }
+    return max;
+}
+/** Slopes shallower than this fraction of the minimum are flagged
+ *  "too flat" — a small tolerance keeps round-off off the list. */
+const SLOPE_TOLERANCE = 0.9;
+/** Horizontal legs shorter than this (meters) are treated as vertical
+ *  stacks and skipped from the slope check. */
+const VERTICAL_LEG_EPS_M = 0.02;
+function legSlope(a, b) {
+    const horizontalM = Math.hypot(b[0] - a[0], b[2] - a[2]);
+    if (horizontalM < VERTICAL_LEG_EPS_M)
+        return { horizontalM, slope: Infinity };
+    return { horizontalM, slope: Math.abs(a[1] - b[1]) / horizontalM };
+}
+function inchLabel(value) {
+    return `${value}"`;
+}
+/** Per-foot slope as a readable fraction, e.g. 0.0208 → '¼"/ft'. */
+function slopePerFootLabel(slope) {
+    const inchesPerFoot = slope * 12;
+    return `${inchesPerFoot.toFixed(2)}"/ft`;
+}
+/**
+ * Run every DWV rule over the scene and return the findings. Empty
+ * array = nothing to flag. Pure: no scene/store access, no rendering.
+ */
+export function validateDwv(nodes) {
+    const findings = [];
+    // ── Per-segment slope (waste only) ──────────────────────────────
+    for (const node of Object.values(nodes)) {
+        if (node?.type !== 'pipe-segment' || node.system !== 'waste')
+            continue;
+        const path = node.path;
+        const minSlope = minSlopeFor(node.diameter);
+        const maxSlope = node.diameter / 12; // 1 pipe-diameter per foot → siphoning
+        let flaggedFlat = false;
+        let flaggedSteep = false;
+        for (let i = 0; i < path.length - 1; i++) {
+            const { slope } = legSlope(path[i], path[i + 1]);
+            if (slope === Infinity)
+                continue; // vertical stack leg
+            if (!flaggedFlat && slope < minSlope * SLOPE_TOLERANCE) {
+                findings.push({
+                    severity: 'error',
+                    code: 'slope-too-flat',
+                    message: `${inchLabel(node.diameter)} drain slopes ${slopePerFootLabel(slope)} — IPC 704.1 requires at least ${slopePerFootLabel(minSlope)}.`,
+                    nodeIds: [node.id],
+                });
+                flaggedFlat = true;
+            }
+            if (!flaggedSteep && slope > maxSlope) {
+                findings.push({
+                    severity: 'warning',
+                    code: 'slope-too-steep',
+                    message: `${inchLabel(node.diameter)} drain slopes ${slopePerFootLabel(slope)} — over one pipe-diameter per foot risks siphoning the traps.`,
+                    nodeIds: [node.id],
+                });
+                flaggedSteep = true;
+            }
+        }
+    }
+    // ── Component-scoped trap rules ──────────────────────────────────
+    for (const component of buildPortComponents(nodes)) {
+        const traps = [];
+        for (const id of component) {
+            const node = nodes[id];
+            if (!node)
+                continue;
+            if (node.type === 'pipe-trap') {
+                traps.push(node);
+            }
+        }
+        // Trap-arm developed length: trap outlet → its vent, capped by size.
+        // Independent of waste segments — a trap on its own can already be
+        // over-armed.
+        for (const trap of traps) {
+            const t = trap;
+            const armLengthM = t.armLengthM ?? 0;
+            const maxArm = trapArmMaxFor(t.diameter);
+            if (armLengthM > maxArm + 1e-6) {
+                findings.push({
+                    severity: 'error',
+                    code: 'trap-arm-too-long',
+                    message: `${inchLabel(t.diameter)} trap arm runs ${(armLengthM / 0.0254).toFixed(0)}" to its vent — IPC 909.1 caps it at ${(maxArm / 0.0254).toFixed(0)}".`,
+                    nodeIds: [t.id],
+                });
+            }
+        }
+    }
+    return findings;
+}

package/dist/services/validate-dwv.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=validate-dwv.test.d.ts.map

package/dist/services/validate-dwv.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-dwv.test.d.ts","sourceRoot":"","sources":["../../src/services/validate-dwv.test.ts"],"names":[],"mappings":""}

package/dist/services/validate-dwv.test.js

@@ -0,0 +1,109 @@
+import { describe, expect, test } from 'bun:test';
+import { registerNode } from '../registry';
+import { validateDwv } from './validate-dwv';
+// The validator reads node fields directly + buildPortComponents (which
+// consults def.ports), so register stub port-providers for the DWV kinds
+// it groups by. Mirrors the system-graph test's approach.
+function stubDef(kind, ports) {
+    registerNode({
+        kind,
+        schemaVersion: 1,
+        schema: {},
+        category: 'utility',
+        defaults: () => ({}),
+        capabilities: {},
+        ports,
+    });
+}
+stubDef('pipe-segment', (node) => {
+    const path = node.path;
+    const diameter = node.diameter;
+    const system = node.system;
+    return [
+        { id: 'start', position: path[0], direction: [-1, 0, 0], diameter, system },
+        {
+            id: 'end',
+            position: path[path.length - 1],
+            direction: [1, 0, 0],
+            diameter,
+            system,
+        },
+    ];
+});
+stubDef('pipe-trap', (node) => {
+    const position = node.position;
+    return [{ id: 'inlet', position, direction: [0, 1, 0], diameter: 1.5, system: 'waste' }];
+});
+let nextId = 0;
+function makeNode(type, fields) {
+    nextId += 1;
+    return { id: `${type}_${nextId}`, type, object: 'node', parentId: null, ...fields };
+}
+function sceneOf(...nodes) {
+    return Object.fromEntries(nodes.map((n) => [n.id, n]));
+}
+/** A waste run from a→b. Drop the end Y to slope it. */
+function waste(path, diameter = 2) {
+    return makeNode('pipe-segment', { path, diameter, system: 'waste' });
+}
+const QUARTER_PER_FOOT = 1 / 48;
+describe('validateDwv — slope', () => {
+    test('flags a flat waste run', () => {
+        const run = waste([
+            [0, 0, 0],
+            [3, 0, 0], // dead level
+        ]);
+        const findings = validateDwv(sceneOf(run));
+        expect(findings.some((f) => f.code === 'slope-too-flat')).toBe(true);
+    });
+    test('passes a run sloped at quarter-inch per foot', () => {
+        const drop = 3 * QUARTER_PER_FOOT;
+        const run = waste([
+            [0, 0, 0],
+            [3, -drop, 0],
+        ]);
+        const findings = validateDwv(sceneOf(run));
+        expect(findings.some((f) => f.code === 'slope-too-flat')).toBe(false);
+    });
+    test('flags an over-steep run (siphoning risk)', () => {
+        // 2" pipe, max slope = 2/12 ≈ 0.167; drop 2m over 1m horizontal.
+        const run = waste([
+            [0, 0, 0],
+            [1, -2, 0],
+        ]);
+        const findings = validateDwv(sceneOf(run));
+        expect(findings.some((f) => f.code === 'slope-too-steep')).toBe(true);
+    });
+    test('ignores vents (level is fine)', () => {
+        const vent = makeNode('pipe-segment', {
+            path: [
+                [0, 0, 0],
+                [0, 3, 0],
+            ],
+            diameter: 2,
+            system: 'vent',
+        });
+        const findings = validateDwv(sceneOf(vent));
+        expect(findings.length).toBe(0);
+    });
+});
+describe('validateDwv — trap arm', () => {
+    test('flags an over-long trap arm', () => {
+        const trap = makeNode('pipe-trap', {
+            position: [0, 0, 0],
+            diameter: 1.5, // max arm 42in = 1.067m
+            armLengthM: 2, // way over
+        });
+        const findings = validateDwv(sceneOf(trap));
+        expect(findings.some((f) => f.code === 'trap-arm-too-long')).toBe(true);
+    });
+    test('passes a trap arm within the limit', () => {
+        const trap = makeNode('pipe-trap', {
+            position: [0, 0, 0],
+            diameter: 2, // max arm 60in = 1.524m
+            armLengthM: 1,
+        });
+        const findings = validateDwv(sceneOf(trap));
+        expect(findings.some((f) => f.code === 'trap-arm-too-long')).toBe(false);
+    });
+});

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

@@ -0,0 +1,17 @@
+import { z } from 'zod';
+export declare const SolarPanelPresetKey: z.ZodEnum<{
+    residential: "residential";
+    "residential-large": "residential-large";
+    compact: "compact";
+    frameless: "frameless";
+}>;
+export type SolarPanelPresetKey = z.infer<typeof SolarPanelPresetKey>;
+export type SolarPanelPresetDims = {
+    panelWidth: number;
+    panelHeight: number;
+    frameThickness: number;
+    frameDepth: number;
+};
+export declare const SOLAR_PANEL_PRESETS: Record<SolarPanelPresetKey, SolarPanelPresetDims>;
+export declare const SOLAR_PANEL_PRESET_LABELS: Record<SolarPanelPresetKey, string>;
+//# sourceMappingURL=solar-panel-presets.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"solar-panel-presets.d.ts","sourceRoot":"","sources":["../src/solar-panel-presets.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAOvB,eAAO,MAAM,mBAAmB;;;;;EAK9B,CAAA;AACF,MAAM,MAAM,mBAAmB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,mBAAmB,CAAC,CAAA;AAErE,MAAM,MAAM,oBAAoB,GAAG;IACjC,UAAU,EAAE,MAAM,CAAA;IAClB,WAAW,EAAE,MAAM,CAAA;IACnB,cAAc,EAAE,MAAM,CAAA;IACtB,UAAU,EAAE,MAAM,CAAA;CACnB,CAAA;AAED,eAAO,MAAM,mBAAmB,EAAE,MAAM,CAAC,mBAAmB,EAAE,oBAAoB,CAyBjF,CAAA;AAED,eAAO,MAAM,yBAAyB,EAAE,MAAM,CAAC,mBAAmB,EAAE,MAAM,CAKzE,CAAA"}

package/dist/solar-panel-presets.js

@@ -0,0 +1,43 @@
+import { z } from 'zod';
+// Vendor-neutral visual presets. Picking one writes the four `panelWidth`,
+// `panelHeight`, `frameThickness`, `frameDepth` fields onto a SolarPanelNode.
+// Manually editing any of those four fields clears the preset back to undefined
+// ("Custom") so the schema's `panelTypePreset` always matches the dims.
+export const SolarPanelPresetKey = z.enum([
+    'residential',
+    'residential-large',
+    'compact',
+    'frameless',
+]);
+export const SOLAR_PANEL_PRESETS = {
+    residential: {
+        panelWidth: 1.0,
+        panelHeight: 1.65,
+        frameThickness: 0.04,
+        frameDepth: 0.04,
+    },
+    'residential-large': {
+        panelWidth: 1.0,
+        panelHeight: 2.0,
+        frameThickness: 0.04,
+        frameDepth: 0.04,
+    },
+    compact: {
+        panelWidth: 0.83,
+        panelHeight: 1.0,
+        frameThickness: 0.03,
+        frameDepth: 0.035,
+    },
+    frameless: {
+        panelWidth: 1.0,
+        panelHeight: 1.65,
+        frameThickness: 0.005,
+        frameDepth: 0.025,
+    },
+};
+export const SOLAR_PANEL_PRESET_LABELS = {
+    residential: 'Residential',
+    'residential-large': 'Residential Large',
+    compact: 'Compact',
+    frameless: 'Frameless',
+};

package/dist/store/actions/node-actions.d.ts

@@ -1,12 +1,24 @@
 import { type AnyNode, type AnyNodeId } from '../../schema';
 import type { SceneState } from '../use-scene';
-export declare const createNodesAction: (set: (fn: (state: SceneState) => Partial<SceneState>) => void, get: () => SceneState, ops: {
+type NodeCreateOp = {
     node: AnyNode;
     parentId?: AnyNodeId;
-}[]) => void;
+};
+type NodeUpdateOp = {
+    id: AnyNodeId;
+    data: Partial<AnyNode>;
+};
+type NodeDeleteOp = AnyNodeId;
+export declare const createNodesAction: (set: (fn: (state: SceneState) => Partial<SceneState>) => void, get: () => SceneState, ops: NodeCreateOp[]) => void;
+export declare const applyNodeChangesAction: (set: (fn: (state: SceneState) => Partial<SceneState>) => void, get: () => SceneState, changes: {
+    create?: NodeCreateOp[];
+    update?: NodeUpdateOp[];
+    delete?: NodeDeleteOp[];
+}) => void;
 export declare const updateNodesAction: (set: (fn: (state: SceneState) => Partial<SceneState>) => void, get: () => SceneState, updates: {
     id: AnyNodeId;
     data: Partial<AnyNode>;
 }[]) => void;
 export declare const deleteNodesAction: (set: (fn: (state: SceneState) => Partial<SceneState>) => void, get: () => SceneState, ids: AnyNodeId[]) => void;
+export {};
 //# sourceMappingURL=node-actions.d.ts.map

package/dist/store/actions/node-actions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAIf,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AA+N9C,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,EAAE,SA+C/C,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SA+DrD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SAsGjB,CAAA"}
+{"version":3,"file":"node-actions.d.ts","sourceRoot":"","sources":["../../../src/store/actions/node-actions.ts"],"names":[],"mappings":"AACA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EASf,MAAM,cAAc,CAAA;AAErB,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,cAAc,CAAA;AAG9C,KAAK,YAAY,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAA;AAC3D,KAAK,YAAY,GAAG;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAA;AAC7D,KAAK,YAAY,GAAG,SAAS,CAAA;AA0uB7B,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,YAAY,EAAE,SAkDpB,CAAA;AAED,eAAO,MAAM,sBAAsB,GACjC,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAC;IAAC,MAAM,CAAC,EAAE,YAAY,EAAE,CAAA;CAAE,SAyIvF,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,SAAS;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,EAAE,SAoFrD,CAAA;AAED,eAAO,MAAM,iBAAiB,GAC5B,KAAK,CAAC,EAAE,EAAE,CAAC,KAAK,EAAE,UAAU,KAAK,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,EAC7D,KAAK,MAAM,UAAU,EACrB,KAAK,SAAS,EAAE,SAqIjB,CAAA"}