@pascal-app/core 1.0.1 → 1.0.4

package/dist/lib/unit-report.js

@@ -1,5 +1,4 @@
-import { measurementArea } from './measurement-geometry.js';
-import { resolveAutoZonePolygon } from './space-detection.js';
+import { area } from './polygon-boolean.js';
 export function buildUnitReport(unit, nodes) {
     const levels = new Map();
     const members = [...new Set(unit.members)].flatMap((id) => {
@@ -9,14 +8,16 @@ export function buildUnitReport(unit, nodes) {
         const level = zone.parentId ? nodes[zone.parentId] : undefined;
         if (level?.type === 'level')
             levels.set(level.id, level.level);
-        const polygon = resolveAutoZonePolygon(zone, (nodeId) => nodes[nodeId]);
+        const { polygon, holes } = zone;
         return [
             {
                 zoneId: zone.id,
                 name: zone.name,
                 levelId: level?.type === 'level' ? level.id : null,
                 levelOrdinal: level?.type === 'level' ? level.level : null,
-                areaM2: measurementArea(polygon.map(([x, z]) => [x, 0, z])),
+                areaM2: zone.autoFromWalls && zone.enclosureStatus === 'open'
+                    ? 0
+                    : area([{ outer: polygon, holes }]),
             },
         ];
     });

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

@@ -0,0 +1,11 @@
+/** The colour picker's swatches, in hue order. */
+export declare const ZONE_COLOR_PALETTE: readonly ["#ef4444", "#f97316", "#f59e0b", "#84cc16", "#22c55e", "#10b981", "#06b6d4", "#3b82f6", "#6366f1", "#a855f7", "#64748b", "#cccccc"];
+/**
+ * The colour a new zone is created with: a palette hue picked from a seed —
+ * the zone's id, or for an imported room a value of its source that survives
+ * re-import (a capture's id). Seeded rather than random, so every creator of
+ * the same room — the browser's reconciler, the hosted MCP bridge, a capture
+ * re-run — writes the same colour.
+ */
+export declare function zoneColorForSeed(seed: string): string;
+//# sourceMappingURL=zone-colors.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"zone-colors.d.ts","sourceRoot":"","sources":["../../src/lib/zone-colors.ts"],"names":[],"mappings":"AAAA,kDAAkD;AAClD,eAAO,MAAM,kBAAkB,+IAarB,CAAA;AAKV;;;;;;GAMG;AACH,wBAAgB,gBAAgB,CAAC,IAAI,EAAE,MAAM,GAAG,MAAM,CAOrD"}

package/dist/lib/zone-colors.js

@@ -0,0 +1,32 @@
+/** The colour picker's swatches, in hue order. */
+export const ZONE_COLOR_PALETTE = [
+    '#ef4444', // Red        0°
+    '#f97316', // Orange    30°
+    '#f59e0b', // Amber     45°
+    '#84cc16', // Lime      85°
+    '#22c55e', // Green    142°
+    '#10b981', // Emerald  160°
+    '#06b6d4', // Cyan     190°
+    '#3b82f6', // Blue     217°
+    '#6366f1', // Indigo   239°
+    '#a855f7', // Violet   270°
+    '#64748b', // Dark gray
+    '#cccccc', // Light gray
+];
+// Greys read as "no colour", so new rooms get one of the hues.
+const ROOM_HUES = ZONE_COLOR_PALETTE.slice(0, 10);
+/**
+ * The colour a new zone is created with: a palette hue picked from a seed —
+ * the zone's id, or for an imported room a value of its source that survives
+ * re-import (a capture's id). Seeded rather than random, so every creator of
+ * the same room — the browser's reconciler, the hosted MCP bridge, a capture
+ * re-run — writes the same colour.
+ */
+export function zoneColorForSeed(seed) {
+    let h = 2166136261;
+    for (let i = 0; i < seed.length; i++) {
+        h ^= seed.charCodeAt(i);
+        h = Math.imul(h, 16777619);
+    }
+    return ROOM_HUES[(h >>> 0) % ROOM_HUES.length];
+}

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

@@ -1 +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;AAYnF,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;AA8bD,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC5C,kBAAkB,CAmGpB"}
+{"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;AAwBnF,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;AAqQD,wBAAgB,wBAAwB,CACtC,IAAI,EAAE,QAAQ,EACd,UAAU,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAC,GAC5C,kBAAkB,CA2IpB"}

package/dist/lib/zone-quantities.js

@@ -2,13 +2,15 @@ import { DEFAULT_LEVEL_HEIGHT, resolveCeilingHeight } from '../services/level-he
 import { getWallPlaneTop } from '../services/storey.js';
 import { computeWallSlabSupport } from '../systems/slab/slab-support.js';
 import { sampleWallCenterline } from '../systems/wall/wall-curve.js';
-import { DEFAULT_WALL_THICKNESS } from '../systems/wall/wall-footprint.js';
+import { getWallLocalFaceZ } from '../systems/wall/wall-frame.js';
 import { resolveWallEffectiveHeight } from '../systems/wall/wall-top.js';
+import { levelWallCover } from './plate-surface.js';
+import { area, containsPoint, difference, distanceToBoundary, intersection, union, } from './polygon-boolean.js';
+import { roomFloorPlate } from './room-floor-plate.js';
 import { detectSpacesForLevel } from './space-detection.js';
 const BOUNDARY_TOLERANCE = 0.08;
 const SURFACE_COVERAGE_THRESHOLD = 0.95;
 const SPACE_CONTAINMENT_THRESHOLD = 0.95;
-const COVERAGE_SAMPLE_STEPS = 24;
 const SURFACE_DATUM_EPSILON = 1e-4;
 function pointDistance(a, b) {
     return Math.hypot(a[0] - b[0], a[1] - b[1]);
@@ -22,147 +24,6 @@ function pointToSegmentDistance(point, start, end) {
     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 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 pointInPolygon(point, polygon, includeBoundary = true) {
-    if (polygon.length < 3)
-        return false;
-    if (pointToPolygonBoundaryDistance(point, polygon) <= 1e-6)
-        return includeBoundary;
-    let inside = false;
-    for (let index = 0, previous = polygon.length - 1; index < polygon.length; previous = index++) {
-        const currentPoint = polygon[index];
-        const previousPoint = polygon[previous];
-        if (currentPoint[1] > point[1] !== previousPoint[1] > point[1] &&
-            point[0] <
-                ((previousPoint[0] - currentPoint[0]) * (point[1] - currentPoint[1])) /
-                    (previousPoint[1] - currentPoint[1]) +
-                    currentPoint[0]) {
-            inside = !inside;
-        }
-    }
-    return inside;
-}
-function segmentsCrossProperly(a, b, c, d) {
-    const cross = (start, end, point) => (end[0] - start[0]) * (point[1] - start[1]) - (end[1] - start[1]) * (point[0] - start[0]);
-    const abC = cross(a, b, c);
-    const abD = cross(a, b, d);
-    const cdA = cross(c, d, a);
-    const cdB = cross(c, d, b);
-    return abC * abD < -1e-12 && cdA * cdB < -1e-12;
-}
-function polygonContainsRegion(outer, inner) {
-    if (outer.length < 3 || inner.length < 3)
-        return false;
-    if (polygonsDescribeSameRegion(outer, inner))
-        return true;
-    if (!inner.every((point) => pointInPolygon(point, outer) ||
-        pointToPolygonBoundaryDistance(point, outer) <= BOUNDARY_TOLERANCE)) {
-        return false;
-    }
-    for (let innerIndex = 0; innerIndex < inner.length; innerIndex += 1) {
-        const innerStart = inner[innerIndex];
-        const innerEnd = inner[(innerIndex + 1) % inner.length];
-        for (let outerIndex = 0; outerIndex < outer.length; outerIndex += 1) {
-            if (segmentsCrossProperly(innerStart, innerEnd, outer[outerIndex], outer[(outerIndex + 1) % outer.length])) {
-                return false;
-            }
-        }
-    }
-    return inner.some((start, index) => {
-        const end = inner[(index + 1) % inner.length];
-        const midpoint = [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2];
-        return pointInPolygon(start, outer, false) || pointInPolygon(midpoint, outer, false);
-    });
-}
-function polygonsHaveInteriorOverlap(a, b) {
-    if (polygonsDescribeSameRegion(a, b))
-        return true;
-    if (a.some((point, index) => {
-        const end = a[(index + 1) % a.length];
-        return (pointInPolygon(point, b, false) ||
-            pointInPolygon([(point[0] + end[0]) / 2, (point[1] + end[1]) / 2], b, false));
-    })) {
-        return true;
-    }
-    if (b.some((point, index) => {
-        const end = b[(index + 1) % b.length];
-        return (pointInPolygon(point, a, false) ||
-            pointInPolygon([(point[0] + end[0]) / 2, (point[1] + end[1]) / 2], a, false));
-    })) {
-        return true;
-    }
-    for (let aIndex = 0; aIndex < a.length; aIndex += 1) {
-        for (let bIndex = 0; bIndex < b.length; bIndex += 1) {
-            if (segmentsCrossProperly(a[aIndex], a[(aIndex + 1) % a.length], b[bIndex], b[(bIndex + 1) % b.length])) {
-                return true;
-            }
-        }
-    }
-    return false;
-}
-function polygonCoverageRatio(subject, covers) {
-    if (subject.length < 3 || covers.length === 0)
-        return 0;
-    const xs = subject.map((point) => point[0]);
-    const ys = subject.map((point) => point[1]);
-    const minX = Math.min(...xs);
-    const maxX = Math.max(...xs);
-    const minY = Math.min(...ys);
-    const maxY = Math.max(...ys);
-    if (maxX - minX <= 1e-9 || maxY - minY <= 1e-9)
-        return 0;
-    let inside = 0;
-    let covered = 0;
-    for (let xIndex = 0; xIndex < COVERAGE_SAMPLE_STEPS; xIndex += 1) {
-        for (let yIndex = 0; yIndex < COVERAGE_SAMPLE_STEPS; yIndex += 1) {
-            const point = [
-                minX + ((xIndex + 0.5) / COVERAGE_SAMPLE_STEPS) * (maxX - minX),
-                minY + ((yIndex + 0.5) / COVERAGE_SAMPLE_STEPS) * (maxY - minY),
-            ];
-            if (!pointInPolygon(point, subject))
-                continue;
-            inside += 1;
-            if (covers.some((cover) => pointInPolygon(point, cover)))
-                covered += 1;
-        }
-    }
-    return inside > 0 ? covered / inside : 0;
-}
 function pointToPolylineDistance(point, polyline) {
     let best = Number.POSITIVE_INFINITY;
     for (let index = 0; index < polyline.length - 1; index += 1) {
@@ -211,22 +72,25 @@ function segmentLengthInsideOrNearPolygon(start, end, polygon, tolerance) {
     if (length <= 1e-9)
         return 0;
     const breaks = [0, 1];
-    for (let index = 0; index < polygon.length; index += 1) {
-        const polygonStart = polygon[index];
-        const polygonEnd = polygon[(index + 1) % polygon.length];
-        const edgeX = polygonEnd[0] - polygonStart[0];
-        const edgeY = polygonEnd[1] - polygonStart[1];
-        const denominator = dx * edgeY - dy * edgeX;
-        if (Math.abs(denominator) > 1e-12) {
-            const t = ((polygonStart[0] - start[0]) * edgeY - (polygonStart[1] - start[1]) * edgeX) / denominator;
-            const edgeT = ((polygonStart[0] - start[0]) * dy - (polygonStart[1] - start[1]) * dx) / denominator;
-            if (t > 0 && t < 1 && edgeT >= -1e-9 && edgeT <= 1 + 1e-9)
-                breaks.push(t);
-        }
-        if (pointToSegmentDistance(polygonStart, start, end) <= tolerance) {
-            const projected = segmentParameter(polygonStart, start, end);
-            if (projected > 0 && projected < 1)
-                breaks.push(projected);
+    for (const ring of [polygon.outer, ...polygon.holes]) {
+        for (let index = 0; index < ring.length; index += 1) {
+            const polygonStart = ring[index];
+            const polygonEnd = ring[(index + 1) % ring.length];
+            const edgeX = polygonEnd[0] - polygonStart[0];
+            const edgeY = polygonEnd[1] - polygonStart[1];
+            const denominator = dx * edgeY - dy * edgeX;
+            if (Math.abs(denominator) > 1e-12) {
+                const t = ((polygonStart[0] - start[0]) * edgeY - (polygonStart[1] - start[1]) * edgeX) /
+                    denominator;
+                const edgeT = ((polygonStart[0] - start[0]) * dy - (polygonStart[1] - start[1]) * dx) / denominator;
+                if (t > 0 && t < 1 && edgeT >= -1e-9 && edgeT <= 1 + 1e-9)
+                    breaks.push(t);
+            }
+            if (pointToSegmentDistance(polygonStart, start, end) <= tolerance) {
+                const projected = segmentParameter(polygonStart, start, end);
+                if (projected > 0 && projected < 1)
+                    breaks.push(projected);
+            }
         }
     }
     breaks.sort((a, b) => a - b);
@@ -236,8 +100,8 @@ function segmentLengthInsideOrNearPolygon(start, end, polygon, tolerance) {
         const t0 = uniqueBreaks[index];
         const t1 = uniqueBreaks[index + 1];
         const midpoint = pointAlongSegment(start, end, (t0 + t1) / 2);
-        if (pointInPolygon(midpoint, polygon) ||
-            pointToPolygonBoundaryDistance(midpoint, polygon) <= tolerance) {
+        if (containsPoint([polygon], [midpoint[0], midpoint[1]]) ||
+            distanceToBoundary([polygon], [midpoint[0], midpoint[1]]) <= tolerance) {
             insideLength += length * (t1 - t0);
         }
     }
@@ -261,10 +125,12 @@ function spansFromSpaces(spaces, zone, wallsById) {
             const wall = wallsById.get(boundary.wallId);
             if (!wall)
                 return null;
-            const tolerance = (wall.thickness ?? DEFAULT_WALL_THICKNESS) / 2 + BOUNDARY_TOLERANCE;
+            const tolerance = getWallLocalFaceZ(wall, boundary.face === 'front' ? 'a' : 'b') *
+                (boundary.face === 'front' ? 1 : -1) +
+                BOUNDARY_TOLERANCE;
             let length = 0;
             for (let index = 0; index < boundary.points.length - 1; index += 1) {
-                length += segmentLengthInsideOrNearPolygon(boundary.points[index], boundary.points[index + 1], zone.polygon, tolerance);
+                length += segmentLengthInsideOrNearPolygon(boundary.points[index], boundary.points[index + 1], { outer: zone.polygon, holes: zone.holes ?? [] }, tolerance);
             }
             if (length > 1e-6)
                 spans.push({ wall, length });
@@ -274,44 +140,47 @@ function spansFromSpaces(spaces, zone, wallsById) {
 }
 function spansFromZoneBoundary(zone, wallPaths) {
     const spans = [];
-    for (let edgeIndex = 0; edgeIndex < zone.polygon.length; edgeIndex += 1) {
-        const start = zone.polygon[edgeIndex];
-        const end = zone.polygon[(edgeIndex + 1) % zone.polygon.length];
-        const edgeLength = pointDistance(start, end);
-        if (edgeLength <= 1e-6)
-            continue;
-        const breaks = [0, 1];
-        for (const path of wallPaths) {
-            for (const point of path.points) {
-                if (pointToSegmentDistance(point, start, end) > BOUNDARY_TOLERANCE)
+    for (const ring of [zone.polygon, ...(zone.holes ?? [])]) {
+        for (let edgeIndex = 0; edgeIndex < ring.length; edgeIndex += 1) {
+            const start = ring[edgeIndex];
+            const end = ring[(edgeIndex + 1) % ring.length];
+            const edgeLength = pointDistance(start, end);
+            if (edgeLength <= 1e-6)
+                continue;
+            const breaks = [0, 1];
+            for (const path of wallPaths) {
+                for (const point of path.points) {
+                    if (pointToSegmentDistance(point, start, end) > BOUNDARY_TOLERANCE)
+                        continue;
+                    const t = segmentParameter(point, start, end);
+                    if (t > 0 && t < 1)
+                        breaks.push(t);
+                }
+            }
+            breaks.sort((a, b) => a - b);
+            const uniqueBreaks = breaks.filter((value, index) => index === 0 || value - breaks[index - 1] > 1e-6);
+            for (let index = 0; index < uniqueBreaks.length - 1; index += 1) {
+                const t0 = uniqueBreaks[index];
+                const t1 = uniqueBreaks[index + 1];
+                if (t1 - t0 <= 1e-6)
                     continue;
-                const t = segmentParameter(point, start, end);
-                if (t > 0 && t < 1)
-                    breaks.push(t);
+                const spanStart = pointAlongSegment(start, end, t0);
+                const spanEnd = pointAlongSegment(start, end, t1);
+                const wall = wallForBoundarySegment(spanStart, spanEnd, wallPaths);
+                if (!wall)
+                    return null;
+                spans.push({ wall, length: edgeLength * (t1 - t0) });
             }
         }
-        breaks.sort((a, b) => a - b);
-        const uniqueBreaks = breaks.filter((value, index) => index === 0 || value - breaks[index - 1] > 1e-6);
-        for (let index = 0; index < uniqueBreaks.length - 1; index += 1) {
-            const t0 = uniqueBreaks[index];
-            const t1 = uniqueBreaks[index + 1];
-            if (t1 - t0 <= 1e-6)
-                continue;
-            const spanStart = pointAlongSegment(start, end, t0);
-            const spanEnd = pointAlongSegment(start, end, t1);
-            const wall = wallForBoundarySegment(spanStart, spanEnd, wallPaths);
-            if (!wall)
-                return null;
-            spans.push({ wall, length: edgeLength * (t1 - t0) });
-        }
     }
     return spans.length > 0 ? spans : null;
 }
-function proveSurfaceCoverage(zone, nodes, getDatum, labels) {
-    const candidates = nodes.filter((node) => polygonsHaveInteriorOverlap(zone.polygon, node.polygon) &&
-        polygonCoverageRatio(zone.polygon, [node.polygon]) > 0);
-    if (candidates.length === 0 ||
-        polygonCoverageRatio(zone.polygon, candidates.map((node) => node.polygon)) < SURFACE_COVERAGE_THRESHOLD) {
+function proveSurfaceCoverage(zone, nodes, getDatum, labels, footprint = [{ outer: zone.polygon, holes: zone.holes ?? [] }]) {
+    const footprintArea = area(footprint);
+    const candidates = nodes.filter((node) => area(intersection(footprint, node.polygon)) > 1e-6);
+    if (!footprintArea ||
+        area(intersection(footprint, union(candidates.map((node) => node.polygon)))) / footprintArea <
+            SURFACE_COVERAGE_THRESHOLD) {
         return { status: 'unavailable', reason: `No ${labels.singular} coverage proves this zone.` };
     }
     const datum = getDatum(candidates[0]);
@@ -322,36 +191,40 @@ function proveSurfaceCoverage(zone, nodes, getDatum, labels) {
             reason: `${labels.plural} covering this zone have different ${labels.datum}.`,
         };
     }
-    let area = polygonArea(zone.polygon);
-    const seenHoles = new Set();
+    const openings = [];
     for (const node of candidates) {
-        for (const hole of node.holes) {
-            const forward = hole.map((point) => `${point[0].toFixed(6)},${point[1].toFixed(6)}`).join('|');
-            const reverse = [...hole]
-                .reverse()
-                .map((point) => `${point[0].toFixed(6)},${point[1].toFixed(6)}`)
-                .join('|');
-            const key = forward < reverse ? forward : reverse;
-            if (seenHoles.has(key))
+        for (const hole of node.holes ?? []) {
+            const overlap = area(intersection(footprint, hole));
+            if (overlap <= 1e-6)
                 continue;
-            seenHoles.add(key);
-            if (polygonContainsRegion(hole, zone.polygon)) {
+            if (area(difference(footprint, hole)) <= 1e-6) {
                 return { status: 'unavailable', reason: 'A surface opening removes this zone.' };
             }
-            if (polygonContainsRegion(zone.polygon, hole)) {
-                area -= polygonArea(hole);
-            }
-            else if (polygonsHaveInteriorOverlap(zone.polygon, hole)) {
+            if (Math.abs(overlap - area([{ outer: hole, holes: [] }])) > 1e-6) {
                 return { status: 'unavailable', reason: 'A surface opening crosses the zone boundary.' };
             }
+            openings.push(hole);
         }
     }
-    return { status: 'available', area: Math.max(0, area), datum };
+    return { status: 'available', area: area(difference(footprint, union(openings))), datum };
 }
 function unavailable(reason) {
     return { status: 'unavailable', reason };
 }
 export function deriveZoneQuantityReport(zone, sceneNodes) {
+    if (zone.autoFromWalls && zone.enclosureStatus === 'open') {
+        const missing = unavailable('The room enclosure is open.');
+        return {
+            classification: 'footprint',
+            footprintArea: 0,
+            perimeter: 0,
+            edgeLengths: [],
+            boundaryWallIds: [],
+            wallSurface: missing,
+            floorSurface: missing,
+            volume: missing,
+        };
+    }
     const levelId = zone.parentId;
     const levelNodes = levelId
         ? Object.values(sceneNodes).filter((node) => node.parentId === levelId)
@@ -359,23 +232,40 @@ export function deriveZoneQuantityReport(zone, sceneNodes) {
     const walls = levelNodes.filter((node) => node.type === 'wall');
     const slabs = levelNodes.filter((node) => node.type === 'slab');
     const wallEffectiveHeight = (wall) => {
-        const support = computeWallSlabSupport(wall, slabs, walls, wall.supportSlabId);
+        const support = computeWallSlabSupport(wall, slabs, walls, wall.supportSlabId, undefined, 0, sceneNodes);
         const planeTop = levelId ? getWallPlaneTop(wall, levelId, sceneNodes) : DEFAULT_LEVEL_HEIGHT;
         return resolveWallEffectiveHeight(wall, planeTop, support.elevation);
     };
-    const edgeLengths = zone.polygon.map((start, index) => {
-        const end = zone.polygon[(index + 1) % zone.polygon.length];
+    const edgeLengths = [zone.polygon, ...(zone.holes ?? [])].flatMap((ring) => ring.map((start, index) => {
+        const end = ring[(index + 1) % ring.length];
         return end ? pointDistance(start, end) : 0;
-    });
-    const footprintArea = polygonArea(zone.polygon);
+    }));
+    const footprint = { outer: zone.polygon, holes: zone.holes ?? [] };
+    const footprintArea = area([footprint]);
     const perimeter = edgeLengths.reduce((sum, length) => sum + length, 0);
-    const slabCoverage = proveSurfaceCoverage(zone, levelNodes.filter((node) => node.type === 'slab'), (node) => node.elevation, { singular: 'slab', plural: 'Slabs', datum: 'elevations' });
-    const ceilingCoverage = proveSurfaceCoverage(zone, levelNodes.filter((node) => node.type === 'ceiling'), (node) => resolveCeilingHeight(node, sceneNodes), { singular: 'ceiling', plural: 'Ceilings', datum: 'heights' });
+    const floorPlate = roomFloorPlate(slabs, zone.id);
+    const clearFootprint = floorPlate?.plateRole
+        ? difference(footprint, levelWallCover(walls))
+        : [footprint];
+    const slabCoverage = proveSurfaceCoverage(zone, slabs.filter((slab) => {
+        if (zone.floor?.support === 'open')
+            return slab.zoneIds?.includes(zone.id);
+        if (slab.support === 'open')
+            return false;
+        return (!floorPlate?.plateRole ||
+            !slab.plateRole ||
+            (slab.plateRole === floorPlate.plateRole && slab.zoneIds?.includes(zone.id)));
+    }), (node) => node.elevation, { singular: 'slab', plural: 'Slabs', datum: 'elevations' }, clearFootprint);
+    const ceilingCoverage = proveSurfaceCoverage(zone, levelNodes.filter((node) => node.type === 'ceiling'), (node) => resolveCeilingHeight(node, sceneNodes), { singular: 'ceiling', plural: 'Ceilings', datum: 'heights' }, clearFootprint);
     const spaces = levelId ? detectSpacesForLevel(levelId, walls).spaces : [];
-    const overlappingSpaces = spaces.filter((space) => polygonsHaveInteriorOverlap(zone.polygon, space.polygon));
-    const topologyEnclosesZone = overlappingSpaces.length > 0 &&
-        polygonCoverageRatio(zone.polygon, overlappingSpaces.map((space) => space.polygon)) >= SPACE_CONTAINMENT_THRESHOLD &&
-        overlappingSpaces.every((space) => polygonCoverageRatio(space.polygon, [zone.polygon]) >= SPACE_CONTAINMENT_THRESHOLD);
+    const spaceFootprint = (space) => ({ outer: space.polygon, holes: space.holes ?? [] });
+    const overlappingSpaces = spaces.filter((space) => area(intersection(footprint, spaceFootprint(space))) > 1e-6);
+    const topologyEnclosesZone = footprintArea > 0 &&
+        overlappingSpaces.length > 0 &&
+        area(intersection(footprint, union(overlappingSpaces.map(spaceFootprint)))) / footprintArea >=
+            SPACE_CONTAINMENT_THRESHOLD &&
+        overlappingSpaces.every((space) => area(intersection(spaceFootprint(space), footprint)) / area([spaceFootprint(space)]) >=
+            SPACE_CONTAINMENT_THRESHOLD);
     const wallsById = new Map(walls.map((wall) => [wall.id, wall]));
     const wallPaths = wallPathsFor(walls);
     const topologyWallSpans = spansFromSpaces(overlappingSpaces, zone, wallsById);

package/dist/material-library.d.ts

@@ -1,4 +1,4 @@
-import { type MaterialPresetPayload } from './schema/material.js';
+import { type MaterialPresetPayload, type MaterialSchema } from './schema/material.js';
 export type MaterialSource = 'pascal' | 'community' | 'mine' | 'workspace';
 export type MaterialCatalogItem = {
     id: string;
@@ -43,5 +43,13 @@ export type ParsedMaterialRef = {
     id: string;
 };
 export declare function parseMaterialRef(ref?: string | null): ParsedMaterialRef | null;
+/**
+ * A plain CSS hex colour (`#rgb` / `#rrggbb`) stored where a `MaterialRef`
+ * goes, e.g. a slot value: it paints that flat colour, as
+ * `material: { properties: { color } }` does. Lowercased, or null.
+ */
+export declare function parseMaterialColor(value?: string | null): string | null;
+/** The flat material a plain colour stored as a material ref paints. */
+export declare function materialColorPaint(color: string): MaterialSchema;
 export declare function getMaterialPresetByRef(materialRef?: string | null): MaterialPresetPayload | null;
 //# sourceMappingURL=material-library.d.ts.map

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,cAAc,GAAG,QAAQ,GAAG,WAAW,GAAG,MAAM,GAAG,WAAW,CAAA;AAE1E,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,2EAA2E;IAC3E,MAAM,CAAC,EAAE,cAAc,CAAA;IACvB;;;OAGG;IACH,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAA;IAC5B,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,0KAiBtB,CAAA;AACV,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEnE,eAAO,MAAM,iBAAiB,uEAOpB,CAAA;AACV,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEhE,eAAO,MAAM,gBAAgB,EAAE,mBAAmB,EAi+HjD,CAAA;AAkBD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,mBAAmB,EAAE,GAAG,IAAI,CAM3E;AAED,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,CAM9D;AAED,wBAAgB,0BAA0B,IAAI,mBAAmB,EAAE,CAElE;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAK1E;AAED,wBAAgB,0BAA0B,IAAI,MAAM,CAEnD;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,mBAAmB,EAAE,CAMzF;AAED,wBAAgB,sBAAsB,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAGnF;AAED,eAAO,MAAM,2BAA2B,aAAa,CAAA;AACrD,eAAO,MAAM,yBAAyB,WAAW,CAAA;AAEjD,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,UAE9C;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,UAE5C;AAED,wBAAgB,2BAA2B,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,iBAItE;AAED,wBAAgB,yBAAyB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAIpF;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,CAAA;AAEhC,MAAM,MAAM,iBAAiB,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAE/F,wBAAgB,gBAAgB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,iBAAiB,GAAG,IAAI,CAM9E;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,EAE1B,KAAK,cAAc,EAGpB,MAAM,mBAAmB,CAAA;AAE1B,MAAM,MAAM,cAAc,GAAG,QAAQ,GAAG,WAAW,GAAG,MAAM,GAAG,WAAW,CAAA;AAE1E,MAAM,MAAM,mBAAmB,GAAG;IAChC,EAAE,EAAE,MAAM,CAAA;IACV,KAAK,EAAE,MAAM,CAAA;IACb,QAAQ,EAAE,gBAAgB,CAAA;IAC1B,2EAA2E;IAC3E,MAAM,CAAC,EAAE,cAAc,CAAA;IACvB;;;OAGG;IACH,QAAQ,CAAC,EAAE,eAAe,EAAE,CAAA;IAC5B,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,0KAiBtB,CAAA;AACV,MAAM,MAAM,gBAAgB,GAAG,CAAC,OAAO,mBAAmB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEnE,eAAO,MAAM,iBAAiB,uEAOpB,CAAA;AACV,MAAM,MAAM,eAAe,GAAG,CAAC,OAAO,iBAAiB,CAAC,CAAC,MAAM,CAAC,CAAA;AAEhE,eAAO,MAAM,gBAAgB,EAAE,mBAAmB,EA2/IjD,CAAA;AAkBD,wBAAgB,wBAAwB,CAAC,KAAK,EAAE,mBAAmB,EAAE,GAAG,IAAI,CAM3E;AAED,wBAAgB,0BAA0B,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,IAAI,CAM9D;AAED,wBAAgB,0BAA0B,IAAI,mBAAmB,EAAE,CAElE;AAED,wBAAgB,yBAAyB,CAAC,QAAQ,EAAE,MAAM,IAAI,GAAG,MAAM,IAAI,CAK1E;AAED,wBAAgB,0BAA0B,IAAI,MAAM,CAEnD;AAED,wBAAgB,uBAAuB,CAAC,QAAQ,EAAE,gBAAgB,GAAG,mBAAmB,EAAE,CAMzF;AAED,wBAAgB,sBAAsB,CAAC,EAAE,CAAC,EAAE,MAAM,GAAG,mBAAmB,GAAG,SAAS,CAGnF;AAED,eAAO,MAAM,2BAA2B,aAAa,CAAA;AACrD,eAAO,MAAM,yBAAyB,WAAW,CAAA;AAEjD,wBAAgB,oBAAoB,CAAC,EAAE,EAAE,MAAM,UAE9C;AAED,wBAAgB,kBAAkB,CAAC,EAAE,EAAE,MAAM,UAE5C;AAED,wBAAgB,2BAA2B,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,iBAItE;AAED,wBAAgB,yBAAyB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAIpF;AAED,MAAM,MAAM,WAAW,GAAG,MAAM,CAAA;AAEhC,MAAM,MAAM,iBAAiB,GAAG;IAAE,IAAI,EAAE,SAAS,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,GAAG;IAAE,IAAI,EAAE,OAAO,CAAC;IAAC,EAAE,EAAE,MAAM,CAAA;CAAE,CAAA;AAE/F,wBAAgB,gBAAgB,CAAC,GAAG,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,iBAAiB,GAAG,IAAI,CAM9E;AAID;;;;GAIG;AACH,wBAAgB,kBAAkB,CAAC,KAAK,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM,GAAG,IAAI,CAEvE;AAED,wEAAwE;AACxE,wBAAgB,kBAAkB,CAAC,KAAK,EAAE,MAAM,GAAG,cAAc,CAEhE;AAED,wBAAgB,sBAAsB,CAAC,WAAW,CAAC,EAAE,MAAM,GAAG,IAAI,GAAG,qBAAqB,GAAG,IAAI,CAIhG"}