@pascal-app/core 0.8.0 → 0.9.1

package/dist/lib/space-detection.d.ts

@@ -1,4 +1,4 @@
-import { type WallNode } from '../schema';
+import { type CeilingNode as CeilingNodeType, type SlabNode as SlabNodeType, type WallNode } from '../schema';
 type Point2D = {
     x: number;
     y: number;
@@ -15,12 +15,41 @@ type WallSideUpdate = {
     frontSide: 'interior' | 'exterior' | 'unknown';
     backSide: 'interior' | 'exterior' | 'unknown';
 };
+export type AutoSlabSyncPlan = {
+    create: SlabNodeType[];
+    update: Array<{
+        id: SlabNodeType['id'];
+        data: Partial<SlabNodeType>;
+    }>;
+    delete: Array<SlabNodeType['id']>;
+};
+export type AutoCeilingSyncPlan = {
+    create: CeilingNodeType[];
+    update: Array<{
+        id: CeilingNodeType['id'];
+        data: Partial<CeilingNodeType>;
+    }>;
+    delete: Array<CeilingNodeType['id']>;
+};
+export type AutoCeilingPlanningContext = {
+    walls?: WallNode[];
+    slabs?: SlabNodeType[];
+};
 export declare function resolveWallSurfaceSides(wall: Pick<WallNode, 'start' | 'end' | 'thickness' | 'frontSide' | 'backSide'>, roomPolygons: Point2D[][]): Pick<WallSideUpdate, 'frontSide' | 'backSide'>;
+export declare function planAutoSlabsForLevel(roomPolygons: Point2D[][], existingSlabs: SlabNodeType[]): AutoSlabSyncPlan;
+export declare function projectAutoSlabsForPlan(existingSlabs: SlabNodeType[], plan: AutoSlabSyncPlan): SlabNodeType[];
+export declare function planAutoCeilingsForLevel(roomPolygons: Point2D[][], existingCeilings: CeilingNodeType[], context?: AutoCeilingPlanningContext): AutoCeilingSyncPlan;
 export declare function detectSpacesForLevel(levelId: string, walls: WallNode[]): {
     roomPolygons: Point2D[][];
     spaces: Space[];
     wallUpdates: WallSideUpdate[];
 };
+/** Pause the wall-driven auto slab/ceiling sync. Refcounted — pair with `resumeSpaceDetection`. */
+export declare function pauseSpaceDetection(): void;
+/** Resume the wall-driven auto slab/ceiling sync. No-op if not currently paused. */
+export declare function resumeSpaceDetection(): void;
+/** True iff the wall-driven auto slab/ceiling sync is currently paused. */
+export declare function isSpaceDetectionPaused(): boolean;
 export declare function initSpaceDetectionSync(sceneStore: any, editorStore: any): () => void;
 export declare function wallTouchesOthers(wall: WallNode, otherWalls: WallNode[]): boolean;
 export {};

package/dist/lib/space-detection.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"space-detection.d.ts","sourceRoot":"","sources":["../../src/lib/space-detection.ts"],"names":[],"mappings":"AAAA,OAAO,EAKL,KAAK,QAAQ,EACd,MAAM,WAAW,CAAA;AAalB,KAAK,OAAO,GAAG;IAAE,CAAC,EAAE,MAAM,CAAC;IAAC,CAAC,EAAE,MAAM,CAAA;CAAE,CAAA;AAEvC,MAAM,MAAM,KAAK,GAAG;IAClB,EAAE,EAAE,MAAM,CAAA;IACV,OAAO,EAAE,MAAM,CAAA;IACf,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;IAChC,OAAO,EAAE,MAAM,EAAE,CAAA;IACjB,UAAU,EAAE,OAAO,CAAA;CACpB,CAAA;AAED,KAAK,cAAc,GAAG;IACpB,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;IAC9C,QAAQ,EAAE,UAAU,GAAG,UAAU,GAAG,SAAS,CAAA;CAC9C,CAAA;AAkWD,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,IAAI,CAAC,QAAQ,EAAE,OAAO,GAAG,KAAK,GAAG,WAAW,GAAG,WAAW,GAAG,UAAU,CAAC,EAC9E,YAAY,EAAE,OAAO,EAAE,EAAE,GACxB,IAAI,CAAC,cAAc,EAAE,WAAW,GAAG,UAAU,CAAC,CA4ChD;AAyWD,wBAAgB,oBAAoB,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,QAAQ,EAAE;;;;EAEtE;AAsED,wBAAgB,sBAAsB,CAAC,UAAU,EAAE,GAAG,EAAE,WAAW,EAAE,GAAG,GAAG,MAAM,IAAI,CAuDpF;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,EAAE,UAAU,EAAE,QAAQ,EAAE,GAAG,OAAO,CAiBjF"}
+{"version":3,"file":"space-detection.d.ts","sourceRoot":"","sources":["../../src/lib/space-detection.ts"],"names":[],"mappings":"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"}

package/dist/lib/space-detection.js

@@ -4,9 +4,11 @@ import { getClampedWallCurveOffset, getWallCurveFrameAt, isCurvedWall, } from '.
 import { simplifyClosedPolygon } from './polygon-geometry';
 const DEFAULT_AUTO_SLAB_ELEVATION = 0.05;
 const DEFAULT_AUTO_CEILING_HEIGHT = 2.5;
+const CEILING_HEIGHT_EPSILON = 1e-6;
 const ROOM_CURVE_TOLERANCE = 0.04;
 const MAX_CURVE_SUBDIVISION_DEPTH = 6;
 const AUTO_SLAB_POLYGON_SIMPLIFY_TOLERANCE = 0.08;
+const WALL_ROOM_BOUNDARY_TOLERANCE = 0.08;
 function pointFromTuple(point) {
     return { x: point[0], y: point[1] };
 }
@@ -114,6 +116,80 @@ function bboxOverlapArea(a, b) {
     const iy = Math.max(0, Math.min(a.maxY, b.maxY) - Math.max(a.minY, b.minY));
     return ix * iy;
 }
+function pointDistanceToPolygonBoundary(point, polygon) {
+    let minDistance = Number.POSITIVE_INFINITY;
+    for (let index = 0; index < polygon.length; index += 1) {
+        const start = polygon[index];
+        const end = polygon[(index + 1) % polygon.length];
+        if (!(start && end))
+            continue;
+        minDistance = Math.min(minDistance, distanceToSegment(pointToTuple(point), pointToTuple(start), pointToTuple(end)));
+    }
+    return minDistance;
+}
+function wallBoundsRoom(wall, roomPolygon) {
+    const sampled = sampleWallPointsForRoomDetection(wall);
+    if (sampled.length === 0)
+        return false;
+    const candidates = sampled.length === 2
+        ? [
+            sampled[0],
+            {
+                x: (sampled[0].x + sampled[1].x) / 2,
+                y: (sampled[0].y + sampled[1].y) / 2,
+            },
+            sampled[1],
+        ]
+        : sampled;
+    const matchingPoints = candidates.filter((point) => pointDistanceToPolygonBoundary(point, roomPolygon) <= WALL_ROOM_BOUNDARY_TOLERANCE);
+    return matchingPoints.length >= 2;
+}
+function pointIsOnSlab(point, slab) {
+    if (slab.polygon.length < 3)
+        return false;
+    const slabPolygon = slab.polygon.map(pointFromTuple);
+    if (!pointInPolygon(point, slabPolygon))
+        return false;
+    for (const hole of slab.holes ?? []) {
+        if (hole.length >= 3 && pointInPolygon(point, hole.map(pointFromTuple))) {
+            return false;
+        }
+    }
+    return true;
+}
+function slabSupportsRoom(roomPolygon, slab) {
+    if (slab.polygon.length < 3)
+        return false;
+    if (polygonSignature(slab.polygon.map(pointFromTuple)) === polygonSignature(roomPolygon)) {
+        return true;
+    }
+    return pointIsOnSlab(polygonCentroid(roomPolygon), slab);
+}
+function resolveRoomSlabElevation(roomPolygon, slabs = []) {
+    let maxElevation = 0;
+    for (const slab of slabs) {
+        if (!slabSupportsRoom(roomPolygon, slab))
+            continue;
+        maxElevation = Math.max(maxElevation, slab.elevation ?? DEFAULT_AUTO_SLAB_ELEVATION);
+    }
+    return maxElevation;
+}
+function resolveRoomWallHeight(roomPolygon, walls = []) {
+    let maxHeight = 0;
+    for (const wall of walls) {
+        if (!wallBoundsRoom(wall, roomPolygon))
+            continue;
+        const height = wall.height ?? DEFAULT_AUTO_CEILING_HEIGHT;
+        if (Number.isFinite(height)) {
+            maxHeight = Math.max(maxHeight, height);
+        }
+    }
+    return maxHeight > 0 ? maxHeight : DEFAULT_AUTO_CEILING_HEIGHT;
+}
+function resolveAutoCeilingHeight(roomPolygon, context = {}) {
+    return (resolveRoomSlabElevation(roomPolygon, context.slabs) +
+        resolveRoomWallHeight(roomPolygon, context.walls));
+}
 function getWallDirection(wall) {
     const dx = wall.end[0] - wall.start[0];
     const dy = wall.end[1] - wall.start[1];
@@ -340,12 +416,48 @@ function wallGeometrySignature(wall) {
         wall.end[0].toFixed(4),
         wall.end[1].toFixed(4),
         (wall.thickness ?? 0.2).toFixed(4),
+        (wall.height ?? DEFAULT_AUTO_CEILING_HEIGHT).toFixed(4),
         getClampedWallCurveOffset(wall).toFixed(4),
     ].join('|');
 }
 function levelWallSnapshot(walls) {
     return walls.map(wallGeometrySignature).sort().join('||');
 }
+function slabGeometrySignature(slab) {
+    const polygon = slab.polygon
+        .map((point) => `${point[0].toFixed(4)},${point[1].toFixed(4)}`)
+        .join(';');
+    const holes = (slab.holes ?? [])
+        .map((hole) => hole.map((point) => `${point[0].toFixed(4)},${point[1].toFixed(4)}`).join(';'))
+        .join('/');
+    return [slab.id, (slab.elevation ?? DEFAULT_AUTO_SLAB_ELEVATION).toFixed(4), polygon, holes].join('|');
+}
+function levelSlabSnapshot(slabs) {
+    return slabs.map(slabGeometrySignature).sort().join('||');
+}
+function levelStructureSnapshots(nodes) {
+    const byLevel = new Map();
+    const getEntry = (levelId) => {
+        const entry = byLevel.get(levelId) ?? { walls: [], slabs: [] };
+        byLevel.set(levelId, entry);
+        return entry;
+    };
+    for (const node of Object.values(nodes)) {
+        if (!(node && typeof node === 'object' && 'parentId' in node && node.parentId))
+            continue;
+        if (node.type === 'wall') {
+            getEntry(node.parentId).walls.push(node);
+        }
+        else if (node.type === 'slab') {
+            getEntry(node.parentId).slabs.push(SlabNode.parse(node));
+        }
+    }
+    const snapshots = new Map();
+    for (const [levelId, entry] of byLevel.entries()) {
+        snapshots.set(levelId, `${levelWallSnapshot(entry.walls)}##${levelSlabSnapshot(entry.slabs)}`);
+    }
+    return snapshots;
+}
 function buildSpace(levelId, polygon) {
     const signature = polygonSignature(polygon);
     return {
@@ -356,7 +468,7 @@ function buildSpace(levelId, polygon) {
         isExterior: false,
     };
 }
-function syncAutoSlabsForLevel(levelId, roomPolygons, existingSlabs, sceneStore) {
+export function planAutoSlabsForLevel(roomPolygons, existingSlabs) {
     const manualSlabs = existingSlabs.filter((slab) => !slab.autoFromWalls);
     const manualSignatures = new Set(manualSlabs.map((slab) => polygonSignature(slab.polygon.map(pointFromTuple))));
     const detected = roomPolygons
@@ -459,17 +571,42 @@ function syncAutoSlabsForLevel(levelId, roomPolygons, existingSlabs, sceneStore)
             autoFromWalls: true,
         }));
     }
-    if (slabsToDelete.length > 0) {
-        sceneStore.getState().deleteNodes(slabsToDelete);
+    return {
+        create: slabsToCreate,
+        update: slabsToUpdate,
+        delete: slabsToDelete,
+    };
+}
+function syncAutoSlabsForLevel(levelId, roomPolygons, existingSlabs, sceneStore) {
+    const plan = planAutoSlabsForLevel(roomPolygons, existingSlabs);
+    if (plan.delete.length > 0) {
+        sceneStore.getState().deleteNodes(plan.delete);
+    }
+    if (plan.update.length > 0) {
+        sceneStore.getState().updateNodes(plan.update);
+    }
+    if (plan.create.length > 0) {
+        sceneStore.getState().createNodes(plan.create.map((node) => ({ node, parentId: levelId })));
     }
-    if (slabsToUpdate.length > 0) {
-        sceneStore.getState().updateNodes(slabsToUpdate);
+    return plan;
+}
+export function projectAutoSlabsForPlan(existingSlabs, plan) {
+    const slabsById = new Map(existingSlabs.map((slab) => [slab.id, slab]));
+    for (const id of plan.delete) {
+        slabsById.delete(id);
+    }
+    for (const update of plan.update) {
+        const slab = slabsById.get(update.id);
+        if (!slab)
+            continue;
+        slabsById.set(update.id, SlabNode.parse({ ...slab, ...update.data }));
     }
-    if (slabsToCreate.length > 0) {
-        sceneStore.getState().createNodes(slabsToCreate.map((node) => ({ node, parentId: levelId })));
+    for (const slab of plan.create) {
+        slabsById.set(slab.id, slab);
     }
+    return [...slabsById.values()];
 }
-function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, sceneStore) {
+export function planAutoCeilingsForLevel(roomPolygons, existingCeilings, context = {}) {
     const manualCeilings = existingCeilings.filter((ceiling) => !ceiling.autoFromWalls);
     const manualSignatures = new Set(manualCeilings.map((ceiling) => polygonSignature(ceiling.polygon.map(pointFromTuple))));
     const detected = roomPolygons
@@ -486,6 +623,7 @@ function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, scene
         centroid: polygonCentroid(room.poly),
         area: Math.abs(polygonArea(room.poly)),
         bbox: bboxOf(room.poly),
+        ceilingHeight: resolveAutoCeilingHeight(room.poly, context),
     }))
         .filter(({ sig }) => !manualSignatures.has(sig));
     const existingAuto = existingCeilings.filter((ceiling) => ceiling.autoFromWalls);
@@ -512,7 +650,10 @@ function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, scene
             return;
         matchedDetectedIdx.add(index);
         matchedCeilingIds.add(existing.ceiling.id);
-        updatesById.set(existing.ceiling.id, room.poly.map(pointToTuple));
+        updatesById.set(existing.ceiling.id, {
+            polygon: room.poly.map(pointToTuple),
+            height: room.ceilingHeight,
+        });
     });
     const remainingDetected = detected
         .map((room, index) => ({ room, index }))
@@ -541,7 +682,10 @@ function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, scene
             continue;
         matchedDetectedIdx.add(index);
         matchedCeilingIds.add(bestMatch.entry.ceiling.id);
-        updatesById.set(bestMatch.entry.ceiling.id, room.poly.map(pointToTuple));
+        updatesById.set(bestMatch.entry.ceiling.id, {
+            polygon: room.poly.map(pointToTuple),
+            height: room.ceilingHeight,
+        });
     }
     const ceilingsToDelete = existingAuto
         .filter((ceiling) => !updatesById.has(ceiling.id))
@@ -549,12 +693,18 @@ function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, scene
     const ceilingsToUpdate = existingAuto
         .filter((ceiling) => updatesById.has(ceiling.id))
         .flatMap((ceiling) => {
-        const polygon = updatesById.get(ceiling.id);
-        if (!polygon)
+        const update = updatesById.get(ceiling.id);
+        if (!update)
             return [];
-        return sameTuplePolygon(ceiling.polygon, polygon)
-            ? []
-            : [{ id: ceiling.id, data: { polygon } }];
+        const data = {};
+        if (!sameTuplePolygon(ceiling.polygon, update.polygon)) {
+            data.polygon = update.polygon;
+        }
+        if (Math.abs((ceiling.height ?? DEFAULT_AUTO_CEILING_HEIGHT) - update.height) >
+            CEILING_HEIGHT_EPSILON) {
+            data.height = update.height;
+        }
+        return Object.keys(data).length === 0 ? [] : [{ id: ceiling.id, data }];
     });
     const plannedCeilingsForNaming = [...existingCeilings];
     const ceilingsToCreate = [];
@@ -570,18 +720,26 @@ function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, scene
             name,
             polygon: room.poly.map(pointToTuple),
             holes: [],
-            height: DEFAULT_AUTO_CEILING_HEIGHT,
+            height: room.ceilingHeight,
             autoFromWalls: true,
         }));
     }
-    if (ceilingsToDelete.length > 0) {
-        sceneStore.getState().deleteNodes(ceilingsToDelete);
+    return {
+        create: ceilingsToCreate,
+        update: ceilingsToUpdate,
+        delete: ceilingsToDelete,
+    };
+}
+function syncAutoCeilingsForLevel(levelId, roomPolygons, existingCeilings, sceneStore, context = {}) {
+    const plan = planAutoCeilingsForLevel(roomPolygons, existingCeilings, context);
+    if (plan.delete.length > 0) {
+        sceneStore.getState().deleteNodes(plan.delete);
     }
-    if (ceilingsToUpdate.length > 0) {
-        sceneStore.getState().updateNodes(ceilingsToUpdate);
+    if (plan.update.length > 0) {
+        sceneStore.getState().updateNodes(plan.update);
     }
-    if (ceilingsToCreate.length > 0) {
-        sceneStore.getState().createNodes(ceilingsToCreate.map((node) => ({ node, parentId: levelId })));
+    if (plan.create.length > 0) {
+        sceneStore.getState().createNodes(plan.create.map((node) => ({ node, parentId: levelId })));
     }
 }
 function detectSpacesFromWalls(levelId, walls) {
@@ -626,14 +784,36 @@ function runSpaceDetection(levelIds, sceneStore, editorStore, nodes) {
                 },
             })));
         }
-        syncAutoSlabsForLevel(levelId, roomPolygons, slabs.map((slab) => SlabNode.parse(slab)), sceneStore);
-        syncAutoCeilingsForLevel(levelId, roomPolygons, ceilings.map((ceiling) => CeilingNode.parse(ceiling)), sceneStore);
+        const parsedSlabs = slabs.map((slab) => SlabNode.parse(slab));
+        const slabPlan = syncAutoSlabsForLevel(levelId, roomPolygons, parsedSlabs, sceneStore);
+        const projectedSlabs = projectAutoSlabsForPlan(parsedSlabs, slabPlan);
+        syncAutoCeilingsForLevel(levelId, roomPolygons, ceilings.map((ceiling) => CeilingNode.parse(ceiling)), sceneStore, { walls, slabs: projectedSlabs });
         for (const space of spaces) {
             nextSpaces[space.id] = space;
         }
     }
     editorStore.getState().setSpaces(nextSpaces);
 }
+// Refcount of outstanding pause requests, matching the pauseSceneHistory
+// pattern. The community editor flips this off while the AI is actively
+// mutating the scene so the wall-driven auto slab/ceiling sync doesn't race
+// `create_room`'s explicit slabs/ceilings (see plan
+// `ai-pause-space-detection`).
+let spaceDetectionPauseDepth = 0;
+/** Pause the wall-driven auto slab/ceiling sync. Refcounted — pair with `resumeSpaceDetection`. */
+export function pauseSpaceDetection() {
+    spaceDetectionPauseDepth += 1;
+}
+/** Resume the wall-driven auto slab/ceiling sync. No-op if not currently paused. */
+export function resumeSpaceDetection() {
+    if (spaceDetectionPauseDepth === 0)
+        return;
+    spaceDetectionPauseDepth -= 1;
+}
+/** True iff the wall-driven auto slab/ceiling sync is currently paused. */
+export function isSpaceDetectionPaused() {
+    return spaceDetectionPauseDepth > 0;
+}
 export function initSpaceDetectionSync(sceneStore, editorStore) {
     const previousSnapshots = new Map();
     let isProcessing = false;
@@ -643,18 +823,16 @@ export function initSpaceDetectionSync(sceneStore, editorStore) {
         if (getSceneHistoryPauseDepth() > 0)
             return;
         const nodes = state.nodes;
-        const wallsByLevel = new Map();
-        for (const node of Object.values(nodes)) {
-            if (node && node.type === 'wall' && node.parentId) {
-                const levelId = node.parentId;
-                const levelWalls = wallsByLevel.get(levelId) ?? [];
-                levelWalls.push(node);
-                wallsByLevel.set(levelId, levelWalls);
+        const currentSnapshots = levelStructureSnapshots(nodes);
+        // Paused: roll the snapshot forward so we don't backfill (and re-duplicate)
+        // every paused change once detection resumes. Whatever the AI built while
+        // paused becomes the new baseline; only future changes will reconcile.
+        if (spaceDetectionPauseDepth > 0) {
+            previousSnapshots.clear();
+            for (const [levelId, snapshot] of currentSnapshots.entries()) {
+                previousSnapshots.set(levelId, snapshot);
             }
-        }
-        const currentSnapshots = new Map();
-        for (const [levelId, walls] of wallsByLevel.entries()) {
-            currentSnapshots.set(levelId, levelWallSnapshot(walls));
+            return;
         }
         const levelsToUpdate = new Set();
         for (const levelId of new Set([...previousSnapshots.keys(), ...currentSnapshots.keys()])) {
@@ -677,7 +855,8 @@ export function initSpaceDetectionSync(sceneStore, editorStore) {
         finally {
             resumeSceneHistory(sceneStore);
             previousSnapshots.clear();
-            for (const [levelId, snapshot] of currentSnapshots.entries()) {
+            const postRunSnapshots = levelStructureSnapshots(sceneStore.getState().nodes);
+            for (const [levelId, snapshot] of postRunSnapshots.entries()) {
                 previousSnapshots.set(levelId, snapshot);
             }
             isProcessing = false;

package/dist/lib/space-detection.test.d.ts

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

package/dist/lib/space-detection.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"space-detection.test.d.ts","sourceRoot":"","sources":["../../src/lib/space-detection.test.ts"],"names":[],"mappings":""}

package/dist/lib/space-detection.test.js

@@ -0,0 +1,77 @@
+import { describe, expect, test } from 'bun:test';
+import { CeilingNode, SlabNode, WallNode } from '../schema';
+import { planAutoCeilingsForLevel } from './space-detection';
+const square = [
+    [0, 0],
+    [4, 0],
+    [4, 3],
+    [0, 3],
+];
+function roomPolygon() {
+    return square.map(([x, y]) => ({ x, y }));
+}
+function squareWalls(height = 2.5) {
+    return [
+        WallNode.parse({ start: [0, 0], end: [4, 0], height }),
+        WallNode.parse({ start: [4, 0], end: [4, 3], height }),
+        WallNode.parse({ start: [4, 3], end: [0, 3], height }),
+        WallNode.parse({ start: [0, 3], end: [0, 0], height }),
+    ];
+}
+function slab(elevation) {
+    return SlabNode.parse({
+        polygon: square,
+        elevation,
+        autoFromWalls: true,
+    });
+}
+describe('planAutoCeilingsForLevel', () => {
+    test('creates auto ceilings at the top of the room walls', () => {
+        const created = planAutoCeilingsForLevel([roomPolygon()], [], {
+            walls: squareWalls(),
+            slabs: [slab(0.05)],
+        }).create[0];
+        expect(created?.height).toBeCloseTo(2.55);
+    });
+    test('updates existing auto ceiling height when the slab elevation changes', () => {
+        const ceiling = CeilingNode.parse({
+            polygon: square,
+            height: 2.55,
+            autoFromWalls: true,
+        });
+        const plan = planAutoCeilingsForLevel([roomPolygon()], [ceiling], {
+            walls: squareWalls(),
+            slabs: [slab(0.4)],
+        });
+        expect(plan.update).toHaveLength(1);
+        expect(plan.update[0]?.id).toBe(ceiling.id);
+        expect(plan.update[0]?.data.polygon).toBeUndefined();
+        expect(plan.update[0]?.data.height).toBeCloseTo(2.9);
+    });
+    test('updates existing auto ceiling height when wall height changes', () => {
+        const ceiling = CeilingNode.parse({
+            polygon: square,
+            height: 2.55,
+            autoFromWalls: true,
+        });
+        const plan = planAutoCeilingsForLevel([roomPolygon()], [ceiling], {
+            walls: squareWalls(3),
+            slabs: [slab(0.05)],
+        });
+        expect(plan.update).toHaveLength(1);
+        expect(plan.update[0]?.data.height).toBeCloseTo(3.05);
+    });
+    test('does not replace a manual ceiling with an auto ceiling', () => {
+        const manualCeiling = CeilingNode.parse({
+            polygon: square,
+            height: 2.5,
+            autoFromWalls: false,
+        });
+        const plan = planAutoCeilingsForLevel([roomPolygon()], [manualCeiling], {
+            walls: squareWalls(),
+            slabs: [slab(0.4)],
+        });
+        expect(plan.create).toHaveLength(0);
+        expect(plan.update).toHaveLength(0);
+    });
+});

package/dist/material-library.d.ts

@@ -8,7 +8,7 @@ export type MaterialCatalogItem = {
     previewColor?: string;
     preset: MaterialPresetPayload;
 };
-export declare const MATERIAL_CATEGORIES: readonly ["wood", "wallpaper", "parquet", "granite", "marble", "other"];
+export declare const MATERIAL_CATEGORIES: readonly ["wood", "flooring", "roof", "other"];
 export type MaterialCategory = (typeof MATERIAL_CATEGORIES)[number];
 export declare const MATERIAL_CATALOG: MaterialCatalogItem[];
 export declare function getMaterialsForCategory(category: MaterialCategory): MaterialCatalogItem[];

package/dist/material-library.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"material-library.d.ts","sourceRoot":"","sources":["../src/material-library.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,qBAAqB,EAG3B,MAAM,mBAAmB,CAAA;AAE1B,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,qBAAqB,CAAA;CAC9B,CAAA;AA4BD,eAAO,MAAM,mBAAmB,yEAOtB,CAAA;AACV,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEnE,eAAO,MAAM,gBAAgB,EAAE,mBAAmB,EAiiBjD,CAAA;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,mBAAmB,EAAE,CAEzF;AAED,wBAAgB,sBAAsB,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAGnF;AAED,eAAO,MAAM,2BAA2B,aAAa,CAAA;AAErD,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,UAE9C;AAED,wBAAgB,2BAA2B,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,iBAItE;AAED,wBAAgB,sBAAsB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,qBAAqB,GAAG,IAAI,CAIhG"}
+{"version":3,"file":"material-library.d.ts","sourceRoot":"","sources":["../src/material-library.ts"],"names":[],"mappings":"AAAA,OAAO,EACL,KAAK,qBAAqB,EAG3B,MAAM,mBAAmB,CAAA;AAE1B,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,WAAW,CAAC,EAAE,MAAM,CAAA;IACpB,mBAAmB,CAAC,EAAE,MAAM,CAAA;IAC5B,YAAY,CAAC,EAAE,MAAM,CAAA;IACrB,MAAM,EAAE,qBAAqB,CAAA;CAC9B,CAAA;AAuCD,eAAO,MAAM,mBAAmB,gDAAiD,CAAA;AACjF,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEnE,eAAO,MAAM,gBAAgB,EAAE,mBAAmB,EAqzEjD,CAAA;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,mBAAmB,EAAE,CAEzF;AAED,wBAAgB,sBAAsB,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAGnF;AAED,eAAO,MAAM,2BAA2B,aAAa,CAAA;AAErD,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,UAE9C;AAED,wBAAgB,2BAA2B,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,iBAItE;AAED,wBAAgB,sBAAsB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,qBAAqB,GAAG,IAAI,CAIhG"}