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

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/roof/roof-elevation-system.d.ts

@@ -0,0 +1,3 @@
+export declare function initializeRoofElevationSync(): () => void;
+export declare function RoofElevationSystem(): null;
+//# sourceMappingURL=roof-elevation-system.d.ts.map

package/dist/systems/roof/roof-elevation-system.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-elevation-system.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-elevation-system.tsx"],"names":[],"mappings":"AAgCA,wBAAgB,2BAA2B,IAAI,MAAM,IAAI,CAmExD;AAED,wBAAgB,mBAAmB,SAGlC"}

package/dist/systems/roof/roof-elevation-system.js

@@ -0,0 +1,94 @@
+'use client';
+import { useEffect } from 'react';
+import { getSceneHistoryPauseDepth, notifySceneCommit, pauseSceneHistory, resumeSceneHistory, } from '../../store/history-control';
+import useScene from '../../store/use-scene';
+import { resolveRoofElevation } from './roof-elevation';
+const ROOF_ELEVATION_EPSILON = 1e-4;
+function sceneSnapshot() {
+    const { nodes, rootNodeIds, collections, materials, installedPlugins } = useScene.getState();
+    return { nodes, rootNodeIds, collections, materials, installedPlugins };
+}
+function isElevationRelevant(node) {
+    return (node?.type === 'roof' ||
+        node?.type === 'wall' ||
+        node?.type === 'slab' ||
+        node?.type === 'level' ||
+        node?.type === 'building' ||
+        node?.type === 'site');
+}
+export function initializeRoofElevationSync() {
+    let disposed = false;
+    let queued = false;
+    let syncing = false;
+    const schedule = () => {
+        if (queued)
+            return;
+        queued = true;
+        // Wall bases use the spatial grid, whose listener must finish before this pass.
+        queueMicrotask(() => {
+            queued = false;
+            if (disposed)
+                return;
+            const { nodes, updateNodes, readOnly } = useScene.getState();
+            if (readOnly)
+                return;
+            const updates = [];
+            for (const node of Object.values(nodes)) {
+                if (node.type !== 'roof' || node.support?.kind !== 'walls')
+                    continue;
+                const elevation = resolveRoofElevation(node, nodes);
+                if (Math.abs(node.position[1] - elevation) <= ROOF_ELEVATION_EPSILON)
+                    continue;
+                updates.push({
+                    id: node.id,
+                    data: { position: [node.position[0], elevation, node.position[2]] },
+                });
+            }
+            if (updates.length === 0)
+                return;
+            const before = sceneSnapshot();
+            const publishCommit = useScene.temporal.getState().isTracking && getSceneHistoryPauseDepth() === 0;
+            syncing = true;
+            pauseSceneHistory(useScene);
+            try {
+                updateNodes(updates);
+            }
+            finally {
+                resumeSceneHistory(useScene);
+                syncing = false;
+            }
+            // Deferred writes miss the originating commit; publish the settled roof without
+            // another undo step. An outer pause belongs to a gesture that owns its commit.
+            if (publishCommit) {
+                notifySceneCommit({
+                    origin: 'local',
+                    before,
+                    current: sceneSnapshot(),
+                    changedNodeIds: new Set(updates.map(({ id }) => id)),
+                });
+            }
+        });
+    };
+    const unsubscribe = useScene.subscribe((state, previous) => {
+        if (syncing || state.nodes === previous.nodes)
+            return;
+        const ids = new Set([...Object.keys(state.nodes), ...Object.keys(previous.nodes)]);
+        for (const id of ids) {
+            const next = state.nodes[id];
+            const prev = previous.nodes[id];
+            if (next !== prev && (isElevationRelevant(next) || isElevationRelevant(prev))) {
+                schedule();
+                return;
+            }
+        }
+    });
+    schedule();
+    return () => {
+        disposed = true;
+        unsubscribe();
+    };
+}
+export function RoofElevationSystem() {
+    useEffect(initializeRoofElevationSync, []);
+    return null;
+}

package/dist/systems/roof/roof-elevation.d.ts

@@ -0,0 +1,4 @@
+import type { AnyNode, LevelNode, RoofNode, WallNode } from '../../schema';
+export declare function resolveRoofWallTopElevation(targetLevelId: LevelNode['id'], wall: WallNode, nodes: Readonly<Record<string, AnyNode>>, elevations?: Map<string, import("../..").LevelElevation>): number;
+export declare function resolveRoofElevation(roof: RoofNode, nodes: Readonly<Record<string, AnyNode>>): number;
+//# sourceMappingURL=roof-elevation.d.ts.map

package/dist/systems/roof/roof-elevation.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-elevation.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-elevation.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAmB,QAAQ,EAAE,MAAM,cAAc,CAAA;AAM3F,wBAAgB,2BAA2B,CACzC,aAAa,EAAE,SAAS,CAAC,IAAI,CAAC,EAC9B,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,UAAU,8CAA4B,GACrC,MAAM,CASR;AAED,wBAAgB,oBAAoB,CAClC,IAAI,EAAE,QAAQ,EACd,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GACvC,MAAM,CAwFR"}

package/dist/systems/roof/roof-elevation.js

@@ -0,0 +1,95 @@
+import { getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, } from '../../hooks/spatial-grid/spatial-grid-manager';
+import { resolveLevelId } from '../../hooks/spatial-grid/spatial-grid-sync';
+import { findLevelBelowId, getLevelElevations } from '../../services/storey';
+import { wallOverlapsSlabFootprint } from '../slab/slab-support';
+import { getWallArcData } from '../wall/wall-curve';
+import { resolveRoomRoofFootprintOnLevel } from './roof-footprint';
+export function resolveRoofWallTopElevation(targetLevelId, wall, nodes, elevations = getLevelElevations(nodes)) {
+    const sourceLevelY = elevations.get(resolveLevelId(wall, nodes))?.baseY ?? 0;
+    const targetLevelY = elevations.get(targetLevelId)?.baseY ?? 0;
+    return (sourceLevelY +
+        getWallBaseElevationForNodes(wall, nodes) +
+        getWallEffectiveHeightForNodes(wall, nodes) -
+        targetLevelY);
+}
+export function resolveRoofElevation(roof, nodes) {
+    if (roof.support?.kind !== 'walls')
+        return roof.position[1];
+    const levelId = resolveLevelId(roof, nodes);
+    if (nodes[levelId]?.type !== 'level')
+        return roof.position[1];
+    const elevations = getLevelElevations(nodes);
+    // A roof usually sits on the storey above its walls, but the top floor (or a
+    // roof armed from the walls' own level) keeps roof and walls on one level.
+    const belowId = findLevelBelowId(levelId, elevations);
+    const candidateWallIds = [levelId, belowId]
+        .map((id) => (id ? nodes[id] : undefined))
+        .filter((node) => node?.type === 'level')
+        .flatMap((level) => level.children);
+    const conicalSegments = roof.children
+        .map((id) => nodes[id])
+        .filter((node) => node?.type === 'roof-segment' && node.roofType === 'conical');
+    const cos = Math.cos(roof.rotation);
+    const sin = Math.sin(roof.rotation);
+    const toLevel = (x, z) => [
+        roof.position[0] + x * cos + z * sin,
+        roof.position[2] - x * sin + z * cos,
+    ];
+    // Walls under the footprint, closed room or not: a room missing a wall, an
+    // L-shaped room whose centre falls outside, or a redrawn enclosure all still
+    // hold the roof up. The band test is curve- and thickness-aware and
+    // boundary-inclusive, so perimeter walls on the footprint edge count.
+    const footprints = roof.children
+        .map((id) => nodes[id])
+        .filter((node) => node?.type === 'roof-segment')
+        .map((segment) => {
+        const c = Math.cos(segment.rotation);
+        const s = Math.sin(segment.rotation);
+        const halfW = segment.width / 2;
+        const halfD = segment.depth / 2;
+        const corners = [
+            [-halfW, -halfD],
+            [halfW, -halfD],
+            [halfW, halfD],
+            [-halfW, halfD],
+        ];
+        return corners.map(([x, z]) => toLevel(segment.position[0] + x * c + z * s, segment.position[2] - x * s + z * c));
+    });
+    const wallIds = conicalSegments.length
+        ? candidateWallIds.filter((id) => {
+            const wall = nodes[id];
+            if (wall?.type !== 'wall')
+                return false;
+            const arc = getWallArcData(wall);
+            if (!arc)
+                return false;
+            return conicalSegments.some((segment) => {
+                const [centerX, centerZ] = toLevel(segment.position[0], segment.position[2]);
+                return (Math.hypot(arc.center.x - centerX, arc.center.y - centerZ) <= 1e-4 &&
+                    Math.abs(arc.radius - segment.width / 2) <= 1e-4);
+            });
+        })
+        : footprints.length
+            ? candidateWallIds.filter((id) => {
+                const wall = nodes[id];
+                return (wall?.type === 'wall' &&
+                    footprints.some((polygon) => wallOverlapsSlabFootprint(wall, polygon)));
+            })
+            : ([levelId, belowId]
+                .map((id) => id
+                ? resolveRoomRoofFootprintOnLevel(id, nodes, [
+                    roof.position[0],
+                    roof.position[2],
+                ])
+                : null)
+                .find((target) => target !== null)?.wallIds ?? []);
+    let highest;
+    for (const id of wallIds) {
+        const wall = nodes[id];
+        if (wall?.type !== 'wall')
+            continue;
+        const top = resolveRoofWallTopElevation(levelId, wall, nodes, elevations);
+        highest = highest === undefined ? top : Math.max(highest, top);
+    }
+    return highest ?? roof.position[1];
+}

package/dist/systems/roof/roof-footprint.d.ts

@@ -0,0 +1,17 @@
+import type { AnyNode, LevelNode, WallNode } from '../../schema';
+export type RoofFootprintTarget = {
+    id: string;
+    polygon: Array<[number, number]>;
+    wallIds: WallNode['id'][];
+    center: [number, number];
+    width: number;
+    depth: number;
+    rotation: number;
+    rectangular: boolean;
+};
+export declare function fitRoofFootprint(id: string, polygon: Array<[number, number]>, wallIds: WallNode['id'][]): RoofFootprintTarget | null;
+export declare function resolveRoomRoofFootprint(levelId: LevelNode['id'], nodes: Readonly<Record<string, AnyNode>>, point: [number, number], options?: {
+    rectangularOnly?: boolean;
+}): RoofFootprintTarget | null;
+export declare function resolveRoomRoofFootprintOnLevel(levelId: LevelNode['id'], nodes: Readonly<Record<string, AnyNode>>, point: [number, number]): RoofFootprintTarget | null;
+//# sourceMappingURL=roof-footprint.d.ts.map

package/dist/systems/roof/roof-footprint.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-footprint.d.ts","sourceRoot":"","sources":["../../../src/systems/roof/roof-footprint.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,MAAM,cAAc,CAAA;AAGhE,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAChC,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,CAAA;IACzB,MAAM,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACxB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,MAAM,CAAA;IAChB,WAAW,EAAE,OAAO,CAAA;CACrB,CAAA;AAWD,wBAAgB,gBAAgB,CAC9B,EAAE,EAAE,MAAM,EACV,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChC,OAAO,EAAE,QAAQ,CAAC,IAAI,CAAC,EAAE,GACxB,mBAAmB,GAAG,IAAI,CAqD5B;AAED,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,EACxB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACvB,OAAO,GAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAO,GAC1C,mBAAmB,GAAG,IAAI,CAW5B;AAED,wBAAgB,+BAA+B,CAC7C,OAAO,EAAE,SAAS,CAAC,IAAI,CAAC,EACxB,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,EACxC,KAAK,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,GACtB,mBAAmB,GAAG,IAAI,CAW5B"}

package/dist/systems/roof/roof-footprint.js

@@ -0,0 +1,83 @@
+import { pointInPolygon as pointInPolygon2D } from '../../lib/polygon-relations';
+import { detectSpacesForLevel } from '../../lib/space-detection';
+import { getLevelBelow } from '../../services/storey';
+function polygonArea(polygon) {
+    return Math.abs(polygon.reduce((area, point, index) => {
+        const next = polygon[(index + 1) % polygon.length];
+        return next ? area + point[0] * next[1] - next[0] * point[1] : area;
+    }, 0) / 2);
+}
+export function fitRoofFootprint(id, polygon, wallIds) {
+    if (polygon.length < 3)
+        return null;
+    let best;
+    for (let index = 0; index < polygon.length; index++) {
+        const point = polygon[index];
+        const next = polygon[(index + 1) % polygon.length];
+        if (!(point && next))
+            continue;
+        const rotation = Math.atan2(next[1] - point[1], next[0] - point[0]);
+        const cos = Math.cos(rotation);
+        const sin = Math.sin(rotation);
+        const rotated = polygon.map(([x, z]) => [x * cos + z * sin, -x * sin + z * cos]);
+        const xs = rotated.map(([x]) => x);
+        const zs = rotated.map(([, z]) => z);
+        const minX = Math.min(...xs);
+        const maxX = Math.max(...xs);
+        const minZ = Math.min(...zs);
+        const maxZ = Math.max(...zs);
+        const width = maxX - minX;
+        const depth = maxZ - minZ;
+        const area = width * depth;
+        if (area <= 0 || (best && best.area <= area))
+            continue;
+        const localCenterX = (minX + maxX) / 2;
+        const localCenterZ = (minZ + maxZ) / 2;
+        best = {
+            center: [localCenterX * cos - localCenterZ * sin, localCenterX * sin + localCenterZ * cos],
+            width,
+            depth,
+            rotation: -rotation,
+            area,
+        };
+    }
+    if (!best)
+        return null;
+    return {
+        id,
+        polygon,
+        wallIds,
+        center: best.center,
+        width: best.width,
+        depth: best.depth,
+        rotation: best.rotation,
+        rectangular: polygonArea(polygon) / best.area >= 0.96,
+    };
+}
+export function resolveRoomRoofFootprint(levelId, nodes, point, options = {}) {
+    const activeTarget = resolveRoomRoofFootprintOnLevel(levelId, nodes, point);
+    if (activeTarget && (!options.rectangularOnly || activeTarget.rectangular))
+        return activeTarget;
+    if (activeTarget)
+        return null;
+    const levelBelow = getLevelBelow(levelId, nodes);
+    const levelBelowTarget = levelBelow
+        ? resolveRoomRoofFootprintOnLevel(levelBelow.id, nodes, point)
+        : null;
+    return levelBelowTarget && (!options.rectangularOnly || levelBelowTarget.rectangular)
+        ? levelBelowTarget
+        : null;
+}
+export function resolveRoomRoofFootprintOnLevel(levelId, nodes, point) {
+    const level = nodes[levelId];
+    if (level?.type !== 'level')
+        return null;
+    const walls = level.children
+        .map((id) => nodes[id])
+        .filter((node) => node?.type === 'wall');
+    const spaces = detectSpacesForLevel(levelId, walls)
+        .spaces.filter((space) => !space.isExterior && pointInPolygon2D(point, space.polygon))
+        .sort((left, right) => polygonArea(left.polygon) - polygonArea(right.polygon));
+    const space = spaces[0];
+    return space ? fitRoofFootprint(space.id, space.polygon, space.wallIds) : null;
+}

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-flight.d.ts

@@ -0,0 +1,17 @@
+import type { AnyNode, StairNode } from '../../schema';
+import { StairSegmentNode } from '../../schema';
+export type StairFlightOverrides = Partial<Pick<StairSegmentNode, 'width' | 'length' | 'height' | 'stepCount' | 'attachmentSide' | 'fillToFloor' | 'thickness'>>;
+/**
+ * The single definition of a default straight flight. Anything left out falls
+ * through to the `StairSegmentNode` schema defaults (length 3 m, 10 steps,
+ * filled to floor) rather than being spelled again per call site, so the stair
+ * tool's seed segment, the flight the panel materializes when a curved stair
+ * becomes straight, and the viewer's fallback body all describe one stair.
+ */
+export declare function createDefaultStairSegment(overrides?: StairFlightOverrides): StairSegmentNode;
+/**
+ * The flight a straight stair implies from its own fields — used wherever a
+ * straight stair has to stand in for missing `stair-segment` children.
+ */
+export declare function createStairFlightFromStair(stair: StairNode, nodes: Record<string, AnyNode>): StairSegmentNode;
+//# sourceMappingURL=stair-flight.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"stair-flight.d.ts","sourceRoot":"","sources":["../../../src/systems/stair/stair-flight.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,cAAc,CAAA;AACtD,OAAO,EAAE,gBAAgB,EAAE,MAAM,cAAc,CAAA;AAM/C,MAAM,MAAM,oBAAoB,GAAG,OAAO,CACxC,IAAI,CACF,gBAAgB,EAChB,OAAO,GAAG,QAAQ,GAAG,QAAQ,GAAG,WAAW,GAAG,gBAAgB,GAAG,aAAa,GAAG,WAAW,CAC7F,CACF,CAAA;AAED;;;;;;GAMG;AACH,wBAAgB,yBAAyB,CAAC,SAAS,GAAE,oBAAyB,GAAG,gBAAgB,CAEhG;AAED;;;GAGG;AACH,wBAAgB,0BAA0B,CACxC,KAAK,EAAE,SAAS,EAChB,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAC7B,gBAAgB,CAQlB"}

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

@@ -0,0 +1,27 @@
+import { StairSegmentNode } from '../../schema';
+import { resolveStairTotalRise } from './stair-rise';
+const MIN_STAIR_FLIGHT_RISE = 0.1;
+const MIN_STAIR_FLIGHT_STEP_COUNT = 2;
+/**
+ * The single definition of a default straight flight. Anything left out falls
+ * through to the `StairSegmentNode` schema defaults (length 3 m, 10 steps,
+ * filled to floor) rather than being spelled again per call site, so the stair
+ * tool's seed segment, the flight the panel materializes when a curved stair
+ * becomes straight, and the viewer's fallback body all describe one stair.
+ */
+export function createDefaultStairSegment(overrides = {}) {
+    return StairSegmentNode.parse({ segmentType: 'stair', position: [0, 0, 0], ...overrides });
+}
+/**
+ * The flight a straight stair implies from its own fields — used wherever a
+ * straight stair has to stand in for missing `stair-segment` children.
+ */
+export function createStairFlightFromStair(stair, nodes) {
+    return createDefaultStairSegment({
+        width: stair.width,
+        height: Math.max(resolveStairTotalRise(stair, nodes), MIN_STAIR_FLIGHT_RISE),
+        stepCount: Math.max(MIN_STAIR_FLIGHT_STEP_COUNT, Math.round(stair.stepCount ?? 10)),
+        thickness: stair.thickness,
+        fillToFloor: stair.fillToFloor,
+    });
+}