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

package/dist/wall/move-shared.js

@@ -61,9 +61,10 @@ export function getLinkedWallSnapshots(args) {
     }
     return snapshots;
 }
-function wallSegmentExists(walls, start, end) {
-    return walls.some((wall) => (samePoint(wall.start, start) && samePoint(wall.end, end)) ||
-        (samePoint(wall.start, end) && samePoint(wall.end, start)));
+function wallSegmentExists(walls, start, end, parentId) {
+    return walls.some((wall) => wall.parentId === parentId &&
+        ((samePoint(wall.start, start) && samePoint(wall.end, end)) ||
+            (samePoint(wall.start, end) && samePoint(wall.end, start))));
 }
 // Resolve a wall slot ref (`library:`/`scene:`) to a swatch colour, or
 // undefined when the ref is absent / dangling / colourless.
@@ -108,7 +109,7 @@ export function buildBridgeWallCreates(args) {
         if (!isSegmentLongEnough(plan.originalPoint, nextPoint)) {
             continue;
         }
-        if (wallSegmentExists(wallsForDuplicateCheck, plan.originalPoint, nextPoint)) {
+        if (wallSegmentExists(wallsForDuplicateCheck, plan.originalPoint, nextPoint, plan.wall.parentId)) {
             continue;
         }
         const { id: _id, parentId: _parentId, children: _children, ...sourceWall } = plan.wall;
@@ -124,20 +125,22 @@ export function buildBridgeWallCreates(args) {
             node: bridgeWall,
             parentId: (plan.wall.parentId ?? undefined),
         });
-        wallsForDuplicateCheck.push(bridgeWall);
+        wallsForDuplicateCheck.push({ ...bridgeWall, parentId: plan.wall.parentId });
     }
     return creates;
 }
 export function buildBridgeWallPreviews(args) {
     const { bridgePlans, nextStart, nextEnd, existingWalls } = args;
-    const wallsForDuplicateCheck = [...existingWalls];
+    const wallsForDuplicateCheck = [
+        ...existingWalls,
+    ];
     const previews = [];
     for (const plan of bridgePlans) {
         const nextPoint = plan.movedEndpoint === 'start' ? nextStart : nextEnd;
         if (!isSegmentLongEnough(plan.originalPoint, nextPoint)) {
             continue;
         }
-        if (wallSegmentExists(wallsForDuplicateCheck, plan.originalPoint, nextPoint)) {
+        if (wallSegmentExists(wallsForDuplicateCheck, plan.originalPoint, nextPoint, plan.wall.parentId)) {
             continue;
         }
         const { id: _id, children: _children, ...sourceWall } = plan.wall;

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

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/wall/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,eAAe,EAOpB,KAAK,QAAQ,EAGd,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAA2C,KAAK,GAAG,EAAa,MAAM,OAAO,CAAA;AAoDpF;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,CAAA;IAC/C,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IACrD,aAAa,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IAC5D,GAAG,CAAC,EAAE,GAAG,CAAA;CACV,GAAG,MAAM,GAAG,IAAI,CA+DhB;AAqCD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,eAoCtB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/wall/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAQL,KAAK,eAAe,EAOpB,KAAK,QAAQ,EAGd,MAAM,kBAAkB,CAAA;AAEzB,OAAO,EAA2C,KAAK,GAAG,EAAa,MAAM,OAAO,CAAA;AAqDpF;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE;IACpC,IAAI,EAAE,QAAQ,CAAA;IACd,SAAS,CAAC,EAAE;QAAE,QAAQ,CAAC,EAAE;YAAE,MAAM,CAAC,EAAE,OAAO,CAAA;SAAE,CAAA;KAAE,CAAA;IAC/C,aAAa,EAAE,MAAM,GAAG,IAAI,CAAA;IAC5B,MAAM,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IACrD,aAAa,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,GAAG,SAAS,CAAA;IAC5D,GAAG,CAAC,EAAE,GAAG,CAAA;CACV,GAAG,MAAM,GAAG,IAAI,CA+DhB;AAqCD;;;;;GAKG;AACH,eAAO,MAAM,SAAS,EAAE,eAoCtB,CAAA"}

package/dist/wall/paint.js

@@ -1,4 +1,5 @@
 import { getEffectiveWallSurfaceMaterial, getWallBandSlotId, getWallFaceBandConfig, getWallFaceBandForHeight, getWallSurfaceSideFromBandSlot, parseMaterialRef, sceneRegistry, useScene, WALL_SURFACE_SLOT_DEFAULTS, } from '@pascal-app/core';
+import { setSurfaceRaycastLayers } from '@pascal-app/viewer';
 import { Raycaster } from 'three';
 import { buildSlotPreviewMaterial, createSlotPaintCapability, previewSlotByUserData, } from '../shared/slot-paint';
 import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
@@ -20,6 +21,7 @@ const WALL_INDEX_SLOT = new Map(Object.entries(WALL_ARRAY_SLOT_INDEX).map(([slot
     slotId,
 ]));
 const wallSlotRaycaster = new Raycaster();
+setSurfaceRaycastLayers(wallSlotRaycaster.layers);
 function resolveSideFromMaterialIndex(materialIndex) {
     const slotId = materialIndex === null ? undefined : WALL_INDEX_SLOT.get(materialIndex);
     if (slotId)

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

@@ -1 +1 @@
-{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AAyFA,MAAM,CAAC,OAAO,UAAU,SAAS,uCAkUhC"}
+{"version":3,"file":"panel.d.ts","sourceRoot":"","sources":["../../src/wall/panel.tsx"],"names":[],"mappings":"AA0FA,MAAM,CAAC,OAAO,UAAU,SAAS,uCA8ThC"}

package/dist/wall/panel.js

@@ -6,6 +6,7 @@ import { useViewer } from '@pascal-app/viewer';
 import { Spline } from 'lucide-react';
 import { useCallback, useMemo, useRef } from 'react';
 import { resolveWallOpeningCeiling } from '../shared/wall-opening-ceiling';
+import { hasWallCurveBlockingChildren } from './curve-eligibility';
 /**
  * Base half of the plane-bound repair: a stamped draft offset goes, and a
  * ground host is dropped unless sculpted terrain actually supports it — a
@@ -63,22 +64,14 @@ export default function WallPanel() {
         return { ...sceneNode, ...liveOverride };
     }, [sceneNode, liveOverride]);
     // Boolean selector — re-renders only when this specific wall's child
-    // composition crosses the "has a door/window/wall-item" threshold.
+    // composition crosses the "has an incompatible hosted child" threshold.
     const hasWallChildrenBlockingCurve = useScene((s) => {
         if (!node)
             return false;
-        return (node.children ?? []).some((childId) => {
+        return hasWallCurveBlockingChildren((node.children ?? []).flatMap((childId) => {
             const child = s.nodes[childId];
-            if (!child)
-                return false;
-            if (child.type === 'door' || child.type === 'window')
-                return true;
-            if (child.type === 'item') {
-                const attachTo = child.asset?.attachTo;
-                return attachTo === 'wall' || attachTo === 'wall-side';
-            }
-            return false;
-        });
+            return child ? [child] : [];
+        }));
     });
     // Existing plane-bound walls have no stored height. Resolve their current
     // body height for display and materialize it if the user edits height or
@@ -181,17 +174,17 @@ export default function WallPanel() {
     const skirting = { ...WALL_SKIRTING_DEFAULT, ...(node.skirting ?? {}) };
     const crown = { ...WALL_CROWN_DEFAULT, ...(node.crown ?? {}) };
     const chairRail = { ...WALL_CHAIR_RAIL_DEFAULT, ...(node.chairRail ?? {}) };
-    return (_jsxs(PanelWrapper, { icon: "/icons/wall.webp", onClose: handleClose, title: node.name || 'Wall', width: 280, children: [_jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Length", max: metersToLinearUnit(20, unit), min: metersToLinearUnit(0.1, unit), onChange: (value) => handleUpdateLength(linearControlValueToMeters(value, unit, { maxMeters: 20, minMeters: 0.1 })), precision: 2, step: unit === 'imperial' ? 0.1 : 0.01, unit: unitLabel, value: displayLength }), _jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Top" }), _jsx(SegmentedControl, { onChange: handleTopModeChange, options: [
+    return (_jsxs(PanelWrapper, { icon: "/icons/wall.webp", onClose: handleClose, title: node.name || 'Wall', width: 280, children: [_jsxs(PanelSection, { title: "Dimensions", children: [_jsx(SliderControl, { label: "Length", max: metersToLinearUnit(1000, unit), min: metersToLinearUnit(0.1, unit), onChange: (value) => handleUpdateLength(linearControlValueToMeters(value, unit, { maxMeters: 1000, minMeters: 0.1 })), precision: 2, step: unit === 'imperial' ? 0.1 : 0.01, unit: unitLabel, value: displayLength }), _jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Top" }), _jsx(SegmentedControl, { onChange: handleTopModeChange, options: [
                             { label: 'Follows level', value: 'storey' },
                             { label: 'Custom height', value: 'custom' },
-                        ], value: isPlaneBound ? 'storey' : 'custom' }), isPlaneBound ? (_jsxs("div", { className: "px-1 text-[11px] text-muted-foreground", children: ["Currently ", formatLinearMeasurement(height, unit)] })) : (_jsx(SliderControl, { label: "Height", max: metersToLinearUnit(20, unit), min: metersToLinearUnit(0.1, unit), onChange: (v) => handleUpdate({
-                            height: linearControlValueToMeters(v, unit, { maxMeters: 20, minMeters: 0.1 }),
+                        ], value: isPlaneBound ? 'storey' : 'custom' }), isPlaneBound ? (_jsxs("div", { className: "px-1 text-[11px] text-muted-foreground", children: ["Currently ", formatLinearMeasurement(height, unit)] })) : (_jsx(SliderControl, { label: "Height", max: metersToLinearUnit(1000, unit), min: metersToLinearUnit(0.1, unit), onChange: (v) => handleUpdate({
+                            height: linearControlValueToMeters(v, unit, { maxMeters: 1000, minMeters: 0.1 }),
                         }), precision: 2, step: 0.1, unit: unitLabel, value: Math.round(displayHeight * 100) / 100 })), _jsx("div", { className: "px-1 font-medium text-[10px] text-muted-foreground/80 uppercase tracking-wider", children: "Bottom" }), _jsx(SegmentedControl, { onChange: handleInfillChange, options: [
                             { label: 'Auto', value: 'auto' },
                             { label: 'Fill to terrain', value: 'terrain' },
-                        ], value: followsTerrain ? 'terrain' : 'auto' }), followsTerrain && (_jsx("div", { className: "px-1 text-[11px] text-muted-foreground", children: "Extends downward to meet the terrain. Height and top stay unchanged." })), _jsx(SliderControl, { label: "Thickness", max: metersToLinearUnit(1, unit), min: metersToLinearUnit(0.05, unit), onChange: (v) => handleUpdate({
+                        ], value: followsTerrain ? 'terrain' : 'auto' }), followsTerrain && (_jsx("div", { className: "px-1 text-[11px] text-muted-foreground", children: "Extends downward to meet the terrain. Height and top stay unchanged." })), _jsx(SliderControl, { label: "Thickness", max: metersToLinearUnit(1000, unit), min: metersToLinearUnit(0.05, unit), onChange: (v) => handleUpdate({
                             thickness: linearControlValueToMeters(v, unit, {
-                                maxMeters: 1,
+                                maxMeters: 1000,
                                 minMeters: 0.05,
                             }),
                         }), precision: 3, step: 0.01, unit: unitLabel, value: Math.round(displayThickness * 1000) / 1000 }), !hasWallChildrenBlockingCurve && (_jsx(SliderControl, { label: "Curve", max: Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), min: -Math.max(metersToLinearUnit(0.01, unit), displayMaxCurveOffset), onChange: (v) => handleUpdate({

package/dist/wall/parametrics.js

@@ -15,10 +15,10 @@ export const wallParametrics = {
         {
             label: 'Dimensions',
             fields: [
-                { key: 'thickness', kind: 'number', unit: 'm', min: 0.05, max: 0.6, step: 0.01 },
+                { key: 'thickness', kind: 'number', unit: 'm', min: 0.05, max: 1000, step: 0.01 },
                 // `height` may be absent (plane-bound top); the custom panel owns the
                 // Follows storey / Custom height mode switch, so this is metadata only.
-                { key: 'height', kind: 'number', unit: 'm', min: 1.5, max: 20, step: 0.05 },
+                { key: 'height', kind: 'number', unit: 'm', min: 0.1, max: 1000, step: 0.05 },
                 { key: 'curveOffset', kind: 'number', unit: 'm', min: -3, max: 3, step: 0.05 },
             ],
         },

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"}