@pascal-app/nodes 1.0.0-beta.5 → 1.0.0

package/dist/wall/treatment-level-data.js

@@ -1,13 +1,33 @@
-import { calculateLevelMiters, getWallThickness, } from '@pascal-app/core';
+import { calculateLevelMiters, getWallThickness, isCurvedWall, pointToKey, } from '@pascal-app/core';
 import { create } from 'zustand';
+import { shallow } from 'zustand/vanilla/shallow';
 const PROUD_KEY_PRECISION = 1e6;
 function proudKey(proud) {
     return Math.round(proud * PROUD_KEY_PRECISION) / PROUD_KEY_PRECISION;
 }
-export function buildWallTreatmentLevelData(walls, proudOffsets) {
-    const uniqueProudOffsets = new Set([0, ...proudOffsets.map(proudKey)]);
+export function treatmentProudKeys(proudOffsets) {
+    return [...new Set([0, ...proudOffsets.map(proudKey)])].sort((a, b) => a - b);
+}
+export function sameTreatmentWalls(a, b) {
+    return a.length === b.length && a.every((wall, index) => wall === b[index]);
+}
+const levelMiterCache = new Map();
+export function clearWallTreatmentMiterCache(levelId) {
+    if (levelId === undefined)
+        levelMiterCache.clear();
+    else
+        levelMiterCache.delete(levelId);
+}
+export function buildWallTreatmentLevelData(levelId, walls, proudOffsets) {
+    const cached = levelMiterCache.get(levelId);
+    const reusable = cached && sameTreatmentWalls(cached.walls, walls) ? cached : undefined;
     const miterDataByProud = new Map();
-    for (const proud of uniqueProudOffsets) {
+    for (const proud of treatmentProudKeys(proudOffsets)) {
+        const previous = reusable?.miterDataByProud.get(proud);
+        if (previous) {
+            miterDataByProud.set(proud, previous);
+            continue;
+        }
         const adjustedWalls = proud === 0
             ? [...walls]
             : walls.map((wall) => ({
@@ -16,11 +36,61 @@ export function buildWallTreatmentLevelData(walls, proudOffsets) {
             }));
         miterDataByProud.set(proud, calculateLevelMiters(adjustedWalls));
     }
-    return { walls, miterDataByProud };
+    const data = { walls, miterDataByProud };
+    levelMiterCache.set(levelId, data);
+    return data;
 }
 export function treatmentMiterDataForProud(levelData, proud) {
     return levelData.miterDataByProud.get(proudKey(proud));
 }
+export function createWallTreatmentSelector(node, proudOffsets) {
+    const keys = isCurvedWall(node)
+        ? []
+        : [...new Set([node.start, node.end].map(([x, y]) => pointToKey({ x, y })))];
+    const prouds = treatmentProudKeys(proudOffsets);
+    let previousLevel;
+    let previousSlice;
+    let previousInputs = [];
+    return (state) => {
+        const level = node.parentId ? state.byLevelId.get(node.parentId) : undefined;
+        if (level === previousLevel)
+            return previousSlice;
+        previousLevel = level;
+        if (!level) {
+            previousSlice = undefined;
+            previousInputs = [];
+            return undefined;
+        }
+        const inputs = [];
+        for (const proud of prouds) {
+            const data = level.miterDataByProud.get(proud);
+            inputs.push(!!data);
+            for (const key of keys) {
+                const entry = data?.junctionData.get(key)?.get(node.id);
+                inputs.push(entry?.left?.x, entry?.left?.y, entry?.right?.x, entry?.right?.y);
+            }
+        }
+        if (previousSlice && shallow(previousInputs, inputs))
+            return previousSlice;
+        const miterDataByProud = new Map();
+        for (const proud of prouds) {
+            const data = level.miterDataByProud.get(proud);
+            if (!data)
+                continue;
+            const junctionData = new Map();
+            for (const key of keys) {
+                const entry = data.junctionData.get(key)?.get(node.id);
+                if (entry)
+                    junctionData.set(key, new Map([[node.id, entry]]));
+            }
+            // Trim boundaries read only this wall's endpoint intersections, never junction membership.
+            miterDataByProud.set(proud, { junctionData, junctions: new Map() });
+        }
+        previousInputs = inputs;
+        previousSlice = { walls: [node], miterDataByProud };
+        return previousSlice;
+    };
+}
 export const useWallTreatmentLevelData = create((set) => ({
     byLevelId: new Map(),
     setLevelData: (levelId, data) => set((state) => {
@@ -28,4 +98,11 @@ export const useWallTreatmentLevelData = create((set) => ({
         byLevelId.set(levelId, data);
         return { byLevelId };
     }),
+    removeLevelData: (levelId) => set((state) => {
+        if (!state.byLevelId.has(levelId))
+            return state;
+        const byLevelId = new Map(state.byLevelId);
+        byLevelId.delete(levelId);
+        return { byLevelId };
+    }),
 }));

package/dist/wall/treatments.d.ts

@@ -12,6 +12,7 @@ type TrimKind = 'skirting' | 'crown' | 'chairRail';
 type WallSide = 'interior' | 'exterior';
 type SceneMaterials = Record<SceneMaterialId, SceneMaterial>;
 type WallTreatmentSlotId = 'skirtingInterior' | 'skirtingExterior' | 'crownInterior' | 'crownExterior' | 'chairRailInterior' | 'chairRailExterior';
+export declare function hasWallTreatments(node: WallNode): boolean;
 export declare function wallTreatmentProudOffsets(node: WallNode): number[];
 export declare function buildTrimGeometry(node: WallNode, side: WallSide, trim: WallTrimConfig, kind: TrimKind, childrenNodes: OpeningLike[], levelData: WallTreatmentLevelData): THREE.BufferGeometry<THREE.NormalBufferAttributes, THREE.BufferGeometryEventMap> | null;
 export declare function createWallExtraSlotMaterials(node: WallNode, shading: RenderShading, sceneMaterials: SceneMaterials): {

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

@@ -1 +1 @@
-{"version":3,"file":"treatments.d.ts","sourceRoot":"","sources":["../../src/wall/treatments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,eAAe,EAMpB,KAAK,QAAQ,EAEb,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,EAA8B,KAAK,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAMhG,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC,CAAA;AAED,KAAK,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,CAAA;AAClD,KAAK,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAA;AACvC,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;AAE5D,KAAK,mBAAmB,GACpB,kBAAkB,GAClB,kBAAkB,GAClB,eAAe,GACf,eAAe,GACf,mBAAmB,GACnB,mBAAmB,CAAA;AAmNvB,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAoBlE;AAuND,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,QAAQ,EACd,aAAa,EAAE,WAAW,EAAE,EAC5B,SAAS,EAAE,sBAAsB,2FAsDlC;AAkBD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,cAAc;;;;;;;EAU/B;AAED,eAAO,MAAM,cAAc,uFAKxB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,EAAE,WAAW,EAAE,CAAA;IAC5B,SAAS,EAAE,sBAAsB,CAAA;IACjC,SAAS,EAAE,MAAM,CAAC,mBAAmB,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CACvD,iCAmEC,CAAA"}
+{"version":3,"file":"treatments.d.ts","sourceRoot":"","sources":["../../src/wall/treatments.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,eAAe,EAMpB,KAAK,QAAQ,EAEb,KAAK,cAAc,EAEpB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAGL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAE3B,OAAO,KAAK,KAAK,MAAM,OAAO,CAAA;AAG9B,OAAO,EAA8B,KAAK,sBAAsB,EAAE,MAAM,wBAAwB,CAAA;AAMhG,KAAK,WAAW,GAAG;IACjB,IAAI,EAAE,MAAM,CAAA;IACZ,KAAK,CAAC,EAAE,MAAM,CAAA;IACd,MAAM,CAAC,EAAE,MAAM,CAAA;IACf,QAAQ,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;CACpC,CAAA;AAED,KAAK,QAAQ,GAAG,UAAU,GAAG,OAAO,GAAG,WAAW,CAAA;AAClD,KAAK,QAAQ,GAAG,UAAU,GAAG,UAAU,CAAA;AACvC,KAAK,cAAc,GAAG,MAAM,CAAC,eAAe,EAAE,aAAa,CAAC,CAAA;AAE5D,KAAK,mBAAmB,GACpB,kBAAkB,GAClB,kBAAkB,GAClB,eAAe,GACf,eAAe,GACf,mBAAmB,GACnB,mBAAmB,CAAA;AAmNvB,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,OAAO,CAMzD;AAED,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,QAAQ,GAAG,MAAM,EAAE,CAoBlE;AAuND,wBAAgB,iBAAiB,CAC/B,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,QAAQ,EACd,IAAI,EAAE,cAAc,EACpB,IAAI,EAAE,QAAQ,EACd,aAAa,EAAE,WAAW,EAAE,EAC5B,SAAS,EAAE,sBAAsB,2FAsDlC;AAkBD,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,OAAO,EAAE,aAAa,EACtB,cAAc,EAAE,cAAc;;;;;;;EAU/B;AAED,eAAO,MAAM,cAAc,uFAKxB;IACD,IAAI,EAAE,QAAQ,CAAA;IACd,aAAa,EAAE,WAAW,EAAE,CAAA;IAC5B,SAAS,EAAE,sBAAsB,CAAA;IACjC,SAAS,EAAE,MAAM,CAAC,mBAAmB,EAAE,KAAK,CAAC,QAAQ,CAAC,CAAA;CACvD,iCAmEC,CAAA"}

package/dist/wall/treatments.js

@@ -221,6 +221,11 @@ function resolveTrimProfile(kind, trim) {
         TRIM_PROFILES[kind][defaultProfile] ??
         TRIM_PROFILES[kind].flat);
 }
+export function hasWallTreatments(node) {
+    return !!((node.skirting?.enabled ?? WALL_SKIRTING_DEFAULT.enabled) ||
+        (node.crown?.enabled ?? WALL_CROWN_DEFAULT.enabled) ||
+        (node.chairRail?.enabled ?? WALL_CHAIR_RAIL_DEFAULT.enabled));
+}
 export function wallTreatmentProudOffsets(node) {
     const offsets = new Set();
     const configs = [

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

@@ -1,5 +1,7 @@
 import { type WallMode } from '@pascal-app/viewer';
 import { type Material, Mesh } from 'three';
+export declare function revealBatchedWallsForCapture(): void;
+export declare function holdBatchedWallsAfterCapture(): void;
 export type WallBatchCandidate = {
     nodeId: string;
     mesh: Mesh;
@@ -10,14 +12,44 @@ export type WallBatchCandidate = {
  *
  * The merged mesh captures one material set when it is sewn and nothing
  * re-reads it, so batching is only sound while every batched wall's materials
- * hold still. That is true in one wall mode. `cutaway` re-assigns materials
- * from the camera's facing test as the view turns, `down` makes every wall
- * see-through and `translucent` does the same by definition — in all three the
- * merged copy would keep drawing walls the cutaway pass has since turned to
- * glass. Isolation is the other stand-down: it hides the level root the merged
- * mesh hangs off, which would leave a focused batched wall drawn by nobody.
+ * hold still. That is true in `up`; in `cutaway`, walls stamped `wallHidden`
+ * are released per wall in the same frame because WallCutout runs at priority
+ * 0 and this system at 5. `down` and `translucent` make every wall see-through.
+ * Isolation is the other stand-down: it hides the level root the merged mesh
+ * hangs off, which would leave a focused batched wall drawn by nobody.
  */
 export declare function canBatchWalls(wallMode: WallMode, isolationActive: boolean): boolean;
+/**
+ * Walls the viewer is currently lighting up — a selection, or any hover.
+ *
+ * A selection or delete hover paints the wall by swapping the materials on its
+ * own mesh, which the merged mesh does not follow. Every other hover draws an
+ * outline instead, and that needs the same thing for a different reason: the
+ * outline node renders `outliner.hoveredObjects` through the main camera, which
+ * enables no batched layer, so a sewn wall reaches neither mask pass and
+ * hovering it lights up nothing at all — in select mode, and in paint mode
+ * where the outline is the only signal for which surface the next click lands
+ * on.
+ *
+ * Both wants are the same one: a lit wall goes back to drawing its own
+ * geometry. Only ever a handful are lit at once, and a handful of extra draw
+ * calls is what lighting them costs.
+ */
+export declare function collectTintedWalls(wallIds: ReadonlySet<string>): Set<string>;
 export declare function collectWallBatchCandidates(levelId: string, excludedNodeIds?: ReadonlySet<string>): Map<string, WallBatchCandidate[]>;
 export declare const WallBatchSystem: () => null;
+/**
+ * Follows the scene's dirty tracking rather than watching the walls itself.
+ *
+ * A wall changes for exactly one reason the merged mesh cares about: the wall
+ * system rebuilt its geometry. That system already runs off `dirtyNodes`, so
+ * this reads the same signal from both ends — the marks still standing when
+ * this frame reaches us, and the rebuild notices the wall system left behind
+ * for the walls whose marks it has already cleared. Nothing here re-derives
+ * "did this wall move" on its own, and the per-frame cost is the size of the
+ * dirty set rather than the size of the floor.
+ */
+export declare function runBatchFrame(invalidate: () => void, wakeRef: {
+    current: ReturnType<typeof setTimeout> | null;
+}): void;
 //# sourceMappingURL=wall-batch-system.d.ts.map

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;AA4HnE,MAAM,MAAM,kBAAkB,GAAG;IAAE,MAAM,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,IAAI,CAAC;IAAC,SAAS,EAAE,QAAQ,EAAE,CAAA;CAAE,CAAA;AA8BtF;;;;;;;;;;;GAWG;AACH,wBAAgB,aAAa,CAAC,QAAQ,EAAE,QAAQ,EAAE,eAAe,EAAE,OAAO,GAAG,OAAO,CAEnF;AA2BD,wBAAgB,0BAA0B,CACxC,OAAO,EAAE,MAAM,EACf,eAAe,GAAE,WAAW,CAAC,MAAM,CAAa,GAC/C,GAAG,CAAC,MAAM,EAAE,kBAAkB,EAAE,CAAC,CAoBnC;AAqFD,eAAO,MAAM,eAAe,YAwB3B,CAAA"}
+{"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"}

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

@@ -1,5 +1,5 @@
 'use client';
-import { sceneRegistry, useScene } from '@pascal-app/core';
+import { emitter, sceneRegistry, useScene } from '@pascal-app/core';
 import { drainRebuiltWalls, getPendingWallRebuildCount, isIsolationActive, SCENE_LAYER, useViewer, } from '@pascal-app/viewer';
 import { useFrame, useThree } from '@react-three/fiber';
 import { useEffect, useRef } from 'react';
@@ -40,6 +40,7 @@ const batchByNode = new Map();
 const staleLevels = new Set();
 const changedWalls = new Set();
 const EMPTY_IDS = new Set();
+let lastCutawayHiddenWalls = EMPTY_IDS;
 let knownWallCount = -1;
 let lastWallChangeAtMs = 0;
 let batchingSuspended = false;
@@ -56,6 +57,17 @@ function showOwnGeometry(nodeId) {
     if (mesh)
         revealBatchedWall(mesh);
 }
+export function revealBatchedWallsForCapture() {
+    for (const nodeId of batchByNode.keys())
+        showOwnGeometry(nodeId);
+}
+export function holdBatchedWallsAfterCapture() {
+    for (const nodeId of batchByNode.keys()) {
+        const mesh = sceneRegistry.nodes.get(nodeId);
+        if (mesh)
+            hideBatchedWall(mesh);
+    }
+}
 /** Hands a wall back to itself: the merged mesh stops drawing it, it resumes. */
 function releaseWall(nodeId) {
     const record = batchByNode.get(nodeId);
@@ -94,6 +106,8 @@ function toCandidate(nodeId, node, excludedNodeIds = EMPTY_IDS) {
     const mesh = sceneRegistry.nodes.get(nodeId);
     if (!mesh?.visible)
         return null;
+    if (mesh.userData.wallHidden === true)
+        return null;
     // Solo's shadow-caster-only pass and the viewer's isolation filter both
     // hide a wall by taking it off the scene layer. Sewing it in would put it
     // back on screen through the merged mesh, which neither asked for.
@@ -113,25 +127,32 @@ function toCandidate(nodeId, node, excludedNodeIds = EMPTY_IDS) {
  *
  * The merged mesh captures one material set when it is sewn and nothing
  * re-reads it, so batching is only sound while every batched wall's materials
- * hold still. That is true in one wall mode. `cutaway` re-assigns materials
- * from the camera's facing test as the view turns, `down` makes every wall
- * see-through and `translucent` does the same by definition — in all three the
- * merged copy would keep drawing walls the cutaway pass has since turned to
- * glass. Isolation is the other stand-down: it hides the level root the merged
- * mesh hangs off, which would leave a focused batched wall drawn by nobody.
+ * hold still. That is true in `up`; in `cutaway`, walls stamped `wallHidden`
+ * are released per wall in the same frame because WallCutout runs at priority
+ * 0 and this system at 5. `down` and `translucent` make every wall see-through.
+ * Isolation is the other stand-down: it hides the level root the merged mesh
+ * hangs off, which would leave a focused batched wall drawn by nobody.
  */
 export function canBatchWalls(wallMode, isolationActive) {
-    return !isolationActive && wallMode === 'up';
+    return !isolationActive && (wallMode === 'up' || wallMode === 'cutaway');
 }
 /**
- * Walls the cutaway pass is currently tinting — a selection or a delete hover.
+ * Walls the viewer is currently lighting up — a selection, or any hover.
+ *
+ * A selection or delete hover paints the wall by swapping the materials on its
+ * own mesh, which the merged mesh does not follow. Every other hover draws an
+ * outline instead, and that needs the same thing for a different reason: the
+ * outline node renders `outliner.hoveredObjects` through the main camera, which
+ * enables no batched layer, so a sewn wall reaches neither mask pass and
+ * hovering it lights up nothing at all — in select mode, and in paint mode
+ * where the outline is the only signal for which surface the next click lands
+ * on.
  *
- * It paints them by swapping the materials on the wall's own mesh, which the
- * merged mesh does not follow, so a lit wall goes back to drawing itself. There
- * are only ever a handful, and a handful of extra draw calls is what the tint
- * costs.
+ * Both wants are the same one: a lit wall goes back to drawing its own
+ * geometry. Only ever a handful are lit at once, and a handful of extra draw
+ * calls is what lighting them costs.
  */
-function collectTintedWalls(wallIds) {
+export function collectTintedWalls(wallIds) {
     const viewer = useViewer.getState();
     const tinted = new Set();
     for (const id of viewer.selection.selectedIds)
@@ -140,7 +161,7 @@ function collectTintedWalls(wallIds) {
     for (const id of viewer.previewSelectedIds)
         if (wallIds.has(id))
             tinted.add(id);
-    const hovered = viewer.hoverHighlightMode === 'delete' ? viewer.hoveredId : null;
+    const hovered = viewer.hoveredId;
     if (hovered && wallIds.has(hovered))
         tinted.add(hovered);
     return tinted;
@@ -223,6 +244,7 @@ function mergeLevel(levelId, excludedNodeIds = EMPTY_IDS) {
             continue;
         const mesh = new Mesh(batch.geometry, candidates[0].materials);
         mesh.name = 'wall-batch';
+        mesh.userData.pascalExport = 'strip';
         mesh.castShadow = true;
         mesh.receiveShadow = true;
         mesh.matrixAutoUpdate = false;
@@ -248,6 +270,49 @@ export const WallBatchSystem = () => {
     const invalidate = useThree((state) => state.invalidate);
     const wakeRef = useRef(null);
     useFrame(() => runBatchFrame(invalidate, wakeRef), 5);
+    // Captures and exports clone the scene and prune whatever is off the scene
+    // layer, so the sources come back for the capture and go under again after
+    // it. The node batch used to reveal them as a side effect of its own sweep
+    // (shared hold reason) and nothing ever re-hid them: every batched wall
+    // drew twice for the rest of the session.
+    useEffect(() => {
+        emitter.on('thumbnail:before-capture', revealBatchedWallsForCapture);
+        emitter.on('thumbnail:after-capture', holdBatchedWallsAfterCapture);
+        return () => {
+            emitter.off('thumbnail:before-capture', revealBatchedWallsForCapture);
+            emitter.off('thumbnail:after-capture', holdBatchedWallsAfterCapture);
+        };
+    }, []);
+    // Scripted-probe hook, ?perf sessions only (mirrors __itemBatch): the
+    // panel has no row for the merged wall batch, so probes read it here.
+    useEffect(() => {
+        if (!new URLSearchParams(window.location.search).has('perf'))
+            return;
+        const probe = {
+            stats: () => {
+                let batches = 0;
+                for (const records of batchesByLevel.values())
+                    batches += records.length;
+                let hidden = 0;
+                for (const nodeId of sceneRegistry.byType.wall ?? EMPTY_IDS) {
+                    if (sceneRegistry.nodes.get(nodeId)?.userData.wallHidden === true)
+                        hidden++;
+                }
+                return {
+                    walls: batchByNode.size,
+                    batches,
+                    levels: batchesByLevel.size,
+                    hidden,
+                    suspended: batchingSuspended,
+                    wallMode: useViewer.getState().wallMode,
+                };
+            },
+        };
+        window.__wallBatch = probe;
+        return () => {
+            delete window.__wallBatch;
+        };
+    }, []);
     useEffect(() => () => {
         if (wakeRef.current)
             clearTimeout(wakeRef.current);
@@ -255,6 +320,7 @@ export const WallBatchSystem = () => {
             disposeLevelBatches(levelId);
         changedWalls.clear();
         staleLevels.clear();
+        lastCutawayHiddenWalls = EMPTY_IDS;
         knownWallCount = -1;
         batchingSuspended = false;
         lastAppearance.shading = undefined;
@@ -276,7 +342,7 @@ export const WallBatchSystem = () => {
  * "did this wall move" on its own, and the per-frame cost is the size of the
  * dirty set rather than the size of the floor.
  */
-function runBatchFrame(invalidate, wakeRef) {
+export function runBatchFrame(invalidate, wakeRef) {
     const wallIds = sceneRegistry.byType.wall ?? EMPTY_IDS;
     const nodes = useScene.getState().nodes;
     // Walls the wall system rebuilt: it clears each mark as it goes, so by the
@@ -313,6 +379,39 @@ function runBatchFrame(invalidate, wakeRef) {
         releaseWall(nodeId);
         changed = true;
     }
+    // Only cutaway hides walls one by one; `up` hides none and the other modes
+    // stand the batch down, so the stamp scan is worth a frame only there.
+    const cutawayHiddenWalls = new Set();
+    if (useViewer.getState().wallMode === 'cutaway') {
+        for (const nodeId of wallIds) {
+            const mesh = sceneRegistry.nodes.get(nodeId);
+            if (mesh?.userData.wallHidden === true)
+                cutawayHiddenWalls.add(nodeId);
+        }
+    }
+    for (const nodeId of cutawayHiddenWalls) {
+        const record = batchByNode.get(nodeId);
+        if (!record)
+            continue;
+        releaseWall(nodeId);
+        staleLevels.add(record.levelId);
+        changed = true;
+    }
+    // A stamp that lifts hands the wall back to its own draw call, and nothing
+    // else marks the level — so the flip itself has to, or the wall would stay
+    // out of the merged mesh until an unrelated edit re-sews the floor.
+    for (const nodeId of lastCutawayHiddenWalls) {
+        if (cutawayHiddenWalls.has(nodeId))
+            continue;
+        const node = nodes[nodeId];
+        if (node?.type === 'wall' && node.parentId)
+            staleLevels.add(node.parentId);
+        changed = true;
+    }
+    lastCutawayHiddenWalls = cutawayHiddenWalls;
+    const excludedNodeIds = new Set(cutawayHiddenWalls);
+    for (const nodeId of tintedWalls)
+        excludedNodeIds.add(nodeId);
     // A theme, texture or material-library switch re-makes every wall's
     // materials without marking a single node, so the merged copies have to be
     // sewn again from the new ones. See `appearanceChanged`.
@@ -336,13 +435,11 @@ function runBatchFrame(invalidate, wakeRef) {
             changed = true;
         }
     }
-    // Two things make merging unsound, and both are handled the same way: the
-    // batch stands down for as long as they hold, and sews the floors back
-    // together once they lift. Isolation hides everything outside the focused
-    // subtree, and a level's merged mesh hangs off the level root — so it goes
-    // dark with everything else, leaving a focused batched wall drawn by nobody.
-    // Every wall mode but `up` re-assigns wall materials the merged mesh does not
-    // follow. See `canBatchWalls`.
+    // Isolation, `down` and `translucent` make batching unsound, so the batch
+    // stands down while they hold and sews the floors back together once they
+    // lift. `cutaway` stays live because WallCutout stamps hidden walls at
+    // priority 0 and this system releases them per wall at priority 5 in the
+    // same frame. See `canBatchWalls`.
     const suspended = !canBatchWalls(useViewer.getState().wallMode, isIsolationActive());
     if (suspended !== batchingSuspended) {
         batchingSuspended = suspended;
@@ -381,8 +478,8 @@ function runBatchFrame(invalidate, wakeRef) {
         return;
     }
     for (const levelId of staleLevels) {
-        if (unbatchedWallCount(levelId, tintedWalls) >= MIN_BATCH_WALLS) {
-            mergeLevel(levelId, tintedWalls);
+        if (unbatchedWallCount(levelId, excludedNodeIds) >= MIN_BATCH_WALLS) {
+            mergeLevel(levelId, excludedNodeIds);
         }
     }
     staleLevels.clear();

package/dist/wall/wall-batch.js

@@ -161,9 +161,9 @@ export function applyWallBatchGroups(batch, hidden) {
  * its subtree keeps rendering and picking.
  */
 export function hideBatchedWall(mesh) {
-    hideFromScene(mesh, 'batched');
+    hideFromScene(mesh, 'wall-batched');
 }
 /** Hands a wall back its own draw call — unless solo or isolation still hide it. */
 export function revealBatchedWall(mesh) {
-    showInScene(mesh, 'batched');
+    showInScene(mesh, 'wall-batched');
 }

package/dist/window/definition.d.ts

@@ -1,5 +1,6 @@
-import type { NodeDefinition } from '@pascal-app/core';
+import type { AnyNodeId, NodeDefinition, SceneApi, WindowNode as WindowNodeType } from '@pascal-app/core';
 import { WindowNode } from './schema';
+export declare function resolveWindowHandlePortalTarget(window: WindowNodeType, scene: Pick<SceneApi, 'get'>): AnyNodeId | null;
 /**
  * Window — Phase 5 batch kind. Mirrors door's shape: hosted on walls,
  * cuts holes in them, animated open/close state for opening windows.

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,EAGV,cAAc,EAIf,MAAM,kBAAkB,CAAA;AAiBzB,OAAO,EAAE,UAAU,EAAE,MAAM,UAAU,CAAA;AAkIrC;;;;;;;;;;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;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"}

package/dist/window/definition.js

@@ -1,3 +1,4 @@
+import { getDormerWallHorizontalBoundsAtHeight, getDormerWallOpeningVerticalBounds, } from '@pascal-app/core';
 import { buildWindowFloorplanSchedule, computeWindowFloorplanLevelData, } from '../shared/opening-documentation';
 import { publishOpeningResizeGuides } from '../shared/opening-guides-runtime';
 import { readRoofFaceHeightMax, readRoofFaceWidthMax } from '../shared/roof-opening-host';
@@ -16,9 +17,19 @@ const SIDE_HANDLE_OFFSET = 0.24;
 const HEIGHT_HANDLE_OFFSET = 0.24;
 const MIN_WINDOW_HEIGHT = 0.3;
 const MIN_WINDOW_WIDTH = 0.3;
-// How far the move cross floats off the wall face (+Z, the window's facing
-// normal) so it's grabbable instead of buried in the sash/frame.
-const MOVE_HANDLE_LIFT = 0.12;
+export function resolveWindowHandlePortalTarget(window, scene) {
+    const parentId = window.parentId;
+    if (!parentId)
+        return null;
+    const grandparentId = scene.get(parentId)
+        ?.parentId;
+    if (!grandparentId)
+        return null;
+    if (window.dormerId !== parentId)
+        return grandparentId;
+    return (scene.get(grandparentId)?.parentId ??
+        grandparentId);
+}
 function readWallLength(w, scene) {
     if (!w.wallId)
         return Number.POSITIVE_INFINITY;
@@ -27,6 +38,30 @@ function readWallLength(w, scene) {
         return Number.POSITIVE_INFINITY;
     return Math.hypot(wall.end[0] - wall.start[0], wall.end[1] - wall.start[1]);
 }
+function resolveDormerHost(window, scene) {
+    const dormerId = window.dormerId ?? window.parentId;
+    if (!dormerId)
+        return null;
+    const dormer = scene.get(dormerId);
+    return dormer?.type === 'dormer' ? dormer : null;
+}
+function readDormerFaceWidthMax(window, scene, localGrowSign) {
+    const dormer = resolveDormerHost(window, scene);
+    if (!dormer)
+        return null;
+    const bounds = getDormerWallHorizontalBoundsAtHeight(dormer, window.dormerFace ?? 'front', window.position[1] + window.height / 2);
+    const faceGrowSign = Math.cos(window.rotation[1]) >= 0 ? localGrowSign : -localGrowSign;
+    const anchorX = window.position[0] - (faceGrowSign * window.width) / 2;
+    return faceGrowSign > 0 ? bounds.max - anchorX : anchorX - bounds.min;
+}
+function readDormerFaceHeightMax(window, scene, growSign) {
+    const dormer = resolveDormerHost(window, scene);
+    if (!dormer)
+        return null;
+    const bounds = getDormerWallOpeningVerticalBounds(dormer, window.dormerFace ?? 'front', window.position[0], window.width);
+    const anchorY = window.position[1] - (growSign * window.height) / 2;
+    return growSign > 0 ? bounds.max - anchorY : anchorY - bounds.min;
+}
 function windowWidthHandle(side) {
     const sign = side === 'right' ? 1 : -1;
     return {
@@ -36,8 +71,12 @@ function windowWidthHandle(side) {
         // front instead of edge-on (the window sits on a vertical wall).
         faceNormal: true,
         anchor: side === 'right' ? 'min' : 'max',
+        gridSnap: true,
         min: MIN_WINDOW_WIDTH,
         max: (n, scene) => {
+            const dormerMax = readDormerFaceWidthMax(n, scene, sign);
+            if (dormerMax !== null)
+                return Math.max(MIN_WINDOW_WIDTH, dormerMax);
             // Roof-hosted windows clamp against the face profile (the
             // wall-based limits read Infinity when wallId is unset).
             const roofMax = readRoofFaceWidthMax(n, scene, sign);
@@ -67,6 +106,7 @@ function windowWidthHandle(side) {
             rotationY: () => (side === 'right' ? 0 : Math.PI),
         },
         portal: 'grandparent',
+        portalTarget: resolveWindowHandlePortalTarget,
     };
 }
 // Window height has two arrows (top + bottom edge) — each anchors at the
@@ -79,8 +119,12 @@ function windowHeightHandle(edge) {
         axis: 'y',
         // top arrow anchors at -Y (bottom stays fixed); bottom at +Y (top stays).
         anchor: edge === 'top' ? 'min' : 'max',
+        gridSnap: true,
         min: MIN_WINDOW_HEIGHT,
         max: (n, scene) => {
+            const dormerMax = readDormerFaceHeightMax(n, scene, sign);
+            if (dormerMax !== null)
+                return Math.max(MIN_WINDOW_HEIGHT, dormerMax);
             const roofMax = readRoofFaceHeightMax(n, scene, sign);
             if (roofMax !== null)
                 return Math.max(MIN_WINDOW_HEIGHT, roofMax);
@@ -110,27 +154,10 @@ function windowHeightHandle(edge) {
             position: (n) => [0, sign * (n.height / 2 + HEIGHT_HANDLE_OFFSET), 0],
         },
         portal: 'grandparent',
-    };
-}
-// Press-drag move grip at the window centre, standing in the wall face. Routes
-// through the same move tool as the floating Move button (3D
-// `affordanceTools.move`, 2D `floorplanMoveTarget`) — slide within the wall
-// plane + re-host onto another wall — committing on release, no second click.
-function windowMoveHandle() {
-    return {
-        kind: 'tap-action',
-        shape: 'move-cross',
-        plane: 'node-normal',
-        portal: 'grandparent',
-        cursor: 'move',
-        onActivate: (node, _scene, editor) => editor.engageMoveDrag(node),
-        placement: {
-            position: () => [0, 0, MOVE_HANDLE_LIFT],
-        },
+        portalTarget: resolveWindowHandlePortalTarget,
     };
 }
 const windowHandles = [
-    windowMoveHandle(),
     windowWidthHandle('left'),
     windowWidthHandle('right'),
     windowHeightHandle('top'),
@@ -151,7 +178,7 @@ export const windowDefinition = {
     kind: 'window',
     snapProfile: 'item',
     facingIndicator: true,
-    schemaVersion: 2,
+    schemaVersion: 3,
     schema: WindowNode,
     category: 'structure',
     extensions: {
@@ -180,9 +207,9 @@ export const windowDefinition = {
             cutScope: 'wall',
             dirtyHandledByOwnSystem: true,
         },
-        // `wallId` / `roofSegmentId` are re-derived from the surface under
+        // `wallId` / `roofSegmentId` / `dormerId` are re-derived from the surface under
         // the cursor at preset placement time — see door for the pattern.
-        hostRefFields: ['wallId', 'roofSegmentId', 'roofFace'],
+        hostRefFields: ['wallId', 'roofSegmentId', 'roofFace', 'dormerId', 'dormerFace'],
         // Frame / glass slots painted through the registry. The window system tags
         // each mesh with its `userData.slotId`; paint writes `node.slots`.
         slots: () => windowSlots(),

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,CAiPrE,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;AAmBzB;;;;;;;;;;GAUG;AAEH,eAAO,MAAM,yBAAyB,EAAE,mBAAmB,CAAC,UAAU,CAkPrE,CAAA"}

package/dist/window/floorplan-move.js

@@ -198,7 +198,7 @@ export const windowFloorplanMoveTarget = ({ node }) => {
                 return false;
             // Block on overlap UNLESS Alt force-places — same `placeable` rule as
             // the 3D move + the shared `resolveOpeningPlacement`.
-            const collides = hasWallChildOverlap(lastValid.parentId, lastValid.position[0], lastValid.position[1], live.width, live.height, live.id);
+            const collides = hasWallChildOverlap(lastValid.parentId, useScene.getState().nodes, lastValid.position[0], lastValid.position[1], live.width, live.height, live.id);
             return resolveOpeningPlacement({ collides, forcePlace }).placeable;
         },
         commit() {