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

package/dist/wall/floorplan-move.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAGL,KAAK,mBAAmB,EAOxB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAmBzB;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAiRjE,CAAA"}
+{"version":3,"file":"floorplan-move.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan-move.ts"],"names":[],"mappings":"AAAA,OAAO,EAOL,KAAK,mBAAmB,EAaxB,KAAK,QAAQ,EAEd,MAAM,kBAAkB,CAAA;AAqCzB;;;;;;;;;;;;;;;;;;;;;;;;;;;GA2BG;AACH,eAAO,MAAM,uBAAuB,EAAE,mBAAmB,CAAC,QAAQ,CAuYjE,CAAA"}

package/dist/wall/floorplan-move.js

@@ -1,7 +1,13 @@
-import { getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, planWallMoveJunctions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
+import { detectSpacesForLevel, getCeilingClampBound, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, getStoredLevelHeight, planAutoCeilingsForLevel, planAutoSlabsForLevel, planWallMoveJunctions, useLiveNodeOverrides, useScene, } from '@pascal-app/core';
 import { getFloorplanWallThickness, getSegmentGridStep, isSegmentLongEnough, snapScalarToGrid, useWallMoveGhosts, } from '@pascal-app/editor';
 import { useViewer } from '@pascal-app/viewer';
 import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots, getWallsAfterUpdates, stripWallIsNewMetadata, } from './move-shared';
+function getLevelSlabs(levelId, nodes) {
+    return Object.values(nodes).filter((entry) => entry?.type === 'slab' && (entry.parentId ?? null) === levelId);
+}
+function getLevelCeilings(levelId, nodes) {
+    return Object.values(nodes).filter((entry) => entry?.type === 'ceiling' && (entry.parentId ?? null) === levelId);
+}
 /**
  * 2D floor-plan move handler for wall.
  *
@@ -26,10 +32,9 @@ import { buildBridgeWallCreates, buildBridgeWallPreviews, getLinkedWallSnapshots
  * overrides after the write lands so the system reads from the new
  * committed scene state.
  *
- * Auto-slab live preview and ghost bridge SVG previews — visible in
- * the 3D tool — are deliberately deferred. Slab polygons re-derive on
- * commit through the normal scene reactions; bridges appear at commit
- * time. Follow-up work to surface them mid-drag is tracked separately.
+ * Existing automatic slabs and ceilings receive live polygon overrides during
+ * the drag. New surfaces and removals stay deferred until commit because live
+ * overrides cannot represent nodes that do not exist in the scene.
  */
 export const wallFloorplanMoveTarget = ({ node }) => {
     const wallId = node.id;
@@ -72,8 +77,75 @@ export const wallFloorplanMoveTarget = ({ node }) => {
     let lastDelta = [0, 0];
     let lastNextStart = originalStart;
     let lastNextEnd = originalEnd;
+    const levelId = node.parentId ?? null;
+    const affectedIds = [wallId, ...linkedOriginals.map((wall) => wall.id)];
+    const affectedIdSet = new Set(affectedIds);
+    const touchedSurfaceIds = new Set();
+    let latestSurfacePlans = null;
+    const planSurfaces = (walls) => {
+        if (!levelId)
+            return null;
+        const sceneState = useScene.getState();
+        const levelWalls = walls.filter((wall) => (wall.parentId ?? null) === levelId);
+        const { roomPolygons } = detectSpacesForLevel(levelId, levelWalls);
+        const slabs = planAutoSlabsForLevel(roomPolygons, getLevelSlabs(levelId, sceneState.nodes));
+        const levelNode = sceneState.nodes[levelId];
+        const ceilings = planAutoCeilingsForLevel(roomPolygons, getLevelCeilings(levelId, sceneState.nodes), {
+            storeyHeight: levelNode?.type === 'level' ? getStoredLevelHeight(levelNode) : undefined,
+            ceilingClampBound: (polygon) => getCeilingClampBound(levelId, sceneState.nodes, polygon),
+        });
+        return { slabs, ceilings };
+    };
+    const publishSurfacePreviews = (walls) => {
+        const plans = planSurfaces(walls);
+        latestSurfacePlans = plans;
+        if (!plans)
+            return;
+        const entries = [];
+        for (const update of plans.slabs.update) {
+            if (update.data.polygon !== undefined) {
+                entries.push([update.id, { polygon: update.data.polygon }]);
+            }
+        }
+        for (const update of plans.ceilings.update) {
+            if (update.data.polygon !== undefined || update.data.height !== undefined) {
+                entries.push([update.id, update.data]);
+            }
+        }
+        const nextIds = new Set(entries.map(([id]) => id));
+        const overrides = useLiveNodeOverrides.getState();
+        const sceneState = useScene.getState();
+        for (const id of touchedSurfaceIds) {
+            if (nextIds.has(id))
+                continue;
+            overrides.clear(id);
+            sceneState.markDirty(id);
+            touchedSurfaceIds.delete(id);
+        }
+        if (entries.length > 0) {
+            overrides.setMany(entries);
+            for (const [id] of entries) {
+                touchedSurfaceIds.add(id);
+                if (!affectedIdSet.has(id)) {
+                    affectedIdSet.add(id);
+                    affectedIds.push(id);
+                }
+                sceneState.markDirty(id);
+            }
+        }
+    };
+    const clearSurfacePreviews = () => {
+        const overrides = useLiveNodeOverrides.getState();
+        const sceneState = useScene.getState();
+        for (const id of touchedSurfaceIds) {
+            overrides.clear(id);
+            sceneState.markDirty(id);
+        }
+        touchedSurfaceIds.clear();
+        latestSurfacePlans = null;
+    };
     const session = {
-        affectedIds: [wallId, ...linkedOriginals.map((w) => w.id)],
+        affectedIds,
         apply({ planPoint }) {
             if (!rawAnchor) {
                 rawAnchor = [planPoint[0], planPoint[1]];
@@ -168,6 +240,7 @@ export const wallFloorplanMoveTarget = ({ node }) => {
                 thickness: getFloorplanWallThickness(wall),
             }));
             useWallMoveGhosts.getState().setBridges(ghostBridges);
+            publishSurfacePreviews([...previewSceneWalls, ...bridgePreviews.map(({ wall }) => wall)]);
             // `WallSystem` only runs its rebuild pass when `dirtyNodes` is
             // non-empty. We're not writing to scene any more, but we still
             // need the system to pick up the live override changes — so
@@ -195,6 +268,7 @@ export const wallFloorplanMoveTarget = ({ node }) => {
                 overrides.clear(wallId);
                 for (const wall of linkedOriginals)
                     overrides.clear(wall.id);
+                clearSurfacePreviews();
                 return;
             }
             const plan = planWallMoveJunctions(linkedOriginals, originalStart, originalEnd, lastNextStart, lastNextEnd);
@@ -232,10 +306,48 @@ export const wallFloorplanMoveTarget = ({ node }) => {
                 existingWalls,
                 wallCount: Object.values(sceneState.nodes).filter((entry) => entry?.type === 'wall').length,
             });
+            const finalWalls = [
+                ...existingWalls,
+                ...bridgeCreates.map((entry) => ({ ...entry.node, parentId: entry.parentId ?? null })),
+            ];
+            const surfacePlans = planSurfaces(finalWalls) ?? latestSurfacePlans;
+            const surfaceUpdates = surfacePlans
+                ? [
+                    ...surfacePlans.slabs.update.map((entry) => ({
+                        id: entry.id,
+                        data: entry.data,
+                    })),
+                    ...surfacePlans.ceilings.update.map((entry) => ({
+                        id: entry.id,
+                        data: entry.data,
+                    })),
+                ]
+                : [];
+            const surfaceCreates = surfacePlans
+                ? [
+                    ...surfacePlans.slabs.create.map((slab) => ({
+                        node: slab,
+                        parentId: levelId,
+                    })),
+                    ...surfacePlans.ceilings.create.map((ceiling) => ({
+                        node: ceiling,
+                        parentId: levelId,
+                    })),
+                ]
+                : [];
+            const surfaceDeletes = surfacePlans
+                ? [
+                    ...surfacePlans.slabs.delete.map((id) => id),
+                    ...surfacePlans.ceilings.delete.map((id) => id),
+                ]
+                : [];
             sceneState.applyNodeChanges({
-                update: commitUpdates,
-                create: bridgeCreates,
-                delete: Array.from(collapsedLinkedWallIds),
+                update: [
+                    ...commitUpdates,
+                    ...surfaceUpdates,
+                ],
+                create: [...bridgeCreates, ...surfaceCreates],
+                delete: Array.from(new Set([...collapsedLinkedWallIds, ...surfaceDeletes])),
             });
             // Drop the live overrides now that the committed scene state
             // matches them — leaving them around would keep the system
@@ -246,6 +358,7 @@ export const wallFloorplanMoveTarget = ({ node }) => {
             overrides.clear(wallId);
             for (const wall of linkedOriginals)
                 overrides.clear(wall.id);
+            clearSurfacePreviews();
             // Swap ghosts → real walls: the bridges we just created render
             // through the registry layer, so the dashed previews aren't
             // needed any more. Clearing here (instead of waiting for the

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

@@ -1 +1 @@
-{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAOpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAKL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAA;AAWlC,QAAA,MAAM,yBAAyB,yDAA0D,CAAA;AAEzF,KAAK,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAA;AAexE,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,aAAa,CAAA;IACrB,cAAc,EAAE,aAAa,CAAA;IAC7B,iCAAiC,EAAE,MAAM,CAAC,sBAAsB,EAAE,6BAA6B,CAAC,CAAA;CACjG,CAAA;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,sBAAsB,CAqCzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAoMjG"}
+{"version":3,"file":"floorplan.d.ts","sourceRoot":"","sources":["../../src/wall/floorplan.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAEZ,KAAK,iBAAiB,EAEtB,KAAK,eAAe,EAOpB,KAAK,aAAa,EAClB,KAAK,QAAQ,EACd,MAAM,kBAAkB,CAAA;AAGzB,OAAO,EAKL,KAAK,6BAA6B,EACnC,MAAM,2BAA2B,CAAA;AAYlC,QAAA,MAAM,yBAAyB,yDAA0D,CAAA;AAEzF,KAAK,sBAAsB,GAAG,CAAC,OAAO,yBAAyB,CAAC,CAAC,MAAM,CAAC,CAAA;AAexE,MAAM,MAAM,sBAAsB,GAAG;IACnC,MAAM,EAAE,aAAa,CAAA;IACrB,cAAc,EAAE,aAAa,CAAA;IAC7B,iCAAiC,EAAE,MAAM,CAAC,sBAAsB,EAAE,6BAA6B,CAAC,CAAA;CACjG,CAAA;AAED,wBAAgB,6BAA6B,CAAC,EAC5C,QAAQ,EACR,KAAK,GACN,EAAE;IACD,QAAQ,EAAE,aAAa,CAAC,QAAQ,CAAC,CAAA;IACjC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;CAC/B,GAAG,sBAAsB,CAqCzB;AAED;;;;;;;;;;;;;;;GAeG;AACH,wBAAgB,kBAAkB,CAAC,IAAI,EAAE,QAAQ,EAAE,GAAG,EAAE,eAAe,GAAG,iBAAiB,GAAG,IAAI,CAkNjG"}

package/dist/wall/floorplan.js

@@ -2,6 +2,7 @@ import { calculateLevelMiters, getWallCurveFrameAt, getWallCurveLength, getWallM
 import { floorplanGeometryMetadata, readFloorplanContext } from '@pascal-app/editor';
 import { constructionDimensionStandard } from '../shared/construction-dimension-standards';
 import { buildCurvedWallConstructionDimensions, buildLevelWallConstructionDimensionPlan, buildWallConstructionDimensions, renderPlannedConstructionDimensions, } from './construction-dimensions';
+import { hasWallCurveBlockingChildren } from './curve-eligibility';
 // Same constants the legacy `getFloorplanWall` uses (editor/lib/floorplan/walls.ts).
 // Slightly exaggerates thin walls so the 2D plan stays legible without
 // drifting from BIM data. Inlined to keep nodes/wall self-contained.
@@ -190,6 +191,20 @@ export function buildWallFloorplan(node, ctx) {
             affordance: 'move-endpoint',
             payload: { wallId: node.id, endpoint: 'end' },
         });
+        const thicknessFrame = getWallCurveFrameAt(self, 0.5);
+        const halfVisibleThickness = getWallThickness(self) / 2;
+        for (const side of [1, -1]) {
+            children.push({
+                kind: 'endpoint-handle',
+                point: [
+                    thicknessFrame.point.x + thicknessFrame.normal.x * halfVisibleThickness * side,
+                    thicknessFrame.point.y + thicknessFrame.normal.y * halfVisibleThickness * side,
+                ],
+                state: 'idle',
+                affordance: 'thickness',
+                payload: { wallId: node.id, side },
+            });
+        }
         // Side move arrows — two directional arrows at the wall midpoint,
         // pointing outward perpendicular to the wall. Mirrors the 3D
         // `WallMoveSideHandles` arrows so users can grab the wall body
@@ -217,11 +232,10 @@ export function buildWallFloorplan(node, ctx) {
             }
         }
         // Curve sagitta handle — teal dot at the wall midpoint that
-        // controls `curveOffset`. Hidden when the wall hosts a door /
-        // window / wall-attached item: bending the wall would tear those
-        // children, so the legacy disables the handle in that case (see
-        // `wallCurveHandles.hasWallChildrenBlockingCurve`).
-        if (!hasCurveBlockingChildren(ctx.children)) {
+        // controls `curveOffset`. Hidden when the wall hosts an opening,
+        // lean-to extension, or wall-attached item because bending the host
+        // would tear the child geometry away from it.
+        if (!hasWallCurveBlockingChildren(ctx.children)) {
             const handle = getWallMidpointHandlePoint(node);
             children.push({
                 kind: 'endpoint-handle',
@@ -271,21 +285,3 @@ function wallDimensionDatumPolicy(reference) {
             return 'wall-face';
     }
 }
-/**
- * Doors, windows, and wall-attached items would tear if the wall bent
- * around them, so the curve sagitta handle hides when any of those
- * children exist. Mirrors the legacy
- * `wallCurveHandles.hasWallChildrenBlockingCurve` check.
- */
-function hasCurveBlockingChildren(children) {
-    for (const child of children) {
-        if (child.type === 'door' || child.type === 'window')
-            return true;
-        if (child.type === 'item') {
-            const attachTo = child.asset?.attachTo;
-            if (attachTo === 'wall' || attachTo === 'wall-side')
-                return true;
-        }
-    }
-    return false;
-}

package/dist/wall/move-shared.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"move-shared.d.ts","sourceRoot":"","sources":["../../src/wall/move-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAKd,QAAQ,EACR,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EACb,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAA;AAczB,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,WAE3D;AAMD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,CAQvF;AAED,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAA;AAEzC;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,aAAa,EAAE,aAAa,CAAA;IAC5B,WAAW,EAAE,aAAa,CAAA;CAC3B,GAAG,kBAAkB,EAAE,CA2CvB;AA0BD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,UAiB/C;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACpD,OAAO,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CAAE,CAAC,GACzD,QAAQ,EAAE,CASZ;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;CAClB,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC,CAkClD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;CAC1B,GAAG,KAAK,CAAC;IAAE,KAAK,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAqCrD"}
+{"version":3,"file":"move-shared.d.ts","sourceRoot":"","sources":["../../src/wall/move-shared.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,SAAS,EAKd,QAAQ,EACR,KAAK,kBAAkB,EACvB,KAAK,QAAQ,EACb,KAAK,aAAa,EAEnB,MAAM,kBAAkB,CAAA;AAczB,wBAAgB,SAAS,CAAC,CAAC,EAAE,aAAa,EAAE,CAAC,EAAE,aAAa,WAE3D;AAMD,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,QAAQ,CAAC,UAAU,CAAC,GAAG,QAAQ,CAAC,UAAU,CAAC,CAQvF;AAED,MAAM,MAAM,kBAAkB,GAAG,QAAQ,CAAA;AAEzC;;;;;GAKG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,YAAY,EAAE,MAAM,GAAG,IAAI,CAAA;IAC3B,aAAa,EAAE,aAAa,CAAA;IAC5B,WAAW,EAAE,aAAa,CAAA;CAC3B,GAAG,kBAAkB,EAAE,CA2CvB;AA4BD,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,UAiB/C;AAED,wBAAgB,oBAAoB,CAClC,KAAK,EAAE,UAAU,CAAC,OAAO,QAAQ,CAAC,QAAQ,CAAC,CAAC,OAAO,CAAC,EACpD,OAAO,EAAE,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,QAAQ,CAAC,CAAA;CAAE,CAAC,GACzD,QAAQ,EAAE,CASZ;AAED,wBAAgB,sBAAsB,CAAC,IAAI,EAAE;IAC3C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,SAAS,EAAE,MAAM,CAAA;CAClB,GAAG,KAAK,CAAC;IAAE,IAAI,EAAE,QAAQ,CAAC;IAAC,QAAQ,CAAC,EAAE,SAAS,CAAA;CAAE,CAAC,CAoClD;AAED,MAAM,MAAM,gBAAgB,GAAG;IAC7B,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,aAAa,CAAA;IACpB,GAAG,EAAE,aAAa,CAAA;IAClB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,wBAAgB,uBAAuB,CAAC,IAAI,EAAE;IAC5C,WAAW,EAAE,KAAK,CAAC,kBAAkB,CAAC,kBAAkB,CAAC,CAAC,CAAA;IAC1D,SAAS,EAAE,aAAa,CAAA;IACxB,OAAO,EAAE,aAAa,CAAA;IACtB,aAAa,EAAE,QAAQ,EAAE,CAAA;CAC1B,GAAG,KAAK,CAAC;IAAE,KAAK,EAAE,gBAAgB,CAAC;IAAC,IAAI,EAAE,QAAQ,CAAA;CAAE,CAAC,CAyCrD"}

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