@pascal-app/nodes 1.0.0-beta.5 → 1.0.0

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/window/panel.tsx"],"names":[],"mappings":"AA6FA,MAAM,CAAC,OAAO,UAAU,WAAW,uCAy1BlC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/window/panel.tsx"],"names":[],"mappings":"AA6FA,MAAM,CAAC,OAAO,UAAU,WAAW,uCA21BlC"}

package/dist/window/panel.js

@@ -149,6 +149,8 @@ export default function WindowPanel() {
             rotation: [...node.rotation],
             side: node.side,
             wallId: node.wallId,
+            dormerId: node.dormerId,
+            dormerFace: node.dormerFace,
             roofSegmentId: node.roofSegmentId,
             roofFace: node.roofFace,
             parentId: node.parentId,

package/dist/window/parametrics.js

@@ -10,8 +10,8 @@ export const windowParametrics = {
         {
             label: 'Dimensions',
             fields: [
-                { key: 'width', kind: 'number', unit: 'm', min: 0.3, max: 4, step: 0.05 },
-                { key: 'height', kind: 'number', unit: 'm', min: 0.3, max: 4, step: 0.05 },
+                { key: 'width', kind: 'number', unit: 'm', min: 0.3, max: 1000, step: 0.05 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.3, max: 1000, step: 0.05 },
             ],
         },
     ],

package/dist/window/renderer.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/window/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAA+C,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAW/F,eAAO,MAAM,cAAc,GAAI,UAAU;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCA8C5D,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/window/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAA+C,KAAK,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAW/F,eAAO,MAAM,cAAc,GAAI,UAAU;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,gCA4C5D,CAAA;AAED,eAAe,cAAc,CAAA"}

package/dist/window/renderer.js

@@ -12,10 +12,8 @@ export const WindowRenderer = ({ node }) => {
     }, [node.id]);
     const handlers = useNodeEvents(node, 'window');
     const shading = useViewer((s) => s.shading);
-    const liveVisible = useLiveNodeOverrides((s) => {
-        const visible = s.get(node.id)?.visible;
-        return typeof visible === 'boolean' ? visible : undefined;
-    });
+    const liveOverrides = useLiveNodeOverrides((s) => s.get(node.id));
+    const renderNode = liveOverrides ? { ...node, ...liveOverrides } : node;
     const isTransient = !!node.metadata?.isTransient;
     const material = useMemo(() => {
         const mat = node.material;
@@ -29,9 +27,9 @@ export const WindowRenderer = ({ node }) => {
         node.material?.properties,
         node.material?.texture,
     ]);
-    const mesh = (_jsx("mesh", { material: material, position: node.position, ref: ref, rotation: node.rotation, visible: liveVisible ?? node.visible, ...(isTransient ? {} : handlers), children: _jsx("boxGeometry", { args: [0, 0, 0] }) }));
-    if (!node.roofSegmentId)
+    const mesh = (_jsx("mesh", { material: material, position: renderNode.position, ref: ref, rotation: renderNode.rotation, visible: renderNode.visible, ...(isTransient ? {} : handlers), children: _jsx("boxGeometry", { args: [0, 0, 0] }) }));
+    if (!renderNode.roofSegmentId)
         return mesh;
-    return (_jsx(RoofFaceHostFrame, { roofFace: node.roofFace, roofSegmentId: node.roofSegmentId, children: mesh }));
+    return (_jsx(RoofFaceHostFrame, { roofFace: renderNode.roofFace, roofSegmentId: renderNode.roofSegmentId, children: mesh }));
 };
 export default WindowRenderer;

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/window/tool.tsx"],"names":[],"mappings":"AAgFA;;;;;;;;;GASG;AACH,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EA6uBvB,CAAA;AAED,eAAe,UAAU,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/window/tool.tsx"],"names":[],"mappings":"AA+FA;;;;;;;;;GASG;AACH,QAAA,MAAM,UAAU,EAAE,KAAK,CAAC,EA09BvB,CAAA;AAED,eAAe,UAAU,CAAA"}

package/dist/window/tool.js

@@ -1,10 +1,10 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { emitter, isCurvedWall, sceneRegistry, spatialGridManager, useScene, WallNode as WallNodeSchema, WindowNode, } from '@pascal-app/core';
-import { calculateCursorRotation, calculateItemRotation, EDITOR_LAYER, getSideFromNormal, isMagneticSnapActive, isValidWallSideFace, snapToHalf, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, } from '@pascal-app/editor';
-import { useViewer } from '@pascal-app/viewer';
+import { dormerWallFacePointToDormer, emitter, getEffectiveNode, holdHiddenWallPointerEvents, isCurvedWall, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useScene, WallNode as WallNodeSchema, WindowNode, } from '@pascal-app/core';
+import { calculateItemRotation, clearPlacementSurface, EDITOR_LAYER, getSideFromNormal, isMagneticSnapActive, isValidWallSideFace, publishPlacementSurface, snapToHalf, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, usePlacementPreview, useRegistryToolContext, } from '@pascal-app/editor';
 import { useEffect, useMemo, useRef, useState } from 'react';
 import { BoxGeometry, EdgesGeometry, Vector3 } from 'three';
 import { LineBasicNodeMaterial } from 'three/webgpu';
+import { dormerEventFromHostedWindow, getDormerWindowWorldNormal, getDormerWindowWorldYaw, resolveDormerWindowTarget, } from '../shared/dormer-wall-opening-placement';
 import { clearOpeningGuides3D, publishOpeningGuidesForWallEvent, resolveSillSnap, } from '../shared/opening-guides-runtime';
 import { getRoofWallOpeningCursorPose, resolveRoofWallOpeningTarget, worldToSelectedBuildingLocal, } from '../shared/roof-wall-opening-placement';
 import { collectWallOpeningAlignmentCandidates, resolveWallSlideAlignment, } from '../shared/wall-opening-alignment';
@@ -38,6 +38,7 @@ const roofFallbackPoint = new Vector3();
  * engages only on an actual mesh hover — no proximity magnet.
  */
 const WindowTool = () => {
+    const { activeLevelId, isCameraDragging, selectNode } = useRegistryToolContext();
     const draftRef = useRef(null);
     const cursorGroupRef = useRef(null);
     const edgesRef = useRef(null);
@@ -86,7 +87,7 @@ const WindowTool = () => {
             if (live?.type !== 'window')
                 return;
             draftRef.current = live;
-            publishPlacementPreview(live, parentNode);
+            publishPlacementPreview(getEffectiveNode(live), parentNode);
         };
         let hostKind = null;
         // timeStamp of the most recent wall/roof mesh event. A wall/roof hover and
@@ -100,10 +101,11 @@ const WindowTool = () => {
         // to the last wall hover so the flip shows live before commit.
         let sideFlip = false;
         let lastWallEvent = null;
+        let lastDormerEvent = null;
         // Last open-floor cursor point (level-local X/Z) + floor Y, so an R-flip
         // while free-following can re-render the floating ghost with the new facing.
         let lastFloorPoint = null;
-        const getLevelId = () => useViewer.getState().selection.levelId;
+        const getLevelId = () => activeLevelId;
         const getLevelYOffset = () => {
             const id = getLevelId();
             return id ? (sceneRegistry.nodes.get(id)?.position.y ?? 0) : 0;
@@ -119,6 +121,7 @@ const WindowTool = () => {
                 return;
             }
             const wallId = draft.parentId;
+            useLiveNodeOverrides.getState().clear(draft.id);
             useScene.getState().deleteNode(draft.id);
             draftRef.current = null;
             clearPlacementPreview();
@@ -133,6 +136,7 @@ const WindowTool = () => {
             clearOpeningGuides3D();
             setFallbackPose(null);
             useFacingPose.getState().clear();
+            clearPlacementSurface();
             clearPlacementPreview();
         };
         // Alignment candidates — anchors of every alignable object; refreshed
@@ -203,6 +207,48 @@ const WindowTool = () => {
             const [x, , z] = worldToSelectedBuildingLocal(roofFallbackPoint.set(...event.position));
             showGhostAt([x, getLevelYOffset() + FALLBACK_HEIGHT / 2 + FALLBACK_SILL_LIFT, z], getLevelYOffset());
         };
+        const dormerWindowWorldPosition = (event, target) => {
+            const point = roofFallbackPoint.set(...dormerWallFacePointToDormer(event.node, target.face, target.position));
+            event.object.localToWorld(point);
+            return worldToSelectedBuildingLocal(point);
+        };
+        const applyDormerTarget = (event, target) => {
+            const side = sideFlip ? 'back' : 'front';
+            const itemRotation = sideFlip ? Math.PI : 0;
+            if (draftRef.current && draftRef.current.parentId !== event.node.id)
+                destroyDraft();
+            if (!draftRef.current) {
+                const node = WindowNode.parse({
+                    position: target.position,
+                    rotation: [0, itemRotation, 0],
+                    side,
+                    parentId: event.node.id,
+                    dormerId: event.node.id,
+                    dormerFace: target.face,
+                    metadata: { isTransient: true },
+                });
+                useScene.getState().createNode(node, event.node.id);
+                draftRef.current = node;
+            }
+            else {
+                useLiveNodeOverrides.getState().set(draftRef.current.id, {
+                    position: target.position,
+                    rotation: [0, itemRotation, 0],
+                    side,
+                    parentId: event.node.id,
+                    dormerId: event.node.id,
+                    dormerFace: target.face,
+                    wallId: undefined,
+                    roofSegmentId: undefined,
+                    roofFace: undefined,
+                });
+            }
+            publishDraftPreview(event.node);
+            clearOpeningGuides3D();
+            const worldPosition = dormerWindowWorldPosition(event, target);
+            publishPlacementSurface(new Vector3(...worldPosition), getDormerWindowWorldNormal(event, target));
+            updateCursor(worldPosition, getDormerWindowWorldYaw(event, target), target.valid, 0);
+        };
         // Sill alignment (snap + guide): a sibling sill/centre/top wins over the
         // grid when within threshold — it's the magnetic ("lines") component for the
         // vertical axis, so it runs only when magnetic snap is on; otherwise the
@@ -244,7 +290,7 @@ const WindowTool = () => {
                 height,
             });
             const { clampedX, clampedY } = clampToWall(wall, localX, localY, width, height, useScene.getState().nodes);
-            const valid = !hasWallChildOverlap(wall.id, clampedX, clampedY, width, height, ignoreId);
+            const valid = !hasWallChildOverlap(wall.id, useScene.getState().nodes, clampedX, clampedY, width, height, ignoreId);
             return { clampedX, clampedY, valid };
         };
         // Shared create/update path for the wall draft — used by the direct
@@ -269,7 +315,7 @@ const WindowTool = () => {
             }
             const { clampedX, clampedY, valid } = resolveWallPlacement(wall, rawLocalX, rawLocalY, width, height, applySnap, draftRef.current.id);
             if (wall.id === draftRef.current.parentId) {
-                useScene.getState().updateNode(draftRef.current.id, {
+                useLiveNodeOverrides.getState().set(draftRef.current.id, {
                     position: [clampedX, clampedY, 0],
                     rotation: [0, itemRotation, 0],
                     side,
@@ -277,6 +323,7 @@ const WindowTool = () => {
                 markHostDirty(wall.id);
             }
             else {
+                useLiveNodeOverrides.getState().clear(draftRef.current.id);
                 useScene.getState().updateNode(draftRef.current.id, {
                     position: [clampedX, clampedY, 0],
                     rotation: [0, itemRotation, 0],
@@ -314,6 +361,7 @@ const WindowTool = () => {
             clearPlacementPreview();
             draftRef.current = null;
             hostKind = null;
+            useLiveNodeOverrides.getState().clear(draft.id);
             useScene.getState().deleteNode(draft.id);
             useScene.temporal.getState().resume();
             const levelId = getLevelId();
@@ -349,7 +397,7 @@ const WindowTool = () => {
                 sillThickness: draft.sillThickness,
             });
             useScene.getState().createNode(node, wall.id);
-            useViewer.getState().setSelection({ selectedIds: [node.id] });
+            selectNode(node.id);
             triggerSFX('sfx:structure-build');
             useAlignmentGuides.getState().clear();
             clearOpeningGuides3D();
@@ -362,6 +410,64 @@ const WindowTool = () => {
                 useEditor.getState().setTool(null);
             }
         };
+        const commitWindowAtDormer = (dormer, target) => {
+            const draft = draftRef.current;
+            if (!draft)
+                return;
+            clearPlacementPreview();
+            draftRef.current = null;
+            hostKind = null;
+            useLiveNodeOverrides.getState().clear(draft.id);
+            useScene.getState().deleteNode(draft.id);
+            useScene.temporal.getState().resume();
+            const state = useScene.getState();
+            const windowCount = Object.values(state.nodes).filter((node) => node.type === 'window').length;
+            const side = sideFlip ? 'back' : 'front';
+            const node = WindowNode.parse({
+                name: `Window ${windowCount + 1}`,
+                position: target.position,
+                rotation: [0, sideFlip ? Math.PI : 0, 0],
+                side,
+                parentId: dormer.id,
+                dormerId: dormer.id,
+                dormerFace: target.face,
+                width: draft.width,
+                height: draft.height,
+                material: draft.material,
+                slots: draft.slots,
+                openingKind: draft.openingKind,
+                windowType: draft.windowType,
+                operationState: draft.operationState,
+                awningDirection: draft.awningDirection,
+                casementStyle: draft.casementStyle,
+                hingesSide: draft.hingesSide,
+                openingShape: draft.openingShape,
+                openingRadiusMode: draft.openingRadiusMode,
+                openingCornerRadii: draft.openingCornerRadii,
+                cornerRadius: draft.cornerRadius,
+                archHeight: draft.archHeight,
+                frameThickness: draft.frameThickness,
+                frameDepth: draft.frameDepth,
+                columnRatios: draft.columnRatios,
+                rowRatios: draft.rowRatios,
+                columnDividerThickness: draft.columnDividerThickness,
+                rowDividerThickness: draft.rowDividerThickness,
+                sill: draft.sill,
+                sillDepth: draft.sillDepth,
+                sillThickness: draft.sillThickness,
+            });
+            state.createNode(node, dormer.id);
+            state.dirtyNodes.add(dormer.id);
+            selectNode(node.id);
+            triggerSFX('sfx:structure-build');
+            if (useEditor.getState().getContinuation('point') === 'repeat') {
+                useScene.temporal.getState().pause();
+            }
+            else {
+                hideCursor();
+                useEditor.getState().setTool(null);
+            }
+        };
         // ── Direct wall-mesh hover ──────────────────────────────────────
         const onWallHover = (event) => {
             hostKind = 'wall';
@@ -378,7 +484,12 @@ const WindowTool = () => {
             const side = sideFlip ? (faceSide === 'front' ? 'back' : 'front') : faceSide;
             const flipOffset = sideFlip ? Math.PI : 0;
             const itemRotation = calculateItemRotation(event.normal) + flipOffset;
-            const cursorRotation = calculateCursorRotation(event.normal, event.node.start, event.node.end) + flipOffset;
+            // World yaw of a wall CHILD: the wall group is yawed -wallAngle and the
+            // node carries wall-local `itemRotation` — `calculateCursorRotation` was
+            // π off, pointing the facing triangle at the far side of the wall (see
+            // MoveDoorTool.applyPreview, which fixed the same class for moves).
+            const wallAngle = Math.atan2(event.node.end[1] - event.node.start[1], event.node.end[0] - event.node.start[0]);
+            const cursorRotation = itemRotation - wallAngle;
             applyWallTarget({
                 wall: event.node,
                 rawLocalX: event.localPosition[0],
@@ -421,7 +532,7 @@ const WindowTool = () => {
         // NOT snap from proximity — snapping engages only when the cursor ray
         // actually hovers a wall (onWallHover) or roof face (onRoofHover).
         const onGridFreeFollow = (event) => {
-            if (useViewer.getState().cameraDragging)
+            if (isCameraDragging())
                 return;
             // A wall/roof mesh handler processed this pointermove (shared DOM
             // timeStamp) — it owns the frame and has snapped the draft, so skip the
@@ -437,6 +548,83 @@ const WindowTool = () => {
             destroyDraft();
             showGhostAt([x, y + FALLBACK_HEIGHT / 2 + FALLBACK_SILL_LIFT, z], y);
         };
+        // ── Dormer wall faces ──────────────────────────────────────────
+        // Dormer windows use the same WindowNode mesh and inspector as regular
+        // windows, but their host frame is supplied by DormerRenderer.
+        const resolveDormerTarget = (event) => resolveDormerWindowTarget({
+            event,
+            width: draftRef.current?.width ?? FALLBACK_WIDTH,
+            height: draftRef.current?.height ?? FALLBACK_HEIGHT,
+            nodes: useScene.getState().nodes,
+            ignoreId: draftRef.current?.id,
+            snap: snapToHalf,
+        });
+        const showDormerFallbackCursor = (event) => {
+            const [x, y, z] = worldToSelectedBuildingLocal(roofFallbackPoint.set(...event.position));
+            showGhostAt([x, y, z], y);
+        };
+        const onDormerHover = (event) => {
+            hostKind = 'dormer';
+            lastMeshEventTime = event.nativeEvent?.timeStamp ?? -1;
+            lastDormerEvent = event;
+            const target = resolveDormerTarget(event);
+            if (!target) {
+                destroyDraft();
+                showDormerFallbackCursor(event);
+                return;
+            }
+            applyDormerTarget(event, target);
+            event.stopPropagation();
+        };
+        const onDormerClick = (event) => {
+            if (!draftRef.current || draftRef.current.parentId !== event.node.id)
+                return;
+            const target = resolveDormerTarget(event);
+            if (!target)
+                return;
+            if (!target.valid && event.nativeEvent?.altKey !== true)
+                return;
+            commitWindowAtDormer(event.node, target);
+            event.stopPropagation();
+        };
+        const onDormerLeave = () => {
+            if (hostKind !== 'dormer')
+                return;
+            lastDormerEvent = null;
+            destroyDraft();
+            hideCursor();
+            hostKind = null;
+        };
+        // The default dormer window is a real WindowNode and therefore sits in
+        // front of the dormer body for raycasting. While placing another window,
+        // translate hits on that child back into a dormer-local event so the
+        // placement tool does not fall through to the ground ghost.
+        const dormerEventFromWindow = (event) => {
+            const dormerId = event.node.dormerId ?? event.node.parentId;
+            const dormer = dormerId
+                ? useScene.getState().nodes[dormerId]
+                : undefined;
+            const object = dormer ? sceneRegistry.nodes.get(dormer.id) : undefined;
+            if (!(dormer?.type === 'dormer' && object))
+                return null;
+            return dormerEventFromHostedWindow(event, dormer, object);
+        };
+        const onDormerWindowHover = (event) => {
+            const dormerEvent = dormerEventFromWindow(event);
+            if (dormerEvent)
+                onDormerHover(dormerEvent);
+        };
+        const onDormerWindowClick = (event) => {
+            const dormerEvent = dormerEventFromWindow(event);
+            if (dormerEvent)
+                onDormerClick(dormerEvent);
+        };
+        const onDormerWindowLeave = (event) => {
+            if (event.node.dormerId ||
+                useScene.getState().nodes[event.node.parentId]?.type === 'dormer') {
+                onDormerLeave();
+            }
+        };
         // ── Roof-segment wall faces ─────────────────────────────────────
         // The merged roof mesh emits `roof:*`; hits are resolved against the
         // segments' vertical wall faces (base walls + coplanar gable ends),
@@ -473,7 +661,7 @@ const WindowTool = () => {
             if (draftRef.current && draftRef.current.parentId !== segment.id)
                 destroyDraft();
             if (draftRef.current) {
-                useScene.getState().updateNode(draftRef.current.id, {
+                useLiveNodeOverrides.getState().set(draftRef.current.id, {
                     position,
                     rotation: [0, 0, 0],
                     roofFace: face.id,
@@ -512,6 +700,7 @@ const WindowTool = () => {
             clearPlacementPreview();
             draftRef.current = null;
             hostKind = null;
+            useLiveNodeOverrides.getState().clear(draft.id);
             useScene.getState().deleteNode(draft.id);
             useScene.temporal.getState().resume();
             const state = useScene.getState();
@@ -545,7 +734,7 @@ const WindowTool = () => {
             // Rebuild the segment (and the merged roof) so the wall brush
             // picks up the new opening cut.
             useScene.getState().dirtyNodes.add(segment.id);
-            useViewer.getState().setSelection({ selectedIds: [node.id] });
+            selectNode(node.id);
             triggerSFX('sfx:structure-build');
             if (useEditor.getState().getContinuation('point') === 'repeat') {
                 useScene.temporal.getState().pause();
@@ -586,6 +775,9 @@ const WindowTool = () => {
             if (lastWallEvent) {
                 onWallHover(lastWallEvent);
             }
+            else if (lastDormerEvent) {
+                onDormerHover(lastDormerEvent);
+            }
             else if (lastFloorPoint) {
                 showGhostAt(lastFloorPoint.pos, lastFloorPoint.floorY);
             }
@@ -599,15 +791,29 @@ const WindowTool = () => {
         emitter.on('roof:move', onRoofHover);
         emitter.on('roof:click', onRoofClick);
         emitter.on('roof:leave', onRoofLeave);
+        emitter.on('dormer:enter', onDormerHover);
+        emitter.on('dormer:move', onDormerHover);
+        emitter.on('dormer:click', onDormerClick);
+        emitter.on('dormer:leave', onDormerLeave);
+        emitter.on('window:enter', onDormerWindowHover);
+        emitter.on('window:move', onDormerWindowHover);
+        emitter.on('window:click', onDormerWindowClick);
+        emitter.on('window:leave', onDormerWindowLeave);
         emitter.on('grid:move', onGridFreeFollow);
         emitter.on('tool:cancel', onCancel);
         window.addEventListener('keydown', onKeyDown);
+        // Placement tracks the cursor through wall events; keep walls hidden by
+        // the wall-mode pass (X-ray 'down' mode) pointer-targetable while the
+        // tool is active so a new window still snaps onto them (see the wall
+        // renderer's pointer transparency).
+        const releaseHiddenWallHold = holdHiddenWallPointerEvents();
         return () => {
             destroyDraft();
             hideCursor();
             clearPlacementPreview();
             useAlignmentGuides.getState().clear();
             clearOpeningGuides3D();
+            releaseHiddenWallHold();
             useScene.temporal.getState().resume();
             emitter.off('wall:enter', onWallHover);
             emitter.off('wall:move', onWallHover);
@@ -617,11 +823,19 @@ const WindowTool = () => {
             emitter.off('roof:move', onRoofHover);
             emitter.off('roof:click', onRoofClick);
             emitter.off('roof:leave', onRoofLeave);
+            emitter.off('dormer:enter', onDormerHover);
+            emitter.off('dormer:move', onDormerHover);
+            emitter.off('dormer:click', onDormerClick);
+            emitter.off('dormer:leave', onDormerLeave);
+            emitter.off('window:enter', onDormerWindowHover);
+            emitter.off('window:move', onDormerWindowHover);
+            emitter.off('window:click', onDormerWindowClick);
+            emitter.off('window:leave', onDormerWindowLeave);
             emitter.off('grid:move', onGridFreeFollow);
             emitter.off('tool:cancel', onCancel);
             window.removeEventListener('keydown', onKeyDown);
         };
-    }, []);
+    }, [activeLevelId, isCameraDragging, selectNode]);
     // Cursor geometry: window outline rectangle. Static dims, so build it once and
     // dispose on unmount rather than reallocating (and orphaning) an EdgesGeometry
     // on every re-render during placement.

package/dist/zone/floorplan-affordances.d.ts

@@ -8,9 +8,9 @@ export declare const zoneMoveVertexAffordance: import("@pascal-app/core").Floorp
     polygon: [number, number][];
     autoFromWalls: boolean;
     boundaryWallIds: `wall_${string}`[];
-    spaceRole: "generic" | "room";
+    spaceRole: "room" | "generic";
     roomNumber: string;
-    enclosureStatus: "auto" | "enclosed" | "open";
+    enclosureStatus: "auto" | "open" | "enclosed";
     floorFinish: string;
     wallFinish: string;
     ceilingFinish: string;
@@ -18,7 +18,7 @@ export declare const zoneMoveVertexAffordance: import("@pascal-app/core").Floorp
     occupancy: string;
     clearDimensionPolicy: "none" | "inside-faces" | "finish-faces";
     color: string;
-    metadata: import("zod").JSONType;
+    metadata: Record<string, unknown>;
     camera?: {
         position: [number, number, number];
         target: [number, number, number];
@@ -37,9 +37,9 @@ export declare const zoneAddVertexAffordance: import("@pascal-app/core").Floorpl
     polygon: [number, number][];
     autoFromWalls: boolean;
     boundaryWallIds: `wall_${string}`[];
-    spaceRole: "generic" | "room";
+    spaceRole: "room" | "generic";
     roomNumber: string;
-    enclosureStatus: "auto" | "enclosed" | "open";
+    enclosureStatus: "auto" | "open" | "enclosed";
     floorFinish: string;
     wallFinish: string;
     ceilingFinish: string;
@@ -47,7 +47,7 @@ export declare const zoneAddVertexAffordance: import("@pascal-app/core").Floorpl
     occupancy: string;
     clearDimensionPolicy: "none" | "inside-faces" | "finish-faces";
     color: string;
-    metadata: import("zod").JSONType;
+    metadata: Record<string, unknown>;
     camera?: {
         position: [number, number, number];
         target: [number, number, number];
@@ -66,9 +66,9 @@ export declare const zoneMoveEdgeAffordance: import("@pascal-app/core").Floorpla
     polygon: [number, number][];
     autoFromWalls: boolean;
     boundaryWallIds: `wall_${string}`[];
-    spaceRole: "generic" | "room";
+    spaceRole: "room" | "generic";
     roomNumber: string;
-    enclosureStatus: "auto" | "enclosed" | "open";
+    enclosureStatus: "auto" | "open" | "enclosed";
     floorFinish: string;
     wallFinish: string;
     ceilingFinish: string;
@@ -76,7 +76,7 @@ export declare const zoneMoveEdgeAffordance: import("@pascal-app/core").Floorpla
     occupancy: string;
     clearDimensionPolicy: "none" | "inside-faces" | "finish-faces";
     color: string;
-    metadata: import("zod").JSONType;
+    metadata: Record<string, unknown>;
     camera?: {
         position: [number, number, number];
         target: [number, number, number];
@@ -95,9 +95,9 @@ export declare const zoneDeleteVertexAffordance: import("@pascal-app/core").Floo
     polygon: [number, number][];
     autoFromWalls: boolean;
     boundaryWallIds: `wall_${string}`[];
-    spaceRole: "generic" | "room";
+    spaceRole: "room" | "generic";
     roomNumber: string;
-    enclosureStatus: "auto" | "enclosed" | "open";
+    enclosureStatus: "auto" | "open" | "enclosed";
     floorFinish: string;
     wallFinish: string;
     ceilingFinish: string;
@@ -105,7 +105,7 @@ export declare const zoneDeleteVertexAffordance: import("@pascal-app/core").Floo
     occupancy: string;
     clearDimensionPolicy: "none" | "inside-faces" | "finish-faces";
     color: string;
-    metadata: import("zod").JSONType;
+    metadata: Record<string, unknown>;
     camera?: {
         position: [number, number, number];
         target: [number, number, number];

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@pascal-app/nodes",
-  "version": "1.0.0-beta.5",
-  "description": "Built-in node bundles for the Pascal 3D editor — one folder per kind, exported as `builtinPlugin`",
+  "version": "1.0.0",
+  "description": "Built-in node bundles for the Pascal 3D editor \u2014 one folder per kind, exported as `builtinPlugin`",
   "type": "module",
   "main": "./dist/index.js",
   "types": "./dist/index.d.ts",
@@ -23,24 +23,26 @@
     "prepublishOnly": "bun run build && bun test"
   },
   "peerDependencies": {
-    "@pascal-app/core": "^1.0.0-beta.5",
-    "@pascal-app/editor": "^1.0.0-beta.5",
-    "@pascal-app/viewer": "^1.0.0-beta.5",
+    "@pascal-app/core": "^1.0.0",
+    "@pascal-app/editor": "^1.0.0",
+    "@pascal-app/viewer": "^1.0.0",
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "lucide-react": "^1",
     "react": "^18 || ^19",
-    "three": "^0.185",
+    "react-dom": "^18 || ^19",
+    "three": "^0.186",
     "zustand": "^5"
   },
   "devDependencies": {
-    "@pascal-app/core": "^1.0.0-beta.5",
-    "@pascal-app/editor": "^1.0.0-beta.5",
-    "@pascal-app/viewer": "^1.0.0-beta.5",
+    "@pascal-app/core": "^1.0.0",
+    "@pascal-app/editor": "^1.0.0",
+    "@pascal-app/viewer": "^1.0.0",
     "@pascal/typescript-config": "*",
     "@types/bun": "^1.3.0",
     "@types/node": "^22.19.12",
     "@types/react": "^19.2.2",
+    "@types/react-dom": "^19.2.3",
     "@types/three": "^0.184.0",
     "typescript": "6.0.3"
   },

package/dist/dormer/panel-window-section.d.ts

@@ -1,14 +0,0 @@
-import type { DormerNode } from '@pascal-app/core';
-/**
- * The Window tab of the dormer inspector: Hung Wall, Opening, Shape
- * (with rounded/arch sub-controls), Frame, Grid, Sill. Owns local UI
- * state for the "All vs Individual" corner-radius view mode — derived
- * from tuple uniformity by default.
- */
-export declare function DormerWindowSection({ node, previewProp, commitProp, handleUpdate, }: {
-    node: DormerNode;
-    previewProp: (updates: Partial<DormerNode>) => void;
-    commitProp: (updates: Partial<DormerNode>) => void;
-    handleUpdate: (updates: Partial<DormerNode>) => void;
-}): import("react").JSX.Element;
-//# sourceMappingURL=panel-window-section.d.ts.map

package/dist/dormer/panel-window-section.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"panel-window-section.d.ts","sourceRoot":"","sources":["../../src/dormer/panel-window-section.tsx"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAA;AAWlD;;;;;GAKG;AACH,wBAAgB,mBAAmB,CAAC,EAClC,IAAI,EACJ,WAAW,EACX,UAAU,EACV,YAAY,GACb,EAAE;IACD,IAAI,EAAE,UAAU,CAAA;IAChB,WAAW,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;IACnD,UAAU,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;IAClD,YAAY,EAAE,CAAC,OAAO,EAAE,OAAO,CAAC,UAAU,CAAC,KAAK,IAAI,CAAA;CACrD,+BA6RA"}