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

package/dist/wall/pointer-transparency.d.ts

@@ -0,0 +1,128 @@
+/**
+ * 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.
+ */
+import type { WallRayHitOwnership } from './selection-hit-owner';
+/**
+ * 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 declare const HIDDEN_WALL_SELECTION_EPSILON = 0.35;
+/** The wall renderer names its invisible pick mesh this (see renderer.tsx). */
+export declare const WALL_COLLISION_MESH_NAME = "collision-mesh";
+/** One raycast hit, reduced to what the yield rule needs. */
+export type WallRayHit = {
+    /** Distance along the ray, in meters (three.js Intersection.distance). */
+    distance: number;
+    /** Who owns the hit — see `selection-hit-owner.ts`. */
+    ownership: WallRayHitOwnership;
+    /** True when a 'selectable' hit lives inside THIS wall's rendered subtree. */
+    hostedByThisWall: boolean;
+};
+/** The pointer ray as seen from one hidden wall's collision-mesh hit. */
+export type WallSelectionRay = {
+    /** Distance of this wall's own collision-mesh hit. */
+    wallHitDistance: number;
+    /** Every other hit on the same ray (the delivered hit itself excluded). */
+    otherHits: ReadonlyArray<WallRayHit>;
+};
+/**
+ * Does any other hit on the ray outrank this hidden wall for hover /
+ * selection? True → the wall yields the event (pointer-transparent).
+ */
+export declare const hiddenWallOutrankedOnRay: (ray: WallSelectionRay, epsilon?: number) => boolean;
+/** Minimal structural shapes so extraction is testable without three.js. */
+export type WallRayObjectLike = {
+    name?: string;
+    parent?: WallRayObjectLike | null;
+};
+export type WallRayIntersectionLike = {
+    distance: number;
+    object: WallRayObjectLike;
+};
+/**
+ * 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 declare const extractWallSelectionRay: (event: unknown, wallRoot: object | null, classify: (object: WallRayObjectLike) => WallRayHitOwnership) => WallSelectionRay | undefined;
+export declare const wallPointerEventsSuppressed: ({ wallHidden, hoverHighlightMode, hiddenWallHoldActive, selectionRay, }: {
+    wallHidden: boolean;
+    hoverHighlightMode: string | null | undefined;
+    hiddenWallHoldActive: boolean;
+    /**
+     * The pointer ray context for hover/selection events. Omitted or
+     * undefined → the hidden wall stays fully transparent (#683 fallback for
+     * events without intersection data).
+     */
+    selectionRay?: WallSelectionRay;
+}) => boolean;
+//# sourceMappingURL=pointer-transparency.d.ts.map

package/dist/wall/pointer-transparency.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"pointer-transparency.d.ts","sourceRoot":"","sources":["../../src/wall/pointer-transparency.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+DG;AAEH,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAEhE;;;;;;GAMG;AACH,eAAO,MAAM,6BAA6B,OAAO,CAAA;AAEjD,+EAA+E;AAC/E,eAAO,MAAM,wBAAwB,mBAAmB,CAAA;AAExD,6DAA6D;AAC7D,MAAM,MAAM,UAAU,GAAG;IACvB,0EAA0E;IAC1E,QAAQ,EAAE,MAAM,CAAA;IAChB,uDAAuD;IACvD,SAAS,EAAE,mBAAmB,CAAA;IAC9B,8EAA8E;IAC9E,gBAAgB,EAAE,OAAO,CAAA;CAC1B,CAAA;AAED,yEAAyE;AACzE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,sDAAsD;IACtD,eAAe,EAAE,MAAM,CAAA;IACvB,2EAA2E;IAC3E,SAAS,EAAE,aAAa,CAAC,UAAU,CAAC,CAAA;CACrC,CAAA;AAED;;;GAGG;AACH,eAAO,MAAM,wBAAwB,GACnC,KAAK,gBAAgB,EACrB,UAAS,MAAsC,KAC9C,OAYF,CAAA;AAED,4EAA4E;AAC5E,MAAM,MAAM,iBAAiB,GAAG;IAC9B,IAAI,CAAC,EAAE,MAAM,CAAA;IACb,MAAM,CAAC,EAAE,iBAAiB,GAAG,IAAI,CAAA;CAClC,CAAA;AACD,MAAM,MAAM,uBAAuB,GAAG;IACpC,QAAQ,EAAE,MAAM,CAAA;IAChB,MAAM,EAAE,iBAAiB,CAAA;CAC1B,CAAA;AAYD;;;;;;;;;GASG;AACH,eAAO,MAAM,uBAAuB,GAClC,OAAO,OAAO,EACd,UAAU,MAAM,GAAG,IAAI,EACvB,UAAU,CAAC,MAAM,EAAE,iBAAiB,KAAK,mBAAmB,KAC3D,gBAAgB,GAAG,SAsBrB,CAAA;AAED,eAAO,MAAM,2BAA2B,GAAI,yEAKzC;IACD,UAAU,EAAE,OAAO,CAAA;IACnB,kBAAkB,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,CAAA;IAC7C,oBAAoB,EAAE,OAAO,CAAA;IAC7B;;;;OAIG;IACH,YAAY,CAAC,EAAE,gBAAgB,CAAA;CAChC,KAAG,OAMH,CAAA"}

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.
  *
@@ -8,6 +10,9 @@
  *    bulk of the wall runtime (~820 lines in viewer).
  *  - **`WallCutout`** — cutaway-mode hide/show logic based on camera
  *    direction and `frontSide` / `backSide` interior/exterior tags.
+ *  - **`WallBatchSystem`** — once a level stops changing, sews its opaque
+ *    walls into one mesh per material set so a floor costs a handful of
+ *    draw calls instead of one per wall face run.
  */
 declare const WallSystems: () => import("react").JSX.Element;
 export default WallSystems;

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

@@ -1 +1 @@
-{"version":3,"file":"system.d.ts","sourceRoot":"","sources":["../../src/wall/system.tsx"],"names":[],"mappings":"AAyCA;;;;;;;;;;GAUG;AACH,QAAA,MAAM,WAAW,mCAQhB,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"}