@pascal-app/core 0.9.1 → 0.9.2

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

@@ -1,6 +1,6 @@
 import { describe, expect, test } from 'bun:test';
-import { CeilingNode, SlabNode, WallNode } from '../schema';
-import { planAutoCeilingsForLevel } from './space-detection';
+import { CeilingNode, SlabNode, WallNode, ZoneNode } from '../schema';
+import { detectSpacesForLevel, planAutoCeilingsForLevel, planAutoSlabsForLevel, planAutoZonesForLevel, resolveAutoZonePolygon, wallClosesRoom, } from './space-detection';
 const square = [
     [0, 0],
     [4, 0],
@@ -74,4 +74,303 @@ describe('planAutoCeilingsForLevel', () => {
         expect(plan.create).toHaveLength(0);
         expect(plan.update).toHaveLength(0);
     });
+    test('demotes an orphaned auto ceiling to manual with its polygon untouched', () => {
+        const ceiling = CeilingNode.parse({
+            polygon: square,
+            height: 2.55,
+            autoFromWalls: true,
+        });
+        const plan = planAutoCeilingsForLevel([], [ceiling]);
+        expect(plan.create).toHaveLength(0);
+        expect(plan.delete).toHaveLength(0);
+        expect(plan.update).toHaveLength(1);
+        expect(plan.update[0]?.id).toBe(ceiling.id);
+        // Ceilings render the stored polygon in both modes, so no polygon bake.
+        expect(plan.update[0]?.data).toEqual({ autoFromWalls: false });
+    });
+    test('deletes an unmatched auto ceiling absorbed by a room merge', () => {
+        const leftCeiling = CeilingNode.parse({
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            autoFromWalls: true,
+        });
+        const rightCeiling = CeilingNode.parse({
+            polygon: [
+                [4, 0],
+                [8, 0],
+                [8, 3],
+                [4, 3],
+            ],
+            autoFromWalls: true,
+        });
+        const mergedRoom = [
+            { x: 0, y: 0 },
+            { x: 8, y: 0 },
+            { x: 8, y: 3 },
+            { x: 0, y: 3 },
+        ];
+        const plan = planAutoCeilingsForLevel([mergedRoom], [leftCeiling, rightCeiling]);
+        expect(plan.create).toHaveLength(0);
+        expect(plan.delete).toHaveLength(1);
+        const survivorId = plan.update[0]?.id;
+        expect([leftCeiling.id, rightCeiling.id]).toContain(plan.delete[0]);
+        expect(plan.delete[0]).not.toBe(survivorId);
+    });
+    test('a demoted ceiling suppresses re-creating an auto ceiling when the room re-forms', () => {
+        const ceiling = CeilingNode.parse({
+            polygon: square,
+            height: 2.55,
+            autoFromWalls: true,
+        });
+        const demotion = planAutoCeilingsForLevel([], [ceiling]).update[0];
+        const demoted = CeilingNode.parse({ ...ceiling, ...demotion?.data });
+        expect(demoted.autoFromWalls).toBe(false);
+        const plan = planAutoCeilingsForLevel([roomPolygon()], [demoted], {
+            walls: squareWalls(),
+            slabs: [slab(0.05)],
+        });
+        expect(plan.create).toHaveLength(0);
+        expect(plan.update).toHaveLength(0);
+        expect(plan.delete).toHaveLength(0);
+    });
+});
+describe('detectSpacesForLevel', () => {
+    const areaOf = (polygon) => {
+        let area = 0;
+        for (let i = 0; i < polygon.length; i += 1) {
+            const a = polygon[i];
+            const b = polygon[(i + 1) % polygon.length];
+            area += a.x * b.y - b.x * a.y;
+        }
+        return Math.abs(area / 2);
+    };
+    test('detects an isolated four-wall room', () => {
+        const walls = squareWalls();
+        const { roomPolygons, spaces } = detectSpacesForLevel('level-1', walls);
+        expect(roomPolygons).toHaveLength(1);
+        expect(new Set(spaces[0]?.wallIds)).toEqual(new Set(walls.map((wall) => wall.id)));
+        expect(spaces[0]?.boundaryFaces).toHaveLength(4);
+        expect(spaces[0]?.boundaryFaces.map((boundary) => `${boundary.wallId}:${boundary.face}`).sort()).toEqual(walls.map((wall) => `${wall.id}:front`).sort());
+    });
+    test('excludes dangling wall branches from a room boundary', () => {
+        const roomWalls = squareWalls();
+        const branch = WallNode.parse({ start: [0, 0], end: [1, 1] });
+        const { roomPolygons, spaces } = detectSpacesForLevel('level-1', [...roomWalls, branch]);
+        expect(roomPolygons).toHaveLength(1);
+        expect(roomPolygons[0]).toHaveLength(4);
+        expect(areaOf(roomPolygons[0])).toBeCloseTo(12);
+        expect(spaces[0]?.wallIds.sort()).toEqual(roomWalls.map((wall) => wall.id).sort());
+        expect(spaces[0]?.boundaryFaces).toHaveLength(4);
+    });
+    test('detects a room closed against the middle of an existing wall (T-junction)', () => {
+        // Big 6×5 room; a smaller room hangs below, its two verticals landing on the
+        // interior of the big room's bottom wall (x=1 and x=3, not endpoints). Before
+        // planarization those touch points were dangling nodes and the small room
+        // was never detected.
+        const walls = [
+            WallNode.parse({ start: [0, 0], end: [6, 0] }),
+            WallNode.parse({ start: [6, 0], end: [6, 5] }),
+            WallNode.parse({ start: [6, 5], end: [0, 5] }),
+            WallNode.parse({ start: [0, 5], end: [0, 0] }),
+            WallNode.parse({ start: [1, 0], end: [1, -2] }),
+            WallNode.parse({ start: [1, -2], end: [3, -2] }),
+            WallNode.parse({ start: [3, -2], end: [3, 0] }),
+        ];
+        const { roomPolygons, spaces } = detectSpacesForLevel('level-1', walls);
+        const areas = roomPolygons.map((poly) => areaOf(poly)).sort((a, b) => a - b);
+        const smallRoom = spaces.find((space) => areaOf(space.polygon.map(([x, y]) => ({ x, y }))) < 5);
+        expect(roomPolygons).toHaveLength(2);
+        expect(areas[0]).toBeCloseTo(4, 1); // small room: 2×2
+        expect(areas[1]).toBeCloseTo(30, 1); // big room: 6×5
+        expect(new Set(smallRoom?.wallIds)).toEqual(new Set([walls[0].id, walls[4].id, walls[5].id, walls[6].id]));
+        const longWallId = walls[0].id;
+        const longWallBoundaries = spaces.flatMap((space) => space.boundaryFaces.filter((boundary) => boundary.wallId === longWallId));
+        expect(longWallBoundaries).toHaveLength(4);
+        expect(longWallBoundaries.filter((boundary) => boundary.face === 'back')).toHaveLength(1);
+        expect(longWallBoundaries.filter((boundary) => boundary.face === 'front')).toHaveLength(3);
+        expect(longWallBoundaries.map((boundary) => boundary.points)).toContainEqual([
+            [1, 0],
+            [3, 0],
+        ]);
+    });
+});
+describe('procedural zones', () => {
+    test('adopts an exact room footprint and records its enclosing walls', () => {
+        const walls = squareWalls();
+        const { spaces } = detectSpacesForLevel('level-1', walls);
+        const zone = ZoneNode.parse({ name: 'Kitchen', polygon: square });
+        const plan = planAutoZonesForLevel(spaces, [zone]);
+        expect(plan.update).toHaveLength(1);
+        expect(plan.update[0]?.data.autoFromWalls).toBe(true);
+        expect(new Set(plan.update[0]?.data.boundaryWallIds)).toEqual(new Set(walls.map((wall) => wall.id)));
+    });
+    test('derives the live polygon from effective wall endpoints', () => {
+        const walls = squareWalls();
+        const zone = ZoneNode.parse({
+            name: 'Kitchen',
+            polygon: square,
+            autoFromWalls: true,
+            boundaryWallIds: walls.map((wall) => wall.id),
+        });
+        const movedWalls = [
+            { ...walls[0], end: [5, 0] },
+            { ...walls[1], start: [5, 0], end: [5, 3] },
+            { ...walls[2], start: [5, 3] },
+            walls[3],
+        ];
+        const byId = new Map(movedWalls.map((wall) => [wall.id, wall]));
+        const polygon = resolveAutoZonePolygon(zone, (id) => byId.get(id));
+        const plan = planAutoZonesForLevel(detectSpacesForLevel('level-1', movedWalls).spaces, [zone]);
+        expect(polygon).toContainEqual([5, 0]);
+        expect(polygon).toContainEqual([5, 3]);
+        expect(polygon).not.toContainEqual([4, 0]);
+        expect(plan.update[0]?.data.polygon).toContainEqual([5, 0]);
+    });
+    test('leaves an unrelated site zone manual', () => {
+        const { spaces } = detectSpacesForLevel('level-1', squareWalls());
+        const zone = ZoneNode.parse({
+            name: 'Lawn',
+            polygon: [
+                [10, 10],
+                [12, 10],
+                [12, 12],
+                [10, 12],
+            ],
+        });
+        expect(planAutoZonesForLevel(spaces, [zone]).update).toHaveLength(0);
+    });
+});
+describe('wallClosesRoom', () => {
+    test('is false while a chain is still open, true once it encloses a room', () => {
+        const open = [
+            WallNode.parse({ start: [0, 0], end: [4, 0] }),
+            WallNode.parse({ start: [4, 0], end: [4, 3] }),
+            WallNode.parse({ start: [4, 3], end: [0, 3] }),
+        ];
+        const closing = WallNode.parse({ start: [0, 3], end: [0, 0] });
+        expect(wallClosesRoom(open, closing)).toBe(false);
+        expect(wallClosesRoom([...open, closing], closing)).toBe(true);
+    });
+    test('fires when a bay is sealed against the middle of an existing wall', () => {
+        const bigRoom = [
+            WallNode.parse({ start: [0, 0], end: [6, 0] }),
+            WallNode.parse({ start: [6, 0], end: [6, 5] }),
+            WallNode.parse({ start: [6, 5], end: [0, 5] }),
+            WallNode.parse({ start: [0, 5], end: [0, 0] }),
+        ];
+        const bayLeft = WallNode.parse({ start: [1, 0], end: [1, -2] });
+        const bayBottom = WallNode.parse({ start: [1, -2], end: [3, -2] });
+        const bayRight = WallNode.parse({ start: [3, -2], end: [3, 0] });
+        // Two sides down and across: not enclosed yet.
+        expect(wallClosesRoom([...bigRoom, bayLeft, bayBottom], bayBottom)).toBe(false);
+        // The final side lands on the interior of the big room's bottom wall.
+        expect(wallClosesRoom([...bigRoom, bayLeft, bayBottom, bayRight], bayRight)).toBe(true);
+    });
+});
+describe('planAutoSlabsForLevel', () => {
+    test('matches two identical rooms to their own existing auto-slabs without churn', () => {
+        // Two rooms with identical polygon signatures previously collided in a
+        // signature-keyed Map, so one detected room never matched an existing slab
+        // and churned (delete + recreate) on every pass.
+        const slabA = slab(0.05);
+        const slabB = slab(0.05);
+        const plan = planAutoSlabsForLevel([roomPolygon(), roomPolygon()], [slabA, slabB]);
+        expect(plan.create).toHaveLength(0);
+        expect(plan.delete).toHaveLength(0);
+        expect(plan.update).toHaveLength(0);
+    });
+    test('deletes an extra auto-slab when only one identical room is detected', () => {
+        const plan = planAutoSlabsForLevel([roomPolygon()], [slab(0.05), slab(0.05)]);
+        expect(plan.create).toHaveLength(0);
+        expect(plan.delete).toHaveLength(1);
+    });
+    test('demotes an orphaned auto slab to manual when its room disappears', () => {
+        const painted = SlabNode.parse({
+            polygon: square,
+            elevation: 0.4,
+            autoFromWalls: true,
+        });
+        const plan = planAutoSlabsForLevel([], [painted]);
+        expect(plan.create).toHaveLength(0);
+        expect(plan.delete).toHaveLength(0);
+        expect(plan.update).toHaveLength(1);
+        const update = plan.update[0];
+        expect(update?.id).toBe(painted.id);
+        // Demotion flips only the flag — the stored polygon stays untouched
+        // (render offsets derive from level context at geometry build time).
+        expect(update?.data).toEqual({ autoFromWalls: false });
+    });
+    test('deletes an unmatched auto slab whose area was absorbed by a room merge', () => {
+        const leftSlab = SlabNode.parse({
+            polygon: [
+                [0, 0],
+                [4, 0],
+                [4, 3],
+                [0, 3],
+            ],
+            autoFromWalls: true,
+        });
+        const rightSlab = SlabNode.parse({
+            polygon: [
+                [4, 0],
+                [8, 0],
+                [8, 3],
+                [4, 3],
+            ],
+            autoFromWalls: true,
+        });
+        const mergedRoom = [
+            { x: 0, y: 0 },
+            { x: 8, y: 0 },
+            { x: 8, y: 3 },
+            { x: 0, y: 3 },
+        ];
+        const plan = planAutoSlabsForLevel([mergedRoom], [leftSlab, rightSlab]);
+        expect(plan.create).toHaveLength(0);
+        expect(plan.delete).toHaveLength(1);
+        expect(plan.update).toHaveLength(1);
+        const survivorId = plan.update[0]?.id;
+        expect([leftSlab.id, rightSlab.id]).toContain(plan.delete[0]);
+        expect(plan.delete[0]).not.toBe(survivorId);
+        // The survivor stays auto — updated to the merged polygon, not demoted.
+        expect(plan.update[0]?.data.autoFromWalls).toBeUndefined();
+    });
+    test('a demoted slab suppresses re-creating an auto slab when the room re-forms', () => {
+        const auto = slab(0.05);
+        const demotion = planAutoSlabsForLevel([], [auto]).update[0];
+        const demoted = SlabNode.parse({ ...auto, ...demotion?.data });
+        expect(demoted.autoFromWalls).toBe(false);
+        const plan = planAutoSlabsForLevel([roomPolygon()], [demoted]);
+        expect(plan.create).toHaveLength(0);
+        expect(plan.update).toHaveLength(0);
+        expect(plan.delete).toHaveLength(0);
+    });
+    test('manual slabs that split one room suppress a replacement full-room slab', () => {
+        const left = SlabNode.parse({
+            polygon: [
+                [0, 0],
+                [2, 0],
+                [2, 3],
+                [0, 3],
+            ],
+            autoFromWalls: false,
+        });
+        const right = SlabNode.parse({
+            polygon: [
+                [2, 0],
+                [4, 0],
+                [4, 3],
+                [2, 3],
+            ],
+            autoFromWalls: false,
+        });
+        const plan = planAutoSlabsForLevel([roomPolygon()], [left, right]);
+        expect(plan.create).toHaveLength(0);
+        expect(plan.update).toHaveLength(0);
+        expect(plan.delete).toHaveLength(0);
+    });
 });

package/dist/lib/wall-distance.d.ts

@@ -0,0 +1,60 @@
+import type { WallNode } from '../schema/nodes/wall';
+import type { AnyNode, AnyNodeId } from '../schema/types';
+/**
+ * Pure plan-space wall-distance math shared by the 2D opening snap
+ * (`findClosestWallInPlan` in @pascal-app/nodes) and the editor's 2D
+ * Voronoi debug overlay. One source of truth means the overlay is a
+ * faithful picture of what the snap actually decides.
+ *
+ * A wall segment's Voronoi cell is exactly "the points whose nearest wall
+ * is this segment", so nearest-segment classification == the segment
+ * Voronoi diagram. Curved walls are excluded (the opening snap rejects
+ * them — mitering + arc + opening tears in 3D).
+ */
+/**
+ * Max cursor-to-wall plan distance (metres) for a 2D opening to snap onto a
+ * wall. Tight, because plan walls are thin and often close together — a large
+ * radius would let a far wall's region reach across a nearer one. Shared so the
+ * snap and the Voronoi debug overlay clip to the exact same range.
+ */
+export declare const WALL_SNAP_DISTANCE_M = 0.4;
+export type WallSegment = {
+    wall: WallNode;
+    /** [x, z] plan start. */
+    start: readonly [number, number];
+    /** [x, z] plan end. */
+    end: readonly [number, number];
+    /** Unit direction (start → end) in plan. */
+    dirX: number;
+    dirY: number;
+    /** Segment length in metres. */
+    length: number;
+};
+export type WallSegmentClosest = {
+    segment: WallSegment;
+    /** Distance from the query point to the closest point on the segment. */
+    distance: number;
+    /** Distance along the wall from `start`, clamped to [0, length]. */
+    along: number;
+    /** Signed perpendicular offset from the wall axis (+ on the front side). */
+    perp: number;
+};
+/**
+ * Collect the straight (non-curved) wall segments that are direct children
+ * of a level — the candidates an opening can snap onto.
+ */
+export declare function collectLevelWallSegments(nodes: Record<AnyNodeId, AnyNode>, levelId: AnyNodeId | null): WallSegment[];
+/** Closest point + signed offset of one query point against one segment. */
+export declare function closestOnSegment(segment: WallSegment, pointX: number, pointY: number): {
+    distance: number;
+    along: number;
+    perp: number;
+};
+/**
+ * The single nearest wall segment to a plan point — its Voronoi cell. Returns
+ * null when `segments` is empty or (when `maxDistance` is given) nothing is
+ * within range. Ties resolve to the first segment scanned; callers pass an
+ * already-curved-filtered list from `collectLevelWallSegments`.
+ */
+export declare function nearestWallSegment(segments: readonly WallSegment[], pointX: number, pointY: number, maxDistance?: number, excludeWallId?: AnyNodeId): WallSegmentClosest | null;
+//# sourceMappingURL=wall-distance.d.ts.map

package/dist/lib/wall-distance.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"wall-distance.d.ts","sourceRoot":"","sources":["../../src/lib/wall-distance.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,sBAAsB,CAAA;AACpD,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAGzD;;;;;;;;;;GAUG;AAEH;;;;;GAKG;AACH,eAAO,MAAM,oBAAoB,MAAM,CAAA;AAEvC,MAAM,MAAM,WAAW,GAAG;IACxB,IAAI,EAAE,QAAQ,CAAA;IACd,yBAAyB;IACzB,KAAK,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAChC,uBAAuB;IACvB,GAAG,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IAC9B,4CAA4C;IAC5C,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,gCAAgC;IAChC,MAAM,EAAE,MAAM,CAAA;CACf,CAAA;AAED,MAAM,MAAM,kBAAkB,GAAG;IAC/B,OAAO,EAAE,WAAW,CAAA;IACpB,yEAAyE;IACzE,QAAQ,EAAE,MAAM,CAAA;IAChB,oEAAoE;IACpE,KAAK,EAAE,MAAM,CAAA;IACb,4EAA4E;IAC5E,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED;;;GAGG;AACH,wBAAgB,wBAAwB,CACtC,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GAAG,IAAI,GACxB,WAAW,EAAE,CA0Bf;AAED,4EAA4E;AAC5E,wBAAgB,gBAAgB,CAC9B,OAAO,EAAE,WAAW,EACpB,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,GACb;IAAE,QAAQ,EAAE,MAAM,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,EAAE,MAAM,CAAA;CAAE,CASnD;AAED;;;;;GAKG;AACH,wBAAgB,kBAAkB,CAChC,QAAQ,EAAE,SAAS,WAAW,EAAE,EAChC,MAAM,EAAE,MAAM,EACd,MAAM,EAAE,MAAM,EACd,WAAW,SAA2B,EACtC,aAAa,CAAC,EAAE,SAAS,GACxB,kBAAkB,GAAG,IAAI,CAU3B"}

package/dist/lib/wall-distance.js

@@ -0,0 +1,85 @@
+import { isCurvedWall } from '../systems/wall/wall-curve';
+/**
+ * Pure plan-space wall-distance math shared by the 2D opening snap
+ * (`findClosestWallInPlan` in @pascal-app/nodes) and the editor's 2D
+ * Voronoi debug overlay. One source of truth means the overlay is a
+ * faithful picture of what the snap actually decides.
+ *
+ * A wall segment's Voronoi cell is exactly "the points whose nearest wall
+ * is this segment", so nearest-segment classification == the segment
+ * Voronoi diagram. Curved walls are excluded (the opening snap rejects
+ * them — mitering + arc + opening tears in 3D).
+ */
+/**
+ * Max cursor-to-wall plan distance (metres) for a 2D opening to snap onto a
+ * wall. Tight, because plan walls are thin and often close together — a large
+ * radius would let a far wall's region reach across a nearer one. Shared so the
+ * snap and the Voronoi debug overlay clip to the exact same range.
+ */
+export const WALL_SNAP_DISTANCE_M = 0.4;
+/**
+ * Collect the straight (non-curved) wall segments that are direct children
+ * of a level — the candidates an opening can snap onto.
+ */
+export function collectLevelWallSegments(nodes, levelId) {
+    if (!levelId)
+        return [];
+    const level = nodes[levelId];
+    const childIds = level?.children;
+    if (!Array.isArray(childIds))
+        return [];
+    const segments = [];
+    for (const childId of childIds) {
+        const node = nodes[childId];
+        if (node?.type !== 'wall')
+            continue;
+        const wall = node;
+        if (isCurvedWall(wall))
+            continue;
+        const dx = wall.end[0] - wall.start[0];
+        const dy = wall.end[1] - wall.start[1];
+        const length = Math.hypot(dx, dy);
+        if (length < 1e-6)
+            continue;
+        segments.push({
+            wall,
+            start: wall.start,
+            end: wall.end,
+            dirX: dx / length,
+            dirY: dy / length,
+            length,
+        });
+    }
+    return segments;
+}
+/** Closest point + signed offset of one query point against one segment. */
+export function closestOnSegment(segment, pointX, pointY) {
+    const px = pointX - segment.start[0];
+    const py = pointY - segment.start[1];
+    const along = Math.max(0, Math.min(segment.length, px * segment.dirX + py * segment.dirY));
+    const perp = px * -segment.dirY + py * segment.dirX;
+    const closestX = segment.start[0] + segment.dirX * along;
+    const closestY = segment.start[1] + segment.dirY * along;
+    const distance = Math.hypot(pointX - closestX, pointY - closestY);
+    return { distance, along, perp };
+}
+/**
+ * The single nearest wall segment to a plan point — its Voronoi cell. Returns
+ * null when `segments` is empty or (when `maxDistance` is given) nothing is
+ * within range. Ties resolve to the first segment scanned; callers pass an
+ * already-curved-filtered list from `collectLevelWallSegments`.
+ */
+export function nearestWallSegment(segments, pointX, pointY, maxDistance = Number.POSITIVE_INFINITY, excludeWallId) {
+    let best = null;
+    for (const segment of segments) {
+        if (excludeWallId && segment.wall.id === excludeWallId)
+            continue;
+        const { distance, along, perp } = closestOnSegment(segment, pointX, pointY);
+        if (distance > maxDistance)
+            continue;
+        if (best && distance >= best.distance)
+            continue;
+        best = { segment, distance, along, perp };
+    }
+    return best;
+}

package/dist/lib/zone-quantities.d.ts

@@ -0,0 +1,21 @@
+import type { AnyNode, ZoneNode } from '../schema';
+export type ZoneQuantityValue = {
+    status: 'available';
+    value: number;
+    note?: string;
+} | {
+    status: 'unavailable';
+    reason: string;
+};
+export type ZoneQuantityReport = {
+    classification: 'footprint' | 'enclosed-room';
+    footprintArea: number;
+    perimeter: number;
+    edgeLengths: number[];
+    boundaryWallIds: string[];
+    wallSurface: ZoneQuantityValue;
+    floorSurface: ZoneQuantityValue;
+    volume: ZoneQuantityValue;
+};
+export declare function deriveZoneQuantityReport(zone: ZoneNode, sceneNodes: Record<string, AnyNode>): ZoneQuantityReport;
+//# sourceMappingURL=zone-quantities.d.ts.map

package/dist/lib/zone-quantities.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"zone-quantities.d.ts","sourceRoot":"","sources":["../../src/lib/zone-quantities.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAmC,QAAQ,EAAE,MAAM,WAAW,CAAA;AAOnF,MAAM,MAAM,iBAAiB,GACzB;IAAE,MAAM,EAAE,WAAW,CAAC;IAAC,KAAK,EAAE,MAAM,CAAC;IAAC,IAAI,CAAC,EAAE,MAAM,CAAA;CAAE,GACrD;IAAE,MAAM,EAAE,aAAa,CAAC;IAAC,MAAM,EAAE,MAAM,CAAA;CAAE,CAAA;AAE7C,MAAM,MAAM,kBAAkB,GAAG;IAC/B,cAAc,EAAE,WAAW,GAAG,eAAe,CAAA;IAC7C,aAAa,EAAE,MAAM,CAAA;IACrB,SAAS,EAAE,MAAM,CAAA;IACjB,WAAW,EAAE,MAAM,EAAE,CAAA;IACrB,eAAe,EAAE,MAAM,EAAE,CAAA;IACzB,WAAW,EAAE,iBAAiB,CAAA;IAC9B,YAAY,EAAE,iBAAiB,CAAA;IAC/B,MAAM,EAAE,iBAAiB,CAAA;CAC1B,CAAA;AA2HD,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAClC,kBAAkB,CA2GpB"}

package/dist/lib/zone-quantities.js

@@ -0,0 +1,183 @@
+import { sampleWallCenterline } from '../systems/wall/wall-curve';
+import { DEFAULT_WALL_HEIGHT } from '../systems/wall/wall-footprint';
+import { detectSpacesForLevel } from './space-detection';
+const BOUNDARY_TOLERANCE = 0.08;
+function pointDistance(a, b) {
+    return Math.hypot(a[0] - b[0], a[1] - b[1]);
+}
+function pointToSegmentDistance(point, start, end) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const lengthSquared = dx * dx + dy * dy;
+    if (lengthSquared <= 1e-12)
+        return pointDistance(point, start);
+    const t = Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy) / lengthSquared));
+    return pointDistance(point, [start[0] + t * dx, start[1] + t * dy]);
+}
+function pointToPolygonBoundaryDistance(point, polygon) {
+    let best = 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;
+        best = Math.min(best, pointToSegmentDistance(point, start, end));
+    }
+    return best;
+}
+function signedPolygonArea(polygon) {
+    let area = 0;
+    for (let index = 0; index < polygon.length; index += 1) {
+        const start = polygon[index];
+        const end = polygon[(index + 1) % polygon.length];
+        if (!(start && end))
+            continue;
+        area += start[0] * end[1] - end[0] * start[1];
+    }
+    return area / 2;
+}
+function polygonArea(polygon) {
+    return Math.abs(signedPolygonArea(polygon));
+}
+function polygonPerimeter(polygon) {
+    let perimeter = 0;
+    for (let index = 0; index < polygon.length; index += 1) {
+        const start = polygon[index];
+        const end = polygon[(index + 1) % polygon.length];
+        if (!(start && end))
+            continue;
+        perimeter += pointDistance(start, end);
+    }
+    return perimeter;
+}
+function polygonsDescribeSameRegion(a, b) {
+    if (a.length < 3 || b.length < 3)
+        return false;
+    const aArea = polygonArea(a);
+    const bArea = polygonArea(b);
+    const areaTolerance = Math.max(0.02, Math.max(aArea, bArea) * 0.01);
+    if (Math.abs(aArea - bArea) > areaTolerance)
+        return false;
+    return (a.every((point) => pointToPolygonBoundaryDistance(point, b) <= BOUNDARY_TOLERANCE) &&
+        b.every((point) => pointToPolygonBoundaryDistance(point, a) <= BOUNDARY_TOLERANCE));
+}
+function polygonSurfaceArea(polygon, holes = []) {
+    return Math.max(0, polygonArea(polygon) - holes.reduce((sum, hole) => sum + polygonArea(hole), 0));
+}
+function pointToPolylineDistance(point, polyline) {
+    let best = Number.POSITIVE_INFINITY;
+    for (let index = 0; index < polyline.length - 1; index += 1) {
+        const start = polyline[index];
+        const end = polyline[index + 1];
+        if (!(start && end))
+            continue;
+        best = Math.min(best, pointToSegmentDistance(point, start, end));
+    }
+    return best;
+}
+function wallForBoundarySegment(start, end, walls) {
+    const midpoint = [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2];
+    let best = null;
+    for (const wall of walls) {
+        const centerline = sampleWallCenterline(wall, 32).map((point) => [point.x, point.y]);
+        const distances = [start, midpoint, end].map((point) => pointToPolylineDistance(point, centerline));
+        if (distances.some((distance) => distance > BOUNDARY_TOLERANCE))
+            continue;
+        const distance = distances.reduce((sum, value) => sum + value, 0);
+        if (!best || distance < best.distance)
+            best = { wall, distance };
+    }
+    return best?.wall ?? null;
+}
+function matchingSurfaceNodes(zone, nodes) {
+    return nodes.filter((node) => polygonsDescribeSameRegion(zone.polygon, node.polygon));
+}
+function unavailable(reason) {
+    return { status: 'unavailable', reason };
+}
+export function deriveZoneQuantityReport(zone, sceneNodes) {
+    const levelId = zone.parentId;
+    const levelNodes = levelId
+        ? Object.values(sceneNodes).filter((node) => node.parentId === levelId)
+        : [];
+    const walls = levelNodes.filter((node) => node.type === 'wall');
+    const slabs = matchingSurfaceNodes(zone, levelNodes.filter((node) => node.type === 'slab'));
+    const ceilings = matchingSurfaceNodes(zone, levelNodes.filter((node) => node.type === 'ceiling'));
+    const edgeLengths = zone.polygon.map((start, index) => {
+        const end = zone.polygon[(index + 1) % zone.polygon.length];
+        return end ? pointDistance(start, end) : 0;
+    });
+    const footprintArea = polygonArea(zone.polygon);
+    const perimeter = edgeLengths.reduce((sum, length) => sum + length, 0);
+    const matchingRoom = levelId
+        ? detectSpacesForLevel(levelId, walls).roomPolygons.find((polygon) => polygonsDescribeSameRegion(zone.polygon, polygon.map((point) => [point.x, point.y])))
+        : undefined;
+    const wallMatches = matchingRoom?.map((start, index) => {
+        const end = matchingRoom[(index + 1) % matchingRoom.length];
+        if (!end)
+            return null;
+        const tupleStart = [start.x, start.y];
+        const tupleEnd = [end.x, end.y];
+        const wall = wallForBoundarySegment(tupleStart, tupleEnd, walls);
+        if (!wall)
+            return null;
+        return { wall, length: pointDistance(tupleStart, tupleEnd) };
+    });
+    const allWallsProven = !!wallMatches && wallMatches.length > 0 && wallMatches.every(Boolean);
+    const boundaryWallIds = allWallsProven
+        ? [...new Set(wallMatches.map((match) => match.wall.id))]
+        : [];
+    const wallSurface = allWallsProven
+        ? {
+            status: 'available',
+            value: wallMatches.reduce((sum, match) => sum + match.length * (match.wall.height ?? DEFAULT_WALL_HEIGHT), 0),
+            note: 'Gross interior wall face before openings.',
+        }
+        : unavailable(matchingRoom
+            ? 'The closed boundary could not be assigned to every wall segment.'
+            : 'No matching closed wall loop was detected.');
+    const matchingSlab = slabs.length === 1 ? slabs[0] : undefined;
+    const floorSurface = matchingSlab
+        ? {
+            status: 'available',
+            value: polygonSurfaceArea(matchingSlab.polygon, matchingSlab.holes),
+            note: 'Matching slab surface after openings.',
+        }
+        : unavailable(slabs.length > 1
+            ? 'More than one slab matches this boundary.'
+            : 'No slab matches this zone boundary.');
+    const matchingCeiling = ceilings.length === 1 ? ceilings[0] : undefined;
+    let volume;
+    if (!matchingRoom) {
+        volume = unavailable('No matching closed wall loop was detected.');
+    }
+    else if (!matchingSlab) {
+        volume = unavailable(floorSurface.status === 'unavailable' ? floorSurface.reason : 'No floor.');
+    }
+    else if (!matchingCeiling) {
+        volume = unavailable(ceilings.length > 1
+            ? 'More than one ceiling matches this boundary.'
+            : 'No ceiling matches this zone boundary.');
+    }
+    else {
+        const clearHeight = matchingCeiling.height - matchingSlab.elevation;
+        volume =
+            Number.isFinite(clearHeight) && clearHeight > 0
+                ? {
+                    status: 'available',
+                    value: polygonSurfaceArea(matchingSlab.polygon, matchingSlab.holes) * clearHeight,
+                    note: 'Matching slab area multiplied by clear ceiling height.',
+                }
+                : unavailable('The matching ceiling is not above the slab surface.');
+    }
+    return {
+        classification: matchingRoom ? 'enclosed-room' : 'footprint',
+        footprintArea,
+        perimeter,
+        edgeLengths,
+        boundaryWallIds,
+        wallSurface,
+        floorSurface,
+        volume,
+    };
+}

package/dist/lib/zone-quantities.test.d.ts

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

package/dist/lib/zone-quantities.test.d.ts.map

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