@pascal-app/core 0.8.0 → 0.9.2

package/dist/index.js

@@ -1,21 +1,48 @@
 export { emitter, eventSuffixes } from './events/bus';
+export { itemClipRegistry } from './hooks/scene-registry/item-clip-registry';
 export { sceneRegistry, useRegistry, } from './hooks/scene-registry/scene-registry';
-export { pointInPolygon, spatialGridManager } from './hooks/spatial-grid/spatial-grid-manager';
-export { initSpatialGridSync, resolveLevelId, } from './hooks/spatial-grid/spatial-grid-sync';
+export { getFloorPlacedElevation, getFloorPlacedFootprints, getFloorStackedPosition, } from './hooks/spatial-grid/floor-placed-elevation';
+export { pointInPolygon, spatialGridManager, } from './hooks/spatial-grid/spatial-grid-manager';
+export { findLevelAncestorId, initSpatialGridSync, resolveBuildingForLevel, resolveLevelId, } from './hooks/spatial-grid/spatial-grid-sync';
 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 { getRenderableSlabPolygon } from './lib/slab-polygon';
-export { detectSpacesForLevel, initSpaceDetectionSync, wallTouchesOthers, } from './lib/space-detection';
-export { getCatalogMaterialById, getLibraryMaterialIdFromRef, getMaterialPresetByRef, getMaterialsForCategory, LIBRARY_MATERIAL_REF_PREFIX, MATERIAL_CATALOG, MATERIAL_CATEGORIES, toLibraryMaterialRef, } from './material-library';
+export { getDefaultLevelName, getLevelDisplayName } from './lib/level-name';
+export { areMeasurementPointsCoplanar, closestMeasurementFeatureBinding, MEASUREMENT_PLANAR_TOLERANCE, measurementAnchorFallback, measurementAngle, measurementArea, measurementAreaVector, measurementCentroid, measurementDistance, measurementFeatureLength, measurementNormal, measurementPerimeter, measurementPrismVolume, measurementReferenceNodeIds, remapMeasurementReferences, } from './lib/measurement-geometry';
+export { pointInPolygon as pointInPolygon2D, pointOnSegment, polygonContainsPolygon, polygonsIntersect, polygonsOverlap, segmentsIntersect, } from './lib/polygon-relations';
+export { resolveSelectionProxyId, selectionProxyIdFromMetadata } from './lib/selection-proxy';
+export { getRenderableSlabPolygon, slabPolygonContextFromGeometry, snapSlabEdgeToWallBand, } from './lib/slab-polygon';
+export { deriveSlotId, isSlotMaterialName, SLOT_MATERIAL_PREFIX, slotLabelFromId, } from './lib/slots';
+export { detectSpacesForLevel, initSpaceDetectionSync, isSpaceDetectionPaused, pauseSpaceDetection, planAutoCeilingsForLevel, planAutoSlabsForLevel, planAutoZonesForLevel, projectAutoSlabsForPlan, resolveAutoZonePolygon, resumeSpaceDetection, wallClosesRoom, wallTouchesOthers, } from './lib/space-detection';
+export { closestOnSegment, collectLevelWallSegments, nearestWallSegment, WALL_SNAP_DISTANCE_M, } from './lib/wall-distance';
+export { deriveZoneQuantityReport, } from './lib/zone-quantities';
+export { getCatalogMaterialById, getLibraryMaterialIdFromRef, getMaterialPresetByRef, getMaterialsForCategory, getSceneMaterialIdFromRef, LIBRARY_MATERIAL_REF_PREFIX, MATERIAL_CATALOG, MATERIAL_CATEGORIES, MATERIAL_SURFACES, parseMaterialRef, SCENE_MATERIAL_REF_PREFIX, toLibraryMaterialRef, toSceneMaterialRef, } from './material-library';
+export * from './registry';
 export * from './schema';
-export { getSceneHistoryPauseDepth, pauseSceneHistory, resetSceneHistoryPauseDepth, resumeSceneHistory, } from './store/history-control';
+export * from './services';
+export { isMovable, movePlanToward, moveToward, resolveMovable } from './services/movement';
+export { getSceneHistoryPauseDepth, pauseSceneHistory, resetSceneHistoryPauseDepth, resumeSceneHistory, runAsSingleSceneHistoryStep, } from './store/history-control';
 export { useInteractive, } from './store/use-interactive';
+export { default as useLiveNodeOverrides, getEffectiveNode, } from './store/use-live-node-overrides';
 export { default as useLiveTransforms } from './store/use-live-transforms';
 export { clearSceneHistory, default as useScene } from './store/use-scene';
+export { resolveElevatorDispatchTarget } from './systems/elevator/elevator-dispatch';
+export { getElevatorCabCenterZ, getElevatorCabDepth, getElevatorCabWidth, getElevatorDoorLeafSides, getElevatorDoorLeafWidth, getElevatorDoorLeafX, getElevatorShaftDepth, getElevatorShaftWallThickness, getElevatorShaftWidth, getResolvedElevatorDoorPanelStyle, getResolvedElevatorDoorStyle, getResolvedElevatorShaftStyle, } from './systems/elevator/elevator-geometry';
+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 { DEFAULT_ELEVATOR_LEVEL_HEIGHT, getElevatorLevelHeight, 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 { 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 { getClampedWallCurveOffset, getMaxWallCurveOffset, 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 { cloneLevelSubtree, cloneSceneGraph, forkSceneGraph } from './utils/clone-scene-graph';
 export { isObject } from './utils/types';
+export { validateBuildJson, } from './validation/validate-build-json';

package/dist/lib/level-name.d.ts

@@ -0,0 +1,4 @@
+import type { LevelNode } from '../schema';
+export declare function getDefaultLevelName(level: number): string;
+export declare function getLevelDisplayName(level: Pick<LevelNode, 'name' | 'level'>): string;
+//# sourceMappingURL=level-name.d.ts.map

package/dist/lib/level-name.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"level-name.d.ts","sourceRoot":"","sources":["../../src/lib/level-name.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAE1C,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,MAAM,GAAG,MAAM,CAIzD;AAED,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,IAAI,CAAC,SAAS,EAAE,MAAM,GAAG,OAAO,CAAC,GAAG,MAAM,CAEpF"}

package/dist/lib/level-name.js

@@ -0,0 +1,10 @@
+export function getDefaultLevelName(level) {
+    if (level === 0)
+        return 'Ground Floor';
+    if (level > 0)
+        return `Floor ${level}`;
+    return `Basement ${-level}`;
+}
+export function getLevelDisplayName(level) {
+    return level.name || getDefaultLevelName(level.level);
+}

package/dist/lib/measurement-geometry.d.ts

@@ -0,0 +1,19 @@
+import type { MeasurementFeature, MeasurementFeatureBinding } from '../registry/types';
+import type { MeasurementAnchor, MeasurementPayload, MeasurementPoint } from '../schema/nodes/measurement';
+import type { AnyNodeId } from '../schema/types';
+export declare const MEASUREMENT_PLANAR_TOLERANCE = 0.01;
+export declare function measurementDistance(start: MeasurementPoint, end: MeasurementPoint): number;
+export declare function measurementAnchorFallback(anchor: MeasurementAnchor): MeasurementPoint;
+export declare function measurementAngle(start: MeasurementPoint, vertex: MeasurementPoint, end: MeasurementPoint): number;
+export declare function measurementPerimeter(points: readonly MeasurementPoint[]): number;
+export declare function measurementFeatureLength(feature: MeasurementFeature): number | null;
+export declare function closestMeasurementFeatureBinding(features: readonly MeasurementFeature[], point: MeasurementPoint, maxDistance: number): MeasurementFeatureBinding | null;
+export declare function remapMeasurementReferences(measurement: MeasurementPayload, idMap: ReadonlyMap<string, string>): MeasurementPayload;
+export declare function measurementReferenceNodeIds(measurement: MeasurementPayload): AnyNodeId[];
+export declare function measurementAreaVector(points: readonly MeasurementPoint[]): MeasurementPoint;
+export declare function measurementArea(points: readonly MeasurementPoint[]): number;
+export declare function measurementNormal(points: readonly MeasurementPoint[]): MeasurementPoint | null;
+export declare function areMeasurementPointsCoplanar(points: readonly MeasurementPoint[], tolerance?: number): boolean;
+export declare function measurementCentroid(points: readonly MeasurementPoint[]): MeasurementPoint | null;
+export declare function measurementPrismVolume(base: readonly MeasurementPoint[], extrusion: MeasurementPoint): number;
+//# sourceMappingURL=measurement-geometry.d.ts.map

package/dist/lib/measurement-geometry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"measurement-geometry.d.ts","sourceRoot":"","sources":["../../src/lib/measurement-geometry.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,kBAAkB,EAAE,yBAAyB,EAAE,MAAM,mBAAmB,CAAA;AACtF,OAAO,KAAK,EACV,iBAAiB,EACjB,kBAAkB,EAClB,gBAAgB,EACjB,MAAM,6BAA6B,CAAA;AACpC,OAAO,KAAK,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAGhD,eAAO,MAAM,4BAA4B,OAAO,CAAA;AAmBhD,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,EAAE,GAAG,EAAE,gBAAgB,GAAG,MAAM,CAE1F;AAED,wBAAgB,yBAAyB,CAAC,MAAM,EAAE,iBAAiB,GAAG,gBAAgB,CAErF;AAED,wBAAgB,gBAAgB,CAC9B,KAAK,EAAE,gBAAgB,EACvB,MAAM,EAAE,gBAAgB,EACxB,GAAG,EAAE,gBAAgB,GACpB,MAAM,CAMR;AAED,wBAAgB,oBAAoB,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,MAAM,CAOhF;AAED,wBAAgB,wBAAwB,CAAC,OAAO,EAAE,kBAAkB,GAAG,MAAM,GAAG,IAAI,CAenF;AA8BD,wBAAgB,gCAAgC,CAC9C,QAAQ,EAAE,SAAS,kBAAkB,EAAE,EACvC,KAAK,EAAE,gBAAgB,EACvB,WAAW,EAAE,MAAM,GAClB,yBAAyB,GAAG,IAAI,CAkElC;AAED,wBAAgB,0BAA0B,CACxC,WAAW,EAAE,kBAAkB,EAC/B,KAAK,EAAE,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,GACjC,kBAAkB,CA4BpB;AAED,wBAAgB,2BAA2B,CAAC,WAAW,EAAE,kBAAkB,GAAG,SAAS,EAAE,CAUxF;AAED,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,gBAAgB,CAgB3F;AAED,wBAAgB,eAAe,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,MAAM,CAE3E;AAED,wBAAgB,iBAAiB,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,gBAAgB,GAAG,IAAI,CAM9F;AAED,wBAAgB,4BAA4B,CAC1C,MAAM,EAAE,SAAS,gBAAgB,EAAE,EACnC,SAAS,SAAO,GACf,OAAO,CAWT;AAED,wBAAgB,mBAAmB,CAAC,MAAM,EAAE,SAAS,gBAAgB,EAAE,GAAG,gBAAgB,GAAG,IAAI,CAwBhG;AAED,wBAAgB,sBAAsB,CACpC,IAAI,EAAE,SAAS,gBAAgB,EAAE,EACjC,SAAS,EAAE,gBAAgB,GAC1B,MAAM,CAER"}

package/dist/lib/measurement-geometry.js

@@ -0,0 +1,232 @@
+const GEOMETRY_EPSILON = 1e-9;
+export const MEASUREMENT_PLANAR_TOLERANCE = 0.01;
+const subtract = (a, b) => [
+    a[0] - b[0],
+    a[1] - b[1],
+    a[2] - b[2],
+];
+const cross = (a, b) => [
+    a[1] * b[2] - a[2] * b[1],
+    a[2] * b[0] - a[0] * b[2],
+    a[0] * b[1] - a[1] * b[0],
+];
+const dot = (a, b) => a[0] * b[0] + a[1] * b[1] + a[2] * b[2];
+const magnitude = (point) => Math.hypot(point[0], point[1], point[2]);
+export function measurementDistance(start, end) {
+    return magnitude(subtract(end, start));
+}
+export function measurementAnchorFallback(anchor) {
+    return Array.isArray(anchor) ? anchor : anchor.fallback;
+}
+export function measurementAngle(start, vertex, end) {
+    const a = subtract(start, vertex);
+    const b = subtract(end, vertex);
+    const denominator = magnitude(a) * magnitude(b);
+    if (!Number.isFinite(denominator) || denominator <= GEOMETRY_EPSILON)
+        return 0;
+    return Math.acos(Math.max(-1, Math.min(1, dot(a, b) / denominator)));
+}
+export function measurementPerimeter(points) {
+    if (points.length < 3)
+        return 0;
+    let length = 0;
+    for (let index = 0; index < points.length; index++) {
+        length += measurementDistance(points[index], points[(index + 1) % points.length]);
+    }
+    return length;
+}
+export function measurementFeatureLength(feature) {
+    const geometry = feature.geometry;
+    if (geometry.kind === 'point')
+        return null;
+    const points = geometry.kind === 'segment' ? [geometry.start, geometry.end] : geometry.points;
+    const closed = geometry.kind === 'polygon' || (geometry.kind === 'path' && geometry.closed === true);
+    const segmentCount = closed ? points.length : points.length - 1;
+    if (segmentCount <= 0)
+        return null;
+    let length = 0;
+    for (let index = 0; index < segmentCount; index++) {
+        const start = points[index];
+        const end = points[(index + 1) % points.length];
+        length += Math.hypot(end[0] - start[0], end[1] - start[1], end[2] - start[2]);
+    }
+    return length;
+}
+function closestPointOnMeasurementSegment(point, start, end) {
+    const dx = end[0] - start[0];
+    const dy = end[1] - start[1];
+    const dz = end[2] - start[2];
+    const lengthSquared = dx * dx + dy * dy + dz * dz;
+    const t = lengthSquared <= 1e-12
+        ? 0
+        : Math.max(0, Math.min(1, ((point[0] - start[0]) * dx + (point[1] - start[1]) * dy + (point[2] - start[2]) * dz) /
+            lengthSquared));
+    const resolved = [start[0] + dx * t, start[1] + dy * t, start[2] + dz * t];
+    return {
+        point: resolved,
+        t,
+        distance: Math.hypot(point[0] - resolved[0], point[1] - resolved[1], point[2] - resolved[2]),
+    };
+}
+export function closestMeasurementFeatureBinding(features, point, maxDistance) {
+    let best = null;
+    for (const feature of features) {
+        const geometry = feature.geometry;
+        if (geometry.kind === 'point') {
+            const distance = measurementDistance(point, geometry.point);
+            const candidate = {
+                featureId: feature.id,
+                point: geometry.point,
+                parameters: { t: 0 },
+                distance,
+                priority: feature.priority ?? 0,
+            };
+            if (distance <= maxDistance &&
+                (!best ||
+                    distance < best.distance ||
+                    (distance === best.distance && candidate.priority > best.priority))) {
+                best = candidate;
+            }
+            continue;
+        }
+        const points = geometry.kind === 'segment' ? [geometry.start, geometry.end] : geometry.points;
+        const closed = geometry.kind === 'polygon' || (geometry.kind === 'path' && geometry.closed === true);
+        const count = closed ? points.length : points.length - 1;
+        const lengths = [];
+        let total = 0;
+        for (let index = 0; index < count; index++) {
+            const start = points[index];
+            const end = points[(index + 1) % points.length];
+            const length = measurementDistance(start, end);
+            lengths.push(length);
+            total += length;
+        }
+        let before = 0;
+        for (let index = 0; index < count; index++) {
+            const start = points[index];
+            const end = points[(index + 1) % points.length];
+            const segment = closestPointOnMeasurementSegment(point, start, end);
+            const t = total <= GEOMETRY_EPSILON ? 0 : (before + segment.t * lengths[index]) / total;
+            const candidate = {
+                featureId: feature.id,
+                point: segment.point,
+                parameters: { t },
+                distance: segment.distance,
+                priority: feature.priority ?? 0,
+            };
+            if (candidate.distance <= maxDistance &&
+                (!best ||
+                    candidate.distance < best.distance ||
+                    (candidate.distance === best.distance && candidate.priority > best.priority))) {
+                best = candidate;
+            }
+            before += lengths[index];
+        }
+    }
+    if (!best)
+        return null;
+    const { priority: _priority, ...binding } = best;
+    return binding;
+}
+export function remapMeasurementReferences(measurement, idMap) {
+    const remap = (anchor) => {
+        if (Array.isArray(anchor))
+            return anchor;
+        const nodeId = idMap.get(anchor.reference.nodeId);
+        return nodeId ? { ...anchor, reference: { ...anchor.reference, nodeId } } : anchor;
+    };
+    switch (measurement.kind) {
+        case 'distance':
+            return {
+                ...measurement,
+                points: [remap(measurement.points[0]), remap(measurement.points[1])],
+            };
+        case 'angle':
+            return {
+                ...measurement,
+                points: [
+                    remap(measurement.points[0]),
+                    remap(measurement.points[1]),
+                    remap(measurement.points[2]),
+                ],
+            };
+        case 'area':
+        case 'perimeter':
+            return { ...measurement, base: measurement.base.map(remap) };
+        case 'volume':
+            return { ...measurement, base: measurement.base.map(remap) };
+    }
+}
+export function measurementReferenceNodeIds(measurement) {
+    const anchors = measurement.kind === 'distance' || measurement.kind === 'angle'
+        ? measurement.points
+        : measurement.base;
+    const ids = new Set();
+    for (const anchor of anchors) {
+        if (!Array.isArray(anchor))
+            ids.add(anchor.reference.nodeId);
+    }
+    return [...ids];
+}
+export function measurementAreaVector(points) {
+    if (points.length < 3)
+        return [0, 0, 0];
+    let x = 0;
+    let y = 0;
+    let z = 0;
+    for (let index = 0; index < points.length; index++) {
+        const current = points[index];
+        const next = points[(index + 1) % points.length];
+        x += (current[1] - next[1]) * (current[2] + next[2]);
+        y += (current[2] - next[2]) * (current[0] + next[0]);
+        z += (current[0] - next[0]) * (current[1] + next[1]);
+    }
+    return [x / 2, y / 2, z / 2];
+}
+export function measurementArea(points) {
+    return magnitude(measurementAreaVector(points));
+}
+export function measurementNormal(points) {
+    const areaVector = measurementAreaVector(points);
+    const length = magnitude(areaVector);
+    if (!Number.isFinite(length) || length <= GEOMETRY_EPSILON)
+        return null;
+    return [areaVector[0] / length, areaVector[1] / length, areaVector[2] / length];
+}
+export function areMeasurementPointsCoplanar(points, tolerance = 1e-6) {
+    if (points.length < 3 || !Number.isFinite(tolerance))
+        return false;
+    const normal = measurementNormal(points);
+    if (!normal)
+        return false;
+    const origin = points[0];
+    const absoluteTolerance = Math.abs(tolerance);
+    return points.every((point) => Math.abs(dot(subtract(point, origin), normal)) <= absoluteTolerance);
+}
+export function measurementCentroid(points) {
+    if (points.length < 3)
+        return null;
+    const normal = measurementNormal(points);
+    if (!normal)
+        return null;
+    const origin = points[0];
+    let totalWeight = 0;
+    let x = 0;
+    let y = 0;
+    let z = 0;
+    for (let index = 1; index < points.length - 1; index++) {
+        const current = points[index];
+        const next = points[index + 1];
+        const weight = dot(cross(subtract(current, origin), subtract(next, origin)), normal);
+        totalWeight += weight;
+        x += ((origin[0] + current[0] + next[0]) / 3) * weight;
+        y += ((origin[1] + current[1] + next[1]) / 3) * weight;
+        z += ((origin[2] + current[2] + next[2]) / 3) * weight;
+    }
+    if (!Number.isFinite(totalWeight) || Math.abs(totalWeight) <= GEOMETRY_EPSILON)
+        return null;
+    return [x / totalWeight, y / totalWeight, z / totalWeight];
+}
+export function measurementPrismVolume(base, extrusion) {
+    return Math.abs(dot(measurementAreaVector(base), extrusion));
+}

package/dist/lib/measurement-geometry.test.d.ts

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

package/dist/lib/measurement-geometry.test.d.ts.map

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

package/dist/lib/measurement-geometry.test.js

@@ -0,0 +1,102 @@
+import { describe, expect, test } from 'bun:test';
+import { areMeasurementPointsCoplanar, closestMeasurementFeatureBinding, measurementAngle, measurementArea, measurementAreaVector, measurementCentroid, measurementDistance, measurementNormal, measurementPerimeter, measurementPrismVolume, } from './measurement-geometry';
+const expectPointCloseTo = (actual, expected) => {
+    expect(actual).not.toBeNull();
+    for (let index = 0; index < 3; index++) {
+        expect(actual[index]).toBeCloseTo(expected[index]);
+    }
+};
+describe('measurement geometry', () => {
+    test('measures full 3D distance', () => {
+        expect(measurementDistance([1, 2, 3], [4, 6, 15])).toBe(13);
+    });
+    test('measures the smaller 3D angle and a closed perimeter', () => {
+        expect(measurementAngle([1, 0, 0], [0, 0, 0], [0, 1, 0])).toBeCloseTo(Math.PI / 2);
+        expect(measurementAngle([0, 0, 0], [0, 0, 0], [1, 0, 0])).toBe(0);
+        expect(measurementPerimeter([
+            [0, 0, 0],
+            [3, 0, 0],
+            [3, 0, 4],
+        ])).toBe(12);
+    });
+    test('matches the closest semantic feature with a normalized path position', () => {
+        const features = [
+            {
+                id: 'boundary',
+                label: 'Boundary',
+                snapKind: 'edge',
+                geometry: {
+                    kind: 'polygon',
+                    points: [
+                        [0, 0, 0],
+                        [2, 0, 0],
+                        [2, 0, 2],
+                        [0, 0, 2],
+                    ],
+                },
+            },
+        ];
+        const match = closestMeasurementFeatureBinding(features, [1.9, 0, 1], 0.2);
+        expect(match?.featureId).toBe('boundary');
+        expect(match?.point).toEqual([2, 0, 1]);
+        expect(match?.parameters?.t).toBeCloseTo(0.375);
+        expect(match?.distance).toBeCloseTo(0.1);
+    });
+    test('computes a Newell area vector, area, and winding-aware normal', () => {
+        const base = [
+            [0, 0, 0],
+            [2, 0, 0],
+            [2, 1, 1],
+            [0, 1, 1],
+        ];
+        expectPointCloseTo(measurementAreaVector(base), [0, -2, 2]);
+        expect(measurementArea(base)).toBeCloseTo(2 * Math.sqrt(2));
+        expectPointCloseTo(measurementNormal(base), [0, -Math.SQRT1_2, Math.SQRT1_2]);
+        expectPointCloseTo(measurementNormal([...base].reverse()), [0, Math.SQRT1_2, -Math.SQRT1_2]);
+    });
+    test('checks coplanarity against the Newell normal', () => {
+        const base = [
+            [0, 0, 0],
+            [2, 0, 0],
+            [2, 1, 1],
+            [0, 1, 1],
+        ];
+        expect(areMeasurementPointsCoplanar(base)).toBe(true);
+        expect(areMeasurementPointsCoplanar([...base, [1, 0.5, 0.51]])).toBe(false);
+        expect(areMeasurementPointsCoplanar([
+            [0, 0, 0],
+            [1, 0, 0],
+            [2, 0, 0],
+        ])).toBe(false);
+    });
+    test('computes the area-weighted centroid of a planar 3D polygon', () => {
+        expectPointCloseTo(measurementCentroid([
+            [0, 0, 0],
+            [2, 0, 0],
+            [2, 1, 1],
+            [0, 1, 1],
+        ]), [1, 0.5, 0.5]);
+    });
+    test('computes area and centroid for a concave polygon', () => {
+        const base = [
+            [0, 0, 0],
+            [2, 0, 0],
+            [2, 0, 1],
+            [1, 0, 1],
+            [1, 0, 2],
+            [0, 0, 2],
+        ];
+        expect(measurementArea(base)).toBeCloseTo(3);
+        expectPointCloseTo(measurementCentroid(base), [5 / 6, 0, 5 / 6]);
+    });
+    test('computes prism volume from normal extrusion and ignores tangential extrusion', () => {
+        const base = [
+            [0, 0, 0],
+            [3, 0, 0],
+            [3, 2, 0],
+            [0, 2, 0],
+        ];
+        expect(measurementPrismVolume(base, [5, 7, 4])).toBeCloseTo(24);
+        expect(measurementPrismVolume([...base].reverse(), [5, 7, 4])).toBeCloseTo(24);
+    });
+});

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

@@ -1,3 +1,2 @@
-export declare function insetPolygonFromCentroid(polygon: Array<[number, number]>, inset: number): Array<[number, number]>;
 export declare function simplifyClosedPolygon(polygon: Array<[number, number]>, tolerance: number): Array<[number, number]>;
 //# sourceMappingURL=polygon-geometry.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"polygon-geometry.d.ts","sourceRoot":"","sources":["../../src/lib/polygon-geometry.ts"],"names":[],"mappings":"AAAA,wBAAgB,wBAAwB,CACtC,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChC,KAAK,EAAE,MAAM,GACZ,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAoBzB;AA0ED,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChC,SAAS,EAAE,MAAM,GAChB,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiCzB"}
+{"version":3,"file":"polygon-geometry.d.ts","sourceRoot":"","sources":["../../src/lib/polygon-geometry.ts"],"names":[],"mappings":"AAwEA,wBAAgB,qBAAqB,CACnC,OAAO,EAAE,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,EAChC,SAAS,EAAE,MAAM,GAChB,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAiCzB"}

package/dist/lib/polygon-geometry.js

@@ -1,21 +1,3 @@
-export function insetPolygonFromCentroid(polygon, inset) {
-    if (inset <= 0) {
-        return polygon.map(([x, z]) => [x, z]);
-    }
-    const centroid = polygon.reduce((acc, [x, z]) => ({ x: acc.x + x, z: acc.z + z }), { x: 0, z: 0 });
-    centroid.x /= Math.max(polygon.length, 1);
-    centroid.z /= Math.max(polygon.length, 1);
-    return polygon.map(([x, z]) => {
-        const dx = x - centroid.x;
-        const dz = z - centroid.z;
-        const length = Math.hypot(dx, dz);
-        if (length <= inset + 1e-6) {
-            return [x, z];
-        }
-        const scale = (length - inset) / length;
-        return [centroid.x + dx * scale, centroid.z + dz * scale];
-    });
-}
 function pointLineDistance(point, start, end) {
     const dx = end[0] - start[0];
     const dz = end[1] - start[1];

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

@@ -0,0 +1,10 @@
+export type Point2D = [number, number];
+export declare function pointOnSegment(point: Point2D, start: Point2D, end: Point2D, tolerance?: number): boolean;
+export declare function pointInPolygon(point: Point2D, polygon: Point2D[], options?: {
+    includeBoundary?: boolean;
+}): boolean;
+export declare function segmentsIntersect(a: Point2D, b: Point2D, c: Point2D, d: Point2D): boolean;
+export declare function polygonsIntersect(left: Point2D[], right: Point2D[]): boolean;
+export declare function polygonContainsPolygon(outer: Point2D[], inner: Point2D[]): boolean;
+export declare function polygonsOverlap(left: Point2D[], right: Point2D[]): boolean;
+//# sourceMappingURL=polygon-relations.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"polygon-relations.d.ts","sourceRoot":"","sources":["../../src/lib/polygon-relations.ts"],"names":[],"mappings":"AAAA,MAAM,MAAM,OAAO,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;AAEtC,wBAAgB,cAAc,CAAC,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,GAAG,EAAE,OAAO,EAAE,SAAS,SAAO,WAS5F;AAED,wBAAgB,cAAc,CAC5B,KAAK,EAAE,OAAO,EACd,OAAO,EAAE,OAAO,EAAE,EAClB,OAAO,CAAC,EAAE;IAAE,eAAe,CAAC,EAAE,OAAO,CAAA;CAAE,WAuBxC;AAED,wBAAgB,iBAAiB,CAAC,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,EAAE,CAAC,EAAE,OAAO,WA2B/E;AAED,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,WAmBlE;AAED,wBAAgB,sBAAsB,CAAC,KAAK,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,WAExE;AAED,wBAAgB,eAAe,CAAC,IAAI,EAAE,OAAO,EAAE,EAAE,KAAK,EAAE,OAAO,EAAE,WAMhE"}

package/dist/lib/polygon-relations.js

@@ -0,0 +1,73 @@
+export function pointOnSegment(point, start, end, tolerance = 1e-6) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const cross = (point[0] - start[0]) * dz - (point[1] - start[1]) * dx;
+    if (Math.abs(cross) > tolerance)
+        return false;
+    const dot = (point[0] - start[0]) * (point[0] - end[0]) + (point[1] - start[1]) * (point[1] - end[1]);
+    return dot <= tolerance;
+}
+export function pointInPolygon(point, polygon, options) {
+    if (polygon.length < 3)
+        return false;
+    const includeBoundary = options?.includeBoundary ?? true;
+    if (polygon.some((start, index) => pointOnSegment(point, start, polygon[(index + 1) % polygon.length]))) {
+        return includeBoundary;
+    }
+    let inside = false;
+    const [x, z] = point;
+    for (let i = 0, j = polygon.length - 1; i < polygon.length; j = i++) {
+        const current = polygon[i];
+        const previous = polygon[j];
+        const intersects = current[1] > z !== previous[1] > z &&
+            x < ((previous[0] - current[0]) * (z - current[1])) / (previous[1] - current[1]) + current[0];
+        if (intersects)
+            inside = !inside;
+    }
+    return inside;
+}
+export function segmentsIntersect(a, b, c, d) {
+    const cross = (ux, uz, vx, vz) => ux * vz - uz * vx;
+    const abx = b[0] - a[0];
+    const abz = b[1] - a[1];
+    const acx = c[0] - a[0];
+    const acz = c[1] - a[1];
+    const adx = d[0] - a[0];
+    const adz = d[1] - a[1];
+    const cdx = d[0] - c[0];
+    const cdz = d[1] - c[1];
+    const cax = a[0] - c[0];
+    const caz = a[1] - c[1];
+    const cbx = b[0] - c[0];
+    const cbz = b[1] - c[1];
+    const o1 = cross(abx, abz, acx, acz);
+    const o2 = cross(abx, abz, adx, adz);
+    const o3 = cross(cdx, cdz, cax, caz);
+    const o4 = cross(cdx, cdz, cbx, cbz);
+    if (Math.sign(o1) !== Math.sign(o2) && Math.sign(o3) !== Math.sign(o4))
+        return true;
+    return (pointOnSegment(c, a, b) ||
+        pointOnSegment(d, a, b) ||
+        pointOnSegment(a, c, d) ||
+        pointOnSegment(b, c, d));
+}
+export function polygonsIntersect(left, right) {
+    for (let leftIndex = 0; leftIndex < left.length; leftIndex++) {
+        const leftStart = left[leftIndex];
+        const leftEnd = left[(leftIndex + 1) % left.length];
+        for (let rightIndex = 0; rightIndex < right.length; rightIndex++) {
+            if (segmentsIntersect(leftStart, leftEnd, right[rightIndex], right[(rightIndex + 1) % right.length])) {
+                return true;
+            }
+        }
+    }
+    return false;
+}
+export function polygonContainsPolygon(outer, inner) {
+    return inner.every((point) => pointInPolygon(point, outer));
+}
+export function polygonsOverlap(left, right) {
+    return (polygonsIntersect(left, right) ||
+        left.some((point) => pointInPolygon(point, right)) ||
+        right.some((point) => pointInPolygon(point, left)));
+}

package/dist/lib/selection-proxy.d.ts

@@ -0,0 +1,4 @@
+import type { AnyNode, AnyNodeId } from '../schema/types';
+export declare function selectionProxyIdFromMetadata(metadata: unknown): AnyNodeId | null;
+export declare function resolveSelectionProxyId(node: AnyNode, nodes: Readonly<Record<string, AnyNode | undefined>>): AnyNodeId;
+//# sourceMappingURL=selection-proxy.d.ts.map

package/dist/lib/selection-proxy.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"selection-proxy.d.ts","sourceRoot":"","sources":["../../src/lib/selection-proxy.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,iBAAiB,CAAA;AAEzD,wBAAgB,4BAA4B,CAAC,QAAQ,EAAE,OAAO,GAAG,SAAS,GAAG,IAAI,CAIhF;AAED,wBAAgB,uBAAuB,CACrC,IAAI,EAAE,OAAO,EACb,KAAK,EAAE,QAAQ,CAAC,MAAM,CAAC,MAAM,EAAE,OAAO,GAAG,SAAS,CAAC,CAAC,GACnD,SAAS,CAIX"}

package/dist/lib/selection-proxy.js

@@ -0,0 +1,12 @@
+export function selectionProxyIdFromMetadata(metadata) {
+    if (!metadata || typeof metadata !== 'object' || Array.isArray(metadata))
+        return null;
+    const value = metadata.nodeSelectionProxyId;
+    return typeof value === 'string' ? value : null;
+}
+export function resolveSelectionProxyId(node, nodes) {
+    const proxyId = selectionProxyIdFromMetadata(node.metadata);
+    if (!proxyId || !nodes[proxyId])
+        return node.id;
+    return proxyId;
+}

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

@@ -1,3 +1,32 @@
-import type { SlabNode } from '../schema';
-export declare function getRenderableSlabPolygon(slabNode: SlabNode): Array<[number, number]>;
+import type { GeometryContext } from '../registry/types';
+import type { SlabNode, WallNode } from '../schema';
+export type SlabPolygonContext = {
+    /** Walls on the slab's level. */
+    walls: WallNode[];
+    /** Other slabs on the same level — the slab itself must be excluded. */
+    siblingSlabs: SlabNode[];
+};
+/**
+ * Derive a {@link SlabPolygonContext} from a registry `GeometryContext`:
+ * sibling slabs come from `ctx.siblings` (same kind, same parent, self
+ * excluded) and walls from the parent level's children.
+ */
+export declare function slabPolygonContextFromGeometry(ctx: GeometryContext | undefined): SlabPolygonContext;
+export declare function getRenderableSlabPolygon(slabNode: SlabNode, context: SlabPolygonContext): Array<[number, number]>;
+export type SlabEdgeWallBandSnap = {
+    wallId: WallNode['id'];
+    /** The candidate edge translated perpendicular onto the wall centerline. */
+    edge: [[number, number], [number, number]];
+};
+/**
+ * Reshape-snap counterpart of the render band rule: when the edge
+ * `a → b` lies inside a wall's footprint band, return the edge
+ * translated onto that wall's CENTERLINE — the canonical stored
+ * position (matching what auto slabs store); the render rule then
+ * places it at the face. `maxLateral` optionally tightens the stick
+ * distance (non-magnetic modes keep only a connect-radius stick).
+ */
+export declare function snapSlabEdgeToWallBand(a: [number, number], b: [number, number], walls: readonly WallNode[], options?: {
+    maxLateral?: number;
+}): SlabEdgeWallBandSnap | null;
 //# sourceMappingURL=slab-polygon.d.ts.map

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

@@ -1 +1 @@
-{"version":3,"file":"slab-polygon.d.ts","sourceRoot":"","sources":["../../src/lib/slab-polygon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AAQzC,wBAAgB,wBAAwB,CAAC,QAAQ,EAAE,QAAQ,GAAG,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAOpF"}
+{"version":3,"file":"slab-polygon.d.ts","sourceRoot":"","sources":["../../src/lib/slab-polygon.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACxD,OAAO,KAAK,EAAa,QAAQ,EAAE,QAAQ,EAAE,MAAM,WAAW,CAAA;AA8E9D,MAAM,MAAM,kBAAkB,GAAG;IAC/B,iCAAiC;IACjC,KAAK,EAAE,QAAQ,EAAE,CAAA;IACjB,wEAAwE;IACxE,YAAY,EAAE,QAAQ,EAAE,CAAA;CACzB,CAAA;AAuBD;;;;GAIG;AACH,wBAAgB,8BAA8B,CAC5C,GAAG,EAAE,eAAe,GAAG,SAAS,GAC/B,kBAAkB,CAmBpB;AAED,wBAAgB,wBAAwB,CACtC,QAAQ,EAAE,QAAQ,EAClB,OAAO,EAAE,kBAAkB,GAC1B,KAAK,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAgBzB;AAuID,MAAM,MAAM,oBAAoB,GAAG;IACjC,MAAM,EAAE,QAAQ,CAAC,IAAI,CAAC,CAAA;IACtB,4EAA4E;IAC5E,IAAI,EAAE,CAAC,CAAC,MAAM,EAAE,MAAM,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC,CAAA;CAC3C,CAAA;AAED;;;;;;;GAOG;AACH,wBAAgB,sBAAsB,CACpC,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACnB,CAAC,EAAE,CAAC,MAAM,EAAE,MAAM,CAAC,EACnB,KAAK,EAAE,SAAS,QAAQ,EAAE,EAC1B,OAAO,CAAC,EAAE;IAAE,UAAU,CAAC,EAAE,MAAM,CAAA;CAAE,GAChC,oBAAoB,GAAG,IAAI,CA4B7B"}