@pascal-app/nodes 1.0.6 → 1.1.0

package/dist/window/definition.render.js

@@ -0,0 +1,83 @@
+import { windowSlots } from '@pascal-app/core';
+import { NEW_WINDOW_FRAME_THICKNESS } from '@pascal-app/core/building';
+import { windowBatchable } from '../shared/node-batch/batchable.js';
+import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut.js';
+import { openingSeenFromOutside } from '../wall/exterior.js';
+import { windowMechanism } from './mechanism.js';
+import { WindowNode } from './schema.js';
+export function resolveWindowHandlePortalTarget(window, scene) {
+    const parentId = window.parentId;
+    if (!parentId)
+        return null;
+    const grandparentId = scene.get(parentId)
+        ?.parentId;
+    if (!grandparentId)
+        return null;
+    if (window.dormerId !== parentId)
+        return grandparentId;
+    return (scene.get(grandparentId)?.parentId ??
+        grandparentId);
+}
+export const windowRenderDefinition = {
+    kind: 'window',
+    schemaVersion: 4,
+    schema: WindowNode,
+    category: 'structure',
+    // 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',
+            frameThickness: NEW_WINDOW_FRAME_THICKNESS,
+            casingFaceA: true,
+            casingFaceB: true,
+        });
+        const { id: _id, type: _type, ...rest } = stub;
+        return rest;
+    },
+    capabilities: {
+        reveal: { phase: 'openings', style: 'cut' },
+        exterior: openingSeenFromOutside,
+        revealOnEdit: ['position', 'width', 'height', 'openingShape', 'windowType'],
+        batchable: windowBatchable,
+        selectable: { hitVolume: 'bbox' },
+        duplicable: true,
+        deletable: true,
+        wallOpeningPlacement: true,
+        // Windows also host on roof-segment wall faces (base walls under the
+        // roof, gable ends) — same wiring as door; see the door capability
+        // for why `dirtyHandledByOwnSystem` is required.
+        roofAccessory: {
+            buildCut: (node, hostSegment) => buildRoofWallOpeningCut(node, hostSegment),
+            cutScope: 'wall',
+            dirtyHandledByOwnSystem: true,
+        },
+        // `wallId` / `roofSegmentId` / `dormerId` are re-derived from the surface under
+        // the cursor at preset placement time — see door for the pattern.
+        hostRefFields: ['wallId', 'roofSegmentId', 'roofFace', 'dormerId', 'dormerFace'],
+        // Frame / glass slots painted through the registry. The window system tags
+        // each mesh with its `userData.slotId`; paint writes `node.slots`.
+        slots: () => windowSlots(),
+        mechanism: windowMechanism,
+    },
+    rendersChildren: false,
+    renderer: {
+        kind: 'parametric',
+        module: () => import('./renderer.js'),
+    },
+    system: {
+        module: () => import('./system.js'),
+        priority: 3,
+    },
+    presentation: {
+        label: 'Window',
+        description: 'A window cut into a wall. Animated open/close for opening windows.',
+        icon: { kind: 'url', src: '/icons/window.webp' },
+        paletteSection: 'structure',
+        paletteOrder: 60,
+    },
+    mcp: {
+        description: 'A window mounted on a wall, with type / dimensions / opening options.',
+    },
+};

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,CA6RrE,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';
@@ -55,6 +56,7 @@ export const windowFloorplanMoveTarget = ({ node }) => {
     // See `doorFloorplanMoveTarget`: off-wall the window free-follows the cursor
     // as a ghost and isn't committable (it needs a wall). Starts true.
     let onWall = true;
+    let lastFits = true;
     // Alt force-place (last apply's modifier) — lets `canCommit` allow an
     // overlapping placement, matching the 3D move.
     let forcePlace = false;
@@ -163,6 +165,7 @@ export const windowFloorplanMoveTarget = ({ node }) => {
             const slid = clampToWall(hit.wall, snappedLocalX, startLocalY, node.width, node.height, nodes);
             const { clampedY } = slid;
             let clampedX = slid.clampedX;
+            lastFits = slid.fits;
             // Alt, or snapping off, drops the window where it is.
             const corner = forcePlace || snappingTurnedOff()
                 ? { snap: null, block: null }
@@ -183,8 +186,10 @@ export const windowFloorplanMoveTarget = ({ node }) => {
                     corner.block = { reason: 'curtain', end: cornerSnap.end };
                     cornerSnap = null;
                 }
-                else
+                else {
                     clampedX = cornerSnap.centreX;
+                    lastFits = settled.fits;
+                }
             }
             showCornerCue(cornerSnap, corner.block);
             // One click per real position step, keyed on the SNAPPED along-wall value
@@ -196,6 +201,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 +215,7 @@ export const windowFloorplanMoveTarget = ({ node }) => {
                 roofSegmentId: undefined,
                 roofFace: undefined,
                 visible: true,
+                ...casing,
             };
             setLiveOverride(`wall:${hit.wall.id}:${side}`, {
                 parentId: hit.wall.id,
@@ -216,6 +224,7 @@ export const windowFloorplanMoveTarget = ({ node }) => {
                 roofSegmentId: undefined,
                 roofFace: undefined,
                 visible: true,
+                ...casing,
             });
             useLiveTransforms.getState().set(nodeId, {
                 position: lastValid.position,
@@ -232,9 +241,8 @@ export const windowFloorplanMoveTarget = ({ node }) => {
             const live = useScene.getState().nodes[nodeId];
             if (live?.type !== 'window')
                 return false;
-            // Block on overlap UNLESS Alt force-places — same `placeable` rule as
-            // the 3D move + the shared `resolveOpeningPlacement`.
-            const collides = hasWallChildOverlap(lastValid.parentId, useScene.getState().nodes, lastValid.position[0], lastValid.position[1], live.width, live.height, live.id);
+            const collides = !lastFits ||
+                hasWallChildOverlap(lastValid.parentId, useScene.getState().nodes, lastValid.position[0], lastValid.position[1], live.width, live.height, live.id);
             return resolveOpeningPlacement({ collides, forcePlace }).placeable;
         },
         commit() {

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"}

package/dist/window/floorplan.js

@@ -1,5 +1,6 @@
-import { cornerPair, getWallBodyCenterOffset } from '@pascal-app/core';
+import { cornerPair, getWallBodyCenterOffset, openingExteriorFace, openingHostFacing, } from '@pascal-app/core';
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
+import { buildOpeningCasingPlan } from '../shared/opening-casing.js';
 import { buildOpeningMarkAnnotation, } from '../shared/opening-documentation.js';
 import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dimensions.js';
 import { resolveOpeningPlanPlane } from '../shared/opening-plane-offset.js';
@@ -70,6 +71,8 @@ function cornerMitre(node, wall, ctx) {
  *   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.
@@ -237,6 +240,60 @@ export function buildWindowFloorplan(node, ctx) {
                 vectorEffect: 'non-scaling-stroke',
             },
         ];
+    // The mode uses its architectural symbol even while the sash is closed.
+    if (node.windowType === 'tilt-turn' && node.openingKind !== 'opening' && !node.source) {
+        const level = wall.parentId ? ctx.resolve(wall.parentId) : undefined;
+        const walls = [
+            wall,
+            ...(level?.type === 'level'
+                ? level.children.map((id) => ctx.resolve(id)).filter((entry) => !!entry)
+                : []),
+        ];
+        const nodes = Object.fromEntries(walls.map((entry) => [entry.id, entry]));
+        const inward = openingExteriorFace(node, nodes) === 'a' ? -1 : 1;
+        const ink = {
+            stroke: drafting ? '#1f2937' : accentColor,
+            strokeWidth: drafting ? 0.008 : 1.1,
+            ...(drafting ? {} : { vectorEffect: 'non-scaling-stroke' }),
+        };
+        if (node.tiltTurnMode === 'turn') {
+            const facing = openingHostFacing(node);
+            const hinge = (node.hingesSide === 'right' ? 1 : -1) * facing;
+            const radius = Math.max(width - 2 * node.frameThickness, 0.01);
+            const [hx, hz] = plan(distance + (hinge * radius) / 2, across);
+            const [closedX, closedZ] = plan(distance - (hinge * radius) / 2, across);
+            const [tipX, tipZ] = plan(distance + (hinge * radius) / 2, across + inward * radius);
+            children.push({
+                kind: 'path',
+                d: `M ${closedX} ${closedZ} A ${radius} ${radius} 0 0 ${hinge * inward < 0 ? 1 : 0} ${tipX} ${tipZ}`,
+                fill: 'none',
+                ...ink,
+            });
+            children.push({ kind: 'line', x1: hx, y1: hz, x2: tipX, y2: tipZ, ...ink });
+        }
+        else {
+            const left = plan(distance - width * 0.2, across);
+            const tip = plan(distance, across + inward * Math.max(depth, 0.15));
+            const right = plan(distance + width * 0.2, across);
+            children.push({
+                kind: 'path',
+                d: `M ${left[0]} ${left[1]} L ${tip[0]} ${tip[1]} L ${right[0]} ${right[1]}`,
+                fill: 'none',
+                ...ink,
+            });
+        }
+    }
+    // Casing legs on the wall faces beside the cutout, as the 3D window has them.
+    const casing = buildOpeningCasingPlan(node, wall, drafting
+        ? { fill: '#ffffff', stroke: '#1f2937', strokeWidth: 0.006 }
+        : {
+            fill: fillColor,
+            stroke: accentColor,
+            strokeWidth: showSelectedChrome || isHovered ? 1.3 : 1,
+            vectorEffect: 'non-scaling-stroke',
+        }, mitre?.end);
+    if (casing)
+        children.push(casing);
     // Move handle — orange dot at the window center. Only when selected.
     if (isSelected) {
         children.push({

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

@@ -1 +1 @@
-{"version":3,"file":"mechanism.d.ts","sourceRoot":"","sources":["../../src/window/mechanism.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAS3D,wFAAwF;AACxF,eAAO,MAAM,eAAe,EAAE,mBAiB7B,CAAA"}
+{"version":3,"file":"mechanism.d.ts","sourceRoot":"","sources":["../../src/window/mechanism.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAW3D,wFAAwF;AACxF,eAAO,MAAM,eAAe,EAAE,mBA4C7B,CAAA"}

package/dist/window/mechanism.js

@@ -1,7 +1,27 @@
-import { closeWindowOpenState, getDisplayedWindowValue, isOperableWindowType, openWindowOpenState, } from '@pascal-app/editor';
+import { closeWindowOpenState, getDisplayedWindowShutterValue, getDisplayedWindowValue, isOperableWindowType, openWindowOpenState, setWindowShuttersOpenState, } from '@pascal-app/core';
 import { scriptedOpening } from '../shared/scripted-opening.js';
 /** A window's sash: Open and Close preview it without touching the saved open state. */
 export const windowMechanism = {
+    parts: [
+        {
+            id: 'shutters',
+            label: 'Shutters',
+            icon: 'shutters',
+            verb: 'open',
+            has: (node) => node.type === 'window' &&
+                !node.source &&
+                ((Boolean(node.shutters) && node.shutters !== 'none') ||
+                    node.rollerShutter === 'box' ||
+                    node.rollerShutter === 'concealed'),
+            isOn: (node, state) => node.type === 'window' &&
+                ((Boolean(node.shutters) &&
+                    node.shutters !== 'none' &&
+                    getDisplayedWindowShutterValue(node.id, 'shutterOpen', node.shutterOpen, state) > 0) ||
+                    ((node.rollerShutter === 'box' || node.rollerShutter === 'concealed') &&
+                        getDisplayedWindowShutterValue(node.id, 'rollerShutterOpen', node.rollerShutterOpen, state) > 0)),
+            set: (node, on) => setWindowShuttersOpenState(node.id, on, { persist: false }),
+        },
+    ],
     verb: 'open',
     icon: 'window',
     has: (node) => node.type === 'window' &&

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

@@ -1 +1 @@
-{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EA0BL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAsEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAi5ClD,CAAA;eAEc,cAAc"}
+{"version":3,"file":"move-tool.d.ts","sourceRoot":"","sources":["../../src/window/move-tool.tsx"],"names":[],"mappings":"AAAA,OAAO,EA6BL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAuEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAu5ClD,CAAA;eAEc,cAAc"}

package/dist/window/move-tool.js

@@ -1,11 +1,12 @@
 import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { beginSceneHistoryDraft, collectionIdsOf, createSnapEaser, dormerWallFacePointToDormer, emitter, evaluateCorner, getOpeningWallPlacement, holdHiddenWallPointerEvents, isCurvedWall, prefersReducedMotion, runSceneHistoryDraftWrite, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useLiveTransforms, useScene, WindowNode, } from '@pascal-app/core';
+import { beginSceneHistoryDraft, collectionIdsOf, createSnapEaser, dormerWallFacePointToDormer, emitter, evaluateCorner, getOpeningWallPlacement, getWallThickness, holdHiddenWallPointerEvents, isCurvedWall, prefersReducedMotion, resolveHostedOpeningFrameDepth, resolveOpeningFrameDepth, runSceneHistoryDraftWrite, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useLiveTransforms, useScene, WindowNode, } from '@pascal-app/core';
 import { calculateItemRotation, clearPlacementSurface, consumePlacementDragRelease, EDITOR_LAYER, getSideFromNormal, isGridSnapActive, isMagneticSnapActive, isTypingTarget, isValidWallSideFace, publishPlacementSurface, snapToHalf, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, useRegistryToolContext, } from '@pascal-app/editor';
 import { useCallback, useEffect, useMemo, useRef, useState } from 'react';
 import { BoxGeometry, EdgesGeometry, Vector3 } from 'three';
 import { LineBasicNodeMaterial } from 'three/webgpu';
 import { commitOpeningMove } from '../shared/commit-opening-move.js';
 import { dormerEventFromHostedWindow, getDormerWindowWorldNormal, getDormerWindowWorldYaw, resolveDormerWindowTarget, } from '../shared/dormer-wall-opening-placement.js';
+import { movedOpeningCasingFaces } from '../shared/opening-casing-move.js';
 import { clearOpeningGuides3D, publishOpeningGuidesForWallEvent, resolveSillSnap, } from '../shared/opening-guides-runtime.js';
 import { beginOpeningMoveHistorySession } from '../shared/opening-move-history.js';
 import { isWallMeshHidden, shouldIgnoreWallEventForOpeningMove, } from '../shared/opening-move-wall-gate.js';
@@ -113,6 +114,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         }
         // Same-wall moves keep the wall-local plane offset; another host resets it.
         const planeOffsetOn = (wallId) => openingPlaneOffsetOnWall(movingWindowNode, wallId);
+        // Another host may name its faces the other way round: the casing keeps to its side of it.
+        const casingOn = (hostId, rotation) => movedOpeningCasingFaces(movingWindowNode, hostId, rotation, useScene.getState().nodes);
         let currentHostId = movingWindowNode.parentId;
         let committed = false;
         // Off-wall free-follow: over empty floor the window is parented to the
@@ -318,6 +321,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             const slid = clampToWall(event.node, localX, targetLocalY, movingWindowNode.width, movingWindowNode.height, nodes);
             const { clampedY } = slid;
             let clampedX = slid.clampedX;
+            let fits = slid.fits;
             // The corner zone: the edge snaps to the corner, unless a curtain wall's margin keeps it off.
             // Alt, or snapping off, places the window where it is dropped.
             const found = plain || snappingTurnedOff()
@@ -338,10 +342,13 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     block = { reason: 'curtain', end: snap.end };
                     snap = null;
                 }
-                else
+                else {
                     clampedX = snap.centreX;
+                    fits = settled.fits;
+                }
             }
-            const valid = !hasWallChildOverlap(event.node.id, nodes, clampedX, clampedY, movingWindowNode.width, movingWindowNode.height, movingWindowNode.id);
+            const valid = fits &&
+                !hasWallChildOverlap(event.node.id, nodes, clampedX, clampedY, movingWindowNode.width, movingWindowNode.height, movingWindowNode.id);
             return {
                 wallNode: event.node,
                 wallId: event.node.id,
@@ -445,7 +452,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     ghostWorldPos[2],
                 ],
                 rotationY: ghostYaw,
-                depth: movingWindowNode.frameDepth ?? 0.07,
+                depth: resolveOpeningFrameDepth(movingWindowNode, getWallThickness(target.wallNode)),
             });
             // Publish the wall surface so the snap grid tilts into the wall plane at
             // the opening (its outward normal is the window's facing, +Z by `ghostYaw`).
@@ -537,6 +544,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     side: target.side,
                     wallId: target.wallId,
                     parentId: target.wallId,
+                    ...casingOn(target.wallId, [0, target.itemRotation, 0]),
                     roofSegmentId: undefined,
                     roofFace: undefined,
                     // Hidden during free-follow; the committed window must be visible.
@@ -575,6 +583,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         side: target.side,
                         parentId: target.wallId,
                         wallId: target.wallId,
+                        ...casingOn(target.wallId, [0, target.itemRotation, 0]),
                         roofSegmentId: undefined,
                         visible: true,
                     });
@@ -663,15 +672,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             // Scene writes, not overrides: leaving the wall must actually remove the
             // window from the wall's `children` or the CSG cut trails the ghost
             // around the old wall (see the wall-branch note in `applyPreview`).
-            if (currentHostId === levelId) {
-                updateDraft({
-                    position: [localX, sillCenterY, localZ],
-                    rotation: [0, yaw, 0],
-                    side: sideOverride,
-                    visible: false,
-                });
-            }
-            else {
+            if (currentHostId !== levelId) {
                 if (currentHostId && currentHostId !== levelId)
                     markHostDirty(currentHostId);
                 updateDraft({
@@ -999,6 +1000,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     roofSegmentId: segmentId,
                     roofFace: target.face.id,
                     parentId: segmentId,
+                    ...casingOn(segmentId, [0, 0, 0]),
                     visible: true,
                 });
                 history.commitStep(() => {
@@ -1033,6 +1035,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         wallId: undefined,
                         roofSegmentId: segmentId,
                         roofFace: target.face.id,
+                        ...casingOn(segmentId, [0, 0, 0]),
                         visible: true,
                     });
                     settleMovedWindow(movingWindowNode.id, null);
@@ -1283,7 +1286,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         };
     }, [activeLevelId, exitMoveMode, isCameraDragging, movingWindowNode, selectNode]);
     const edgesGeo = useMemo(() => {
-        const boxGeo = new BoxGeometry(movingWindowNode.width, movingWindowNode.height, movingWindowNode.frameDepth ?? 0.07);
+        const boxGeo = new BoxGeometry(movingWindowNode.width, movingWindowNode.height, resolveHostedOpeningFrameDepth(movingWindowNode, useScene.getState().nodes));
         const geo = new EdgesGeometry(boxGeo);
         boxGeo.dispose();
         return geo;

package/dist/window/paint.d.ts

@@ -1,8 +1,3 @@
-/**
- * Window paint on the unified slot model. The window's opening proxy (a proud,
- * invisible cutout) wins the shared scene raycast over the wall in front of the
- * recessed window, so `resolveSlotByReRaycast` re-raycasts the window's own
- * subtree to find the part (frame / glass) under the cursor.
- */
-export declare const windowPaint: import("@pascal-app/core").PaintCapability;
+import { type PaintCapability } from '@pascal-app/core';
+export declare const windowPaint: PaintCapability;
 //# sourceMappingURL=paint.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/window/paint.ts"],"names":[],"mappings":"AAMA;;;;;GAKG;AACH,eAAO,MAAM,WAAW,4CAOtB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/window/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,KAAK,eAAe,EAA+C,MAAM,kBAAkB,CAAA;AAkCpG,eAAO,MAAM,WAAW,EAAE,eAezB,CAAA"}

package/dist/window/paint.js

@@ -1,14 +1,42 @@
-import { createSlotPaintCapability, previewSlotByUserData, resolveSlotByReRaycast, } from '../shared/slot-paint.js';
+import { slotDefaultPaintMaterial, slotPaintMaterial } from '@pascal-app/core';
+import { openingCasingPaintLabel } from '../shared/opening-casing.js';
+import { createSlotPaintCapability, declaredSlotLook, previewSlotByUserData, resolveSlotByReRaycast, } from '../shared/slot-paint.js';
 /**
  * Window paint on the unified slot model. The window's opening proxy (a proud,
  * invisible cutout) wins the shared scene raycast over the wall in front of the
  * recessed window, so `resolveSlotByReRaycast` re-raycasts the window's own
- * subtree to find the part (frame / glass) under the cursor.
+ * subtree to find the part (frame / glass / hardware / shutters) under the cursor.
  */
-export const windowPaint = createSlotPaintCapability({
+const base = createSlotPaintCapability({
     resolveRole: resolveSlotByReRaycast,
     applyPreview: previewSlotByUserData,
+    erasedLook: ({ node, role, materials = {} }) => {
+        if (role !== 'casing-a' && role !== 'casing-b' && role !== 'hardware' && role !== 'sill')
+            return declaredSlotLook(node, role);
+        if (node.type !== 'window' || node.source)
+            return null;
+        const frame = slotPaintMaterial(node.slots?.frame, materials) ?? slotDefaultPaintMaterial(node.slots?.frame);
+        if (frame)
+            return frame;
+        if (node.material)
+            return { material: node.material };
+        return declaredSlotLook(node, 'frame');
+    },
     legacyEffective: (node, role) => node.type === 'window' && !node.source && node.material && role === 'frame'
         ? { material: node.material, materialPreset: undefined }
         : null,
 });
+export const windowPaint = {
+    ...base,
+    roleLabel: (_node, role) => openingCasingPaintLabel(role),
+    getEffectiveMaterial: (args) => {
+        const own = base.getEffectiveMaterial?.(args);
+        if (own ||
+            (args.role !== 'casing-a' &&
+                args.role !== 'casing-b' &&
+                args.role !== 'hardware' &&
+                args.role !== 'sill'))
+            return own ?? null;
+        return base.getEffectiveMaterial?.({ ...args, role: 'frame' }) ?? null;
+    },
+};

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/window/panel.tsx"],"names":[],"mappings":"AA0GA,MAAM,CAAC,OAAO,UAAU,WAAW,uCA68BlC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/window/panel.tsx"],"names":[],"mappings":"AA+KA,MAAM,CAAC,OAAO,UAAU,WAAW,uCAm6ClC"}