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

package/dist/lib/space-detection.test.js

@@ -1,376 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { CeilingNode, SlabNode, WallNode, ZoneNode } from '../schema';
-import { detectSpacesForLevel, planAutoCeilingsForLevel, planAutoSlabsForLevel, planAutoZonesForLevel, resolveAutoZonePolygon, wallClosesRoom, } from './space-detection';
-const square = [
-    [0, 0],
-    [4, 0],
-    [4, 3],
-    [0, 3],
-];
-function roomPolygon() {
-    return square.map(([x, y]) => ({ x, y }));
-}
-function squareWalls(height = 2.5) {
-    return [
-        WallNode.parse({ start: [0, 0], end: [4, 0], height }),
-        WallNode.parse({ start: [4, 0], end: [4, 3], height }),
-        WallNode.parse({ start: [4, 3], end: [0, 3], height }),
-        WallNode.parse({ start: [0, 3], end: [0, 0], height }),
-    ];
-}
-function slab(elevation) {
-    return SlabNode.parse({
-        polygon: square,
-        elevation,
-        autoFromWalls: true,
-    });
-}
-describe('planAutoCeilingsForLevel', () => {
-    test('creates auto ceilings at the top of the room walls', () => {
-        const created = planAutoCeilingsForLevel([roomPolygon()], [], {
-            walls: squareWalls(),
-            slabs: [slab(0.05)],
-        }).create[0];
-        expect(created?.height).toBeCloseTo(2.55);
-    });
-    test('updates existing auto ceiling height when the slab elevation changes', () => {
-        const ceiling = CeilingNode.parse({
-            polygon: square,
-            height: 2.55,
-            autoFromWalls: true,
-        });
-        const plan = planAutoCeilingsForLevel([roomPolygon()], [ceiling], {
-            walls: squareWalls(),
-            slabs: [slab(0.4)],
-        });
-        expect(plan.update).toHaveLength(1);
-        expect(plan.update[0]?.id).toBe(ceiling.id);
-        expect(plan.update[0]?.data.polygon).toBeUndefined();
-        expect(plan.update[0]?.data.height).toBeCloseTo(2.9);
-    });
-    test('updates existing auto ceiling height when wall height changes', () => {
-        const ceiling = CeilingNode.parse({
-            polygon: square,
-            height: 2.55,
-            autoFromWalls: true,
-        });
-        const plan = planAutoCeilingsForLevel([roomPolygon()], [ceiling], {
-            walls: squareWalls(3),
-            slabs: [slab(0.05)],
-        });
-        expect(plan.update).toHaveLength(1);
-        expect(plan.update[0]?.data.height).toBeCloseTo(3.05);
-    });
-    test('does not replace a manual ceiling with an auto ceiling', () => {
-        const manualCeiling = CeilingNode.parse({
-            polygon: square,
-            height: 2.5,
-            autoFromWalls: false,
-        });
-        const plan = planAutoCeilingsForLevel([roomPolygon()], [manualCeiling], {
-            walls: squareWalls(),
-            slabs: [slab(0.4)],
-        });
-        expect(plan.create).toHaveLength(0);
-        expect(plan.update).toHaveLength(0);
-    });
-    test('demotes an orphaned auto ceiling to manual with its polygon untouched', () => {
-        const ceiling = CeilingNode.parse({
-            polygon: square,
-            height: 2.55,
-            autoFromWalls: true,
-        });
-        const plan = planAutoCeilingsForLevel([], [ceiling]);
-        expect(plan.create).toHaveLength(0);
-        expect(plan.delete).toHaveLength(0);
-        expect(plan.update).toHaveLength(1);
-        expect(plan.update[0]?.id).toBe(ceiling.id);
-        // Ceilings render the stored polygon in both modes, so no polygon bake.
-        expect(plan.update[0]?.data).toEqual({ autoFromWalls: false });
-    });
-    test('deletes an unmatched auto ceiling absorbed by a room merge', () => {
-        const leftCeiling = CeilingNode.parse({
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-            autoFromWalls: true,
-        });
-        const rightCeiling = CeilingNode.parse({
-            polygon: [
-                [4, 0],
-                [8, 0],
-                [8, 3],
-                [4, 3],
-            ],
-            autoFromWalls: true,
-        });
-        const mergedRoom = [
-            { x: 0, y: 0 },
-            { x: 8, y: 0 },
-            { x: 8, y: 3 },
-            { x: 0, y: 3 },
-        ];
-        const plan = planAutoCeilingsForLevel([mergedRoom], [leftCeiling, rightCeiling]);
-        expect(plan.create).toHaveLength(0);
-        expect(plan.delete).toHaveLength(1);
-        const survivorId = plan.update[0]?.id;
-        expect([leftCeiling.id, rightCeiling.id]).toContain(plan.delete[0]);
-        expect(plan.delete[0]).not.toBe(survivorId);
-    });
-    test('a demoted ceiling suppresses re-creating an auto ceiling when the room re-forms', () => {
-        const ceiling = CeilingNode.parse({
-            polygon: square,
-            height: 2.55,
-            autoFromWalls: true,
-        });
-        const demotion = planAutoCeilingsForLevel([], [ceiling]).update[0];
-        const demoted = CeilingNode.parse({ ...ceiling, ...demotion?.data });
-        expect(demoted.autoFromWalls).toBe(false);
-        const plan = planAutoCeilingsForLevel([roomPolygon()], [demoted], {
-            walls: squareWalls(),
-            slabs: [slab(0.05)],
-        });
-        expect(plan.create).toHaveLength(0);
-        expect(plan.update).toHaveLength(0);
-        expect(plan.delete).toHaveLength(0);
-    });
-});
-describe('detectSpacesForLevel', () => {
-    const areaOf = (polygon) => {
-        let area = 0;
-        for (let i = 0; i < polygon.length; i += 1) {
-            const a = polygon[i];
-            const b = polygon[(i + 1) % polygon.length];
-            area += a.x * b.y - b.x * a.y;
-        }
-        return Math.abs(area / 2);
-    };
-    test('detects an isolated four-wall room', () => {
-        const walls = squareWalls();
-        const { roomPolygons, spaces } = detectSpacesForLevel('level-1', walls);
-        expect(roomPolygons).toHaveLength(1);
-        expect(new Set(spaces[0]?.wallIds)).toEqual(new Set(walls.map((wall) => wall.id)));
-        expect(spaces[0]?.boundaryFaces).toHaveLength(4);
-        expect(spaces[0]?.boundaryFaces.map((boundary) => `${boundary.wallId}:${boundary.face}`).sort()).toEqual(walls.map((wall) => `${wall.id}:front`).sort());
-    });
-    test('excludes dangling wall branches from a room boundary', () => {
-        const roomWalls = squareWalls();
-        const branch = WallNode.parse({ start: [0, 0], end: [1, 1] });
-        const { roomPolygons, spaces } = detectSpacesForLevel('level-1', [...roomWalls, branch]);
-        expect(roomPolygons).toHaveLength(1);
-        expect(roomPolygons[0]).toHaveLength(4);
-        expect(areaOf(roomPolygons[0])).toBeCloseTo(12);
-        expect(spaces[0]?.wallIds.sort()).toEqual(roomWalls.map((wall) => wall.id).sort());
-        expect(spaces[0]?.boundaryFaces).toHaveLength(4);
-    });
-    test('detects a room closed against the middle of an existing wall (T-junction)', () => {
-        // Big 6×5 room; a smaller room hangs below, its two verticals landing on the
-        // interior of the big room's bottom wall (x=1 and x=3, not endpoints). Before
-        // planarization those touch points were dangling nodes and the small room
-        // was never detected.
-        const walls = [
-            WallNode.parse({ start: [0, 0], end: [6, 0] }),
-            WallNode.parse({ start: [6, 0], end: [6, 5] }),
-            WallNode.parse({ start: [6, 5], end: [0, 5] }),
-            WallNode.parse({ start: [0, 5], end: [0, 0] }),
-            WallNode.parse({ start: [1, 0], end: [1, -2] }),
-            WallNode.parse({ start: [1, -2], end: [3, -2] }),
-            WallNode.parse({ start: [3, -2], end: [3, 0] }),
-        ];
-        const { roomPolygons, spaces } = detectSpacesForLevel('level-1', walls);
-        const areas = roomPolygons.map((poly) => areaOf(poly)).sort((a, b) => a - b);
-        const smallRoom = spaces.find((space) => areaOf(space.polygon.map(([x, y]) => ({ x, y }))) < 5);
-        expect(roomPolygons).toHaveLength(2);
-        expect(areas[0]).toBeCloseTo(4, 1); // small room: 2×2
-        expect(areas[1]).toBeCloseTo(30, 1); // big room: 6×5
-        expect(new Set(smallRoom?.wallIds)).toEqual(new Set([walls[0].id, walls[4].id, walls[5].id, walls[6].id]));
-        const longWallId = walls[0].id;
-        const longWallBoundaries = spaces.flatMap((space) => space.boundaryFaces.filter((boundary) => boundary.wallId === longWallId));
-        expect(longWallBoundaries).toHaveLength(4);
-        expect(longWallBoundaries.filter((boundary) => boundary.face === 'back')).toHaveLength(1);
-        expect(longWallBoundaries.filter((boundary) => boundary.face === 'front')).toHaveLength(3);
-        expect(longWallBoundaries.map((boundary) => boundary.points)).toContainEqual([
-            [1, 0],
-            [3, 0],
-        ]);
-    });
-});
-describe('procedural zones', () => {
-    test('adopts an exact room footprint and records its enclosing walls', () => {
-        const walls = squareWalls();
-        const { spaces } = detectSpacesForLevel('level-1', walls);
-        const zone = ZoneNode.parse({ name: 'Kitchen', polygon: square });
-        const plan = planAutoZonesForLevel(spaces, [zone]);
-        expect(plan.update).toHaveLength(1);
-        expect(plan.update[0]?.data.autoFromWalls).toBe(true);
-        expect(new Set(plan.update[0]?.data.boundaryWallIds)).toEqual(new Set(walls.map((wall) => wall.id)));
-    });
-    test('derives the live polygon from effective wall endpoints', () => {
-        const walls = squareWalls();
-        const zone = ZoneNode.parse({
-            name: 'Kitchen',
-            polygon: square,
-            autoFromWalls: true,
-            boundaryWallIds: walls.map((wall) => wall.id),
-        });
-        const movedWalls = [
-            { ...walls[0], end: [5, 0] },
-            { ...walls[1], start: [5, 0], end: [5, 3] },
-            { ...walls[2], start: [5, 3] },
-            walls[3],
-        ];
-        const byId = new Map(movedWalls.map((wall) => [wall.id, wall]));
-        const polygon = resolveAutoZonePolygon(zone, (id) => byId.get(id));
-        const plan = planAutoZonesForLevel(detectSpacesForLevel('level-1', movedWalls).spaces, [zone]);
-        expect(polygon).toContainEqual([5, 0]);
-        expect(polygon).toContainEqual([5, 3]);
-        expect(polygon).not.toContainEqual([4, 0]);
-        expect(plan.update[0]?.data.polygon).toContainEqual([5, 0]);
-    });
-    test('leaves an unrelated site zone manual', () => {
-        const { spaces } = detectSpacesForLevel('level-1', squareWalls());
-        const zone = ZoneNode.parse({
-            name: 'Lawn',
-            polygon: [
-                [10, 10],
-                [12, 10],
-                [12, 12],
-                [10, 12],
-            ],
-        });
-        expect(planAutoZonesForLevel(spaces, [zone]).update).toHaveLength(0);
-    });
-});
-describe('wallClosesRoom', () => {
-    test('is false while a chain is still open, true once it encloses a room', () => {
-        const open = [
-            WallNode.parse({ start: [0, 0], end: [4, 0] }),
-            WallNode.parse({ start: [4, 0], end: [4, 3] }),
-            WallNode.parse({ start: [4, 3], end: [0, 3] }),
-        ];
-        const closing = WallNode.parse({ start: [0, 3], end: [0, 0] });
-        expect(wallClosesRoom(open, closing)).toBe(false);
-        expect(wallClosesRoom([...open, closing], closing)).toBe(true);
-    });
-    test('fires when a bay is sealed against the middle of an existing wall', () => {
-        const bigRoom = [
-            WallNode.parse({ start: [0, 0], end: [6, 0] }),
-            WallNode.parse({ start: [6, 0], end: [6, 5] }),
-            WallNode.parse({ start: [6, 5], end: [0, 5] }),
-            WallNode.parse({ start: [0, 5], end: [0, 0] }),
-        ];
-        const bayLeft = WallNode.parse({ start: [1, 0], end: [1, -2] });
-        const bayBottom = WallNode.parse({ start: [1, -2], end: [3, -2] });
-        const bayRight = WallNode.parse({ start: [3, -2], end: [3, 0] });
-        // Two sides down and across: not enclosed yet.
-        expect(wallClosesRoom([...bigRoom, bayLeft, bayBottom], bayBottom)).toBe(false);
-        // The final side lands on the interior of the big room's bottom wall.
-        expect(wallClosesRoom([...bigRoom, bayLeft, bayBottom, bayRight], bayRight)).toBe(true);
-    });
-});
-describe('planAutoSlabsForLevel', () => {
-    test('matches two identical rooms to their own existing auto-slabs without churn', () => {
-        // Two rooms with identical polygon signatures previously collided in a
-        // signature-keyed Map, so one detected room never matched an existing slab
-        // and churned (delete + recreate) on every pass.
-        const slabA = slab(0.05);
-        const slabB = slab(0.05);
-        const plan = planAutoSlabsForLevel([roomPolygon(), roomPolygon()], [slabA, slabB]);
-        expect(plan.create).toHaveLength(0);
-        expect(plan.delete).toHaveLength(0);
-        expect(plan.update).toHaveLength(0);
-    });
-    test('deletes an extra auto-slab when only one identical room is detected', () => {
-        const plan = planAutoSlabsForLevel([roomPolygon()], [slab(0.05), slab(0.05)]);
-        expect(plan.create).toHaveLength(0);
-        expect(plan.delete).toHaveLength(1);
-    });
-    test('demotes an orphaned auto slab to manual when its room disappears', () => {
-        const painted = SlabNode.parse({
-            polygon: square,
-            elevation: 0.4,
-            autoFromWalls: true,
-        });
-        const plan = planAutoSlabsForLevel([], [painted]);
-        expect(plan.create).toHaveLength(0);
-        expect(plan.delete).toHaveLength(0);
-        expect(plan.update).toHaveLength(1);
-        const update = plan.update[0];
-        expect(update?.id).toBe(painted.id);
-        // Demotion flips only the flag — the stored polygon stays untouched
-        // (render offsets derive from level context at geometry build time).
-        expect(update?.data).toEqual({ autoFromWalls: false });
-    });
-    test('deletes an unmatched auto slab whose area was absorbed by a room merge', () => {
-        const leftSlab = SlabNode.parse({
-            polygon: [
-                [0, 0],
-                [4, 0],
-                [4, 3],
-                [0, 3],
-            ],
-            autoFromWalls: true,
-        });
-        const rightSlab = SlabNode.parse({
-            polygon: [
-                [4, 0],
-                [8, 0],
-                [8, 3],
-                [4, 3],
-            ],
-            autoFromWalls: true,
-        });
-        const mergedRoom = [
-            { x: 0, y: 0 },
-            { x: 8, y: 0 },
-            { x: 8, y: 3 },
-            { x: 0, y: 3 },
-        ];
-        const plan = planAutoSlabsForLevel([mergedRoom], [leftSlab, rightSlab]);
-        expect(plan.create).toHaveLength(0);
-        expect(plan.delete).toHaveLength(1);
-        expect(plan.update).toHaveLength(1);
-        const survivorId = plan.update[0]?.id;
-        expect([leftSlab.id, rightSlab.id]).toContain(plan.delete[0]);
-        expect(plan.delete[0]).not.toBe(survivorId);
-        // The survivor stays auto — updated to the merged polygon, not demoted.
-        expect(plan.update[0]?.data.autoFromWalls).toBeUndefined();
-    });
-    test('a demoted slab suppresses re-creating an auto slab when the room re-forms', () => {
-        const auto = slab(0.05);
-        const demotion = planAutoSlabsForLevel([], [auto]).update[0];
-        const demoted = SlabNode.parse({ ...auto, ...demotion?.data });
-        expect(demoted.autoFromWalls).toBe(false);
-        const plan = planAutoSlabsForLevel([roomPolygon()], [demoted]);
-        expect(plan.create).toHaveLength(0);
-        expect(plan.update).toHaveLength(0);
-        expect(plan.delete).toHaveLength(0);
-    });
-    test('manual slabs that split one room suppress a replacement full-room slab', () => {
-        const left = SlabNode.parse({
-            polygon: [
-                [0, 0],
-                [2, 0],
-                [2, 3],
-                [0, 3],
-            ],
-            autoFromWalls: false,
-        });
-        const right = SlabNode.parse({
-            polygon: [
-                [2, 0],
-                [4, 0],
-                [4, 3],
-                [2, 3],
-            ],
-            autoFromWalls: false,
-        });
-        const plan = planAutoSlabsForLevel([roomPolygon()], [left, right]);
-        expect(plan.create).toHaveLength(0);
-        expect(plan.update).toHaveLength(0);
-        expect(plan.delete).toHaveLength(0);
-    });
-});

package/dist/lib/zone-quantities.test.d.ts

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

package/dist/lib/zone-quantities.test.d.ts.map

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

package/dist/lib/zone-quantities.test.js

@@ -1,82 +0,0 @@
-import { describe, expect, test } from 'bun:test';
-import { CeilingNode, SlabNode, WallNode, ZoneNode } from '../schema';
-import { deriveZoneQuantityReport } from './zone-quantities';
-const polygon = [
-    [0, 0],
-    [4, 0],
-    [4, 3],
-    [0, 3],
-];
-function sceneRecord(nodes) {
-    return Object.fromEntries(nodes.map((node) => [node.id, node]));
-}
-function roomNodes() {
-    const zone = ZoneNode.parse({ id: 'zone_room', name: 'Studio', parentId: 'level_main', polygon });
-    const slab = SlabNode.parse({ id: 'slab_room', parentId: 'level_main', polygon });
-    const ceiling = CeilingNode.parse({ id: 'ceiling_room', parentId: 'level_main', polygon });
-    const walls = polygon.map((start, index) => WallNode.parse({
-        id: `wall_${index}`,
-        parentId: 'level_main',
-        start,
-        end: polygon[(index + 1) % polygon.length],
-        height: 2.5,
-    }));
-    return { zone, slab, ceiling, walls };
-}
-describe('deriveZoneQuantityReport', () => {
-    test('derives room surfaces and volume only from matching enclosure geometry', () => {
-        const { zone, slab, ceiling, walls } = roomNodes();
-        const report = deriveZoneQuantityReport(zone, sceneRecord([zone, slab, ceiling, ...walls]));
-        expect(report.classification).toBe('enclosed-room');
-        expect(report.footprintArea).toBeCloseTo(12);
-        expect(report.perimeter).toBeCloseTo(14);
-        expect(report.boundaryWallIds).toHaveLength(4);
-        expect(report.wallSurface).toEqual({
-            status: 'available',
-            value: 35,
-            note: 'Gross interior wall face before openings.',
-        });
-        expect(report.floorSurface).toEqual({
-            status: 'available',
-            value: 12,
-            note: 'Matching slab surface after openings.',
-        });
-        expect(report.volume.status).toBe('available');
-        if (report.volume.status === 'available')
-            expect(report.volume.value).toBeCloseTo(29.4);
-    });
-    test('keeps standalone zones honest about unavailable room quantities', () => {
-        const zone = ZoneNode.parse({
-            id: 'zone_site',
-            name: 'Garden',
-            parentId: 'level_main',
-            polygon,
-        });
-        const report = deriveZoneQuantityReport(zone, sceneRecord([zone]));
-        expect(report.classification).toBe('footprint');
-        expect(report.footprintArea).toBeCloseTo(12);
-        expect(report.wallSurface.status).toBe('unavailable');
-        expect(report.floorSurface.status).toBe('unavailable');
-        expect(report.volume.status).toBe('unavailable');
-    });
-    test('subtracts matching slab openings from floor surface', () => {
-        const { zone, slab } = roomNodes();
-        const slabWithHole = SlabNode.parse({
-            ...slab,
-            holes: [
-                [
-                    [1, 1],
-                    [2, 1],
-                    [2, 2],
-                    [1, 2],
-                ],
-            ],
-        });
-        const report = deriveZoneQuantityReport(zone, sceneRecord([zone, slabWithHole]));
-        expect(report.floorSurface).toEqual({
-            status: 'available',
-            value: 11,
-            note: 'Matching slab surface after openings.',
-        });
-    });
-});

package/dist/registry/registry.test.d.ts

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

package/dist/registry/registry.test.d.ts.map

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

package/dist/registry/registry.test.js

@@ -1,196 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-import { getHostRefFields, getNodePluginId, isDrawnViaTool, isDrawnViaToolKind, isNodeKindEnabled, isPresettable, isPresettableKind, loadPlugin, nodeRegistry, registerNode, } from './registry';
-// Re-registering a kind warns + replaces in dev (HMR) but throws in
-// production — see `registry._register`. `bun test` runs with
-// NODE_ENV=test (dev path), so the throw-path tests pin NODE_ENV to
-// 'production' for the duration of the call.
-async function inProduction(fn) {
-    const prev = process.env.NODE_ENV;
-    process.env.NODE_ENV = 'production';
-    try {
-        return await fn();
-    }
-    finally {
-        process.env.NODE_ENV = prev;
-    }
-}
-function makeDefinition(kind, overrides = {}) {
-    return {
-        kind,
-        schemaVersion: 1,
-        schema: z.object({ type: z.literal(kind) }),
-        category: 'utility',
-        defaults: () => ({}),
-        capabilities: {},
-        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
-        ...overrides,
-    };
-}
-describe('nodeRegistry', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('starts empty', () => {
-        expect(nodeRegistry.size).toBe(0);
-        expect(nodeRegistry.has('anything')).toBe(false);
-        expect(nodeRegistry.get('anything')).toBeUndefined();
-    });
-    test('registerNode adds a definition', () => {
-        const def = makeDefinition('column');
-        registerNode(def);
-        expect(nodeRegistry.size).toBe(1);
-        expect(nodeRegistry.has('column')).toBe(true);
-        expect(nodeRegistry.get('column')).toBe(def);
-    });
-    test('registerNode throws on duplicate kind in production', async () => {
-        await inProduction(() => {
-            registerNode(makeDefinition('column'));
-            expect(() => registerNode(makeDefinition('column'))).toThrow(/duplicate node kind/);
-        });
-    });
-    test('registerNode replaces on duplicate kind in dev (HMR)', () => {
-        const first = makeDefinition('column');
-        const second = makeDefinition('column');
-        registerNode(first);
-        registerNode(second);
-        expect(nodeRegistry.size).toBe(1);
-        expect(nodeRegistry.get('column')).toBe(second);
-    });
-    test('registerNode rejects empty kind', () => {
-        expect(() => registerNode(makeDefinition(''))).toThrow(/non-empty string/);
-    });
-    test('registerNode rejects invalid schemaVersion', () => {
-        expect(() => registerNode(makeDefinition('bad', { schemaVersion: 0 }))).toThrow(/schemaVersion/);
-        expect(() => registerNode(makeDefinition('bad', { schemaVersion: -1 }))).toThrow(/schemaVersion/);
-    });
-    test('entries() iterates registered definitions', () => {
-        registerNode(makeDefinition('a'));
-        registerNode(makeDefinition('b'));
-        const kinds = Array.from(nodeRegistry.entries(), ([k]) => k);
-        expect(kinds).toEqual(['a', 'b']);
-    });
-    test('schemas() returns all registered schemas', () => {
-        const a = makeDefinition('a');
-        const b = makeDefinition('b');
-        registerNode(a);
-        registerNode(b);
-        expect(nodeRegistry.schemas()).toEqual([a.schema, b.schema]);
-    });
-});
-describe('isPresettable', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('explicit true wins', () => {
-        const def = makeDefinition('explicit-true', { capabilities: { presettable: true } });
-        expect(isPresettable(def)).toBe(true);
-    });
-    test('explicit false wins even with parametrics', () => {
-        const def = makeDefinition('explicit-false', {
-            capabilities: { presettable: false },
-            parametrics: { groups: [] },
-        });
-        expect(isPresettable(def)).toBe(false);
-    });
-    test('defaults to true when parametrics exists', () => {
-        const def = makeDefinition('param', { parametrics: { groups: [] } });
-        expect(isPresettable(def)).toBe(true);
-    });
-    test('defaults to false without parametrics', () => {
-        const def = makeDefinition('no-param');
-        expect(isPresettable(def)).toBe(false);
-    });
-    test('isPresettableKind looks up the registry', () => {
-        registerNode(makeDefinition('shelfy', { parametrics: { groups: [] } }));
-        expect(isPresettableKind('shelfy')).toBe(true);
-        expect(isPresettableKind('unknown')).toBe(false);
-    });
-});
-describe('getHostRefFields', () => {
-    test('returns the declared hostRefFields verbatim', () => {
-        const def = makeDefinition('door', { capabilities: { hostRefFields: ['wallId'] } });
-        expect(getHostRefFields(def)).toEqual(['wallId']);
-    });
-    test('defaults to an empty array when none declared', () => {
-        const def = makeDefinition('shelf');
-        expect(getHostRefFields(def)).toEqual([]);
-    });
-});
-describe('isDrawnViaTool', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('true when capability set', () => {
-        const def = makeDefinition('fence', { capabilities: { drawTool: true } });
-        expect(isDrawnViaTool(def)).toBe(true);
-    });
-    test('false when unset or not exactly true', () => {
-        expect(isDrawnViaTool(makeDefinition('column'))).toBe(false);
-        expect(isDrawnViaTool(makeDefinition('off', { capabilities: { drawTool: false } }))).toBe(false);
-    });
-    test('isDrawnViaToolKind looks up the registry', () => {
-        registerNode(makeDefinition('fence', { capabilities: { drawTool: true } }));
-        expect(isDrawnViaToolKind('fence')).toBe(true);
-        expect(isDrawnViaToolKind('unknown')).toBe(false);
-    });
-});
-describe('loadPlugin', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('registers all nodes from a plugin', async () => {
-        const plugin = {
-            id: 'test:plugin',
-            apiVersion: 1,
-            nodes: [makeDefinition('a'), makeDefinition('b')],
-        };
-        await loadPlugin(plugin);
-        expect(nodeRegistry.size).toBe(2);
-        expect(nodeRegistry.has('a')).toBe(true);
-        expect(nodeRegistry.has('b')).toBe(true);
-        expect(getNodePluginId('a')).toBe('test:plugin');
-        expect(getNodePluginId('b')).toBe('test:plugin');
-    });
-    test('enables plugin kinds only when the project has the plugin installed', async () => {
-        await loadPlugin({ id: 'test:plugin', apiVersion: 1, nodes: [makeDefinition('plugin:node')] });
-        expect(isNodeKindEnabled('plugin:node', [])).toBe(false);
-        expect(isNodeKindEnabled('plugin:node', ['test:plugin'])).toBe(true);
-        expect(isNodeKindEnabled('plugin:node')).toBe(true);
-        expect(isNodeKindEnabled('host:node', [])).toBe(true);
-    });
-    test('keeps built-in plugin kinds enabled independently of project installs', async () => {
-        await loadPlugin({ id: 'pascal:core', apiVersion: 1, nodes: [makeDefinition('wall')] });
-        expect(isNodeKindEnabled('wall', [])).toBe(true);
-    });
-    test('handles plugin with no nodes', async () => {
-        await loadPlugin({ id: 'empty', apiVersion: 1 });
-        expect(nodeRegistry.size).toBe(0);
-    });
-    test('handles plugin with empty nodes array', async () => {
-        await loadPlugin({ id: 'empty', apiVersion: 1, nodes: [] });
-        expect(nodeRegistry.size).toBe(0);
-    });
-    test('throws on apiVersion mismatch', async () => {
-        const plugin = {
-            id: 'old-plugin',
-            apiVersion: 99,
-            nodes: [],
-        };
-        await expect(loadPlugin(plugin)).rejects.toThrow(/apiVersion/);
-    });
-    test('propagates duplicate-kind error from a single plugin in production', async () => {
-        const plugin = {
-            id: 'broken',
-            apiVersion: 1,
-            nodes: [makeDefinition('dup'), makeDefinition('dup')],
-        };
-        await inProduction(() => expect(loadPlugin(plugin)).rejects.toThrow(/duplicate node kind/));
-    });
-    test('propagates duplicate-kind error across plugins in production', async () => {
-        await inProduction(async () => {
-            await loadPlugin({ id: 'a', apiVersion: 1, nodes: [makeDefinition('shared')] });
-            await expect(loadPlugin({ id: 'b', apiVersion: 1, nodes: [makeDefinition('shared')] })).rejects.toThrow(/duplicate node kind/);
-        });
-    });
-});

package/dist/registry/relations-resolver.test.d.ts

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

package/dist/registry/relations-resolver.test.d.ts.map

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