@pascal-app/core 0.8.0 → 0.9.2

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

@@ -0,0 +1,88 @@
+import { describe, expect, test } from 'bun:test';
+import { healSceneNodes } from './heal-scene-graph';
+describe('healSceneNodes', () => {
+    test('strips non-string (null) children entries', () => {
+        const { nodes, strippedChildRefs } = healSceneNodes({
+            wall_a: {
+                id: 'wall_a',
+                type: 'wall',
+                start: [0, 0],
+                end: [1, 0],
+                children: [null, 'item_x'],
+            },
+            item_x: { id: 'item_x', type: 'item' },
+        });
+        expect(strippedChildRefs).toBe(1);
+        expect(nodes.wall_a.children).toEqual(['item_x']);
+    });
+    test('drops childless zero-length walls and removes their parent reference', () => {
+        const { nodes, droppedWallIds } = healSceneNodes({
+            level_0: { id: 'level_0', type: 'level', children: ['wall_zero', 'wall_real'] },
+            wall_zero: { id: 'wall_zero', type: 'wall', start: [5, 5], end: [5, 5], children: [] },
+            wall_real: { id: 'wall_real', type: 'wall', start: [0, 0], end: [3, 0], children: [] },
+        });
+        expect(droppedWallIds).toEqual(['wall_zero']);
+        expect('wall_zero' in nodes).toBe(false);
+        expect(nodes.level_0.children).toEqual(['wall_real']);
+    });
+    test('keeps a zero-length wall that still hosts a door/window', () => {
+        const { nodes, droppedWallIds } = healSceneNodes({
+            wall_z: { id: 'wall_z', type: 'wall', start: [1, 1], end: [1, 1], children: ['door_1'] },
+            door_1: { id: 'door_1', type: 'door' },
+        });
+        expect(droppedWallIds).toEqual([]);
+        expect('wall_z' in nodes).toBe(true);
+    });
+    test('passes a clean scene through untouched', () => {
+        const input = {
+            wall_a: { id: 'wall_a', type: 'wall', start: [0, 0], end: [2, 0], children: ['door_1'] },
+            door_1: { id: 'door_1', type: 'door' },
+        };
+        const { nodes, droppedWallIds, strippedChildRefs } = healSceneNodes(input);
+        expect(droppedWallIds).toEqual([]);
+        expect(strippedChildRefs).toBe(0);
+        expect(nodes.wall_a).toBe(input.wall_a);
+    });
+    test('drops a stale child reference left behind by a reparent', () => {
+        // window's parentId says wall_b, but wall_a still lists it — the exact
+        // corruption that rendered a window twice (duplicate React keys in 2D).
+        const { nodes, strippedStaleChildRefs } = healSceneNodes({
+            wall_a: { id: 'wall_a', type: 'wall', start: [0, 0], end: [2, 0], children: ['window_1'] },
+            wall_b: { id: 'wall_b', type: 'wall', start: [2, 0], end: [4, 0], children: ['window_1'] },
+            window_1: { id: 'window_1', type: 'window', parentId: 'wall_b' },
+        });
+        expect(strippedStaleChildRefs).toBe(1);
+        expect(nodes.wall_a.children).toEqual([]);
+        expect(nodes.wall_b.children).toEqual(['window_1']);
+    });
+    test('collapses same-array duplicate child references', () => {
+        const { nodes, strippedStaleChildRefs } = healSceneNodes({
+            wall_a: {
+                id: 'wall_a',
+                type: 'wall',
+                start: [0, 0],
+                end: [2, 0],
+                children: ['door_1', 'door_1'],
+            },
+            door_1: { id: 'door_1', type: 'door', parentId: 'wall_a' },
+        });
+        expect(strippedStaleChildRefs).toBe(1);
+        expect(nodes.wall_a.children).toEqual(['door_1']);
+    });
+    test('keeps children whose parentId matches or is absent', () => {
+        const input = {
+            wall_a: {
+                id: 'wall_a',
+                type: 'wall',
+                start: [0, 0],
+                end: [2, 0],
+                children: ['door_1', 'item_legacy'],
+            },
+            door_1: { id: 'door_1', type: 'door', parentId: 'wall_a' },
+            item_legacy: { id: 'item_legacy', type: 'item' },
+        };
+        const { nodes, strippedStaleChildRefs } = healSceneNodes(input);
+        expect(strippedStaleChildRefs).toBe(0);
+        expect(nodes.wall_a).toBe(input.wall_a);
+    });
+});

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

@@ -0,0 +1,44 @@
+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[];
+    installedPlugins?: 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;AAG3D,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;IACrB,gBAAgB,CAAC,EAAE,MAAM,EAAE,CAAA;CAC5B,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,CAwPzE"}

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

@@ -0,0 +1,256 @@
+import { AnyNode } from '../schema/types';
+import { healSceneNodes } from '../utils/heal-scene-graph';
+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;
+    const installedPluginsRaw = input.installedPlugins;
+    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,
+        };
+    }
+    // Heal known pre-existing corruption (null children, zero-length walls) up
+    // front, so a scene saved before the source fixes still imports instead of
+    // hard-failing schema validation. `parsed` below carries the repaired nodes.
+    const { nodes, droppedWallIds, strippedChildRefs } = healSceneNodes(nodesRaw);
+    const rootNodeIds = rootNodeIdsRaw;
+    const installedPlugins = Array.isArray(installedPluginsRaw) &&
+        installedPluginsRaw.every((pluginId) => typeof pluginId === 'string')
+        ? Array.from(new Set(installedPluginsRaw))
+        : undefined;
+    if (installedPluginsRaw !== undefined && installedPlugins === undefined) {
+        warnings.push({
+            severity: 'warning',
+            code: 'invalid_installed_plugins',
+            message: 'Ignored invalid "installedPlugins" — expected an array of plugin IDs.',
+        });
+    }
+    if (strippedChildRefs > 0 || droppedWallIds.length > 0) {
+        warnings.push({
+            severity: 'warning',
+            code: 'auto_repaired',
+            message: `Repaired on import: removed ${strippedChildRefs} invalid child reference${strippedChildRefs === 1 ? '' : 's'} and ${droppedWallIds.length} zero-length wall${droppedWallIds.length === 1 ? '' : 's'}.`,
+        });
+    }
+    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,
+                ...(installedPlugins ? { installedPlugins } : {}),
+            }
+            : 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.2",
   "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",
@@ -53,14 +58,16 @@
   ],
   "scripts": {
     "build": "tsc --build",
-    "dev": "tsc --build --watch",
+    "dev": "tsgo --build --watch",
+    "test": "bun test",
+    "bench:registry": "bun run src/registry/__bench__/relations-resolver.bench.ts",
     "prepublishOnly": "npm run build"
   },
   "peerDependencies": {
     "@react-three/drei": "^10",
     "@react-three/fiber": "^9",
     "react": "^18 || ^19",
-    "three": "^0.184"
+    "three": "^0.185"
   },
   "dependencies": {
     "dedent": "^1.7.1",
@@ -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",