@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/window/tool.js

@@ -1,14 +1,18 @@
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { dormerWallFacePointToDormer, emitter, getEffectiveNode, holdHiddenWallPointerEvents, isCurvedWall, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useScene, WallNode as WallNodeSchema, WindowNode, } from '@pascal-app/core';
+import { beginSceneHistoryDraft, dormerWallFacePointToDormer, emitter, getEffectiveNode, holdHiddenWallPointerEvents, isCurvedWall, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useScene, WallNode as WallNodeSchema, WindowNode, } from '@pascal-app/core';
+import { windowTakesStyle } from '@pascal-app/core/building';
 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 { shouldFollowOpeningGrid, shouldHandleOpeningHostLeave, } from '../shared/opening-grid-follow';
 import { clearOpeningGuides3D, publishOpeningGuidesForWallEvent, resolveSillSnap, } from '../shared/opening-guides-runtime';
 import { getRoofWallOpeningCursorPose, resolveRoofWallOpeningTarget, worldToSelectedBuildingLocal, } from '../shared/roof-wall-opening-placement';
+import { wallEventFromGrid } from '../shared/wall-event-from-grid';
 import { collectWallOpeningAlignmentCandidates, resolveWallSlideAlignment, } from '../shared/wall-opening-alignment';
 import { WindowFloorProjection } from './floor-projection';
+import { placedWindowFields, useWindowPlacement } from './placement';
 import WindowPreview from './preview';
 import { clampToWall, DEFAULT_WINDOW_SILL_M, hasWallChildOverlap, wallLocalToWorld, } from './window-math';
 // Shared edge material — reuse across renders, just toggle color
@@ -47,20 +51,50 @@ const WindowTool = () => {
     // `floorY` feeds the floor "shadow" projection; `side` carries the R-flip so
     // the floating ghost faces the side that will be committed.
     const [fallbackPose, setFallbackPose] = useState(null);
-    // Ghost preview node — zeroed transform + the live facing side (rebuilds on R).
+    const placedType = useWindowPlacement((state) => state.type);
+    const placedStyle = useWindowPlacement((state) => state.style);
+    // Ghost preview node — zeroed transform + the live facing side (rebuilds on R) and the
+    // chips' type and style (rebuilds on O / L).
+    // biome-ignore lint/correctness/useExhaustiveDependencies: placedWindowFields reads the chips' store
     const ghostStub = useMemo(() => WindowNode.parse({
+        ...placedWindowFields(),
         position: [0, 0, 0],
         rotation: [0, 0, 0],
         side: fallbackPose?.side ?? 'front',
-    }), [fallbackPose?.side]);
+    }), [fallbackPose?.side, placedType, placedStyle]);
     // The frame depth is a fixed parse default (the `side` flip doesn't change
     // it); a ref lets the facing-pose publish inside the setup effect read it
     // without re-subscribing every event listener.
     const frameDepthRef = useRef(ghostStub.frameDepth);
     useEffect(() => {
         useScene.temporal.getState().pause();
+        // The draft is a created carry draft: undo history and every save leave it out
+        // (core `getSceneDocument`), so a reload mid-placement never finds it in the scene.
+        const draftHistoryEnds = new Map();
+        const createDraft = (node, parentId) => {
+            const end = beginSceneHistoryDraft(node.id, null);
+            draftHistoryEnds.set(node.id, end);
+            try {
+                useScene.getState().createNode(node, parentId);
+            }
+            catch (error) {
+                end();
+                draftHistoryEnds.delete(node.id);
+                throw error;
+            }
+        };
+        const deleteDraft = (id) => {
+            try {
+                useScene.getState().deleteNode(id);
+            }
+            finally {
+                draftHistoryEnds.get(id)?.();
+                draftHistoryEnds.delete(id);
+            }
+        };
         const ownedPreviewIds = new Set();
-        const fallbackPreview = WindowNode.parse({
+        const fallbackPreview = () => WindowNode.parse({
+            ...placedWindowFields(),
             position: [0, 0, 0],
             rotation: [0, 0, 0],
             side: 'front',
@@ -110,7 +144,7 @@ const WindowTool = () => {
             const id = getLevelId();
             return id ? (sceneRegistry.nodes.get(id)?.position.y ?? 0) : 0;
         };
-        const getSlabElevationForWall = (wall) => spatialGridManager.getSlabElevationForWall(wall.parentId ?? '', wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId);
+        const getSlabElevationForWall = (wall) => spatialGridManager.getSlabElevationForWall(wall.parentId ?? '', wall.start, wall.end, wall.curveOffset ?? 0, wall.thickness, wall.supportSlabId, wall.justification);
         const markHostDirty = (hostId) => {
             useScene.getState().dirtyNodes.add(hostId);
         };
@@ -122,7 +156,7 @@ const WindowTool = () => {
             }
             const wallId = draft.parentId;
             useLiveNodeOverrides.getState().clear(draft.id);
-            useScene.getState().deleteNode(draft.id);
+            deleteDraft(draft.id);
             draftRef.current = null;
             clearPlacementPreview();
             // Rebuild wall so it removes the cutout from the deleted draft
@@ -177,7 +211,8 @@ const WindowTool = () => {
                 floorY,
                 side: sideFlip ? 'back' : 'front',
             });
-            const halfWidth = fallbackPreview.width / 2 + 0.5;
+            const preview = fallbackPreview();
+            const halfWidth = preview.width / 2 + 0.5;
             const wall = WallNodeSchema.parse({
                 end: [position[0] + halfWidth, position[2]],
                 id: fallbackWallId,
@@ -185,10 +220,10 @@ const WindowTool = () => {
                 thickness: 0.1,
             });
             const ghost = WindowNode.parse({
-                ...fallbackPreview,
+                ...preview,
                 metadata: { isTransient: true },
                 parentId: wall.id,
-                position: [halfWidth, FALLBACK_SILL_LIFT + fallbackPreview.height / 2, 0],
+                position: [halfWidth, FALLBACK_SILL_LIFT + preview.height / 2, 0],
                 rotation: [0, sideFlip ? Math.PI : 0, 0],
                 side: sideFlip ? 'back' : 'front',
                 wallId: wall.id,
@@ -217,31 +252,32 @@ const WindowTool = () => {
             const itemRotation = sideFlip ? Math.PI : 0;
             if (draftRef.current && draftRef.current.parentId !== event.node.id)
                 destroyDraft();
-            if (!draftRef.current) {
-                const node = WindowNode.parse({
+            if (draftRef.current) {
+                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,
-                    metadata: { isTransient: true },
+                    wallId: undefined,
+                    roofSegmentId: undefined,
+                    roofFace: undefined,
                 });
-                useScene.getState().createNode(node, event.node.id);
-                draftRef.current = node;
             }
             else {
-                useLiveNodeOverrides.getState().set(draftRef.current.id, {
+                const node = WindowNode.parse({
+                    ...placedWindowFields(),
                     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,
+                    metadata: { isTransient: true },
                 });
+                createDraft(node, event.node.id);
+                draftRef.current = node;
             }
             publishDraftPreview(event.node);
             clearOpeningGuides3D();
@@ -303,6 +339,7 @@ const WindowTool = () => {
             const height = draftRef.current?.height ?? 1.5;
             if (!draftRef.current) {
                 const node = WindowNode.parse({
+                    ...placedWindowFields(),
                     position: [0, DEFAULT_SILL_CENTER_Y, 0],
                     rotation: [0, itemRotation, 0],
                     side,
@@ -310,7 +347,7 @@ const WindowTool = () => {
                     parentId: wall.id,
                     metadata: { isTransient: true },
                 });
-                useScene.getState().createNode(node, wall.id);
+                createDraft(node, wall.id);
                 draftRef.current = node;
             }
             const { clampedX, clampedY, valid } = resolveWallPlacement(wall, rawLocalX, rawLocalY, width, height, applySnap, draftRef.current.id);
@@ -362,7 +399,7 @@ const WindowTool = () => {
             draftRef.current = null;
             hostKind = null;
             useLiveNodeOverrides.getState().clear(draft.id);
-            useScene.getState().deleteNode(draft.id);
+            deleteDraft(draft.id);
             useScene.temporal.getState().resume();
             const levelId = getLevelId();
             const state = useScene.getState();
@@ -418,7 +455,7 @@ const WindowTool = () => {
             draftRef.current = null;
             hostKind = null;
             useLiveNodeOverrides.getState().clear(draft.id);
-            useScene.getState().deleteNode(draft.id);
+            deleteDraft(draft.id);
             useScene.temporal.getState().resume();
             const state = useScene.getState();
             const windowCount = Object.values(state.nodes).filter((node) => node.type === 'window').length;
@@ -519,7 +556,16 @@ const WindowTool = () => {
             commitWindowAtWall(event.node, clampedX, clampedY, side, itemRotation);
             event.stopPropagation();
         };
-        const onWallLeave = () => {
+        // XR selectend produces a grid click without replaying the wall mesh's
+        // R3F pointer-up event. Use the latest valid wall hover for that release.
+        const onXRGridClick = (event) => {
+            if (event.nativeEvent?.pointerType !== 'xr' || !lastWallEvent)
+                return;
+            onWallClick(lastWallEvent);
+        };
+        const onWallLeave = (event) => {
+            if (!shouldHandleOpeningHostLeave(event.nativeEvent))
+                return;
             if (hostKind !== 'wall')
                 return;
             lastWallEvent = null;
@@ -538,8 +584,18 @@ const WindowTool = () => {
             // timeStamp) — it owns the frame and has snapped the draft, so skip the
             // floor follow this tick.
             const ts = event.nativeEvent?.timeStamp ?? -1;
-            if (ts === lastMeshEventTime)
+            if (!shouldFollowOpeningGrid({
+                eventTime: ts,
+                hasActiveHost: hostKind !== null,
+                lastHostEventTime: lastMeshEventTime,
+                pointerType: event.nativeEvent?.pointerType,
+            }))
                 return;
+            const wallEvent = wallEventFromGrid(event, activeLevelId, useScene.getState().nodes, sceneRegistry.nodes);
+            if (wallEvent) {
+                onWallHover(wallEvent);
+                return;
+            }
             // Fresh floor-only frame: the cursor is off any wall/roof. Drop any draft
             // and free-follow the cursor with the invalid (unplaceable) ghost.
             hostKind = null;
@@ -548,6 +604,13 @@ const WindowTool = () => {
             destroyDraft();
             showGhostAt([x, y + FALLBACK_HEIGHT / 2 + FALLBACK_SILL_LIFT, z], y);
         };
+        const onGridPointerUp = (event) => {
+            if (isCameraDragging() || !draftRef.current)
+                return;
+            const wallEvent = wallEventFromGrid(event, activeLevelId, useScene.getState().nodes, sceneRegistry.nodes);
+            if (wallEvent)
+                onWallClick(wallEvent);
+        };
         // ── Dormer wall faces ──────────────────────────────────────────
         // Dormer windows use the same WindowNode mesh and inspector as regular
         // windows, but their host frame is supplied by DormerRenderer.
@@ -669,6 +732,7 @@ const WindowTool = () => {
             }
             else {
                 const node = WindowNode.parse({
+                    ...placedWindowFields(),
                     position,
                     rotation: [0, 0, 0],
                     side: 'front',
@@ -677,7 +741,7 @@ const WindowTool = () => {
                     parentId: segment.id,
                     metadata: { isTransient: true },
                 });
-                useScene.getState().createNode(node, segment.id);
+                createDraft(node, segment.id);
                 draftRef.current = node;
             }
             publishDraftPreview(segment);
@@ -701,7 +765,7 @@ const WindowTool = () => {
             draftRef.current = null;
             hostKind = null;
             useLiveNodeOverrides.getState().clear(draft.id);
-            useScene.getState().deleteNode(draft.id);
+            deleteDraft(draft.id);
             useScene.temporal.getState().resume();
             const state = useScene.getState();
             const windowCount = Object.values(state.nodes).filter((n) => n.type === 'window' && n.roofSegmentId !== undefined).length;
@@ -762,14 +826,28 @@ const WindowTool = () => {
         // guard dropped R off-wall / before the first hover). Then re-renders the
         // current preview so the flip shows live and matches commit.
         const onKeyDown = (e) => {
-            if (e.key !== 'r' && e.key !== 'R')
+            const key = e.key.toLowerCase();
+            if (key !== 'r' && key !== 'o' && key !== 'l')
+                return;
+            if (key === 'l' && !windowTakesStyle(useWindowPlacement.getState().type))
                 return;
             if (e.repeat)
                 return;
             const t = e.target;
             if (t && (t.tagName === 'INPUT' || t.tagName === 'TEXTAREA' || t.isContentEditable))
                 return;
+            if (key !== 'r' && (e.metaKey || e.ctrlKey || e.altKey))
+                return;
             e.preventDefault();
+            if (key !== 'r') {
+                // O / L cycle the chips; the store subscription re-previews.
+                if (key === 'o')
+                    useWindowPlacement.getState().cycleType();
+                else
+                    useWindowPlacement.getState().cycleStyle();
+                triggerSFX('sfx:item-rotate');
+                return;
+            }
             sideFlip = !sideFlip;
             triggerSFX('sfx:item-rotate');
             if (lastWallEvent) {
@@ -786,6 +864,7 @@ const WindowTool = () => {
         emitter.on('wall:enter', onWallHover);
         emitter.on('wall:move', onWallHover);
         emitter.on('wall:click', onWallClick);
+        emitter.on('grid:click', onXRGridClick);
         emitter.on('wall:leave', onWallLeave);
         emitter.on('roof:enter', onRoofHover);
         emitter.on('roof:move', onRoofHover);
@@ -800,8 +879,28 @@ const WindowTool = () => {
         emitter.on('window:click', onDormerWindowClick);
         emitter.on('window:leave', onDormerWindowLeave);
         emitter.on('grid:move', onGridFreeFollow);
+        emitter.on('grid:pointerup', onGridPointerUp);
         emitter.on('tool:cancel', onCancel);
         window.addEventListener('keydown', onKeyDown);
+        // A chip changed (key or click): the draft takes the new type and style, then re-previews.
+        const unsubscribePlacement = useWindowPlacement.subscribe(() => {
+            const draft = draftRef.current;
+            if (draft) {
+                useScene.getState().updateNode(draft.id, placedWindowFields());
+                const live = useScene.getState().nodes[draft.id];
+                if (live?.type === 'window')
+                    draftRef.current = live;
+            }
+            const parent = draft?.parentId ? useScene.getState().nodes[draft.parentId] : null;
+            if (lastWallEvent)
+                onWallHover(lastWallEvent);
+            else if (lastDormerEvent)
+                onDormerHover(lastDormerEvent);
+            else if (parent)
+                publishDraftPreview(parent);
+            else if (lastFloorPoint)
+                showGhostAt(lastFloorPoint.pos, lastFloorPoint.floorY);
+        });
         // 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
@@ -809,6 +908,8 @@ const WindowTool = () => {
         const releaseHiddenWallHold = holdHiddenWallPointerEvents();
         return () => {
             destroyDraft();
+            for (const end of draftHistoryEnds.values())
+                end();
             hideCursor();
             clearPlacementPreview();
             useAlignmentGuides.getState().clear();
@@ -818,6 +919,7 @@ const WindowTool = () => {
             emitter.off('wall:enter', onWallHover);
             emitter.off('wall:move', onWallHover);
             emitter.off('wall:click', onWallClick);
+            emitter.off('grid:click', onXRGridClick);
             emitter.off('wall:leave', onWallLeave);
             emitter.off('roof:enter', onRoofHover);
             emitter.off('roof:move', onRoofHover);
@@ -832,8 +934,10 @@ const WindowTool = () => {
             emitter.off('window:click', onDormerWindowClick);
             emitter.off('window:leave', onDormerWindowLeave);
             emitter.off('grid:move', onGridFreeFollow);
+            emitter.off('grid:pointerup', onGridPointerUp);
             emitter.off('tool:cancel', onCancel);
             window.removeEventListener('keydown', onKeyDown);
+            unsubscribePlacement();
         };
     }, [activeLevelId, isCameraDragging, selectNode]);
     // Cursor geometry: window outline rectangle. Static dims, so build it once and

package/dist/window/window-math.d.ts

@@ -1,4 +1,4 @@
-import type { AnyNode, AnyNodeId, WallNode } from '@pascal-app/core';
+import { type WallNode } from '@pascal-app/core';
 /**
  * Default sill height (metres from the floor to the BOTTOM of a window) for a
  * fresh window that has no wall-face height yet — the off-wall ghost and the
@@ -8,24 +8,16 @@ import type { AnyNode, AnyNodeId, WallNode } from '@pascal-app/core';
  */
 export declare const DEFAULT_WINDOW_SILL_M = 0.5;
 /**
- * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
+ * Converts wall-local (X along wall, Y = height above wall base, Z = offset
+ * from the wall centre plane along its normal) to world XYZ.
  * Wall XZ uses level-local coordinates (levels only offset in Y, not XZ).
  * Pass levelYOffset (the level group's current world Y) and slabElevation (the
  * wall mesh's Y within the level group) so the cursor lands at the correct world
  * height — matching how WallSystem positions the wall mesh at slabElevation.
  */
-export declare function wallLocalToWorld(wallNode: WallNode, localX: number, localY: number, levelYOffset?: number, slabElevation?: number): [number, number, number];
-/**
- * Clamps window center position so it stays fully within wall bounds. The Y
- * ceiling is the wall's RESOLVED top (storey plane for plane-bound walls,
- * stored height for explicit ones, minus the elected slab base) — `nodes` is
- * required because a plane-bound wall's top lives on its level, not on the
- * wall record.
- */
-export declare function clampToWall(wallNode: WallNode, localX: number, localY: number, width: number, height: number, nodes: Readonly<Record<AnyNodeId, AnyNode>>): {
-    clampedX: number;
-    clampedY: number;
-};
+export declare function wallLocalToWorld(wallNode: WallNode, localX: number, localY: number, levelYOffset?: number, slabElevation?: number, localZ?: number): [number, number, number];
+/** Window centre on its wall and under its ceiling: the shared rule in core (`clampWindowToWall`). */
+export { clampWindowToWall as clampToWall } from '@pascal-app/core/building';
 /**
  * Wall-child overlap is shared by door + window placement (one source of
  * truth in `shared/wall-attach-target.ts`). Re-exported here so existing

package/dist/window/window-math.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"window-math.d.ts","sourceRoot":"","sources":["../../src/window/window-math.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAA;AAGpE;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAExC;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,SAAI,EAChB,aAAa,SAAI,GAChB,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAU1B;AAED;;;;;;GAMG;AACH,wBAAgB,WAAW,CACzB,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,MAAM,EACb,MAAM,EAAE,MAAM,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,QAAQ,EAAE,MAAM,CAAA;CAAE,CASxC;AAED;;;;GAIG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA"}
+{"version":3,"file":"window-math.d.ts","sourceRoot":"","sources":["../../src/window/window-math.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;GAMG;AACH,eAAO,MAAM,qBAAqB,MAAM,CAAA;AAExC;;;;;;;GAOG;AACH,wBAAgB,gBAAgB,CAC9B,QAAQ,EAAE,QAAQ,EAClB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,YAAY,SAAI,EAChB,aAAa,SAAI,EACjB,MAAM,SAAI,GACT,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAW1B;AAED,sGAAsG;AACtG,OAAO,EAAE,iBAAiB,IAAI,WAAW,EAAE,MAAM,2BAA2B,CAAA;AAE5E;;;;GAIG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,8BAA8B,CAAA"}

package/dist/window/window-math.js

@@ -1,4 +1,4 @@
-import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
+import { getWallBodyCenterOffset, getWallCurveFrameAt, getWallCurveLength, } from '@pascal-app/core';
 /**
  * Default sill height (metres from the floor to the BOTTOM of a window) for a
  * fresh window that has no wall-face height yet — the off-wall ghost and the
@@ -8,36 +8,27 @@ import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
  */
 export const DEFAULT_WINDOW_SILL_M = 0.5;
 /**
- * Converts wall-local (X along wall, Y = height above wall base) to world XYZ.
+ * Converts wall-local (X along wall, Y = height above wall base, Z = offset
+ * from the wall centre plane along its normal) to world XYZ.
  * Wall XZ uses level-local coordinates (levels only offset in Y, not XZ).
  * Pass levelYOffset (the level group's current world Y) and slabElevation (the
  * wall mesh's Y within the level group) so the cursor lands at the correct world
  * height — matching how WallSystem positions the wall mesh at slabElevation.
  */
-export function wallLocalToWorld(wallNode, localX, localY, levelYOffset = 0, slabElevation = 0) {
-    const wallAngle = Math.atan2(wallNode.end[1] - wallNode.start[1], wallNode.end[0] - wallNode.start[0]);
+export function wallLocalToWorld(wallNode, localX, localY, levelYOffset = 0, slabElevation = 0, localZ = 0) {
+    const wallLength = getWallCurveLength(wallNode);
+    const frame = getWallCurveFrameAt(wallNode, wallLength > 1e-6 ? localX / wallLength : 0);
+    // `localZ` is measured from the body's centre plane, which a justified wall
+    // sets off its reference line.
+    const across = getWallBodyCenterOffset(wallNode) + localZ;
     return [
-        wallNode.start[0] + localX * Math.cos(wallAngle),
+        frame.point.x + frame.normal.x * across,
         slabElevation + localY + levelYOffset,
-        wallNode.start[1] + localX * Math.sin(wallAngle),
+        frame.point.y + frame.normal.y * across,
     ];
 }
-/**
- * Clamps window center position so it stays fully within wall bounds. The Y
- * ceiling is the wall's RESOLVED top (storey plane for plane-bound walls,
- * stored height for explicit ones, minus the elected slab base) — `nodes` is
- * required because a plane-bound wall's top lives on its level, not on the
- * wall record.
- */
-export function clampToWall(wallNode, localX, localY, width, height, nodes) {
-    const dx = wallNode.end[0] - wallNode.start[0];
-    const dz = wallNode.end[1] - wallNode.start[1];
-    const wallLength = Math.sqrt(dx * dx + dz * dz);
-    const wallHeight = resolveWallOpeningCeiling(wallNode, nodes);
-    const clampedX = Math.max(width / 2, Math.min(wallLength - width / 2, localX));
-    const clampedY = Math.max(height / 2, Math.min(wallHeight - height / 2, localY));
-    return { clampedX, clampedY };
-}
+/** Window centre on its wall and under its ceiling: the shared rule in core (`clampWindowToWall`). */
+export { clampWindowToWall as clampToWall } from '@pascal-app/core/building';
 /**
  * Wall-child overlap is shared by door + window placement (one source of
  * truth in `shared/wall-attach-target.ts`). Re-exported here so existing

package/dist/zone/contextual-dimensions.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/zone/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAc1B"}
+{"version":3,"file":"contextual-dimensions.d.ts","sourceRoot":"","sources":["../../src/zone/contextual-dimensions.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAEpB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,wBAAgB,6BAA6B,CAC3C,IAAI,EAAE,QAAQ,EACd,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CAgB1B"}

package/dist/zone/contextual-dimensions.js

@@ -1,10 +1,13 @@
-import { resolveAutoZonePolygon, } from '@pascal-app/core';
+import { area as footprintArea, polygonInteriorPoint, } from '@pascal-app/core';
 import { formatAreaLabel } from '@pascal-app/editor';
 export function buildZoneContextualDimensions(node, ctx) {
-    const polygon = resolveAutoZonePolygon(node, ctx.resolve);
+    if (node.autoFromWalls && node.enclosureStatus === 'open')
+        return null;
+    const polygon = node.polygon;
     if (polygon.length < 3)
         return null;
-    const { area, centroid } = polygonAreaAndCentroid(polygon);
+    const area = footprintArea([{ outer: polygon, holes: node.holes ?? [] }]);
+    const centroid = polygonInteriorPoint(node, true);
     if (area <= 1e-6)
         return null;
     return {
@@ -16,28 +19,3 @@ export function buildZoneContextualDimensions(node, ctx) {
         angle: 0,
     };
 }
-function polygonAreaAndCentroid(points) {
-    let twiceSignedArea = 0;
-    let weightedX = 0;
-    let weightedY = 0;
-    for (let index = 0; index < points.length; index += 1) {
-        const current = points[index];
-        const next = points[(index + 1) % points.length];
-        const cross = current[0] * next[1] - next[0] * current[1];
-        twiceSignedArea += cross;
-        weightedX += (current[0] + next[0]) * cross;
-        weightedY += (current[1] + next[1]) * cross;
-    }
-    const area = Math.abs(twiceSignedArea) / 2;
-    if (Math.abs(twiceSignedArea) <= 1e-9) {
-        const sum = points.reduce((acc, point) => [acc[0] + point[0], acc[1] + point[1]], [0, 0]);
-        return {
-            area,
-            centroid: [sum[0] / points.length, sum[1] / points.length],
-        };
-    }
-    return {
-        area,
-        centroid: [weightedX / (3 * twiceSignedArea), weightedY / (3 * twiceSignedArea)],
-    };
-}

package/dist/zone/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/zone/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,cAAc,EAGpB,MAAM,kBAAkB,CAAA;AAezB,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGnC;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAmF1D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/zone/definition.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAelF,OAAO,EAAE,QAAQ,EAAE,MAAM,UAAU,CAAA;AAGnC;;;;;GAKG;AACH,eAAO,MAAM,cAAc,EAAE,cAAc,CAAC,OAAO,QAAQ,CAoF1D,CAAA"}

package/dist/zone/definition.js

@@ -1,4 +1,4 @@
-import { resolveAutoZonePolygon, ZoneNode as ZoneNodeSchema, } from '@pascal-app/core';
+import { ZoneNode as ZoneNodeSchema } from '@pascal-app/core';
 import { polygonMeasurementFeatures } from '../shared/polygon-measurement';
 import { buildZoneContextualDimensions } from './contextual-dimensions';
 import { buildZoneFloorplan } from './floorplan';
@@ -46,12 +46,13 @@ export const zoneDefinition = {
             featurePrefix: 'zone',
             height: 0,
             label: 'Zone',
-            polygon: resolveAutoZonePolygon(node, ctx.resolve),
+            polygon: node.polygon,
         }),
-        quickMeasure: (node, ctx) => zoneQuickMeasurement(node, ctx),
+        quickMeasure: (node) => zoneQuickMeasurement(node),
     },
     // No dirty consumer rebuilds this kind — see NodeDefinition.dirtyTracking.
     dirtyTracking: false,
+    rendersChildren: false,
     renderer: {
         kind: 'parametric',
         module: () => import('./renderer'),