@pascal-app/core 1.0.1 → 1.0.4

package/dist/procedural-items/node.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/procedural-items/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,EAA+B,KAAK,MAAM,EAAE,MAAM,UAAU,CAAA;AAanE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoCmD,CAAA;AAClF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACnE,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;SAIjF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;EAS5E"}
+{"version":3,"file":"node.d.ts","sourceRoot":"","sources":["../../src/procedural-items/node.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,CAAC,EAAE,MAAM,KAAK,CAAA;AAGvB,OAAO,EAA+B,KAAK,MAAM,EAAE,MAAM,UAAU,CAAA;AAanE,eAAO,MAAM,kBAAkB;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBAoCmD,CAAA;AAClF,MAAM,MAAM,kBAAkB,GAAG,CAAC,CAAC,KAAK,CAAC,OAAO,kBAAkB,CAAC,CAAA;AACnE,wBAAgB,cAAc,CAAC,IAAI,EAAE,kBAAkB,EAAE,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;SAIjF;AAED,wBAAgB,cAAc,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC;;EAS5E"}

package/dist/procedural-items/query.d.ts

@@ -9,13 +9,31 @@ export declare function proceduralLocalPose(node: ProceduralItemNode, nodes: Que
     position: Vec3;
     rotation: Vec3;
 };
+/** A ceiling design's cut as a hole ring in its ceiling's local [x, z], or null. */
+export declare function proceduralCeilingHole(node: ProceduralItemNode): [number, number][] | null;
 export declare function proceduralFootprint(node: ProceduralItemNode): {
     position: Vec3;
     rotation: [number, number, number];
     dimensions: Vec3;
 };
-export declare function nodeLevelFrame(id: string, nodes: QueryNodes, seen?: Set<string>): Frame;
+export type LevelFrameOptions = {
+    /**
+     * Frames already resolved over the same unchanged `nodes` record, filled as
+     * hosts resolve, so a query over many nodes resolves each host once. Keep
+     * one cache per `planOnly` setting.
+     */
+    cache?: Map<string, Frame>;
+    /**
+     * Resolve only the plan (XZ) placement: heights that need the scene (wall
+     * slab support, ceiling height, floor lift) are taken as 0, which skips
+     * their cost. Rotations and plan positions are exact.
+     */
+    planOnly?: boolean;
+};
+/** A node's frame in its level's coordinates. */
+export declare function nodeLevelFrame(id: string, nodes: QueryNodes, seen?: Set<string>, options?: LevelFrameOptions): Frame;
 export declare function attachmentBounds(child: ProceduralItemNode | ItemNode): import("./spatial.js").Bounds;
+export declare function attachmentRegionsOverlap(a: ReturnType<typeof attachmentBounds>, b: ReturnType<typeof attachmentBounds>): boolean;
 export declare function validateProceduralRelations(raw: AnyNode | ProceduralItemNode, nodes: QueryNodes): void;
 export declare function queryProceduralItem(node: ProceduralItemNode, nodes: QueryNodes): {
     id: `procedural-item_${string}`;

package/dist/procedural-items/query.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/procedural-items/query.ts"],"names":[],"mappings":"AAWA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAIpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAM9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAA;AAChD,OAAO,EAAgC,KAAK,IAAI,EAAE,MAAM,UAAU,CAAA;AAClE,OAAO,EAIL,KAAK,KAAK,EAIX,MAAM,WAAW,CAAA;AAElB,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,kBAAkB,CAAC,CAAC,CAAA;AAC/E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,kBAAkB,CAI1E;AAQD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,UAAU;;;EA6B9E;AACD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB;;;;EAK3D;AAyED,wBAAgB,cAAc,CAAC,EAAE,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU,EAAE,IAAI,cAAoB,GAAG,KAAK,CA8D7F;AAMD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG,QAAQ,8BAKpE;AA0BD,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,OAAO,GAAG,kBAAkB,EAAE,KAAK,EAAE,UAAU,QAwG/F;AACD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B9E"}
+{"version":3,"file":"query.d.ts","sourceRoot":"","sources":["../../src/procedural-items/query.ts"],"names":[],"mappings":"AAYA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AAIpD,OAAO,KAAK,EAAE,OAAO,EAAE,MAAM,iBAAiB,CAAA;AAM9C,OAAO,KAAK,EAAE,kBAAkB,EAAE,MAAM,QAAQ,CAAA;AAChD,OAAO,EAAgC,KAAK,IAAI,EAAE,MAAM,UAAU,CAAA;AAClE,OAAO,EAIL,KAAK,KAAK,EAIX,MAAM,WAAW,CAAA;AAElB,MAAM,MAAM,UAAU,GAAG,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,kBAAkB,CAAC,CAAC,CAAA;AAC/E,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,OAAO,GAAG,IAAI,IAAI,kBAAkB,CAI1E;AAQD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,UAAU;;;EAiC9E;AACD,oFAAoF;AACpF,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,kBAAkB,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,GAAG,IAAI,CAYzF;AACD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB;;;;EAK3D;AAwED,MAAM,MAAM,iBAAiB,GAAG;IAC9B;;;;OAIG;IACH,KAAK,CAAC,EAAE,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,CAAA;IAC1B;;;;OAIG;IACH,QAAQ,CAAC,EAAE,OAAO,CAAA;CACnB,CAAA;AAED,iDAAiD;AACjD,wBAAgB,cAAc,CAC5B,EAAE,EAAE,MAAM,EACV,KAAK,EAAE,UAAU,EACjB,IAAI,cAAoB,EACxB,OAAO,GAAE,iBAAsB,GAC9B,KAAK,CAMP;AA+GD,wBAAgB,gBAAgB,CAAC,KAAK,EAAE,kBAAkB,GAAG,QAAQ,8BAKpE;AACD,wBAAgB,wBAAwB,CACtC,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,EACtC,CAAC,EAAE,UAAU,CAAC,OAAO,gBAAgB,CAAC,WAQvC;AA0BD,wBAAgB,2BAA2B,CAAC,GAAG,EAAE,OAAO,GAAG,kBAAkB,EAAE,KAAK,EAAE,UAAU,QA6G/F;AACD,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,kBAAkB,EAAE,KAAK,EAAE,UAAU;;;;;;;;;;;;;;;;;;;;;;;;;;;;;EA0B9E"}

package/dist/procedural-items/query.js

@@ -1,14 +1,17 @@
 import { getFloorPlacedFootprints } from '../hooks/spatial-grid/floor-placed-footprints.js';
-import { itemOverlapsPolygon } from '../lib/item-polygon-overlap.js';
+import { liftedManualSlab } from '../lib/floor-construction-lift.js';
+import { selectSlabSupportForItem } from '../lib/item-slab-support.js';
 import { pointInPolygon as containsPoint, polygonsOverlap, } from '../lib/polygon-relations.js';
 import { getRenderableSlabPolygon } from '../lib/slab-polygon.js';
-import { levelBaseElevationAt } from '../lib/terrain-support.js';
+import { levelBaseElevationAt } from '../lib/terrain-support-query.js';
 import { nodeRegistry } from '../registry/registry.js';
+import { getBlockFaceFrame } from '../schema/nodes/block.js';
+import { getRoofWallFaceFrame, roofFacePointToSegment } from '../schema/nodes/roof-segment-walls.js';
 import { resolveCeilingHeight } from '../services/level-height.js';
 import { getStoredLevelHeight } from '../services/storey.js';
 import { surfaceRegionContainsPoint } from '../services/surface-region.js';
-import { computeWallSlabSupport, pointInPolygon } from '../systems/slab/slab-support.js';
-import { getWallThickness } from '../systems/wall/wall-footprint.js';
+import { computeWallSlabSupport } from '../systems/slab/slab-support.js';
+import { getWallLocalFaceZ } from '../systems/wall/wall-frame.js';
 import { evaluateRecipe } from './recipe.js';
 import { boundsOf, boxCorners, composeFrames, frame, IDENTITY_FRAME, transformPoint, } from './spatial.js';
 export function isProceduralItem(node) {
@@ -46,9 +49,29 @@ export function proceduralLocalPose(node, nodes) {
     rotation[1] = sign < 0 ? Math.PI : 0;
     position[0] -= reference.position[0] * sign;
     position[1] -= reference.position[1];
-    position[2] = sign * (getWallThickness(wall) / 2 - reference.position[2] + node.position[2]);
+    position[2] =
+        sign *
+            (getWallLocalFaceZ(wall, sign > 0 ? 'a' : 'b') * sign -
+                reference.position[2] +
+                node.position[2]);
     return { position, rotation };
 }
+/** A ceiling design's cut as a hole ring in its ceiling's local [x, z], or null. */
+export function proceduralCeilingHole(node) {
+    if (node.recipe.mounting?.attachTo !== 'ceiling')
+        return null;
+    const e = evaluateRecipe(node.recipe, node.parameters);
+    const cut = e.cuts.find((c) => c.host === 'ceiling');
+    const reference = e.surfaces.find((s) => s.id === node.recipe.mounting?.reference);
+    if (!(cut && reference))
+        return null;
+    // Same pose as proceduralLocalPose: the reference sits at the node's ceiling position.
+    const f = frame(node.position, node.rotation);
+    return cut.ring.map(([x, z]) => {
+        const p = transformPoint(f, [x - reference.position[0], 0, z - reference.position[2]]);
+        return [p[0], p[2]];
+    });
+}
 export function proceduralFootprint(node) {
     const e = evaluateRecipe(node.recipe, node.parameters);
     const center = e.min.map((v, i) => (v + e.max[i]) / 2);
@@ -56,51 +79,68 @@ export function proceduralFootprint(node) {
     return { position, rotation: node.rotation, dimensions: e.dimensions };
 }
 function floorLift(node, nodes) {
-    if (!node.parentId || nodes[node.parentId]?.type !== 'level')
+    if (!node.parentId || nodes[node.parentId]?.type !== 'level' || !('position' in node))
         return 0;
+    const position = node.position;
+    const supportSlabId = node.supportSlabId;
+    const capability = nodeRegistry.get(node.type)?.capabilities.floorPlaced;
     const { slabs, walls } = levelSurfaces(nodes, node.parentId);
-    const ground = levelBaseElevationAt(nodes, node.parentId, node.position[0], node.position[2]);
-    if (node.supportSlabId === 'ground')
+    const ground = levelBaseElevationAt(nodes, node.parentId, position[0], position[2]);
+    if (supportSlabId === 'ground')
         return ground;
-    if (node.type === 'cabinet' || node.type === 'cabinet-module') {
-        const capability = nodeRegistry.get(node.type)?.capabilities.floorPlaced;
+    const supportSlabs = slabs.map((slab) => liftedManualSlab(nodes, slab));
+    const supportFor = (footprint) => selectSlabSupportForItem(supportSlabs, footprint, (slab) => getRenderableSlabPolygon(slab, { walls, siblingSlabs: supportSlabs }), { preferredSlabId: supportSlabId });
+    if (capability || node.type === 'cabinet' || node.type === 'cabinet-module') {
         const footprints = capability
             ? getFloorPlacedFootprints(capability, node, { nodes: nodes })
             : [];
-        const candidatesFor = (footprint) => slabs.filter((slab) => {
-            const position = footprint.position ?? node.position;
-            return (itemOverlapsPolygon(position, footprint.dimensions, footprint.rotation, getRenderableSlabPolygon(slab, { walls, siblingSlabs: slabs }), 0.005) && !(slab.holes ?? []).some((hole) => pointInPolygon(position[0], position[2], hole)));
-        });
-        const candidates = footprints.map(candidatesFor);
-        const pinned = candidates.flat().find((slab) => slab.id === node.supportSlabId);
+        const supports = footprints.map((footprint) => supportFor({ ...footprint, position: footprint.position ?? position }));
+        const preferred = supportSlabId ? nodes[supportSlabId] : undefined;
+        const prefersBase = preferred?.type === 'slab' && preferred.plateRole === 'base';
+        const pinned = supports.find((slab) => slab && (slab.id === supportSlabId || (prefersBase && slab.plateRole === 'platform')));
         if (pinned)
             return pinned.elevation ?? 0.05;
-        return candidates.length
-            ? Math.max(...candidates.map((slabs) => slabs.length ? Math.max(...slabs.map((slab) => slab.elevation ?? 0.05)) : ground))
+        return supports.length
+            ? Math.max(...supports.map((slab) => (slab ? (slab.elevation ?? 0.05) : ground)))
             : ground;
     }
+    if (!(isProceduralItem(node) || node.type === 'item' || node.type === 'shelf'))
+        return 0;
     const footprint = isProceduralItem(node)
         ? proceduralFootprint(node)
         : {
-            position: node.position,
+            position,
             dimensions: node.type === 'shelf'
                 ? [node.width, node.height, node.depth]
                 : node.asset.dimensions.map((v, i) => v * node.scale[i]),
             rotation: node.rotation,
         };
-    const candidates = slabs.filter((s) => {
-        const polygon = getRenderableSlabPolygon(s, { walls, siblingSlabs: slabs });
-        return (itemOverlapsPolygon(footprint.position, footprint.dimensions, footprint.rotation, polygon, 0.005) &&
-            !(s.holes ?? []).some((h) => pointInPolygon(footprint.position[0], footprint.position[2], h)));
-    });
-    const pinned = candidates.find((s) => s.id === node.supportSlabId);
-    return pinned
-        ? (pinned.elevation ?? 0.05)
-        : candidates.length
-            ? Math.max(...candidates.map((s) => s.elevation ?? 0.05))
-            : ground;
+    const support = supportFor(footprint);
+    return support ? (support.elevation ?? 0.05) : ground;
+}
+function nodeParentFrame(node, nodes, seen, options) {
+    if (!node.parentId)
+        return IDENTITY_FRAME;
+    let parentFrame = nodeLevelFrame(node.parentId, nodes, seen, options);
+    const parent = nodes[node.parentId];
+    if (isProceduralItem(parent) && parent.attachments[node.id] !== undefined) {
+        const surface = evaluateRecipe(parent.recipe, parent.parameters).surfaces.find((s) => s.id === parent.attachments[node.id]);
+        if (!surface)
+            throw new Error('Missing attachment surface');
+        parentFrame = composeFrames(parentFrame, frame(surface.position, surface.rotation));
+    }
+    return parentFrame;
 }
-export function nodeLevelFrame(id, nodes, seen = new Set()) {
+/** A node's frame in its level's coordinates. */
+export function nodeLevelFrame(id, nodes, seen = new Set(), options = {}) {
+    const cached = options.cache?.get(id);
+    if (cached)
+        return cached;
+    const resolved = resolveNodeLevelFrame(id, nodes, seen, options);
+    options.cache?.set(id, resolved);
+    return resolved;
+}
+function resolveNodeLevelFrame(id, nodes, seen, options) {
     if (seen.has(id) || seen.size > 32)
         throw new Error('Cyclic or excessively deep hosting graph');
     const node = nodes[id];
@@ -111,20 +151,41 @@ export function nodeLevelFrame(id, nodes, seen = new Set()) {
     seen.add(id);
     if (node.type === 'ceiling') {
         // Match the ceiling renderer's underside frame, including its 1 cm inset.
+        if (options.planOnly)
+            return IDENTITY_FRAME;
         return frame([0, resolveCeilingHeight(node, nodes) - 0.01, 0], [0, 0, 0]);
     }
     if (node.type === 'wall') {
+        const rotation = [
+            0,
+            -Math.atan2(node.end[1] - node.start[1], node.end[0] - node.start[0]),
+            0,
+        ];
+        if (options.planOnly)
+            return frame([node.start[0], 0, node.start[1]], rotation);
         const { slabs, walls } = levelSurfaces(nodes, node.parentId ?? '');
         const ground = levelBaseElevationAt(nodes, node.parentId ?? '', node.start[0], node.start[1]);
-        const support = computeWallSlabSupport(node, slabs, walls, node.supportSlabId, undefined, ground);
-        return frame([node.start[0], support.elevation + (node.supportOffset ?? 0), node.start[1]], [0, -Math.atan2(node.end[1] - node.start[1], node.end[0] - node.start[0]), 0]);
+        const support = computeWallSlabSupport(node, slabs, walls, node.supportSlabId, undefined, ground, nodes);
+        return frame([node.start[0], support.elevation + (node.supportOffset ?? 0), node.start[1]], rotation);
     }
     if (!(isProceduralItem(node) ||
         node.type === 'item' ||
         node.type === 'shelf' ||
         node.type === 'cabinet' ||
-        node.type === 'cabinet-module'))
-        throw new Error(`Unsupported host ${node.type}`);
+        node.type === 'cabinet-module')) {
+        const transform = node;
+        const rotation = typeof transform.rotation === 'number'
+            ? [0, transform.rotation, 0]
+            : transform.rotation;
+        const position = [...(transform.position ?? [0, 0, 0])];
+        const capability = nodeRegistry.get(node.type)?.capabilities.floorPlaced;
+        if (!capability?.applies || capability.applies(node)) {
+            if (!options.planOnly)
+                position[1] += floorLift(node, nodes);
+        }
+        const local = node.type === 'slab' ? IDENTITY_FRAME : frame(position, rotation ?? [0, 0, 0]);
+        return node.parentId ? composeFrames(nodeParentFrame(node, nodes, seen, options), local) : local;
+    }
     const pose = isProceduralItem(node)
         ? proceduralLocalPose(node, nodes)
         : {
@@ -134,14 +195,21 @@ export function nodeLevelFrame(id, nodes, seen = new Set()) {
     const parent = node.parentId ? nodes[node.parentId] : undefined;
     if (!node.parentId)
         return frame(pose.position, pose.rotation);
-    let parentFrame = nodeLevelFrame(node.parentId, nodes, seen);
-    if (isProceduralItem(parent) && parent.attachments[node.id] !== undefined) {
-        const surface = evaluateRecipe(parent.recipe, parent.parameters).surfaces.find((s) => s.id === parent.attachments[node.id]);
-        if (!surface)
-            throw new Error('Missing attachment surface');
-        parentFrame = composeFrames(parentFrame, frame(surface.position, surface.rotation));
+    if (node.type === 'item' && parent?.type === 'roof-segment' && node.roofFace) {
+        const face = getRoofWallFaceFrame(parent, node.roofFace);
+        const local = frame(roofFacePointToSegment(parent, node.roofFace, pose.position), pose.rotation);
+        local.axes = composeFrames(frame([0, 0, 0], [0, face.yaw, 0]), frame([0, 0, 0], pose.rotation)).axes;
+        return composeFrames(nodeLevelFrame(parent.id, nodes, seen, options), local);
     }
-    else if (parent?.type === 'level')
+    if (node.type === 'item' && parent?.type === 'block' && node.blockFaceId) {
+        const face = getBlockFaceFrame(parent.topology, node.blockFaceId);
+        if (face) {
+            const host = nodeLevelFrame(parent.id, nodes, seen, options);
+            return composeFrames(host, composeFrames({ position: face.origin, axes: [face.xAxis, face.yAxis, face.normal] }, frame(pose.position, pose.rotation)));
+        }
+    }
+    const parentFrame = nodeParentFrame(node, nodes, seen, options);
+    if (parent?.type === 'level' && !options.planOnly)
         pose.position[1] += floorLift(node, nodes);
     return composeFrames(parentFrame, frame(pose.position, pose.rotation));
 }
@@ -155,6 +223,12 @@ export function attachmentBounds(child) {
     const b = localBounds(child);
     return boundsOf(boxCorners(b.min, b.max).map((p) => transformPoint(frame(child.position, child.rotation), p)));
 }
+export function attachmentRegionsOverlap(a, b) {
+    return (a.min[0] < b.max[0] - 1e-6 &&
+        a.max[0] > b.min[0] + 1e-6 &&
+        a.min[2] < b.max[2] - 1e-6 &&
+        a.max[2] > b.min[2] + 1e-6);
+}
 function ceilingContainsFootprint(outer, footprint) {
     if (!footprint.every((p) => containsPoint(p, outer)))
         return false;
@@ -201,11 +275,15 @@ export function validateProceduralRelations(raw, nodes) {
             throw new Error('The top reference must be flush with the ceiling');
         const pose = proceduralLocalPose(node, nodes);
         const f = frame(pose.position, pose.rotation);
-        const b = boundsOf(boxCorners(evaluation.min, evaluation.max).map((p) => transformPoint(f, p)));
+        // Moving parts of a recessed design must stay within the storey through their whole travel.
+        const extent = evaluation.reach ?? evaluation;
+        const b = boundsOf(boxCorners(extent.min, extent.max).map((p) => transformPoint(f, p)));
         const height = nodeLevelFrame(ceiling.id, nodes).position[1];
         const level = ceiling.parentId ? nodes[ceiling.parentId] : undefined;
+        // A recessed design rises into the plenum through its own cut.
+        const recessed = evaluation.cuts.length > 0;
         if (b.min[1] + height < -1e-6 ||
-            b.max[1] > 1e-6 ||
+            (!recessed && b.max[1] > 1e-6) ||
             b.max[1] + height > getStoredLevelHeight(level?.type === 'level' ? level : {}) + 1e-6)
             throw new Error('The hanging design must fit below the ceiling within the level height');
         const footprint = [
@@ -220,6 +298,11 @@ export function validateProceduralRelations(raw, nodes) {
         if (!ceilingContainsFootprint(ceiling.polygon, footprint) ||
             ceiling.holes.some((hole) => polygonsOverlap(hole, footprint)))
             throw new Error('The hanging design must fit inside the ceiling, outside its holes');
+        const ring = proceduralCeilingHole(node);
+        if (ring &&
+            (!ceilingContainsFootprint(ceiling.polygon, ring) ||
+                ceiling.holes.some((hole) => polygonsOverlap(hole, ring))))
+            throw new Error('The design’s ceiling cut must fit inside the ceiling, outside its holes');
     }
     else if (node.recipe.mounting?.attachTo === 'wall-side' && !awaitingHost) {
         const wall = node.wallId ? nodes[node.wallId] : undefined;
@@ -260,11 +343,11 @@ export function validateProceduralRelations(raw, nodes) {
         if (!surfaceRegionContainsPoint({ kind: 'rect', size: [surface.size[0] / 2, surface.size[1] / 2] }, [(b.min[0] + b.max[0]) / 2, (b.min[2] + b.max[2]) / 2]) ||
             Math.abs(b.min[1]) > 1e-6)
             throw new Error(`The hosted item does not fit on ${surface.label}`);
+        // A fresh duplicate initially overlaps its source; only committed children occupy a surface.
+        if (child.metadata?.isNew === true)
+            continue;
         const occupied = regions.get(surface.id) ?? [];
-        if (occupied.some((a) => a.min[0] < b.max[0] - 1e-6 &&
-            a.max[0] > b.min[0] + 1e-6 &&
-            a.min[2] < b.max[2] - 1e-6 &&
-            a.max[2] > b.min[2] + 1e-6))
+        if (occupied.some((a) => attachmentRegionsOverlap(a, b)))
             throw new Error(`Another item occupies ${surface.label}`);
         occupied.push(b);
         regions.set(surface.id, occupied);