@pascal-app/core 1.0.0-beta.4 → 1.0.0-beta.5

package/dist/store/use-scene.js

@@ -7,7 +7,7 @@ import { BuildingNode } from '../schema';
 import { generateCollectionId } from '../schema/collections';
 import { DoorNode as DoorNodeSchema } from '../schema/nodes/door';
 import { ElevatorNode as ElevatorNodeSchema } from '../schema/nodes/elevator';
-import { LevelNode } from '../schema/nodes/level';
+import { LevelNode, normalizeLevelBaseElevation } from '../schema/nodes/level';
 import { getPitchFromActiveRoofHeight, } from '../schema/nodes/roof-segment';
 import { segmentPointToRoofWallFace } from '../schema/nodes/roof-segment-walls';
 import { ShelfNode as ShelfNodeSchema } from '../schema/nodes/shelf';
@@ -18,12 +18,9 @@ import { getEffectiveWallSurfaceMaterial } from '../schema/nodes/wall';
 import { WindowNode as WindowNodeSchema } from '../schema/nodes/window';
 import { generateSceneMaterialId, SceneMaterial, } from '../schema/scene-material';
 import { AnyNode as AnyNodeSchema } from '../schema/types';
-import { deriveLegacyLevelHeight } from '../services/level-height';
-import { getCeilingClampBound } from '../services/storey';
-import { computeWallSlabSupport } from '../systems/slab/slab-support';
-import { DEFAULT_WALL_HEIGHT } from '../systems/wall/wall-footprint';
 import { healSceneNodes } from '../utils/heal-scene-graph';
 import { removeRetiredDrawingSheetNodes } from '../utils/retired-scene-nodes';
+import { migrateVerticalSceneNodes } from '../utils/vertical-scene-migration';
 import * as nodeActions from './actions/node-actions';
 import { areSceneSnapshotsEqual, getSceneHistoryPauseDepth, notifySceneCommit, pauseSceneHistory, resetSceneHistoryPauseDepth, resumeSceneHistory, } from './history-control';
 import useLiveNodeOverrides from './use-live-node-overrides';
@@ -485,14 +482,6 @@ function migrateWallAssembly(node) {
     const { assemblyLayers: _assemblyLayers, ...wall } = node;
     return assemblyThickness > 0 ? { ...wall, thickness: assemblyThickness } : wall;
 }
-// Walls whose top lands within this of the storey plane become plane-bound;
-// ceilings whose stored height lands within this of their clamp bound become
-// follows-mode (step 3f) — same census-backed threshold for both.
-// From a prod census: the 0.15-short "hole pattern" (default 2.5 walls next to
-// a taller wall) must snap to the plane, while intentional 0.20-short walls
-// (2.5 under a 2.7 plane, 2.3 under a 2.5 plane) must keep their explicit
-// height — hence 0.20 with a strictly-less-than comparison.
-const PLANE_BOUND_EPSILON = 0.2;
 function migrateNodes(nodes) {
     // Repair pre-existing corruption (null children, zero-length walls) before
     // any per-type migration runs, so already-saved scenes load cleanly.
@@ -749,6 +738,7 @@ function migrateNodes(nodes) {
             const levelNumber = getFiniteNumber(node.level, 0);
             patchedNodes[id] = {
                 ...node,
+                baseElevation: normalizeLevelBaseElevation(node.baseElevation),
                 level: levelNumber,
                 children: validChildren,
             };
@@ -771,155 +761,8 @@ function migrateNodes(nodes) {
             patchedNodes[id] = normalized;
         }
     }
-    // Pass 3: vertical building model.
-    // A level without `height` marks a scene saved before the vertical model
-    // landed. Computed before this pass mutates anything: the stair-rise
-    // cleanup below must never run on already-migrated scenes.
-    const isLegacyScene = Object.values(patchedNodes).some((node) => node?.type === 'level' && !('height' in node));
-    // 3a. Ordinal renumber — always runs, per building (idempotent
-    // self-healing; MCP's create-level historically wrote its elevation PARAM
-    // into the ordinal, so fractional/duplicate ordinals exist in the wild).
-    const buildingNodes = Object.values(patchedNodes).filter((node) => node?.type === 'building');
-    const levelsByBuilding = new Map();
-    for (const [id, node] of Object.entries(patchedNodes)) {
-        if (node?.type !== 'level')
-            continue;
-        // Mirrors the building resolution in services/storey.ts: an explicit
-        // parentId pointing at a building wins, membership in a building's
-        // children array is the legacy fallback, and unresolvable levels share
-        // one orphan bucket.
-        const buildingId = buildingNodes.find((building) => building.id === node.parentId)?.id ??
-            buildingNodes.find((building) => getStringArray(building.children).includes(id))?.id ??
-            null;
-        const bucket = levelsByBuilding.get(buildingId) ?? [];
-        bucket.push({ id, ordinal: getFiniteNumber(node.level, 0) });
-        levelsByBuilding.set(buildingId, bucket);
-    }
-    for (const bucket of levelsByBuilding.values()) {
-        // Anchored at zero on purpose: ordinals are semantic — `level < 0`
-        // renders "Basement N" and `level === 0` is the ground-floor default —
-        // so negatives compact upward toward −1 and non-negatives compact down
-        // to 0. A blind 0..n renumber would rename basements.
-        const sorted = [...bucket].sort((a, b) => a.ordinal - b.ordinal);
-        const negativeCount = sorted.filter((entry) => entry.ordinal < 0).length;
-        sorted.forEach((entry, index) => {
-            const nextOrdinal = index - negativeCount;
-            const current = patchedNodes[entry.id];
-            if (current.level !== nextOrdinal) {
-                patchedNodes[entry.id] = { ...current, level: nextOrdinal };
-            }
-        });
-    }
-    // 3b. Stored storey heights: materialize the legacy stacked height verbatim
-    // (never rounded or snapped — snapping would move existing buildings).
-    // All planes derive before any wall height below mutates.
-    const legacyLevelIds = Object.entries(patchedNodes)
-        .filter(([, node]) => node?.type === 'level' && !('height' in node))
-        .map(([id]) => id);
-    const derivedHeights = new Map();
-    for (const levelId of legacyLevelIds) {
-        derivedHeights.set(levelId, deriveLegacyLevelHeight(levelId, patchedNodes));
-    }
-    for (const levelId of legacyLevelIds) {
-        const plane = derivedHeights.get(levelId);
-        const level = patchedNodes[levelId];
-        patchedNodes[levelId] = { ...level, height: plane };
-        // 3c. Wall-top classification against the just-written plane, using the
-        // same slab-support election as deriveLegacyLevelHeight (call shape
-        // mirrored from services/level-height.ts). Walls whose top meets the
-        // plane drop their explicit height and follow the level from now on;
-        // walls ending short (or tall) keep an explicit height — materializing
-        // the 2.5 default onto absent-height walls that end short of the plane.
-        const children = getStringArray(level.children)
-            .map((childId) => patchedNodes[childId])
-            .filter((child) => child !== undefined);
-        const slabs = children.filter((child) => child.type === 'slab');
-        const walls = children.filter((child) => child.type === 'wall');
-        for (const wall of walls) {
-            const electedBase = computeWallSlabSupport({
-                start: wall.start,
-                end: wall.end,
-                curveOffset: wall.curveOffset,
-                thickness: wall.thickness,
-            }, slabs, walls).elevation;
-            const effectiveHeight = wall.height ?? DEFAULT_WALL_HEIGHT;
-            const top = Math.max(0, electedBase) + effectiveHeight;
-            if (Math.abs(plane - top) < PLANE_BOUND_EPSILON) {
-                if ('height' in wall) {
-                    const { height: _height, ...planeBound } = wall;
-                    patchedNodes[wall.id] = planeBound;
-                }
-            }
-            else {
-                patchedNodes[wall.id] = { ...wall, height: effectiveHeight };
-            }
-        }
-    }
-    // 3d. Stair rise: on legacy scenes a totalRise of exactly 2.5 is the old
-    // schema default, not a user choice — drop it so the rise derives from the
-    // storey height. Gated on isLegacyScene because on a post-migration scene
-    // a stored 2.5 IS a deliberately typed value and must survive reloads.
-    if (isLegacyScene) {
-        for (const [id, node] of Object.entries(patchedNodes)) {
-            if (node?.type !== 'stair')
-                continue;
-            if (node.totalRise !== 2.5)
-                continue;
-            const { totalRise: _totalRise, ...derivedRise } = node;
-            patchedNodes[id] = derivedRise;
-        }
-    }
-    // 3e. Slab placement/thickness split. `elevation` stays the walking surface;
-    // the new `thickness` grows downward so the solid occupies
-    // [elevation − thickness, elevation]. Legacy solids extruded [0, elevation],
-    // so thickness = elevation EXACTLY (including degenerate 0 — MIN_SLAB_THICKNESS
-    // applies to edits only, never here) keeps the occupied interval identical.
-    // Legacy pools (elevation < 0) become explicit `recessed` intent with
-    // elevation unchanged. Gated per slab on a missing `thickness` — the
-    // migration output is cast, so schema defaults never materialize on load.
-    for (const [id, node] of Object.entries(patchedNodes)) {
-        if (node?.type !== 'slab' || 'thickness' in node)
-            continue;
-        const elevation = getFiniteNumber(node.elevation, 0.05);
-        patchedNodes[id] =
-            elevation < 0
-                ? { ...node, thickness: 0.05, recessed: true }
-                : { ...node, thickness: elevation };
-    }
-    // 3f. Ceiling follows-mode classification (the ceiling mirror of 3c; runs
-    // after 3b/3e so the clamp bound sees stored level heights and split slab
-    // thicknesses). A stored ceiling height within PLANE_BOUND_EPSILON of its
-    // clamp bound (min(storey plane, covering-slab underside) − margin, via
-    // getCeilingClampBound) is the legacy default tracking the level top, not
-    // a choice — drop it so the ceiling follows the level from now on.
-    // autoFromWalls ceilings always convert: their height was derived by the
-    // space-detection sync, never user intent. Gated on isLegacyScene, which
-    // is exact — nothing shipped between the level-height migration and this
-    // one — and makes the step idempotent. Known accepted edge: a
-    // post-migration user typing a custom height exactly equal to the bound
-    // keeps it (the gate prevents re-classification on later loads).
-    if (isLegacyScene) {
-        for (const [id, node] of Object.entries(patchedNodes)) {
-            if (node?.type !== 'ceiling' || !('height' in node))
-                continue;
-            const dropHeight = () => {
-                const { height: _height, ...follows } = node;
-                patchedNodes[id] = follows;
-            };
-            if (node.autoFromWalls === true) {
-                dropHeight();
-                continue;
-            }
-            if (typeof node.parentId !== 'string')
-                continue;
-            const bound = getCeilingClampBound(node.parentId, patchedNodes, Array.isArray(node.polygon) ? node.polygon : []);
-            const stored = getFiniteNumber(node.height, Number.NaN);
-            if (Number.isFinite(bound) && Math.abs(stored - bound) < PLANE_BOUND_EPSILON) {
-                dropHeight();
-            }
-        }
-    }
-    return { nodes: patchedNodes, mintedMaterials };
+    const vertical = migrateVerticalSceneNodes(patchedNodes);
+    return { nodes: vertical.nodes, mintedMaterials };
 }
 function getNodeChildIds(node) {
     if (!('children' in node && Array.isArray(node.children))) {
@@ -971,7 +814,76 @@ function collectReachableNodeIds(nodes, rootNodeIds) {
 }
 function sceneHistorySnapshotFromState(state) {
     const { nodes, rootNodeIds, collections, materials, installedPlugins } = state;
-    return { nodes, rootNodeIds, collections, materials, installedPlugins };
+    // Fresh placement nodes are renderable drafts, not document history. Excluding their
+    // entire subtree here protects both local undo and external commit subscribers.
+    const transientNodeIds = new Set();
+    for (const node of Object.values(nodes)) {
+        const metadata = node.metadata;
+        if (metadata &&
+            typeof metadata === 'object' &&
+            !Array.isArray(metadata) &&
+            metadata.isNew === true) {
+            transientNodeIds.add(node.id);
+        }
+    }
+    if (transientNodeIds.size === 0) {
+        return { nodes, rootNodeIds, collections, materials, installedPlugins };
+    }
+    const childIdsByParentId = new Map();
+    const addChild = (parentId, childId) => {
+        const childIds = childIdsByParentId.get(parentId) ?? new Set();
+        childIds.add(childId);
+        childIdsByParentId.set(parentId, childIds);
+    };
+    for (const node of Object.values(nodes)) {
+        if (node.parentId)
+            addChild(node.parentId, node.id);
+        for (const childId of getNodeChildIds(node))
+            addChild(node.id, childId);
+    }
+    const pendingIds = [...transientNodeIds];
+    while (pendingIds.length > 0) {
+        const parentId = pendingIds.pop();
+        if (!parentId)
+            continue;
+        for (const childId of childIdsByParentId.get(parentId) ?? []) {
+            if (transientNodeIds.has(childId))
+                continue;
+            transientNodeIds.add(childId);
+            pendingIds.push(childId);
+        }
+    }
+    const historyNodes = {};
+    for (const [id, node] of Object.entries(nodes)) {
+        if (transientNodeIds.has(id))
+            continue;
+        if (!('children' in node && Array.isArray(node.children))) {
+            historyNodes[id] = node;
+            continue;
+        }
+        const children = node.children.filter((childId) => !transientNodeIds.has(childId));
+        historyNodes[id] =
+            children.length === node.children.length ? node : { ...node, children };
+    }
+    const historyCollections = {};
+    for (const [id, collection] of Object.entries(collections)) {
+        const nodeIds = collection.nodeIds.filter((nodeId) => !transientNodeIds.has(nodeId));
+        if (collection.controlNodeId && transientNodeIds.has(collection.controlNodeId)) {
+            const { controlNodeId: _controlNodeId, ...rest } = collection;
+            historyCollections[id] = { ...rest, nodeIds };
+        }
+        else {
+            historyCollections[id] =
+                nodeIds.length === collection.nodeIds.length ? collection : { ...collection, nodeIds };
+        }
+    }
+    return {
+        nodes: historyNodes,
+        rootNodeIds: rootNodeIds.filter((id) => !transientNodeIds.has(id)),
+        collections: historyCollections,
+        materials,
+        installedPlugins,
+    };
 }
 const useScene = create()(temporal((set, get) => ({
     // 1. Flat dictionary of all nodes

package/dist/systems/elevator/elevator-service.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"elevator-service.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAa,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAG/E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AA2BD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAEb;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,EAAE,CAEV;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAsBb;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,YAAY,EAAE,kBAAkB,GAAG,IAAI,CAAA;IACvC,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB,CA0CA"}
+{"version":3,"file":"elevator-service.d.ts","sourceRoot":"","sources":["../../../src/systems/elevator/elevator-service.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAa,YAAY,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AAG/E,MAAM,MAAM,kBAAkB,GAAG;IAC/B,EAAE,EAAE,SAAS,CAAC,IAAI,CAAC,CAAA;IACnB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AA2BD,wBAAgB,6BAA6B,CAC3C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAEb;AAED,wBAAgB,8BAA8B,CAC5C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,MAAM,EAAE,CAEV;AAED,wBAAgB,4BAA4B,CAC1C,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,SAAS,EAAE,CAsBb;AAED,wBAAgB,qBAAqB,CACnC,QAAQ,EAAE,YAAY,EACtB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B;IACD,OAAO,EAAE,kBAAkB,EAAE,CAAA;IAC7B,YAAY,EAAE,kBAAkB,GAAG,IAAI,CAAA;IACvC,UAAU,EAAE,MAAM,CAAA;IAClB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,CAAA;CACpB,CA6CA"}

package/dist/systems/elevator/elevator-service.js

@@ -1,4 +1,4 @@
-import { getStoredLevelHeight } from '../../services/storey';
+import { getLevelElevations } from '../../services/storey';
 function getBuildingLevels(elevator, nodes) {
     const building = elevator.parentId && nodes[elevator.parentId]?.type === 'building'
         ? nodes[elevator.parentId]
@@ -51,17 +51,12 @@ export function resolveElevatorServiceLevels(elevator, nodes) {
 }
 export function resolveElevatorLevels(elevator, nodes) {
     const allLevels = resolveElevatorBuildingLevels(elevator, nodes);
-    const baseYByLevelId = new Map();
-    let cumulativeY = 0;
-    for (const level of allLevels) {
-        baseYByLevelId.set(level.id, cumulativeY);
-        cumulativeY += getStoredLevelHeight(level);
-    }
+    const levelElevations = getLevelElevations(nodes);
     const serviceLevels = resolveElevatorServiceLevels(elevator, nodes);
     const entries = serviceLevels.map((level) => ({
         id: level.id,
         label: String(level.level),
-        baseY: baseYByLevelId.get(level.id) ?? 0,
+        baseY: levelElevations.get(level.id)?.baseY ?? 0,
     }));
     const defaultEntry = entries.find((entry) => entry.id === elevator.defaultLevelId) ??
         entries.find((entry) => entry.id === elevator.fromLevelId) ??
@@ -69,15 +64,25 @@ export function resolveElevatorLevels(elevator, nodes) {
         null;
     const firstServedLevel = serviceLevels[0] ?? null;
     const lastServedLevel = serviceLevels[serviceLevels.length - 1] ?? null;
-    const shaftBaseY = firstServedLevel ? (baseYByLevelId.get(firstServedLevel.id) ?? 0) : 0;
+    const shaftBaseY = firstServedLevel ? (levelElevations.get(firstServedLevel.id)?.baseY ?? 0) : 0;
     const lastServedIndex = lastServedLevel
         ? allLevels.findIndex((level) => level.id === lastServedLevel.id)
         : -1;
     const nextLevel = lastServedIndex >= 0 ? allLevels[lastServedIndex + 1] : null;
+    // Highest ceiling in the stack, not the topmost level's: a negative
+    // baseElevation on the top level can put its ceiling below the level
+    // beneath it, and a shaft top under a served level would clip the cab.
+    let stackTopY = 0;
+    for (const level of allLevels) {
+        const elevation = levelElevations.get(level.id);
+        if (!elevation)
+            continue;
+        stackTopY = Math.max(stackTopY, elevation.baseY + elevation.height);
+    }
     const shaftTopY = nextLevel
-        ? (baseYByLevelId.get(nextLevel.id) ?? cumulativeY)
+        ? (levelElevations.get(nextLevel.id)?.baseY ?? stackTopY)
         : lastServedLevel
-            ? cumulativeY
+            ? stackTopY
             : elevator.cabHeight + 0.3;
     return {
         entries,

package/dist/systems/slab/slab-support.d.ts

@@ -114,37 +114,6 @@ export type WallSlabSupportSegment = {
     end: number;
     elevation: number;
 };
-/**
- * `preferredSlabId` is a persisted support host (`wall.supportSlabId`):
- * while that slab is still in the candidate set (still overlaps the wall
- * band with enough covered length), the elected `elevation` is pinned to
- * it instead of the majority/best-coverage election. `baseSegments` /
- * `baseElevation` (fill-down) still derive from ALL supporting slabs
- * unchanged. A preferred slab that no longer qualifies is silently
- * ignored — deliberately never cleared here, so the host resumes if the
- * slab's polygon returns (only slab deletion strips the stored field).
- *
- * `maxElevation` is the pointer-decided support cap (level-local Y, same
- * semantics as the item election): when set, elevation groups whose
- * walking surface sits above `maxElevation + SUPPORT_ELEVATION_EPSILON`
- * are excluded from the majority/best election — a deck hanging above the
- * surface the cursor ray actually hit never captures the elected base.
- * `baseSegments` / `baseElevation` stay uncapped (geometry fill-down), and
- * an explicit `preferredSlabId` still wins over the cap.
- *
- * `levelBase` is what "no slab supports this here" evaluates to — the
- * sculpted ground under the wall (`levelBaseElevationAt`), or 0 for a level
- * with no terrain under it. A caller-resolved scalar rather than a terrain
- * lookup in here, so this stays pure and the sample stays at the wall's own
- * XZ. It substitutes for every place this function used to write a literal
- * `0`, and nowhere else: a slab that supports the wall's faces still wins
- * outright, so a slab pad on a hillside keeps its wall at the pad's
- * elevation instead of being overruled by the ground around it. The one
- * clamp — center-only support, where the old code already clamped a
- * recessed slab up to `0` so a wall over a pool didn't sink — generalizes to
- * "never below the ground", which is the same rule with the ground no longer
- * assumed flat.
- */
 export declare function computeWallSlabSupport(wallLike: WallOverlapInput, slabs: readonly SlabNode[], levelWalls: WallNode[], preferredSlabId?: string | null, maxElevation?: number | null, levelBase?: number): WallSlabSupport;
 export declare function computeWallSlabElevation(wallLike: WallOverlapInput, slabs: readonly SlabNode[], levelWalls: WallNode[]): number;
 //# sourceMappingURL=slab-support.d.ts.map

package/dist/systems/slab/slab-support.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"slab-support.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-support.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"slab-support.d.ts","sourceRoot":"","sources":["../../../src/systems/slab/slab-support.ts"],"names":[],"mappings":"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"}

package/dist/systems/slab/slab-support.js

@@ -396,6 +396,31 @@ const WALL_SLAB_ELEVATION_POOL_EPSILON = 1e-4;
  * "never below the ground", which is the same rule with the ground no longer
  * assumed flat.
  */
+// A rendered slab polygon depends only on the slab set and the level's walls,
+// never on the wall being tested — but a per-frame pass asks for support once
+// per wall, so the identical polygons were rebuilt for every wall on the level
+// (and each rebuild scans all of `levelWalls`). Keyed on array identity: the
+// caller derives those arrays once and only rebuilds them when the scene or a
+// live preview changes, so a hit means the inputs are the same objects.
+let polygonMemoSlabs = null;
+let polygonMemoWalls = null;
+let polygonMemo = new Map();
+function renderedSlabPolygon(slab, slabs, levelWalls) {
+    if (polygonMemoSlabs !== slabs || polygonMemoWalls !== levelWalls) {
+        polygonMemoSlabs = slabs;
+        polygonMemoWalls = levelWalls;
+        polygonMemo = new Map();
+    }
+    const cached = polygonMemo.get(slab.id);
+    if (cached)
+        return cached;
+    const polygon = getRenderableSlabPolygon(slab, {
+        walls: levelWalls,
+        siblingSlabs: slabs.filter((other) => other.id !== slab.id),
+    });
+    polygonMemo.set(slab.id, polygon);
+    return polygon;
+}
 export function computeWallSlabSupport(wallLike, slabs, levelWalls, preferredSlabId, maxElevation, levelBase = 0) {
     const { start, end, curveOffset = 0, thickness = DEFAULT_WALL_THICKNESS } = wallLike;
     const halfThickness = Math.max(thickness / 2, 0);
@@ -417,10 +442,7 @@ export function computeWallSlabSupport(wallLike, slabs, levelWalls, preferredSla
     for (const slab of slabs) {
         if (slab.polygon.length < 3)
             continue;
-        const renderedPolygon = getRenderableSlabPolygon(slab, {
-            walls: levelWalls,
-            siblingSlabs: slabs.filter((other) => other.id !== slab.id),
-        });
+        const renderedPolygon = renderedSlabPolygon(slab, slabs, levelWalls);
         let supported = 0;
         const perPolyline = polylines.map((line) => {
             let intervals = polylineInsideIntervals(line, renderedPolygon);

package/dist/systems/stair/stair-opening-preview.d.ts

@@ -1338,6 +1338,7 @@ export declare function getNodesWithLiveStairOpeningInputs(nodes: Record<string,
     type: "level";
     children: (`item_${string}` | `ceiling_${string}` | `column_${string}` | `wall_${string}` | `fence_${string}` | `construction-dimension_${string}` | `structural-grid_${string}` | `zone_${string}` | `slab_${string}` | `roof_${string}` | `stair_${string}` | `scan_${string}` | `guide_${string}` | `measurement_${string}` | `spawn_${string}` | `shelf_${string}` | `duct-segment_${string}` | `duct-fitting_${string}` | `duct-terminal_${string}` | `hvac-equipment_${string}` | `lineset_${string}` | `liquid-line_${string}` | `pipe-segment_${string}` | `pipe-fitting_${string}` | `pipe-trap_${string}`)[];
     level: number;
+    baseElevation: number;
     name?: string | undefined;
     camera?: {
         position: [number, number, number];

package/dist/systems/stair/stair-opening-preview.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-opening-preview.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC7E,OAA6B,EAAE,KAAK,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AAClG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAGpE,KAAK,oBAAoB,GAAG;IAC1B,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAA;CACtC,CAAA;AAoBD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,WAYvC;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwBvC;AAED,wBAAgB,qCAAqC;;mBAUlC,oBAAoB,EAAE;;EAiCxC"}
+{"version":3,"file":"stair-opening-preview.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-opening-preview.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,WAAW,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAC7E,OAA6B,EAAE,KAAK,iBAAiB,EAAE,MAAM,qCAAqC,CAAA;AAClG,OAAO,KAAK,EAAE,aAAa,EAAE,MAAM,iCAAiC,CAAA;AAGpE,KAAK,oBAAoB,GAAG;IAC1B,EAAE,EAAE,SAAS,CAAA;IACb,IAAI,EAAE,OAAO,CAAC,QAAQ,GAAG,WAAW,CAAC,CAAA;CACtC,CAAA;AAoBD,wBAAgB,yBAAyB,CACvC,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC,WAYvC;AAED,wBAAgB,kCAAkC,CAChD,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAC9B,cAAc,EAAE,WAAW,CAAC,MAAM,EAAE,aAAa,CAAC,EAClD,aAAa,EAAE,WAAW,CAAC,MAAM,EAAE,iBAAiB,CAAC,EACrD,iBAAiB,EAAE,WAAW,CAAC,MAAM,CAAC;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAwBvC;AAED,wBAAgB,qCAAqC;;mBAUlC,oBAAoB,EAAE;;EAiCxC"}

package/dist/systems/stair/stair-rise.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"stair-rise.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-rise.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAoB,MAAM,cAAc,CAAA;AAInF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CA+B9F;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAgClD"}
+{"version":3,"file":"stair-rise.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-rise.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,SAAS,EAAoB,MAAM,cAAc,CAAA;AAInF,wBAAgB,qBAAqB,CAAC,KAAK,EAAE,SAAS,EAAE,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAiC9F;AAID;;;;;;;;;;;;;;GAcG;AACH,wBAAgB,cAAc,CAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,KAAK,CAAC;IAAE,EAAE,EAAE,SAAS,CAAC;IAAC,IAAI,EAAE,OAAO,CAAC,OAAO,CAAC,CAAA;CAAE,CAAC,CAgClD"}

package/dist/systems/stair/stair-rise.js

@@ -1,6 +1,6 @@
 import { getFloorStackedPosition } from '../../hooks/spatial-grid/floor-placed-elevation';
 import { DEFAULT_LEVEL_HEIGHT } from '../../services/level-height';
-import { getStoredLevelHeight } from '../../services/storey';
+import { getLevelFloorToFloorHeight } from '../../services/storey';
 export function resolveStairTotalRise(stair, nodes) {
     if (stair.totalRise !== undefined)
         return stair.totalRise;
@@ -27,7 +27,9 @@ export function resolveStairTotalRise(stair, nodes) {
             return (deck.elevation ?? 0.05) - baseElevation;
         }
     }
-    return level?.type === 'level' ? getStoredLevelHeight(level) : DEFAULT_LEVEL_HEIGHT;
+    return level?.type === 'level'
+        ? getLevelFloorToFloorHeight(level.id, nodes)
+        : DEFAULT_LEVEL_HEIGHT;
 }
 const RISE_SYNC_EPSILON = 1e-4;
 /**

package/dist/systems/wall/wall-mitering.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"wall-mitering.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAO5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;CAClB;AASD,KAAK,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAGzE,KAAK,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAmBlD,iBAAS,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAY,GAAG,MAAM,CAG7D;AA8CD,UAAU,QAAQ;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAA;KAAE,CAAC,CAAA;CACpF;AAkPD,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,YAAY,CAAA;IAE1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CACjC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,aAAa,CAWrE;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,aAAa,GACvB,uBAAuB,GAAG,IAAI,CA0BhC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CA8C/F;AAGD,OAAO,EAAE,UAAU,EAAE,CAAA"}
+{"version":3,"file":"wall-mitering.d.ts","sourceRoot":"","sources":["../../../src/systems/wall/wall-mitering.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAO5C,MAAM,WAAW,OAAO;IACtB,CAAC,EAAE,MAAM,CAAA;IACT,CAAC,EAAE,MAAM,CAAA;CACV;AAED,MAAM,WAAW,uBAAuB;IACtC,SAAS,EAAE,OAAO,CAAA;IAClB,UAAU,EAAE,OAAO,CAAA;IACnB,OAAO,EAAE,OAAO,CAAA;IAChB,QAAQ,EAAE,OAAO,CAAA;CAClB;AASD,KAAK,iBAAiB,GAAG,GAAG,CAAC,MAAM,EAAE;IAAE,IAAI,CAAC,EAAE,OAAO,CAAC;IAAC,KAAK,CAAC,EAAE,OAAO,CAAA;CAAE,CAAC,CAAA;AAGzE,KAAK,YAAY,GAAG,GAAG,CAAC,MAAM,EAAE,iBAAiB,CAAC,CAAA;AAmBlD,iBAAS,UAAU,CAAC,CAAC,EAAE,OAAO,EAAE,SAAS,SAAY,GAAG,MAAM,CAG7D;AA8CD,UAAU,QAAQ;IAChB,YAAY,EAAE,OAAO,CAAA;IACrB,cAAc,EAAE,KAAK,CAAC;QAAE,IAAI,EAAE,QAAQ,CAAC;QAAC,OAAO,EAAE,OAAO,GAAG,KAAK,GAAG,aAAa,CAAA;KAAE,CAAC,CAAA;CACpF;AAyUD,MAAM,WAAW,aAAa;IAE5B,YAAY,EAAE,YAAY,CAAA;IAE1B,SAAS,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;CACjC;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,KAAK,EAAE,QAAQ,EAAE,GAAG,aAAa,CAWrE;AAED,wBAAgB,0BAA0B,CACxC,IAAI,EAAE,QAAQ,EACd,SAAS,EAAE,aAAa,GACvB,uBAAuB,GAAG,IAAI,CA0BhC;AAED;;GAEG;AACH,wBAAgB,kBAAkB,CAAC,QAAQ,EAAE,QAAQ,EAAE,EAAE,YAAY,EAAE,GAAG,CAAC,MAAM,CAAC,GAAG,GAAG,CAAC,MAAM,CAAC,CA8C/F;AAGD,OAAO,EAAE,UAAU,EAAE,CAAA"}

package/dist/systems/wall/wall-mitering.js

@@ -52,6 +52,49 @@ function pointOnWallSegment(point, wall, tolerance = TOLERANCE) {
     const dist = Math.sqrt((point.x - projX) ** 2 + (point.y - projY) ** 2);
     return dist < tolerance;
 }
+// --- Uniform grid used to prefilter T-junction candidates --------------------
+// 2 m cells: small enough that a dense imported floor spreads across many
+// buckets, large enough that an ordinary room wall touches only a few.
+const JUNCTION_GRID_CELL = 2.0;
+// A wall whose AABB would touch more than this many cells (a very long diagonal)
+// is kept in a fallback list checked against every junction. Such walls are rare,
+// and a model made only of them is a model with very few walls — where the naive
+// scan was never the problem.
+const JUNCTION_GRID_MAX_CELLS_PER_WALL = 64;
+function cellKey(x, y) {
+    return `${Math.floor(x / JUNCTION_GRID_CELL)},${Math.floor(y / JUNCTION_GRID_CELL)}`;
+}
+function buildJunctionGrid(walls) {
+    const grid = new Map();
+    const oversized = [];
+    for (const wall of walls) {
+        // Pad by TOLERANCE so a point sitting exactly on the AABB edge still lands
+        // in a covered cell.
+        const minX = Math.min(wall.start[0], wall.end[0]) - TOLERANCE;
+        const maxX = Math.max(wall.start[0], wall.end[0]) + TOLERANCE;
+        const minY = Math.min(wall.start[1], wall.end[1]) - TOLERANCE;
+        const maxY = Math.max(wall.start[1], wall.end[1]) + TOLERANCE;
+        const cx0 = Math.floor(minX / JUNCTION_GRID_CELL);
+        const cx1 = Math.floor(maxX / JUNCTION_GRID_CELL);
+        const cy0 = Math.floor(minY / JUNCTION_GRID_CELL);
+        const cy1 = Math.floor(maxY / JUNCTION_GRID_CELL);
+        if ((cx1 - cx0 + 1) * (cy1 - cy0 + 1) > JUNCTION_GRID_MAX_CELLS_PER_WALL) {
+            oversized.push(wall);
+            continue;
+        }
+        for (let cx = cx0; cx <= cx1; cx++) {
+            for (let cy = cy0; cy <= cy1; cy++) {
+                const key = `${cx},${cy}`;
+                const bucket = grid.get(key);
+                if (bucket)
+                    bucket.push(wall);
+                else
+                    grid.set(key, [wall]);
+            }
+        }
+    }
+    return { grid, oversized };
+}
 function findJunctions(walls) {
     const junctions = new Map();
     // First pass: group walls by their endpoints
@@ -69,17 +112,47 @@ function findJunctions(walls) {
         }
         junctions.get(keyEnd)?.connectedWalls.push({ wall, endType: 'end' });
     }
-    // Second pass: detect T-junctions (walls passing through junction points)
+    // Second pass: detect T-junctions (walls passing through junction points).
+    //
+    // The naive form of this pass is `for each junction: for each wall` — O(J×N).
+    // On a real imported floor (1081 walls, 2047 endpoint keys) that is ~2.2M
+    // pointOnWallSegment calls and measured 584 ms per findJunctions() call, which
+    // WallSystem then repeats every frame while progressively rebuilding.
+    //
+    // A T-junction can only exist where the junction point lies ON the wall
+    // segment, so it must lie inside the wall's AABB. Bucketing walls by the grid
+    // cells their AABB covers therefore loses nothing: the cell containing the
+    // point is always one of the cells the wall was indexed into. With the input
+    // ordering restored below, the result matches the naive pass exactly; measured
+    // 11 ms on the same geometry.
+    const { grid, oversized } = buildJunctionGrid(walls);
+    const wallOrder = new Map(walls.map((wall, index) => [wall.id, index]));
     for (const [_key, junction] of junctions.entries()) {
-        for (const wall of walls) {
-            // Skip if wall already in this junction
-            if (junction.connectedWalls.some((cw) => cw.wall.id === wall.id))
+        const p = junction.meetingPoint;
+        const cellCandidates = grid.get(cellKey(p.x, p.y));
+        const passthrough = [];
+        for (const bucket of [cellCandidates, oversized]) {
+            if (!bucket || bucket.length === 0)
                 continue;
-            // Check if junction point lies on this wall's segment (not at endpoints)
-            if (pointOnWallSegment(junction.meetingPoint, wall)) {
-                junction.connectedWalls.push({ wall, endType: 'passthrough' });
+            for (const wall of bucket) {
+                // Skip if wall already in this junction
+                if (junction.connectedWalls.some((cw) => cw.wall.id === wall.id))
+                    continue;
+                // Check if junction point lies on this wall's segment (not at endpoints)
+                if (pointOnWallSegment(junction.meetingPoint, wall)) {
+                    passthrough.push(wall);
+                }
             }
         }
+        // Append in input order, not bucket order. Two collinear walls overlapping a
+        // junction tie on angle in `calculateJunctionIntersections`, so its stable
+        // sort leaves them in the order they were appended here — and an oversized
+        // wall would otherwise land after a shorter collinear neighbour it precedes
+        // in `walls`, picking the other wall's thickness for the miter.
+        passthrough.sort((a, b) => (wallOrder.get(a.id) ?? 0) - (wallOrder.get(b.id) ?? 0));
+        for (const wall of passthrough) {
+            junction.connectedWalls.push({ wall, endType: 'passthrough' });
+        }
     }
     // Filter to only junctions with 2+ walls
     const actualJunctions = new Map();
@@ -186,8 +259,14 @@ function calculateJunctionIntersections(junction, getThickness) {
             });
         }
     }
-    // Sort by outgoing angle
-    processedWalls.sort((a, b) => a.angle - b.angle);
+    // Sort by outgoing angle, then by wall ID so equal-angle walls produce the
+    // same pairing regardless of scene iteration order.
+    processedWalls.sort((a, b) => {
+        const angleOrder = a.angle - b.angle;
+        if (angleOrder !== 0)
+            return angleOrder;
+        return a.wallId < b.wallId ? -1 : a.wallId > b.wallId ? 1 : 0;
+    });
     const wallIntersections = new Map();
     const n = processedWalls.length;
     if (n < 2)