@pascal-app/nodes 1.0.1 → 1.0.4

package/dist/shared/slot-paint.js

@@ -1,6 +1,7 @@
-import { generateSceneMaterialId, parseMaterialRef, sceneRegistry, toSceneMaterialRef, useScene, } from '@pascal-app/core';
+import { generateSceneMaterialId, nodeRegistry, parseMaterialRef, sceneRegistry, slotDefaultPaintMaterial, slotPaintMaterial, toSceneMaterialRef, useScene, } from '@pascal-app/core';
 import { createMaterial, createMaterialFromPresetRef, registerMaterialCacheCleanup, setSurfaceRaycastLayers, useViewer, } from '@pascal-app/viewer';
 import { Raycaster } from 'three';
+import { swapPreviewMaterial } from './swap-preview-material';
 /**
  * Shared paint capability for procedural kinds on the unified slot model
  * (`node.slots: Record<slotId, MaterialRef>` + the shared scene-material
@@ -152,12 +153,12 @@ function commitSlotPaint(node, role, material, materialPreset) {
     state.updateNode(nodeId, { slots: nextSlots });
 }
 /** Preview material for a slot paint — mirrors the commit's resolution. */
-export function buildSlotPreviewMaterial(material, materialPreset) {
+export function buildSlotPreviewMaterial(material, materialPreset, materials = useScene.getState().materials) {
     const shading = useViewer.getState().shading;
     if (materialPreset) {
         const parsed = parseMaterialRef(materialPreset);
         if (parsed?.kind === 'scene') {
-            const sceneMaterial = useScene.getState().materials[parsed.id];
+            const sceneMaterial = materials[parsed.id];
             return sceneMaterial ? createMaterial(sceneMaterial.material, shading) : null;
         }
         return createMaterialFromPresetRef(materialPreset, shading);
@@ -172,8 +173,8 @@ export function buildSlotPreviewMaterial(material, materialPreset) {
  * slot matches `role`, leaving hosted-child meshes (which can carry a colliding
  * `userData.slotId` from their own GLB) untouched.
  */
-export function previewGeometrySlot(args) {
-    const { role, root, material, materialPreset } = args;
+export function previewGeometrySlot(args, matches = (meshRole) => meshRole === args.role) {
+    const { root, material, materialPreset } = args;
     const preview = buildSlotPreviewMaterial(material, materialPreset);
     if (!preview)
         return () => { };
@@ -186,13 +187,10 @@ export function previewGeometrySlot(args) {
         const userData = mesh.userData;
         if (userData.__fromGeometry !== true)
             return;
-        if (userData.slotId !== role)
+        const meshRole = userData.paintRole ?? userData.slotId;
+        if (!(meshRole && matches(meshRole)))
             return;
-        const previous = mesh.material;
-        mesh.material = preview;
-        restores.push(() => {
-            mesh.material = previous;
-        });
+        restores.push(swapPreviewMaterial(mesh, preview));
     });
     if (restores.length === 0)
         return null;
@@ -223,11 +221,7 @@ export function previewSlotByUserData(args) {
             return;
         if (mesh.userData.slotId !== role)
             return;
-        const previous = mesh.material;
-        mesh.material = preview;
-        restores.push(() => {
-            mesh.material = previous;
-        });
+        restores.push(swapPreviewMaterial(mesh, preview));
     });
     if (restores.length === 0)
         return null;
@@ -266,6 +260,14 @@ export function resolveSlotByReRaycast(args) {
     }
     return null;
 }
+/** A slot's declared default, as a look: what an unpainted slot draws. */
+export function declaredSlotLook(node, role) {
+    const declared = nodeRegistry
+        .get(node.type)
+        ?.capabilities?.slots?.(node)
+        .find((slot) => slot.slotId === role);
+    return slotDefaultPaintMaterial(declared?.default);
+}
 export function createSlotPaintCapability(config) {
     return {
         materialTarget: config.materialTarget,
@@ -284,8 +286,15 @@ export function createSlotPaintCapability(config) {
             // Release before swapping materials, including each room/all-matching target.
             const end = beginSlotPaintPreview(args.node.id);
             let restore;
+            // The eraser previews what the surface looks like once erased.
+            const erasing = args.material === undefined && args.materialPreset === undefined;
+            const look = erasing
+                ? config.erasedLook
+                    ? config.erasedLook(args)
+                    : declaredSlotLook(args.node, args.role)
+                : null;
             try {
-                restore = config.applyPreview(args);
+                restore = config.applyPreview(look ? { ...args, ...look } : args);
             }
             catch (error) {
                 end();
@@ -312,17 +321,8 @@ export function createSlotPaintCapability(config) {
             };
             return Object.assign(() => finish(false), { commit: () => finish(true) });
         },
-        getEffectiveMaterial: ({ node, role }) => {
-            const ref = node.slots?.[role];
-            const parsed = parseMaterialRef(ref);
-            if (parsed) {
-                if (parsed.kind === 'library')
-                    return { material: undefined, materialPreset: ref };
-                const sceneMaterial = useScene.getState().materials[parsed.id];
-                if (sceneMaterial)
-                    return { material: sceneMaterial.material, materialPreset: undefined };
-            }
-            return config.legacyEffective?.(node, role) ?? null;
-        },
+        getEffectiveMaterial: ({ node, role, materials = {} }) => slotPaintMaterial(node.slots?.[role], materials) ??
+            config.legacyEffective?.(node, role) ??
+            null,
     };
 }

package/dist/shared/surface-counterparts.d.ts

@@ -0,0 +1,12 @@
+import type { AnyNode, AnyNodeId } from '@pascal-app/core';
+/**
+ * The other surface of the same room: a slab's ceiling, a ceiling's slab —
+ * on the same level with the same outline. The plan draws them on top of each
+ * other (only the slab takes a click), so deselecting one deselects both.
+ * Both kinds declare it as their plan `selectionCounterparts`.
+ */
+export declare function sameOutlineSurfaceCounterparts({ node, nodes, }: {
+    node: AnyNode;
+    nodes: Readonly<Record<string, AnyNode | undefined>>;
+}): AnyNodeId[];
+//# sourceMappingURL=surface-counterparts.d.ts.map

package/dist/shared/surface-counterparts.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"surface-counterparts.d.ts","sourceRoot":"","sources":["../../src/shared/surface-counterparts.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAA;AAwB1D;;;;;GAKG;AACH,wBAAgB,8BAA8B,CAAC,EAC7C,IAAI,EACJ,KAAK,GACN,EAAE;IACD,IAAI,EAAE,OAAO,CAAA;IACb,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,CAAA;CACrD,GAAG,SAAS,EAAE,CAYd"}

package/dist/shared/surface-counterparts.js

@@ -0,0 +1,27 @@
+const POINT_EPSILON = 1e-6;
+function isSurface(node) {
+    return ((node?.type === 'slab' || node?.type === 'ceiling') &&
+        Array.isArray(node.polygon));
+}
+function samePolygon(a, b) {
+    return (a.length === b.length &&
+        a.every((point, index) => Math.abs(point[0] - b[index][0]) <= POINT_EPSILON &&
+            Math.abs(point[1] - b[index][1]) <= POINT_EPSILON));
+}
+/**
+ * The other surface of the same room: a slab's ceiling, a ceiling's slab —
+ * on the same level with the same outline. The plan draws them on top of each
+ * other (only the slab takes a click), so deselecting one deselects both.
+ * Both kinds declare it as their plan `selectionCounterparts`.
+ */
+export function sameOutlineSurfaceCounterparts({ node, nodes, }) {
+    if (!isSurface(node))
+        return [];
+    const other = node.type === 'slab' ? 'ceiling' : 'slab';
+    return Object.values(nodes)
+        .filter((candidate) => isSurface(candidate) &&
+        candidate.type === other &&
+        (candidate.parentId ?? null) === (node.parentId ?? null) &&
+        samePolygon(candidate.polygon, node.polygon))
+        .map((candidate) => candidate.id);
+}

package/dist/shared/surface-paint.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"surface-paint.d.ts","sourceRoot":"","sources":["../../src/shared/surface-paint.ts"],"names":[],"mappings":"AAMA,eAAO,MAAM,sBAAsB,4CAwBjC,CAAA"}
+{"version":3,"file":"surface-paint.d.ts","sourceRoot":"","sources":["../../src/shared/surface-paint.ts"],"names":[],"mappings":"AAOA,eAAO,MAAM,sBAAsB,4CAoBjC,CAAA"}

package/dist/shared/surface-paint.js

@@ -1,4 +1,5 @@
 import { buildSlotPreviewMaterial, createSlotPaintCapability } from './slot-paint';
+import { swapPreviewMaterial } from './swap-preview-material';
 export const surfacePaintCapability = createSlotPaintCapability({
     resolveRole: () => 'surface',
     applyPreview: ({ material, materialPreset, root }) => {
@@ -10,11 +11,7 @@ export const surfacePaintCapability = createSlotPaintCapability({
             const mesh = object;
             if (!mesh.isMesh)
                 return;
-            const previous = mesh.material;
-            mesh.material = preview;
-            restores.push(() => {
-                mesh.material = previous;
-            });
+            restores.push(swapPreviewMaterial(mesh, preview));
         });
         if (restores.length === 0)
             return null;

package/dist/shared/swap-preview-material.d.ts

@@ -0,0 +1,11 @@
+import type { Material, Mesh } from 'three';
+/**
+ * Shows a paint preview by giving `mesh` another material (or material
+ * array), and returns the undo. The undo puts the original back only while the
+ * mesh still wears the preview: a commit or rebuild that gave it new materials
+ * meanwhile (a new finish adds a palette entry and a geometry group) keeps
+ * them — restoring the older, shorter array would leave a group with no
+ * material, which the next raycast trips over.
+ */
+export declare function swapPreviewMaterial(mesh: Mesh, preview: Material | Material[]): () => void;
+//# sourceMappingURL=swap-preview-material.d.ts.map

package/dist/shared/swap-preview-material.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"swap-preview-material.d.ts","sourceRoot":"","sources":["../../src/shared/swap-preview-material.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,IAAI,EAAE,MAAM,OAAO,CAAA;AAE3C;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,IAAI,EAAE,OAAO,EAAE,QAAQ,GAAG,QAAQ,EAAE,GAAG,MAAM,IAAI,CAM1F"}

package/dist/shared/swap-preview-material.js

@@ -0,0 +1,16 @@
+/**
+ * Shows a paint preview by giving `mesh` another material (or material
+ * array), and returns the undo. The undo puts the original back only while the
+ * mesh still wears the preview: a commit or rebuild that gave it new materials
+ * meanwhile (a new finish adds a palette entry and a geometry group) keeps
+ * them — restoring the older, shorter array would leave a group with no
+ * material, which the next raycast trips over.
+ */
+export function swapPreviewMaterial(mesh, preview) {
+    const previous = mesh.material;
+    mesh.material = preview;
+    return () => {
+        if (mesh.material === preview)
+            mesh.material = previous;
+    };
+}

package/dist/shared/system-checks.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"system-checks.d.ts","sourceRoot":"","sources":["../../src/shared/system-checks.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAUf,MAAM,kBAAkB,CAAA;AAKzB,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;CAC9B,CAAA;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,aAAa,EAAE,CAmI3F"}
+{"version":3,"file":"system-checks.d.ts","sourceRoot":"","sources":["../../src/shared/system-checks.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAUf,MAAM,kBAAkB,CAAA;AAKzB,MAAM,MAAM,aAAa,GAAG;IAC1B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,SAAS,EAAE,CAAA;IACpB,QAAQ,EAAE,OAAO,GAAG,SAAS,CAAA;CAC9B,CAAA;AAED,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAAG,aAAa,EAAE,CAqI3F"}

package/dist/shared/system-checks.js

@@ -1,4 +1,4 @@
-import { buildPortComponents, collectSystemPorts, distributionPointToWorld, getWallBaseElevationForNodes, getWallCurveFrameAt, getWallEffectiveHeightForNodes, getWallThickness, nodeRegistry, validateDwv, } from '@pascal-app/core';
+import { buildPortComponents, collectSystemPorts, distributionPointToWorld, getWallBaseElevationForNodes, getWallCurveFrameAt, getWallEffectiveHeightForNodes, getWallFaceOffsets, nodeRegistry, validateDwv, } from '@pascal-app/core';
 import { Box3, Ray, Vector3 } from 'three';
 import { connectionCompatibility } from './connection-compatibility';
 import { planRunHangerSlots } from './run-hangers';
@@ -99,7 +99,9 @@ export function checkDistributionSystems(nodes) {
             const frame = getWallCurveFrameAt(wall, i / 16);
             points.push(world(wall, [frame.point.x, base, frame.point.y]), world(wall, [frame.point.x, top, frame.point.y]));
         }
-        const box = new Box3().setFromPoints(points).expandByScalar(getWallThickness(wall) / 2);
+        const box = new Box3()
+            .setFromPoints(points)
+            .expandByScalar(Math.max(getWallFaceOffsets(wall).a, -getWallFaceOffsets(wall).b));
         for (const segment of segments) {
             if (segment.run.wallAttachment?.wallId === wall.id)
                 continue;
@@ -108,7 +110,7 @@ export function checkDistributionSystems(nodes) {
         }
     }
     for (const run of runs) {
-        const missing = planRunHangerSlots(run, nodes).filter((slot) => !slot.skipped && !slot.hanger);
+        const missing = planRunHangerSlots(run, nodes).filter((slot) => !(slot.skipped || slot.hanger));
         if (missing.length)
             findings.push({
                 code: 'unsupported-hanger',

package/dist/shared/wall-attach-target.d.ts

@@ -54,6 +54,7 @@ export type WallPlanAttachment = Omit<WallHit, 'wall'> & {
 };
 /** Resolve a plan point against one wall, including its curved centerline. */
 export declare function resolveWallAttachmentAtPlanPoint(wall: WallNode, planPoint: readonly [number, number], maxDistance?: number): WallPlanAttachment | null;
+export declare function projectPlanPointToWallLocalX(wall: WallNode, planPoint: readonly [number, number]): number;
 /**
  * Return the closest wall attachment target in plan space, including curved
  * walls. This is deliberately separate from `findClosestWallInPlan`: doors,
@@ -86,17 +87,10 @@ export declare function snapLocalXToNeighbors(args: {
     threshold?: number;
 }): number | null;
 /**
- * Does a wall-hosted opening of `width × height` centred at `(clampedX,
- * clampedY)` (wall-local) overlap any OTHER child of `wallId` (door / window /
- * wall-mounted item)? AABB test in the wall's local face plane. `ignoreId`
- * excludes the moving node itself. Returns `true` (blocked) if the wall is
- * gone.
- *
- * Single source of truth for door + window placement collision — door-math and
- * window-math had byte-identical copies of this. Y conventions differ per kind
- * (items store bottom Y; doors/windows store centre Y), handled inline.
+ * Whether a wall-hosted opening would overlap another child of its wall. The rule lives in
+ * core, shared with every agent surface (`planWallOpening`); re-exported for the tools here.
  */
-export declare function hasWallChildOverlap(wallId: string, nodes: Readonly<Record<string, AnyNode>>, clampedX: number, clampedY: number, width: number, height: number, ignoreId?: string): boolean;
+export { hasWallChildOverlap } from '@pascal-app/core/building';
 /** Placement state for a wall-hosted opening — the SINGLE decision the preview
  *  tint and the commit gate both consume so they can never disagree. */
 export type OpeningPlacement = {

package/dist/shared/wall-attach-target.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-attach-target.d.ts","sourceRoot":"","sources":["../../src/shared/wall-attach-target.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"wall-attach-target.d.ts","sourceRoot":"","sources":["../../src/shared/wall-attach-target.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAUd,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;;;;;;;;;;GAaG;AAEH,MAAM,MAAM,OAAO,GAAG;IACpB,IAAI,EAAE,QAAQ,CAAA;IACd,qEAAqE;IACrE,MAAM,EAAE,MAAM,CAAA;IACd,gFAAgF;IAChF,YAAY,EAAE,MAAM,CAAA;IACpB,iDAAiD;IACjD,IAAI,EAAE,OAAO,GAAG,MAAM,CAAA;IACtB,qCAAqC;IACrC,IAAI,EAAE,MAAM,CAAA;IACZ,oDAAoD;IACpD,IAAI,EAAE,MAAM,CAAA;IACZ,6BAA6B;IAC7B,UAAU,EAAE,MAAM,CAAA;IAClB;;;;;;;OAOG;IACH,YAAY,EAAE,MAAM,CAAA;CACrB,CAAA;AAED,wBAAgB,2BAA2B,CACzC,IAAI,EAAE,QAAQ,EACd,MAAM,EAAE,MAAM,EACd,MAAM,SAAI,GACT,CAAC,MAAM,EAAE,MAAM,CAAC,CAKlB;AAED;;;;;;;;;GASG;AACH,wBAAgB,qBAAqB,CACnC,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,aAAa,EAAE,SAAS,GAAG,IAAI,EAC/B,aAAa,CAAC,EAAE,SAAS,GACxB,OAAO,GAAG,IAAI,CA+BhB;AAWD,MAAM,MAAM,kBAAkB,GAAG,IAAI,CAAC,OAAO,EAAE,MAAM,CAAC,GAAG;IACvD,QAAQ,EAAE,MAAM,CAAA;CACjB,CAAA;AAyCD,8EAA8E;AAC9E,wBAAgB,gCAAgC,CAC9C,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,WAAW,SAAuB,GACjC,kBAAkB,GAAG,IAAI,CA0C3B;AAED,wBAAgB,4BAA4B,CAC1C,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,GACnC,MAAM,CAER;AAED;;;;;GAKG;AACH,wBAAgB,+BAA+B,CAC7C,SAAS,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,EACpC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,aAAa,EAAE,SAAS,GAAG,IAAI,EAC/B,aAAa,CAAC,EAAE,SAAS,GACxB,OAAO,GAAG,IAAI,CAehB;AAwBD;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE;IAC1C,IAAI,EAAE,QAAQ,CAAA;IACd,MAAM,EAAE,MAAM,CAAA;IACd,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,SAAS,CAAA;IACjB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,SAAS,CAAC,EAAE,MAAM,CAAA;CACnB,GAAG,MAAM,GAAG,IAAI,CAiChB;AAED;;;GAGG;AACH,OAAO,EAAE,mBAAmB,EAAE,MAAM,2BAA2B,CAAA;AAE/D;wEACwE;AACxE,MAAM,MAAM,gBAAgB,GAAG;IAC7B,4EAA4E;IAC5E,QAAQ,EAAE,OAAO,CAAA;IACjB;+BAC2B;IAC3B,SAAS,EAAE,OAAO,CAAA;IAClB,sDAAsD;IACtD,IAAI,EAAE,OAAO,GAAG,SAAS,CAAA;CAC1B,CAAA;AAED;;;;;GAKG;AACH,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,QAAQ,EAAE,OAAO,CAAA;IACjB,UAAU,EAAE,OAAO,CAAA;CACpB,GAAG,gBAAgB,CAOnB"}

package/dist/shared/wall-attach-target.js

@@ -120,6 +120,9 @@ export function resolveWallAttachmentAtPlanPoint(wall, planPoint, maxDistance =
         itemRotation: side === 'front' ? 0 : Math.PI,
     };
 }
+export function projectPlanPointToWallLocalX(wall, planPoint) {
+    return resolveWallAttachmentAtPlanPoint(wall, planPoint, Number.POSITIVE_INFINITY)?.localX ?? 0;
+}
 /**
  * Return the closest wall attachment target in plan space, including curved
  * walls. This is deliberately separate from `findClosestWallInPlan`: doors,
@@ -216,70 +219,10 @@ export function snapLocalXToNeighbors(args) {
     return bestDelta === null ? null : localX + bestDelta;
 }
 /**
- * Does a wall-hosted opening of `width × height` centred at `(clampedX,
- * clampedY)` (wall-local) overlap any OTHER child of `wallId` (door / window /
- * wall-mounted item)? AABB test in the wall's local face plane. `ignoreId`
- * excludes the moving node itself. Returns `true` (blocked) if the wall is
- * gone.
- *
- * Single source of truth for door + window placement collision — door-math and
- * window-math had byte-identical copies of this. Y conventions differ per kind
- * (items store bottom Y; doors/windows store centre Y), handled inline.
+ * Whether a wall-hosted opening would overlap another child of its wall. The rule lives in
+ * core, shared with every agent surface (`planWallOpening`); re-exported for the tools here.
  */
-export function hasWallChildOverlap(wallId, nodes, clampedX, clampedY, width, height, ignoreId) {
-    const wallNode = nodes[wallId];
-    if (!wallNode)
-        return true;
-    const halfW = width / 2;
-    const halfH = height / 2;
-    const newBottom = clampedY - halfH;
-    const newTop = clampedY + halfH;
-    const newLeft = clampedX - halfW;
-    const newRight = clampedX + halfW;
-    for (const childId of Array.isArray(wallNode.children) ? wallNode.children : []) {
-        if (childId === ignoreId)
-            continue;
-        const child = nodes[childId];
-        if (!child)
-            continue;
-        let childLeft;
-        let childRight;
-        let childBottom;
-        let childTop;
-        if (child.type === 'item') {
-            const item = child;
-            if (item.asset.attachTo !== 'wall' && item.asset.attachTo !== 'wall-side')
-                continue;
-            const [w, h] = getScaledDimensions(item);
-            childLeft = item.position[0] - w / 2;
-            childRight = item.position[0] + w / 2;
-            childBottom = item.position[1]; // items store bottom Y
-            childTop = item.position[1] + h;
-        }
-        else if (child.type === 'window') {
-            const win = child;
-            childLeft = win.position[0] - win.width / 2;
-            childRight = win.position[0] + win.width / 2;
-            childBottom = win.position[1] - win.height / 2; // windows store centre Y
-            childTop = win.position[1] + win.height / 2;
-        }
-        else if (child.type === 'door') {
-            const door = child;
-            childLeft = door.position[0] - door.width / 2;
-            childRight = door.position[0] + door.width / 2;
-            childBottom = door.position[1] - door.height / 2; // doors store centre Y
-            childTop = door.position[1] + door.height / 2;
-        }
-        else {
-            continue;
-        }
-        const xOverlap = newLeft < childRight && newRight > childLeft;
-        const yOverlap = newBottom < childTop && newTop > childBottom;
-        if (xOverlap && yOverlap)
-            return true;
-    }
-    return false;
-}
+export { hasWallChildOverlap } from '@pascal-app/core/building';
 /**
  * Resolve the placement state from the raw collision result and whether the
  * user is force-placing (held Alt). Force-place lifts the collision block, so the

package/dist/shared/wall-event-from-grid.d.ts

@@ -0,0 +1,5 @@
+import { type AnyNode, type AnyNodeId, type GridEvent, type WallEvent } from '@pascal-app/core';
+import { type Object3D } from 'three';
+/** Canvas surface queries still reach the host when a rendered child consumes mesh events. */
+export declare function wallEventFromGrid(event: GridEvent, activeLevelId: AnyNodeId | null, nodes: Record<AnyNodeId, AnyNode>, objects: ReadonlyMap<string, Object3D>): WallEvent | null;
+//# sourceMappingURL=wall-event-from-grid.d.ts.map

package/dist/shared/wall-event-from-grid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-event-from-grid.d.ts","sourceRoot":"","sources":["../../src/shared/wall-event-from-grid.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,SAAS,EAEd,KAAK,SAAS,EACf,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAW,KAAK,QAAQ,EAAW,MAAM,OAAO,CAAA;AAEvD,8FAA8F;AAC9F,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,SAAS,EAChB,aAAa,EAAE,SAAS,GAAG,IAAI,EAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,WAAW,CAAC,MAAM,EAAE,QAAQ,CAAC,GACrC,SAAS,GAAG,IAAI,CA8BlB"}

package/dist/shared/wall-event-from-grid.js

@@ -0,0 +1,36 @@
+import { isCurvedWall, } from '@pascal-app/core';
+import { Matrix3, Vector3 } from 'three';
+/** Canvas surface queries still reach the host when a rendered child consumes mesh events. */
+export function wallEventFromGrid(event, activeLevelId, nodes, objects) {
+    if (event.surfaceHit?.kind !== 'wall' || !event.surfaceNormal)
+        return null;
+    const wall = nodes[event.surfaceHit.hostId];
+    if (wall?.type !== 'wall' ||
+        wall.visible === false ||
+        wall.metadata.isTransient ||
+        wall.parentId !== activeLevelId ||
+        isCurvedWall(wall))
+        return null;
+    const object = objects.get(wall.id);
+    const frame = event.localFrameId ? objects.get(event.localFrameId) : undefined;
+    if (!object || (event.localFrameId && !frame))
+        return null;
+    object.updateWorldMatrix(true, false);
+    frame?.updateWorldMatrix(true, false);
+    const normal = new Vector3(...event.surfaceNormal);
+    if (frame)
+        normal.applyNormalMatrix(new Matrix3().getNormalMatrix(frame.matrixWorld));
+    normal.applyNormalMatrix(new Matrix3().getNormalMatrix(object.matrixWorld.clone().invert()));
+    if (Math.abs(normal.z) <= 0.7)
+        return null;
+    const position = object.worldToLocal(new Vector3(...event.position));
+    return {
+        node: wall,
+        object,
+        position: event.position,
+        localPosition: position.toArray(),
+        normal: normal.toArray(),
+        nativeEvent: event.nativeEvent,
+        stopPropagation: () => { },
+    };
+}

package/dist/shared/wall-opening-ceiling.d.ts

@@ -1,4 +1,5 @@
-import { type AnyNode, type AnyNodeId, type WallNode } from '@pascal-app/core';
+import { type AnyNode, type AnyNodeId, type DoorNode } from '@pascal-app/core';
+import { resolveWallOpeningCeiling } from '@pascal-app/core/building';
 /**
  * Structural subset of `SceneApi` the opening-cap readers need — matches
  * both handle-descriptor callbacks (which receive the full SceneApi) and
@@ -8,23 +9,12 @@ export type WallCeilingSceneReader = {
     get: (id: AnyNodeId) => unknown;
     nodes: () => Readonly<Record<AnyNodeId, AnyNode>>;
 };
-/**
- * Available wall-local Y span for an opening hosted on `wall`: the wall's
- * resolved top (storey plane for plane-bound walls, stored height for
- * explicit ones) minus the wall's elected slab base. Wall-local Y = 0 sits
- * at the elected base (where the viewer positions the wall mesh), so this
- * is the ceiling an opening's top edge must stay under.
- *
- * Uses the same slab election as the viewer's WallSystem
- * (`spatialGridManager.getSlabSupportForWall`) so the cap agrees with the
- * rendered wall; headless callers with an empty spatial grid elect base 0
- * and fall back to the full storey height.
- */
-export declare function resolveWallOpeningCeiling(wall: WallNode, nodes: Readonly<Record<AnyNodeId, AnyNode>>): number;
+/** The ceiling an opening's top edge must stay under: the shared rule in core. */
+export { resolveWallOpeningCeiling };
 /**
  * Height cap for a wall-hosted opening's resize handles. Infinity only when
  * the opening is unhosted (no wallId, or the wall is gone) — roof-hosted
  * openings clamp elsewhere.
  */
-export declare function readHostWallCeiling(wallId: string | null | undefined, scene: WallCeilingSceneReader): number;
+export declare function readHostWallCeiling(wallId: string | null | undefined, scene: WallCeilingSceneReader, opening?: Pick<DoorNode, 'position' | 'width' | 'height'>): number;
 //# sourceMappingURL=wall-opening-ceiling.d.ts.map

package/dist/shared/wall-opening-ceiling.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-opening-ceiling.d.ts","sourceRoot":"","sources":["../../src/shared/wall-opening-ceiling.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EAEd,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAEzB;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,GAAG,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,OAAO,CAAA;IAC/B,KAAK,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;CAClD,CAAA;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,yBAAyB,CACvC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,GAC1C,MAAM,CAER;AAED;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,KAAK,EAAE,sBAAsB,GAC5B,MAAM,CAKR"}
+{"version":3,"file":"wall-opening-ceiling.d.ts","sourceRoot":"","sources":["../../src/shared/wall-opening-ceiling.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EACZ,KAAK,SAAS,EACd,KAAK,QAAQ,EAId,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAAE,yBAAyB,EAAE,MAAM,2BAA2B,CAAA;AAErE;;;;GAIG;AACH,MAAM,MAAM,sBAAsB,GAAG;IACnC,GAAG,EAAE,CAAC,EAAE,EAAE,SAAS,KAAK,OAAO,CAAA;IAC/B,KAAK,EAAE,MAAM,QAAQ,CAAC,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAC,CAAA;CAClD,CAAA;AAED,kFAAkF;AAClF,OAAO,EAAE,yBAAyB,EAAE,CAAA;AAEpC;;;;GAIG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,MAAM,GAAG,IAAI,GAAG,SAAS,EACjC,KAAK,EAAE,sBAAsB,EAC7B,OAAO,CAAC,EAAE,IAAI,CAAC,QAAQ,EAAE,UAAU,GAAG,OAAO,GAAG,QAAQ,CAAC,GACxD,MAAM,CASR"}

package/dist/shared/wall-opening-ceiling.js

@@ -1,29 +1,21 @@
-import { getWallEffectiveHeightForNodes, } from '@pascal-app/core';
-/**
- * Available wall-local Y span for an opening hosted on `wall`: the wall's
- * resolved top (storey plane for plane-bound walls, stored height for
- * explicit ones) minus the wall's elected slab base. Wall-local Y = 0 sits
- * at the elected base (where the viewer positions the wall mesh), so this
- * is the ceiling an opening's top edge must stay under.
- *
- * Uses the same slab election as the viewer's WallSystem
- * (`spatialGridManager.getSlabSupportForWall`) so the cap agrees with the
- * rendered wall; headless callers with an empty spatial grid elect base 0
- * and fall back to the full storey height.
- */
-export function resolveWallOpeningCeiling(wall, nodes) {
-    return getWallEffectiveHeightForNodes(wall, nodes);
-}
+import { getOpeningFloorDatum, wallSupportForNodes, } from '@pascal-app/core';
+import { resolveWallOpeningCeiling } from '@pascal-app/core/building';
+/** The ceiling an opening's top edge must stay under: the shared rule in core. */
+export { resolveWallOpeningCeiling };
 /**
  * Height cap for a wall-hosted opening's resize handles. Infinity only when
  * the opening is unhosted (no wallId, or the wall is gone) — roof-hosted
  * openings clamp elsewhere.
  */
-export function readHostWallCeiling(wallId, scene) {
+export function readHostWallCeiling(wallId, scene, opening) {
     if (!wallId)
         return Number.POSITIVE_INFINITY;
     const wall = scene.get(wallId);
     if (!wall)
         return Number.POSITIVE_INFINITY;
-    return resolveWallOpeningCeiling(wall, scene.nodes());
+    const nodes = scene.nodes();
+    const lift = opening
+        ? getOpeningFloorDatum(wall, opening, nodes) - wallSupportForNodes(wall, nodes).elevation
+        : 0;
+    return resolveWallOpeningCeiling(wall, nodes) - lift;
 }

package/dist/shelf/definition.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAQpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA4HpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAwJ5D,CAAA"}
+{"version":3,"file":"definition.d.ts","sourceRoot":"","sources":["../../src/shelf/definition.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAoB,cAAc,EAA8B,MAAM,kBAAkB,CAAA;AAUpG,OAAO,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA2HpC,eAAO,MAAM,eAAe,EAAE,cAAc,CAAC,OAAO,SAAS,CAyJ5D,CAAA"}

package/dist/shelf/definition.js

@@ -1,3 +1,5 @@
+import { shelfSlots } from '@pascal-app/core';
+import { restingFloorplanAffectedIds } from '../shared/resting-surface-plan';
 import { sanitizeShelfDimensions } from './dimensions';
 import { buildShelfFloorplan } from './floorplan';
 import { shelfResizeAffordance, shelfRotateAffordance } from './floorplan-affordances';
@@ -6,7 +8,6 @@ import { buildShelfGeometry, shelfRowSurfaceYs } from './geometry';
 import { shelfPaint } from './paint';
 import { shelfParametrics } from './parametrics';
 import { ShelfNode } from './schema';
-import { shelfSlots } from './slots';
 const SIDE_HANDLE_OFFSET = 0.18;
 const HEIGHT_HANDLE_OFFSET = 0.22;
 const ROTATE_CORNER_OFFSET = 0.32;
@@ -173,7 +174,7 @@ export const shelfDefinition = {
             })),
         },
         selectable: { hitVolume: 'bbox' },
-        duplicable: true,
+        duplicable: { subtree: 'with-children' },
         deletable: true,
         paint: shelfPaint,
         slots: (n) => shelfSlots(n),
@@ -230,6 +231,7 @@ export const shelfDefinition = {
         ]);
     },
     floorplan: buildShelfFloorplan,
+    floorplanAffectedIds: restingFloorplanAffectedIds,
     // 2D move handler — Path 1 in `FloorplanRegistryMoveOverlay`. Without
     // this the overlay falls through to Path 2 which stomps the SVG
     // entry's `transform` attribute (set by the floor-plan layer to

package/dist/shelf/floorplan.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAG1E,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAQzC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,CAAC,EAAE,eAAe,GAAG,iBAAiB,CAmH7F"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/shelf/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,iBAAiB,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAA;AAIrF,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAQzC;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,SAAS,EAAE,GAAG,CAAC,EAAE,eAAe,GAAG,iBAAiB,CA0H7F"}

package/dist/shelf/floorplan.js

@@ -1,3 +1,4 @@
+import { restingNodePlanFrame } from '../shared/resting-surface-plan';
 import { sanitizeShelfDimensions } from './dimensions';
 // Offsets for the floor-plan selection chrome. Resize chevrons sit a
 // hair off the footprint rim; the rotate-arrow corner sits a bit further
@@ -22,8 +23,14 @@ const ROTATE_ARROW_CORNER_OFFSET = 0.22;
  */
 export function buildShelfFloorplan(node, ctx) {
     const shelf = sanitizeShelfDimensions(node);
-    const [px, , pz] = shelf.position;
-    const ry = shelf.rotation[1] ?? 0;
+    const parent = shelf.parentId ? ctx?.resolve(shelf.parentId) : undefined;
+    const hostedFrame = ctx && parent?.type === 'procedural-item' && parent.attachments[shelf.id] !== undefined
+        ? restingNodePlanFrame(shelf, ctx.resolve)
+        : null;
+    const [px, , pz] = hostedFrame?.position ?? shelf.position;
+    const ry = hostedFrame
+        ? Math.atan2(hostedFrame.axes[2][0], hostedFrame.axes[2][2])
+        : (shelf.rotation[1] ?? 0);
     // Floor-plan plots at `-ry` so SVG's CW-with-y-down `rotate` direction
     // ends up visually matching Three.js Y-rotation (CCW from a top-down
     // view) — same `rotation` value rotates the same way in both views.

package/dist/shelf/geometry.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/shelf/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,eAAe,EAGrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAIL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAe,KAAK,EAAuB,MAAM,OAAO,CAAA;AAE/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AA0EzC,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,SAAS,EAClB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,GAClC,KAAK,CAkCP;AAySD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,EAAE,CAM3D"}
+{"version":3,"file":"geometry.d.ts","sourceRoot":"","sources":["../../src/shelf/geometry.ts"],"names":[],"mappings":"AAAA,OAAO,EAEL,KAAK,eAAe,EAKrB,MAAM,kBAAkB,CAAA;AACzB,OAAO,EAIL,KAAK,aAAa,EAEnB,MAAM,oBAAoB,CAAA;AAC3B,OAAO,EAAe,KAAK,EAAuB,MAAM,OAAO,CAAA;AAE/D,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,UAAU,CAAA;AAyEzC,wBAAgB,kBAAkB,CAChC,OAAO,EAAE,SAAS,EAClB,GAAG,CAAC,EAAE,eAAe,EACrB,OAAO,GAAE,aAA0B,GAClC,KAAK,CAkCP;AAySD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,SAAS,GAAG,MAAM,EAAE,CAM3D"}

package/dist/shelf/geometry.js

@@ -1,8 +1,7 @@
-import { SHELF_BOARD_INSET as BOARD_INSET, getMaterialPresetByRef, shelfBoardDimensions, } from '@pascal-app/core';
+import { SHELF_BOARD_INSET as BOARD_INSET, getMaterialPresetByRef, SHELF_SLOT_DEFAULT_COLOR, shelfBoardDimensions, } from '@pascal-app/core';
 import { applyMaterialPresetToMaterials, createDefaultMaterial, createMaterial, resolveMaterialRef, } from '@pascal-app/viewer';
 import { BoxGeometry, Group, Mesh } from 'three';
 import { sanitizeShelfDimensions } from './dimensions';
-import { SHELF_SLOT_DEFAULT_COLOR } from './slots';
 function getShelfSlotMaterial(node, slotId, materials, shading) {
     const ref = node.slots?.[slotId];
     if (ref) {

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

@@ -1 +1 @@
-{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/shelf/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,eAAe,EAOrB,MAAM,kBAAkB,CAAA;AAmLzB,eAAO,MAAM,UAAU,EAAE,eA0BxB,CAAA"}
+{"version":3,"file":"paint.d.ts","sourceRoot":"","sources":["../../src/shelf/paint.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,eAAe,EAOrB,MAAM,kBAAkB,CAAA;AAmLzB,eAAO,MAAM,UAAU,EAAE,eAoBxB,CAAA"}

package/dist/shelf/paint.js

@@ -1,4 +1,4 @@
-import { generateSceneMaterialId, parseMaterialRef, toSceneMaterialRef, useScene, } from '@pascal-app/core';
+import { generateSceneMaterialId, slotPaintMaterial, toSceneMaterialRef, useScene, } from '@pascal-app/core';
 import { createMaterial, createMaterialFromPresetRef, useViewer } from '@pascal-app/viewer';
 function deepEqual(a, b) {
     if (Object.is(a, b))
@@ -162,15 +162,9 @@ export const shelfPaint = {
     applyPreview: ({ role, root, material, materialPreset }) => applyShelfPreview(role, root, material, materialPreset),
     getEffectiveMaterial: ({ node, role }) => {
         const shelf = node;
-        const parsed = parseMaterialRef(shelf.slots?.[role]);
-        if (parsed) {
-            if (parsed.kind === 'library') {
-                return { material: undefined, materialPreset: shelf.slots?.[role] };
-            }
-            const sceneMaterial = useScene.getState().materials[parsed.id];
-            if (sceneMaterial)
-                return { material: sceneMaterial.material, materialPreset: undefined };
-        }
+        const painted = slotPaintMaterial(shelf.slots?.[role], useScene.getState().materials);
+        if (painted)
+            return painted;
         // No (or dangling) slot ref — surface the legacy whole-shelf paint the
         // geometry builder still falls back to, so the picker matches what renders.
         if (shelf.materialPreset || shelf.material) {