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

package/dist/services/drag-session.test.js

@@ -1,219 +0,0 @@
-import { beforeEach, describe, expect, mock, test } from 'bun:test';
-import { z } from 'zod';
-import { nodeRegistry, registerNode } from '../registry/registry';
-import { createDragSession } from './drag-session';
-const id = (s) => s;
-function makeSpyScene(initial = {}) {
-    const calls = {
-        pauseHistory: 0,
-        resumeHistory: 0,
-        restoreAll: 0,
-        markedDirty: [],
-        updated: [],
-    };
-    const nodes = { ...initial };
-    return {
-        get: ((nid) => nodes[nid]),
-        nodes: () => nodes,
-        update: (nid, patch) => {
-            calls.updated.push([nid, patch]);
-            const existing = nodes[nid];
-            if (existing)
-                nodes[nid] = { ...existing, ...patch };
-        },
-        upsert: (n) => {
-            nodes[n.id] = n;
-            return n.id;
-        },
-        delete: (nid) => {
-            delete nodes[nid];
-        },
-        restore: () => { },
-        restoreAll: () => {
-            calls.restoreAll += 1;
-        },
-        markDirty: (nid) => {
-            calls.markedDirty.push(nid);
-        },
-        pauseHistory: () => {
-            calls.pauseHistory += 1;
-        },
-        resumeHistory: () => {
-            calls.resumeHistory += 1;
-        },
-        getSubtree: () => null,
-        cloneNodesInto: () => null,
-        _calls: calls,
-    };
-}
-function makeDef(kind, relations) {
-    return {
-        kind,
-        schemaVersion: 1,
-        schema: z.object({ type: z.literal(kind) }),
-        category: 'utility',
-        defaults: () => ({}),
-        capabilities: {},
-        relations,
-        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
-    };
-}
-function makeAction() {
-    return {
-        begin: ({ node }) => ({ id: node?.id ?? id('default') }),
-        preview: (_ctx, point) => ({ x: point[0] }),
-        apply: (_draft, ctx) => [ctx.id],
-        cancel: () => { },
-    };
-}
-describe('createDragSession', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('start pauses history; commit resumes', () => {
-        const scene = makeSpyScene();
-        const session = createDragSession(makeAction(), scene);
-        session.start({ point: [0, 0] });
-        expect(scene._calls.pauseHistory).toBe(1);
-        expect(scene._calls.resumeHistory).toBe(0);
-        session.commit();
-        expect(scene._calls.resumeHistory).toBe(1);
-    });
-    test('cancel resumes history and calls restoreAll', () => {
-        const scene = makeSpyScene();
-        const session = createDragSession(makeAction(), scene);
-        session.start({ point: [0, 0] });
-        session.cancel();
-        expect(scene._calls.resumeHistory).toBe(1);
-        expect(scene._calls.restoreAll).toBe(1);
-    });
-    test('move runs preview + apply and marks the returned id dirty', () => {
-        const scene = makeSpyScene({ a: { id: id('a'), type: 'thing' } });
-        const session = createDragSession(makeAction(), scene);
-        session.start({ point: [0, 0], node: { id: id('a') } });
-        session.move([1, 0], { shift: false, alt: false, ctrl: false, meta: false });
-        expect(session.getDraft()).toEqual({ x: 1 });
-        expect(scene._calls.markedDirty).toContain(id('a'));
-    });
-    test('snap callback is invoked when defined', () => {
-        const action = {
-            ...makeAction(),
-            snap: (draft) => ({ x: Math.round(draft.x) }),
-        };
-        const scene = makeSpyScene({ a: { id: id('a'), type: 'thing' } });
-        const session = createDragSession(action, scene);
-        session.start({ point: [0, 0], node: { id: id('a') } });
-        session.move([0.7, 0], { shift: false, alt: false, ctrl: false, meta: false });
-        expect(session.getDraft()).toEqual({ x: 1 });
-    });
-    test('commit returns false when action.commit returns false; calls action.cancel and restoreAll', () => {
-        const cancelSpy = mock(() => { });
-        const action = {
-            ...makeAction(),
-            cancel: cancelSpy,
-            commit: () => false,
-        };
-        const scene = makeSpyScene({ a: { id: id('a'), type: 'thing' } });
-        const session = createDragSession(action, scene);
-        session.start({ point: [0, 0], node: { id: id('a') } });
-        session.move([1, 0], { shift: false, alt: false, ctrl: false, meta: false });
-        const result = session.commit();
-        expect(result).toBe(false);
-        expect(cancelSpy).toHaveBeenCalledTimes(1);
-        expect(scene._calls.restoreAll).toBe(1);
-    });
-    test('move is a no-op when session is not active', () => {
-        const scene = makeSpyScene();
-        const session = createDragSession(makeAction(), scene);
-        session.move([1, 0], { shift: false, alt: false, ctrl: false, meta: false });
-        expect(scene._calls.markedDirty.length).toBe(0);
-    });
-    test('repeated start is a no-op (re-entry guard)', () => {
-        const scene = makeSpyScene();
-        const session = createDragSession(makeAction(), scene);
-        session.start({ point: [0, 0] });
-        session.start({ point: [99, 99] });
-        expect(scene._calls.pauseHistory).toBe(1); // only one pause
-    });
-    test('dispose mid-drag cancels and cleans up', () => {
-        const scene = makeSpyScene();
-        const session = createDragSession(makeAction(), scene);
-        session.start({ point: [0, 0] });
-        expect(session.isActive()).toBe(true);
-        session.dispose();
-        expect(session.isActive()).toBe(false);
-        expect(scene._calls.resumeHistory).toBe(1);
-        expect(scene._calls.restoreAll).toBe(1);
-    });
-    test('dispose when inactive is a no-op', () => {
-        const scene = makeSpyScene();
-        const session = createDragSession(makeAction(), scene);
-        session.dispose();
-        expect(scene._calls.pauseHistory).toBe(0);
-        expect(scene._calls.resumeHistory).toBe(0);
-    });
-    test('onCommit callback fires on successful commit', () => {
-        const onCommit = mock(() => { });
-        const onCancel = mock(() => { });
-        const scene = makeSpyScene();
-        const session = createDragSession(makeAction(), scene, { onCommit, onCancel });
-        session.start({ point: [0, 0] });
-        session.commit();
-        expect(onCommit).toHaveBeenCalledTimes(1);
-        expect(onCancel).toHaveBeenCalledTimes(0);
-    });
-    test('onCancel callback fires on explicit cancel', () => {
-        const onCommit = mock(() => { });
-        const onCancel = mock(() => { });
-        const scene = makeSpyScene();
-        const session = createDragSession(makeAction(), scene, { onCommit, onCancel });
-        session.start({ point: [0, 0] });
-        session.cancel();
-        expect(onCommit).toHaveBeenCalledTimes(0);
-        expect(onCancel).toHaveBeenCalledTimes(1);
-    });
-    test('dispose does NOT fire onCancel (silent cleanup)', () => {
-        const onCommit = mock(() => { });
-        const onCancel = mock(() => { });
-        const scene = makeSpyScene();
-        const session = createDragSession(makeAction(), scene, { onCommit, onCancel });
-        session.start({ point: [0, 0] });
-        session.dispose();
-        expect(onCommit).toHaveBeenCalledTimes(0);
-        expect(onCancel).toHaveBeenCalledTimes(0);
-        expect(scene._calls.resumeHistory).toBe(1);
-        expect(scene._calls.restoreAll).toBe(1);
-    });
-    test('dirty cascade fires once per id even across multiple move ticks', () => {
-        // Register a kind with no relations — cascade returns just {startId}.
-        registerNode(makeDef('thing'));
-        const scene = makeSpyScene({ a: { id: id('a'), type: 'thing' } });
-        const session = createDragSession(makeAction(), scene);
-        session.start({ point: [0, 0], node: { id: id('a') } });
-        session.move([1, 0], { shift: false, alt: false, ctrl: false, meta: false });
-        session.move([2, 0], { shift: false, alt: false, ctrl: false, meta: false });
-        session.move([3, 0], { shift: false, alt: false, ctrl: false, meta: false });
-        // a is marked once, not three times
-        expect(scene._calls.markedDirty.filter((mid) => mid === id('a')).length).toBe(1);
-    });
-    test('dirty cascade follows hosts relations from the registry', () => {
-        registerNode(makeDef('wall', { hosts: ['door'] }));
-        registerNode(makeDef('door'));
-        const scene = makeSpyScene({
-            w: { id: id('w'), type: 'wall', children: [id('d')] },
-            d: { id: id('d'), type: 'door', parentId: id('w') },
-        });
-        const action = {
-            begin: () => ({ id: id('w') }),
-            preview: (_ctx, point) => ({ x: point[0] }),
-            apply: (_draft, ctx) => [ctx.id],
-            cancel: () => { },
-        };
-        const session = createDragSession(action, scene);
-        session.start({ point: [0, 0], node: { id: id('w') } });
-        session.move([1, 0], { shift: false, alt: false, ctrl: false, meta: false });
-        // both wall and door marked dirty
-        expect(scene._calls.markedDirty).toContain(id('w'));
-        expect(scene._calls.markedDirty).toContain(id('d'));
-    });
-});

package/dist/services/hosting.test.d.ts

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

package/dist/services/hosting.test.d.ts.map

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

package/dist/services/hosting.test.js

@@ -1,230 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-import { nodeRegistry, registerNode } from '../registry/registry';
-import { canAttach, canHostOnTop, clampYToHostTop, getSurface, getTopSurfaceHeight, MAX_HOST_DEPTH, pickHost, } from './hosting';
-const id = (s) => s;
-function makeItem(idStr, attachTo) {
-    return {
-        id: id(idStr),
-        type: 'item',
-        parentId: null,
-        visible: true,
-        asset: attachTo ? { attachTo } : {},
-    };
-}
-function makeDef(kind, capabilities = {}, overrides = {}) {
-    return {
-        kind,
-        schemaVersion: 1,
-        schema: z.object({ type: z.literal(kind) }),
-        category: 'utility',
-        defaults: () => ({}),
-        capabilities,
-        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
-        ...overrides,
-    };
-}
-function makeNode(kind, idStr, parentId = null) {
-    return {
-        id: id(idStr),
-        type: kind,
-        parentId: parentId ? id(parentId) : null,
-        visible: true,
-    };
-}
-function makeFakeScene(nodes) {
-    return {
-        get: ((nid) => nodes[nid]),
-        nodes: () => nodes,
-        update: () => { },
-        upsert: () => id(''),
-        delete: () => { },
-        restore: () => { },
-        restoreAll: () => { },
-        markDirty: () => { },
-        pauseHistory: () => { },
-        resumeHistory: () => { },
-        getSubtree: () => null,
-        cloneNodesInto: () => null,
-    };
-}
-describe('canAttach', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('rejects self-host', () => {
-        const scene = makeFakeScene({ a: makeNode('thing', 'a') });
-        const result = canAttach(id('a'), id('a'), scene);
-        expect(result.ok).toBe(false);
-        if (!result.ok)
-            expect(result.error.kind).toBe('self-host');
-    });
-    test('rejects missing host', () => {
-        const scene = makeFakeScene({ a: makeNode('thing', 'a') });
-        const result = canAttach(id('a'), id('missing'), scene);
-        expect(result.ok).toBe(false);
-        if (!result.ok)
-            expect(result.error.kind).toBe('host-missing');
-    });
-    test('detects cycle when host is a descendant of child', () => {
-        // child=a, host=b, b's parent chain leads back to a → cycle.
-        const scene = makeFakeScene({
-            a: makeNode('thing', 'a'),
-            b: makeNode('thing', 'b', 'c'),
-            c: makeNode('thing', 'c', 'a'), // c.parent = a, b.parent = c → cycle if a → b
-        });
-        const result = canAttach(id('a'), id('b'), scene);
-        expect(result.ok).toBe(false);
-        if (!result.ok)
-            expect(result.error.kind).toBe('cycle');
-    });
-    test('rejects when chain would exceed MAX_HOST_DEPTH', () => {
-        const nodes = {};
-        for (let i = 0; i <= MAX_HOST_DEPTH; i++) {
-            nodes[`n${i}`] = makeNode('thing', `n${i}`, i === 0 ? null : `n${i - 1}`);
-        }
-        // n6 is already MAX_HOST_DEPTH deep — attaching n_new beneath it would
-        // push the child to MAX_HOST_DEPTH + 1.
-        nodes.candidate = makeNode('thing', 'candidate');
-        const scene = makeFakeScene(nodes);
-        const result = canAttach(id('candidate'), id(`n${MAX_HOST_DEPTH}`), scene);
-        expect(result.ok).toBe(false);
-        if (!result.ok)
-            expect(result.error.kind).toBe('depth-exceeded');
-    });
-    test('accepts attach when chain stays within MAX_HOST_DEPTH', () => {
-        const scene = makeFakeScene({
-            root: makeNode('thing', 'root'),
-            candidate: makeNode('thing', 'candidate'),
-        });
-        expect(canAttach(id('candidate'), id('root'), scene).ok).toBe(true);
-    });
-    test('rejects host kind not in child def.hostable.parents', () => {
-        registerNode(makeDef('shelf', { hostable: { parents: ['wall', 'slab'] } }));
-        const scene = makeFakeScene({
-            s: makeNode('shelf', 's'),
-            ceiling: makeNode('ceiling', 'ceiling'),
-        });
-        const result = canAttach(id('s'), id('ceiling'), scene);
-        expect(result.ok).toBe(false);
-        if (!result.ok)
-            expect(result.error.kind).toBe('kind-not-allowed');
-    });
-    test('accepts when host kind is in parents', () => {
-        registerNode(makeDef('shelf', { hostable: { parents: ['wall', 'slab'] } }));
-        const scene = makeFakeScene({
-            s: makeNode('shelf', 's'),
-            w: makeNode('wall', 'w'),
-        });
-        expect(canAttach(id('s'), id('w'), scene).ok).toBe(true);
-    });
-    test('no def or no hostable.parents = no kind restriction', () => {
-        // Some kinds (e.g. items via catalog) defer to runtime checks instead of
-        // declaring parents up front. canAttach should not block them.
-        const scene = makeFakeScene({
-            i: makeNode('item', 'i'),
-            w: makeNode('wall', 'w'),
-        });
-        expect(canAttach(id('i'), id('w'), scene).ok).toBe(true);
-    });
-    test('allows missing child (placement preview before commit)', () => {
-        const scene = makeFakeScene({ w: makeNode('wall', 'w') });
-        expect(canAttach(id('future-child'), id('w'), scene).ok).toBe(true);
-    });
-});
-describe('getSurface / getTopSurfaceHeight', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('returns null when host has no registered def', () => {
-        const node = makeNode('mystery', 'm');
-        expect(getSurface(node)).toBeNull();
-        expect(getTopSurfaceHeight(node)).toBeNull();
-    });
-    test('returns surface config when declared', () => {
-        registerNode(makeDef('table', {
-            surfaces: { top: { height: 0.74 } },
-        }));
-        const t = makeNode('table', 't');
-        expect(getSurface(t)?.top?.height).toBe(0.74);
-        expect(getTopSurfaceHeight(t)).toBe(0.74);
-    });
-    test('evaluates function-valued height with the node', () => {
-        registerNode(makeDef('shelf', {
-            surfaces: {
-                top: {
-                    height: (n) => (n.id === id('high') ? 1.8 : 0.3),
-                },
-            },
-        }));
-        expect(getTopSurfaceHeight(makeNode('shelf', 'high'))).toBe(1.8);
-        expect(getTopSurfaceHeight(makeNode('shelf', 'low'))).toBe(0.3);
-    });
-});
-describe('clampYToHostTop', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('clamps to top when host has one', () => {
-        registerNode(makeDef('table', { surfaces: { top: { height: 0.74 } } }));
-        expect(clampYToHostTop(makeNode('table', 't'), 5)).toBe(0.74);
-    });
-    test('passes through when host has no top surface', () => {
-        registerNode(makeDef('plain'));
-        expect(clampYToHostTop(makeNode('plain', 'p'), 5)).toBe(5);
-    });
-});
-describe('pickHost', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('returns first candidate that has hostable capability', () => {
-        registerNode(makeDef('slab', { hostable: { parents: ['*'] } }));
-        registerNode(makeDef('item')); // no hostable
-        const candidates = [makeNode('item', 'i'), makeNode('slab', 's')];
-        const picked = pickHost({
-            point: [0, 0, 0],
-            candidates,
-            placedKind: 'chair',
-        });
-        expect(picked?.id).toBe(id('s'));
-    });
-    test('returns null when nothing in candidates is hostable', () => {
-        registerNode(makeDef('item'));
-        const candidates = [makeNode('item', 'i')];
-        expect(pickHost({ point: [0, 0, 0], candidates, placedKind: 'chair' })).toBeNull();
-    });
-    test('hitTest can reject hostable candidates', () => {
-        registerNode(makeDef('slab', { hostable: { parents: ['*'] } }));
-        const candidates = [makeNode('slab', 's1'), makeNode('slab', 's2')];
-        const picked = pickHost({
-            point: [0, 0, 0],
-            candidates,
-            placedKind: 'chair',
-            hitTest: (host) => host.id === id('s2'),
-        });
-        expect(picked?.id).toBe(id('s2'));
-    });
-    test('excludes ceiling-mounted hosts (ceiling fan cannot be a top surface)', () => {
-        registerNode(makeDef('item', { hostable: { parents: ['*'] } }));
-        const candidates = [makeItem('fan', 'ceiling'), makeItem('table')];
-        const picked = pickHost({ point: [0, 0, 0], candidates, placedKind: 'item' });
-        expect(picked?.id).toBe(id('table'));
-    });
-    test('keeps wall-mounted hosts (wall shelf still hosts)', () => {
-        registerNode(makeDef('item', { hostable: { parents: ['*'] } }));
-        const candidates = [makeItem('shelf', 'wall')];
-        const picked = pickHost({ point: [0, 0, 0], candidates, placedKind: 'item' });
-        expect(picked?.id).toBe(id('shelf'));
-    });
-});
-describe('canHostOnTop', () => {
-    test('rejects ceiling-attachTo hosts', () => {
-        expect(canHostOnTop(makeItem('fan', 'ceiling'))).toBe(false);
-    });
-    test('accepts wall / wall-side / floor (undefined) hosts', () => {
-        expect(canHostOnTop(makeItem('shelf', 'wall'))).toBe(true);
-        expect(canHostOnTop(makeItem('sconce', 'wall-side'))).toBe(true);
-        expect(canHostOnTop(makeItem('table'))).toBe(true);
-    });
-});

package/dist/services/movement.test.d.ts

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

package/dist/services/movement.test.d.ts.map

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

package/dist/services/movement.test.js

@@ -1,133 +0,0 @@
-import { beforeEach, describe, expect, test } from 'bun:test';
-import { z } from 'zod';
-import { nodeRegistry, registerNode } from '../registry/registry';
-import { applyAxisLock, isMovable, movePlanToward, moveToward, resolveMovable } from './movement';
-const id = (s) => s;
-function makeDef(kind, capabilities = {}) {
-    return {
-        kind,
-        schemaVersion: 1,
-        schema: z.object({ type: z.literal(kind) }),
-        category: 'utility',
-        defaults: () => ({}),
-        capabilities,
-        renderer: { kind: 'parametric', module: async () => ({ default: () => null }) },
-    };
-}
-function makeNode(kind, idStr) {
-    return {
-        id: id(idStr),
-        type: kind,
-        parentId: null,
-        visible: true,
-    };
-}
-describe('resolveMovable', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('returns null when no def is registered', () => {
-        expect(resolveMovable(makeNode('mystery', 'm'))).toBeNull();
-    });
-    test('returns null when def declares no movable capability', () => {
-        registerNode(makeDef('static'));
-        expect(resolveMovable(makeNode('static', 's'))).toBeNull();
-    });
-    test('returns the declared config', () => {
-        registerNode(makeDef('column', { movable: { axes: ['x', 'z'], gridSnap: true } }));
-        const config = resolveMovable(makeNode('column', 'c'));
-        expect(config?.axes).toEqual(['x', 'z']);
-        expect(config?.gridSnap).toBe(true);
-    });
-    test('runs override callback when present', () => {
-        let overrideRan = false;
-        const config = {
-            axes: ['x'],
-            override: () => {
-                overrideRan = true;
-                return { axes: ['y'] };
-            },
-        };
-        registerNode(makeDef('weird', { movable: config }));
-        const resolved = resolveMovable(makeNode('weird', 'w'));
-        expect(overrideRan).toBe(true);
-        expect(resolved?.axes).toEqual(['y']);
-    });
-    test('override returning null falls back to base config', () => {
-        registerNode(makeDef('column', {
-            movable: { axes: ['x', 'z'], override: () => null },
-        }));
-        const resolved = resolveMovable(makeNode('column', 'c'));
-        expect(resolved?.axes).toEqual(['x', 'z']);
-    });
-});
-describe('applyAxisLock', () => {
-    test('passes through unlocked axes only', () => {
-        expect(applyAxisLock([1, 2, 3], [10, 20, 30], ['x'])).toEqual([10, 2, 3]);
-        expect(applyAxisLock([1, 2, 3], [10, 20, 30], ['x', 'z'])).toEqual([10, 2, 30]);
-        expect(applyAxisLock([1, 2, 3], [10, 20, 30], ['x', 'y', 'z'])).toEqual([10, 20, 30]);
-    });
-    test('empty lock returns current unchanged', () => {
-        expect(applyAxisLock([1, 2, 3], [10, 20, 30], [])).toEqual([1, 2, 3]);
-    });
-});
-describe('moveToward', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('returns null when node is not movable', () => {
-        registerNode(makeDef('static'));
-        expect(moveToward(makeNode('static', 's'), [0, 0, 0], [1, 1, 1])).toBeNull();
-    });
-    test('axis-locks and returns the constrained target', () => {
-        registerNode(makeDef('column', { movable: { axes: ['x', 'z'] } }));
-        expect(moveToward(makeNode('column', 'c'), [0, 0.5, 0], [1, 99, 2])).toEqual([1, 0.5, 2]);
-    });
-    test('applies grid snap when capability declares gridSnap: true', () => {
-        registerNode(makeDef('column', { movable: { axes: ['x', 'z'], gridSnap: true } }));
-        const result = moveToward(makeNode('column', 'c'), [0, 0, 0], [0.3, 0, 0.6], {
-            gridStep: 0.25,
-        });
-        expect(result).toEqual([0.25, 0, 0.5]);
-    });
-    test('grid snap can be overridden at call site', () => {
-        registerNode(makeDef('column', { movable: { axes: ['x', 'z'], gridSnap: true } }));
-        // Caller explicitly disables grid snap for this call
-        const result = moveToward(makeNode('column', 'c'), [0, 0, 0], [0.3, 0, 0.6], {
-            gridSnap: false,
-        });
-        expect(result).toEqual([0.3, 0, 0.6]);
-    });
-});
-describe('movePlanToward', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('returns 2D point with X/Z constrained, Y dropped', () => {
-        registerNode(makeDef('column', { movable: { axes: ['x', 'z'], gridSnap: true } }));
-        const result = movePlanToward(makeNode('column', 'c'), 0.5, // currentY
-        [0, 0], [0.3, 0.6], { gridStep: 0.25 });
-        expect(result).toEqual([0.25, 0.5]);
-    });
-    test('returns null when node is not movable', () => {
-        registerNode(makeDef('static'));
-        expect(movePlanToward(makeNode('static', 's'), 0, [0, 0], [1, 1])).toBeNull();
-    });
-});
-describe('isMovable', () => {
-    beforeEach(() => {
-        nodeRegistry._reset();
-    });
-    test('true when movable.axes has entries', () => {
-        registerNode(makeDef('column', { movable: { axes: ['x'] } }));
-        expect(isMovable(makeNode('column', 'c'))).toBe(true);
-    });
-    test('false when no movable capability', () => {
-        registerNode(makeDef('static'));
-        expect(isMovable(makeNode('static', 's'))).toBe(false);
-    });
-    test('false when movable.axes is empty', () => {
-        registerNode(makeDef('locked', { movable: { axes: [] } }));
-        expect(isMovable(makeNode('locked', 'l'))).toBe(false);
-    });
-});

package/dist/services/opening-guides.test.d.ts

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

package/dist/services/opening-guides.test.d.ts.map

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