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

package/dist/wall/pointer-transparency.js

@@ -0,0 +1,147 @@
+/**
+ * Should a wall's pointer handlers swallow (early-return) this event?
+ *
+ * Hidden walls ('down' wall mode, cutaway-hidden faces, auto-mode interior
+ * partitions) keep invisible full-height collision meshes that raycast for
+ * every pointer event. #683 made them blanket pointer-TRANSPARENT so clicks
+ * reached the visible objects behind them (wall-mounted plugin device /
+ * service boxes, items). That over-corrected hover + selection: with the
+ * Bones X-ray on (walls hidden, framing rendering where the walls are),
+ * mousing over a wall highlighted and selected the furniture BEHIND it,
+ * because nothing at the wall's depth was allowed to win.
+ *
+ * The rule is NEAREST-FIRST over hits that OWN SELECTION SEMANTICS. The
+ * live event raycast recurses through the level/building wrapper groups
+ * (they carry pointer handlers), so `event.intersections` also contains
+ * passive geometry — Bones framing InstancedMeshes sit exactly at the
+ * wall's own depth (QA f2 probe6/probe7), and the wall's own render mesh
+ * rides the same list. Rank by distance alone and the hidden wall yields
+ * everywhere its overlay (or its own body) renders — i.e. always. So every
+ * hit is first classified by its nearest REGISTERED node ancestor
+ * (`selection-hit-owner.ts`):
+ *
+ * - 'self-wall' hits (own render/collision/treatment meshes) are neutral;
+ * - 'other-wall' hits never compete directly (two hidden walls must not
+ *   both yield and drop the event into the room behind — delivery order
+ *   gives the nearest one the event) but ANCHOR the wall-mounted test;
+ * - 'passive' hits (framing members, gizmos, the grid — no selectable-node
+ *   ancestry, or a level/building wrapper as their nearest handler owner)
+ *   never outrank the wall;
+ * - 'selectable' hits (furniture, devices, openings, slabs …) outrank the
+ *   hidden wall when any of these hold:
+ *     1. HOSTED by this wall (its own doors / windows / wall-mounted
+ *        children — subtree membership, so grazing angles can't inflate
+ *        the depth gap past any epsilon);
+ *     2. at ~equal-or-nearer depth (`HIDDEN_WALL_SELECTION_EPSILON`
+ *        tie-break: device boxes flush with / proud of / recessed into the
+ *        face, items standing in front of the wall);
+ *     3. WALL-MOUNTED further down the ray — within epsilon of some other
+ *        wall's hit (the #683 / night-5 D4 class: a visible receptacle on
+ *        a wall two meters BEHIND an interposed hidden wall still wins —
+ *        the interposed wall falls through, like the #694 MOVE gate).
+ *
+ * Free-standing selectables clearly behind the wall (a sofa mid-room) no
+ * longer outrank it: the wall in front highlights, which is what the ray
+ * visually strikes when the Bones framing renders there. Trade-off
+ * (deliberate, host-side only — no plugin presence flag): in a plain manual
+ * 'down' mode with NO overlay rendering at the wall, that wall strip is
+ * hover/selectable even though it draws nothing.
+ *
+ * Two pre-existing exceptions keep ALL events flowing unconditionally:
+ *
+ * - DELETE hover mode: hidden walls must stay hover-targetable for the
+ *   deleteInvisible highlight flow.
+ * - A live hidden-wall pointer HOLD (`holdHiddenWallPointerEvents`, core):
+ *   the door / window move + place tools drive their cursor entirely from
+ *   `wall:enter` / `wall:move` / `wall:click`, so while one is active the
+ *   hidden wall must keep raycasting or the opening detaches into the floor
+ *   free-follow (red world-axis ghost) instead of sliding along its wall.
+ *   (#694's own-wall MOVE gate then filters those events downstream —
+ *   this predicate never runs for held events, so the two compose.)
+ *
+ * Visible walls never suppress. Pure so the truth table is testable without
+ * an R3F rig; the renderer supplies live values per event.
+ */
+/**
+ * Depth tie-break for "at the wall face": in-wall boxes sit flush-to-
+ * recessed within a wall thickness (0.09–0.3 m); openings sit inside the
+ * slab. Along-ray gaps inflate by 1/cos(incidence), so this carries typical
+ * face-mounted gear through moderate grazing angles without letting a sofa
+ * a metre behind the wall win.
+ */
+export const HIDDEN_WALL_SELECTION_EPSILON = 0.35;
+/** The wall renderer names its invisible pick mesh this (see renderer.tsx). */
+export const WALL_COLLISION_MESH_NAME = 'collision-mesh';
+/**
+ * Does any other hit on the ray outrank this hidden wall for hover /
+ * selection? True → the wall yields the event (pointer-transparent).
+ */
+export const hiddenWallOutrankedOnRay = (ray, epsilon = HIDDEN_WALL_SELECTION_EPSILON) => {
+    const wallAnchors = [];
+    for (const hit of ray.otherHits) {
+        if (hit.ownership === 'other-wall')
+            wallAnchors.push(hit.distance);
+    }
+    return ray.otherHits.some((hit) => {
+        if (hit.ownership !== 'selectable')
+            return false;
+        if (hit.hostedByThisWall)
+            return true;
+        if (hit.distance <= ray.wallHitDistance + epsilon)
+            return true;
+        return wallAnchors.some((anchor) => Math.abs(hit.distance - anchor) <= epsilon);
+    });
+};
+const isInSubtree = (object, root) => {
+    if (!root)
+        return false;
+    let current = object;
+    while (current) {
+        if (current === root)
+            return true;
+        current = current.parent;
+    }
+    return false;
+};
+/**
+ * Reduce a live R3F pointer event (Intersection & { intersections }) to the
+ * `WallSelectionRay` the yield rule consumes. `wallRoot` is the wall's
+ * registered outer mesh — its subtree hosts the collision mesh, treatments,
+ * and the hosted door / window / item renderers. `classify` resolves each
+ * hit's owner (`createWallRayHitClassifier(node.id)` in the renderer).
+ * Returns undefined when the event carries no usable ray data (synthetic
+ * replays); the caller then falls back to full transparency, #683's
+ * original behavior.
+ */
+export const extractWallSelectionRay = (event, wallRoot, classify) => {
+    const e = event;
+    if (typeof e?.distance !== 'number' || !e.object || !Array.isArray(e.intersections)) {
+        return undefined;
+    }
+    const self = e.object;
+    const otherHits = [];
+    for (const hit of e.intersections) {
+        if (!hit || typeof hit.distance !== 'number' || !hit.object)
+            continue;
+        if (hit.object === self)
+            continue;
+        const ownership = classify(hit.object);
+        otherHits.push({
+            distance: hit.distance,
+            ownership,
+            hostedByThisWall: ownership === 'selectable' && isInSubtree(hit.object, wallRoot),
+        });
+    }
+    return { wallHitDistance: e.distance, otherHits };
+};
+export const wallPointerEventsSuppressed = ({ wallHidden, hoverHighlightMode, hiddenWallHoldActive, selectionRay, }) => {
+    if (!wallHidden)
+        return false;
+    if (hoverHighlightMode === 'delete')
+        return false;
+    if (hiddenWallHoldActive)
+        return false;
+    if (!selectionRay)
+        return true;
+    return hiddenWallOutrankedOnRay(selectionRay);
+};

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

@@ -1 +1 @@
-{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/wall/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AASzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCAyFjD,CAAA;AAED,eAAe,YAAY,CAAA"}
+{"version":3,"file":"renderer.d.ts","sourceRoot":"","sources":["../../src/wall/renderer.tsx"],"names":[],"mappings":"AAEA,OAAO,EAOL,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAsCzB;;;;;;;;;;;;;;;;;;GAkBG;AACH,QAAA,MAAM,YAAY,GAAI,UAAU;IAAE,IAAI,EAAE,QAAQ,CAAA;CAAE,gCA4IjD,CAAA;AAED,eAAe,YAAY,CAAA"}

package/dist/wall/renderer.js

@@ -1,12 +1,20 @@
 'use client';
 import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
-import { useRegistry, useScene, } from '@pascal-app/core';
-import { getVisibleWallMaterials, NodeRenderer, useNodeEvents, useViewer } from '@pascal-app/viewer';
+import { hiddenWallPointerEventsHeld, useLiveNodeOverrides, useRegistry, useScene, } from '@pascal-app/core';
+import { getVisibleWallMaterials, NodeRenderer, useLibraryMaterialsVersion, useNodeEvents, useViewer, } from '@pascal-app/viewer';
 import { useEffect, useLayoutEffect, useMemo, useRef } from 'react';
 import { useShallow } from 'zustand/react/shallow';
 import { createPlaceholderGeometry } from '../shared/placeholder-geometry';
-import { useWallTreatmentLevelData } from './treatment-level-data';
-import { createWallExtraSlotMaterials, WallTreatments } from './treatments';
+import { extractWallSelectionRay, WALL_COLLISION_MESH_NAME, wallPointerEventsSuppressed, } from './pointer-transparency';
+import { createWallRayHitClassifier } from './selection-hit-owner';
+import { createWallTreatmentSelector, useWallTreatmentLevelData } from './treatment-level-data';
+import { createWallExtraSlotMaterials, hasWallTreatments, WallTreatments, wallTreatmentProudOffsets, } from './treatments';
+function WallTreatmentSubscription(props) {
+    const { node } = props;
+    const selector = useMemo(() => createWallTreatmentSelector(node, wallTreatmentProudOffsets(node)), [node]);
+    const levelData = useWallTreatmentLevelData(selector);
+    return levelData ? _jsx(WallTreatments, { ...props, levelData: levelData }) : null;
+}
 /**
  * Thin wall renderer.
  *
@@ -40,7 +48,50 @@ const WallRenderer = ({ node }) => {
             collisionPlaceholderGeometry.dispose();
         };
     }, [collisionPlaceholderGeometry, placeholderGeometry]);
-    const handlers = useNodeEvents(node, 'wall');
+    const rawHandlers = useNodeEvents(node, 'wall');
+    // Hidden walls participate in hover/selection NEAREST-FIRST: when the
+    // wall-mode pass hides this wall (`WallCutout` stamps `userData.wallHidden`
+    // — X-ray 'down' mode, cutaway-hidden faces, auto-mode interior
+    // partitions), its invisible full-height collision mesh handles the event
+    // only when no hit that OWNS selection semantics outranks it — its own
+    // hosted doors / windows / wall-mounted children, any selectable at
+    // ~equal-or-nearer depth (device boxes at the face), or wall-mounted gear
+    // on a wall behind it (the #683 D4 receptacle class) all win instead.
+    // Passive geometry (Bones framing members, the wall's own render mesh,
+    // gizmos — see `selection-hit-owner.ts`) never outranks it. Returning
+    // early without stopPropagation lets R3F continue to that next
+    // intersection. Free-standing objects clearly BEHIND the wall no longer
+    // steal the hover: the wall in front highlights (the Bones framing
+    // renders exactly there).
+    // Two exceptions keep ALL events (see `wallPointerEventsSuppressed`):
+    // delete mode (hidden walls stay hover-targetable for the deleteInvisible
+    // highlight flow) and a live hidden-wall pointer hold (a door / window
+    // move / place tool is tracking the cursor via wall events — without the
+    // wall the opening detaches into the floor free-follow).
+    const classifyRayHit = useMemo(() => createWallRayHitClassifier(node.id), [node.id]);
+    const handlers = useMemo(() => {
+        const gated = {};
+        for (const key of Object.keys(rawHandlers)) {
+            const fn = rawHandlers[key];
+            gated[key] = (e) => {
+                const wallHidden = ref.current?.userData?.wallHidden === true;
+                if (wallPointerEventsSuppressed({
+                    wallHidden,
+                    hoverHighlightMode: useViewer.getState().hoverHighlightMode,
+                    hiddenWallHoldActive: hiddenWallPointerEventsHeld(),
+                    // Reduced lazily: visible walls never suppress, so don't walk
+                    // the intersection list for every hover move over them.
+                    selectionRay: wallHidden
+                        ? extractWallSelectionRay(e, ref.current, classifyRayHit)
+                        : undefined,
+                })) {
+                    return;
+                }
+                fn(e);
+            };
+        }
+        return gated;
+    }, [classifyRayHit, rawHandlers]);
     const shading = useViewer((s) => s.shading);
     const textures = useViewer((s) => s.textures);
     const colorPreset = useViewer((s) => s.colorPreset);
@@ -48,20 +99,26 @@ const WallRenderer = ({ node }) => {
     const childNodes = useScene(useShallow((state) => (node.children ?? [])
         .map((childId) => state.nodes[childId])
         .filter((child) => child !== undefined)));
-    const treatmentLevelData = useWallTreatmentLevelData((state) => node.parentId ? state.byLevelId.get(node.parentId) : undefined);
+    const treatmentOverride = useLiveNodeOverrides((state) => state.overrides.get(node.id));
+    const treatmentNode = useMemo(() => (treatmentOverride ? { ...node, ...treatmentOverride } : node), [node, treatmentOverride]);
     // Subscribe to the scene-material palette so editing a `scene:` material a
     // wall slot references re-renders the wall live (the wall-system geometry
     // dirty loop never fires for a material-only edit). `getMaterialsForWall`'s
     // content hash keeps unaffected walls on their cached materials.
     const sceneMaterials = useScene((s) => s.materials);
+    // Same for the dynamic library: AI-generated `library:mtl_*` presets
+    // register after mount, and a dangling ref cached as the slot default must
+    // re-resolve when they land.
+    const libraryMaterialsVersion = useLibraryMaterialsVersion();
     const baseMaterials = getVisibleWallMaterials(node, shading, textures, colorPreset, sceneTheme, sceneMaterials);
-    const extraMaterials = useMemo(() => createWallExtraSlotMaterials(node, shading, sceneMaterials), [node, sceneMaterials, shading]);
+    // biome-ignore lint/correctness/useExhaustiveDependencies: libraryMaterialsVersion invalidates the ref resolution inside createWallExtraSlotMaterials
+    const extraMaterials = useMemo(() => createWallExtraSlotMaterials(node, shading, sceneMaterials), [node, sceneMaterials, shading, libraryMaterialsVersion]);
     useEffect(() => () => {
         const baseSet = new Set(baseMaterials);
         const owned = new Set(Object.values(extraMaterials).filter((entry) => !baseSet.has(entry)));
         for (const entry of owned)
             entry.dispose();
     }, [baseMaterials, extraMaterials]);
-    return (_jsxs("mesh", { castShadow: true, geometry: placeholderGeometry, material: baseMaterials, receiveShadow: true, ref: ref, visible: node.visible, children: [_jsx("mesh", { geometry: collisionPlaceholderGeometry, name: "collision-mesh", visible: false, ...handlers }), treatmentLevelData && (_jsx(WallTreatments, { childrenNodes: childNodes, levelData: treatmentLevelData, materials: extraMaterials, node: node })), (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, `${node.id}:${childId}`)))] }));
+    return (_jsxs("mesh", { castShadow: true, geometry: placeholderGeometry, material: baseMaterials, receiveShadow: true, ref: ref, visible: node.visible, children: [_jsx("mesh", { geometry: collisionPlaceholderGeometry, name: WALL_COLLISION_MESH_NAME, visible: false, ...handlers }), hasWallTreatments(treatmentNode) && (_jsx(WallTreatmentSubscription, { childrenNodes: childNodes, materials: extraMaterials, node: treatmentNode })), (node.children ?? []).map((childId) => (_jsx(NodeRenderer, { nodeId: childId }, `${node.id}:${childId}`)))] }));
 };
 export default WallRenderer;

package/dist/wall/selection-hit-owner.d.ts

@@ -0,0 +1,53 @@
+/**
+ * Who "owns" a raycast hit, for the hidden-wall nearest-first selection rule
+ * (`pointer-transparency.ts`)?
+ *
+ * The live R3F event raycast recurses through the level/building wrapper
+ * groups (they carry pointer handlers), so `event.intersections` contains
+ * every mesh under them — including PASSIVE geometry that owns no selection
+ * semantics: plugin overlay members (the Bones framing InstancedMeshes sit
+ * exactly at the wall's depth), helper meshes, the grid. Distance alone
+ * cannot rank those against a hidden wall; ownership can:
+ *
+ * - 'self-wall'   — the hit resolves to THIS wall (its own collision mesh,
+ *                   render mesh, treatments). Neutral: a wall cannot outrank
+ *                   itself, and must not yield to itself either.
+ * - 'other-wall'  — the hit resolves to a different wall. Never a direct
+ *                   competitor (two hidden walls must not both yield and
+ *                   drop the event into the room behind — delivery order
+ *                   already gives the nearest one the event), but an ANCHOR
+ *                   for the wall-mounted test.
+ * - 'selectable'  — the hit resolves to a node the editor can select
+ *                   (furniture, devices, openings, slabs …). These are the
+ *                   real competitors.
+ * - 'passive'     — no selectable-node ancestry (framing members, gizmos,
+ *                   the grid, unregistered helpers). Never outranks a wall.
+ *
+ * Ownership = the hit object's NEAREST ancestor registered in
+ * `sceneRegistry` (every node's renderer registers its root). A hosted
+ * door's meshes resolve to the door (registered deeper than its host wall),
+ * a wall's own trim resolves to the wall, a framing member resolves to the
+ * plugin's overlay node (registered, but not selectable → passive).
+ */
+export type WallRayHitOwnership = 'self-wall' | 'other-wall' | 'selectable' | 'passive';
+/** Injectable seams so the classifier is testable without the live editor. */
+export type HitOwnerDeps = {
+    /** Bumped whenever a node (un)registers — invalidates the reverse map. */
+    registryRevision: () => number;
+    /** All registered (nodeId, root Object3D) pairs. */
+    registeredEntries: () => Iterable<[string, object]>;
+    /** The node kind for a registered id (undefined once the node is gone). */
+    kindOf: (id: string) => string | undefined;
+    /** Plugin kinds that declare `capabilities.selectable`. */
+    isRegistrySelectableKind: (kind: string) => boolean;
+};
+type ObjectLike = {
+    parent?: ObjectLike | null;
+};
+/**
+ * Build a classifier for one wall's pointer gate. `selfWallId` is that
+ * wall's node id; hits resolving to it are 'self-wall'.
+ */
+export declare const createWallRayHitClassifier: (selfWallId: string, deps?: HitOwnerDeps) => ((object: ObjectLike) => WallRayHitOwnership);
+export {};
+//# sourceMappingURL=selection-hit-owner.d.ts.map

package/dist/wall/selection-hit-owner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-hit-owner.d.ts","sourceRoot":"","sources":["../../src/wall/selection-hit-owner.ts"],"names":[],"mappings":"AAEA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA8BG;AACH,MAAM,MAAM,mBAAmB,GAAG,WAAW,GAAG,YAAY,GAAG,YAAY,GAAG,SAAS,CAAA;AA2BvF,8EAA8E;AAC9E,MAAM,MAAM,YAAY,GAAG;IACzB,0EAA0E;IAC1E,gBAAgB,EAAE,MAAM,MAAM,CAAA;IAC9B,oDAAoD;IACpD,iBAAiB,EAAE,MAAM,QAAQ,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IACnD,2EAA2E;IAC3E,MAAM,EAAE,CAAC,EAAE,EAAE,MAAM,KAAK,MAAM,GAAG,SAAS,CAAA;IAC1C,2DAA2D;IAC3D,wBAAwB,EAAE,CAAC,IAAI,EAAE,MAAM,KAAK,OAAO,CAAA;CACpD,CAAA;AAWD,KAAK,UAAU,GAAG;IAAE,MAAM,CAAC,EAAE,UAAU,GAAG,IAAI,CAAA;CAAE,CAAA;AA8BhD;;;GAGG;AACH,eAAO,MAAM,0BAA0B,GACrC,YAAY,MAAM,EAClB,OAAM,YAAuB,KAC5B,CAAC,CAAC,MAAM,EAAE,UAAU,KAAK,mBAAmB,CAW9C,CAAA"}

package/dist/wall/selection-hit-owner.js

@@ -0,0 +1,79 @@
+import { isRegistrySelectable, sceneRegistry, useScene } from '@pascal-app/core';
+/**
+ * Built-in kinds with selection semantics in the editor (mirrors
+ * SelectionManager's structure/furnish lists until Phase 4 makes
+ * `capabilities.selectable` the single source of truth). Wrapper kinds
+ * (level/building/site) and the zone volume are deliberately absent: a hit
+ * whose nearest owner is a wrapper is passive scenery, and zone volumes
+ * share the wall's own planes.
+ */
+const BUILTIN_SELECTABLE_COMPETITOR_KINDS = new Set([
+    'fence',
+    'item',
+    'column',
+    'elevator',
+    'slab',
+    'ceiling',
+    'roof',
+    'roof-segment',
+    'stair',
+    'stair-segment',
+    'spawn',
+    'window',
+    'door',
+    'shelf',
+]);
+const liveDeps = {
+    registryRevision: () => sceneRegistry.revision,
+    registeredEntries: () => sceneRegistry.nodes.entries(),
+    // The store index is keyed by AnyNodeId; keep the loose read in one place.
+    kindOf: (id) => useScene.getState().nodes[id]?.type,
+    isRegistrySelectableKind: isRegistrySelectable,
+};
+/**
+ * Reverse lookup (Object3D → registered node id), rebuilt lazily when the
+ * scene registry's revision moves. One map per classifier factory; the
+ * default factory below shares a single module-level instance.
+ */
+const createRegisteredObjectLookup = (deps) => {
+    let revision = -1;
+    let reverse = new Map();
+    return (object) => {
+        const currentRevision = deps.registryRevision();
+        if (currentRevision !== revision) {
+            revision = currentRevision;
+            reverse = new Map();
+            for (const [id, root] of deps.registeredEntries())
+                reverse.set(root, id);
+        }
+        let current = object;
+        while (current) {
+            const id = reverse.get(current);
+            if (id !== undefined)
+                return id;
+            current = current.parent;
+        }
+        return null;
+    };
+};
+const isSelectableCompetitorKind = (kind, deps) => BUILTIN_SELECTABLE_COMPETITOR_KINDS.has(kind) || deps.isRegistrySelectableKind(kind);
+/**
+ * Build a classifier for one wall's pointer gate. `selfWallId` is that
+ * wall's node id; hits resolving to it are 'self-wall'.
+ */
+export const createWallRayHitClassifier = (selfWallId, deps = liveDeps) => {
+    const nearestRegisteredId = createRegisteredObjectLookup(deps);
+    return (object) => {
+        const ownerId = nearestRegisteredId(object);
+        if (ownerId === null)
+            return 'passive';
+        if (ownerId === selfWallId)
+            return 'self-wall';
+        const kind = deps.kindOf(ownerId);
+        if (kind === undefined)
+            return 'passive';
+        if (kind === 'wall')
+            return 'other-wall';
+        return isSelectableCompetitorKind(kind, deps) ? 'selectable' : 'passive';
+    };
+};

package/dist/wall/system.d.ts

@@ -1,3 +1,5 @@
+export declare function resetWallTreatmentLevels(): void;
+export declare function updateWallTreatmentLevels(): void;
 /**
  * Registry-driven wall system bundle.
  *

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AA0CA;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,WAAW,mCAShB,CAAA;AAED,eAAe,WAAW,CAAA"}
+{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AAkCA,wBAAgB,wBAAwB,IAAI,IAAI,CAO/C;AAED,wBAAgB,yBAAyB,IAAI,IAAI,CAyChD;AASD;;;;;;;;;;;;;GAaG;AACH,QAAA,MAAM,WAAW,mCAShB,CAAA;AAED,eAAe,WAAW,CAAA"}

package/dist/wall/system.js

@@ -1,40 +1,81 @@
 'use client';
 import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
 import { useLiveNodeOverrides, useScene } from '@pascal-app/core';
-import { WallCutout, WallSystem } from '@pascal-app/viewer';
+import { timeSpan, WallCutout, WallSystem } from '@pascal-app/viewer';
 import { useFrame } from '@react-three/fiber';
-import { buildWallTreatmentLevelData, useWallTreatmentLevelData } from './treatment-level-data';
+import { useEffect } from 'react';
+import { buildWallTreatmentLevelData, clearWallTreatmentMiterCache, sameTreatmentWalls, treatmentProudKeys, useWallTreatmentLevelData, } from './treatment-level-data';
 import { wallTreatmentProudOffsets } from './treatments';
 import { WallBatchSystem } from './wall-batch-system';
+const levelInputs = new Map();
+let effectiveWalls = new WeakMap();
+let previousNodes;
+let previousOverrides;
 function effectiveWall(wall) {
     const override = useLiveNodeOverrides.getState().get(wall.id);
-    return override ? { ...wall, ...override } : wall;
+    if (!override)
+        return wall;
+    const cached = effectiveWalls.get(wall);
+    if (cached?.override === override)
+        return cached.wall;
+    const effective = { ...wall, ...override };
+    effectiveWalls.set(wall, { override, wall: effective });
+    return effective;
 }
-const WallTreatmentMiterSystem = () => {
-    useFrame(() => {
-        const { dirtyNodes, nodes } = useScene.getState();
-        if (dirtyNodes.size === 0)
-            return;
-        const dirtyLevelIds = new Set();
-        for (const id of dirtyNodes) {
-            const node = nodes[id];
-            if (node?.type === 'wall' && node.parentId)
-                dirtyLevelIds.add(node.parentId);
+export function resetWallTreatmentLevels() {
+    levelInputs.clear();
+    effectiveWalls = new WeakMap();
+    previousNodes = undefined;
+    previousOverrides = undefined;
+    clearWallTreatmentMiterCache();
+    useWallTreatmentLevelData.setState({ byLevelId: new Map() });
+}
+export function updateWallTreatmentLevels() {
+    const { dirtyNodes, nodes } = useScene.getState();
+    const { overrides } = useLiveNodeOverrides.getState();
+    const dirtyLevelIds = new Set();
+    for (const id of dirtyNodes) {
+        const node = nodes[id];
+        if (node?.type === 'wall' && node.parentId)
+            dirtyLevelIds.add(node.parentId);
+        else if (node?.type === 'level')
+            dirtyLevelIds.add(node.id);
+    }
+    // Removed walls and cleared overrides can leave no dirty wall to identify their old level.
+    if (nodes !== previousNodes || overrides !== previousOverrides) {
+        for (const levelId of levelInputs.keys())
+            dirtyLevelIds.add(levelId);
+        previousNodes = nodes;
+        previousOverrides = overrides;
+    }
+    for (const levelId of dirtyLevelIds) {
+        const level = nodes[levelId];
+        if (level?.type !== 'level') {
+            levelInputs.delete(levelId);
+            clearWallTreatmentMiterCache(levelId);
+            useWallTreatmentLevelData.getState().removeLevelData(levelId);
+            continue;
         }
-        for (const levelId of dirtyLevelIds) {
-            const level = nodes[levelId];
-            if (level?.type !== 'level')
-                continue;
-            const walls = level.children
-                .map((id) => nodes[id])
-                .filter((node) => node?.type === 'wall')
-                .map(effectiveWall);
-            const proudOffsets = walls.flatMap(wallTreatmentProudOffsets);
+        const walls = level.children
+            .map((id) => nodes[id])
+            .filter((node) => node?.type === 'wall')
+            .map(effectiveWall);
+        const proudOffsets = walls.flatMap(wallTreatmentProudOffsets);
+        const proudKey = treatmentProudKeys(proudOffsets).join(',');
+        const previous = levelInputs.get(levelId);
+        if (previous?.proudKey === proudKey && sameTreatmentWalls(previous.walls, walls))
+            continue;
+        timeSpan('wall-treatment-level', () => {
             useWallTreatmentLevelData
                 .getState()
-                .setLevelData(levelId, buildWallTreatmentLevelData(walls, proudOffsets));
-        }
-    }, -1);
+                .setLevelData(levelId, buildWallTreatmentLevelData(levelId, walls, proudOffsets));
+            levelInputs.set(levelId, { walls, proudKey });
+        });
+    }
+}
+const WallTreatmentMiterSystem = () => {
+    useEffect(() => resetWallTreatmentLevels, []);
+    useFrame(updateWallTreatmentLevels, -1);
     return null;
 };
 /**

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

@@ -1 +1 @@
-{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AA6bA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAkf5B,CAAA;AAED,eAAe,QAAQ,CAAA"}
+{"version":3,"file":"tool.d.ts","sourceRoot":"","sources":["../../src/wall/tool.tsx"],"names":[],"mappings":"AA6bA,eAAO,MAAM,QAAQ,EAAE,KAAK,CAAC,EAuf5B,CAAA;AAED,eAAe,QAAQ,CAAA"}

package/dist/wall/tool.js

@@ -325,6 +325,7 @@ export const WallTool = () => {
     // snapping onto the chain's own segments never reads as a join.
     const chainWallIds = useRef([]);
     const constructionPlane = useRef(null);
+    const flatConstructionBase = useRef(false);
     const buildingState = useRef(0);
     const [draftMeasurement, setDraftMeasurement] = useState(null);
     const [axisGuide, setAxisGuide] = useState(null);
@@ -432,6 +433,7 @@ export const WallTool = () => {
         const stopDrafting = () => {
             buildingState.current = 0;
             constructionPlane.current = null;
+            flatConstructionBase.current = false;
             chainFirstVertex.current = null;
             chainWallIds.current = [];
             const draftPreview = useFloorplanDraftPreview.getState();
@@ -545,6 +547,7 @@ export const WallTool = () => {
                         : null) ?? resolveEventConstructionPlane(event, pointed);
                 const plane = resampleTerrainConstructionPlane(resolvedPlane, snappedStart);
                 constructionPlane.current = plane;
+                flatConstructionBase.current = pointed?.sourceNodeId != null;
                 publishHorizontalConstructionPlane(event, plane);
                 gridPosition = snappedStart;
                 startingPoint.current.set(snappedStart[0], plane.localY, snappedStart[1]);
@@ -591,6 +594,8 @@ export const WallTool = () => {
                     preferredSupportSlabId: draftPlane?.supportSlabId ?? null,
                     constructionElevation: draftPlane?.elevation ?? null,
                     constructionHeight: previewHeightRef.current,
+                    constructionSourceNodeId: constructionPlane.current?.sourceNodeId ?? null,
+                    flatConstructionBase: flatConstructionBase.current,
                 });
                 if (!createdWall)
                     return;

package/dist/wall/treatment-level-data.d.ts

@@ -1,14 +1,19 @@
 import { type WallMiterData, type WallNode } from '@pascal-app/core';
+export declare function treatmentProudKeys(proudOffsets: readonly number[]): number[];
+export declare function sameTreatmentWalls(a: readonly WallNode[], b: readonly WallNode[]): boolean;
 export type WallTreatmentLevelData = {
     walls: readonly WallNode[];
     miterDataByProud: ReadonlyMap<number, WallMiterData>;
 };
-export declare function buildWallTreatmentLevelData(walls: readonly WallNode[], proudOffsets: readonly number[]): WallTreatmentLevelData;
+export declare function clearWallTreatmentMiterCache(levelId?: string): void;
+export declare function buildWallTreatmentLevelData(levelId: string, walls: readonly WallNode[], proudOffsets: readonly number[]): WallTreatmentLevelData;
 export declare function treatmentMiterDataForProud(levelData: WallTreatmentLevelData, proud: number): WallMiterData | undefined;
 type WallTreatmentLevelDataState = {
     byLevelId: ReadonlyMap<string, WallTreatmentLevelData>;
     setLevelData: (levelId: string, data: WallTreatmentLevelData) => void;
+    removeLevelData: (levelId: string) => void;
 };
+export declare function createWallTreatmentSelector(node: WallNode, proudOffsets: readonly number[]): (state: WallTreatmentLevelDataState) => WallTreatmentLevelData | undefined;
 export declare const useWallTreatmentLevelData: import("zustand").UseBoundStore<import("zustand").StoreApi<WallTreatmentLevelDataState>>;
 export {};
 //# sourceMappingURL=treatment-level-data.d.ts.map

package/dist/wall/treatment-level-data.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"treatment-level-data.d.ts","sourceRoot":"","sources":["../../src/wall/treatment-level-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AASzB,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAA;IAC1B,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CACrD,CAAA;AAED,wBAAgB,2BAA2B,CACzC,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,YAAY,EAAE,SAAS,MAAM,EAAE,GAC9B,sBAAsB,CAgBxB;AAED,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,MAAM,GACZ,aAAa,GAAG,SAAS,CAE3B;AAED,KAAK,2BAA2B,GAAG;IACjC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;IACtD,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,sBAAsB,KAAK,IAAI,CAAA;CACtE,CAAA;AAED,eAAO,MAAM,yBAAyB,0FAQnC,CAAA"}
+{"version":3,"file":"treatment-level-data.d.ts","sourceRoot":"","sources":["../../src/wall/treatment-level-data.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAUzB,wBAAgB,kBAAkB,CAAC,YAAY,EAAE,SAAS,MAAM,EAAE,GAAG,MAAM,EAAE,CAE5E;AAED,wBAAgB,kBAAkB,CAAC,CAAC,EAAE,SAAS,QAAQ,EAAE,EAAE,CAAC,EAAE,SAAS,QAAQ,EAAE,GAAG,OAAO,CAE1F;AAED,MAAM,MAAM,sBAAsB,GAAG;IACnC,KAAK,EAAE,SAAS,QAAQ,EAAE,CAAA;IAC1B,gBAAgB,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,CAAA;CACrD,CAAA;AAID,wBAAgB,4BAA4B,CAAC,OAAO,CAAC,EAAE,MAAM,GAAG,IAAI,CAGnE;AAED,wBAAgB,2BAA2B,CACzC,OAAO,EAAE,MAAM,EACf,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,YAAY,EAAE,SAAS,MAAM,EAAE,GAC9B,sBAAsB,CAwBxB;AAED,wBAAgB,0BAA0B,CACxC,SAAS,EAAE,sBAAsB,EACjC,KAAK,EAAE,MAAM,GACZ,aAAa,GAAG,SAAS,CAE3B;AAED,KAAK,2BAA2B,GAAG;IACjC,SAAS,EAAE,WAAW,CAAC,MAAM,EAAE,sBAAsB,CAAC,CAAA;IACtD,YAAY,EAAE,CAAC,OAAO,EAAE,MAAM,EAAE,IAAI,EAAE,sBAAsB,KAAK,IAAI,CAAA;IACrE,eAAe,EAAE,CAAC,OAAO,EAAE,MAAM,KAAK,IAAI,CAAA;CAC3C,CAAA;AAED,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,QAAQ,EAAE,YAAY,EAAE,SAAS,MAAM,EAAE,IASjF,OAAO,2BAA2B,KAAG,sBAAsB,GAAG,SAAS,CAqChF;AAED,eAAO,MAAM,yBAAyB,0FAenC,CAAA"}