@pascal-app/nodes 1.0.4 → 1.0.5

package/dist/window/floorplan.js

@@ -1,8 +1,66 @@
-import { getWallBodyCenterOffset } from '@pascal-app/core';
+import { cornerPair, getWallBodyCenterOffset } from '@pascal-app/core';
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
-import { buildOpeningMarkAnnotation, } from '../shared/opening-documentation';
-import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dimensions';
-import { resolveOpeningPlanPlane } from '../shared/opening-plane-offset';
+import { buildOpeningMarkAnnotation, } from '../shared/opening-documentation.js';
+import { buildOpeningPlacementDimensions } from '../shared/opening-placement-dimensions.js';
+import { resolveOpeningPlanPlane } from '../shared/opening-plane-offset.js';
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1];
+/**
+ * Where a corner window ends at its corner: on the mitre its wall meets the partner's wall along,
+ * which the 3D cut opens up to, so the two sides meet there and the corner reads as glass rather
+ * than a wall post. `at(v)` is the mitre's along-wall position (from the wall's start) at a
+ * perpendicular offset `v` from the wall's reference line. Null when the window is not one side of
+ * a corner pair.
+ */
+function cornerMitre(node, wall, ctx) {
+    const partnerId = node.corner?.partnerId;
+    const partner = partnerId ? ctx.resolve(partnerId) : undefined;
+    const partnerWall = partner?.parentId
+        ? ctx.resolve(partner.parentId)
+        : undefined;
+    if (partner?.type !== 'window' || partnerWall?.type !== 'wall')
+        return null;
+    const pair = cornerPair({ [node.id]: node, [wall.id]: wall, [partner.id]: partner, [partnerWall.id]: partnerWall }, node);
+    if (!pair)
+        return null;
+    const into = (from, to) => {
+        const length = Math.hypot(to[0] - from[0], to[1] - from[1]);
+        return [(to[0] - from[0]) / length, (to[1] - from[1]) / length];
+    };
+    const length = Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
+    const dir = into(wall.start, wall.end);
+    const perp = [-dir[1], dir[0]];
+    const away = pair.end === 'start' ? dir : [-dir[0], -dir[1]];
+    const otherDir = into(partnerWall.start, partnerWall.end);
+    const otherPerp = [-otherDir[1], otherDir[0]];
+    const otherAway = partner.corner?.end === 'start' ? otherDir : [-otherDir[0], -otherDir[1]];
+    const half = (wall.thickness ?? 0.1) / 2;
+    const otherHalf = (partnerWall.thickness ?? 0.1) / 2;
+    // Each wall's face toward the other meets the other's face toward it; the outer faces meet too.
+    const side = Math.sign(dot(otherAway, perp)) || 1;
+    const otherSide = Math.sign(dot(away, otherPerp)) || 1;
+    const inner = getWallBodyCenterOffset(wall) + side * half;
+    const outer = getWallBodyCenterOffset(wall) - side * half;
+    const otherInner = getWallBodyCenterOffset(partnerWall) + otherSide * otherHalf;
+    const otherOuter = getWallBodyCenterOffset(partnerWall) - otherSide * otherHalf;
+    // How far from the corner, along this wall, its face at `v` meets the other's face at `q`;
+    // capped where a wall's own miter stops, at five thicknesses.
+    const reach = 10 * half;
+    const det = away[1] * otherAway[0] - away[0] * otherAway[1];
+    const meet = (v, q) => {
+        const rhs = [q * otherPerp[0] - v * perp[0], q * otherPerp[1] - v * perp[1]];
+        const t = (rhs[1] * otherAway[0] - rhs[0] * otherAway[1]) / det;
+        return Math.max(-reach, Math.min(reach, t));
+    };
+    const tInner = meet(inner, otherInner);
+    const tOuter = meet(outer, otherOuter);
+    return {
+        end: pair.end,
+        at: (v) => {
+            const t = tInner + ((v - inner) * (tOuter - tInner)) / (outer - inner);
+            return pair.end === 'start' ? t : length - t;
+        },
+    };
+}
 /**
  * Stage C floor-plan builder for window. Mirrors the legacy
  * floorplan-panel window rendering:
@@ -44,70 +102,54 @@ export function buildWindowFloorplan(node, ctx) {
     const cz = z1 + dirZ * distance + perpZ * across;
     const halfWidth = width / 2;
     const halfDepth = depth / 2;
-    // An offset frame stands clear of the wall centre, but the wall is still
-    // cut through its whole thickness: that hole is drawn too.
-    const wallX = x1 + dirX * distance + perpX * bodyOffset;
-    const wallZ = z1 + dirZ * distance + perpZ * bodyOffset;
     const halfWallDepth = wallDepth / 2;
-    const cutoutPoints = plane.offset === 0
-        ? null
-        : [
-            [
-                wallX - dirX * halfWidth + perpX * halfWallDepth,
-                wallZ - dirZ * halfWidth + perpZ * halfWallDepth,
-            ],
-            [
-                wallX + dirX * halfWidth + perpX * halfWallDepth,
-                wallZ + dirZ * halfWidth + perpZ * halfWallDepth,
-            ],
-            [
-                wallX + dirX * halfWidth - perpX * halfWallDepth,
-                wallZ + dirZ * halfWidth - perpZ * halfWallDepth,
-            ],
-            [
-                wallX - dirX * halfWidth - perpX * halfWallDepth,
-                wallZ - dirZ * halfWidth - perpZ * halfWallDepth,
-            ],
-        ];
-    const points = [
-        [cx - dirX * halfWidth + perpX * halfDepth, cz - dirZ * halfWidth + perpZ * halfDepth],
-        [cx + dirX * halfWidth + perpX * halfDepth, cz + dirZ * halfWidth + perpZ * halfDepth],
-        [cx + dirX * halfWidth - perpX * halfDepth, cz + dirZ * halfWidth - perpZ * halfDepth],
-        [cx - dirX * halfWidth - perpX * halfDepth, cz - dirZ * halfWidth - perpZ * halfDepth],
+    const plan = (along, v) => [
+        x1 + dirX * along + perpX * v,
+        z1 + dirZ * along + perpZ * v,
+    ];
+    // Where the window's side edge at perpendicular offset `v` lies along the wall, `inset` in from
+    // its jamb; a corner window's corner side runs to the mitre, with no jamb there.
+    const mitre = cornerMitre(node, wall, ctx);
+    const edge = (side, v, inset = 0) => mitre?.end === side
+        ? mitre.at(v)
+        : side === 'start'
+            ? distance - halfWidth + inset
+            : distance + halfWidth - inset;
+    const rectangle = (v, half, inset = 0) => [
+        plan(edge('start', v + half, inset), v + half),
+        plan(edge('end', v + half, inset), v + half),
+        plan(edge('end', v - half, inset), v - half),
+        plan(edge('start', v - half, inset), v - half),
     ];
+    // An offset frame stands clear of the wall centre, but the wall is still
+    // cut through its whole thickness: that hole is drawn too.
+    const cutoutPoints = plane.offset === 0 ? null : rectangle(bodyOffset, halfWallDepth);
+    const points = rectangle(across, halfDepth);
     const view = ctx.viewState;
     const palette = view?.palette;
     const isSelected = view?.selected ?? false;
     const isHighlighted = view?.highlighted ?? false;
+    const isHovered = view?.hovered ?? false;
     const showSelectedChrome = isSelected || isHighlighted;
     // Same selection treatment as door — selected windows get a full
-    // orange body + outline so they read as the active target.
-    const accentColor = showSelectedChrome ? '#f97316' : 'rgba(31, 41, 55, 0.92)';
+    // orange body + outline so they read as the active target. Hover takes the
+    // walls' hover stroke: the window a dragged one would join at a corner is
+    // outlined that way, as the 3D view outlines it.
+    const accentColor = showSelectedChrome
+        ? '#f97316'
+        : isHovered && palette
+            ? palette.wallHoverStroke
+            : 'rgba(31, 41, 55, 0.92)';
     const fillColor = showSelectedChrome ? '#fed7aa' : 'rgba(255, 255, 255, 0.96)';
     // Inner inset rectangle (the glass pane outline). Tangent inset
     // pulls the long sides in slightly; normal inset reduces the depth.
     const tangentInset = Math.min(width * 0.08, 0.12);
     const normalInset = Math.min(depth * 0.22, 0.07);
-    const innerStartA = [
-        cx - dirX * (halfWidth - tangentInset) + perpX * (halfDepth - normalInset),
-        cz - dirZ * (halfWidth - tangentInset) + perpZ * (halfDepth - normalInset),
-    ];
-    const innerEndA = [
-        cx + dirX * (halfWidth - tangentInset) + perpX * (halfDepth - normalInset),
-        cz + dirZ * (halfWidth - tangentInset) + perpZ * (halfDepth - normalInset),
-    ];
-    const innerEndB = [
-        cx + dirX * (halfWidth - tangentInset) - perpX * (halfDepth - normalInset),
-        cz + dirZ * (halfWidth - tangentInset) - perpZ * (halfDepth - normalInset),
-    ];
-    const innerStartB = [
-        cx - dirX * (halfWidth - tangentInset) - perpX * (halfDepth - normalInset),
-        cz - dirZ * (halfWidth - tangentInset) - perpZ * (halfDepth - normalInset),
-    ];
+    const innerPane = rectangle(across, halfDepth - normalInset, tangentInset);
     // Center mullion — from the midpoint of the left edge to the
     // midpoint of the right edge of the cutout.
-    const mullionStart = [cx - dirX * halfWidth, cz - dirZ * halfWidth];
-    const mullionEnd = [cx + dirX * halfWidth, cz + dirZ * halfWidth];
+    const mullionStart = plan(edge('start', across), across);
+    const mullionEnd = plan(edge('end', across), across);
     // A sheet draws the standard window symbol in plan-metre ink, so it prints
     // the same in every back end: the two wall faces carried across the opening
     // (the outline, which closes on the jambs) and the glass line between them.
@@ -128,7 +170,7 @@ export function buildWindowFloorplan(node, ctx) {
                     points: cutoutPoints,
                     fill: fillColor,
                     stroke: accentColor,
-                    strokeWidth: showSelectedChrome ? 1.9 : 1.25,
+                    strokeWidth: showSelectedChrome || isHovered ? 1.9 : 1.25,
                     vectorEffect: 'non-scaling-stroke',
                     strokeLinejoin: 'round',
                     metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
@@ -165,7 +207,7 @@ export function buildWindowFloorplan(node, ctx) {
                 points,
                 fill: fillColor,
                 stroke: accentColor,
-                strokeWidth: showSelectedChrome ? 1.9 : 1.25,
+                strokeWidth: showSelectedChrome || isHovered ? 1.9 : 1.25,
                 vectorEffect: 'non-scaling-stroke',
                 strokeLinejoin: 'round',
                 metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
@@ -173,7 +215,7 @@ export function buildWindowFloorplan(node, ctx) {
             // Inset glass-pane outline.
             {
                 kind: 'polygon',
-                points: [innerStartA, innerEndA, innerEndB, innerStartB],
+                points: innerPane,
                 fill: 'none',
                 stroke: accentColor,
                 strokeOpacity: 0.6,

package/dist/window/index.d.ts

@@ -1,3 +1,3 @@
-export { windowDefinition } from './definition';
-export { WindowNode } from './schema';
+export { windowDefinition } from './definition.js';
+export { WindowNode } from './schema.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/window/index.js

@@ -1,2 +1,2 @@
-export { windowDefinition } from './definition';
-export { WindowNode } from './schema';
+export { windowDefinition } from './definition.js';
+export { WindowNode } from './schema.js';

package/dist/window/mechanism.js

@@ -1,5 +1,5 @@
 import { closeWindowOpenState, getDisplayedWindowValue, isOperableWindowType, openWindowOpenState, } from '@pascal-app/editor';
-import { scriptedOpening } from '../shared/scripted-opening';
+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 = {
     verb: 'open',

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,EAqBL,UAAU,EACX,MAAM,kBAAkB,CAAA;AAmEzB;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,cAAc,EAAE,KAAK,CAAC,EAAE,CAAC;IAAE,IAAI,EAAE,UAAU,CAAA;CAAE,CAy0ClD,CAAA;AAED,eAAe,cAAc,CAAA"}
+{"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"}

package/dist/window/move-tool.js

@@ -1,21 +1,23 @@
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
-import { beginSceneHistoryDraft, collectionIdsOf, dormerWallFacePointToDormer, emitter, getOpeningWallPlacement, holdHiddenWallPointerEvents, isCurvedWall, runSceneHistoryDraftWrite, sceneRegistry, spatialGridManager, useLiveNodeOverrides, useLiveTransforms, useScene, WindowNode, } from '@pascal-app/core';
-import { calculateItemRotation, clearPlacementSurface, consumePlacementDragRelease, EDITOR_LAYER, getSideFromNormal, isGridSnapActive, isMagneticSnapActive, isValidWallSideFace, publishPlacementSurface, snapToHalf, stripPlacementMetadataFlags, triggerSFX, useAlignmentGuides, useEditor, useFacingPose, useRegistryToolContext, } from '@pascal-app/editor';
+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 { 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';
-import { dormerEventFromHostedWindow, getDormerWindowWorldNormal, getDormerWindowWorldYaw, resolveDormerWindowTarget, } from '../shared/dormer-wall-opening-placement';
-import { clearOpeningGuides3D, publishOpeningGuidesForWallEvent, resolveSillSnap, } from '../shared/opening-guides-runtime';
-import { beginOpeningMoveHistorySession } from '../shared/opening-move-history';
-import { isWallMeshHidden, shouldIgnoreWallEventForOpeningMove, } from '../shared/opening-move-wall-gate';
-import { openingPlaneOffsetOnWall } from '../shared/opening-plane-offset';
-import { getRoofWallOpeningCursorPose, resolveRoofWallOpeningTarget, } from '../shared/roof-wall-opening-placement';
-import { resolveOpeningPlacement } from '../shared/wall-attach-target';
-import { collectWallOpeningAlignmentCandidates, resolveWallSlideAlignment, } from '../shared/wall-opening-alignment';
-import { WindowFloorProjection } from './floor-projection';
-import WindowPreview from './preview';
-import { clampToWall, DEFAULT_WINDOW_SILL_M, hasWallChildOverlap, wallLocalToWorld, } from './window-math';
+import { commitOpeningMove } from '../shared/commit-opening-move.js';
+import { dormerEventFromHostedWindow, getDormerWindowWorldNormal, getDormerWindowWorldYaw, resolveDormerWindowTarget, } from '../shared/dormer-wall-opening-placement.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';
+import { openingPlaneOffsetOnWall } from '../shared/opening-plane-offset.js';
+import { getRoofWallOpeningCursorPose, resolveRoofWallOpeningTarget, } from '../shared/roof-wall-opening-placement.js';
+import { resolveOpeningPlacement } from '../shared/wall-attach-target.js';
+import { collectWallOpeningAlignmentCandidates, resolveWallSlideAlignment, } from '../shared/wall-opening-alignment.js';
+import { showCornerCue, snappingTurnedOff } from './corner-cue.js';
+import { fuseAtCorner, settleMovedWindow } from './corner-fuse.js';
+import { WindowFloorProjection } from './floor-projection.js';
+import WindowPreview from './preview.js';
+import { clampToWall, DEFAULT_WINDOW_SILL_M, hasWallChildOverlap, wallLocalToWorld, } from './window-math.js';
 const edgeMaterial = new LineBasicNodeMaterial({
     color: 0xef_44_44,
     linewidth: 3,
@@ -167,6 +169,20 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         // The wall the window was grabbed from. Nulled the first time the anchor
         // seeds on any other host: the grab offset is then forgotten for good.
         let grabWallId = movingWindowNode.parentId;
+        // Dragging near a corner, the same zone as placing: the window snaps its edge to the corner,
+        // the window waiting on the other wall is outlined, and on release they join. Alt drops it
+        // plain.
+        let cornerHeld = null;
+        const cornerEaser = createSnapEaser();
+        let cornerEaseFrame = 0;
+        const resetCorner = () => {
+            cornerHeld = null;
+            cornerEaser.reset();
+            if (cornerEaseFrame)
+                cancelAnimationFrame(cornerEaseFrame);
+            cornerEaseFrame = 0;
+            showCornerCue(null);
+        };
         let lastTarget = null;
         let lastRoofEvent = null;
         let lastDormerEvent = null;
@@ -203,6 +219,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         };
         const getSlabElevation = (wallEvent) => spatialGridManager.getSlabElevationForWall(wallEvent.node.parentId ?? '', wallEvent.node.start, wallEvent.node.end, wallEvent.node.curveOffset ?? 0, wallEvent.node.thickness, wallEvent.node.supportSlabId, wallEvent.node.justification);
         const hideCursor = () => {
+            resetCorner();
             if (cursorGroupRef.current)
                 cursorGroupRef.current.visible = false;
             useAlignmentGuides.getState().clear();
@@ -238,7 +255,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 eventWallHidden: isWallMeshHidden(event.node.id),
                 ownWallIds: [original.wallId, currentHostId],
             });
-        const resolveMoveTarget = (event) => {
+        const resolveMoveTarget = (event, plain = event.nativeEvent?.altKey === true || altHeld) => {
             if (!isValidWallSideFace(event.normal))
                 return;
             if (isCurvedWall(event.node)) {
@@ -297,8 +314,34 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 // component lives in `snapToHalf` (itself mode-aware).
                 applySnap: isMagneticSnapActive(),
             });
-            const { clampedX, clampedY } = clampToWall(event.node, localX, targetLocalY, movingWindowNode.width, movingWindowNode.height, useScene.getState().nodes);
-            const valid = !hasWallChildOverlap(event.node.id, useScene.getState().nodes, clampedX, clampedY, movingWindowNode.width, movingWindowNode.height, movingWindowNode.id);
+            const nodes = useScene.getState().nodes;
+            const slid = clampToWall(event.node, localX, targetLocalY, movingWindowNode.width, movingWindowNode.height, nodes);
+            const { clampedY } = slid;
+            let clampedX = slid.clampedX;
+            // 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()
+                ? { snap: null, block: null }
+                : evaluateCorner(nodes, {
+                    wallId: event.node.id,
+                    centreX: clampedX,
+                    width: movingWindowNode.width,
+                    height: movingWindowNode.height,
+                    sillHeight: clampedY - movingWindowNode.height / 2,
+                    ignoreId: movingWindowNode.id,
+                    held: cornerHeld,
+                });
+            let { snap, block } = found;
+            if (snap) {
+                const settled = clampToWall(event.node, snap.centreX, clampedY, movingWindowNode.width, movingWindowNode.height, nodes);
+                if (Math.abs(settled.clampedX - snap.centreX) > 1e-6) {
+                    block = { reason: 'curtain', end: snap.end };
+                    snap = null;
+                }
+                else
+                    clampedX = snap.centreX;
+            }
+            const valid = !hasWallChildOverlap(event.node.id, nodes, clampedX, clampedY, movingWindowNode.width, movingWindowNode.height, movingWindowNode.id);
             return {
                 wallNode: event.node,
                 wallId: event.node.id,
@@ -307,6 +350,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 clampedX,
                 clampedY,
                 valid,
+                snap,
+                block,
                 event,
             };
         };
@@ -317,6 +362,18 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             // mouse-move even when the window stays in the same along-wall cell.
             // Per-frame guard collapses duplicate wall events on the same pointermove.
             tickGridStep(target.event.nativeEvent?.timeStamp ?? -1, target.clampedX);
+            cornerHeld = (target.snap ?? target.block)?.end ?? null;
+            showCornerCue(target.snap, target.block);
+            // The ghost eases into and out of the snap; the drop always lands on the snapped place.
+            const now = performance.now();
+            const shownX = cornerEaser.display(target.clampedX, target.snap !== null, now, prefersReducedMotion());
+            if (cornerEaser.active(now) && !cornerEaseFrame) {
+                cornerEaseFrame = requestAnimationFrame(() => {
+                    cornerEaseFrame = 0;
+                    if (!committed && lastTarget)
+                        applyPreview(lastTarget);
+                });
+            }
             // Keep the REAL node hidden and show a tinted ghost in the wall opening —
             // green when placeable, red when it collides — matching the free-follow
             // ghost so validity reads at a glance (see MoveDoorTool). Reparenting
@@ -333,7 +390,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     // justified wall plus the opening's own plane offset, on the arc.
                     const placement = getOpeningWallPlacement(target.wallNode, {
                         ...movingWindowNode,
-                        position: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
+                        position: [shownX, target.clampedY, planeOffsetOn(target.wallId)],
                         rotation: [0, target.itemRotation, 0],
                     }, useScene.getState().nodes);
                     windowMesh.position.set(...placement.position);
@@ -343,7 +400,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             }
             else {
                 updateDraft({
-                    position: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
+                    position: [shownX, target.clampedY, planeOffsetOn(target.wallId)],
                     rotation: [0, target.itemRotation, 0],
                     side: target.side,
                     parentId: target.wallId,
@@ -358,7 +415,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 currentHostId = target.wallId;
             }
             useLiveTransforms.getState().set(movingWindowNode.id, {
-                position: [target.clampedX, target.clampedY, planeOffsetOn(target.wallId)],
+                position: [shownX, target.clampedY, planeOffsetOn(target.wallId)],
                 rotation: target.itemRotation,
             });
             markHostDirtyThrottled(target.wallId);
@@ -369,7 +426,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             // (-wallAngle + itemRotation); `cursorRotation` is π off here. See
             // `MoveDoorTool.applyPreview`.
             const wallAngle = Math.atan2(target.wallNode.end[1] - target.wallNode.start[1], target.wallNode.end[0] - target.wallNode.start[0]);
-            const ghostWorldPos = wallLocalToWorld(target.wallNode, target.clampedX, target.clampedY, getLevelYOffset(), getSlabElevation(target.event), planeOffsetOn(target.wallId));
+            const ghostWorldPos = wallLocalToWorld(target.wallNode, shownX, target.clampedY, getLevelYOffset(), getSlabElevation(target.event), planeOffsetOn(target.wallId));
             const ghostYaw = target.itemRotation - wallAngle;
             setGhostPose({
                 position: ghostWorldPos,
@@ -489,6 +546,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                     useScene
                         .getState()
                         .createNodes([{ node, parentId: target.wallId, collectionIds }]);
+                    if (target.snap)
+                        fuseAtCorner(node.id, target.snap.waitingId);
                 });
                 placedId = node.id;
             }
@@ -519,6 +578,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         roofSegmentId: undefined,
                         visible: true,
                     });
+                    settleMovedWindow(movingWindowNode.id, target.snap);
                 });
                 if (original.parentId && original.parentId !== target.wallId) {
                     markHostDirty(original.parentId);
@@ -771,6 +831,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         roofFace: undefined,
                         visible: true,
                     });
+                    settleMovedWindow(movingWindowNode.id, null);
                 });
                 if (original.parentId && original.parentId !== target.dormer.id) {
                     markHostDirty(original.parentId);
@@ -974,6 +1035,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                         roofFace: target.face.id,
                         visible: true,
                     });
+                    settleMovedWindow(movingWindowNode.id, null);
                 });
                 if (original.parentId && original.parentId !== segmentId) {
                     markHostDirty(original.parentId);
@@ -1056,11 +1118,8 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
                 return;
             if (e.key !== 'r' && e.key !== 'R')
                 return;
-            const target = e.target;
-            if (target &&
-                (target.tagName === 'INPUT' || target.tagName === 'TEXTAREA' || target.isContentEditable)) {
+            if (isTypingTarget(e.target))
                 return;
-            }
             // Ignore OS key-repeat so a held R doesn't flip many times per press.
             if (e.repeat)
                 return;
@@ -1099,12 +1158,17 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
         // Alt toggles force-place — re-run the on-wall preview so the tint flips
         // green↔red live (pointer stationary). Commit gates still read alt fresh.
         const onAltToggle = (e) => {
-            if (e.key !== 'Alt')
+            // A field's own Alt (a typed character) is not the placement's.
+            if (e.key !== 'Alt' || isTypingTarget(e.target))
                 return;
             const held = e.type === 'keydown';
             if (held === altHeld)
                 return;
             altHeld = held;
+            // Alt takes the corner join off the target at once and gives it back on release: the hint
+            // and the drop follow without the pointer moving.
+            if (lastTarget)
+                lastTarget = resolveMoveTarget(lastTarget.event, held) ?? lastTarget;
             if (!committed && lastTarget)
                 applyPreview(lastTarget);
         };
@@ -1151,6 +1215,7 @@ const MoveWindowTool = ({ node: movingWindowNode }) => {
             }
         }
         return () => {
+            resetCorner();
             // Safety cleanup: if still transient on unmount (e.g. phase switch mid-move)
             const current = useScene.getState().nodes[movingWindowNode.id];
             const currentMeta = current?.metadata;

package/dist/window/paint.js

@@ -1,4 +1,4 @@
-import { createSlotPaintCapability, previewSlotByUserData, resolveSlotByReRaycast, } from '../shared/slot-paint';
+import { createSlotPaintCapability, 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

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

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