@pascal-app/nodes 1.0.3 → 1.0.5

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;AAwBzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAQrC,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,CAsG9D,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;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"}

package/dist/window/definition.js

@@ -1,21 +1,25 @@
-import { getDormerWallHorizontalBoundsAtHeight, getDormerWallOpeningVerticalBounds, } from '@pascal-app/core';
-import { curtainOpeningResizeMax } from '../shared/curtain-opening-limits';
-import { buildWindowFloorplanSchedule, computeWindowFloorplanLevelData, } from '../shared/opening-documentation';
-import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime';
-import { createOpeningPropertyPreview } from '../shared/opening-property-preview';
-import { openingPropertyPreviewHost } from '../shared/opening-property-preview-host';
-import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host';
-import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut';
-import { readHostWallCeiling } from '../shared/wall-opening-ceiling';
-import { wallFloorplanSiblingOverrides } from '../wall/floorplan-overrides';
-import { buildWindowContextualDimensions } from './contextual-dimensions';
-import { buildWindowFloorplan } from './floorplan';
-import { windowWidthAffordance } from './floorplan-affordances';
-import { windowFloorplanMoveTarget } from './floorplan-move';
-import { windowPaint } from './paint';
-import { windowParametrics } from './parametrics';
-import { WindowNode } from './schema';
-import { windowSlots } from './slots';
+import { getDormerWallHorizontalBoundsAtHeight, getDormerWallOpeningVerticalBounds, windowSlots, } from '@pascal-app/core';
+import { curtainOpeningResizeMax } from '../shared/curtain-opening-limits.js';
+import { windowBatchable } from '../shared/node-batch/batchable.js';
+import { buildWindowFloorplanSchedule, computeWindowFloorplanLevelData, } from '../shared/opening-documentation.js';
+import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime.js';
+import { createOpeningPropertyPreview } from '../shared/opening-property-preview.js';
+import { openingPropertyPreviewHost } from '../shared/opening-property-preview-host.js';
+import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host.js';
+import { buildRoofWallOpeningCut } from '../shared/roof-wall-opening-cut.js';
+import { scriptedOpeningHandles } from '../shared/scripted-opening-handles.js';
+import { readHostWallCeiling } from '../shared/wall-opening-ceiling.js';
+import { openingSeenFromOutside } from '../wall/exterior.js';
+import { wallFloorplanSiblingOverrides } from '../wall/floorplan-overrides.js';
+import { buildWindowContextualDimensions } from './contextual-dimensions.js';
+import { buildWindowFloorplan } from './floorplan.js';
+import { windowWidthAffordance } from './floorplan-affordances.js';
+import { windowFloorplanMoveTarget } from './floorplan-move.js';
+import { windowMechanism } from './mechanism.js';
+import { windowPaint } from './paint.js';
+import { windowParametrics } from './parametrics.js';
+import { WINDOW_CORNER_HINTS, WINDOW_PLACEMENT_HINTS, WINDOW_PLAIN_PLACE_VISIBLE, } from './placement.js';
+import { WindowNode } from './schema.js';
 const SIDE_HANDLE_OFFSET = 0.24;
 const HEIGHT_HANDLE_OFFSET = 0.24;
 const MIN_WINDOW_HEIGHT = 0.3;
@@ -137,7 +141,7 @@ function windowHeightHandle(edge) {
             const curtainMax = curtainOpeningResizeMax(n, scene.nodes(), 'y', sign);
             if (curtainMax !== undefined)
                 return curtainMax;
-            const wallH = readHostWallCeiling(n.wallId, scene);
+            const wallH = readHostWallCeiling(n.wallId, scene, n);
             const anchored = edge === 'top' ? n.position[1] - n.height / 2 : n.position[1] + n.height / 2;
             return edge === 'top'
                 ? Math.max(MIN_WINDOW_HEIGHT, wallH - anchored)
@@ -241,6 +245,10 @@ export const windowDefinition = {
         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,
@@ -260,17 +268,20 @@ export const windowDefinition = {
         // each mesh with its `userData.slotId`; paint writes `node.slots`.
         slots: () => windowSlots(),
         paint: windowPaint,
+        mechanism: windowMechanism,
     },
     parametrics: windowParametrics,
-    handles: windowHandles,
+    handles: (node) => node.source
+        ? scriptedOpeningHandles(node, windowWidthHandle, () => windowHeightHandle('top'))
+        : windowHandles,
     rendersChildren: false,
     renderer: {
         kind: 'parametric',
-        module: () => import('./renderer'),
+        module: () => import('./renderer.js'),
     },
-    preview: () => import('./preview'),
+    preview: () => import('./preview.js'),
     system: {
-        module: () => import('./system'),
+        module: () => import('./system.js'),
         priority: 3,
     },
     // Stage C: floor-plan polygon. ctx.parent gives the wall for direction
@@ -284,9 +295,9 @@ export const windowDefinition = {
     floorplanSiblingOverrides: wallFloorplanSiblingOverrides,
     // Stage D — placement + move-on-wall. Same recipe as door. See
     // `nodes/src/window/{tool,move-tool,window-math}.ts`.
-    tool: () => import('./tool'),
+    tool: () => import('./tool.js'),
     affordanceTools: {
-        move: () => import('./move-tool'),
+        move: () => import('./move-tool.js'),
     },
     // 2D move-on-floorplan handler — same shape as door.
     floorplanMoveTarget: windowFloorplanMoveTarget,
@@ -298,7 +309,9 @@ export const windowDefinition = {
         'resize-width': windowWidthAffordance,
     },
     toolHints: [
-        { key: 'Left click', label: 'Place window on wall' },
+        { key: 'Left click', label: 'Place window on wall', visible: WINDOW_PLAIN_PLACE_VISIBLE },
+        ...WINDOW_CORNER_HINTS,
+        ...WINDOW_PLACEMENT_HINTS,
         { key: 'R', label: 'Flip side' },
         { key: 'Alt', label: 'Force place' },
         { key: 'Esc', label: 'Cancel' },

package/dist/window/floor-projection.js

@@ -1,5 +1,5 @@
 'use client';
-import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { Fragment as _Fragment, jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
 import { EDITOR_LAYER } from '@pascal-app/editor';
 import { useEffect, useMemo } from 'react';
 import { BufferGeometry, Float32BufferAttribute, LineSegments } from 'three';

package/dist/window/floorplan-affordances.js

@@ -1,6 +1,6 @@
 import { getWallCurveLength, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
-import { curtainOpeningLimits } from '../shared/curtain-opening-limits';
-import { projectPlanPointToWallLocalX } from '../shared/wall-attach-target';
+import { curtainOpeningLimits } from '../shared/curtain-opening-limits.js';
+import { projectPlanPointToWallLocalX } from '../shared/wall-attach-target.js';
 const MIN_WINDOW_WIDTH = 0.3;
 /**
  * 2D drag affordance for the window's width side-arrows. Sister to the 3D

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,EAEL,KAAK,mBAAmB,EAOxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAkPrE,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;AAsBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAkRrE,CAAA"}

package/dist/window/floorplan-move.js

@@ -1,9 +1,12 @@
-import { useLiveNodeOverrides, useLiveTransforms, useScene, WallNode as WallNodeSchema, } from '@pascal-app/core';
+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';
-import { getOpeningHostLevelId, getRoofHostedOpeningPlanPoint } from '../shared/roof-opening-host';
-import { findClosestWallInPlan, projectWallLocalPointToPlan, resolveOpeningPlacement, snapLocalXToNeighbors, } from '../shared/wall-attach-target';
-import { clampToWall, DEFAULT_WINDOW_SILL_M, hasWallChildOverlap } from './window-math';
+import { createFloorplanCursorResolver } from '../shared/floorplan-cursor.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';
+import { showCornerCue, snappingTurnedOff } from './corner-cue.js';
+import { settleMovedWindow } from './corner-fuse.js';
+import { clampToWall, DEFAULT_WINDOW_SILL_M, hasWallChildOverlap } from './window-math.js';
 /**
  * 2D floor-plan move handler for window. Same shape as door (see
  * `nodes/src/door/floorplan-move.ts`) — pointer in plan space → snap
@@ -55,6 +58,9 @@ export const windowFloorplanMoveTarget = ({ node }) => {
     // Alt force-place (last apply's modifier) — lets `canCommit` allow an
     // overlapping placement, matching the 3D move.
     let forcePlace = false;
+    // Near a corner, as in the 3D move: the edge snaps to it, the window waiting on the other wall
+    // is outlined, and the drop joins them. Alt drops it plain.
+    let cornerSnap = null;
     let liveTransformActive = useLiveTransforms.getState().transforms.has(nodeId);
     let liveOverrideKey = null;
     let placementPreviewActive = usePlacementPreview.getState().node?.id === nodeId;
@@ -82,6 +88,8 @@ export const windowFloorplanMoveTarget = ({ node }) => {
     const freeFollow = (planPoint) => {
         onWall = false;
         lastValid = null;
+        cornerSnap = null;
+        showCornerCue(null);
         if (liveTransformActive) {
             useLiveTransforms.getState().clear(nodeId);
             liveTransformActive = false;
@@ -152,7 +160,33 @@ export const windowFloorplanMoveTarget = ({ node }) => {
                     nodes,
                 });
             const snappedLocalX = neighborX ?? snapToHalf(hit.localX);
-            const { clampedX, clampedY } = clampToWall(hit.wall, snappedLocalX, startLocalY, node.width, node.height, nodes);
+            const slid = clampToWall(hit.wall, snappedLocalX, startLocalY, node.width, node.height, nodes);
+            const { clampedY } = slid;
+            let clampedX = slid.clampedX;
+            // Alt, or snapping off, drops the window where it is.
+            const corner = forcePlace || snappingTurnedOff()
+                ? { snap: null, block: null }
+                : evaluateCorner(nodes, {
+                    wallId: hit.wall.id,
+                    centreX: clampedX,
+                    width: node.width,
+                    height: node.height,
+                    sillHeight: clampedY - node.height / 2,
+                    ignoreId: nodeId,
+                    held: cornerSnap?.end ?? null,
+                });
+            cornerSnap = corner.snap;
+            // A curtain wall's margin can keep the window off its corner: then it is no corner.
+            if (cornerSnap) {
+                const settled = clampToWall(hit.wall, cornerSnap.centreX, clampedY, node.width, node.height, nodes);
+                if (Math.abs(settled.clampedX - cornerSnap.centreX) > 1e-6) {
+                    corner.block = { reason: 'curtain', end: cornerSnap.end };
+                    cornerSnap = null;
+                }
+                else
+                    clampedX = cornerSnap.centreX;
+            }
+            showCornerCue(cornerSnap, corner.block);
             // One click per real position step, keyed on the SNAPPED along-wall value
             // so it ticks only when the window actually moves to a new cell.
             tickGridStep(clampedX);
@@ -163,7 +197,8 @@ export const windowFloorplanMoveTarget = ({ node }) => {
                 : hit.side;
             const itemRotation = hit.itemRotation + (flipped ? Math.PI : 0);
             lastValid = {
-                position: [clampedX, clampedY, 0],
+                // Same-wall moves keep the wall-local plane offset; another host resets it.
+                position: [clampedX, clampedY, openingPlaneOffsetOnWall(node, hit.wall.id)],
                 rotation: [0, itemRotation, 0],
                 side,
                 parentId: hit.wall.id,
@@ -189,6 +224,7 @@ export const windowFloorplanMoveTarget = ({ node }) => {
             liveTransformActive = true;
         },
         canCommit() {
+            showCornerCue(null);
             // Off-wall the window is free-following — not placeable; the overlay
             // reverts to the pre-move snapshot. Matches the 3D move.
             if (!onWall || !lastValid)
@@ -211,12 +247,12 @@ export const windowFloorplanMoveTarget = ({ node }) => {
             // See `doorFloorplanMoveTarget.commit` for the original fix.
             if (!lastValid)
                 return;
-            useScene.getState().updateNodes([
-                {
-                    id: nodeId,
-                    data: lastValid,
-                },
-            ]);
+            const placed = lastValid;
+            // At a corner the window lands already joined, as one undo step.
+            runAsSingleSceneHistoryStep(useScene, () => {
+                useScene.getState().updateNodes([{ id: nodeId, data: placed }]);
+                settleMovedWindow(nodeId, cornerSnap);
+            });
         },
     };
     return session;

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,EACV,iBAAiB,EAEjB,eAAe,EAEf,UAAU,EACX,MAAM,kBAAkB,CAAA;AAQzB;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,UAAU,EAChB,GAAG,EAAE,eAAe,GACnB,iBAAiB,GAAG,IAAI,CA4J1B"}
+{"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"}

package/dist/window/floorplan.js

@@ -1,6 +1,66 @@
+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 { 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:
@@ -31,88 +91,152 @@ export function buildWindowFloorplan(node, ctx) {
     const perpZ = dirX;
     const distance = node.position[0];
     const width = node.width;
-    const depth = wall.thickness ?? 0.1;
-    const cx = x1 + dirX * distance;
-    const cz = z1 + dirZ * distance;
+    const wallDepth = wall.thickness ?? 0.1;
+    const plane = resolveOpeningPlanPlane(node, wallDepth);
+    const depth = plane.depth;
+    // The plane offset is measured from the body centre, which a justified wall
+    // sets off its reference line.
+    const bodyOffset = getWallBodyCenterOffset(wall);
+    const across = bodyOffset + plane.offset;
+    const cx = x1 + dirX * distance + perpX * across;
+    const cz = z1 + dirZ * distance + perpZ * across;
     const halfWidth = width / 2;
     const halfDepth = depth / 2;
-    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 halfWallDepth = wallDepth / 2;
+    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 children = [
-        // Outer footprint — white fill so the wall hatch underneath
-        // doesn't bleed through.
-        {
-            kind: 'polygon',
-            points,
-            fill: fillColor,
-            stroke: accentColor,
-            strokeWidth: showSelectedChrome ? 1.9 : 1.25,
-            vectorEffect: 'non-scaling-stroke',
-            strokeLinejoin: 'round',
-            metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
-        },
-        // Inset glass-pane outline.
-        {
-            kind: 'polygon',
-            points: [innerStartA, innerEndA, innerEndB, innerStartB],
-            fill: 'none',
-            stroke: accentColor,
-            strokeOpacity: 0.6,
-            strokeWidth: showSelectedChrome ? 1.3 : 0.9,
-            vectorEffect: 'non-scaling-stroke',
-            strokeLinejoin: 'round',
-        },
-        // Center mullion.
-        {
-            kind: 'line',
-            x1: mullionStart[0],
-            y1: mullionStart[1],
-            x2: mullionEnd[0],
-            y2: mullionEnd[1],
-            stroke: accentColor,
-            strokeWidth: showSelectedChrome ? 1.6 : 1.1,
-            strokeOpacity: 0.85,
-            strokeLinecap: 'round',
-            vectorEffect: 'non-scaling-stroke',
-        },
-    ];
+    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.
+    const drafting = readFloorplanContext(ctx).drafting;
+    const cutout = cutoutPoints
+        ? [
+            drafting
+                ? {
+                    kind: 'polygon',
+                    points: cutoutPoints,
+                    fill: '#ffffff',
+                    stroke: '#1f2937',
+                    strokeWidth: 0.01,
+                    strokeLinejoin: 'miter',
+                }
+                : {
+                    kind: 'polygon',
+                    points: cutoutPoints,
+                    fill: fillColor,
+                    stroke: accentColor,
+                    strokeWidth: showSelectedChrome || isHovered ? 1.9 : 1.25,
+                    vectorEffect: 'non-scaling-stroke',
+                    strokeLinejoin: 'round',
+                    metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
+                },
+        ]
+        : [];
+    const children = drafting
+        ? [
+            ...cutout,
+            {
+                kind: 'polygon',
+                points,
+                fill: '#ffffff',
+                stroke: '#1f2937',
+                strokeWidth: 0.01,
+                strokeLinejoin: 'miter',
+            },
+            {
+                kind: 'line',
+                x1: mullionStart[0],
+                y1: mullionStart[1],
+                x2: mullionEnd[0],
+                y2: mullionEnd[1],
+                stroke: '#1f2937',
+                strokeWidth: 0.008,
+            },
+        ]
+        : [
+            ...cutout,
+            // Outer footprint — white fill so the wall hatch underneath
+            // doesn't bleed through.
+            {
+                kind: 'polygon',
+                points,
+                fill: fillColor,
+                stroke: accentColor,
+                strokeWidth: showSelectedChrome || isHovered ? 1.9 : 1.25,
+                vectorEffect: 'non-scaling-stroke',
+                strokeLinejoin: 'round',
+                metadata: floorplanGeometryMetadata({ annotationObstacle: 'bounds' }),
+            },
+            // Inset glass-pane outline.
+            {
+                kind: 'polygon',
+                points: innerPane,
+                fill: 'none',
+                stroke: accentColor,
+                strokeOpacity: 0.6,
+                strokeWidth: showSelectedChrome ? 1.3 : 0.9,
+                vectorEffect: 'non-scaling-stroke',
+                strokeLinejoin: 'round',
+            },
+            // Center mullion.
+            {
+                kind: 'line',
+                x1: mullionStart[0],
+                y1: mullionStart[1],
+                x2: mullionEnd[0],
+                y2: mullionEnd[1],
+                stroke: accentColor,
+                strokeWidth: showSelectedChrome ? 1.6 : 1.1,
+                strokeOpacity: 0.85,
+                strokeLinecap: 'round',
+                vectorEffect: 'non-scaling-stroke',
+            },
+        ];
     // Move handle — orange dot at the window center. Only when selected.
     if (isSelected) {
         children.push({
@@ -124,24 +248,27 @@ export function buildWindowFloorplan(node, ctx) {
         // `resize-width` affordance — anchored at the opposite edge, clamped
         // to wall bounds. Mirrors the 3D `WindowSideArrow` width drag and the
         // door's 2D pattern.
-        const startEdgeX = cx - dirX * halfWidth;
-        const startEdgeZ = cz - dirZ * halfWidth;
-        const endEdgeX = cx + dirX * halfWidth;
-        const endEdgeZ = cz + dirZ * halfWidth;
-        children.push({
-            kind: 'move-arrow',
-            point: [startEdgeX, startEdgeZ],
-            angle: Math.atan2(-dirZ, -dirX),
-            affordance: 'resize-width',
-            payload: { side: 'start' },
-        });
-        children.push({
-            kind: 'move-arrow',
-            point: [endEdgeX, endEdgeZ],
-            angle: Math.atan2(dirZ, dirX),
-            affordance: 'resize-width',
-            payload: { side: 'end' },
-        });
+        // A scripted opening's width is its script's: its size arrows live in 3D, on its params.
+        if (!node.source) {
+            const startEdgeX = cx - dirX * halfWidth;
+            const startEdgeZ = cz - dirZ * halfWidth;
+            const endEdgeX = cx + dirX * halfWidth;
+            const endEdgeZ = cz + dirZ * halfWidth;
+            children.push({
+                kind: 'move-arrow',
+                point: [startEdgeX, startEdgeZ],
+                angle: Math.atan2(-dirZ, -dirX),
+                affordance: 'resize-width',
+                payload: { side: 'start' },
+            });
+            children.push({
+                kind: 'move-arrow',
+                point: [endEdgeX, endEdgeZ],
+                angle: Math.atan2(dirZ, dirX),
+                affordance: 'resize-width',
+                payload: { side: 'end' },
+            });
+        }
     }
     // Placement-measurement dimensions when actively moving — same
     // contract as door (see `nodes/src/door/floorplan.ts`).
@@ -150,7 +277,7 @@ export function buildWindowFloorplan(node, ctx) {
             children.push(dim);
         }
     }
-    const markAnnotation = buildOpeningMarkAnnotation(node, wall, ctx.levelData, { stroke: showSelectedChrome ? '#f97316' : '#334155' });
+    const markAnnotation = buildOpeningMarkAnnotation(node, wall, ctx.levelData, { stroke: showSelectedChrome ? '#f97316' : '#334155', drafting });
     if (markAnnotation)
         children.push(markAnnotation);
     return { kind: 'group', children };

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.d.ts

@@ -0,0 +1,4 @@
+import type { MechanismCapability } from '@pascal-app/core';
+/** A window's sash: Open and Close preview it without touching the saved open state. */
+export declare const windowMechanism: MechanismCapability;
+//# sourceMappingURL=mechanism.d.ts.map

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

@@ -0,0 +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"}