@pascal-app/nodes 1.0.7 → 1.1.1

package/dist/slab/definition.js

@@ -1,334 +1,4 @@
-import { liftedManualSlab, MIN_SLAB_THICKNESS, markSlabChangeDependents, pointInPolygon2D, slabSlots, syncStairRises, } from '@pascal-app/core';
-import { clearStructuralElevationGuide, DRAFTING_SURFACE_EXTENSION_KEY, publishStructuralElevationGuide, resolveStructuralElevationSnap, } from '@pascal-app/editor';
-import { surfaceBatchable } from '../shared/node-batch/batchable.js';
-import { polygonMeasurementFeatures } from '../shared/polygon-measurement.js';
-import { sameOutlineSurfaceCounterparts } from '../shared/surface-counterparts.js';
-import { applySlabBaseElevationChange, applySlabThicknessChange, applySlabTopChange, getSlabBaseElevation, slabElevationUpperBound, } from './elevation-limit.js';
-import { buildSlabFloorplan } from './floorplan.js';
-import { slabAddVertexAffordance, slabDeleteVertexAffordance, slabMoveEdgeAffordance, slabMoveVertexAffordance, } from './floorplan-affordances.js';
-import { slabFloorplanMoveTarget } from './floorplan-move.js';
-import { buildSlabGeometry } from './geometry.js';
-import { slabPaint } from './paint.js';
-import { slabParametrics } from './parametrics.js';
-import { slabQuickMeasurement } from './quick-measurement.js';
-import { SlabNode } from './schema.js';
-const HEIGHT_HANDLE_OFFSET = 0.22;
-const MIN_SLAB_ELEVATION = -1;
-function polygonVertexAverage(polygon) {
-    if (polygon.length === 0)
-        return [0, 0];
-    let cx = 0;
-    let cz = 0;
-    for (const [x, z] of polygon) {
-        cx += x;
-        cz += z;
-    }
-    return [cx / polygon.length, cz / polygon.length];
-}
-function pointIsOnSolidSlab(point, slab) {
-    if (!pointInPolygon2D(point, slab.polygon, { includeBoundary: false }))
-        return false;
-    return !(slab.holes ?? []).some((hole) => hole.length >= 3 && pointInPolygon2D(point, hole, { includeBoundary: true }));
-}
-function slabHandleAnchor(slab) {
-    const polygon = slab.polygon ?? [];
-    const fallback = polygonVertexAverage(polygon);
-    if (polygon.length < 3)
-        return fallback;
-    if (pointIsOnSolidSlab(fallback, slab))
-        return fallback;
-    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 polygon) {
-        minX = Math.min(minX, x);
-        maxX = Math.max(maxX, x);
-        minZ = Math.min(minZ, z);
-        maxZ = Math.max(maxZ, z);
-    }
-    const candidates = [];
-    for (const point of polygon) {
-        candidates.push([
-            fallback[0] + (point[0] - fallback[0]) * 0.35,
-            fallback[1] + (point[1] - fallback[1]) * 0.35,
-        ]);
-    }
-    const steps = 12;
-    for (let xi = 1; xi < steps; xi += 1) {
-        const x = minX + ((maxX - minX) * xi) / steps;
-        for (let zi = 1; zi < steps; zi += 1) {
-            const z = minZ + ((maxZ - minZ) * zi) / steps;
-            candidates.push([x, z]);
-        }
-    }
-    let best = null;
-    let bestDistance = Number.POSITIVE_INFINITY;
-    for (const candidate of candidates) {
-        if (!pointIsOnSolidSlab(candidate, slab))
-            continue;
-        const dx = candidate[0] - fallback[0];
-        const dz = candidate[1] - fallback[1];
-        const distance = dx * dx + dz * dz;
-        if (distance < bestDistance) {
-            best = candidate;
-            bestDistance = distance;
-        }
-    }
-    return best ?? fallback;
-}
-function slabElevationGuideSource(slab) {
-    return {
-        nodeId: slab.id,
-        levelId: slab.parentId,
-        anchor: slabHandleAnchor(slab),
-    };
-}
-function slabChangePreviewOverrides(slab, patch, sceneApi) {
-    const next = { ...slab, ...patch };
-    const nodes = { ...sceneApi.nodes(), [slab.id]: next };
-    const previews = new Map();
-    markSlabChangeDependents(slab, next, nodes, (id) => previews.set(id, {}));
-    for (const update of syncStairRises(nodes)) {
-        const segment = nodes[update.id];
-        if (segment?.type !== 'stair-segment' ||
-            !segment.parentId ||
-            !previews.has(segment.parentId)) {
-            continue;
-        }
-        previews.set(update.id, update.data);
-    }
-    return [...previews];
-}
-function slabRecessedDepthHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        min: MIN_SLAB_ELEVATION,
-        max: (n, sceneApi) => slabElevationUpperBound(sceneApi.nodes(), n),
-        currentValue: (n) => n.elevation ?? 0.05,
-        magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(slabElevationGuideSource(n), newValue, sceneApi.nodes()),
-        onDrag: (n, sceneApi) => publishStructuralElevationGuide(slabElevationGuideSource(n), n.elevation ?? 0.05, sceneApi.nodes()),
-        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
-        apply: (n, newValue) => applySlabTopChange(n, newValue),
-        previewOverrides: (n, newValue, sceneApi) => slabChangePreviewOverrides(n, applySlabTopChange(n, newValue), sceneApi),
-        placement: {
-            position: (n) => {
-                const [cx, cz] = slabHandleAnchor(n);
-                const elevation = n.elevation ?? 0.05;
-                return [cx, elevation + HEIGHT_HANDLE_OFFSET, cz];
-            },
-        },
-    };
-}
-function slabThicknessHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        min: MIN_SLAB_THICKNESS,
-        max: (n, sceneApi) => Math.max(MIN_SLAB_THICKNESS, slabElevationUpperBound(sceneApi.nodes(), n) - getSlabBaseElevation(n)),
-        currentValue: (n) => n.thickness ?? 0.05,
-        magneticSnap: (n, newThickness, sceneApi) => {
-            const base = getSlabBaseElevation(n);
-            const snappedTop = resolveStructuralElevationSnap(slabElevationGuideSource(n), base + newThickness, sceneApi.nodes());
-            return Math.max(MIN_SLAB_THICKNESS, snappedTop - base);
-        },
-        onDrag: (n, sceneApi) => publishStructuralElevationGuide(slabElevationGuideSource(n), n.elevation ?? 0.05, sceneApi.nodes()),
-        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
-        apply: (n, newThickness) => applySlabThicknessChange(n, newThickness),
-        previewOverrides: (n, newThickness, sceneApi) => slabChangePreviewOverrides(n, applySlabThicknessChange(n, newThickness), sceneApi),
-        placement: {
-            position: (n) => {
-                const [cx, cz] = slabHandleAnchor(n);
-                return [cx, (n.elevation ?? 0.05) + HEIGHT_HANDLE_OFFSET, cz];
-            },
-        },
-    };
-}
-function slabBaseElevationHandle() {
-    return {
-        kind: 'linear-resize',
-        axis: 'y',
-        anchor: 'min',
-        shape: 'tracker',
-        gridSnap: true,
-        min: (n) => MIN_SLAB_ELEVATION - (n.thickness ?? 0.05),
-        max: (n, sceneApi) => slabElevationUpperBound(sceneApi.nodes(), n) - (n.thickness ?? 0.05),
-        currentValue: (n) => getSlabBaseElevation(n),
-        magneticSnap: (n, newValue, sceneApi) => resolveStructuralElevationSnap(slabElevationGuideSource(n), newValue, sceneApi.nodes()),
-        onDrag: (n, sceneApi) => publishStructuralElevationGuide(slabElevationGuideSource(n), getSlabBaseElevation(n), sceneApi.nodes()),
-        onDragEnd: (n) => clearStructuralElevationGuide(n.id),
-        apply: (n, newBase) => applySlabBaseElevationChange(n, newBase),
-        previewOverrides: (n, newBase, sceneApi) => slabChangePreviewOverrides(n, applySlabBaseElevationChange(n, newBase), sceneApi),
-        placement: {
-            position: (n) => {
-                const [cx, cz] = slabHandleAnchor(n);
-                return [cx, getSlabBaseElevation(n), cz];
-            },
-        },
-    };
-}
-function slabHandles(node) {
-    // A footprint's floor (base plate) has one control, its height above the
-    // ground, drawn by the editor's footprint height handle; room plates are
-    // reached through their room. Only user-drawn slabs keep these handles.
-    if (node.plateRole)
-        return [];
-    return node.recessed
-        ? [slabRecessedDepthHandle()]
-        : [slabThicknessHandle(), slabBaseElevationHandle()];
-}
-/**
- * Slab — Phase 5 batch kind, polygon-based. Stage B: `def.geometry`
- * drives the rebuild via generic <GeometrySystem>; <ParametricNodeRenderer>
- * mounts the empty group, which the slab's renderer composes with the build
- * of its surface script.
- *
- * Capabilities:
- *  - **No `movable`**: slab's "move" today is whole-slab translation via
- *    legacy `MoveSlabTool`, which integrates with the floor-plan boundary /
- *    hole editors. Capability-driven dispatch keeps the legacy mover.
- *  - **`surfaces.top`**: items host on the slab top at `elevation`.
- *  - `selectable`, `duplicable`, `deletable` standard.
- *
- * Relations:
- *  - `hosts: ['item']` — items mount on the slab top.
- *  - `cascadeDelete: 'descendants'` — deleting a slab removes hosted items.
- */
-export const slabDefinition = {
-    kind: 'slab',
-    snapProfile: 'structural',
-    schemaVersion: 1,
-    schema: SlabNode,
-    category: 'structure',
-    surfaceRole: 'floor',
-    extensions: {
-        [DRAFTING_SURFACE_EXTENSION_KEY]: {
-            kind: 'slab',
-        },
-        'pascal:editor/floorplan': {
-            selectionCounterparts: sameOutlineSurfaceCounterparts,
-        },
-    },
-    defaults: () => ({
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        polygon: [],
-        holes: [],
-        holeMetadata: [],
-        elevation: 0.05,
-        thickness: 0.05,
-        recessed: false,
-        autoFromWalls: false,
-    }),
-    capabilities: {
-        reveal: { phase: 'foundation', style: 'settle', height: 0.08 },
-        revealOnEdit: [
-            'polygon',
-            'holes',
-            'elevation',
-            'thickness',
-            'recessed',
-            'recessedRimElevation',
-        ],
-        batchable: surfaceBatchable,
-        selectable: { hitVolume: 'bbox' },
-        surfaces: {
-            top: {
-                height: (n) => n.elevation,
-                supportHeight: (node, x, z, context) => {
-                    const slab = node;
-                    if (slab.polygon.length < 3 ||
-                        !pointInPolygon2D([x, z], slab.polygon, { includeBoundary: true }) ||
-                        slab.holes.some((hole) => hole.length >= 3 && pointInPolygon2D([x, z], hole, { includeBoundary: false })))
-                        return null;
-                    return liftedManualSlab(context.nodes, slab).elevation;
-                },
-            },
-        },
-        duplicable: true,
-        deletable: true,
-        // Unified slot model: one paintable floor surface with a declared default,
-        // painted through the registry `capabilities.paint` dispatch like the shelf.
-        slots: () => slabSlots(),
-        paint: slabPaint,
-    },
-    relations: {
-        hosts: ['item'],
-        cascadeDelete: 'descendants',
-    },
-    parametrics: slabParametrics,
-    handles: slabHandles,
-    measurement: {
-        features: (node) => polygonMeasurementFeatures({
-            featurePrefix: 'slab',
-            height: node.elevation,
-            label: 'Slab',
-            polygon: node.polygon,
-        }),
-        quickMeasure: (node) => slabQuickMeasurement(node),
-    },
-    // Stage D: kind-owned placement tool. Multi-click polygon drawing
-    // with 15° angle snap (Shift to defeat).
-    tool: () => import('./tool.js'),
-    // Stage D — all four slab drag-affordances live in this folder.
-    // boundary-edit / hole-edit are thin <PolygonEditor> wrappers; move
-    // is a 1:1 port of the legacy MoveSlabTool (scene.update per tick
-    // with the same history dance, no live-drag exception).
-    affordanceTools: {
-        'boundary-edit': () => import('./boundary-editor.js'),
-        'hole-edit': () => import('./hole-editor.js'),
-        move: () => import('./move-tool.js'),
-    },
-    renderer: {
-        kind: 'parametric',
-        module: () => import('./renderer.js'),
-    },
-    // Stage B: pure geometry function.
-    geometry: buildSlabGeometry,
-    // Dependency tracker only — dirties level slabs when walls / sibling
-    // slabs change, since the renderable polygon derives from level context.
-    system: {
-        module: () => import('./system.js'),
-        priority: 4,
-    },
-    // The fill reads walls + sibling slabs via ctx (per-edge render offsets),
-    // so committed sibling edits must invalidate the cached floor-plan entry.
-    floorplanDependsOnSiblings: true,
-    // Stage C: floor-plan rendering. Legacy `slabPolygons` short-circuits
-    // to [] when slab is registered (see floorplan-panel.tsx).
-    floorplan: buildSlabFloorplan,
-    // 2D move handler — translates polygon by cursor delta from first
-    // pointer position. The 3D `MoveSlabTool` in `affordanceTools.move`
-    // skips events sourced from the 2D scene so the two paths don't
-    // double-write on commit.
-    floorplanMoveTarget: slabFloorplanMoveTarget,
-    // Sister to `affordanceTools['boundary-edit']` (the 3D `PolygonEditor`
-    // wrapper). The 2D version edits the same `polygon` field via SVG
-    // pointer events on the vertex handles emitted by `def.floorplan`.
-    floorplanAffordances: {
-        'move-vertex': slabMoveVertexAffordance,
-        'add-vertex': slabAddVertexAffordance,
-        'move-edge': slabMoveEdgeAffordance,
-        'delete-vertex': slabDeleteVertexAffordance,
-    },
-    toolHints: [
-        { key: 'Left click', label: 'Trace slab outline' },
-        { key: 'Enter', label: 'Finish slab', minDraftVertices: 3 },
-        { key: 'Esc', label: 'Cancel' },
-    ],
-    presentation: {
-        label: 'Slab',
-        description: 'A polygon-bounded floor surface that hosts items on top.',
-        icon: { kind: 'url', src: '/icons/floor.webp' },
-        paletteSection: 'structure',
-        paletteOrder: 30,
-    },
-    mcp: {
-        description: 'A polygon-bounded slab (floor) with optional cutout holes.',
-    },
-};
+import { composeNodeDefinition } from '../definition-contributions.js';
+import { slabEditContribution } from './definition.edit.js';
+import { slabRenderDefinition } from './definition.render.js';
+export const slabDefinition = composeNodeDefinition(slabRenderDefinition, slabEditContribution);

package/dist/slab/definition.render.d.ts

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

package/dist/slab/definition.render.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"definition.render.d.ts","sourceRoot":"","sources":["../../src/slab/definition.render.ts"],"names":[],"mappings":"AAMA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAMvE,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAEnC,eAAO,MAAM,oBAAoB,EAAE,oBAAoB,CAAC,OAAO,QAAQ,CAAC,GAAG;IAAE,IAAI,EAAE,MAAM,CAAA;CA8FxF,CAAA"}

package/dist/slab/definition.render.js

@@ -0,0 +1,96 @@
+import { liftedManualSlab, pointInPolygon2D, slabSlots, } from '@pascal-app/core';
+import { surfaceBatchable } from '../shared/node-batch/batchable.js';
+import { polygonMeasurementFeatures } from '../shared/polygon-measurement.js';
+import { buildSlabFloorplan } from './floorplan.js';
+import { buildSlabGeometry } from './geometry.js';
+import { slabQuickMeasurement } from './quick-measurement.js';
+import { SlabNode } from './schema.js';
+export const slabRenderDefinition = {
+    kind: 'slab',
+    schemaVersion: 1,
+    schema: SlabNode,
+    category: 'structure',
+    surfaceRole: 'floor',
+    defaults: () => ({
+        object: 'node',
+        parentId: null,
+        visible: true,
+        metadata: {},
+        polygon: [],
+        holes: [],
+        holeMetadata: [],
+        elevation: 0.05,
+        thickness: 0.05,
+        recessed: false,
+        autoFromWalls: false,
+    }),
+    capabilities: {
+        reveal: { phase: 'foundation', style: 'settle', height: 0.08 },
+        revealOnEdit: [
+            'polygon',
+            'holes',
+            'elevation',
+            'thickness',
+            'recessed',
+            'recessedRimElevation',
+        ],
+        batchable: surfaceBatchable,
+        selectable: { hitVolume: 'bbox' },
+        surfaces: {
+            top: {
+                height: (n) => n.elevation,
+                supportHeight: (node, x, z, context) => {
+                    const slab = node;
+                    if (slab.polygon.length < 3 ||
+                        !pointInPolygon2D([x, z], slab.polygon, { includeBoundary: true }) ||
+                        slab.holes.some((hole) => hole.length >= 3 && pointInPolygon2D([x, z], hole, { includeBoundary: false })))
+                        return null;
+                    return liftedManualSlab(context.nodes, slab).elevation;
+                },
+            },
+        },
+        duplicable: true,
+        deletable: true,
+        // Unified slot model: one paintable floor surface with a declared default,
+        // painted through the registry `capabilities.paint` dispatch like the shelf.
+        slots: () => slabSlots(),
+    },
+    relations: {
+        hosts: ['item'],
+        cascadeDelete: 'descendants',
+    },
+    measurement: {
+        features: (node) => polygonMeasurementFeatures({
+            featurePrefix: 'slab',
+            height: node.elevation,
+            label: 'Slab',
+            polygon: node.polygon,
+        }),
+        quickMeasure: (node) => slabQuickMeasurement(node),
+    },
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    // Stage B: pure geometry function.
+    geometry: buildSlabGeometry,
+    // Dependency tracker only — dirties level slabs when walls / sibling
+    // slabs change, since the renderable polygon derives from level context.
+    system: {
+        module: () => import('./system.js'),
+        priority: 4,
+    },
+    // Stage C: floor-plan rendering. Legacy `slabPolygons` short-circuits
+    // to [] when slab is registered (see floorplan-panel.tsx).
+    floorplan: buildSlabFloorplan,
+    presentation: {
+        label: 'Slab',
+        description: 'A polygon-bounded floor surface that hosts items on top.',
+        icon: { kind: 'url', src: '/icons/floor.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 30,
+    },
+    mcp: {
+        description: 'A polygon-bounded slab (floor) with optional cutout holes.',
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/slab/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAIpB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAGzB;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAE3D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAgGjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/slab/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAKpB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAEzB;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAE3D;AAED;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAgGjG"}

package/dist/slab/floorplan.js

@@ -1,5 +1,4 @@
-import { cutterContextNodes, getRenderableSlabPolygon, hostedCutterHoles, isDerivedNode, slabPolygonContextFromGeometry, } from '@pascal-app/core';
-import { readFloorplanContext } from '@pascal-app/editor';
+import { cutterContextNodes, getRenderableSlabPolygon, hostedCutterHoles, isDerivedNode, readFloorplanContext, slabPolygonContextFromGeometry, } from '@pascal-app/core';
 /**
  * Whether the plan offers the slab's outline and hole handles: only a slab the
  * user drew. A floor plate's outline (and its room-cut holes) follow the rooms

package/dist/slab/panel.js

@@ -1,8 +1,8 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { formatFixed, isDerivedNode, MIN_SLAB_THICKNESS, usePascalI18n, useScene, } from '@pascal-app/core';
+import { formatAreaLabel, formatFixed, getAreaUnitLabel, isDerivedNode, MIN_SLAB_THICKNESS, squareMetersToAreaUnit, usePascalI18n, useScene, } from '@pascal-app/core';
 import { setSlabSurfaceScript } from '@pascal-app/core/agent-operations';
-import { ActionButton, ActionGroup, FloorFoundationPanel, formatAreaLabel, getAreaUnitLabel, holeEditScope, PanelSection, PanelWrapper, ScriptedFinishRow, SegmentedControl, ShapeChoice, SliderControl, squareMetersToAreaUnit, startOpeningDraft, triggerSFX, useEditingHole, useEditor, useInteractionScope, } from '@pascal-app/editor';
+import { ActionButton, ActionGroup, FloorFoundationPanel, holeEditScope, PanelSection, PanelWrapper, ScriptedFinishRow, SegmentedControl, ShapeChoice, SliderControl, startOpeningDraft, triggerSFX, useEditingHole, useEditor, useInteractionScope, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { Edit, Move, Plus, Trash2 } from 'lucide-react';
 import { useCallback, useEffect, useRef } from 'react';

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

@@ -1,15 +1,146 @@
-import { type NodeDefinition } from '@pascal-app/core';
-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
- * 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 declare const solarPanelDefinition: NodeDefinition<typeof SolarPanelNode>;
+export declare const solarPanelDefinition: import("@pascal-app/core").NodeDefinition<import("zod").ZodObject<{
+    object: import("zod").ZodDefault<import("zod").ZodLiteral<"node">>;
+    name: import("zod").ZodOptional<import("zod").ZodString>;
+    parentId: import("zod").ZodDefault<import("zod").ZodNullable<import("zod").ZodString>>;
+    visible: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodBoolean>>;
+    camera: import("zod").ZodOptional<import("zod").ZodObject<{
+        position: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        target: import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>;
+        mode: import("zod").ZodDefault<import("zod").ZodEnum<{
+            orthographic: "orthographic";
+            perspective: "perspective";
+        }>>;
+        fov: import("zod").ZodOptional<import("zod").ZodNumber>;
+        zoom: import("zod").ZodOptional<import("zod").ZodNumber>;
+    }, import("zod/v4/core").$strip>>;
+    metadata: import("zod").ZodDefault<import("zod").ZodOptional<import("zod").ZodRecord<import("zod").ZodString, import("zod").ZodUnknown>>>;
+    provenance: import("zod").ZodOptional<import("zod").ZodObject<{
+        refs: import("zod").ZodArray<import("zod").ZodObject<{
+            ns: import("zod").ZodOptional<import("zod").ZodString>;
+            id: import("zod").ZodString;
+            role: import("zod").ZodOptional<import("zod").ZodEnum<{
+                absorbed: "absorbed";
+                alias: "alias";
+                derived: "derived";
+                piece: "piece";
+                primary: "primary";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        lineage: import("zod").ZodOptional<import("zod").ZodObject<{
+            op: import("zod").ZodEnum<{
+                attach: "attach";
+                convert: "convert";
+                duplicate: "duplicate";
+                import: "import";
+                "make-independent": "make-independent";
+                merge: "merge";
+                promote: "promote";
+                split: "split";
+            }>;
+            fromIds: import("zod").ZodArray<import("zod").ZodString>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    id: import("zod").ZodDefault<import("zod").ZodTemplateLiteral<`solarpanel_${string}`>>;
+    type: import("zod").ZodDefault<import("zod").ZodLiteral<"solar-panel">>;
+    material: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    materialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    panelMaterial: import("zod").ZodOptional<import("zod").ZodObject<{
+        id: import("zod").ZodOptional<import("zod").ZodString>;
+        preset: import("zod").ZodOptional<import("zod").ZodCatch<import("zod").ZodEnum<{
+            brick: "brick";
+            concrete: "concrete";
+            custom: "custom";
+            glass: "glass";
+            marble: "marble";
+            metal: "metal";
+            plaster: "plaster";
+            tile: "tile";
+            white: "white";
+            wood: "wood";
+        }>>>;
+        properties: import("zod").ZodOptional<import("zod").ZodObject<{
+            color: import("zod").ZodDefault<import("zod").ZodString>;
+            roughness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            metalness: import("zod").ZodDefault<import("zod").ZodNumber>;
+            opacity: import("zod").ZodDefault<import("zod").ZodNumber>;
+            transparent: import("zod").ZodDefault<import("zod").ZodBoolean>;
+            side: import("zod").ZodDefault<import("zod").ZodEnum<{
+                back: "back";
+                double: "double";
+                front: "front";
+            }>>;
+        }, import("zod/v4/core").$strip>>;
+        texture: import("zod").ZodOptional<import("zod").ZodObject<{
+            url: import("zod").ZodString;
+            repeat: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            scale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            offset: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+            normalMap: import("zod").ZodOptional<import("zod").ZodString>;
+            normalScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+            bumpMap: import("zod").ZodOptional<import("zod").ZodString>;
+            bumpScale: import("zod").ZodOptional<import("zod").ZodNumber>;
+        }, import("zod/v4/core").$strip>>;
+    }, import("zod/v4/core").$strip>>;
+    panelMaterialPreset: import("zod").ZodOptional<import("zod").ZodString>;
+    panelTypePreset: import("zod").ZodOptional<import("zod").ZodEnum<{
+        compact: "compact";
+        frameless: "frameless";
+        residential: "residential";
+        "residential-large": "residential-large";
+    }>>;
+    roofSegmentId: import("zod").ZodOptional<import("zod").ZodString>;
+    position: import("zod").ZodDefault<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+    rotation: import("zod").ZodDefault<import("zod").ZodNumber>;
+    rows: import("zod").ZodDefault<import("zod").ZodNumber>;
+    columns: import("zod").ZodDefault<import("zod").ZodNumber>;
+    panelWidth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    panelHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    gapX: import("zod").ZodDefault<import("zod").ZodNumber>;
+    gapY: import("zod").ZodDefault<import("zod").ZodNumber>;
+    mountingType: import("zod").ZodDefault<import("zod").ZodEnum<{
+        flush: "flush";
+        tilted: "tilted";
+    }>>;
+    tiltAngle: import("zod").ZodDefault<import("zod").ZodNumber>;
+    standoffHeight: import("zod").ZodDefault<import("zod").ZodNumber>;
+    frameThickness: import("zod").ZodDefault<import("zod").ZodNumber>;
+    frameDepth: import("zod").ZodDefault<import("zod").ZodNumber>;
+    surfaceNormal: import("zod").ZodOptional<import("zod").ZodTuple<[import("zod").ZodNumber, import("zod").ZodNumber, import("zod").ZodNumber], null>>;
+}, import("zod/v4/core").$strip>>;
 //# sourceMappingURL=definition.d.ts.map

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,CA2DtE,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/solar-panel/definition.ts"],"names":[],"mappings":"AAIA,eAAO,MAAM,oBAAoB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iCAGhC,CAAA"}

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

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

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

@@ -0,0 +1 @@
+{"version":3,"file":"definition.edit.d.ts","sourceRoot":"","sources":["../../src/solar-panel/definition.edit.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,6BAA6B,CAAA;AAEvE,OAAO,KAAK,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AAwN9C,eAAO,MAAM,0BAA0B,EAAE,oBAAoB,CAAC,OAAO,cAAc,CAalF,CAAA"}