opentasks 0.0.6 → 0.0.7

package/dist/graph/__tests__/FederatedGraph.test.d.ts.map

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

package/dist/graph/__tests__/FederatedGraph.test.js

@@ -0,0 +1,661 @@
+import { describe, it, expect, beforeEach } from 'vitest';
+import { createFederatedGraph, } from '../FederatedGraph.js';
+import { createGraphologyAdapter } from '../GraphologyAdapter.js';
+describe('FederatedGraph', () => {
+    let adapter;
+    let graph;
+    beforeEach(() => {
+        adapter = createGraphologyAdapter();
+        graph = createFederatedGraph(adapter);
+    });
+    // Test fixtures - a simple graph:
+    //
+    //   s-spec1 ──implements──> i-issue1 ──blocks──> i-issue2 ──blocks──> i-issue3
+    //                              │
+    //                              └──blocks──> i-issue4
+    //
+    const spec1 = {
+        id: 's-spec1',
+        uuid: 'uuid-spec1',
+        type: 'spec',
+        title: 'Spec 1',
+        created_at: '2025-01-01T00:00:00Z',
+        updated_at: '2025-01-01T00:00:00Z',
+    };
+    const issue1 = {
+        id: 'i-issue1',
+        uuid: 'uuid-issue1',
+        type: 'issue',
+        title: 'Issue 1',
+        status: 'open',
+        created_at: '2025-01-01T00:00:00Z',
+        updated_at: '2025-01-01T00:00:00Z',
+    };
+    const issue2 = {
+        id: 'i-issue2',
+        uuid: 'uuid-issue2',
+        type: 'issue',
+        title: 'Issue 2',
+        status: 'open',
+        created_at: '2025-01-01T00:00:00Z',
+        updated_at: '2025-01-01T00:00:00Z',
+    };
+    const issue3 = {
+        id: 'i-issue3',
+        uuid: 'uuid-issue3',
+        type: 'issue',
+        title: 'Issue 3',
+        status: 'closed',
+        created_at: '2025-01-01T00:00:00Z',
+        updated_at: '2025-01-01T00:00:00Z',
+    };
+    const issue4 = {
+        id: 'i-issue4',
+        uuid: 'uuid-issue4',
+        type: 'issue',
+        title: 'Issue 4',
+        status: 'open',
+        created_at: '2025-01-01T00:00:00Z',
+        updated_at: '2025-01-01T00:00:00Z',
+    };
+    const edgeImplements = {
+        id: 'e-impl',
+        uuid: 'uuid-impl',
+        from_id: 'i-issue1',
+        to_id: 's-spec1',
+        type: 'implements',
+        created_at: '2025-01-01T00:00:00Z',
+    };
+    const edgeBlocks1 = {
+        id: 'e-blocks1',
+        uuid: 'uuid-blocks1',
+        from_id: 'i-issue1',
+        to_id: 'i-issue2',
+        type: 'blocks',
+        created_at: '2025-01-01T00:00:00Z',
+    };
+    const edgeBlocks2 = {
+        id: 'e-blocks2',
+        uuid: 'uuid-blocks2',
+        from_id: 'i-issue2',
+        to_id: 'i-issue3',
+        type: 'blocks',
+        created_at: '2025-01-01T00:00:00Z',
+    };
+    const edgeBlocks3 = {
+        id: 'e-blocks3',
+        uuid: 'uuid-blocks3',
+        from_id: 'i-issue1',
+        to_id: 'i-issue4',
+        type: 'blocks',
+        created_at: '2025-01-01T00:00:00Z',
+    };
+    function setupGraph() {
+        adapter.onNodeCreated(spec1);
+        adapter.onNodeCreated(issue1);
+        adapter.onNodeCreated(issue2);
+        adapter.onNodeCreated(issue3);
+        adapter.onNodeCreated(issue4);
+        adapter.onEdgeCreated(edgeImplements);
+        adapter.onEdgeCreated(edgeBlocks1);
+        adapter.onEdgeCreated(edgeBlocks2);
+        adapter.onEdgeCreated(edgeBlocks3);
+    }
+    describe('related()', () => {
+        beforeEach(setupGraph);
+        it('returns outgoing neighbors', () => {
+            const result = graph.related('native://i-issue1', { direction: 'out' });
+            expect(result).toHaveLength(3);
+            expect(result).toContain('native://s-spec1');
+            expect(result).toContain('native://i-issue2');
+            expect(result).toContain('native://i-issue4');
+        });
+        it('returns incoming neighbors', () => {
+            const result = graph.related('native://i-issue2', { direction: 'in' });
+            expect(result).toHaveLength(1);
+            expect(result).toContain('native://i-issue1');
+        });
+        it('returns both directions by default', () => {
+            const result = graph.related('native://i-issue2');
+            expect(result).toHaveLength(2);
+            expect(result).toContain('native://i-issue1'); // incoming
+            expect(result).toContain('native://i-issue3'); // outgoing
+        });
+        it('filters by edge type (string)', () => {
+            const result = graph.related('native://i-issue1', {
+                direction: 'out',
+                edgeType: 'blocks',
+            });
+            expect(result).toHaveLength(2);
+            expect(result).toContain('native://i-issue2');
+            expect(result).toContain('native://i-issue4');
+            expect(result).not.toContain('native://s-spec1');
+        });
+        it('filters by edge type (array)', () => {
+            const result = graph.related('native://i-issue1', {
+                direction: 'out',
+                edgeType: ['implements'],
+            });
+            expect(result).toHaveLength(1);
+            expect(result).toContain('native://s-spec1');
+        });
+        it('returns empty for non-existent node', () => {
+            const result = graph.related('native://non-existent');
+            expect(result).toHaveLength(0);
+        });
+        it('removes duplicates with both direction', () => {
+            // Create a bidirectional relationship
+            adapter.onEdgeCreated({
+                id: 'e-related1',
+                uuid: 'uuid-related1',
+                from_id: 'i-issue2',
+                to_id: 'i-issue1',
+                type: 'related',
+                created_at: '2025-01-01T00:00:00Z',
+            });
+            const result = graph.related('native://i-issue1', {
+                direction: 'both',
+                edgeType: ['blocks', 'related'],
+            });
+            // issue2 should only appear once even though there are edges in both directions
+            const issue2Count = result.filter((r) => r === 'native://i-issue2').length;
+            expect(issue2Count).toBe(1);
+        });
+    });
+    describe('reachable()', () => {
+        beforeEach(setupGraph);
+        it('returns transitively reachable nodes (out)', () => {
+            const result = graph.reachable('native://i-issue1', {
+                direction: 'out',
+                edgeType: 'blocks',
+            });
+            expect(result).toHaveLength(3);
+            expect(result).toContain('native://i-issue2');
+            expect(result).toContain('native://i-issue3');
+            expect(result).toContain('native://i-issue4');
+        });
+        it('returns transitively reachable nodes (in)', () => {
+            const result = graph.reachable('native://i-issue3', {
+                direction: 'in',
+                edgeType: 'blocks',
+            });
+            expect(result).toHaveLength(2);
+            expect(result).toContain('native://i-issue2');
+            expect(result).toContain('native://i-issue1');
+        });
+        it('respects maxDepth', () => {
+            const result = graph.reachable('native://i-issue1', {
+                direction: 'out',
+                edgeType: 'blocks',
+                maxDepth: 1,
+            });
+            expect(result).toHaveLength(2);
+            expect(result).toContain('native://i-issue2');
+            expect(result).toContain('native://i-issue4');
+            expect(result).not.toContain('native://i-issue3'); // 2 hops away
+        });
+        it('does not include start node', () => {
+            const result = graph.reachable('native://i-issue1', { direction: 'out' });
+            expect(result).not.toContain('native://i-issue1');
+        });
+        it('handles cycles without infinite loop', () => {
+            // Create a cycle: issue3 -> issue1
+            adapter.onEdgeCreated({
+                id: 'e-cycle',
+                uuid: 'uuid-cycle',
+                from_id: 'i-issue3',
+                to_id: 'i-issue1',
+                type: 'blocks',
+                created_at: '2025-01-01T00:00:00Z',
+            });
+            const result = graph.reachable('native://i-issue1', {
+                direction: 'out',
+                edgeType: 'blocks',
+            });
+            // Should terminate and include all reachable nodes exactly once
+            expect(result).toHaveLength(3);
+        });
+        it('returns empty for non-existent node', () => {
+            const result = graph.reachable('native://non-existent');
+            expect(result).toHaveLength(0);
+        });
+        it('filters by multiple edge types', () => {
+            const result = graph.reachable('native://i-issue1', {
+                direction: 'out',
+                edgeType: ['blocks', 'implements'],
+            });
+            expect(result).toHaveLength(4);
+            expect(result).toContain('native://s-spec1');
+            expect(result).toContain('native://i-issue2');
+            expect(result).toContain('native://i-issue3');
+            expect(result).toContain('native://i-issue4');
+        });
+    });
+    describe('shortestPath()', () => {
+        beforeEach(setupGraph);
+        it('finds shortest path', () => {
+            const result = graph.shortestPath('native://i-issue1', 'native://i-issue3');
+            expect(result).not.toBeNull();
+            expect(result).toHaveLength(3);
+            expect(result[0]).toBe('native://i-issue1');
+            expect(result[1]).toBe('native://i-issue2');
+            expect(result[2]).toBe('native://i-issue3');
+        });
+        it('returns path of length 1 for adjacent nodes', () => {
+            const result = graph.shortestPath('native://i-issue1', 'native://i-issue2');
+            expect(result).toHaveLength(2);
+        });
+        it('returns path of length 0 for same node', () => {
+            const result = graph.shortestPath('native://i-issue1', 'native://i-issue1');
+            expect(result).toHaveLength(1);
+            expect(result[0]).toBe('native://i-issue1');
+        });
+        it('returns null for non-existent start node', () => {
+            const result = graph.shortestPath('native://non-existent', 'native://i-issue1');
+            expect(result).toBeNull();
+        });
+        it('returns null for non-existent end node', () => {
+            const result = graph.shortestPath('native://i-issue1', 'native://non-existent');
+            expect(result).toBeNull();
+        });
+        it('returns null when no path exists', () => {
+            // Create an isolated node
+            adapter.onNodeCreated({
+                id: 'i-isolated',
+                uuid: 'uuid-isolated',
+                type: 'issue',
+                title: 'Isolated',
+                created_at: '2025-01-01T00:00:00Z',
+                updated_at: '2025-01-01T00:00:00Z',
+            });
+            const result = graph.shortestPath('native://i-issue1', 'native://i-isolated');
+            expect(result).toBeNull();
+        });
+        it('filters by edge types', () => {
+            // issue1 -> issue2 is via 'blocks'
+            // There's no 'implements' path from issue1 to issue2
+            const result = graph.shortestPath('native://i-issue1', 'native://i-issue2', {
+                edgeTypes: ['implements'],
+            });
+            expect(result).toBeNull();
+        });
+    });
+    describe('hasPath()', () => {
+        beforeEach(setupGraph);
+        it('returns true when path exists', () => {
+            expect(graph.hasPath('native://i-issue1', 'native://i-issue3')).toBe(true);
+        });
+        it('returns false when no path exists', () => {
+            adapter.onNodeCreated({
+                id: 'i-isolated',
+                uuid: 'uuid-isolated',
+                type: 'issue',
+                title: 'Isolated',
+                created_at: '2025-01-01T00:00:00Z',
+                updated_at: '2025-01-01T00:00:00Z',
+            });
+            expect(graph.hasPath('native://i-issue1', 'native://i-isolated')).toBe(false);
+        });
+    });
+    describe('getNode()', () => {
+        beforeEach(setupGraph);
+        it('returns node attributes', () => {
+            const node = graph.getNode('native://i-issue1');
+            expect(node).not.toBeNull();
+            expect(node.title).toBe('Issue 1');
+            expect(node.type).toBe('issue');
+        });
+        it('returns null for non-existent node', () => {
+            expect(graph.getNode('native://non-existent')).toBeNull();
+        });
+    });
+    describe('hasNode()', () => {
+        beforeEach(setupGraph);
+        it('returns true for existing node', () => {
+            expect(graph.hasNode('native://i-issue1')).toBe(true);
+        });
+        it('returns false for non-existent node', () => {
+            expect(graph.hasNode('native://non-existent')).toBe(false);
+        });
+    });
+    describe('nodes()', () => {
+        beforeEach(setupGraph);
+        it('returns all node URIs', () => {
+            const nodes = graph.nodes();
+            expect(nodes).toHaveLength(5);
+            expect(nodes).toContain('native://s-spec1');
+            expect(nodes).toContain('native://i-issue1');
+            expect(nodes).toContain('native://i-issue2');
+            expect(nodes).toContain('native://i-issue3');
+            expect(nodes).toContain('native://i-issue4');
+        });
+    });
+    describe('stats()', () => {
+        beforeEach(setupGraph);
+        it('returns correct node and edge counts', () => {
+            const stats = graph.stats();
+            expect(stats.nodes).toBe(5);
+            expect(stats.edges).toBe(4);
+        });
+    });
+    describe('traverse()', () => {
+        beforeEach(setupGraph);
+        it('traverses single step pattern', async () => {
+            const results = [];
+            for await (const result of graph.traverse('native://i-issue1', {
+                steps: [{ type: 'blocks', direction: 'out' }],
+            })) {
+                results.push(result.uri);
+            }
+            expect(results).toContain('native://i-issue2');
+            expect(results).toContain('native://i-issue4');
+            expect(results).not.toContain('native://s-spec1'); // implements, not blocks
+        });
+        it('traverses multi-step pattern', async () => {
+            // First find specs, then issues that implement them
+            const results = [];
+            for await (const result of graph.traverse('native://i-issue1', {
+                steps: [
+                    { type: 'implements', direction: 'out' }, // i-issue1 -> s-spec1
+                    { type: 'implements', direction: 'in' }, // s-spec1 <- other issues
+                ],
+            })) {
+                results.push(result.uri);
+            }
+            // Should find s-spec1 first, then back to i-issue1
+            expect(results).toContain('native://s-spec1');
+            expect(results).toContain('native://i-issue1');
+        });
+        it('traverses with maxHops=Infinity for transitive closure', async () => {
+            const results = [];
+            for await (const result of graph.traverse('native://i-issue1', {
+                steps: [{ type: 'blocks', direction: 'out', maxHops: Infinity }],
+            })) {
+                results.push(result.uri);
+            }
+            // Should find all transitively blocked issues
+            expect(results).toContain('native://i-issue2');
+            expect(results).toContain('native://i-issue3');
+            expect(results).toContain('native://i-issue4');
+        });
+        it('respects limit option', async () => {
+            const results = [];
+            for await (const result of graph.traverse('native://i-issue1', {
+                steps: [{ type: 'blocks', direction: 'out', maxHops: Infinity }],
+                limit: 2,
+            })) {
+                results.push(result.uri);
+            }
+            expect(results).toHaveLength(2);
+        });
+        it('tracks depth correctly', async () => {
+            const depths = [];
+            for await (const result of graph.traverse('native://i-issue1', {
+                steps: [{ type: 'blocks', direction: 'out', maxHops: Infinity }],
+            })) {
+                depths.push(result.depth);
+            }
+            // issue2 and issue4 are depth 1, issue3 is depth 2
+            expect(depths).toContain(1);
+            expect(depths).toContain(2);
+        });
+        it('tracks path correctly', async () => {
+            let issue3Path = [];
+            for await (const result of graph.traverse('native://i-issue1', {
+                steps: [{ type: 'blocks', direction: 'out', maxHops: Infinity }],
+            })) {
+                if (result.uri === 'native://i-issue3') {
+                    issue3Path = result.path;
+                    break;
+                }
+            }
+            // Path should be: issue1 -> issue2 -> issue3
+            expect(issue3Path).toEqual([
+                'native://i-issue1',
+                'native://i-issue2',
+                'native://i-issue3',
+            ]);
+        });
+        it('handles multiple start URIs', async () => {
+            const results = [];
+            for await (const result of graph.traverse(['native://i-issue1', 'native://i-issue2'], { steps: [{ type: 'blocks', direction: 'out' }] })) {
+                results.push(result.uri);
+            }
+            // issue1 blocks issue2 and issue4
+            // issue2 blocks issue3
+            expect(results).toContain('native://i-issue2');
+            expect(results).toContain('native://i-issue3');
+            expect(results).toContain('native://i-issue4');
+        });
+        it('handles non-existent start URI', async () => {
+            const results = [];
+            for await (const result of graph.traverse('native://non-existent', {
+                steps: [{ type: 'blocks', direction: 'out' }],
+            })) {
+                results.push(result.uri);
+            }
+            expect(results).toHaveLength(0);
+        });
+        it('handles empty steps', async () => {
+            const results = [];
+            for await (const result of graph.traverse('native://i-issue1', {
+                steps: [],
+            })) {
+                results.push(result.uri);
+            }
+            expect(results).toHaveLength(0);
+        });
+        it('respects minHops option', async () => {
+            const results = [];
+            for await (const result of graph.traverse('native://i-issue1', {
+                steps: [{ type: 'blocks', direction: 'out', minHops: 2, maxHops: 2 }],
+            })) {
+                results.push(result.uri);
+            }
+            // Only issue3 is exactly 2 hops away via blocks
+            expect(results).toContain('native://i-issue3');
+            expect(results).not.toContain('native://i-issue2'); // 1 hop
+            expect(results).not.toContain('native://i-issue4'); // 1 hop
+        });
+        it('handles cycles without infinite loop', async () => {
+            // Add a cycle: issue3 -> issue1
+            adapter.onEdgeCreated({
+                id: 'e-cycle',
+                uuid: 'uuid-cycle',
+                from_id: 'i-issue3',
+                to_id: 'i-issue1',
+                type: 'blocks',
+                created_at: '2025-01-01T00:00:00Z',
+            });
+            const results = [];
+            for await (const result of graph.traverse('native://i-issue1', {
+                steps: [{ type: 'blocks', direction: 'out', maxHops: 10 }],
+            })) {
+                results.push(result.uri);
+            }
+            // Should not hang, and should not include duplicates
+            expect(results.length).toBeLessThanOrEqual(4);
+        });
+        it('includes stepIndex and edgeType in results', async () => {
+            for await (const result of graph.traverse('native://i-issue1', {
+                steps: [{ type: 'blocks', direction: 'out' }],
+            })) {
+                expect(result.stepIndex).toBe(0);
+                expect(result.edgeType).toBe('blocks');
+                break;
+            }
+        });
+        it('applies filter predicate to exclude nodes', async () => {
+            const results = [];
+            for await (const result of graph.traverse('native://i-issue1', {
+                steps: [{ type: 'blocks', direction: 'out', maxHops: Infinity }],
+                filter: (uri, attrs) => {
+                    // Only include open issues
+                    return attrs?.data?.status === 'open';
+                },
+            })) {
+                results.push(result.uri);
+            }
+            // Should include issue2 and issue4 (open) but not issue3 (closed)
+            expect(results).toContain('native://i-issue2');
+            expect(results).toContain('native://i-issue4');
+            expect(results).not.toContain('native://i-issue3');
+        });
+        it('filter continues traversal through filtered nodes', async () => {
+            // Add another edge: issue3 -> issue5
+            adapter.onNodeCreated({
+                id: 'i-issue5',
+                uuid: 'uuid-issue5',
+                type: 'issue',
+                title: 'Issue 5',
+                status: 'open',
+                created_at: '2025-01-01T00:00:00Z',
+                updated_at: '2025-01-01T00:00:00Z',
+            });
+            adapter.onEdgeCreated({
+                id: 'e-blocks4',
+                uuid: 'uuid-blocks4',
+                from_id: 'i-issue3',
+                to_id: 'i-issue5',
+                type: 'blocks',
+                created_at: '2025-01-01T00:00:00Z',
+            });
+            const results = [];
+            for await (const result of graph.traverse('native://i-issue1', {
+                steps: [{ type: 'blocks', direction: 'out', maxHops: Infinity }],
+                filter: (uri, attrs) => attrs?.data?.status === 'open',
+            })) {
+                results.push(result.uri);
+            }
+            // Should find issue5 even though it goes through filtered issue3
+            expect(results).toContain('native://i-issue5');
+            expect(results).not.toContain('native://i-issue3');
+        });
+    });
+    describe('parseSelector()', () => {
+        it('parses children selector (+uri)', () => {
+            const result = graph.parseSelector('+native://s-spec1');
+            expect(result.type).toBe('children');
+            expect(result.uri).toBe('native://s-spec1');
+            expect(result.original).toBe('+native://s-spec1');
+        });
+        it('parses descendants selector (uri+)', () => {
+            const result = graph.parseSelector('native://i-issue1+');
+            expect(result.type).toBe('descendants');
+            expect(result.uri).toBe('native://i-issue1');
+            expect(result.original).toBe('native://i-issue1+');
+        });
+        it('parses neighbors selector (@uri)', () => {
+            const result = graph.parseSelector('@native://i-issue2');
+            expect(result.type).toBe('neighbors');
+            expect(result.uri).toBe('native://i-issue2');
+            expect(result.original).toBe('@native://i-issue2');
+        });
+        it('parses literal URI', () => {
+            const result = graph.parseSelector('native://i-issue1');
+            expect(result.type).toBe('literal');
+            expect(result.uri).toBe('native://i-issue1');
+            expect(result.original).toBe('native://i-issue1');
+        });
+    });
+    describe('expandSelector()', () => {
+        beforeEach(setupGraph);
+        it('expands literal to the node if exists', () => {
+            const result = graph.expandSelector('native://i-issue1');
+            expect(result).toEqual(['native://i-issue1']);
+        });
+        it('expands literal to empty if not exists', () => {
+            const result = graph.expandSelector('native://non-existent');
+            expect(result).toEqual([]);
+        });
+        it('expands children selector to direct outgoing neighbors', () => {
+            const result = graph.expandSelector('+native://i-issue1');
+            expect(result).toHaveLength(3);
+            expect(result).toContain('native://s-spec1');
+            expect(result).toContain('native://i-issue2');
+            expect(result).toContain('native://i-issue4');
+        });
+        it('expands children selector with edge type filter', () => {
+            const result = graph.expandSelector('+native://i-issue1', { edgeType: 'blocks' });
+            expect(result).toHaveLength(2);
+            expect(result).toContain('native://i-issue2');
+            expect(result).toContain('native://i-issue4');
+            expect(result).not.toContain('native://s-spec1');
+        });
+        it('expands descendants selector transitively', () => {
+            const result = graph.expandSelector('native://i-issue1+');
+            // Should include all transitively reachable nodes
+            expect(result).toContain('native://s-spec1');
+            expect(result).toContain('native://i-issue2');
+            expect(result).toContain('native://i-issue3');
+            expect(result).toContain('native://i-issue4');
+        });
+        it('expands descendants with edge type filter', () => {
+            const result = graph.expandSelector('native://i-issue1+', { edgeType: 'blocks' });
+            expect(result).toHaveLength(3);
+            expect(result).toContain('native://i-issue2');
+            expect(result).toContain('native://i-issue3');
+            expect(result).toContain('native://i-issue4');
+            expect(result).not.toContain('native://s-spec1');
+        });
+        it('expands neighbors selector to all connected nodes', () => {
+            const result = graph.expandSelector('@native://i-issue2');
+            expect(result).toHaveLength(2);
+            expect(result).toContain('native://i-issue1'); // incoming
+            expect(result).toContain('native://i-issue3'); // outgoing
+        });
+        it('expands neighbors with edge type filter', () => {
+            const result = graph.expandSelector('@native://i-issue1', { edgeType: 'implements' });
+            expect(result).toHaveLength(1);
+            expect(result).toContain('native://s-spec1');
+        });
+        it('returns empty for non-existent node selectors', () => {
+            expect(graph.expandSelector('+native://non-existent')).toEqual([]);
+            expect(graph.expandSelector('native://non-existent+')).toEqual([]);
+            expect(graph.expandSelector('@native://non-existent')).toEqual([]);
+        });
+    });
+    describe('edgeTypes()', () => {
+        it('returns all registered edge types', () => {
+            const types = graph.edgeTypes();
+            expect(types.length).toBeGreaterThan(0);
+            // Should include built-in types
+            const typeNames = types.map((t) => t.name);
+            expect(typeNames).toContain('blocks');
+            expect(typeNames).toContain('implements');
+            expect(typeNames).toContain('parent-of');
+            expect(typeNames).toContain('related');
+        });
+        it('includes edge type metadata', () => {
+            const types = graph.edgeTypes();
+            const blocksType = types.find((t) => t.name === 'blocks');
+            expect(blocksType).toBeDefined();
+            expect(blocksType.description).toBeDefined();
+            expect(blocksType.inverseOf).toBe('blocked-by');
+            expect(blocksType.affectsReady).toBe(true);
+            expect(blocksType.direction).toBe('directed');
+        });
+    });
+    describe('capabilities()', () => {
+        it('returns graph capabilities', () => {
+            const caps = graph.capabilities();
+            expect(caps.edgeTypes).toBeDefined();
+            expect(caps.edgeTypes.length).toBeGreaterThan(0);
+        });
+        it('includes ready-affecting types', () => {
+            const caps = graph.capabilities();
+            expect(caps.readyAffectingTypes).toContain('blocks');
+            expect(caps.readyAffectingTypes).toContain('blocked-by');
+        });
+        it('includes provider-specific capabilities', () => {
+            const caps = graph.capabilities();
+            expect(caps.providers).toBeDefined();
+            expect(caps.providers.get('native')).toBeDefined();
+            const nativeTypes = caps.providers.get('native');
+            const nativeTypeNames = nativeTypes.map((t) => t.name);
+            expect(nativeTypeNames).toContain('blocks');
+            expect(nativeTypeNames).toContain('implements');
+        });
+    });
+});
+//# sourceMappingURL=FederatedGraph.test.js.map