@pascal-app/core 0.8.0 → 0.9.1

package/dist/systems/wall/wall-move.js

@@ -0,0 +1,193 @@
+const AXIS_EPSILON = 1e-6;
+export function getPerpendicularWallMoveAxis(start, end) {
+    const dx = end[0] - start[0];
+    const dz = end[1] - start[1];
+    const length = Math.hypot(dx, dz);
+    if (length < AXIS_EPSILON)
+        return null;
+    // Perpendicular (normal) direction for moving the wall "sideways".
+    // This matches the arrow handles shown in the editor.
+    return [-dz / length, dx / length];
+}
+export function constrainWallMoveDeltaToAxis(deltaX, deltaZ, axis) {
+    if (axis) {
+        const projected = deltaX * axis[0] + deltaZ * axis[1];
+        return [axis[0] * projected, axis[1] * projected];
+    }
+    return [deltaX, deltaZ];
+}
+function pointsEqual(a, b) {
+    return Math.abs(a[0] - b[0]) <= AXIS_EPSILON && Math.abs(a[1] - b[1]) <= AXIS_EPSILON;
+}
+function wallTouchesPoint(wall, point) {
+    return pointsEqual(wall.start, point) || pointsEqual(wall.end, point);
+}
+function otherWallEndpoint(wall, point) {
+    return pointsEqual(wall.start, point) ? wall.end : wall.start;
+}
+function wallLengthFromPoint(wall, point) {
+    const freeEndpoint = otherWallEndpoint(wall, point);
+    return Math.hypot(freeEndpoint[0] - point[0], freeEndpoint[1] - point[1]);
+}
+function getMoveWallRelation(wall, sharedPoint, nextPoint) {
+    const moveX = nextPoint[0] - sharedPoint[0];
+    const moveZ = nextPoint[1] - sharedPoint[1];
+    const moveLength = Math.hypot(moveX, moveZ);
+    if (moveLength < AXIS_EPSILON)
+        return 'stationary';
+    const freeEndpoint = otherWallEndpoint(wall, sharedPoint);
+    const wallX = freeEndpoint[0] - sharedPoint[0];
+    const wallZ = freeEndpoint[1] - sharedPoint[1];
+    const wallLength = Math.hypot(wallX, wallZ);
+    if (wallLength < AXIS_EPSILON)
+        return 'stationary';
+    const normalizedCross = Math.abs(moveX * wallZ - moveZ * wallX) / (moveLength * wallLength);
+    if (normalizedCross > 1e-4)
+        return 'off-axis';
+    const normalizedDot = (moveX * wallX + moveZ * wallZ) / (moveLength * wallLength);
+    return normalizedDot >= 0 ? 'same-direction' : 'opposite-direction';
+}
+/**
+ * Apply a junction plan to a list of linked walls, producing the per-wall
+ * endpoint updates. Mirrors the 3D `MoveWallTool`'s drag-preview behavior
+ * so the 2D move handler can drive the same scene topology.
+ *
+ * `linkedWallTargetPlans` take precedence over `linkedWallsToMove` — when
+ * the planner emits a target plan for a same-direction-consumed wall the
+ * matchPoint/targetPoint pair encodes the pivot, not the original ↔ next
+ * endpoint mapping.
+ */
+export function getLinkedWallUpdates(linkedWalls, originalStart, originalEnd, nextStart, nextEnd) {
+    return linkedWalls.map(({ wall, matchPoint, targetPoint }) => {
+        if (matchPoint && targetPoint) {
+            return {
+                id: wall.id,
+                start: pointsEqual(wall.start, matchPoint) ? targetPoint : wall.start,
+                end: pointsEqual(wall.end, matchPoint) ? targetPoint : wall.end,
+            };
+        }
+        const targetStart = targetPoint ?? nextStart;
+        const targetEnd = targetPoint ?? nextEnd;
+        return {
+            id: wall.id,
+            start: pointsEqual(wall.start, originalStart)
+                ? targetStart
+                : pointsEqual(wall.start, originalEnd)
+                    ? targetEnd
+                    : wall.start,
+            end: pointsEqual(wall.end, originalStart)
+                ? targetStart
+                : pointsEqual(wall.end, originalEnd)
+                    ? targetEnd
+                    : wall.end,
+        };
+    });
+}
+export function getPlannedLinkedWallUpdates(plan, originalStart, originalEnd, nextStart, nextEnd) {
+    const movePlans = new Map();
+    for (const wall of plan.linkedWallsToMove) {
+        movePlans.set(wall.id, { wall });
+    }
+    for (const targetPlan of plan.linkedWallTargetPlans) {
+        movePlans.set(targetPlan.wall.id, {
+            wall: targetPlan.wall,
+            matchPoint: targetPlan.originalPoint,
+            targetPoint: targetPlan.targetPoint,
+        });
+    }
+    return getLinkedWallUpdates(Array.from(movePlans.values()), originalStart, originalEnd, nextStart, nextEnd);
+}
+export function planWallMoveJunctions(linkedWalls, originalStart, originalEnd, nextStart, nextEnd) {
+    const linkedWallsToMove = new Map();
+    const linkedWallTargetPlans = new Map();
+    const bridgePlans = new Map();
+    const wallsToDelete = new Map();
+    const addStandardEndpointPlan = (endpoint, point, nextPoint, relatedWalls, keySuffix = '', useTargetPlans = false) => {
+        const hasSideBranch = relatedWalls.some((entry) => entry.relation === 'off-axis');
+        const hasOppositeBridge = relatedWalls.some((entry) => entry.relation === 'opposite-direction' && hasSideBranch);
+        for (const { wall, relation } of relatedWalls) {
+            if (relation === 'stationary' ||
+                relation === 'same-direction' ||
+                (relation === 'opposite-direction' && !hasSideBranch)) {
+                if (useTargetPlans) {
+                    linkedWallTargetPlans.set(wall.id, {
+                        wall,
+                        originalPoint: point,
+                        targetPoint: nextPoint,
+                    });
+                }
+                else {
+                    linkedWallsToMove.set(wall.id, wall);
+                }
+                continue;
+            }
+            if (relation === 'off-axis' && hasOppositeBridge) {
+                continue;
+            }
+            bridgePlans.set(`${wall.id}:${endpoint}${keySuffix}`, {
+                wall,
+                originalPoint: point,
+                movedEndpoint: endpoint,
+            });
+        }
+    };
+    const addEndpointPlan = (endpoint, point, nextPoint) => {
+        const moveLength = Math.hypot(nextPoint[0] - point[0], nextPoint[1] - point[1]);
+        const linkedAtEndpoint = linkedWalls
+            .filter((wall) => wallTouchesPoint(wall, point))
+            .map((wall) => ({
+            wall,
+            relation: getMoveWallRelation(wall, point, nextPoint),
+        }));
+        const consumedSameDirectionWall = linkedAtEndpoint
+            .filter((entry) => entry.relation === 'same-direction')
+            .map((entry) => ({
+            ...entry,
+            distance: wallLengthFromPoint(entry.wall, point),
+        }))
+            .filter((entry) => moveLength + AXIS_EPSILON >= entry.distance)
+            .sort((a, b) => a.distance - b.distance)[0];
+        if (consumedSameDirectionWall) {
+            const pivotPoint = [
+                ...otherWallEndpoint(consumedSameDirectionWall.wall, point),
+            ];
+            const bridgeSource = linkedAtEndpoint.find((entry) => entry.relation === 'opposite-direction');
+            wallsToDelete.set(consumedSameDirectionWall.wall.id, consumedSameDirectionWall.wall);
+            linkedWallTargetPlans.set(consumedSameDirectionWall.wall.id, {
+                wall: consumedSameDirectionWall.wall,
+                originalPoint: point,
+                targetPoint: pivotPoint,
+            });
+            if (bridgeSource) {
+                linkedWallTargetPlans.set(bridgeSource.wall.id, {
+                    wall: bridgeSource.wall,
+                    originalPoint: point,
+                    targetPoint: pivotPoint,
+                });
+                bridgePlans.set(`${bridgeSource.wall.id}:${endpoint}:through`, {
+                    wall: bridgeSource.wall,
+                    originalPoint: pivotPoint,
+                    movedEndpoint: endpoint,
+                });
+                return;
+            }
+            const linkedAtPivot = linkedWalls
+                .filter((wall) => wall.id !== consumedSameDirectionWall.wall.id && wallTouchesPoint(wall, pivotPoint))
+                .map((wall) => ({
+                wall,
+                relation: getMoveWallRelation(wall, pivotPoint, nextPoint),
+            }));
+            addStandardEndpointPlan(endpoint, pivotPoint, nextPoint, linkedAtPivot, ':through-pivot', true);
+            return;
+        }
+        addStandardEndpointPlan(endpoint, point, nextPoint, linkedAtEndpoint);
+    };
+    addEndpointPlan('start', originalStart, nextStart);
+    addEndpointPlan('end', originalEnd, nextEnd);
+    return {
+        linkedWallsToMove: Array.from(linkedWallsToMove.values()),
+        linkedWallTargetPlans: Array.from(linkedWallTargetPlans.values()),
+        bridgePlans: Array.from(bridgePlans.values()),
+        wallsToDelete: Array.from(wallsToDelete.values()),
+    };
+}

package/dist/utils/clone-scene-graph.d.ts

@@ -33,10 +33,12 @@ export declare function cloneLevelSubtree(nodes: Record<AnyNodeId, AnyNode>, lev
     newLevelId: AnyNodeId;
     idMap: Map<string, string>;
 };
+export type ForkSceneGraphOptions = {
+    preserveScans?: boolean;
+};
 /**
- * Forks a scene graph for use as a new project: clones with new IDs and strips
- * scan and guide nodes (and their references) since those contain user-uploaded
- * imagery that shouldn't carry over to a forked project.
+ * Forks a scene graph for use as a new project: clones with new IDs and, by
+ * default, strips scan and guide nodes since they contain user-uploaded imagery.
  */
-export declare function forkSceneGraph(sceneGraph: SceneGraph): SceneGraph;
+export declare function forkSceneGraph(sceneGraph: SceneGraph, options?: ForkSceneGraphOptions): SceneGraph;
 //# sourceMappingURL=clone-scene-graph.d.ts.map

package/dist/utils/clone-scene-graph.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAErE,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;CAC/C,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAuGlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GACjB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CA8E/E;AAED;;;;GAIG;AACH,wBAAgB,cAAc,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAgEjE"}
+{"version":3,"file":"clone-scene-graph.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,OAAO,EAAE,SAAS,EAAE,MAAM,WAAW,CAAA;AAEnD,OAAO,KAAK,EAAE,UAAU,EAAE,YAAY,EAAE,MAAM,uBAAuB,CAAA;AAErE,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,CAAA;IACjC,WAAW,EAAE,SAAS,EAAE,CAAA;IACxB,WAAW,CAAC,EAAE,MAAM,CAAC,YAAY,EAAE,UAAU,CAAC,CAAA;CAC/C,CAAA;AAUD;;;;;;;;GAQG;AACH,wBAAgB,eAAe,CAAC,UAAU,EAAE,UAAU,GAAG,UAAU,CAuGlE;AAED;;;;;;;;;;;;GAYG;AACH,wBAAgB,iBAAiB,CAC/B,KAAK,EAAE,MAAM,CAAC,SAAS,EAAE,OAAO,CAAC,EACjC,OAAO,EAAE,SAAS,GACjB;IAAE,WAAW,EAAE,OAAO,EAAE,CAAC;IAAC,UAAU,EAAE,SAAS,CAAC;IAAC,KAAK,EAAE,GAAG,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;CAAE,CA8E/E;AAED,MAAM,MAAM,qBAAqB,GAAG;IAClC,aAAa,CAAC,EAAE,OAAO,CAAA;CACxB,CAAA;AAED;;;GAGG;AACH,wBAAgB,cAAc,CAC5B,UAAU,EAAE,UAAU,EACtB,OAAO,GAAE,qBAA0B,GAClC,UAAU,CAoEZ"}

package/dist/utils/clone-scene-graph.js

@@ -190,11 +190,13 @@ export function cloneLevelSubtree(nodes, levelId) {
     return { clonedNodes, newLevelId, idMap };
 }
 /**
- * Forks a scene graph for use as a new project: clones with new IDs and strips
- * scan and guide nodes (and their references) since those contain user-uploaded
- * imagery that shouldn't carry over to a forked project.
+ * Forks a scene graph for use as a new project: clones with new IDs and, by
+ * default, strips scan and guide nodes since they contain user-uploaded imagery.
  */
-export function forkSceneGraph(sceneGraph) {
+export function forkSceneGraph(sceneGraph, options = {}) {
+    if (options.preserveScans) {
+        return cloneSceneGraph(sceneGraph);
+    }
     const { nodes, rootNodeIds, collections } = sceneGraph;
     // First, identify scan and guide node IDs to exclude (user-uploaded imagery)
     const excludedNodeIds = new Set();

package/dist/utils/clone-scene-graph.test.d.ts

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

package/dist/utils/clone-scene-graph.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"clone-scene-graph.test.d.ts","sourceRoot":"","sources":["../../src/utils/clone-scene-graph.test.ts"],"names":[],"mappings":""}

package/dist/utils/clone-scene-graph.test.js

@@ -0,0 +1,59 @@
+import { describe, expect, test } from 'bun:test';
+import { forkSceneGraph } from './clone-scene-graph';
+function makeNode(id, type, extra = {}) {
+    return {
+        object: 'node',
+        id,
+        type,
+        parentId: null,
+        visible: true,
+        metadata: {},
+        ...extra,
+    };
+}
+function makeSceneGraph() {
+    const site = makeNode('site_1', 'site', { children: ['level_1'] });
+    const level = makeNode('level_1', 'level', {
+        parentId: 'site_1',
+        children: ['wall_1', 'scan_1', 'guide_1'],
+    });
+    const wall = makeNode('wall_1', 'wall', { parentId: 'level_1' });
+    const scan = makeNode('scan_1', 'scan', { parentId: 'level_1', url: 'scan.glb' });
+    const guide = makeNode('guide_1', 'guide', { parentId: 'level_1', url: 'guide.png' });
+    return {
+        nodes: {
+            ['site_1']: site,
+            ['level_1']: level,
+            ['wall_1']: wall,
+            ['scan_1']: scan,
+            ['guide_1']: guide,
+        },
+        rootNodeIds: ['site_1'],
+        collections: {
+            ['collection_1']: {
+                id: 'collection_1',
+                name: 'References',
+                nodeIds: ['scan_1', 'guide_1'],
+            },
+        },
+    };
+}
+describe('forkSceneGraph', () => {
+    test('strips scan and guide nodes by default', () => {
+        const forked = forkSceneGraph(makeSceneGraph());
+        const nodes = Object.values(forked.nodes);
+        expect(nodes.some((node) => node.type === 'scan')).toBe(false);
+        expect(nodes.some((node) => node.type === 'guide')).toBe(false);
+        expect(nodes.some((node) => node.type === 'wall')).toBe(true);
+        expect(forked.collections).toEqual({});
+    });
+    test('preserves scan and guide nodes when requested', () => {
+        const forked = forkSceneGraph(makeSceneGraph(), { preserveScans: true });
+        const nodes = Object.values(forked.nodes);
+        expect(nodes.some((node) => node.type === 'scan')).toBe(true);
+        expect(nodes.some((node) => node.type === 'guide')).toBe(true);
+        expect(nodes.map((node) => node.id)).not.toContain('scan_1');
+        expect(nodes.map((node) => node.id)).not.toContain('guide_1');
+        expect(Object.values(forked.collections ?? {}).flatMap((collection) => collection.nodeIds)).toHaveLength(2);
+    });
+});

package/dist/validation/validate-build-json.d.ts

@@ -0,0 +1,43 @@
+import { type AnyNodeType } from '../schema/types';
+export type ValidationSeverity = 'error' | 'warning';
+export type ValidationIssue = {
+    severity: ValidationSeverity;
+    code: string;
+    message: string;
+    nodeId?: string;
+};
+export type BuildStats = {
+    total: number;
+    byType: Partial<Record<AnyNodeType, number>>;
+    unknownTypes: Record<string, number>;
+    floorAreaM2: number;
+};
+export type ParsedBuildJson = {
+    nodes: Record<string, unknown>;
+    rootNodeIds: string[];
+};
+export type SchemaIssue = {
+    nodeId: string;
+    nodeType: string;
+    path: string;
+    message: string;
+};
+export type ValidateBuildJsonResult = {
+    ok: boolean;
+    parsed: ParsedBuildJson | null;
+    stats: BuildStats;
+    errors: ValidationIssue[];
+    warnings: ValidationIssue[];
+    schemaIssues: SchemaIssue[];
+    schemaIssueCount: number;
+};
+/**
+ * Pre-flight validator for `{ nodes, rootNodeIds }` build JSON loaded via
+ * Load Build (drag-drop, IFC converter output, hand-edited files).
+ *
+ * Reports issues without mutating; the scene store still owns migration
+ * and orphan cleanup at import time. Hard errors mean the file is
+ * structurally unusable and import should be blocked.
+ */
+export declare function validateBuildJson(input: unknown): ValidateBuildJsonResult;
+//# sourceMappingURL=validate-build-json.d.ts.map

package/dist/validation/validate-build-json.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"validate-build-json.d.ts","sourceRoot":"","sources":["../../src/validation/validate-build-json.ts"],"names":[],"mappings":"AAAA,OAAO,EAAW,KAAK,WAAW,EAAE,MAAM,iBAAiB,CAAA;AAE3D,MAAM,MAAM,kBAAkB,GAAG,OAAO,GAAG,SAAS,CAAA;AAEpD,MAAM,MAAM,eAAe,GAAG;IAC5B,QAAQ,EAAE,kBAAkB,CAAA;IAC5B,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;IACf,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,UAAU,GAAG;IACvB,KAAK,EAAE,MAAM,CAAA;IACb,MAAM,EAAE,OAAO,CAAC,MAAM,CAAC,WAAW,EAAE,MAAM,CAAC,CAAC,CAAA;IAC5C,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,MAAM,CAAC,CAAA;IACpC,WAAW,EAAE,MAAM,CAAA;CACpB,CAAA;AAED,MAAM,MAAM,eAAe,GAAG;IAC5B,KAAK,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAAA;IAC9B,WAAW,EAAE,MAAM,EAAE,CAAA;CACtB,CAAA;AAED,MAAM,MAAM,WAAW,GAAG;IACxB,MAAM,EAAE,MAAM,CAAA;IACd,QAAQ,EAAE,MAAM,CAAA;IAChB,IAAI,EAAE,MAAM,CAAA;IACZ,OAAO,EAAE,MAAM,CAAA;CAChB,CAAA;AAED,MAAM,MAAM,uBAAuB,GAAG;IACpC,EAAE,EAAE,OAAO,CAAA;IACX,MAAM,EAAE,eAAe,GAAG,IAAI,CAAA;IAC9B,KAAK,EAAE,UAAU,CAAA;IACjB,MAAM,EAAE,eAAe,EAAE,CAAA;IACzB,QAAQ,EAAE,eAAe,EAAE,CAAA;IAC3B,YAAY,EAAE,WAAW,EAAE,CAAA;IAC3B,gBAAgB,EAAE,MAAM,CAAA;CACzB,CAAA;AA8BD;;;;;;;GAOG;AACH,wBAAgB,iBAAiB,CAAC,KAAK,EAAE,OAAO,GAAG,uBAAuB,CAuNzE"}

package/dist/validation/validate-build-json.js

@@ -0,0 +1,227 @@
+import { AnyNode } from '../schema/types';
+const KNOWN_TYPES = new Set(AnyNode.options.map((o) => o.shape.type.parse(undefined)));
+function isPlainObject(value) {
+    return typeof value === 'object' && value !== null && !Array.isArray(value);
+}
+function polygonAreaM2(points) {
+    if (points.length < 3)
+        return 0;
+    let area = 0;
+    for (let i = 0; i < points.length; i++) {
+        const a = points[i];
+        const b = points[(i + 1) % points.length];
+        if (!a || !b)
+            return 0;
+        area += a[0] * b[1] - b[0] * a[1];
+    }
+    return Math.abs(area) / 2;
+}
+function isPointArray(value) {
+    if (!Array.isArray(value))
+        return false;
+    return value.every((p) => Array.isArray(p) && p.length === 2 && typeof p[0] === 'number' && typeof p[1] === 'number');
+}
+/**
+ * Pre-flight validator for `{ nodes, rootNodeIds }` build JSON loaded via
+ * Load Build (drag-drop, IFC converter output, hand-edited files).
+ *
+ * Reports issues without mutating; the scene store still owns migration
+ * and orphan cleanup at import time. Hard errors mean the file is
+ * structurally unusable and import should be blocked.
+ */
+export function validateBuildJson(input) {
+    const errors = [];
+    const warnings = [];
+    const schemaIssues = [];
+    const stats = { total: 0, byType: {}, unknownTypes: {}, floorAreaM2: 0 };
+    if (!isPlainObject(input)) {
+        errors.push({
+            severity: 'error',
+            code: 'not_an_object',
+            message: 'File is not a JSON object.',
+        });
+        return {
+            ok: false,
+            parsed: null,
+            stats,
+            errors,
+            warnings,
+            schemaIssues,
+            schemaIssueCount: 0,
+        };
+    }
+    const nodesRaw = input.nodes;
+    const rootNodeIdsRaw = input.rootNodeIds;
+    if (!isPlainObject(nodesRaw)) {
+        errors.push({
+            severity: 'error',
+            code: 'missing_nodes',
+            message: 'Missing or invalid "nodes" — expected an object of id → node.',
+        });
+    }
+    if (!Array.isArray(rootNodeIdsRaw) || !rootNodeIdsRaw.every((id) => typeof id === 'string')) {
+        errors.push({
+            severity: 'error',
+            code: 'missing_root_node_ids',
+            message: 'Missing or invalid "rootNodeIds" — expected an array of node IDs.',
+        });
+    }
+    if (errors.length > 0) {
+        return {
+            ok: false,
+            parsed: null,
+            stats,
+            errors,
+            warnings,
+            schemaIssues,
+            schemaIssueCount: 0,
+        };
+    }
+    const nodes = nodesRaw;
+    const rootNodeIds = rootNodeIdsRaw;
+    if (rootNodeIds.length === 0) {
+        errors.push({
+            severity: 'error',
+            code: 'empty_root_node_ids',
+            message: '"rootNodeIds" is empty — no entry point into the scene.',
+        });
+    }
+    let validRootCount = 0;
+    let mismatchedKeyCount = 0;
+    let schemaFailureCount = 0;
+    for (const [key, value] of Object.entries(nodes)) {
+        if (!isPlainObject(value)) {
+            warnings.push({
+                severity: 'warning',
+                code: 'node_not_object',
+                message: `Node "${key}" is not an object.`,
+                nodeId: key,
+            });
+            continue;
+        }
+        stats.total += 1;
+        const id = typeof value.id === 'string' ? value.id : null;
+        const type = typeof value.type === 'string' ? value.type : null;
+        const parentId = typeof value.parentId === 'string' ? value.parentId : null;
+        if (id && id !== key) {
+            mismatchedKeyCount += 1;
+        }
+        if (!type) {
+            warnings.push({
+                severity: 'warning',
+                code: 'missing_type',
+                message: `Node "${key}" has no "type" field.`,
+                nodeId: key,
+            });
+            continue;
+        }
+        if (KNOWN_TYPES.has(type)) {
+            const t = type;
+            stats.byType[t] = (stats.byType[t] ?? 0) + 1;
+            const parseResult = AnyNode.safeParse(value);
+            if (!parseResult.success) {
+                schemaFailureCount += 1;
+                const issue = parseResult.error.issues[0];
+                schemaIssues.push({
+                    nodeId: key,
+                    nodeType: type,
+                    path: issue ? issue.path.join('.') : '',
+                    message: issue ? issue.message : 'schema mismatch',
+                });
+            }
+            if (type === 'slab') {
+                const polygon = value.polygon;
+                if (isPointArray(polygon)) {
+                    let area = polygonAreaM2(polygon);
+                    const holes = value.holes;
+                    if (Array.isArray(holes)) {
+                        for (const hole of holes) {
+                            if (isPointArray(hole))
+                                area -= polygonAreaM2(hole);
+                        }
+                    }
+                    stats.floorAreaM2 += Math.max(0, area);
+                }
+            }
+        }
+        else {
+            stats.unknownTypes[type] = (stats.unknownTypes[type] ?? 0) + 1;
+        }
+        if (parentId && !(parentId in nodes)) {
+            warnings.push({
+                severity: 'warning',
+                code: 'orphan_parent',
+                message: `Node "${key}" has parentId "${parentId}" which is not in the file (will be dropped on import).`,
+                nodeId: key,
+            });
+        }
+    }
+    if (mismatchedKeyCount > 0) {
+        warnings.push({
+            severity: 'warning',
+            code: 'key_id_mismatch',
+            message: `${mismatchedKeyCount} node${mismatchedKeyCount === 1 ? '' : 's'} have a key that does not match their "id" field.`,
+        });
+    }
+    const unknownTypeNames = Object.keys(stats.unknownTypes);
+    if (unknownTypeNames.length > 0) {
+        const totalUnknown = unknownTypeNames.reduce((n, t) => n + stats.unknownTypes[t], 0);
+        warnings.push({
+            severity: 'warning',
+            code: 'unknown_types',
+            message: `${totalUnknown} node${totalUnknown === 1 ? '' : 's'} use unknown type${unknownTypeNames.length === 1 ? '' : 's'}: ${unknownTypeNames.join(', ')}.`,
+        });
+    }
+    if (schemaFailureCount > 0) {
+        errors.push({
+            severity: 'error',
+            code: 'schema_failure',
+            message: `${schemaFailureCount} node${schemaFailureCount === 1 ? '' : 's'} did not match the expected schema. See details below — these would cause the editor to crash on load.`,
+        });
+    }
+    for (const id of rootNodeIds) {
+        if (id in nodes) {
+            validRootCount += 1;
+        }
+        else {
+            warnings.push({
+                severity: 'warning',
+                code: 'orphan_root',
+                message: `Root node "${id}" is not in the file (will be ignored on import).`,
+                nodeId: id,
+            });
+        }
+    }
+    if (rootNodeIds.length > 0 && validRootCount === 0) {
+        errors.push({
+            severity: 'error',
+            code: 'no_valid_roots',
+            message: 'None of the rootNodeIds point to a node in the file.',
+        });
+    }
+    const hasBuildingOrSite = (stats.byType.building ?? 0) > 0 || (stats.byType.site ?? 0) > 0;
+    if (!hasBuildingOrSite) {
+        warnings.push({
+            severity: 'warning',
+            code: 'no_building',
+            message: 'No site or building node found.',
+        });
+    }
+    if ((stats.byType.level ?? 0) === 0) {
+        warnings.push({
+            severity: 'warning',
+            code: 'no_levels',
+            message: 'No level nodes found.',
+        });
+    }
+    const ok = errors.length === 0;
+    return {
+        ok,
+        parsed: ok ? { nodes, rootNodeIds } : null,
+        stats,
+        errors,
+        warnings,
+        schemaIssues,
+        schemaIssueCount: schemaFailureCount,
+    };
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/core",
-  "version": "0.8.0",
+  "version": "0.9.1",
   "description": "Core library for Pascal 3D building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -16,6 +16,11 @@
       "import": "./dist/utils/clone-scene-graph.js",
       "default": "./dist/utils/clone-scene-graph.js"
     },
+    "./registry": {
+      "types": "./dist/registry/index.d.ts",
+      "import": "./dist/registry/index.js",
+      "default": "./dist/registry/index.js"
+    },
     "./schema": {
       "types": "./dist/schema/index.d.ts",
       "import": "./dist/schema/index.js",
@@ -54,6 +59,8 @@
   "scripts": {
     "build": "tsc --build",
     "dev": "tsc --build --watch",
+    "test": "bun test",
+    "bench:registry": "bun run src/registry/__bench__/relations-resolver.bench.ts",
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
@@ -76,7 +83,7 @@
     "@types/bun": "^1.3.0",
     "@types/react": "^19.2.2",
     "@types/three": "^0.184.0",
-    "typescript": "6.0.2"
+    "typescript": "6.0.3"
   },
   "keywords": [
     "3d",