@pascal-app/nodes 0.1.1

package/dist/slab/panel.d.ts

@@ -0,0 +1,14 @@
+/**
+ * Phase 5 Stage E — slab inspector (kind-owned).
+ *
+ * 1:1 port of the legacy `SlabPanel`. Mounted via
+ * `parametrics.customPanel` because the slab editor has shape-specific
+ * concerns (elevation presets, area display, holes list with auto-
+ * vs-manual provenance) that don't fit the auto-derived
+ * `<ParametricInspector>` field model yet. When the inspector grows
+ * `list` / `computed` / `action` field kinds, this panel collapses
+ * into `parametrics.groups`.
+ */
+export declare function SlabPanel(): import("react").JSX.Element | null;
+export default SlabPanel;
+//# sourceMappingURL=panel.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/slab/panel.tsx"],"names":[],"mappings":"AAmBA;;;;;;;;;;GAUG;AACH,wBAAgB,SAAS,uCAiQxB;AAED,eAAe,SAAS,CAAA"}

package/dist/slab/panel.js

@@ -0,0 +1,144 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs, Fragment as _Fragment } from "react/jsx-runtime";
+import { useScene } from '@pascal-app/core';
+import { ActionButton, ActionGroup, holeEditScope, PanelSection, PanelWrapper, SliderControl, 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';
+/**
+ * Phase 5 Stage E — slab inspector (kind-owned).
+ *
+ * 1:1 port of the legacy `SlabPanel`. Mounted via
+ * `parametrics.customPanel` because the slab editor has shape-specific
+ * concerns (elevation presets, area display, holes list with auto-
+ * vs-manual provenance) that don't fit the auto-derived
+ * `<ParametricInspector>` field model yet. When the inspector grows
+ * `list` / `computed` / `action` field kinds, this panel collapses
+ * into `parametrics.groups`.
+ */
+export function SlabPanel() {
+    const selectedId = useViewer((s) => s.selection.selectedIds[0]);
+    const setSelection = useViewer((s) => s.setSelection);
+    const editingHole = useEditingHole();
+    const setMovingNode = useEditor((s) => s.setMovingNode);
+    const node = useScene((s) => selectedId ? s.nodes[selectedId] : undefined);
+    // See "Panel slider-drag fix recipe" in plans/editor-node-registry.md.
+    // Stable handler refs across re-renders so slider drags don't trigger
+    // a Maximum update depth cascade on the panel's SliderControls.
+    const nodeRef = useRef(node);
+    nodeRef.current = node;
+    const handleUpdate = useCallback((updates) => {
+        if (!selectedId)
+            return;
+        useScene.getState().updateNode(selectedId, updates);
+    }, [selectedId]);
+    const handleClose = useCallback(() => {
+        setSelection({ selectedIds: [] });
+        useInteractionScope
+            .getState()
+            .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'hole');
+    }, [setSelection]);
+    useEffect(() => {
+        if (!node) {
+            useInteractionScope
+                .getState()
+                .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'hole');
+        }
+    }, [node]);
+    useEffect(() => {
+        return () => {
+            useInteractionScope
+                .getState()
+                .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'hole');
+        };
+    }, []);
+    const handleAddHole = useCallback(() => {
+        if (!(node && selectedId))
+            return;
+        const polygon = node.polygon;
+        let cx = 0;
+        let cz = 0;
+        for (const [x, z] of polygon) {
+            cx += x;
+            cz += z;
+        }
+        cx /= polygon.length;
+        cz /= polygon.length;
+        const holeSize = 0.5;
+        const newHole = [
+            [cx - holeSize, cz - holeSize],
+            [cx + holeSize, cz - holeSize],
+            [cx + holeSize, cz + holeSize],
+            [cx - holeSize, cz + holeSize],
+        ];
+        const currentHoles = node?.holes || [];
+        const currentMetadata = currentHoles.map((_, index) => node?.holeMetadata?.[index] ?? { source: 'manual' });
+        handleUpdate({
+            holes: [...currentHoles, newHole],
+            holeMetadata: [...currentMetadata, { source: 'manual' }],
+        });
+        useInteractionScope
+            .getState()
+            .begin(holeEditScope({ nodeId: selectedId, holeIndex: currentHoles.length }));
+    }, [node, selectedId, handleUpdate]);
+    const handleEditHole = useCallback((index) => {
+        if (!selectedId)
+            return;
+        useInteractionScope.getState().begin(holeEditScope({ nodeId: selectedId, holeIndex: index }));
+    }, [selectedId]);
+    const handleDeleteHole = useCallback((index) => {
+        if (!selectedId)
+            return;
+        const currentHoles = node?.holes || [];
+        if ((node?.holeMetadata?.[index]?.source ?? 'manual') !== 'manual')
+            return;
+        const newHoles = currentHoles.filter((_, i) => i !== index);
+        const currentMetadata = currentHoles.map((_, metadataIndex) => node?.holeMetadata?.[metadataIndex] ?? { source: 'manual' });
+        const newMetadata = currentMetadata.filter((_, i) => i !== index);
+        handleUpdate({ holes: newHoles, holeMetadata: newMetadata });
+        if (editingHole?.nodeId === selectedId && editingHole?.holeIndex === index) {
+            useInteractionScope
+                .getState()
+                .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'hole');
+        }
+    }, [selectedId, node?.holes, node?.holeMetadata, handleUpdate, editingHole]);
+    const handleMove = useCallback(() => {
+        if (!node)
+            return;
+        triggerSFX('sfx:item-pick');
+        setMovingNode(node);
+        setSelection({ selectedIds: [] });
+    }, [node, setMovingNode, setSelection]);
+    if (!(node && node.type === 'slab' && selectedId))
+        return null;
+    const calculateArea = (polygon) => {
+        if (polygon.length < 3)
+            return 0;
+        let area = 0;
+        const n = polygon.length;
+        for (let i = 0; i < n; i++) {
+            const j = (i + 1) % n;
+            const current = polygon[i];
+            const next = polygon[j];
+            if (!(current && next))
+                continue;
+            area += current[0] * next[1];
+            area -= next[0] * current[1];
+        }
+        return Math.abs(area) / 2;
+    };
+    const area = calculateArea(node.polygon);
+    return (_jsxs(PanelWrapper, { icon: "/icons/floor.webp", onClose: handleClose, title: node.name || 'Slab', width: 320, children: [_jsxs(PanelSection, { title: "Elevation", children: [_jsx(SliderControl, { label: "Height", max: 1, min: -1, onChange: (v) => handleUpdate({ elevation: v }), precision: 3, step: 0.01, unit: "m", value: Math.round(node.elevation * 1000) / 1000 }), _jsxs("div", { className: "mt-2 grid grid-cols-2 gap-1.5 px-1 pb-1", children: [_jsx(ActionButton, { label: "Sunken (-15cm)", onClick: () => handleUpdate({ elevation: -0.15 }) }), _jsx(ActionButton, { label: "Ground (0m)", onClick: () => handleUpdate({ elevation: 0 }) }), _jsx(ActionButton, { label: "Raised (+5cm)", onClick: () => handleUpdate({ elevation: 0.05 }) }), _jsx(ActionButton, { label: "Step (+15cm)", onClick: () => handleUpdate({ elevation: 0.15 }) })] })] }), _jsx(PanelSection, { title: "Info", children: _jsxs("div", { className: "flex items-center justify-between px-2 py-1 text-muted-foreground text-sm", children: [_jsx("span", { children: "Area" }), _jsxs("span", { className: "font-mono text-white", children: [area.toFixed(2), " m\u00B2"] })] }) }), _jsxs(PanelSection, { title: "Holes", children: [node.holes && node.holes.length > 0 ? (_jsx("div", { className: "flex flex-col gap-1 pb-2", children: node.holes.map((hole, index) => {
+                            const holeArea = calculateArea(hole);
+                            const isEditing = editingHole?.nodeId === selectedId && editingHole?.holeIndex === index;
+                            const source = node.holeMetadata?.[index]?.source ?? 'manual';
+                            const isAutoHole = source !== 'manual';
+                            const autoLabel = source === 'elevator' ? 'Auto elevator cutout' : 'Auto stair cutout';
+                            return (_jsxs("div", { className: `flex items-center justify-between rounded-lg border p-2 transition-colors ${isEditing
+                                    ? 'border-primary/50 bg-primary/10'
+                                    : 'border-transparent hover:bg-accent/30'}`, children: [_jsxs("div", { className: "min-w-0 flex-1", children: [_jsxs("p", { className: `font-medium text-xs ${isEditing ? 'text-primary' : 'text-white'}`, children: ["Hole ", index + 1, " ", isEditing && '(Editing)'] }), _jsxs("p", { className: "text-[10px] text-muted-foreground", children: [holeArea.toFixed(2), " m\u00B2 \u00B7 ", hole.length, " pts \u00B7", ' ', isAutoHole ? autoLabel : 'Manual'] })] }), _jsx("div", { className: "flex items-center gap-1", children: isEditing ? (_jsx(ActionButton, { className: "h-7 bg-primary text-primary-foreground hover:bg-primary/90", label: "Done", onClick: () => useInteractionScope
+                                                .getState()
+                                                .endIf((scope) => scope.kind === 'reshaping' && scope.reshape === 'hole') })) : isAutoHole ? (_jsx("div", { className: "rounded-md bg-[#2C2C2E] px-2 py-1 text-[10px] text-muted-foreground", children: "Auto" })) : (_jsxs(_Fragment, { children: [_jsx("button", { className: "flex h-7 w-7 items-center justify-center rounded-md bg-[#2C2C2E] text-muted-foreground hover:bg-[#3e3e3e] hover:text-foreground", onClick: () => handleEditHole(index), type: "button", children: _jsx(Edit, { className: "h-3.5 w-3.5" }) }), _jsx("button", { className: "flex h-7 w-7 items-center justify-center rounded-md bg-red-500/10 text-red-400 hover:bg-red-500/20 hover:text-red-300", onClick: () => handleDeleteHole(index), type: "button", children: _jsx(Trash2, { className: "h-3.5 w-3.5" }) })] })) })] }, index));
+                        }) })) : (_jsx("div", { className: "px-2 py-3 text-center text-muted-foreground text-xs", children: "No holes" })), _jsx("div", { className: "px-1 pt-1 pb-1", children: _jsx(ActionButton, { className: "w-full", disabled: editingHole?.nodeId === selectedId, icon: _jsx(Plus, { className: "h-3.5 w-3.5" }), label: "Add Hole", onClick: handleAddHole }) })] }), _jsx(ActionGroup, { children: _jsx(ActionButton, { icon: _jsx(Move, { className: "h-3.5 w-3.5" }), label: "Move", onClick: handleMove }) })] }));
+}
+export default SlabPanel;

package/dist/slab/parametrics.d.ts

@@ -0,0 +1,14 @@
+import type { ParametricDescriptor } from '@pascal-app/core';
+import type { SlabNode } from './schema';
+/**
+ * Inspector descriptor for slab.
+ *
+ * Mounts the kind-owned `<SlabPanel>` via `customPanel` — the slab
+ * editor has shape-specific concerns (elevation presets, area display,
+ * holes list with auto-vs-manual provenance) that don't fit the
+ * auto-derived field model. `groups` retained as a placeholder for the
+ * future when `list` / `computed` / `action` field kinds let this
+ * collapse into pure parametrics.
+ */
+export declare const slabParametrics: ParametricDescriptor<SlabNode>;
+//# sourceMappingURL=parametrics.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"parametrics.d.ts","sourceRoot":"","sources":["../../src/slab/parametrics.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAA;AAC5D,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAExC;;;;;;;;;GASG;AACH,eAAO,MAAM,eAAe,EAAE,oBAAoB,CAAC,QAAQ,CAQ1D,CAAA"}

package/dist/slab/parametrics.js

@@ -0,0 +1,19 @@
+/**
+ * Inspector descriptor for slab.
+ *
+ * Mounts the kind-owned `<SlabPanel>` via `customPanel` — the slab
+ * editor has shape-specific concerns (elevation presets, area display,
+ * holes list with auto-vs-manual provenance) that don't fit the
+ * auto-derived field model. `groups` retained as a placeholder for the
+ * future when `list` / `computed` / `action` field kinds let this
+ * collapse into pure parametrics.
+ */
+export const slabParametrics = {
+    groups: [
+        {
+            label: 'Elevation',
+            fields: [{ key: 'elevation', kind: 'number', unit: 'm', min: -1, max: 1, step: 0.01 }],
+        },
+    ],
+    customPanel: () => import('./panel'),
+};

package/dist/slab/quick-measurement.d.ts

@@ -0,0 +1,3 @@
+import type { QuickMeasurementReport, SlabNode } from '@pascal-app/core';
+export declare function slabQuickMeasurement(node: SlabNode): QuickMeasurementReport | null;
+//# sourceMappingURL=quick-measurement.d.ts.map

package/dist/slab/quick-measurement.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"quick-measurement.d.ts","sourceRoot":"","sources":["../../src/slab/quick-measurement.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,sBAAsB,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAOxE,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,QAAQ,GAAG,sBAAsB,GAAG,IAAI,CAiClF"}

package/dist/slab/quick-measurement.js

@@ -0,0 +1,35 @@
+import { polygonBoundaryLength, polygonReportAnchor, polygonSurfaceArea, } from '../shared/quick-measurement';
+export function slabQuickMeasurement(node) {
+    if (node.polygon.length < 3)
+        return null;
+    const thickness = node.elevation ?? 0.05;
+    return {
+        title: node.name ?? 'Floor slab',
+        kindLabel: 'Floor slab',
+        anchor: polygonReportAnchor(node.polygon, thickness + 0.04),
+        metrics: [
+            {
+                key: 'area',
+                label: 'Surface',
+                abbreviation: 'A',
+                quantity: 'area',
+                value: polygonSurfaceArea(node.polygon, node.holes),
+            },
+            {
+                key: 'perimeter',
+                label: 'Perimeter',
+                abbreviation: 'P',
+                quantity: 'length',
+                value: polygonBoundaryLength(node.polygon),
+            },
+            {
+                key: 'thickness',
+                label: 'Thickness',
+                abbreviation: 'T',
+                quantity: 'length',
+                value: thickness,
+            },
+        ],
+        note: node.holes.length > 0 ? 'Surface excludes slab openings.' : undefined,
+    };
+}

package/dist/slab/schema.d.ts

@@ -0,0 +1,2 @@
+export { SlabNode } from '@pascal-app/core';
+//# sourceMappingURL=schema.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"schema.d.ts","sourceRoot":"","sources":["../../src/slab/schema.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA"}

package/dist/slab/schema.js

@@ -0,0 +1 @@
+export { SlabNode } from '@pascal-app/core';

package/dist/slab/slots.d.ts

@@ -0,0 +1,10 @@
+import type { SlotDeclaration } from '@pascal-app/core';
+export type SlabSlotId = 'surface' | 'side';
+export declare const SLAB_TOP_SLOT_DEFAULT = "library:wood-woodplank48";
+export declare const SLAB_SIDE_SLOT_DEFAULT = "#cccccc";
+/**
+ * A slab exposes two paintable faces: the top floor surface and its sides
+ * (vertical walls + underside).
+ */
+export declare function slabSlots(): SlotDeclaration[];
+//# sourceMappingURL=slots.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"slots.d.ts","sourceRoot":"","sources":["../../src/slab/slots.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAEvD,MAAM,MAAM,UAAU,GAAG,SAAS,GAAG,MAAM,CAAA;AAU3C,eAAO,MAAM,qBAAqB,6BAA6B,CAAA;AAC/D,eAAO,MAAM,sBAAsB,YAAY,CAAA;AAE/C;;;GAGG;AACH,wBAAgB,SAAS,IAAI,eAAe,EAAE,CAK7C"}

package/dist/slab/slots.js

@@ -0,0 +1,20 @@
+// Declared default appearances for an unpainted slab in colored mode — a
+// catalog `library:<id>` finish or a `#rrggbb` colour. Textures-off collapses
+// both to the themed floor role (the escape hatch).
+//
+// `surface` (top face) keeps the wood floor default and the slot id used before
+// the top/side split, so existing painted slabs keep their floor finish. `side`
+// (walls + underside) defaults to a light grey so a slab's edges read as a
+// distinct trim rather than wood end-grain.
+export const SLAB_TOP_SLOT_DEFAULT = 'library:wood-woodplank48';
+export const SLAB_SIDE_SLOT_DEFAULT = '#cccccc';
+/**
+ * A slab exposes two paintable faces: the top floor surface and its sides
+ * (vertical walls + underside).
+ */
+export function slabSlots() {
+    return [
+        { slotId: 'surface', label: 'Top', default: SLAB_TOP_SLOT_DEFAULT },
+        { slotId: 'side', label: 'Sides', default: SLAB_SIDE_SLOT_DEFAULT },
+    ];
+}

package/dist/slab/system.d.ts

@@ -0,0 +1,3 @@
+declare const SlabSystems: () => null;
+export default SlabSystems;
+//# sourceMappingURL=system.d.ts.map

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

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

package/dist/slab/system.js

@@ -0,0 +1,63 @@
+'use client';
+import { useScene, } from '@pascal-app/core';
+import { useEffect } from 'react';
+/**
+ * Slab dependency tracker. The renderable slab polygon derives from level
+ * context — wall centerlines/thickness (exterior flush offsets) and sibling
+ * slab polygons (interior centerline seams) — none of which lives on the slab
+ * node itself. Store updates only dirty the node that changed, so a wall
+ * thickness edit or a neighbour slab add/remove/reshape would leave stale
+ * slab meshes. Watch a per-level signature of those inputs and dirty every
+ * slab on a level whose signature moved; `GeometrySystem` then rebuilds
+ * them through `def.geometry` as usual.
+ */
+function levelSlabContextSignatures(nodes) {
+    const partsByLevel = new Map();
+    const push = (levelId, part) => {
+        const parts = partsByLevel.get(levelId);
+        if (parts)
+            parts.push(part);
+        else
+            partsByLevel.set(levelId, [part]);
+    };
+    for (const node of Object.values(nodes)) {
+        const levelId = node.parentId;
+        if (!levelId)
+            continue;
+        if (node.type === 'wall') {
+            const wall = node;
+            push(levelId, `w|${wall.id}|${wall.start[0]},${wall.start[1]}|${wall.end[0]},${wall.end[1]}|${wall.thickness ?? ''}|${wall.curveOffset ?? ''}`);
+        }
+        else if (node.type === 'slab') {
+            const slab = node;
+            // Elevation is a seam input: an unequal-elevation seam projects to
+            // the lower side's wall face, so a height change reshapes siblings.
+            push(levelId, `s|${slab.id}|${slab.elevation ?? ''}|${slab.polygon.map(([x, z]) => `${x},${z}`).join(';')}`);
+        }
+    }
+    const signatures = new Map();
+    for (const [levelId, parts] of partsByLevel.entries()) {
+        signatures.set(levelId, parts.sort().join('||'));
+    }
+    return signatures;
+}
+const SlabSystems = () => {
+    useEffect(() => {
+        let previous = levelSlabContextSignatures(useScene.getState().nodes);
+        return useScene.subscribe((state) => {
+            const current = levelSlabContextSignatures(state.nodes);
+            for (const [levelId, signature] of current.entries()) {
+                if (previous.get(levelId) === signature)
+                    continue;
+                for (const node of Object.values(state.nodes)) {
+                    if (node.type === 'slab' && node.parentId === levelId) {
+                        state.markDirty(node.id);
+                    }
+                }
+            }
+            previous = current;
+        });
+    }, []);
+    return null;
+};
+export default SlabSystems;

package/dist/slab/tool.d.ts

@@ -0,0 +1,3 @@
+export declare const SlabTool: React.FC;
+export default SlabTool;
+//# sourceMappingURL=tool.d.ts.map

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

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

package/dist/slab/tool.js

@@ -0,0 +1,204 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { DEFAULT_ANGLE_STEP, emitter, snapPointAlongAngleRay, snapPointToGrid, useScene, } from '@pascal-app/core';
+import { CursorSphere, clearSlabSnapFeedback, EDITOR_LAYER, isAngleSnapActive, isGridSnapActive, markToolCancelConsumed, resolveSlabPlanPointSnap, triggerSFX, useEditor, } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { useEffect, useMemo, useRef, useState } from 'react';
+import { BufferGeometry, DoubleSide, Shape, Vector3 } from 'three';
+import { SlabNode } from './schema';
+/**
+ * Phase 5 Stage D — slab placement tool (kind-owned via `def.tool`).
+ *
+ * Multi-click polygon drawing: each click adds a vertex; clicking near
+ * the first vertex (or double-clicking) closes the polygon and creates
+ * the slab. Shift-modifier defeats the 15° angle snap during drag.
+ *
+ * Not a `DragAction` — same reasoning as `tool.tsx` for fence: this is
+ * a stateful sequence of grid:click events with preview state, not a
+ * single pointer-down → drag-up.
+ */
+const Y_OFFSET = 0.02;
+function commitSlabDrawing(levelId, points) {
+    const { createNode, nodes } = useScene.getState();
+    const slabCount = Object.values(nodes).filter((n) => n.type === 'slab').length;
+    const name = `Slab ${slabCount + 1}`;
+    // A placed slab preset seeds `toolDefaults.slab` (thickness, material, …)
+    // before the tool activates; the drawn polygon always wins.
+    const defaults = useEditor.getState().toolDefaults.slab ?? {};
+    const slab = SlabNode.parse({ ...defaults, name, polygon: points });
+    createNode(slab, levelId);
+    triggerSFX('sfx:structure-build');
+    return slab.id;
+}
+export const SlabTool = () => {
+    const cursorRef = useRef(null);
+    const mainLineRef = useRef(null);
+    const closingLineRef = useRef(null);
+    const currentLevelId = useViewer((s) => s.selection.levelId);
+    const setSelection = useViewer((s) => s.setSelection);
+    const [points, setPoints] = useState([]);
+    const [cursorPosition, setCursorPosition] = useState([0, 0]);
+    const [snappedCursorPosition, setSnappedCursorPosition] = useState([0, 0]);
+    const [levelY, setLevelY] = useState(0);
+    const previousSnappedPointRef = useRef(null);
+    // Clear preset-seeded defaults on deactivation so a later manual slab draw
+    // isn't built with a stale preset's parameters. Unmount-only.
+    useEffect(() => () => useEditor.getState().setToolDefaults('slab', null), []);
+    useEffect(() => () => clearSlabSnapFeedback(), []);
+    // Publish the live vertex count so the HUD shows "Finish" only at ≥ 3 points.
+    useEffect(() => {
+        useEditor.getState().setDraftVertexCount(points.length);
+    }, [points.length]);
+    useEffect(() => () => useEditor.getState().setDraftVertexCount(0), []);
+    useEffect(() => {
+        if (!currentLevelId)
+            return;
+        const onGridMove = (event) => {
+            if (!cursorRef.current)
+                return;
+            const rawPoint = [event.localPosition[0], event.localPosition[2]];
+            // Slab drafting is the 'polygon' snap context (grid / lines / off — no
+            // angle, no Shift bypass; Shift cycles the mode, Off is the bypass).
+            const gridStep = isGridSnapActive() ? useEditor.getState().gridSnapStep : 0;
+            const gridPosition = [...snapPointToGrid(rawPoint, gridStep)];
+            setCursorPosition(gridPosition);
+            setLevelY(event.localPosition[1]);
+            const lastPoint = points[points.length - 1];
+            // Angle lock only when the mode asks for it (polygon never does today, but
+            // honour the flag so the behaviour follows the HUD).
+            const orthoPoint = isAngleSnapActive() && lastPoint
+                ? [...snapPointAlongAngleRay(lastPoint, rawPoint, DEFAULT_ANGLE_STEP, gridStep)]
+                : gridPosition;
+            const displayPoint = resolveSlabPlanPointSnap({
+                rawPoint,
+                fallbackPoint: orthoPoint,
+                levelId: currentLevelId,
+            }).point;
+            setSnappedCursorPosition(displayPoint);
+            if (points.length > 0 &&
+                previousSnappedPointRef.current &&
+                (displayPoint[0] !== previousSnappedPointRef.current[0] ||
+                    displayPoint[1] !== previousSnappedPointRef.current[1])) {
+                triggerSFX('sfx:grid-snap');
+            }
+            previousSnappedPointRef.current = displayPoint;
+            cursorRef.current.position.set(displayPoint[0], event.localPosition[1], displayPoint[1]);
+        };
+        const onGridClick = (_event) => {
+            if (!currentLevelId)
+                return;
+            const clickPoint = previousSnappedPointRef.current ?? cursorPosition;
+            const firstPoint = points[0];
+            if (points.length >= 3 &&
+                firstPoint &&
+                Math.abs(clickPoint[0] - firstPoint[0]) < 0.25 &&
+                Math.abs(clickPoint[1] - firstPoint[1]) < 0.25) {
+                const slabId = commitSlabDrawing(currentLevelId, points);
+                setSelection({ selectedIds: [slabId] });
+                setPoints([]);
+                clearSlabSnapFeedback();
+            }
+            else {
+                // Every non-closing vertex is a "start" tick; the closing click above
+                // fires the structure-build (end) cue.
+                triggerSFX('sfx:structure-build-start');
+                setPoints([...points, clickPoint]);
+            }
+        };
+        // Finish the polygon (Enter or double-click): commit once there are enough
+        // vertices. Closing near the first vertex (in onGridClick) is the third way.
+        const finishDrawing = () => {
+            if (points.length < 3)
+                return;
+            const slabId = commitSlabDrawing(currentLevelId, points);
+            setSelection({ selectedIds: [slabId] });
+            setPoints([]);
+            clearSlabSnapFeedback();
+        };
+        const onGridDoubleClick = (_event) => {
+            finishDrawing();
+        };
+        const onCancel = () => {
+            if (points.length > 0)
+                markToolCancelConsumed();
+            setPoints([]);
+            clearSlabSnapFeedback();
+        };
+        const onKeyDown = (e) => {
+            if (e.key === 'Enter') {
+                e.preventDefault();
+                finishDrawing();
+            }
+        };
+        document.addEventListener('keydown', onKeyDown);
+        emitter.on('grid:move', onGridMove);
+        emitter.on('grid:click', onGridClick);
+        emitter.on('grid:double-click', onGridDoubleClick);
+        emitter.on('tool:cancel', onCancel);
+        return () => {
+            document.removeEventListener('keydown', onKeyDown);
+            emitter.off('grid:move', onGridMove);
+            emitter.off('grid:click', onGridClick);
+            emitter.off('grid:double-click', onGridDoubleClick);
+            emitter.off('tool:cancel', onCancel);
+        };
+    }, [currentLevelId, points, cursorPosition, setSelection]);
+    useEffect(() => {
+        if (!(mainLineRef.current && closingLineRef.current))
+            return;
+        if (points.length === 0) {
+            mainLineRef.current.visible = false;
+            closingLineRef.current.visible = false;
+            return;
+        }
+        const y = levelY + Y_OFFSET;
+        const snappedCursor = snappedCursorPosition;
+        const linePoints = points.map(([x, z]) => new Vector3(x, y, z));
+        linePoints.push(new Vector3(snappedCursor[0], y, snappedCursor[1]));
+        if (linePoints.length >= 2) {
+            mainLineRef.current.geometry.dispose();
+            mainLineRef.current.geometry = new BufferGeometry().setFromPoints(linePoints);
+            mainLineRef.current.visible = true;
+        }
+        else {
+            mainLineRef.current.visible = false;
+        }
+        const firstPoint = points[0];
+        if (points.length >= 2 && firstPoint) {
+            const closingPoints = [
+                new Vector3(snappedCursor[0], y, snappedCursor[1]),
+                new Vector3(firstPoint[0], y, firstPoint[1]),
+            ];
+            closingLineRef.current.geometry.dispose();
+            closingLineRef.current.geometry = new BufferGeometry().setFromPoints(closingPoints);
+            closingLineRef.current.visible = true;
+        }
+        else {
+            closingLineRef.current.visible = false;
+        }
+    }, [points, snappedCursorPosition, levelY]);
+    const previewShape = useMemo(() => {
+        if (points.length < 3)
+            return null;
+        const snappedCursor = snappedCursorPosition;
+        const allPoints = [...points, snappedCursor];
+        const firstPt = allPoints[0];
+        if (!firstPt)
+            return null;
+        const shape = new Shape();
+        shape.moveTo(firstPt[0], -firstPt[1]);
+        for (let i = 1; i < allPoints.length; i++) {
+            const pt = allPoints[i];
+            if (pt)
+                shape.lineTo(pt[0], -pt[1]);
+        }
+        shape.closePath();
+        return shape;
+    }, [points, snappedCursorPosition]);
+    return (_jsxs("group", { children: [_jsx(CursorSphere, { ref: cursorRef }), previewShape && (_jsxs("mesh", { frustumCulled: false, layers: EDITOR_LAYER, position: [0, levelY + Y_OFFSET, 0], rotation: [-Math.PI / 2, 0, 0], children: [_jsx("shapeGeometry", { args: [previewShape] }), _jsx("meshBasicMaterial", { color: "#818cf8", depthTest: false, opacity: 0.15, side: DoubleSide, transparent: true })] })), _jsxs("line", { frustumCulled: false, layers: EDITOR_LAYER, 
+                // @ts-expect-error
+                ref: mainLineRef, renderOrder: 1, visible: false, children: [_jsx("bufferGeometry", {}), _jsx("lineBasicNodeMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, linewidth: 3 })] }), _jsxs("line", { frustumCulled: false, layers: EDITOR_LAYER, 
+                // @ts-expect-error
+                ref: closingLineRef, renderOrder: 1, visible: false, children: [_jsx("bufferGeometry", {}), _jsx("lineBasicNodeMaterial", { color: "#818cf8", depthTest: false, depthWrite: false, linewidth: 2, opacity: 0.5, transparent: true })] }), points.map(([x, z], index) => (_jsx(CursorSphere, { color: "#818cf8", height: 0, position: [x, levelY + Y_OFFSET + 0.01, z], showTooltip: false }, index)))] }));
+};
+export default SlabTool;

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

@@ -0,0 +1,15 @@
+import { type NodeDefinition } from '@pascal-app/core';
+import { SolarPanelNode } from './schema';
+/**
+ * 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>;
+//# sourceMappingURL=definition.d.ts.map

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

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