@pascal-app/nodes 1.0.5 → 1.0.7

package/dist/wall/tool.js

@@ -1,6 +1,6 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { calculateLevelMiters, collectAlignmentAnchors, DEFAULT_LEVEL_HEIGHT, emitter, GROUND_SUPPORT_ID, getWallMiterBoundaryPoints, resolveAlignment, resolveBuildingForLevel, sceneRegistry, useScene, wallClosesRoom, } from '@pascal-app/core';
-import { addWallPolygonDraftCorner, CursorSphere, chainEndJoinsExistingWall, clearPlacementSurface, commitWallPolygonDraft, createWallOnCurrentLevel, DraftMeasurementLabel, discardWallPolygonDraft, EDITOR_LAYER, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, getWallDrawVariant, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolvePointerSupportSurface, snapWallDraftPointDetailed, startWallPolygonDraft, triggerSFX, useAlignmentGuides, useEditor, useFloorplanDraftPreview, useSegmentDraftChain, useWallDrawVariant, useWallSnapIndicator, visibleScene, WALL_CONNECT_SNAP_RADIUS, WALL_JOIN_SNAP_RADIUS, wallPolygonDraftWalls, } from '@pascal-app/editor';
+import { addWallPolygonDraftCorner, CursorSphere, chainEndJoinsExistingWall, clearPlacementSurface, commitWallPolygonDraft, createInvisibleWallOnCurrentLevel, createWallOnCurrentLevel, DraftMeasurementLabel, discardWallPolygonDraft, EDITOR_LAYER, endWallPullRun, formatAngleRadians, formatLinearMeasurement, getAngleArcToSegmentReference, getAngleToSegmentReference, getSegmentAngleReferenceAtPoint, getWallDrawVariant, getWallLineKind, invisibleWallDraftSnapLines, isAlignmentGuideActive, isAngleSnapActive, isMagneticSnapActive, isWallRunFree, markToolCancelConsumed, publishHorizontalConstructionPlane, publishPlacementSurface, publishWallRunFeedback, resampleTerrainConstructionPlane, resolveEventConstructionPlane, resolveLevelConstructionPlane, resolvePointerSupportSurface, snapWallDraftPointDetailed, snapWallRunDraftPoint, startWallPolygonDraft, triggerSFX, useAlignmentGuides, useEditor, useFloorplanDraftPreview, useSegmentDraftChain, useWallDraftThickness, useWallDrawVariant, useWallPullRun, useWallSnapIndicator, visibleScene, WALL_CONNECT_SNAP_RADIUS, WALL_JOIN_SNAP_RADIUS, wallDraftIsRun, wallPolygonDraftWalls, wallRunDirection, } from '@pascal-app/editor';
 import { getSceneTheme, useViewer } from '@pascal-app/viewer';
 import { useThree } from '@react-three/fiber';
 import { useEffect, useRef, useState } from 'react';
@@ -10,14 +10,23 @@ import RectangleWallTool from './rectangle-tool.js';
 /**
  * Phase 5 Stage D — wall placement tool (kind-owned).
  *
- * 1:1 port of the legacy `WallTool`. Two-click flow: click 1 sets the
- * start, click 2 creates the wall. Between clicks a vertical preview
- * rectangle + length/angle measurement HUD follow the pointer. Snapping is
- * governed by the global snapping mode (`'off'` is the bypass); Esc cancels.
+ * Walls: click 1 sets the start, click 2 creates the wall, and the tool waits
+ * for the next start. Polygon: each click adds a corner and the next side
+ * chains from it until Esc, a double-click, closing the loop or teeing into
+ * another wall. Between clicks a vertical preview rectangle + length/angle
+ * measurement HUD follow the pointer. Snapping is governed by the global
+ * snapping mode (`'off'` is the bypass): a Walls segment locks to 15° rays from
+ * its start; a Polygon side holds square to the one before and the house's
+ * axes, with projection guides and a labelled snap marker
+ * (`snapWallRunDraftPoint`).
  *
  * Not a `DragAction` — same reasoning as fence/slab/ceiling placement:
  * stateful sequence of grid:click events, not a single drag-up.
  *
+ * A wall end's pull grip (`startWallPull`) arms a run already started at that
+ * end: the tool seeds its chain from `useWallPullRun`, its first wall square to
+ * the pulled one, and ends the pull when the chain stops.
+ *
  * Mounted via `def.tool` from `wall/definition.ts`.
  */
 const DRAFT_WALL_THICKNESS = 0.1;
@@ -290,6 +299,25 @@ function getBelowLevelWalls() {
         .sort((a, b) => b.level - a.level)[0];
     return getLevelWalls(belowLevel?.id ?? null, nodes);
 }
+/**
+ * The walls the line tool snaps a drafted point against. `walls` is the active
+ * level, which the measurement HUD reports against. `snapWalls` adds an open
+ * Polygon room's sides and, as a reference for the corner and edge snaps, the
+ * floor below. `bodyWalls` leaves the floor below out: a body capture T-joins
+ * the wall it lands in, and a wall on another floor can't be joined, so an end
+ * near a lower wall's face stays where the plan (which only knows the active
+ * level) puts it. An invisible-wall draft also catches the invisible walls
+ * already drawn (`invisibleWallDraftSnapLines`).
+ */
+export function getWallDraftSnapWalls() {
+    const walls = getCurrentLevelWalls();
+    const draftWalls = [...wallPolygonDraftWalls(), ...invisibleWallDraftSnapLines()];
+    return {
+        walls,
+        snapWalls: [...walls, ...getBelowLevelWalls(), ...draftWalls],
+        bodyWalls: [...walls, ...draftWalls],
+    };
+}
 const LineWallTool = () => {
     const unit = useViewer((state) => state.unit);
     const metricNotation = useViewer((state) => state.metricNotation);
@@ -311,7 +339,7 @@ const LineWallTool = () => {
     const cameraRef = useRef(camera);
     cameraRef.current = camera;
     const previewHeight = typeof wallDefaults?.height === 'number' ? wallDefaults.height : activeLevelHeight;
-    const previewThickness = typeof wallDefaults?.thickness === 'number' ? wallDefaults.thickness : DRAFT_WALL_THICKNESS;
+    const previewThickness = useWallDraftThickness(DRAFT_WALL_THICKNESS);
     const previewHeightRef = useRef(previewHeight);
     previewHeightRef.current = previewHeight;
     const previewThicknessRef = useRef(previewThickness);
@@ -452,11 +480,60 @@ const LineWallTool = () => {
             useWallSnapIndicator.getState().clear();
             useSegmentDraftChain.getState().clear('wall');
             clearPlacementSurface();
+            seededPullSeq = null;
+            runReference = null;
+            // A pulled run ends with its chain: back to Select.
+            endWallPullRun();
         };
         // In 2D-only view the plan owns wall drafting; this tool stays mounted
         // behind the hidden canvas and still hears the plan's grid events, so it
         // must not also draft (it would add every corner twice).
         const planOwnsInput = () => visibleScene(useEditor.getState()) === '2d';
+        // The pull run this chain was seeded from.
+        let seededPullSeq = null;
+        // Direction of the run's last wall (the pulled one first); null before one.
+        let runReference = null;
+        // The floor plan forwards its own snapped moves; it shows their feedback.
+        const fromCanvas = (event) => event.nativeEvent?.target instanceof HTMLCanvasElement;
+        // A started run holds square to its last wall and the house's axes.
+        const snapRun = (point, event) => {
+            const runStart = chainFirstVertex.current ?? startingPoint.current;
+            return snapWallRunDraftPoint({
+                point,
+                start: [startingPoint.current.x, startingPoint.current.z],
+                runStart: [runStart.x, runStart.z],
+                reference: runReference,
+                walls: getWallDraftSnapWalls().bodyWalls,
+                free: isWallRunFree(event.nativeEvent),
+            });
+        };
+        // A wall end's pull grip opens the run at that end: start the chain there,
+        // on the pulled wall's own base, as if its end had been clicked.
+        const seedPull = (run) => {
+            if (!run || run.seq === seededPullSeq || planOwnsInput())
+                return;
+            const { walls } = getWallDraftSnapWalls();
+            const plane = snappedWallConstructionPlane([run.sourceWallId], walls) ?? resolveLevelConstructionPlane();
+            if (!plane)
+                return;
+            seededPullSeq = run.seq;
+            runReference = run.reference;
+            constructionPlane.current = plane;
+            flatConstructionBase.current = false;
+            chainWallIds.current = [];
+            startingPoint.current.set(run.start[0], plane.localY, run.start[1]);
+            chainFirstVertex.current = startingPoint.current.clone();
+            endingPoint.current.copy(startingPoint.current);
+            buildingState.current = 1;
+            const draftPreview = useFloorplanDraftPreview.getState();
+            draftPreview.setWallDraftStart(run.start);
+            draftPreview.setWallDraftEnd(run.start);
+            cursorRef.current?.position.copy(startingPoint.current);
+            if (wallPreviewRef.current)
+                wallPreviewRef.current.visible = false;
+            setDraftMeasurement(null);
+            setAxisGuide({ origin: run.start, endOrigin: null, y: plane.localY, angleLabel: null });
+        };
         const onGridMove = (event) => {
             if (!(cursorRef.current && wallPreviewRef.current) || planOwnsInput())
                 return;
@@ -472,32 +549,48 @@ const LineWallTool = () => {
             else if (pointed) {
                 publishPlacementSurface(surfacePointScratch.set(event.position[0], pointed.worldY, event.position[2]), SURFACE_UP);
             }
-            const walls = getCurrentLevelWalls();
-            // Add walls on the floor below as extra snap references so the new wall
-            // can align with the level beneath it. Kept separate from `walls` so the
-            // measurement HUD only reports against the active level.
-            const snapWalls = [...walls, ...getBelowLevelWalls(), ...wallPolygonDraftWalls()];
+            // Walls on the floor below are extra snap references so the new wall can
+            // align with the level beneath it; the measurement HUD reports against
+            // the active level's `walls` only.
+            const { walls, snapWalls, bodyWalls } = getWallDraftSnapWalls();
             const localPoint = pointed?.localPoint
                 ? [pointed.localPoint[0], pointed.localPoint[2]]
                 : [event.localPosition[0], event.localPosition[2]];
             // Snapping is governed entirely by the snapping mode (grid / lines /
             // angles / off). `'off'` is the bypass — there is no Shift hold-to-bypass.
-            const angleLocked = buildingState.current === 1 && isAngleSnapActive();
-            const snapResult = snapWallDraftPointDetailed({
-                point: localPoint,
-                walls: snapWalls,
-                start: angleLocked ? [startingPoint.current.x, startingPoint.current.z] : undefined,
-                angleSnap: angleLocked,
-                magnetic: isMagneticSnapActive(),
-            });
-            gridPosition = alignPoint(snapResult.point, { applySnap: !angleLocked });
-            // Stand the magnetic beacon at the endpoint when it locked onto an
-            // existing wall corner / wall point; clear it for plain grid/angle moves.
-            useWallSnapIndicator
-                .getState()
-                .set(snapResult.snap
-                ? { x: gridPosition[0], z: gridPosition[1], kind: snapResult.snap }
-                : null);
+            // Everything here is building-local: the lattice, the 15° rays and the
+            // alignment axes all turn with a building the site planner turned.
+            if (buildingState.current === 1 && wallDraftIsRun()) {
+                // A started run holds square and shows its guides and snap marker.
+                const runSnap = snapRun(localPoint, event);
+                gridPosition = runSnap.point;
+                if (fromCanvas(event))
+                    publishWallRunFeedback(runSnap);
+            }
+            else {
+                // A Walls segment locks to 15° rays from its start.
+                const angleLocked = buildingState.current === 1 && isAngleSnapActive();
+                const snapResult = snapWallDraftPointDetailed({
+                    point: localPoint,
+                    walls: snapWalls,
+                    start: angleLocked ? [startingPoint.current.x, startingPoint.current.z] : undefined,
+                    angleSnap: angleLocked,
+                    magnetic: isMagneticSnapActive(),
+                    captureWallBodies: true,
+                    bodyWalls,
+                });
+                // A point locked onto a wall stays on it: alignment only shows its guides.
+                gridPosition = alignPoint(snapResult.point, {
+                    applySnap: !angleLocked && snapResult.snap === null,
+                });
+                // Stand the magnetic beacon at the endpoint when it locked onto an
+                // existing wall corner / wall point; clear it for plain grid/angle moves.
+                useWallSnapIndicator
+                    .getState()
+                    .set(snapResult.snap
+                    ? { x: gridPosition[0], z: gridPosition[1], kind: snapResult.snap }
+                    : null);
+            }
             if (buildingState.current === 1) {
                 const snappedLocal = gridPosition;
                 const draftY = constructionPlane.current?.localY ?? event.localPosition[1];
@@ -537,8 +630,7 @@ const LineWallTool = () => {
                 stopDrafting();
                 return;
             }
-            const walls = getCurrentLevelWalls();
-            const snapWalls = [...walls, ...getBelowLevelWalls(), ...wallPolygonDraftWalls()];
+            const { walls, snapWalls, bodyWalls } = getWallDraftSnapWalls();
             const pointed = buildingState.current === 0 ? pointedSurfaceFor(event) : null;
             const localClick = pointed?.localPoint
                 ? [pointed.localPoint[0], pointed.localPoint[2]]
@@ -548,8 +640,12 @@ const LineWallTool = () => {
                     point: localClick,
                     walls: snapWalls,
                     magnetic: isMagneticSnapActive(),
+                    captureWallBodies: true,
+                    bodyWalls,
+                });
+                const snappedStart = alignPoint(snapResult.point, {
+                    applySnap: snapResult.snap === null,
                 });
-                const snappedStart = alignPoint(snapResult.point);
                 const resolvedPlane = (pointed?.sourceNodeId
                     ? resolveEventConstructionPlane(event, pointed)
                     : pointMatches(snappedStart, snapResult.point)
@@ -562,6 +658,7 @@ const LineWallTool = () => {
                 gridPosition = snappedStart;
                 startingPoint.current.set(snappedStart[0], plane.localY, snappedStart[1]);
                 chainFirstVertex.current = startingPoint.current.clone();
+                runReference = null;
                 endingPoint.current.copy(startingPoint.current);
                 buildingState.current = 1;
                 const draftPreview = useFloorplanDraftPreview.getState();
@@ -593,13 +690,17 @@ const LineWallTool = () => {
             }
             else if (buildingState.current === 1) {
                 const angleLocked = isAngleSnapActive();
-                const snappedEnd = alignPoint(snapWallDraftPointDetailed({
-                    point: localClick,
-                    walls: snapWalls,
-                    start: angleLocked ? [startingPoint.current.x, startingPoint.current.z] : undefined,
-                    angleSnap: angleLocked,
-                    magnetic: isMagneticSnapActive(),
-                }).point, { applySnap: !angleLocked });
+                const snappedEnd = wallDraftIsRun()
+                    ? snapRun(localClick, event).point
+                    : alignPoint(snapWallDraftPointDetailed({
+                        point: localClick,
+                        walls: snapWalls,
+                        start: angleLocked ? [startingPoint.current.x, startingPoint.current.z] : undefined,
+                        angleSnap: angleLocked,
+                        magnetic: isMagneticSnapActive(),
+                        captureWallBodies: true,
+                        bodyWalls,
+                    }).point, { applySnap: !angleLocked });
                 const dx = snappedEnd[0] - startingPoint.current.x;
                 const dz = snappedEnd[1] - startingPoint.current.z;
                 if (dx * dx + dz * dz < 0.01 * 0.01)
@@ -620,29 +721,38 @@ const LineWallTool = () => {
                         stopDrafting();
                         return;
                     }
+                    runReference = wallRunDirection([startingPoint.current.x, startingPoint.current.z], snappedEnd);
                     nextStart = snappedEnd;
                 }
                 else {
                     const draftPlane = constructionPlane.current;
                     const commitPointed = draftPlane?.supportSlabId === GROUND_SUPPORT_ID ? null : pointedSurfaceFor(event);
                     // Both start and end are building-local ✓
-                    const createdWall = createWallOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd, {
-                        supportCap: commitPointed ? commitPointed.elevation : (draftPlane?.elevation ?? null),
-                        preferredSupportSlabId: draftPlane?.supportSlabId ?? null,
-                        constructionElevation: draftPlane?.elevation ?? null,
-                        constructionHeight: previewHeightRef.current,
-                        constructionSourceNodeId: constructionPlane.current?.sourceNodeId ?? null,
-                        flatConstructionBase: flatConstructionBase.current,
-                    });
+                    // The Walls variant's Invisible draws room separators, not walls.
+                    const createdWall = getWallLineKind() === 'invisible'
+                        ? createInvisibleWallOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd)
+                        : createWallOnCurrentLevel([startingPoint.current.x, startingPoint.current.z], snappedEnd, {
+                            supportCap: commitPointed
+                                ? commitPointed.elevation
+                                : (draftPlane?.elevation ?? null),
+                            preferredSupportSlabId: draftPlane?.supportSlabId ?? null,
+                            constructionElevation: draftPlane?.elevation ?? null,
+                            constructionHeight: previewHeightRef.current,
+                            constructionSourceNodeId: constructionPlane.current?.sourceNodeId ?? null,
+                            flatConstructionBase: flatConstructionBase.current,
+                        });
                     if (!createdWall)
                         return;
                     chainWallIds.current.push(createdWall.id);
+                    // The run's next wall holds square to this one.
+                    runReference = wallRunDirection(createdWall.start, createdWall.end);
                     // The new segment is now a real node — make it an alignment target
                     // for the next segment, and drop the just-shown guide.
                     refreshAlignmentCandidates();
                     useAlignmentGuides.getState().clear();
                     useWallSnapIndicator.getState().clear();
-                    if (useEditor.getState().getContinuation('wall') === 'single') {
+                    // Walls draws one wall per two clicks.
+                    if (!wallDraftIsRun()) {
                         stopDrafting();
                         return;
                     }
@@ -659,7 +769,7 @@ const LineWallTool = () => {
                     const levelWalls = getCurrentLevelWalls();
                     if (closedToChainStart ||
                         chainEndJoinsExistingWall(createdWall.end, levelWalls, chainWallIds.current) ||
-                        wallClosesRoom(levelWalls, createdWall)) {
+                        (createdWall.type === 'wall' && wallClosesRoom(levelWalls, createdWall))) {
                         stopDrafting();
                         return;
                     }
@@ -702,9 +812,12 @@ const LineWallTool = () => {
         emitter.on('grid:move', onGridMove);
         emitter.on('grid:click', onGridClick);
         emitter.on('tool:cancel', onCancel);
+        const stopPullSeeding = useWallPullRun.subscribe((state) => seedPull(state.run));
+        seedPull(useWallPullRun.getState().run);
         return () => {
             // Leaving the tool mid-polygon abandons it (nothing was written).
             discardWallPolygonDraft();
+            stopPullSeeding();
             emitter.off('grid:move', onGridMove);
             emitter.off('grid:click', onGridClick);
             emitter.off('tool:cancel', onCancel);

package/dist/wall/treatments.d.ts

@@ -7,6 +7,9 @@ type OpeningLike = {
     width?: number;
     height?: number;
     position?: [number, number, number];
+    casingFaceA?: boolean;
+    casingFaceB?: boolean;
+    casingWidth?: number;
 };
 type TrimKind = WallTrimKind;
 type WallSide = WallFace;

package/dist/wall/treatments.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treatments.d.ts","sourceRoot":"","sources":["../../src/wall/treatments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,aAAa,EAClB,KAAK,eAAe,EAOpB,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,YAAY,EAEjB,KAAK,cAAc,EAIpB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,EAA8B,KAAK,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAMhG,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC,CAAA;AAED,KAAK,QAAQ,GAAG,YAAY,CAAA;AAC5B,KAAK,QAAQ,GAAG,QAAQ,CAAA;AACxB,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;AAE5D,KAAK,mBAAmB,GAAG,cAAc,CAAA;AAoMzC,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAMzD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAoBlE;AAwND,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,QAAQ,EACd,aAAa,EAAE,WAAW,EAAE,EAC5B,SAAS,EAAE,sBAAsB,2FA2GlC;AAkBD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,cAAc;;;;;;;EAU/B;AAED,eAAO,MAAM,cAAc,uFAKxB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,EAAE,WAAW,EAAE,CAAA;IAC5B,SAAS,EAAE,sBAAsB,CAAA;IACjC,SAAS,EAAE,MAAM,CAAC,mBAAmB,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CACvD,iCA+DC,CAAA"}
+{"version":3,"file":"treatments.d.ts","sourceRoot":"","sources":["../../src/wall/treatments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAUL,KAAK,aAAa,EAClB,KAAK,eAAe,EAOpB,KAAK,QAAQ,EACb,KAAK,QAAQ,EACb,KAAK,cAAc,EACnB,KAAK,YAAY,EAEjB,KAAK,cAAc,EAKpB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAI9B,OAAO,EAA8B,KAAK,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAMhG,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IACnC,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,WAAW,CAAC,EAAE,OAAO,CAAA;IACrB,WAAW,CAAC,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,KAAK,QAAQ,GAAG,YAAY,CAAA;AAC5B,KAAK,QAAQ,GAAG,QAAQ,CAAA;AACxB,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;AAE5D,KAAK,mBAAmB,GAAG,cAAc,CAAA;AAoMzC,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAMzD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAoBlE;AA2OD,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,QAAQ,EACd,aAAa,EAAE,WAAW,EAAE,EAC5B,SAAS,EAAE,sBAAsB,2FAgHlC;AAkBD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,cAAc;;;;;;;EAU/B;AAED,eAAO,MAAM,cAAc,uFAKxB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,EAAE,WAAW,EAAE,CAAA;IAC5B,SAAS,EAAE,sBAAsB,CAAA;IACjC,SAAS,EAAE,MAAM,CAAC,mBAAmB,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CACvD,iCA+DC,CAAA"}

package/dist/wall/treatments.js

@@ -1,11 +1,12 @@
 'use client';
 import { Fragment as _Fragment, jsx as _jsx } from "react/jsx-runtime";
-import { getWallCurveFrameAt, getWallLocalFaceZ, getWallMiterBoundaryPoints, getWallTrimFaces, getWallTrimSlotId, isCurvedWall, spatialGridManager, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, wallDoorStepRuns, wallFaceBaseOffset, wallFaceScriptSkirtingGap, } from '@pascal-app/core';
+import { getWallCurveFrameAt, getWallLocalFaceZ, getWallMiterBoundaryPoints, getWallTrimFaces, getWallTrimSlotId, isCurvedWall, openingCasingBoards, resolveOpeningCasingHost, spatialGridManager, useScene, WALL_CHAIR_RAIL_DEFAULT, WALL_CROWN_DEFAULT, WALL_SKIRTING_DEFAULT, WALL_SURFACE_SLOT_DEFAULTS, wallDoorStepRuns, wallFaceBaseOffset, wallFaceScriptSkirtingGap, } from '@pascal-app/core';
 import { baseMaterial, createMaterialFromPresetRef, resolveMaterialRef, } from '@pascal-app/viewer';
 import { memo, useEffect, useMemo } from 'react';
 import * as THREE from 'three';
 import { mergeGeometries as mergeBufferGeometries } from 'three/examples/jsm/utils/BufferGeometryUtils.js';
 import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling.js';
+import { skirtingFloorOpeningRanges } from './skirting-floor-gaps.js';
 import { treatmentMiterDataForProud } from './treatment-level-data.js';
 const CURVE_SEGMENTS = 24;
 const MIN_SLICE_PROUD = 0.0005;
@@ -340,8 +341,17 @@ function subtractOpeningRanges(ranges, openings) {
     }
     return next;
 }
-function trimOpeningRanges(node, childrenNodes, yBottom, height) {
+/**
+ * Where a trim on `face`, from `yBottom` to `height` above it, breaks for the wall's doors and
+ * windows: across each opening it reaches, and across each casing board on that face it reaches
+ * (the legs beside the cutout, the head over it, a window's bottom board under it), so a skirting
+ * or chair rail stops against the casing instead of running through it. A face the opening is not
+ * cased on breaks at the cutout only.
+ */
+function trimOpeningRanges(node, face, childrenNodes, yBottom, height) {
     const yTop = yBottom + height;
+    const reaches = (bottom, top) => top > yBottom + EPS && bottom < yTop - EPS;
+    const nodes = useScene.getState().nodes;
     return childrenNodes
         .filter((child) => child.type === 'door' || child.type === 'window')
         .flatMap((child) => {
@@ -349,10 +359,19 @@ function trimOpeningRanges(node, childrenNodes, yBottom, height) {
         const childHeight = child.height ?? 0;
         const position = child.position ?? [0, 0, 0];
         const childBottom = position[1] - childHeight / 2;
-        const childTop = childBottom + childHeight;
-        if (childTop <= yBottom + EPS || childBottom >= yTop - EPS)
-            return [];
-        return [[position[0] - width / 2, position[0] + width / 2]];
+        const ranges = [];
+        if (reaches(childBottom, childBottom + childHeight))
+            ranges.push([position[0] - width / 2, position[0] + width / 2]);
+        const opening = { ...child, position };
+        const host = resolveOpeningCasingHost(opening, nodes, node);
+        if (!host)
+            return ranges;
+        for (const board of openingCasingBoards(opening, host)) {
+            const [x, y] = [position[0] + board.center[0], position[1] + board.center[1]];
+            if (board.face === face && reaches(y - board.size[1] / 2, y + board.size[1] / 2))
+                ranges.push([x - board.size[0] / 2, x + board.size[0] / 2]);
+        }
+        return ranges;
     });
 }
 function buildPlanPolygon(outer, inner) {
@@ -456,9 +475,13 @@ export function buildTrimGeometry(node, side, trim, kind, childrenNodes, levelDa
     };
     const face = resolveTreatmentSideSign(node, side) > 0 ? 'a' : 'b';
     const faceScript = kind === 'skirting' ? node.finishScripts?.[face] : undefined;
+    const floorGaps = kind === 'skirting' ? skirtingFloorOpeningRanges(node, face, useScene.getState().nodes) : [];
     const runs = bases.flatMap((base) => {
         const bottom = support ? base.elevation - support.elevation : yBottom;
-        const openingRanges = trimOpeningRanges(node, childrenNodes, bottom, height);
+        const openingRanges = [
+            ...trimOpeningRanges(node, face, childrenNodes, bottom, height),
+            ...floorGaps,
+        ];
         if (support)
             for (const child of childrenNodes) {
                 for (const run of wallDoorStepRuns(node, child, support.faceDatum, support.elevation))

package/dist/window/actions.d.ts

@@ -0,0 +1,7 @@
+/**
+ * The window's action-menu contribution, in 2D and 3D, mirroring the door's: swap a casement's
+ * hinge side without opening the panel. One undo step; a closed window opens so the new side
+ * shows.
+ */
+export default function WindowActions(): import("react").JSX.Element | null;
+//# sourceMappingURL=actions.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"actions.d.ts","sourceRoot":"","sources":["../../src/window/actions.tsx"],"names":[],"mappings":"AASA;;;;GAIG;AACH,MAAM,CAAC,OAAO,UAAU,aAAa,uCAoBpC"}

package/dist/window/actions.js

@@ -0,0 +1,29 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { usePascalI18n, useScene } from '@pascal-app/core';
+import { ActionMenuButton } from '@pascal-app/editor';
+import { useViewer } from '@pascal-app/viewer';
+import { ArrowLeftRight } from 'lucide-react';
+import { applyOpeningSwap } from '../shared/opening-swap.js';
+import { windowMechanism } from './mechanism.js';
+import { canSwapWindowHinge, swapWindowHingePatch } from './swing.js';
+/**
+ * The window's action-menu contribution, in 2D and 3D, mirroring the door's: swap a casement's
+ * hinge side without opening the panel. One undo step; a closed window opens so the new side
+ * shows.
+ */
+export default function WindowActions() {
+    const i18n = usePascalI18n();
+    const selected = useViewer((s) => s.selection.selectedIds);
+    const windowNode = useScene((s) => {
+        const node = selected.length === 1 ? s.nodes[selected[0]] : undefined;
+        return node?.type === 'window' ? node : undefined;
+    });
+    const readOnly = useScene((s) => s.readOnly);
+    if (!windowNode || readOnly || !canSwapWindowHinge(windowNode))
+        return null;
+    return (_jsx(ActionMenuButton, { label: i18n._({ id: 'node.window.actions.swapHingeSide', message: 'Swap hinge side' }), onClick: (event) => {
+            event.stopPropagation();
+            applyOpeningSwap(windowNode, swapWindowHingePatch(windowNode), windowMechanism);
+        }, children: _jsx(ArrowLeftRight, { className: "h-4 w-4" }) }));
+}

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

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/window/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAGT,cAAc,EAEd,QAAQ,EAER,UAAU,IAAI,cAAc,EAC7B,MAAM,kBAAkB,CAAA;AAkCzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAOrC,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,GAC3B,SAAS,GAAG,IAAI,CAWlB;AAwMD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAgH9D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/window/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EACV,SAAS,EAGT,cAAc,EAEd,QAAQ,EAER,UAAU,IAAI,cAAc,EAC7B,MAAM,kBAAkB,CAAA;AAmCzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAOrC,wBAAgB,+BAA+B,CAC7C,MAAM,EAAE,cAAc,EACtB,KAAK,EAAE,IAAI,CAAC,QAAQ,EAAE,KAAK,CAAC,GAC3B,SAAS,GAAG,IAAI,CAWlB;AAwMD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAwH9D,CAAA"}

package/dist/window/definition.js

@@ -1,4 +1,5 @@
 import { getDormerWallHorizontalBoundsAtHeight, getDormerWallOpeningVerticalBounds, windowSlots, } from '@pascal-app/core';
+import { NEW_WINDOW_FRAME_THICKNESS } from '@pascal-app/core/building';
 import { curtainOpeningResizeMax } from '../shared/curtain-opening-limits.js';
 import { windowBatchable } from '../shared/node-batch/batchable.js';
 import { buildWindowFloorplanSchedule, computeWindowFloorplanLevelData, } from '../shared/opening-documentation.js';
@@ -228,19 +229,27 @@ export const windowDefinition = {
     kind: 'window',
     snapProfile: 'item',
     facingIndicator: true,
-    schemaVersion: 3,
+    schemaVersion: 4,
     schema: WindowNode,
     category: 'structure',
     extensions: {
         'pascal:editor/floorplan': {
             contextualDimensions: buildWindowContextualDimensions,
             schedule: buildWindowFloorplanSchedule,
+            // Swap a casement's hinge side from the action bar, in 2D and 3D.
+            actionMenu: { actions: () => import('./actions.js') },
         },
     },
     // Same schema-driven defaults trick as door: parse a stub, strip
     // id/type. Window also has many fields with zod `.default()` set.
     defaults: () => {
-        const stub = WindowNode.parse({ id: 'window_default', type: 'window' });
+        const stub = WindowNode.parse({
+            id: 'window_default',
+            type: 'window',
+            frameThickness: NEW_WINDOW_FRAME_THICKNESS,
+            casingFaceA: true,
+            casingFaceB: true,
+        });
         const { id: _id, type: _type, ...rest } = stub;
         return rest;
     },

package/dist/window/floorplan-move.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAQxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAsBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAkRrE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAIL,KAAK,mBAAmB,EAQxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAuBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAwRrE,CAAA"}

package/dist/window/floorplan-move.js

@@ -1,6 +1,7 @@
 import { evaluateCorner, runAsSingleSceneHistoryStep, useLiveNodeOverrides, useLiveTransforms, useScene, WallNode as WallNodeSchema, } from '@pascal-app/core';
 import { isGridSnapActive, isMagneticSnapActive, snapToHalf, triggerSFX, useEditor, usePlacementPreview, } from '@pascal-app/editor';
 import { createFloorplanCursorResolver } from '../shared/floorplan-cursor.js';
+import { movedOpeningCasingFaces } from '../shared/opening-casing-move.js';
 import { openingPlaneOffsetOnWall } from '../shared/opening-plane-offset.js';
 import { getOpeningHostLevelId, getRoofHostedOpeningPlanPoint } from '../shared/roof-opening-host.js';
 import { findClosestWallInPlan, projectWallLocalPointToPlan, resolveOpeningPlacement, snapLocalXToNeighbors, } from '../shared/wall-attach-target.js';
@@ -196,6 +197,8 @@ export const windowFloorplanMoveTarget = ({ node }) => {
                     : 'front'
                 : hit.side;
             const itemRotation = hit.itemRotation + (flipped ? Math.PI : 0);
+            // Another wall may be drawn the other way round: the casing keeps to its side.
+            const casing = movedOpeningCasingFaces(node, hit.wall.id, [0, itemRotation, 0], nodes);
             lastValid = {
                 // Same-wall moves keep the wall-local plane offset; another host resets it.
                 position: [clampedX, clampedY, openingPlaneOffsetOnWall(node, hit.wall.id)],
@@ -208,6 +211,7 @@ export const windowFloorplanMoveTarget = ({ node }) => {
                 roofSegmentId: undefined,
                 roofFace: undefined,
                 visible: true,
+                ...casing,
             };
             setLiveOverride(`wall:${hit.wall.id}:${side}`, {
                 parentId: hit.wall.id,
@@ -216,6 +220,7 @@ export const windowFloorplanMoveTarget = ({ node }) => {
                 roofSegmentId: undefined,
                 roofFace: undefined,
                 visible: true,
+                ...casing,
             });
             useLiveTransforms.getState().set(nodeId, {
                 position: lastValid.position,

package/dist/window/floorplan.d.ts

@@ -8,6 +8,8 @@ import type { FloorplanGeometry, GeometryContext, WindowNode } from '@pascal-app
  *   2. Inset inner outline — the "glass pane" frame inside the cutout.
  *   3. Center mullion line down the middle of the opening, along the
  *      wall direction — the legacy's standard glass divider.
+ *   4. Casing legs standing proud of each cased wall face beside the
+ *      cutout (`buildOpeningCasingPlan`).
  *
  * Skipped vs the full legacy for now: arched / rounded opening shape
  * variants, multi-pane mullion grids.

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/window/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iBAAiB,EAEjB,eAAe,EAEf,UAAU,EACX,MAAM,kBAAkB,CAAA;AAyEzB;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA+N1B"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/window/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAEV,iBAAiB,EAEjB,eAAe,EAEf,UAAU,EACX,MAAM,kBAAkB,CAAA;AAgFzB;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA6R1B"}