@pascal-app/core 0.8.0 → 0.9.2

package/dist/hooks/spatial-grid/spatial-grid-sync.d.ts

@@ -1,4 +1,31 @@
-import { type AnyNode } from '../../schema';
+import type { AnyNode, AnyNodeId } from '../../schema';
 export declare function resolveLevelId(node: AnyNode, nodes: Record<string, AnyNode>): string;
+/**
+ * Walks the parent chain of `nodeId` and returns the id of the first ancestor
+ * whose `type` is `'level'`, or `null` when no level ancestor exists (orphaned
+ * node, top-level building node, etc.). Unlike `resolveLevelId`, this variant:
+ *
+ * - accepts a node **id** rather than a resolved node, saving the caller a
+ *   `nodes[id]` lookup when only the id is at hand.
+ * - returns `null` instead of the `'default'` fallback, which lets callers
+ *   distinguish "genuinely has no level" from "is a level".
+ * - has a loop guard (16 iterations) so a corrupt parent-chain cycle cannot
+ *   hang the frame loop.
+ */
+export declare function findLevelAncestorId(nodeId: AnyNodeId, nodes: Record<string, AnyNode>): string | null;
+/**
+ * Returns the building id that contains the given level, or `null` if
+ * the level is unparented or no enclosing building exists.
+ *
+ * Most scenes record the relationship via `level.parentId →
+ * building.id`, but older serialisations occasionally drop `parentId`
+ * even though the building's `children` array still references the
+ * level. The fallback scan covers that case.
+ *
+ * Used by `FloorplanRegistryLayer` to discover building-scoped kinds
+ * (`def.floorplanScope === 'building'`) without hardcoding any kind
+ * name in the editor layer.
+ */
+export declare function resolveBuildingForLevel(levelId: AnyNodeId, nodes: Record<AnyNodeId, AnyNode>): AnyNodeId | null;
 export declare function initSpatialGridSync(): () => void;
 //# sourceMappingURL=spatial-grid-sync.d.ts.map

package/dist/hooks/spatial-grid/spatial-grid-sync.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"spatial-grid-sync.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/spatial-grid-sync.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,OAAO,EAMb,MAAM,cAAc,CAAA;AAQrB,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAmBpF;AAKD,wBAAgB,mBAAmB,IAAI,MAAM,IAAI,CAgFhD"}
+{"version":3,"file":"spatial-grid-sync.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/spatial-grid-sync.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAsB,MAAM,cAAc,CAAA;AAS1E,wBAAgB,cAAc,CAAC,IAAI,EAAE,OAAO,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAmBpF;AAED;;;;;;;;;;;GAWG;AACH,wBAAgB,mBAAmB,CACjC,MAAM,EAAE,SAAS,EACjB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,GAAG,IAAI,CASf;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,uBAAuB,CACrC,OAAO,EAAE,SAAS,EAClB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,GAChC,SAAS,GAAG,IAAI,CAgBlB;AAKD,wBAAgB,mBAAmB,IAAI,MAAM,IAAI,CAgFhD"}

package/dist/hooks/spatial-grid/spatial-grid-sync.js

@@ -1,5 +1,7 @@
-import { getScaledDimensions, } from '../../schema';
+import { getRenderableSlabPolygon } from '../../lib/slab-polygon';
+import { nodeRegistry } from '../../registry';
 import useScene from '../../store/use-scene';
+import { getFloorPlacedFootprints } from './floor-placed-elevation';
 import { itemOverlapsPolygon, spatialGridManager, wallOverlapsPolygon, } from './spatial-grid-manager';
 export function resolveLevelId(node, nodes) {
     // If the node itself is a level
@@ -21,6 +23,62 @@ export function resolveLevelId(node, nodes) {
     }
     return 'default'; // fallback for orphaned items
 }
+/**
+ * Walks the parent chain of `nodeId` and returns the id of the first ancestor
+ * whose `type` is `'level'`, or `null` when no level ancestor exists (orphaned
+ * node, top-level building node, etc.). Unlike `resolveLevelId`, this variant:
+ *
+ * - accepts a node **id** rather than a resolved node, saving the caller a
+ *   `nodes[id]` lookup when only the id is at hand.
+ * - returns `null` instead of the `'default'` fallback, which lets callers
+ *   distinguish "genuinely has no level" from "is a level".
+ * - has a loop guard (16 iterations) so a corrupt parent-chain cycle cannot
+ *   hang the frame loop.
+ */
+export function findLevelAncestorId(nodeId, nodes) {
+    let current = nodes[nodeId];
+    let guard = 0;
+    while (current && guard < 16) {
+        if (current.type === 'level')
+            return current.id;
+        current = current.parentId ? nodes[current.parentId] : undefined;
+        guard += 1;
+    }
+    return null;
+}
+/**
+ * Returns the building id that contains the given level, or `null` if
+ * the level is unparented or no enclosing building exists.
+ *
+ * Most scenes record the relationship via `level.parentId →
+ * building.id`, but older serialisations occasionally drop `parentId`
+ * even though the building's `children` array still references the
+ * level. The fallback scan covers that case.
+ *
+ * Used by `FloorplanRegistryLayer` to discover building-scoped kinds
+ * (`def.floorplanScope === 'building'`) without hardcoding any kind
+ * name in the editor layer.
+ */
+export function resolveBuildingForLevel(levelId, nodes) {
+    const level = nodes[levelId];
+    if (!level)
+        return null;
+    const directParent = level.parentId ?? null;
+    if (directParent) {
+        const candidate = nodes[directParent];
+        if (candidate?.type === 'building')
+            return candidate.id;
+    }
+    for (const candidate of Object.values(nodes)) {
+        if (candidate?.type !== 'building')
+            continue;
+        const children = candidate.children;
+        if (Array.isArray(children) && children.includes(levelId)) {
+            return candidate.id;
+        }
+    }
+    return null;
+}
 // Call this once at app initialization. Returns an unsubscribe function that
 // detaches the scene-store listener (useful when the editor is unmounted so
 // the spatial grid singleton does not hold stale references to old scenes).
@@ -96,36 +154,69 @@ function arraysEqual(a, b) {
     return a.length === b.length && a.every((v, i) => v === b[i]);
 }
 /**
- * Mark all floor items, walls, and stairs that may be affected by a slab change as dirty.
+ * Mark all floor items and walls that may be affected by a slab change as dirty.
  */
 function markNodesOverlappingSlab(slab, nodes, markDirty) {
     if (slab.polygon.length < 3)
         return;
     const slabLevelId = resolveLevelId(slab, nodes);
+    // Walls follow the slab's RENDERED footprint (band-adopted edges reach
+    // the wall's outer face), so the dirty gate must test the same polygon
+    // `getSlabElevationForWall` will re-evaluate — a stored polygon that
+    // stops short of the wall body would otherwise never re-elevate it.
+    const levelWalls = [];
+    const siblingSlabs = [];
     for (const node of Object.values(nodes)) {
-        if (node.type === 'item') {
-            const item = node;
-            // Only floor items are affected by slabs
-            if (item.asset.attachTo)
-                continue;
-            if (resolveLevelId(node, nodes) !== slabLevelId)
-                continue;
-            if (itemOverlapsPolygon(item.position, getScaledDimensions(item), item.rotation, slab.polygon, 0.01)) {
-                markDirty(node.id);
-            }
+        if (node.type === 'wall' && resolveLevelId(node, nodes) === slabLevelId) {
+            levelWalls.push(node);
+        }
+        else if (node.type === 'slab' &&
+            node.id !== slab.id &&
+            resolveLevelId(node, nodes) === slabLevelId) {
+            siblingSlabs.push(node);
         }
-        else if (node.type === 'wall') {
+    }
+    const renderedPolygon = getRenderableSlabPolygon(slab, { walls: levelWalls, siblingSlabs });
+    for (const node of Object.values(nodes)) {
+        if (node.type === 'wall') {
             const wall = node;
             if (resolveLevelId(node, nodes) !== slabLevelId)
                 continue;
-            if (wallOverlapsPolygon(wall.start, wall.end, slab.polygon)) {
+            if (wallOverlapsPolygon({
+                start: wall.start,
+                end: wall.end,
+                curveOffset: wall.curveOffset ?? 0,
+                thickness: wall.thickness,
+            }, renderedPolygon)) {
                 markDirty(node.id);
             }
+            continue;
         }
-        else if (node.type === 'stair') {
-            if (resolveLevelId(node, nodes) !== slabLevelId)
-                continue;
-            markDirty(node.id);
+        // Generic floor-placed sweep: any registry kind that opts in via
+        // `capabilities.floorPlaced` (item / shelf / column / spawn / …)
+        // re-elevates through `<FloorElevationSystem>` when a slab below
+        // changes. We dirty-mark when the kind's footprint overlaps the
+        // changed slab so the system picks it up next frame.
+        const def = nodeRegistry.get(node.type);
+        const floorPlaced = def?.capabilities?.floorPlaced;
+        if (!floorPlaced)
+            continue;
+        if (floorPlaced.applies && !floorPlaced.applies(node))
+            continue;
+        const parentId = node.parentId;
+        const parent = parentId ? nodes[parentId] : null;
+        if (parent && parent.type !== 'level')
+            continue;
+        if (resolveLevelId(node, nodes) !== slabLevelId)
+            continue;
+        const position = node.position;
+        if (!position)
+            continue;
+        for (const footprint of getFloorPlacedFootprints(floorPlaced, node, { nodes })) {
+            if (itemOverlapsPolygon(footprint.position ?? position, footprint.dimensions, footprint.rotation, slab.polygon, 0.01)) {
+                markDirty(node.id);
+                break;
+            }
         }
     }
 }

package/dist/hooks/spatial-grid/wall-slab-overlap.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=wall-slab-overlap.test.d.ts.map

package/dist/hooks/spatial-grid/wall-slab-overlap.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-slab-overlap.test.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/wall-slab-overlap.test.ts"],"names":[],"mappings":""}

package/dist/hooks/spatial-grid/wall-slab-overlap.test.js

@@ -0,0 +1,363 @@
+import { describe, expect, it } from 'bun:test';
+import { SlabNode, WallNode } from '../../schema';
+import { computeWallSlabElevation, computeWallSlabSupport, wallOverlapsPolygon, } from './spatial-grid-manager';
+// 4×4 square slab, like an auto-slab derived from a room's wall centerlines.
+const SLAB = [
+    [0, 0],
+    [4, 0],
+    [4, 4],
+    [0, 4],
+];
+const wall = (start, end, curveOffset = 0) => ({
+    start,
+    end,
+    curveOffset,
+    thickness: 0.1,
+});
+describe('wallOverlapsPolygon', () => {
+    it('excludes perpendicular walls butting into the slab, on every side', () => {
+        // Regression: side-dependent ray-cast tie-breaking used to push some of
+        // these walls (depending on which slab edge they touched) but not others.
+        expect(wallOverlapsPolygon(wall([2, 4], [2, 7]), SLAB)).toBe(false); // top
+        expect(wallOverlapsPolygon(wall([2, 0], [2, -3]), SLAB)).toBe(false); // bottom
+        expect(wallOverlapsPolygon(wall([0, 2], [-3, 2]), SLAB)).toBe(false); // left
+        expect(wallOverlapsPolygon(wall([4, 2], [7, 2]), SLAB)).toBe(false); // right
+        // Reversed direction (endpoint order must not matter)
+        expect(wallOverlapsPolygon(wall([2, 7], [2, 4]), SLAB)).toBe(false);
+        expect(wallOverlapsPolygon(wall([-3, 2], [0, 2]), SLAB)).toBe(false);
+    });
+    it('includes walls lying on the slab boundary, on every side', () => {
+        expect(wallOverlapsPolygon(wall([0, 0], [4, 0]), SLAB)).toBe(true); // bottom
+        expect(wallOverlapsPolygon(wall([4, 0], [4, 4]), SLAB)).toBe(true); // right
+        expect(wallOverlapsPolygon(wall([4, 4], [0, 4]), SLAB)).toBe(true); // top
+        expect(wallOverlapsPolygon(wall([0, 4], [0, 0]), SLAB)).toBe(true); // left
+        // Partial edge coverage still counts
+        expect(wallOverlapsPolygon(wall([1, 0], [3, 0]), SLAB)).toBe(true);
+    });
+    it('includes a wall running past the slab if enough of it lies on the edge', () => {
+        // 4m on the edge + 6m beyond: whole wall follows the slab.
+        expect(wallOverlapsPolygon(wall([0, 0], [10, 0]), SLAB)).toBe(true);
+    });
+    it('excludes corner-only contact', () => {
+        expect(wallOverlapsPolygon(wall([4, 4], [6, 6]), SLAB)).toBe(false);
+        expect(wallOverlapsPolygon(wall([0, 0], [-2, -2]), SLAB)).toBe(false);
+    });
+    it('includes walls inside or crossing through the slab', () => {
+        expect(wallOverlapsPolygon(wall([1, 1], [3, 3]), SLAB)).toBe(true); // fully inside
+        expect(wallOverlapsPolygon(wall([-1, 2], [5, 2]), SLAB)).toBe(true); // crossing
+    });
+    it('uses wall thickness: a face grazing the slab counts, clear separation does not', () => {
+        // Centerline 4cm outside, body (half thickness 5cm) reaches the slab.
+        expect(wallOverlapsPolygon(wall([0, -0.04], [4, -0.04]), SLAB)).toBe(true);
+        // Centerline 1m outside: no contact.
+        expect(wallOverlapsPolygon(wall([0, -1], [4, -1]), SLAB)).toBe(false);
+    });
+    it('handles curved walls by their sampled body', () => {
+        // Chord below the slab, bowing into the slab interior (negative offset
+        // bows toward +z here).
+        expect(wallOverlapsPolygon(wall([0, -0.5], [4, -0.5], -1), SLAB)).toBe(true);
+        // Same chord bowing away from the slab: never touches it.
+        expect(wallOverlapsPolygon(wall([0, -0.5], [4, -0.5], 1), SLAB)).toBe(false);
+    });
+    it('supports the legacy (start, end, polygon) call shape', () => {
+        expect(wallOverlapsPolygon([1, 1], [3, 3], SLAB)).toBe(true);
+        expect(wallOverlapsPolygon([2, 4], [2, 7], SLAB)).toBe(false);
+    });
+});
+describe('computeWallSlabElevation', () => {
+    const parseWall = (start, end, thickness = 0.1) => WallNode.parse({ start, end, thickness });
+    it('lifts a wall standing on an auto slab stored at the centerlines', () => {
+        const walls = [
+            parseWall([0, 0], [4, 0]),
+            parseWall([4, 0], [4, 4]),
+            parseWall([4, 4], [0, 4]),
+            parseWall([0, 4], [0, 0]),
+        ];
+        const slab = SlabNode.parse({ polygon: SLAB, elevation: 0.1 });
+        const bottom = walls[0];
+        expect(computeWallSlabElevation({ start: bottom.start, end: bottom.end, thickness: bottom.thickness }, [slab], walls)).toBeCloseTo(0.1);
+    });
+    it('lifts a wall whose body a legacy stored polygon falls short of', () => {
+        // Legacy hand-adjusted slab: edges 6cm inside the wall centerlines —
+        // 1cm short of even the inner faces, so the STORED polygon never
+        // touches the wall body and the old stored-polygon test returned 0.
+        // The rendered footprint band-adopts the edges out to the outer
+        // faces, so the wall stands on the slab.
+        const walls = [
+            parseWall([0, 0], [4, 0]),
+            parseWall([4, 0], [4, 4]),
+            parseWall([4, 4], [0, 4]),
+            parseWall([0, 4], [0, 0]),
+        ];
+        const slab = SlabNode.parse({
+            polygon: [
+                [0.06, 0.06],
+                [3.94, 0.06],
+                [3.94, 3.94],
+                [0.06, 3.94],
+            ],
+            elevation: 0.1,
+        });
+        const bottom = walls[0];
+        expect(computeWallSlabElevation({ start: bottom.start, end: bottom.end, thickness: bottom.thickness }, [slab], walls)).toBeCloseTo(0.1);
+    });
+    it('does not lift a wall clearly off the slab', () => {
+        const walls = [parseWall([0, 0], [4, 0])];
+        const slab = SlabNode.parse({ polygon: SLAB, elevation: 0.1 });
+        expect(computeWallSlabElevation({ start: [0, -1], end: [4, -1], thickness: 0.1 }, [slab], walls)).toBe(0);
+    });
+    it('ignores a slab when the wall runs entirely inside a hole', () => {
+        const walls = [parseWall([1, 2], [3, 2])];
+        const slab = SlabNode.parse({
+            polygon: SLAB,
+            elevation: 0.1,
+            holes: [
+                [
+                    [0.5, 0.5],
+                    [3.5, 0.5],
+                    [3.5, 3.5],
+                    [0.5, 3.5],
+                ],
+            ],
+        });
+        expect(computeWallSlabElevation({ start: [1, 2], end: [3, 2], thickness: 0.1 }, [slab], walls)).toBe(0);
+    });
+    it('keeps a wall on the lower slab when a higher slab only reaches one endpoint', () => {
+        // The floating-wall bug: a wall standing on the low room whose far
+        // endpoint pokes 0.2m onto a raised platform must NOT lift wholesale.
+        const low = SlabNode.parse({ polygon: SLAB, elevation: 0.05 });
+        const high = SlabNode.parse({
+            polygon: [
+                [4, 0],
+                [8, 0],
+                [8, 4],
+                [4, 4],
+            ],
+            elevation: 0.6,
+        });
+        expect(computeWallSlabElevation({ start: [0.5, 2], end: [4.2, 2], thickness: 0.1 }, [low, high], [])).toBeCloseTo(0.05);
+    });
+    it('keeps a curved wall on the lower slab when a higher slab only reaches its end', () => {
+        const low = SlabNode.parse({ polygon: SLAB, elevation: 0.05 });
+        const high = SlabNode.parse({
+            polygon: [
+                [4, 0],
+                [8, 0],
+                [8, 4],
+                [4, 4],
+            ],
+            elevation: 0.6,
+        });
+        expect(computeWallSlabElevation({ start: [0.5, 2], end: [4.2, 2], curveOffset: 0.5, thickness: 0.1 }, [low, high], [])).toBeCloseTo(0.05);
+    });
+    it('lifts a wall standing fully on a raised platform', () => {
+        const platform = SlabNode.parse({ polygon: SLAB, elevation: 0.6 });
+        expect(computeWallSlabElevation({ start: [1, 2], end: [3, 2], thickness: 0.1 }, [platform], [])).toBeCloseTo(0.6);
+    });
+    it('lifts a wall half on a raised platform, half in the air, onto the platform', () => {
+        // No elevation reaches majority (only 39% supported), so the
+        // best-covered slab wins — the only alternative would bury the
+        // supported half inside the platform.
+        const platform = SlabNode.parse({ polygon: SLAB, elevation: 0.6 });
+        expect(computeWallSlabElevation({ start: [0.1, 2], end: [10.1, 2], thickness: 0.1 }, [platform], [])).toBeCloseTo(0.6);
+    });
+    it('pools same-elevation slabs so a shared wall follows their common level', () => {
+        // Rooms A and B at the same elevation each cover exactly half the
+        // wall (interior edges seam at the x=2 midline); a raised slab covers
+        // just under half. Pooled, the common level covers 100% and must
+        // win — without pooling the raised slab's 0.4975 would beat either
+        // half alone.
+        const roomA = SlabNode.parse({
+            polygon: [
+                [0, 0],
+                [2, 0],
+                [2, 4],
+                [0, 4],
+            ],
+            elevation: 0.1,
+        });
+        const roomB = SlabNode.parse({
+            polygon: [
+                [2, 0],
+                [4, 0],
+                [4, 4],
+                [2, 4],
+            ],
+            elevation: 0.1,
+        });
+        const raised = SlabNode.parse({
+            polygon: [
+                [1.0, 1],
+                [2.99, 1],
+                [2.99, 3],
+                [1.0, 3],
+            ],
+            elevation: 0.6,
+        });
+        expect(computeWallSlabElevation({ start: [0, 2], end: [4, 2], thickness: 0.1 }, [roomA, roomB, raised], [])).toBeCloseTo(0.1);
+    });
+    it('prefers the higher of two majority-supporting slabs (platform stacked on a floor)', () => {
+        const floor = SlabNode.parse({
+            polygon: [
+                [0, 0],
+                [8, 0],
+                [8, 4],
+                [0, 4],
+            ],
+            elevation: 0.05,
+        });
+        const platform = SlabNode.parse({
+            polygon: [
+                [0, 0],
+                [5, 0],
+                [5, 4],
+                [0, 4],
+            ],
+            elevation: 0.6,
+        });
+        // Wall 6m long: floor covers all of it, platform covers ~2/3 — both
+        // majorities, and the wall physically rests on the platform.
+        expect(computeWallSlabElevation({ start: [1, 2], end: [7, 2], thickness: 0.1 }, [floor, platform], [])).toBeCloseTo(0.6);
+    });
+    it('keeps a wall pushed up on a raised platform above a coincident floor', () => {
+        const floor = SlabNode.parse({ polygon: SLAB, elevation: 0.05 });
+        const platform = SlabNode.parse({ polygon: SLAB, elevation: 0.6 });
+        expect(computeWallSlabSupport({ start: [1, 2], end: [3, 2], thickness: 0.1 }, [floor, platform], [])).toEqual({
+            elevation: 0.6,
+            baseElevation: 0.6,
+            baseSegments: [{ start: 0, end: 1, elevation: 0.6 }],
+        });
+    });
+    it('fills down only when a lower support is exposed beyond a partial platform', () => {
+        const floor = SlabNode.parse({ polygon: SLAB, elevation: 0.05 });
+        const platform = SlabNode.parse({
+            polygon: [
+                [0, 0],
+                [2.5, 0],
+                [2.5, 4],
+                [0, 4],
+            ],
+            elevation: 0.6,
+        });
+        expect(computeWallSlabSupport({ start: [0.5, 2], end: [3.5, 2], thickness: 0.1 }, [floor, platform], [])).toEqual({
+            elevation: 0.6,
+            baseElevation: 0.05,
+            baseSegments: [
+                { start: 0, end: 2 / 3, elevation: 0.6 },
+                { start: 2 / 3, end: 1, elevation: 0.05 },
+            ],
+        });
+    });
+    it('keeps a shared wall on the higher slab that carries the full wall band', () => {
+        const sharedWall = parseWall([4, 0], [4, 4]);
+        const low = SlabNode.parse({ polygon: SLAB, elevation: 0.05 });
+        const high = SlabNode.parse({
+            polygon: [
+                [4, 0],
+                [8, 0],
+                [8, 4],
+                [4, 4],
+            ],
+            elevation: 0.6,
+        });
+        expect(computeWallSlabSupport({ start: sharedWall.start, end: sharedWall.end, thickness: sharedWall.thickness }, [low, high], [sharedWall])).toEqual({
+            elevation: 0.6,
+            baseElevation: 0.6,
+            baseSegments: [{ start: 0, end: 1, elevation: 0.6 }],
+        });
+    });
+    it('profiles an offset-room wall as high-only, shared, then low-only', () => {
+        const sharedWall = parseWall([4, 0], [4, 4.5]);
+        const walls = [
+            parseWall([0, 0], [4, 0]),
+            parseWall([0, 3], [0, 0]),
+            parseWall([0, 3], [4, 3]),
+            sharedWall,
+            parseWall([4, 1.5], [8, 1.5]),
+            parseWall([8, 1.5], [8, 4.5]),
+            parseWall([8, 4.5], [4, 4.5]),
+        ];
+        const high = SlabNode.parse({
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            elevation: 0.6,
+        });
+        const low = SlabNode.parse({
+            polygon: [
+                [4, 1.5],
+                [8, 1.5],
+                [8, 4.5],
+                [4, 4.5],
+            ],
+            elevation: 0.05,
+        });
+        expect(computeWallSlabSupport({ start: sharedWall.start, end: sharedWall.end, thickness: sharedWall.thickness }, [high, low], walls)).toEqual({
+            elevation: 0.6,
+            baseElevation: 0.05,
+            baseSegments: [
+                { start: 0, end: 3.05 / 4.5, elevation: 0.6 },
+                { start: 3.05 / 4.5, end: 1, elevation: 0.05 },
+            ],
+        });
+    });
+    it('lifts a tiny stub wall standing fully on a slab', () => {
+        const slab = SlabNode.parse({ polygon: SLAB, elevation: 0.3 });
+        expect(computeWallSlabElevation({ start: [2, 2], end: [2.08, 2], thickness: 0.1 }, [slab], [])).toBeCloseTo(0.3);
+    });
+    it('does not lift a wall whose run over a higher slab is mostly inside a hole', () => {
+        const low = SlabNode.parse({
+            polygon: [
+                [0, 0],
+                [8, 0],
+                [8, 4],
+                [0, 4],
+            ],
+            elevation: 0.05,
+        });
+        const high = SlabNode.parse({
+            polygon: [
+                [0, 0],
+                [8, 0],
+                [8, 4],
+                [0, 4],
+            ],
+            elevation: 0.6,
+            holes: [
+                [
+                    [0.5, 0],
+                    [8, 0],
+                    [8, 4],
+                    [0.5, 4],
+                ],
+            ],
+        });
+        // Net high support is only x ∈ [0, 0.5]; the low slab carries the wall.
+        expect(computeWallSlabElevation({ start: [0, 2], end: [8, 2], thickness: 0.1 }, [low, high], [])).toBeCloseTo(0.05);
+    });
+    it('keeps support for a wall running along a hole rim', () => {
+        // Hole boundaries count as solid: the wall ringing a stairwell sits
+        // on the rim, its outer face on solid slab.
+        const slab = SlabNode.parse({
+            polygon: [
+                [0, 0],
+                [6, 0],
+                [6, 6],
+                [0, 6],
+            ],
+            elevation: 0.4,
+            holes: [
+                [
+                    [2, 2],
+                    [4, 2],
+                    [4, 4],
+                    [2, 4],
+                ],
+            ],
+        });
+        expect(computeWallSlabElevation({ start: [2, 2], end: [4, 2], thickness: 0.1 }, [slab], [])).toBeCloseTo(0.4);
+    });
+});

package/dist/index.d.ts

@@ -1,24 +1,52 @@
-export type { BuildingEvent, CameraControlEvent, CameraControlFitSceneEvent, CeilingEvent, ColumnEvent, DoorEvent, EventSuffix, FenceEvent, GridEvent, ItemEvent, LevelEvent, NodeEvent, RoofEvent, RoofSegmentEvent, SiteEvent, SlabEvent, SpawnEvent, StairEvent, StairSegmentEvent, WallEvent, WindowEvent, ZoneEvent, } from './events/bus';
+export type { BoxVentEvent, BuildingEvent, CabinetEvent, CabinetModuleEvent, CameraControlEvent, CameraControlFitSceneEvent, CeilingEvent, ChimneyEvent, ColumnEvent, DoorEvent, DormerEvent, ElevatorEvent, EventSuffix, FenceEvent, GridEvent, GuideEvent, GutterEvent, ItemEvent, LevelEvent, MeasurementEvent, NodeEvent, RidgeVentEvent, RoofEvent, RoofSegmentEvent, RoomPresetCreateEvent, ScanEvent, ShelfEvent, SiteEvent, SkylightEvent, SlabEvent, SolarPanelEvent, SpawnEvent, StairEvent, StairSegmentEvent, WallEvent, WindowEvent, ZoneEvent, } from './events/bus';
 export { emitter, eventSuffixes } from './events/bus';
+export { type ItemClipEntry, itemClipRegistry } from './hooks/scene-registry/item-clip-registry';
 export { sceneRegistry, useRegistry, } from './hooks/scene-registry/scene-registry';
-export { pointInPolygon, spatialGridManager } from './hooks/spatial-grid/spatial-grid-manager';
-export { initSpatialGridSync, resolveLevelId, } from './hooks/spatial-grid/spatial-grid-sync';
+export { type FloorPlacedElevationArgs, getFloorPlacedElevation, getFloorPlacedFootprints, getFloorStackedPosition, } from './hooks/spatial-grid/floor-placed-elevation';
+export { pointInPolygon, spatialGridManager, type WallSlabSupportSegment, } from './hooks/spatial-grid/spatial-grid-manager';
+export { findLevelAncestorId, initSpatialGridSync, resolveBuildingForLevel, resolveLevelId, } from './hooks/spatial-grid/spatial-grid-sync';
 export { useSpatialQuery } from './hooks/spatial-grid/use-spatial-query';
 export { loadAssetUrl, saveAsset } from './lib/asset-storage';
 export { clampDoorOperationState, getDoorRenderOpenAmount, getGarageVisibleOpeningRatio, isOperationDoorType, SECTIONAL_GARAGE_RENDER_OPEN_SCALE, } from './lib/door-operation';
-export { getRenderableSlabPolygon } from './lib/slab-polygon';
-export { detectSpacesForLevel, initSpaceDetectionSync, type Space, wallTouchesOthers, } from './lib/space-detection';
-export { getCatalogMaterialById, getLibraryMaterialIdFromRef, getMaterialPresetByRef, getMaterialsForCategory, LIBRARY_MATERIAL_REF_PREFIX, MATERIAL_CATALOG, MATERIAL_CATEGORIES, type MaterialCatalogItem, type MaterialCategory, toLibraryMaterialRef, } from './material-library';
+export { getDefaultLevelName, getLevelDisplayName } from './lib/level-name';
+export { areMeasurementPointsCoplanar, closestMeasurementFeatureBinding, MEASUREMENT_PLANAR_TOLERANCE, measurementAnchorFallback, measurementAngle, measurementArea, measurementAreaVector, measurementCentroid, measurementDistance, measurementFeatureLength, measurementNormal, measurementPerimeter, measurementPrismVolume, measurementReferenceNodeIds, remapMeasurementReferences, } from './lib/measurement-geometry';
+export { type Point2D as PolygonPoint2D, pointInPolygon as pointInPolygon2D, pointOnSegment, polygonContainsPolygon, polygonsIntersect, polygonsOverlap, segmentsIntersect, } from './lib/polygon-relations';
+export { resolveSelectionProxyId, selectionProxyIdFromMetadata } from './lib/selection-proxy';
+export { getRenderableSlabPolygon, type SlabEdgeWallBandSnap, type SlabPolygonContext, slabPolygonContextFromGeometry, snapSlabEdgeToWallBand, } from './lib/slab-polygon';
+export { deriveSlotId, isSlotMaterialName, SLOT_MATERIAL_PREFIX, slotLabelFromId, } from './lib/slots';
+export { type AutoCeilingPlanningContext, type AutoCeilingSyncPlan, type AutoSlabSyncPlan, type AutoZoneSyncPlan, detectSpacesForLevel, initSpaceDetectionSync, isSpaceDetectionPaused, pauseSpaceDetection, planAutoCeilingsForLevel, planAutoSlabsForLevel, planAutoZonesForLevel, projectAutoSlabsForPlan, resolveAutoZonePolygon, resumeSpaceDetection, type Space, type SpaceBoundaryFace, wallClosesRoom, wallTouchesOthers, } from './lib/space-detection';
+export { closestOnSegment, collectLevelWallSegments, nearestWallSegment, WALL_SNAP_DISTANCE_M, type WallSegment, type WallSegmentClosest, } from './lib/wall-distance';
+export { deriveZoneQuantityReport, type ZoneQuantityReport, type ZoneQuantityValue, } from './lib/zone-quantities';
+export { getCatalogMaterialById, getLibraryMaterialIdFromRef, getMaterialPresetByRef, getMaterialsForCategory, getSceneMaterialIdFromRef, LIBRARY_MATERIAL_REF_PREFIX, MATERIAL_CATALOG, MATERIAL_CATEGORIES, MATERIAL_SURFACES, type MaterialCatalogItem, type MaterialCategory, type MaterialRef, type MaterialSurface, type ParsedMaterialRef, parseMaterialRef, SCENE_MATERIAL_REF_PREFIX, toLibraryMaterialRef, toSceneMaterialRef, } from './material-library';
+export type { FloorPlacedFootprint, FloorPlacedFootprintContext, FloorPlacedFootprintResolver, FloorPlacedFootprintsResolver, } from './registry';
+export * from './registry';
 export * from './schema';
-export { getSceneHistoryPauseDepth, pauseSceneHistory, resetSceneHistoryPauseDepth, resumeSceneHistory, } from './store/history-control';
-export { type ControlValue, type DoorAnimationState, type DoorInteractiveState, type ItemInteractiveState, useInteractive, type WindowAnimationState, type WindowInteractiveState, } from './store/use-interactive';
+export * from './services';
+export { isMovable, movePlanToward, moveToward, resolveMovable } from './services/movement';
+export { getSceneHistoryPauseDepth, pauseSceneHistory, resetSceneHistoryPauseDepth, resumeSceneHistory, runAsSingleSceneHistoryStep, } from './store/history-control';
+export { type ControlValue, type DoorAnimationState, type DoorInteractiveState, type ElevatorInteractiveState, type ElevatorPhase, type ItemInteractiveState, type SkylightAnimationState, type SkylightInteractiveState, useInteractive, type WindowAnimationState, type WindowInteractiveState, } from './store/use-interactive';
+export { default as useLiveNodeOverrides, getEffectiveNode, type LiveNodeOverrides, } from './store/use-live-node-overrides';
 export { default as useLiveTransforms, type LiveTransform } from './store/use-live-transforms';
 export { clearSceneHistory, default as useScene } from './store/use-scene';
+export { resolveElevatorDispatchTarget } from './systems/elevator/elevator-dispatch';
+export { type ElevatorDoorSide, getElevatorCabCenterZ, getElevatorCabDepth, getElevatorCabWidth, getElevatorDoorLeafSides, getElevatorDoorLeafWidth, getElevatorDoorLeafX, getElevatorShaftDepth, getElevatorShaftWallThickness, getElevatorShaftWidth, getResolvedElevatorDoorPanelStyle, getResolvedElevatorDoorStyle, getResolvedElevatorShaftStyle, } from './systems/elevator/elevator-geometry';
+export { syncAutoElevatorOpenings } from './systems/elevator/elevator-opening-sync';
+export { ElevatorOpeningSystem } from './systems/elevator/elevator-opening-system';
+export { createElevatorInteractiveState, openElevatorDoor, openElevatorDoorState, queueElevatorRequest, requestElevatorLevel, stepElevatorRuntimeState, stepElevatorRuntimes, } from './systems/elevator/elevator-runtime';
+export { ElevatorRuntimeSystem } from './systems/elevator/elevator-runtime-system';
+export { DEFAULT_ELEVATOR_LEVEL_HEIGHT, type ElevatorLevelEntry, getElevatorLevelHeight, resolveElevatorBuildingLevels, resolveElevatorLevels, resolveElevatorServiceLevelIds, resolveElevatorServiceLevels, } from './systems/elevator/elevator-service';
+export { getFenceCenterlineFrameAt, getFenceCenterlineLength, sampleFenceCenterline, } from './systems/fence/fence-centerline';
+export { getFenceControlHandle, getFenceSplineFrameAt, getFenceSplineLength, getTwoPointFenceCurveTangents, isSplineFence, sampleFenceSpline, } from './systems/fence/fence-spline';
+export { type StairFootprintAABB, stairFootprintAABB } from './systems/stair/stair-footprint';
+export { createSurfaceOpeningPreviewController } from './systems/stair/stair-opening-preview';
 export { syncAutoStairOpenings } from './systems/stair/stair-opening-sync';
+export { StairOpeningSystem } from './systems/stair/stair-opening-system';
 export { getClampedWallCurveOffset, getMaxWallCurveOffset, getWallChordFrame, getWallCurveFrameAt, getWallCurveLength, getWallMidpointHandlePoint, getWallStraightSnapOffset, getWallSurfacePolygon, isCurvedWall, normalizeWallCurveOffset, sampleWallCenterline, } from './systems/wall/wall-curve';
 export { DEFAULT_WALL_HEIGHT, DEFAULT_WALL_THICKNESS, getWallPlanFootprint, getWallThickness, } from './systems/wall/wall-footprint';
 export { calculateLevelMiters, getAdjacentWallIds, getWallMiterBoundaryPoints, type Point2D, pointToKey, type WallMiterBoundaryPoints, type WallMiterData, } from './systems/wall/wall-mitering';
+export { constrainWallMoveDeltaToAxis, getLinkedWallUpdates, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, planWallMoveJunctions, type WallMoveAxis, type WallMoveBridgePlan, type WallMoveJunctionPlan, type WallMoveLinkedWallTargetPlan, type WallPlanPoint, } from './systems/wall/wall-move';
 export type { SceneGraph } from './utils/clone-scene-graph';
 export { cloneLevelSubtree, cloneSceneGraph, forkSceneGraph } from './utils/clone-scene-graph';
 export { isObject } from './utils/types';
+export { type BuildStats, type ParsedBuildJson, type SchemaIssue, type ValidateBuildJsonResult, type ValidationIssue, type ValidationSeverity, validateBuildJson, } from './validation/validate-build-json';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,aAAa,EACb,kBAAkB,EAClB,0BAA0B,EAC1B,YAAY,EACZ,WAAW,EACX,SAAS,EACT,WAAW,EACX,UAAU,EACV,SAAS,EACT,SAAS,EACT,UAAU,EACV,SAAS,EACT,SAAS,EACT,gBAAgB,EAChB,SAAS,EACT,SAAS,EACT,UAAU,EACV,UAAU,EACV,iBAAiB,EACjB,SAAS,EACT,WAAW,EACX,SAAS,GACV,MAAM,cAAc,CAAA;AACrB,OAAO,EAAE,OAAO,EAAE,aAAa,EAAE,MAAM,cAAc,CAAA;AACrD,OAAO,EACL,aAAa,EACb,WAAW,GACZ,MAAM,uCAAuC,CAAA;AAC9C,OAAO,EAAE,cAAc,EAAE,kBAAkB,EAAE,MAAM,2CAA2C,CAAA;AAC9F,OAAO,EACL,mBAAmB,EACnB,cAAc,GACf,MAAM,wCAAwC,CAAA;AAC/C,OAAO,EAAE,eAAe,EAAE,MAAM,wCAAwC,CAAA;AACxE,OAAO,EAAE,YAAY,EAAE,SAAS,EAAE,MAAM,qBAAqB,CAAA;AAC7D,OAAO,EACL,uBAAuB,EACvB,uBAAuB,EACvB,4BAA4B,EAC5B,mBAAmB,EACnB,kCAAkC,GACnC,MAAM,sBAAsB,CAAA;AAC7B,OAAO,EAAE,wBAAwB,EAAE,MAAM,oBAAoB,CAAA;AAC7D,OAAO,EACL,oBAAoB,EACpB,sBAAsB,EACtB,KAAK,KAAK,EACV,iBAAiB,GAClB,MAAM,uBAAuB,CAAA;AAC9B,OAAO,EACL,sBAAsB,EACtB,2BAA2B,EAC3B,sBAAsB,EACtB,uBAAuB,EACvB,2BAA2B,EAC3B,gBAAgB,EAChB,mBAAmB,EACnB,KAAK,mBAAmB,EACxB,KAAK,gBAAgB,EACrB,oBAAoB,GACrB,MAAM,oBAAoB,CAAA;AAC3B,cAAc,UAAU,CAAA;AACxB,OAAO,EACL,yBAAyB,EACzB,iBAAiB,EACjB,2BAA2B,EAC3B,kBAAkB,GACnB,MAAM,yBAAyB,CAAA;AAChC,OAAO,EACL,KAAK,YAAY,EACjB,KAAK,kBAAkB,EACvB,KAAK,oBAAoB,EACzB,KAAK,oBAAoB,EACzB,cAAc,EACd,KAAK,oBAAoB,EACzB,KAAK,sBAAsB,GAC5B,MAAM,yBAAyB,CAAA;AAChC,OAAO,EAAE,OAAO,IAAI,iBAAiB,EAAE,KAAK,aAAa,EAAE,MAAM,6BAA6B,CAAA;AAC9F,OAAO,EAAE,iBAAiB,EAAE,OAAO,IAAI,QAAQ,EAAE,MAAM,mBAAmB,CAAA;AAC1E,OAAO,EAAE,qBAAqB,EAAE,MAAM,oCAAoC,CAAA;AAC1E,OAAO,EACL,yBAAyB,EACzB,qBAAqB,EACrB,iBAAiB,EACjB,mBAAmB,EACnB,kBAAkB,EAClB,0BAA0B,EAC1B,yBAAyB,EACzB,qBAAqB,EACrB,YAAY,EACZ,wBAAwB,EACxB,oBAAoB,GACrB,MAAM,2BAA2B,CAAA;AAClC,OAAO,EACL,mBAAmB,EACnB,sBAAsB,EACtB,oBAAoB,EACpB,gBAAgB,GACjB,MAAM,+BAA+B,CAAA;AACtC,OAAO,EACL,oBAAoB,EACpB,kBAAkB,EAClB,0BAA0B,EAC1B,KAAK,OAAO,EACZ,UAAU,EACV,KAAK,uBAAuB,EAC5B,KAAK,aAAa,GACnB,MAAM,8BAA8B,CAAA;AACrC,YAAY,EAAE,UAAU,EAAE,MAAM,2BAA2B,CAAA;AAC3D,OAAO,EAAE,iBAAiB,EAAE,eAAe,EAAE,cAAc,EAAE,MAAM,2BAA2B,CAAA;AAC9F,OAAO,EAAE,QAAQ,EAAE,MAAM,eAAe,CAAA"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"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"}