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

package/dist/index.js

@@ -1,18 +1,21 @@
 export { emitter, eventSuffixes } from './events/bus';
+export { hiddenWallPointerEventsHeld, holdHiddenWallPointerEvents, } from './events/hidden-wall-pointer-hold';
 export { itemClipRegistry } from './hooks/scene-registry/item-clip-registry';
 export { sceneRegistry, useRegistry, } from './hooks/scene-registry/scene-registry';
 export { GROUND_SUPPORT_ID, getFloorPlacedElevation, getFloorPlacedFootprints, getFloorStackedPosition, } from './hooks/spatial-grid/floor-placed-elevation';
 export { getWallBaseElevationForNodes, getWallEffectiveHeightForNodes, pointInPolygon, SUPPORT_ELEVATION_EPSILON, spatialGridManager, } from './hooks/spatial-grid/spatial-grid-manager';
 export { findLevelAncestorId, initSpatialGridSync, markSlabChangeDependents, resolveBuildingForLevel, resolveLevelId, } from './hooks/spatial-grid/spatial-grid-sync';
-export { resolveFenceSupportSlabPatch, resolveMovedWallSupportSlabPatch, resolveSupportSlabPatch, resolveWallSupportSlabPatch, } from './hooks/spatial-grid/support-host-patch';
+export { resolveFenceConstructionSupport, resolveFenceSupportSlabPatch, resolveFrozenFloorPlacementPatch, resolveMovedWallSupportSlabPatch, resolveSupportSlabPatch, resolveTerrainWallConstructionOptions, resolveWallConstruction, resolveWallSupportSlabPatch, } from './hooks/spatial-grid/support-host-patch';
 export { useSpatialQuery } from './hooks/spatial-grid/use-spatial-query';
 export { loadAssetUrl, saveAsset } from './lib/asset-storage';
 export { clampDoorOperationState, getDoorRenderOpenAmount, getGarageVisibleOpeningRatio, isOperationDoorType, SECTIONAL_GARAGE_RENDER_OPEN_SCALE, } from './lib/door-operation';
 export { getDefaultLevelName, getLevelDisplayName } from './lib/level-name';
 export { areMeasurementPointsCoplanar, closestMeasurementFeatureBinding, MEASUREMENT_PLANAR_TOLERANCE, measurementAnchorFallback, measurementAnchorReferenceNodeIds, measurementAngle, measurementArea, measurementAreaVector, measurementCentroid, measurementDistance, measurementFeatureLength, measurementNormal, measurementPerimeter, measurementPrismVolume, measurementReferenceNodeIds, remapMeasurementAnchors, remapMeasurementReferences, } from './lib/measurement-geometry';
 export { pointInPolygon as pointInPolygon2D, pointOnSegment, polygonContainsPolygon, polygonsIntersect, polygonsOverlap, segmentsIntersect, } from './lib/polygon-relations';
+export { subtractPolygonsFromPolygon, unionPolygons, } from './lib/polygon-union';
+export { compareRoofOverlapIdentity, getRoofPlanBounds, roofOverlapEntryOwns, roofPlanBoundsOverlap, roofPlanOverlapEntryOwns, } from './lib/roof-overlap';
 export { resolveSelectionProxyId, selectionProxyIdFromMetadata } from './lib/selection-proxy';
-export { getRenderableSlabPolygon, slabPolygonContextFromGeometry, snapSlabEdgeToWallBand, } from './lib/slab-polygon';
+export { getRenderableSlabPolygon, prepareSlabPolygonContext, scopeSlabPolygonContext, slabPolygonContextChanges, slabPolygonContextForLevel, slabPolygonContextFromGeometry, snapSlabEdgeToWallBand, } from './lib/slab-polygon';
 export { deriveSlotId, isSlotMaterialName, SLOT_MATERIAL_PREFIX, slotLabelFromId, } from './lib/slots';
 export { detectSpacesForLevel, initSpaceDetectionSync, isSpaceDetectionPaused, pauseSpaceDetection, planAutoCeilingsForLevel, planAutoSlabsForLevel, planAutoZonesForLevel, resolveAutoZonePolygon, resumeSpaceDetection, wallClosesRoom, wallTouchesOthers, } from './lib/space-detection';
 export { advanceStroke, beginStroke, brushHeightAt, DEFAULT_BRUSH_SETTINGS, detachStrokeAnchor, highestOver, MIN_BRUSH_RADIUS_IN_SPACINGS, maxCoverage, minBrushRadius, RAISE_METRES_PER_STROKE, sampleTarget, weightAt, } from './lib/terrain-brush';
@@ -25,10 +28,15 @@ export { closestOnSegment, collectLevelWallSegments, nearestWallSegment, WALL_SN
 export { deriveZoneQuantityReport, } from './lib/zone-quantities';
 export { getCatalogMaterialById, getDynamicLibraryMaterials, getLibraryMaterialIdFromRef, getLibraryMaterialsVersion, getMaterialPresetByRef, getMaterialsForCategory, getSceneMaterialIdFromRef, LIBRARY_MATERIAL_REF_PREFIX, MATERIAL_CATALOG, MATERIAL_CATEGORIES, MATERIAL_SURFACES, parseMaterialRef, registerLibraryMaterials, SCENE_MATERIAL_REF_PREFIX, subscribeLibraryMaterials, toLibraryMaterialRef, toSceneMaterialRef, unregisterLibraryMaterials, } from './material-library';
 export * from './registry';
+// Exported here rather than from the registry barrel: that barrel is
+// reachable from server-safe graphs (schema → spatial grid → registry)
+// and must stay free of React imports.
+export { useRegistryVersion } from './registry/use-registry-version';
 export * from './schema';
 export * from './services';
 export { isMovable, movePlanToward, moveToward, resolveMovable } from './services/movement';
-export { getSceneHistoryPauseDepth, pauseSceneHistory, resetSceneHistoryPauseDepth, resumeSceneHistory, runAsSingleSceneHistoryStep, subscribeSceneCommits, } from './store/history-control';
+export { acquireSceneHistoryPause, activeSceneCommitNodeIds, getSceneHistoryPauseDepth, pauseSceneHistory, resetSceneHistoryPauseDepth, resumeSceneHistory, runAsSingleSceneHistoryStep, subscribeSceneCommits, } from './store/history-control';
+export { getHistoryDirtyNodeIds } from './store/history-invalidation';
 export { useInteractive, } from './store/use-interactive';
 export { default as useLiveNodeOverrides, getEffectiveNode, } from './store/use-live-node-overrides';
 export { default as useLiveTerrain, } from './store/use-live-terrain';
@@ -39,22 +47,26 @@ export { getElevatorCabCenterZ, getElevatorCabDepth, getElevatorCabWidth, getEle
 export { syncAutoElevatorOpenings } from './systems/elevator/elevator-opening-sync';
 export { ElevatorOpeningSystem } from './systems/elevator/elevator-opening-system';
 export { createElevatorInteractiveState, openElevatorDoor, openElevatorDoorState, queueElevatorRequest, requestElevatorLevel, stepElevatorRuntimeState, stepElevatorRuntimes, } from './systems/elevator/elevator-runtime';
-export { ElevatorRuntimeSystem } from './systems/elevator/elevator-runtime-system';
 export { resolveElevatorBuildingLevels, resolveElevatorLevels, resolveElevatorServiceLevelIds, resolveElevatorServiceLevels, } from './systems/elevator/elevator-service';
 export { getFenceCenterlineFrameAt, getFenceCenterlineLength, sampleFenceCenterline, } from './systems/fence/fence-centerline';
 export { getFenceControlHandle, getFenceSplineFrameAt, getFenceSplineLength, getTwoPointFenceCurveTangents, isSplineFence, sampleFenceSpline, } from './systems/fence/fence-spline';
+export { resolveRoofElevation, resolveRoofWallTopElevation } from './systems/roof/roof-elevation';
+export { RoofElevationSystem } from './systems/roof/roof-elevation-system';
+export { fitRoofFootprint, resolveRoomRoofFootprint, resolveRoomRoofFootprintOnLevel, } from './systems/roof/roof-footprint';
 export { resolveSlabPlacementElevation } from './systems/slab/slab-placement';
 export { clampSlabElevationForWalls, getSlabElevationUpperBound, } from './systems/slab/slab-support';
+export { createDefaultStairSegment, createStairFlightFromStair, } from './systems/stair/stair-flight';
 export { stairFootprintAABB } from './systems/stair/stair-footprint';
 export { createSurfaceOpeningPreviewController } from './systems/stair/stair-opening-preview';
 export { syncAutoStairOpenings } from './systems/stair/stair-opening-sync';
 export { StairOpeningSystem } from './systems/stair/stair-opening-system';
 export { resolveStairTotalRise, syncStairRises } from './systems/stair/stair-rise';
-export { getClampedWallCurveOffset, getMaxWallCurveOffset, getWallArcData, getWallChordFrame, getWallCurveFrameAt, getWallCurveLength, getWallMidpointHandlePoint, getWallStraightSnapOffset, getWallSurfacePolygon, isCurvedWall, normalizeWallCurveOffset, sampleWallCenterline, } from './systems/wall/wall-curve';
+export { constrainWallCurveOffsetToAvoidIntersections, getClampedWallCurveOffset, getMaxWallCurveOffset, getWallArcData, getWallChordFrame, getWallCurveFrameAt, getWallCurveLength, getWallMidpointHandlePoint, getWallStraightSnapOffset, getWallSurfacePolygon, isCurvedWall, normalizeWallCurveOffset, sampleWallCenterline, } from './systems/wall/wall-curve';
 export { DEFAULT_WALL_HEIGHT, DEFAULT_WALL_THICKNESS, getWallPlanFootprint, getWallThickness, } from './systems/wall/wall-footprint';
 export { calculateLevelMiters, getAdjacentWallIds, getWallMiterBoundaryPoints, pointToKey, } from './systems/wall/wall-mitering';
 export { constrainWallMoveDeltaToAxis, getLinkedWallUpdates, getPerpendicularWallMoveAxis, getPlannedLinkedWallUpdates, planWallMoveJunctions, } from './systems/wall/wall-move';
 export { MIN_WALL_HEIGHT, resolveWallEffectiveHeight, resolveWallTop, } from './systems/wall/wall-top';
+export { planWallInsertion, planWallSplitAtPoint, } from './systems/wall/wall-topology';
 export { cloneLevelSubtree, cloneSceneGraph, forkSceneGraph } from './utils/clone-scene-graph';
 export { isObject } from './utils/types';
 export { validateBuildJson, } from './validation/validate-build-json';

package/dist/lib/asset-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"asset-storage.d.ts","sourceRoot":"","sources":["../../src/lib/asset-storage.ts"],"names":[],"mappings":"AAEA,eAAO,MAAM,YAAY,gBAAgB,CAAA;AAKzC;;GAEG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAI3D;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkCtE"}
+{"version":3,"file":"asset-storage.d.ts","sourceRoot":"","sources":["../../src/lib/asset-storage.ts"],"names":[],"mappings":"AAGA,eAAO,MAAM,YAAY,gBAAgB,CAAA;AAQzC;;GAEG;AACH,wBAAsB,SAAS,CAAC,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,MAAM,CAAC,CAI3D;AAED;;;GAGG;AACH,wBAAsB,YAAY,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,MAAM,GAAG,IAAI,CAAC,CAkCtE"}

package/dist/lib/asset-storage.js

@@ -1,12 +1,15 @@
 import { get, set } from 'idb-keyval';
+import { customAlphabet } from 'nanoid';
 export const ASSET_PREFIX = 'asset_data:';
 // Cache for active object URLs to prevent leaks and flickering
 const urlCache = new Map();
+// Unlike crypto.randomUUID(), nanoid works outside secure contexts.
+const nanoAssetId = customAlphabet('0123456789abcdefghijklmnopqrstuvwxyz', 16);
 /**
  * Save a file to IndexedDB and return a custom protocol URL
  */
 export async function saveAsset(file) {
-    const id = crypto.randomUUID();
+    const id = nanoAssetId();
     await set(`${ASSET_PREFIX}${id}`, file);
     return `asset://${id}`;
 }

package/dist/lib/polygon-union.d.ts

@@ -0,0 +1,4 @@
+export type Point2D = [number, number];
+export declare function unionPolygons(polygons: Point2D[][]): Point2D[][];
+export declare function subtractPolygonsFromPolygon(subject: Point2D[], cutters: Point2D[][]): Point2D[][];
+//# sourceMappingURL=polygon-union.d.ts.map

package/dist/lib/polygon-union.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-union.d.ts","sourceRoot":"","sources":["../../src/lib/polygon-union.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AA6TtC,wBAAgB,aAAa,CAAC,QAAQ,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CAShE;AA4CD,wBAAgB,2BAA2B,CAAC,OAAO,EAAE,OAAO,EAAE,EAAE,OAAO,EAAE,OAAO,EAAE,EAAE,GAAG,OAAO,EAAE,EAAE,CAkBjG"}

package/dist/lib/polygon-union.js

@@ -0,0 +1,306 @@
+const EPSILON = 1e-7;
+const KEY_SCALE = 1e6;
+function pointsEqual(a, b, tolerance = EPSILON) {
+    return Math.hypot(a[0] - b[0], a[1] - b[1]) <= tolerance;
+}
+function pointKey(point) {
+    return `${Math.round(point[0] * KEY_SCALE)}:${Math.round(point[1] * KEY_SCALE)}`;
+}
+function interpolate(a, b, t) {
+    return [a[0] + (b[0] - a[0]) * t, a[1] + (b[1] - a[1]) * t];
+}
+function cross(ax, ay, bx, by) {
+    return ax * by - ay * bx;
+}
+function polygonArea(points) {
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+        const current = points[i];
+        const next = points[(i + 1) % points.length];
+        area += current[0] * next[1] - next[0] * current[1];
+    }
+    return area / 2;
+}
+function pointOnSegment(point, start, end) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const crossValue = cross(point[0] - start[0], point[1] - start[1], dx, dz);
+    if (Math.abs(crossValue) > EPSILON)
+        return false;
+    const dot = (point[0] - start[0]) * (point[0] - end[0]) + (point[1] - start[1]) * (point[1] - end[1]);
+    return dot <= EPSILON;
+}
+function pointInPolygonOrOnBoundary(point, polygon) {
+    if (polygon.some((start, index) => pointOnSegment(point, start, polygon[(index + 1) % polygon.length]))) {
+        return true;
+    }
+    return pointInPolygon(point, polygon);
+}
+function pointInPolygon(point, polygon) {
+    let inside = false;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const pi = polygon[i];
+        const pj = polygon[j];
+        if (pointOnSegment(point, pj, pi))
+            return false;
+        const intersects = pi[1] > point[1] !== pj[1] > point[1] &&
+            point[0] < ((pj[0] - pi[0]) * (point[1] - pi[1])) / (pj[1] - pi[1]) + pi[0];
+        if (intersects)
+            inside = !inside;
+    }
+    return inside;
+}
+function normalizeRing(ring) {
+    const normalized = [];
+    for (const [x, z] of ring) {
+        if (!Number.isFinite(x) || !Number.isFinite(z))
+            continue;
+        const point = [x, z];
+        const previous = normalized[normalized.length - 1];
+        if (!previous || !pointsEqual(previous, point)) {
+            normalized.push(point);
+        }
+    }
+    const first = normalized[0];
+    const last = normalized[normalized.length - 1];
+    if (first && last && pointsEqual(first, last)) {
+        normalized.pop();
+    }
+    if (normalized.length < 3 || Math.abs(polygonArea(normalized)) <= EPSILON)
+        return [];
+    return polygonArea(normalized) < 0 ? [...normalized].reverse() : normalized;
+}
+function addSplit(edge, t) {
+    if (t < -EPSILON || t > 1 + EPSILON)
+        return;
+    const clamped = Math.max(0, Math.min(1, t));
+    if (edge.splits.some((split) => Math.abs(split - clamped) <= EPSILON))
+        return;
+    edge.splits.push(clamped);
+}
+function parameterOnEdge(point, edge) {
+    const dx = edge.end[0] - edge.start[0];
+    const dz = edge.end[1] - edge.start[1];
+    const lengthSquared = dx * dx + dz * dz;
+    if (lengthSquared <= EPSILON)
+        return 0;
+    return ((point[0] - edge.start[0]) * dx + (point[1] - edge.start[1]) * dz) / lengthSquared;
+}
+function addIntersectionSplits(left, right) {
+    const rx = left.end[0] - left.start[0];
+    const rz = left.end[1] - left.start[1];
+    const sx = right.end[0] - right.start[0];
+    const sz = right.end[1] - right.start[1];
+    const qpx = right.start[0] - left.start[0];
+    const qpz = right.start[1] - left.start[1];
+    const denominator = cross(rx, rz, sx, sz);
+    const numerator = cross(qpx, qpz, rx, rz);
+    if (Math.abs(denominator) <= EPSILON) {
+        if (Math.abs(numerator) > EPSILON)
+            return;
+        for (const point of [left.start, left.end, right.start, right.end]) {
+            if (pointOnSegment(point, left.start, left.end) &&
+                pointOnSegment(point, right.start, right.end)) {
+                addSplit(left, parameterOnEdge(point, left));
+                addSplit(right, parameterOnEdge(point, right));
+            }
+        }
+        return;
+    }
+    const t = cross(qpx, qpz, sx, sz) / denominator;
+    const u = cross(qpx, qpz, rx, rz) / denominator;
+    if (t < -EPSILON || t > 1 + EPSILON || u < -EPSILON || u > 1 + EPSILON)
+        return;
+    addSplit(left, t);
+    addSplit(right, u);
+}
+function buildEdges(polygons) {
+    const edges = [];
+    polygons.forEach((polygon, polygonIndex) => {
+        for (let i = 0; i < polygon.length; i++) {
+            edges.push({
+                start: polygon[i],
+                end: polygon[(i + 1) % polygon.length],
+                polygonIndex,
+                splits: [0, 1],
+            });
+        }
+    });
+    for (let i = 0; i < edges.length; i++) {
+        for (let j = i + 1; j < edges.length; j++) {
+            const left = edges[i];
+            const right = edges[j];
+            if (left.polygonIndex === right.polygonIndex)
+                continue;
+            addIntersectionSplits(left, right);
+        }
+    }
+    return edges;
+}
+function buildBoundarySegments(edges, polygons) {
+    const segments = [];
+    for (const edge of edges) {
+        const splits = [...edge.splits].sort((a, b) => a - b);
+        for (let i = 0; i < splits.length - 1; i++) {
+            const startT = splits[i];
+            const endT = splits[i + 1];
+            if (endT - startT <= EPSILON)
+                continue;
+            const start = interpolate(edge.start, edge.end, startT);
+            const end = interpolate(edge.start, edge.end, endT);
+            const mid = interpolate(edge.start, edge.end, (startT + endT) / 2);
+            const insideAnother = polygons.some((polygon, index) => index !== edge.polygonIndex && pointInPolygon(mid, polygon));
+            if (!insideAnother) {
+                segments.push({ start, end, used: false });
+            }
+        }
+    }
+    return removeDuplicateInteriorSegments(segments);
+}
+function segmentKey(segment) {
+    const start = pointKey(segment.start);
+    const end = pointKey(segment.end);
+    return start < end ? `${start}|${end}` : `${end}|${start}`;
+}
+function removeDuplicateInteriorSegments(segments) {
+    const groups = new Map();
+    for (const segment of segments) {
+        const key = segmentKey(segment);
+        const group = groups.get(key);
+        if (group) {
+            group.push(segment);
+        }
+        else {
+            groups.set(key, [segment]);
+        }
+    }
+    const result = [];
+    for (const group of groups.values()) {
+        if (group.length === 1) {
+            result.push(group[0]);
+            continue;
+        }
+        const firstStart = pointKey(group[0].start);
+        const firstEnd = pointKey(group[0].end);
+        const hasOppositeDirection = group.some((segment) => pointKey(segment.start) === firstEnd && pointKey(segment.end) === firstStart);
+        if (!hasOppositeDirection) {
+            result.push(group[0]);
+        }
+    }
+    return result;
+}
+function assembleRings(segments) {
+    const byStart = new Map();
+    for (const segment of segments) {
+        const key = pointKey(segment.start);
+        const group = byStart.get(key);
+        if (group) {
+            group.push(segment);
+        }
+        else {
+            byStart.set(key, [segment]);
+        }
+    }
+    const rings = [];
+    const nextBoundarySegment = (ring, candidates) => {
+        const previous = ring[ring.length - 2];
+        const current = ring[ring.length - 1];
+        const incomingX = current[0] - previous[0];
+        const incomingZ = current[1] - previous[1];
+        const reverseIncomingAngle = Math.atan2(-incomingZ, -incomingX);
+        const clockwiseTurn = (segment) => {
+            const outgoingAngle = Math.atan2(segment.end[1] - current[1], segment.end[0] - current[0]);
+            const turn = reverseIncomingAngle - outgoingAngle;
+            return ((turn % (Math.PI * 2)) + Math.PI * 2) % (Math.PI * 2);
+        };
+        return [...candidates].sort((left, right) => {
+            return (clockwiseTurn(left) - clockwiseTurn(right) ||
+                pointKey(left.end).localeCompare(pointKey(right.end)));
+        })[0];
+    };
+    for (const firstSegment of segments) {
+        if (firstSegment.used)
+            continue;
+        firstSegment.used = true;
+        const ring = [firstSegment.start, firstSegment.end];
+        const startKey = pointKey(firstSegment.start);
+        let currentKey = pointKey(firstSegment.end);
+        while (currentKey !== startKey) {
+            const candidates = byStart.get(currentKey)?.filter((segment) => !segment.used) ?? [];
+            const next = nextBoundarySegment(ring, candidates);
+            if (!next)
+                break;
+            next.used = true;
+            ring.push(next.end);
+            currentKey = pointKey(next.end);
+        }
+        if (currentKey !== startKey)
+            continue;
+        const last = ring[ring.length - 1];
+        if (last && pointsEqual(ring[0], last)) {
+            ring.pop();
+        }
+        const normalized = normalizeRing(ring);
+        if (normalized.length >= 3) {
+            rings.push(normalized);
+        }
+    }
+    return rings;
+}
+export function unionPolygons(polygons) {
+    const validPolygons = polygons.map(normalizeRing).filter((polygon) => polygon.length >= 3);
+    if (validPolygons.length <= 1)
+        return validPolygons;
+    const edges = buildEdges(validPolygons);
+    const segments = buildBoundarySegments(edges, validPolygons);
+    const rings = assembleRings(segments);
+    return rings.length > 0 ? rings : validPolygons;
+}
+function buildDifferenceBoundarySegments(edges, polygons) {
+    const subject = polygons[0];
+    const cutters = polygons.slice(1);
+    if (!subject)
+        return [];
+    const segments = [];
+    for (const edge of edges) {
+        const splits = [...edge.splits].sort((a, b) => a - b);
+        for (let i = 0; i < splits.length - 1; i++) {
+            const startT = splits[i];
+            const endT = splits[i + 1];
+            if (endT - startT <= EPSILON)
+                continue;
+            const start = interpolate(edge.start, edge.end, startT);
+            const end = interpolate(edge.start, edge.end, endT);
+            const mid = interpolate(edge.start, edge.end, (startT + endT) / 2);
+            if (edge.polygonIndex === 0) {
+                const insideCutter = cutters.some((cutter) => pointInPolygonOrOnBoundary(mid, cutter));
+                if (!insideCutter) {
+                    segments.push({ start, end, used: false });
+                }
+                continue;
+            }
+            const insideSubject = pointInPolygon(mid, subject);
+            const insideAnotherCutter = cutters.some((cutter, cutterIndex) => cutterIndex !== edge.polygonIndex - 1 && pointInPolygonOrOnBoundary(mid, cutter));
+            if (insideSubject && !insideAnotherCutter) {
+                segments.push({ start: end, end: start, used: false });
+            }
+        }
+    }
+    return removeDuplicateInteriorSegments(segments);
+}
+export function subtractPolygonsFromPolygon(subject, cutters) {
+    const validSubject = normalizeRing(subject);
+    if (validSubject.length < 3)
+        return [];
+    const validCutters = cutters.map(normalizeRing).filter((polygon) => polygon.length >= 3);
+    if (validCutters.length === 0)
+        return [validSubject];
+    const polygons = [validSubject, ...validCutters];
+    const edges = buildEdges(polygons);
+    const segments = buildDifferenceBoundarySegments(edges, polygons);
+    const rings = assembleRings(segments);
+    if (rings.length > 0)
+        return rings;
+    const fullyCovered = validSubject.every((point) => validCutters.some((cutter) => pointInPolygonOrOnBoundary(point, cutter)));
+    return fullyCovered ? [] : [validSubject];
+}

package/dist/lib/roof-overlap.d.ts

@@ -0,0 +1,32 @@
+export type RoofOverlapEntry = {
+    roofId: string;
+    segmentId: string;
+    supportRoofId?: string;
+    supportRoofSegmentId?: string;
+    roofType?: string;
+    width: number;
+    depth: number;
+};
+export type RoofPlanBounds = {
+    minX: number;
+    minZ: number;
+    maxX: number;
+    maxZ: number;
+};
+export type RoofPlanSegment = {
+    position: readonly [number, number, number];
+    rotation?: number;
+    width: number;
+    depth: number;
+};
+export type RoofPlan = {
+    position: readonly [number, number, number];
+    rotation?: number;
+    segments: readonly RoofPlanSegment[];
+};
+export declare function compareRoofOverlapIdentity(a: RoofOverlapEntry, b: RoofOverlapEntry): number;
+export declare function roofOverlapEntryOwns(candidate: RoofOverlapEntry, current: RoofOverlapEntry, epsilon?: number): boolean;
+export declare function roofPlanOverlapEntryOwns(candidate: RoofOverlapEntry, current: RoofOverlapEntry, epsilon?: number): boolean;
+export declare function getRoofPlanBounds(roof: RoofPlan): RoofPlanBounds | null;
+export declare function roofPlanBoundsOverlap(a: RoofPlanBounds, b: RoofPlanBounds, epsilon?: number): boolean;
+//# sourceMappingURL=roof-overlap.d.ts.map

package/dist/lib/roof-overlap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"roof-overlap.d.ts","sourceRoot":"","sources":["../../src/lib/roof-overlap.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,gBAAgB,GAAG;IAC7B,MAAM,EAAE,MAAM,CAAA;IACd,SAAS,EAAE,MAAM,CAAA;IACjB,aAAa,CAAC,EAAE,MAAM,CAAA;IACtB,oBAAoB,CAAC,EAAE,MAAM,CAAA;IAC7B,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,cAAc,GAAG;IAC3B,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;IACZ,IAAI,EAAE,MAAM,CAAA;CACb,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,KAAK,EAAE,MAAM,CAAA;IACb,KAAK,EAAE,MAAM,CAAA;CACd,CAAA;AAED,MAAM,MAAM,QAAQ,GAAG;IACrB,QAAQ,EAAE,SAAS,CAAC,MAAM,EAAE,MAAM,EAAE,MAAM,CAAC,CAAA;IAC3C,QAAQ,CAAC,EAAE,MAAM,CAAA;IACjB,QAAQ,EAAE,SAAS,eAAe,EAAE,CAAA;CACrC,CAAA;AAED,wBAAgB,0BAA0B,CAAC,CAAC,EAAE,gBAAgB,EAAE,CAAC,EAAE,gBAAgB,GAAG,MAAM,CAG3F;AAED,wBAAgB,oBAAoB,CAClC,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,gBAAgB,EACzB,OAAO,SAAO,GACb,OAAO,CAiBT;AAED,wBAAgB,wBAAwB,CACtC,SAAS,EAAE,gBAAgB,EAC3B,OAAO,EAAE,gBAAgB,EACzB,OAAO,SAAO,GACb,OAAO,CAYT;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,QAAQ,GAAG,cAAc,GAAG,IAAI,CAmCvE;AAED,wBAAgB,qBAAqB,CACnC,CAAC,EAAE,cAAc,EACjB,CAAC,EAAE,cAAc,EACjB,OAAO,SAAO,GACb,OAAO,CAOT"}

package/dist/lib/roof-overlap.js

@@ -0,0 +1,72 @@
+export function compareRoofOverlapIdentity(a, b) {
+    const roofOrder = a.roofId.localeCompare(b.roofId);
+    return roofOrder !== 0 ? roofOrder : a.segmentId.localeCompare(b.segmentId);
+}
+export function roofOverlapEntryOwns(candidate, current, epsilon = 1e-6) {
+    const candidateIsMountedOnCurrent = candidate.supportRoofId === current.roofId ||
+        candidate.supportRoofSegmentId === current.segmentId;
+    if (candidateIsMountedOnCurrent)
+        return false;
+    const currentIsMountedOnCandidate = current.supportRoofId === candidate.roofId ||
+        current.supportRoofSegmentId === candidate.segmentId;
+    if (currentIsMountedOnCandidate)
+        return true;
+    const candidateArea = candidate.width * candidate.depth;
+    const currentArea = current.width * current.depth;
+    return (candidateArea > currentArea + epsilon ||
+        (Math.abs(candidateArea - currentArea) <= epsilon &&
+            compareRoofOverlapIdentity(candidate, current) < 0));
+}
+export function roofPlanOverlapEntryOwns(candidate, current, epsilon = 1e-6) {
+    const candidateIsMountedOnCurrent = candidate.supportRoofId === current.roofId ||
+        candidate.supportRoofSegmentId === current.segmentId;
+    if (candidateIsMountedOnCurrent)
+        return true;
+    const currentIsMountedOnCandidate = current.supportRoofId === candidate.roofId ||
+        current.supportRoofSegmentId === candidate.segmentId;
+    if (currentIsMountedOnCandidate)
+        return false;
+    return roofOverlapEntryOwns(candidate, current, epsilon);
+}
+export function getRoofPlanBounds(roof) {
+    if (roof.segments.length === 0)
+        return null;
+    const roofRotation = roof.rotation ?? 0;
+    const roofCos = Math.cos(roofRotation);
+    const roofSin = Math.sin(roofRotation);
+    const bounds = {
+        minX: Number.POSITIVE_INFINITY,
+        minZ: Number.POSITIVE_INFINITY,
+        maxX: Number.NEGATIVE_INFINITY,
+        maxZ: Number.NEGATIVE_INFINITY,
+    };
+    for (const segment of roof.segments) {
+        const segmentRotation = segment.rotation ?? 0;
+        const segmentCos = Math.cos(segmentRotation);
+        const segmentSin = Math.sin(segmentRotation);
+        const halfWidth = Math.max(0, segment.width) / 2;
+        const halfDepth = Math.max(0, segment.depth) / 2;
+        for (const [x, z] of [
+            [-halfWidth, -halfDepth],
+            [halfWidth, -halfDepth],
+            [halfWidth, halfDepth],
+            [-halfWidth, halfDepth],
+        ]) {
+            const roofX = segment.position[0] + x * segmentCos + z * segmentSin;
+            const roofZ = segment.position[2] - x * segmentSin + z * segmentCos;
+            const worldX = roof.position[0] + roofX * roofCos + roofZ * roofSin;
+            const worldZ = roof.position[2] - roofX * roofSin + roofZ * roofCos;
+            bounds.minX = Math.min(bounds.minX, worldX);
+            bounds.minZ = Math.min(bounds.minZ, worldZ);
+            bounds.maxX = Math.max(bounds.maxX, worldX);
+            bounds.maxZ = Math.max(bounds.maxZ, worldZ);
+        }
+    }
+    return bounds;
+}
+export function roofPlanBoundsOverlap(a, b, epsilon = 1e-6) {
+    return !(a.maxX < b.minX - epsilon ||
+        b.maxX < a.minX - epsilon ||
+        a.maxZ < b.minZ - epsilon ||
+        b.maxZ < a.minZ - epsilon);
+}

package/dist/lib/room-topology-index.d.ts

@@ -0,0 +1,50 @@
+import type { WallNode } from '../schema';
+type SceneNodes = Record<string, any>;
+type Point = [number, number];
+type IndexedRoom = {
+    boundaryFaces: Array<{
+        wallId: WallNode['id'];
+    }>;
+};
+type IndexedLevelTopology<TRoom extends IndexedRoom> = {
+    walls: Map<string, WallNode>;
+    rooms: TRoom[];
+    wallIdsByCell: Map<string, Set<string>>;
+    cellKeysByWallId: Map<string, string[]>;
+};
+export type IndexedTopologyDelta<TRoom extends IndexedRoom> = {
+    strategy: 'indexed' | 'fallback';
+    beforeRooms: TRoom[];
+    currentRooms: TRoom[];
+    allCurrentRooms: TRoom[];
+    previousWalls: WallNode[];
+    currentWalls: WallNode[];
+    examinedWallIds: string[];
+};
+type RoomTopologyIndexOptions<TRoom extends IndexedRoom> = {
+    detectRooms: (walls: WallNode[]) => TRoom[];
+    sampleWall: (wall: WallNode) => Point[];
+    junctionTolerance: number;
+};
+export declare function distanceToSegment(point: Point, segStart: Point, segEnd: Point): number;
+export declare class RoomTopologyIndex<TRoom extends IndexedRoom> {
+    private readonly options;
+    private readonly levels;
+    private readonly queryMargin;
+    constructor(options: RoomTopologyIndexOptions<TRoom>);
+    rebuild(nodes: SceneNodes): void;
+    rebuildLevel(levelId: string, nodes: SceneNodes): IndexedLevelTopology<TRoom>;
+    applyWallDelta(levelId: string, changedWallIds: ReadonlySet<string>, beforeNodes: SceneNodes, currentNodes: SceneNodes): IndexedTopologyDelta<TRoom>;
+    private wallsForLevel;
+    private wallsFromNodes;
+    private createLevel;
+    private wallBbox;
+    private cellKeysForWall;
+    private removeWall;
+    private setWall;
+    private queryWalls;
+    private wallsTouch;
+    private connectedWallIds;
+}
+export {};
+//# sourceMappingURL=room-topology-index.d.ts.map

package/dist/lib/room-topology-index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"room-topology-index.d.ts","sourceRoot":"","sources":["../../src/lib/room-topology-index.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAGzC,KAAK,UAAU,GAAG,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAA;AACrC,KAAK,KAAK,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAE7B,KAAK,WAAW,GAAG;IACjB,aAAa,EAAE,KAAK,CAAC;QAAE,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;KAAE,CAAC,CAAA;CACjD,CAAA;AAED,KAAK,oBAAoB,CAAC,KAAK,SAAS,WAAW,IAAI;IACrD,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,QAAQ,CAAC,CAAA;IAC5B,KAAK,EAAE,KAAK,EAAE,CAAA;IACd,aAAa,EAAE,GAAG,CAAC,MAAM,EAAE,GAAG,CAAC,MAAM,CAAC,CAAC,CAAA;IACvC,gBAAgB,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,EAAE,CAAC,CAAA;CACxC,CAAA;AAED,MAAM,MAAM,oBAAoB,CAAC,KAAK,SAAS,WAAW,IAAI;IAC5D,QAAQ,EAAE,SAAS,GAAG,UAAU,CAAA;IAChC,WAAW,EAAE,KAAK,EAAE,CAAA;IACpB,YAAY,EAAE,KAAK,EAAE,CAAA;IACrB,eAAe,EAAE,KAAK,EAAE,CAAA;IACxB,aAAa,EAAE,QAAQ,EAAE,CAAA;IACzB,YAAY,EAAE,QAAQ,EAAE,CAAA;IACxB,eAAe,EAAE,MAAM,EAAE,CAAA;CAC1B,CAAA;AAED,KAAK,wBAAwB,CAAC,KAAK,SAAS,WAAW,IAAI;IACzD,WAAW,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,KAAK,KAAK,EAAE,CAAA;IAC3C,UAAU,EAAE,CAAC,IAAI,EAAE,QAAQ,KAAK,KAAK,EAAE,CAAA;IACvC,iBAAiB,EAAE,MAAM,CAAA;CAC1B,CAAA;AAqCD,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,KAAK,EAAE,QAAQ,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,UAY7E;AAkBD,qBAAa,iBAAiB,CAAC,KAAK,SAAS,WAAW;IAI1C,OAAO,CAAC,QAAQ,CAAC,OAAO;IAHpC,OAAO,CAAC,QAAQ,CAAC,MAAM,CAAiD;IACxE,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAQ;gBAEP,OAAO,EAAE,wBAAwB,CAAC,KAAK,CAAC;IAIrE,OAAO,CAAC,KAAK,EAAE,UAAU;IAczB,YAAY,CAAC,OAAO,EAAE,MAAM,EAAE,KAAK,EAAE,UAAU;IAM/C,cAAc,CACZ,OAAO,EAAE,MAAM,EACf,cAAc,EAAE,WAAW,CAAC,MAAM,CAAC,EACnC,WAAW,EAAE,UAAU,EACvB,YAAY,EAAE,UAAU,GACvB,oBAAoB,CAAC,KAAK,CAAC;IAuD9B,OAAO,CAAC,aAAa;IASrB,OAAO,CAAC,cAAc;IAOtB,OAAO,CAAC,WAAW;IAWnB,OAAO,CAAC,QAAQ;IAIhB,OAAO,CAAC,eAAe;IAIvB,OAAO,CAAC,UAAU;IAUlB,OAAO,CAAC,OAAO;IAYf,OAAO,CAAC,UAAU;IAQlB,OAAO,CAAC,UAAU;IAoBlB,OAAO,CAAC,gBAAgB;CAiBzB"}