@pascal-app/core 0.9.1 → 1.0.0-beta.1

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: Readonly<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;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"}

package/dist/lib/zone-quantities.js

@@ -0,0 +1,428 @@
+import { DEFAULT_LEVEL_HEIGHT, resolveCeilingHeight } from '../services/level-height';
+import { getWallPlaneTop } from '../services/storey';
+import { computeWallSlabSupport } from '../systems/slab/slab-support';
+import { sampleWallCenterline } from '../systems/wall/wall-curve';
+import { DEFAULT_WALL_THICKNESS } from '../systems/wall/wall-footprint';
+import { resolveWallEffectiveHeight } from '../systems/wall/wall-top';
+import { detectSpacesForLevel } from './space-detection';
+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]);
+}
+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 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) {
+        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, wallPaths) {
+    const midpoint = [(start[0] + end[0]) / 2, (start[1] + end[1]) / 2];
+    let best = null;
+    for (const { wall, points } of wallPaths) {
+        const distances = [start, midpoint, end].map((point) => pointToPolylineDistance(point, points));
+        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 wallPathsFor(walls) {
+    return walls.map((wall) => ({
+        wall,
+        points: sampleWallCenterline(wall, 32).map((point) => [point.x, point.y]),
+    }));
+}
+function pointAlongSegment(start, end, t) {
+    return [start[0] + (end[0] - start[0]) * t, start[1] + (end[1] - start[1]) * t];
+}
+function segmentParameter(point, start, end) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const lengthSquared = dx * dx + dy * dy;
+    return lengthSquared <= 1e-12
+        ? 0
+        : ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy) / lengthSquared;
+}
+function segmentLengthInsideOrNearPolygon(start, end, polygon, tolerance) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const length = Math.hypot(dx, dy);
+    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);
+        }
+    }
+    breaks.sort((a, b) => a - b);
+    const uniqueBreaks = breaks.filter((value, index) => index === 0 || value - breaks[index - 1] > 1e-7);
+    let insideLength = 0;
+    for (let index = 0; index < uniqueBreaks.length - 1; index += 1) {
+        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) {
+            insideLength += length * (t1 - t0);
+        }
+    }
+    return insideLength;
+}
+function boundaryFaceKey(boundary) {
+    const pointKey = (point) => `${point[0].toFixed(6)},${point[1].toFixed(6)}`;
+    const forward = boundary.points.map(pointKey).join('|');
+    const reverse = [...boundary.points].reverse().map(pointKey).join('|');
+    return `${boundary.wallId}:${boundary.face}:${forward < reverse ? forward : reverse}`;
+}
+function spansFromSpaces(spaces, zone, wallsById) {
+    const spans = [];
+    const seen = new Set();
+    for (const space of spaces) {
+        for (const boundary of space.boundaryFaces) {
+            const key = boundaryFaceKey(boundary);
+            if (seen.has(key))
+                continue;
+            seen.add(key);
+            const wall = wallsById.get(boundary.wallId);
+            if (!wall)
+                return null;
+            const tolerance = (wall.thickness ?? DEFAULT_WALL_THICKNESS) / 2 + 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);
+            }
+            if (length > 1e-6)
+                spans.push({ wall, length });
+        }
+    }
+    return spans.length > 0 ? spans : null;
+}
+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)
+                    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 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) {
+        return { status: 'unavailable', reason: `No ${labels.singular} coverage proves this zone.` };
+    }
+    const datum = getDatum(candidates[0]);
+    if (!Number.isFinite(datum) ||
+        candidates.some((node) => Math.abs(getDatum(node) - datum) > SURFACE_DATUM_EPSILON)) {
+        return {
+            status: 'unavailable',
+            reason: `${labels.plural} covering this zone have different ${labels.datum}.`,
+        };
+    }
+    let area = polygonArea(zone.polygon);
+    const seenHoles = new Set();
+    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))
+                continue;
+            seenHoles.add(key);
+            if (polygonContainsRegion(hole, zone.polygon)) {
+                return { status: 'unavailable', reason: 'A surface opening removes this zone.' };
+            }
+            if (polygonContainsRegion(zone.polygon, hole)) {
+                area -= polygonArea(hole);
+            }
+            else if (polygonsHaveInteriorOverlap(zone.polygon, hole)) {
+                return { status: 'unavailable', reason: 'A surface opening crosses the zone boundary.' };
+            }
+        }
+    }
+    return { status: 'available', area: Math.max(0, area), datum };
+}
+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 = levelNodes.filter((node) => node.type === 'slab');
+    const wallEffectiveHeight = (wall) => {
+        const support = computeWallSlabSupport(wall, slabs, walls, wall.supportSlabId);
+        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];
+        return end ? pointDistance(start, end) : 0;
+    });
+    const footprintArea = polygonArea(zone.polygon);
+    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 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 wallsById = new Map(walls.map((wall) => [wall.id, wall]));
+    const wallPaths = wallPathsFor(walls);
+    const topologyWallSpans = spansFromSpaces(overlappingSpaces, zone, wallsById);
+    const boundaryWallSpans = spansFromZoneBoundary(zone, wallPaths);
+    const wallSpans = topologyWallSpans ?? boundaryWallSpans;
+    const allWallsProven = Boolean(wallSpans);
+    const boundaryWallIds = wallSpans ? [...new Set(wallSpans.map((span) => span.wall.id))] : [];
+    const wallSurface = allWallsProven
+        ? {
+            status: 'available',
+            value: wallSpans.reduce((sum, span) => sum + span.length * wallEffectiveHeight(span.wall), 0),
+            note: 'Gross indoor-facing wall surface within this zone, including both sides of interior partitions.',
+        }
+        : unavailable('No indoor-facing wall surface is proven within this zone.');
+    const floorSurface = slabCoverage.status === 'available'
+        ? {
+            status: 'available',
+            value: slabCoverage.area,
+            note: 'Zone floor surface proven by compatible slab coverage, after openings.',
+        }
+        : unavailable(slabCoverage.reason);
+    let volume;
+    if (slabCoverage.status === 'unavailable') {
+        volume = unavailable(slabCoverage.reason);
+    }
+    else if (ceilingCoverage.status === 'unavailable') {
+        volume = unavailable(ceilingCoverage.reason);
+    }
+    else {
+        const clearHeight = ceilingCoverage.datum - slabCoverage.datum;
+        volume =
+            Number.isFinite(clearHeight) && clearHeight > 0
+                ? {
+                    status: 'available',
+                    value: slabCoverage.area * clearHeight,
+                    note: 'Proven zone floor area multiplied by clear ceiling height.',
+                }
+                : unavailable('The matching ceiling is not above the slab surface.');
+    }
+    return {
+        classification: topologyEnclosesZone || boundaryWallSpans ? 'enclosed-room' : 'footprint',
+        footprintArea,
+        perimeter,
+        edgeLengths,
+        boundaryWallIds,
+        wallSurface,
+        floorSurface,
+        volume,
+    };
+}

package/dist/material-library.d.ts

@@ -1,20 +1,47 @@
 import { type MaterialPresetPayload } from './schema/material';
+export type MaterialSource = 'pascal' | 'community' | 'mine' | 'workspace';
 export type MaterialCatalogItem = {
     id: string;
     label: string;
     category: MaterialCategory;
+    /** Origin of the entry. Absent = 'pascal' (all static catalog entries). */
+    source?: MaterialSource;
+    /**
+     * Where this finish is appropriate. Absent = universal (e.g. flat colors).
+     * The paint picker may filter by the slot being painted; v1 shows everything.
+     */
+    surfaces?: MaterialSurface[];
     description?: string;
     previewThumbnailUrl?: string;
     previewColor?: string;
     preset: MaterialPresetPayload;
 };
-export declare const MATERIAL_CATEGORIES: readonly ["wood", "flooring", "roof", "other"];
+export declare const MATERIAL_CATEGORIES: readonly ["colors", "wood", "stone", "brick", "tile", "wallpaper", "concrete", "metal", "plastic", "fabric", "carpet", "leather", "roofing", "ground", "glass", "other"];
 export type MaterialCategory = (typeof MATERIAL_CATEGORIES)[number];
+export declare const MATERIAL_SURFACES: readonly ["floor", "wall", "ceiling", "roof", "furniture", "outdoor"];
+export type MaterialSurface = (typeof MATERIAL_SURFACES)[number];
 export declare const MATERIAL_CATALOG: MaterialCatalogItem[];
+export declare function registerLibraryMaterials(items: MaterialCatalogItem[]): void;
+export declare function unregisterLibraryMaterials(ids: string[]): void;
+export declare function getDynamicLibraryMaterials(): MaterialCatalogItem[];
+export declare function subscribeLibraryMaterials(listener: () => void): () => void;
+export declare function getLibraryMaterialsVersion(): number;
 export declare function getMaterialsForCategory(category: MaterialCategory): MaterialCatalogItem[];
 export declare function getCatalogMaterialById(id?: string): MaterialCatalogItem | undefined;
 export declare const LIBRARY_MATERIAL_REF_PREFIX = "library:";
+export declare const SCENE_MATERIAL_REF_PREFIX = "scene:";
 export declare function toLibraryMaterialRef(id: string): string;
+export declare function toSceneMaterialRef(id: string): string;
 export declare function getLibraryMaterialIdFromRef(materialRef?: string | null): string | null;
+export declare function getSceneMaterialIdFromRef(materialRef?: string | null): string | null;
+export type MaterialRef = string;
+export type ParsedMaterialRef = {
+    kind: 'library';
+    id: string;
+} | {
+    kind: 'scene';
+    id: string;
+};
+export declare function parseMaterialRef(ref?: string | null): ParsedMaterialRef | null;
 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,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"}
+{"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"}