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

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

@@ -1,3 +1,4 @@
+import { nodeRegistry } from '../registry';
 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)));
@@ -34,7 +35,13 @@ export function validateBuildJson(input) {
     const errors = [];
     const warnings = [];
     const schemaIssues = [];
-    const stats = { total: 0, byType: {}, unknownTypes: {}, floorAreaM2: 0 };
+    const stats = {
+        total: 0,
+        byType: {},
+        pluginTypes: {},
+        unknownTypes: {},
+        floorAreaM2: 0,
+    };
     if (!isPlainObject(input)) {
         errors.push({
             severity: 'error',
@@ -109,6 +116,33 @@ export function validateBuildJson(input) {
             message: '"rootNodeIds" is empty — no entry point into the scene.',
         });
     }
+    // Ids of nodes whose type falls outside the static schema union — plugin
+    // kinds (`trees:tree`) or genuinely unknown types. The scene store accepts
+    // them on load (they already round-trip through the DB fine) and they're
+    // surfaced by the unknown-types warning, but a parent's strict `children`
+    // id union would hard-fail over them: validate parents against a copy with
+    // those ids filtered out. The imported data itself keeps them.
+    const nonSchemaNodeIds = new Set();
+    for (const [key, value] of Object.entries(nodes)) {
+        if (!isPlainObject(value))
+            continue;
+        const type = typeof value.type === 'string' ? value.type : null;
+        if (type && KNOWN_TYPES.has(type))
+            continue;
+        nonSchemaNodeIds.add(typeof value.id === 'string' ? value.id : key);
+    }
+    const withoutNonSchemaChildren = (value) => {
+        const children = value.children;
+        if (!Array.isArray(children))
+            return value;
+        if (!children.some((child) => typeof child === 'string' && nonSchemaNodeIds.has(child))) {
+            return value;
+        }
+        return {
+            ...value,
+            children: children.filter((child) => !(typeof child === 'string' && nonSchemaNodeIds.has(child))),
+        };
+    };
     let validRootCount = 0;
     let mismatchedKeyCount = 0;
     let schemaFailureCount = 0;
@@ -141,7 +175,7 @@ export function validateBuildJson(input) {
         if (KNOWN_TYPES.has(type)) {
             const t = type;
             stats.byType[t] = (stats.byType[t] ?? 0) + 1;
-            const parseResult = AnyNode.safeParse(value);
+            const parseResult = AnyNode.safeParse(withoutNonSchemaChildren(value));
             if (!parseResult.success) {
                 schemaFailureCount += 1;
                 const issue = parseResult.error.issues[0];
@@ -168,7 +202,29 @@ export function validateBuildJson(input) {
             }
         }
         else {
-            stats.unknownTypes[type] = (stats.unknownTypes[type] ?? 0) + 1;
+            const registered = nodeRegistry.get(type);
+            if (registered) {
+                // A runtime-registered plugin kind (e.g. `trees:tree`) is a
+                // first-class citizen: validate it with its own registered schema
+                // instead of flagging it unknown. Files from projects whose plugin
+                // is NOT loaded here still fall through to the unknown-types
+                // warning below.
+                stats.pluginTypes[type] = (stats.pluginTypes[type] ?? 0) + 1;
+                const parseResult = registered.schema.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',
+                    });
+                }
+            }
+            else {
+                stats.unknownTypes[type] = (stats.unknownTypes[type] ?? 0) + 1;
+            }
         }
         if (parentId && !(parentId in nodes)) {
             warnings.push({

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pascal-app/core",
-  "version": "0.9.2",
+  "version": "1.0.0-beta.1",
   "description": "Core library for Pascal 3D building editor",
   "type": "module",
   "main": "./dist/index.js",
@@ -59,7 +59,7 @@
   "scripts": {
     "build": "tsc --build",
     "dev": "tsgo --build --watch",
-    "test": "bun test",
+    "test": "bun test src",
     "bench:registry": "bun run src/registry/__bench__/relations-resolver.bench.ts",
     "prepublishOnly": "npm run build"
   },

package/dist/hooks/scene-registry/scene-registry.test.d.ts

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

package/dist/hooks/scene-registry/scene-registry.test.d.ts.map

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

package/dist/hooks/scene-registry/scene-registry.test.js

@@ -1,26 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { Group } from 'three';
-import { sceneRegistry } from './scene-registry';
-describe('sceneRegistry revision', () => {
-    test('changes only when registered object membership changes', () => {
-        sceneRegistry.clear();
-        const initial = sceneRegistry.revision;
-        const object = new Group();
-        sceneRegistry.nodes.set('wall_a', object);
-        expect(sceneRegistry.revision).toBe(initial + 1);
-        sceneRegistry.nodes.set('wall_a', object);
-        expect(sceneRegistry.revision).toBe(initial + 1);
-        sceneRegistry.nodes.delete('missing');
-        expect(sceneRegistry.revision).toBe(initial + 1);
-        sceneRegistry.nodes.delete('wall_a');
-        expect(sceneRegistry.revision).toBe(initial + 2);
-    });
-    test('clear invalidates a populated registry once', () => {
-        sceneRegistry.clear();
-        sceneRegistry.nodes.set('wall_a', new Group());
-        sceneRegistry.nodes.set('wall_b', new Group());
-        const beforeClear = sceneRegistry.revision;
-        sceneRegistry.clear();
-        expect(sceneRegistry.revision).toBe(beforeClear + 1);
-    });
-});

package/dist/hooks/spatial-grid/floor-placed-elevation.test.d.ts

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

package/dist/hooks/spatial-grid/floor-placed-elevation.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"floor-placed-elevation.test.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/floor-placed-elevation.test.ts"],"names":[],"mappings":""}

package/dist/hooks/spatial-grid/floor-placed-elevation.test.js

@@ -1,366 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-import { nodeRegistry, registerNode } from '../../registry';
-import useScene from '../../store/use-scene';
-import { getFloorPlacedElevation, getFloorStackedPosition } from './floor-placed-elevation';
-import { spatialGridManager } from './spatial-grid-manager';
-const LEVEL_ID = 'level_test';
-function makeDefinition(kind, capabilities = {}) {
-    return {
-        kind,
-        schemaVersion: 1,
-        schema: z.object({ type: z.literal(kind) }),
-        category: 'utility',
-        defaults: () => ({}),
-        capabilities,
-    };
-}
-function makeLevel() {
-    return {
-        id: LEVEL_ID,
-        type: 'level',
-        object: 'node',
-        parentId: null,
-        visible: true,
-        metadata: {},
-        children: [],
-        level: 0,
-    };
-}
-function makeFloorNode(overrides = {}) {
-    return {
-        id: 'item_test',
-        type: 'item',
-        object: 'node',
-        parentId: LEVEL_ID,
-        visible: true,
-        metadata: {},
-        children: [],
-        position: [0, 0, 0],
-        rotation: [0, 0, 0],
-        scale: [1, 1, 1],
-        asset: {
-            id: 'asset_test',
-            category: 'test',
-            name: 'Test',
-            thumbnail: '',
-            src: 'asset:test',
-            dimensions: [1, 1, 1],
-            source: 'library',
-        },
-        ...overrides,
-    };
-}
-function addSlab(polygon, elevation, id = `slab_${elevation}`) {
-    const slab = {
-        id,
-        type: 'slab',
-        object: 'node',
-        parentId: LEVEL_ID,
-        visible: true,
-        metadata: {},
-        children: [],
-        polygon,
-        holes: [],
-        holeMetadata: [],
-        elevation,
-        autoFromWalls: false,
-    };
-    spatialGridManager.handleNodeCreated(slab, LEVEL_ID);
-}
-function nodesFor(...nodes) {
-    return Object.fromEntries(nodes.map((node) => [node.id, node]));
-}
-describe('floor-placed elevation resolver', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-        spatialGridManager.clear();
-        useScene.setState({ nodes: {} });
-    });
-    test('returns 0 without a floorPlaced capability', () => {
-        registerNode(makeDefinition('item'));
-        addSlab([
-            [-1, -1],
-            [1, -1],
-            [1, 1],
-            [-1, 1],
-        ], 0.4);
-        const level = makeLevel();
-        const node = makeFloorNode();
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(level, node),
-            position: [0, 0, 0],
-            rotation: [0, 0, 0],
-        })).toBe(0);
-    });
-    test('canPlaceOnFloorFootprints accepts an L-shaped draft in the open corner gap', () => {
-        const baseAsset = makeFloorNode().asset;
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprint: (node) => ({
-                    dimensions: node.asset
-                        .dimensions,
-                    rotation: [0, node.rotation[1] ?? 0, 0],
-                }),
-                collides: true,
-            },
-        }));
-        const level = makeLevel();
-        const blocker = makeFloorNode({
-            id: 'item_blocker',
-            position: [0.85, 0, 0.85],
-            asset: {
-                ...baseAsset,
-                id: 'asset_blocker',
-                name: 'Blocker',
-                src: 'asset:blocker',
-                dimensions: [0.3, 1, 0.3],
-            },
-        });
-        useScene.setState({ nodes: nodesFor(level, blocker) });
-        const coarse = spatialGridManager.canPlaceOnFloor(LEVEL_ID, [0.5, 0, 0.5], [1, 1, 1], [0, 0, 0]);
-        const precise = spatialGridManager.canPlaceOnFloorFootprints(LEVEL_ID, [
-            { position: [0.2, 0, 0.5], dimensions: [0.4, 1, 1], rotation: [0, 0, 0] },
-            { position: [0.8, 0, 0.2], dimensions: [0.4, 1, 0.4], rotation: [0, 0, 0] },
-        ]);
-        expect(coarse.valid).toBe(false);
-        expect(coarse.conflictIds).toEqual(['item_blocker']);
-        expect(precise.valid).toBe(true);
-        expect(precise.conflictIds).toEqual([]);
-    });
-    test('canPlaceOnFloorFootprints rejects overlapping draft footprints', () => {
-        useScene.setState({ nodes: nodesFor(makeLevel()) });
-        const result = spatialGridManager.canPlaceOnFloorFootprints(LEVEL_ID, [
-            { position: [0, 0, 0], dimensions: [1, 1, 1], rotation: [0, 0, 0] },
-            { position: [0.25, 0, 0], dimensions: [1, 1, 1], rotation: [0, 0, 0] },
-        ]);
-        expect(result.valid).toBe(false);
-        expect(result.conflictIds).toEqual([]);
-    });
-    test('canPlaceOnFloorFootprints ignores descendants of an ignored composite node', () => {
-        registerNode(makeDefinition('cabinet', {
-            floorPlaced: {
-                footprint: () => ({
-                    dimensions: [1, 1, 1],
-                    rotation: [0, 0, 0],
-                }),
-                collides: true,
-            },
-        }));
-        registerNode(makeDefinition('cabinet-module', {
-            floorPlaced: {
-                footprint: () => ({
-                    dimensions: [1, 1, 1],
-                    rotation: [0, 0, 0],
-                }),
-                collides: true,
-            },
-        }));
-        const level = makeLevel();
-        const run = {
-            id: 'cabinet_run',
-            type: 'cabinet',
-            object: 'node',
-            parentId: LEVEL_ID,
-            visible: true,
-            metadata: {},
-            children: ['cabinet-module_child'],
-            position: [0, 0, 0],
-            rotation: 0,
-        };
-        const module = {
-            id: 'cabinet-module_child',
-            type: 'cabinet-module',
-            object: 'node',
-            parentId: run.id,
-            visible: true,
-            metadata: {},
-            children: [],
-            position: [0, 0, 0],
-            rotation: 0,
-        };
-        useScene.setState({ nodes: nodesFor(level, run, module) });
-        const result = spatialGridManager.canPlaceOnFloorFootprints(LEVEL_ID, [{ position: [0, 0, 0], dimensions: [1, 1, 1], rotation: [0, 0, 0] }], [run.id]);
-        expect(result.valid).toBe(true);
-        expect(result.conflictIds).toEqual([]);
-    });
-    test('returns 0 when applies returns false', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprint: () => ({ dimensions: [1, 1, 1], rotation: [0, 0, 0] }),
-                applies: () => false,
-            },
-        }));
-        addSlab([
-            [-1, -1],
-            [1, -1],
-            [1, 1],
-            [-1, 1],
-        ], 0.4);
-        const level = makeLevel();
-        const node = makeFloorNode();
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(level, node),
-            position: [0, 0, 0],
-            rotation: [0, 0, 0],
-        })).toBe(0);
-    });
-    test('clamps non-finite slab elevation to 0', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprint: () => ({ dimensions: [1, 1, 1], rotation: [0, 0, 0] }),
-            },
-        }));
-        const original = spatialGridManager.getSlabElevationForItem;
-        spatialGridManager.getSlabElevationForItem = (() => Number.NaN);
-        try {
-            const level = makeLevel();
-            const node = makeFloorNode();
-            expect(getFloorPlacedElevation({
-                node,
-                nodes: nodesFor(level, node),
-                position: [0, 0, 0],
-                rotation: [0, 0, 0],
-            })).toBe(0);
-        }
-        finally {
-            spatialGridManager.getSlabElevationForItem = original;
-        }
-    });
-    test('returns 0 for a non-level direct parent', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprint: () => ({ dimensions: [1, 1, 1], rotation: [0, 0, 0] }),
-            },
-        }));
-        addSlab([
-            [-1, -1],
-            [1, -1],
-            [1, 1],
-            [-1, 1],
-        ], 0.4);
-        const level = makeLevel();
-        const shelf = {
-            id: 'shelf_test',
-            type: 'shelf',
-            parentId: LEVEL_ID,
-        };
-        const node = makeFloorNode({ parentId: shelf.id });
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(level, shelf, node),
-            position: [0, 0, 0],
-            rotation: [0, 0, 0],
-        })).toBe(0);
-    });
-    test('returns 0 when the declared parent is missing', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprint: () => ({ dimensions: [1, 1, 1], rotation: [0, 0, 0] }),
-            },
-        }));
-        addSlab([
-            [-1, -1],
-            [1, -1],
-            [1, 1],
-            [-1, 1],
-        ], 0.4);
-        const node = makeFloorNode({ parentId: 'missing_level' });
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(node),
-            position: [0, 0, 0],
-            rotation: [0, 0, 0],
-            levelId: LEVEL_ID,
-        })).toBe(0);
-    });
-    test('uses the pending rotated footprint', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprint: (node) => ({
-                    dimensions: [4, 1, 1],
-                    rotation: node.rotation,
-                }),
-            },
-        }));
-        addSlab([
-            [-0.2, 1.2],
-            [0.2, 1.2],
-            [0.2, 1.8],
-            [-0.2, 1.8],
-        ], 0.45);
-        const level = makeLevel();
-        const node = makeFloorNode();
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(level, node),
-            position: [0, 0, 0],
-            rotation: [0, Math.PI / 2, 0],
-        })).toBeCloseTo(0.45);
-    });
-    test('returns slab overlap elevation and stacks Y onto canonical position', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprint: (node) => ({
-                    dimensions: [1, 1, 1],
-                    rotation: node.rotation,
-                }),
-            },
-        }));
-        addSlab([
-            [-1, -1],
-            [1, -1],
-            [1, 1],
-            [-1, 1],
-        ], 0.35);
-        const level = makeLevel();
-        const node = makeFloorNode();
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(level, node),
-            position: [0, 0.1, 0],
-            rotation: [0, 0, 0],
-        })).toBeCloseTo(0.35);
-        const stacked = getFloorStackedPosition({
-            node,
-            nodes: nodesFor(level, node),
-            position: [0, 0.1, 0],
-            rotation: [0, 0, 0],
-        });
-        expect(stacked[0]).toBe(0);
-        expect(stacked[1]).toBeCloseTo(0.45);
-        expect(stacked[2]).toBe(0);
-    });
-    test('takes the max elevation across composite footprints', () => {
-        registerNode(makeDefinition('item', {
-            floorPlaced: {
-                footprints: () => [
-                    { position: [0, 0, 0], dimensions: [1, 1, 1], rotation: [0, 0, 0] },
-                    { position: [3, 0, 0], dimensions: [1, 1, 1], rotation: [0, 0, 0] },
-                ],
-            },
-        }));
-        addSlab([
-            [-1, -1],
-            [1, -1],
-            [1, 1],
-            [-1, 1],
-        ], 0.2, 'slab_low');
-        addSlab([
-            [2.5, -0.5],
-            [3.5, -0.5],
-            [3.5, 0.5],
-            [2.5, 0.5],
-        ], 0.8, 'slab_high');
-        const level = makeLevel();
-        const node = makeFloorNode();
-        expect(getFloorPlacedElevation({
-            node,
-            nodes: nodesFor(level, node),
-            position: [0, 0, 0],
-            rotation: [0, 0, 0],
-        })).toBeCloseTo(0.8);
-    });
-});

package/dist/hooks/spatial-grid/wall-slab-overlap.test.d.ts

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

package/dist/hooks/spatial-grid/wall-slab-overlap.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"wall-slab-overlap.test.d.ts","sourceRoot":"","sources":["../../../src/hooks/spatial-grid/wall-slab-overlap.test.ts"],"names":[],"mappings":""}