@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/wall/wall-batch-system.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-batch-system.d.ts","sourceRoot":"","sources":["../../src/wall/wall-batch-system.tsx"],"names":[],"mappings":"AAGA,OAAO,EAML,KAAK,QAAQ,EACd,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EAAE,KAAK,QAAQ,EAAW,IAAI,EAAiB,MAAM,OAAO,CAAA;AAkGnE,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD;AAED,wBAAgB,4BAA4B,IAAI,IAAI,CAKnD;AA6BD,MAAM,MAAM,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAA;AA+BtF;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,OAAO,GAAG,OAAO,CAEnF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAW5E;AAMD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,eAAe,GAAE,WAAW,CAAC,MAAM,CAAa,GAC/C,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAoBnC;AAsFD,eAAO,MAAM,eAAe,YAmE3B,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,IAAI,EACtB,OAAO,EAAE;IAAE,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,IAAI,CAAA;CAAE,QAyI3D"}
+{"version":3,"file":"wall-batch-system.d.ts","sourceRoot":"","sources":["../../src/wall/wall-batch-system.tsx"],"names":[],"mappings":"AAGA,OAAO,EAML,KAAK,QAAQ,EACd,MAAM,oBAAoB,CAAA;AAG3B,OAAO,EAAE,KAAK,QAAQ,EAAW,IAAI,EAAiB,MAAM,OAAO,CAAA;AAmGnE,wBAAgB,4BAA4B,IAAI,IAAI,CAEnD;AAED,wBAAgB,4BAA4B,IAAI,IAAI,CAKnD;AA6BD,MAAM,MAAM,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAA;AAiCtF;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,OAAO,GAAG,OAAO,CAEnF;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,OAAO,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CAe5E;AAED;;;;GAIG;AACH,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,IAAI,CAAC,IAAI,EAAE,UAAU,CAAC,EAC5B,SAAS,EAAE,SAAS,QAAQ,EAAE,GAC7B,QAAQ,EAAE,CAcZ;AAED,wBAAgB,cAAc,CAAC,SAAS,EAAE,SAAS,QAAQ,EAAE,GAAG,MAAM,CAErE;AAED,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,eAAe,GAAE,WAAW,CAAC,MAAM,CAAa,GAC/C,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAoBnC;AA2FD,eAAO,MAAM,eAAe,YAmE3B,CAAA;AAED;;;;;;;;;;GAUG;AACH,wBAAgB,aAAa,CAC3B,UAAU,EAAE,MAAM,IAAI,EACtB,OAAO,EAAE;IAAE,OAAO,EAAE,UAAU,CAAC,OAAO,UAAU,CAAC,GAAG,IAAI,CAAA;CAAE,QAyI3D"}

package/dist/wall/wall-batch-system.js

@@ -4,6 +4,7 @@ import { drainRebuiltWalls, getPendingWallRebuildCount, isIsolationActive, SCENE
 import { useFrame, useThree } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
 import { Matrix4, Mesh } from 'three';
+import { isSlotPaintPreviewActive } from '../shared/slot-paint';
 import { applyWallBatchGroups, buildWallBatch, hideBatchedWall, revealBatchedWall, } from './wall-batch';
 // A level's walls are merged only once they stop changing. Below this many
 // walls a merge is not worth the buffer, and the leftovers (a selected wall,
@@ -103,6 +104,9 @@ function toCandidate(nodeId, node, excludedNodeIds = EMPTY_IDS) {
         return null;
     if (node.visible === false)
         return null;
+    // Curtain walls use a separate caster that excludes their transparent panes.
+    if (node.wallType === 'curtain')
+        return null;
     const mesh = sceneRegistry.nodes.get(nodeId);
     if (!mesh?.visible)
         return null;
@@ -164,9 +168,35 @@ export function collectTintedWalls(wallIds) {
     const hovered = viewer.hoveredId;
     if (hovered && wallIds.has(hovered))
         tinted.add(hovered);
+    // A paint preview spreads past the hovered wall (a room's walls): each one it
+    // repaints has to draw itself, or the merged copy hides the preview.
+    for (const id of wallIds)
+        if (isSlotPaintPreviewActive(id))
+            tinted.add(id);
     return tinted;
 }
-function materialSetKey(materials) {
+/**
+ * The materials a wall actually draws, in canonical (uuid) order. Two walls
+ * showing the same finishes batch together however their palettes are laid out
+ * — a room's finish on side a of one wall and side b of the next is one set.
+ */
+export function canonicalWallMaterials(mesh, materials) {
+    const groups = mesh.geometry.groups;
+    const used = new Set();
+    if (groups.length === 0) {
+        if (materials[0])
+            used.add(materials[0]);
+    }
+    else {
+        for (const group of groups) {
+            const material = materials[group.materialIndex ?? 0];
+            if (material)
+                used.add(material);
+        }
+    }
+    return [...used].sort((left, right) => left.uuid < right.uuid ? -1 : left.uuid > right.uuid ? 1 : 0);
+}
+export function materialSetKey(materials) {
     return materials.map((material) => material.uuid).join('|');
 }
 export function collectWallBatchCandidates(levelId, excludedNodeIds = EMPTY_IDS) {
@@ -182,7 +212,7 @@ export function collectWallBatchCandidates(levelId, excludedNodeIds = EMPTY_IDS)
         const candidate = toCandidate(childId, child, excludedNodeIds);
         if (!candidate)
             continue;
-        const key = materialSetKey(candidate.materials);
+        const key = materialSetKey(canonicalWallMaterials(candidate.mesh, candidate.materials));
         const bucket = grouped.get(key);
         if (bucket)
             bucket.push(candidate);
@@ -231,18 +261,23 @@ function mergeLevel(levelId, excludedNodeIds = EMPTY_IDS) {
     for (const candidates of collectWallBatchCandidates(levelId, excludedNodeIds).values()) {
         if (candidates.length < MIN_BATCH_WALLS)
             continue;
+        const canonical = canonicalWallMaterials(candidates[0].mesh, candidates[0].materials);
         const sources = candidates.map((candidate) => {
             candidate.mesh.updateWorldMatrix(true, false);
             return {
                 nodeId: candidate.nodeId,
                 geometry: candidate.mesh.geometry,
                 matrix: localMatrix.multiplyMatrices(rootInverse, candidate.mesh.matrixWorld).clone(),
+                materialIndexMap: candidate.materials.map((material) => {
+                    const index = canonical.indexOf(material);
+                    return index < 0 ? undefined : index;
+                }),
             };
         });
         const batch = buildWallBatch(sources);
         if (!batch)
             continue;
-        const mesh = new Mesh(batch.geometry, candidates[0].materials);
+        const mesh = new Mesh(batch.geometry, canonical);
         mesh.name = 'wall-batch';
         mesh.userData.pascalExport = 'strip';
         mesh.castShadow = true;

package/dist/wall/wall-batch.d.ts

@@ -17,6 +17,12 @@ export type WallBatchSource = {
     geometry: THREE.BufferGeometry;
     /** Source-local to batch-root transform, baked into the merged vertices. */
     matrix: THREE.Matrix4;
+    /**
+     * Source material index → batch material index. Walls that draw the same
+     * materials in a different palette order share a batch this way; a group
+     * whose index maps nowhere draws nothing and is dropped.
+     */
+    materialIndexMap?: ReadonlyArray<number | undefined>;
 };
 export type WallBatch = {
     geometry: THREE.BufferGeometry;

package/dist/wall/wall-batch.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-batch.d.ts","sourceRoot":"","sources":["../../src/wall/wall-batch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,0EAA0E;AAC1E,MAAM,MAAM,cAAc,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7E,mEAAmE;AACnE,MAAM,MAAM,YAAY,GAAG;IACzB,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,cAAc,EAAE,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAA;IAC9B,4EAA4E;IAC5E,MAAM,EAAE,KAAK,CAAC,OAAO,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAA;IAC9B,IAAI,EAAE,YAAY,EAAE,CAAA;CACrB,CAAA;AAkCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,GAAG,IAAI,CAmEpF;AAwCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,CAmBxF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAE1D;AAED,oFAAoF;AACpF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAE5D"}
+{"version":3,"file":"wall-batch.d.ts","sourceRoot":"","sources":["../../src/wall/wall-batch.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAE9B,0EAA0E;AAC1E,MAAM,MAAM,cAAc,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7E,mEAAmE;AACnE,MAAM,MAAM,YAAY,GAAG;IACzB,aAAa,EAAE,MAAM,CAAA;IACrB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,cAAc,EAAE,CAAA;CACzB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAA;IAC9B,4EAA4E;IAC5E,MAAM,EAAE,KAAK,CAAC,OAAO,CAAA;IACrB;;;;OAIG;IACH,gBAAgB,CAAC,EAAE,aAAa,CAAC,MAAM,GAAG,SAAS,CAAC,CAAA;CACrD,CAAA;AAED,MAAM,MAAM,SAAS,GAAG;IACtB,QAAQ,EAAE,KAAK,CAAC,cAAc,CAAA;IAC9B,IAAI,EAAE,YAAY,EAAE,CAAA;CACrB,CAAA;AAuCD;;;;;;;;;;;;;GAaG;AACH,wBAAgB,cAAc,CAAC,OAAO,EAAE,SAAS,eAAe,EAAE,GAAG,SAAS,GAAG,IAAI,CAmEpF;AAwCD;;;;;;;;;;;;GAYG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,SAAS,EAAE,MAAM,EAAE,WAAW,CAAC,MAAM,CAAC,GAAG,IAAI,CAmBxF;AAED;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAE1D;AAED,oFAAoF;AACpF,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,KAAK,CAAC,QAAQ,GAAG,IAAI,CAE5D"}

package/dist/wall/wall-batch.js

@@ -20,7 +20,13 @@ function planSource(source) {
         const count = Math.min(group.count, position.count - start);
         if (count <= 0)
             continue;
-        groups.push({ materialIndex: group.materialIndex ?? 0, start, count });
+        const sourceIndex = group.materialIndex ?? 0;
+        const materialIndex = source.materialIndexMap
+            ? source.materialIndexMap[sourceIndex]
+            : sourceIndex;
+        if (materialIndex === undefined)
+            continue;
+        groups.push({ materialIndex, start, count });
     }
     return groups.length > 0 ? { source, groups } : null;
 }

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;AAqBzB,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;AA0JD;;;;;;;;;;GAUG;AACH,eAAO,MAAM,gBAAgB,EAAE,cAAc,CAAC,OAAO,UAAU,CAqG9D,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;AA6BzB,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,CA4G9D,CAAA"}

package/dist/window/definition.js

@@ -1,18 +1,24 @@
-import { getDormerWallHorizontalBoundsAtHeight, getDormerWallOpeningVerticalBounds, } from '@pascal-app/core';
+import { getDormerWallHorizontalBoundsAtHeight, getDormerWallOpeningVerticalBounds, windowSlots, } from '@pascal-app/core';
+import { curtainOpeningResizeMax } from '../shared/curtain-opening-limits';
+import { windowBatchable } from '../shared/node-batch/batchable';
 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 { scriptedOpeningHandles } from '../shared/scripted-opening-handles';
 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 { windowMechanism } from './mechanism';
 import { windowPaint } from './paint';
 import { windowParametrics } from './parametrics';
+import { WINDOW_PLACEMENT_HINTS } from './placement';
 import { WindowNode } from './schema';
-import { windowSlots } from './slots';
 const SIDE_HANDLE_OFFSET = 0.24;
 const HEIGHT_HANDLE_OFFSET = 0.24;
 const MIN_WINDOW_HEIGHT = 0.3;
@@ -82,7 +88,7 @@ function windowWidthHandle(side) {
             const roofMax = readRoofFaceWidthMax(n, scene, sign);
             if (roofMax !== null)
                 return Math.max(MIN_WINDOW_WIDTH, roofMax);
-            return readWallLength(n, scene);
+            return curtainOpeningResizeMax(n, scene.nodes(), 'x', sign) ?? readWallLength(n, scene);
         },
         currentValue: (n) => n.width,
         onDrag: (node) => publishOpeningResizeGuides(node, true),
@@ -131,7 +137,10 @@ function windowHeightHandle(edge) {
             // Maximum: distance from the anchored edge to the wall's allowed Y
             // bounds. Top arrow caps at the wall's resolved ceiling - bottom;
             // bottom arrow caps at top (positive Y room above the floor).
-            const wallH = readHostWallCeiling(n.wallId, scene);
+            const curtainMax = curtainOpeningResizeMax(n, scene.nodes(), 'y', sign);
+            if (curtainMax !== undefined)
+                return curtainMax;
+            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)
@@ -157,11 +166,51 @@ function windowHeightHandle(edge) {
         portalTarget: resolveWindowHandlePortalTarget,
     };
 }
+function windowRadiusHandle(index) {
+    const corners = [
+        [-1, 1],
+        [1, 1],
+        [1, -1],
+        [-1, -1],
+    ];
+    return {
+        kind: 'corner-radius',
+        corner: corners[index],
+        width: (node) => node.width,
+        height: (node) => node.height,
+        currentValue: (node) => node.openingRadiusMode === 'individual'
+            ? (node.openingCornerRadii[index] ?? 0)
+            : node.cornerRadius,
+        max: (node) => Math.min(node.width, node.height) / 2,
+        apply: (node, radius, _scene, modifiers) => {
+            if (!modifiers.shiftKey) {
+                return { openingShape: 'rounded', openingRadiusMode: 'all', cornerRadius: radius };
+            }
+            const radii = node.openingRadiusMode === 'individual'
+                ? [...node.openingCornerRadii]
+                : [node.cornerRadius, node.cornerRadius, node.cornerRadius, node.cornerRadius];
+            radii[index] = radius;
+            return {
+                openingShape: 'rounded',
+                openingRadiusMode: 'individual',
+                openingCornerRadii: radii,
+            };
+        },
+        createPreview: (node) => createOpeningPropertyPreview(node.id, openingPropertyPreviewHost),
+        visible: (node) => node.openingShape !== 'arch',
+        portal: 'grandparent',
+        portalTarget: resolveWindowHandlePortalTarget,
+    };
+}
 const windowHandles = [
     windowWidthHandle('left'),
     windowWidthHandle('right'),
     windowHeightHandle('top'),
     windowHeightHandle('bottom'),
+    windowRadiusHandle(0),
+    windowRadiusHandle(1),
+    windowRadiusHandle(2),
+    windowRadiusHandle(3),
 ];
 /**
  * Window — Phase 5 batch kind. Mirrors door's shape: hosted on walls,
@@ -195,6 +244,7 @@ export const windowDefinition = {
         return rest;
     },
     capabilities: {
+        batchable: windowBatchable,
         selectable: { hitVolume: 'bbox' },
         duplicable: true,
         deletable: true,
@@ -214,9 +264,13 @@ 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'),
@@ -252,6 +306,7 @@ export const windowDefinition = {
     },
     toolHints: [
         { key: 'Left click', label: 'Place window on wall' },
+        ...WINDOW_PLACEMENT_HINTS,
         { key: 'R', label: 'Flip side' },
         { key: 'Alt', label: 'Force place' },
         { key: 'Esc', label: 'Cancel' },

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAKxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAMzB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,UAAU,CAqEjE,CAAA"}
+{"version":3,"file":"floorplan-affordances.d.ts","sourceRoot":"","sources":["../../src/window/floorplan-affordances.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,mBAAmB,EAMxB,KAAK,UAAU,EAChB,MAAM,kBAAkB,CAAA;AAQzB;;;;;;;;;;;;;;;GAeG;AACH,eAAO,MAAM,qBAAqB,EAAE,mBAAmB,CAAC,UAAU,CAkEjE,CAAA"}

package/dist/window/floorplan-affordances.js

@@ -1,4 +1,6 @@
-import { useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { getWallCurveLength, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { curtainOpeningLimits } from '../shared/curtain-opening-limits';
+import { projectPlanPointToWallLocalX } from '../shared/wall-attach-target';
 const MIN_WINDOW_WIDTH = 0.3;
 /**
  * 2D drag affordance for the window's width side-arrows. Sister to the 3D
@@ -27,16 +29,12 @@ export const windowWidthAffordance = {
         const initialWindowZ = node.position[2];
         const growDir = side === 'end' ? 1 : -1;
         const anchorX = side === 'end' ? initialWindowX - initialWidth / 2 : initialWindowX + initialWidth / 2;
-        const wallStart = wall ? wall.start : [0, 0];
-        const wallEnd = wall ? wall.end : [1, 0];
-        const dx = wallEnd[0] - wallStart[0];
-        const dz = wallEnd[1] - wallStart[1];
-        const wallLength = Math.hypot(dx, dz) || 1;
-        const dirX = dx / wallLength;
-        const dirZ = dz / wallLength;
-        const maxWidth = growDir > 0 ? wallLength - anchorX : anchorX;
+        const wallLength = wall ? getWallCurveLength(wall) : 1;
+        const limits = curtainOpeningLimits(node, nodes);
+        const margin = limits?.margin ?? 0;
+        const maxWidth = growDir > 0 ? (limits?.length ?? wallLength) - margin - anchorX : anchorX - margin;
         const projectToWallLocalX = (planPoint) => {
-            return (planPoint[0] - wallStart[0]) * dirX + (planPoint[1] - wallStart[1]) * dirZ;
+            return wall ? projectPlanPointToWallLocalX(wall, planPoint) : planPoint[0];
         };
         const initialPointerLocalX = projectToWallLocalX(initialPlanPoint);
         let lastWidth = initialWidth;

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

package/dist/window/floorplan-move.js

@@ -1,6 +1,7 @@
 import { 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 { openingPlaneOffsetOnWall } from '../shared/opening-plane-offset';
 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';
@@ -163,7 +164,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,

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

package/dist/window/floorplan.js

@@ -1,6 +1,8 @@
+import { 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';
 /**
  * Stage C floor-plan builder for window. Mirrors the legacy
  * floorplan-panel window rendering:
@@ -31,11 +33,42 @@ 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;
+    // 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],
@@ -75,44 +108,93 @@ export function buildWindowFloorplan(node, ctx) {
     // 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',
-        },
-    ];
+    // 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 ? 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 ? 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',
+            },
+        ];
     // Move handle — orange dot at the window center. Only when selected.
     if (isSelected) {
         children.push({
@@ -124,24 +206,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 +235,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/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"}

package/dist/window/mechanism.js

@@ -0,0 +1,20 @@
+import { closeWindowOpenState, getDisplayedWindowValue, isOperableWindowType, openWindowOpenState, } from '@pascal-app/editor';
+import { scriptedOpening } from '../shared/scripted-opening';
+/** A window's sash: Open and Close preview it without touching the saved open state. */
+export const windowMechanism = {
+    verb: 'open',
+    icon: 'window',
+    has: (node) => node.type === 'window' &&
+        (node.source
+            ? scriptedOpening.has(node)
+            : node.openingKind !== 'opening' && isOperableWindowType(node.windowType)),
+    isOn: (node) => node.type === 'window' &&
+        (node.source
+            ? scriptedOpening.isOn(node)
+            : getDisplayedWindowValue(node.id, node.operationState) > 0),
+    set: (node, on) => {
+        if (node.type === 'window' && node.source)
+            return scriptedOpening.set(node, on);
+        return (on ? openWindowOpenState : closeWindowOpenState)(node.id, { persist: false });
+    },
+};

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