@kaelio/ktx 0.5.0 → 0.7.0

package/dist/context/wiki/tools/wiki-read.tool.test.js

@@ -1,66 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createTouchedSlSources } from '../../../context/tools/touched-sl-sources.js';
-import { WikiReadTool } from './wiki-read.tool.js';
-describe('WikiReadTool', () => {
-    const baseContext = { sourceId: 's', messageId: 'm', userId: 'u' };
-    it('reads from the session wiki service when a worktree-scoped ingest session is present', async () => {
-        const rootWikiService = { readPageForUser: vi.fn().mockResolvedValue(null) };
-        const sessionWikiService = {
-            readPageForUser: vi.fn().mockResolvedValue({
-                pageKey: 'staged-page',
-                scope: 'GLOBAL',
-                frontmatter: { summary: 'Staged', tags: ['notion'], refs: ['related'] },
-                content: 'A page written earlier in the same ingest worktree.',
-            }),
-        };
-        const pagesRepository = { findPageByKey: vi.fn().mockResolvedValue({ id: 'page-1' }), incrementUsageCount: vi.fn() };
-        const tool = new WikiReadTool(rootWikiService, pagesRepository);
-        const session = {
-            connectionId: 'c',
-            isWorktreeScoped: true,
-            preHead: null,
-            touchedSlSources: createTouchedSlSources(),
-            actions: [],
-            semanticLayerService: {},
-            wikiService: sessionWikiService,
-            configService: {},
-            gitService: {},
-        };
-        const result = await tool.call({ key: 'staged-page' }, { ...baseContext, session });
-        expect(rootWikiService.readPageForUser).not.toHaveBeenCalled();
-        expect(sessionWikiService.readPageForUser).toHaveBeenCalledWith('u', 'staged-page');
-        expect(result.structured).toMatchObject({ found: true, blockKey: 'staged-page', scope: 'GLOBAL' });
-        expect(result.markdown).toContain('A page written earlier in the same ingest worktree.');
-    });
-    it('rejects slash-delimited page keys with a flat-key suggestion', async () => {
-        const rootWikiService = { readPageForUser: vi.fn().mockResolvedValue(null) };
-        const pagesRepository = { findPageByKey: vi.fn(), incrementUsageCount: vi.fn() };
-        const tool = new WikiReadTool(rootWikiService, pagesRepository);
-        const result = await tool.call({ key: 'orbit/company-overview' }, baseContext);
-        expect(result.structured).toEqual({
-            blockKey: 'orbit/company-overview',
-            content: '',
-            scope: '',
-            found: false,
-        });
-        expect(result.markdown).toContain('Invalid wiki key "orbit/company-overview". Wiki keys must be flat; use "orbit-company-overview".');
-        expect(rootWikiService.readPageForUser).not.toHaveBeenCalled();
-    });
-    it('does not append derived refs to the editable markdown body', async () => {
-        const rootWikiService = {
-            readPageForUser: vi.fn().mockResolvedValue({
-                pageKey: 'orbit-how-we-work',
-                scope: 'GLOBAL',
-                frontmatter: { summary: 'How we work', tags: ['policy'], refs: ['orbit-company-overview'] },
-                content: '## How We Work\n\nUse written-first operating norms.',
-            }),
-        };
-        const pagesRepository = { findPageByKey: vi.fn().mockResolvedValue(null), incrementUsageCount: vi.fn() };
-        const tool = new WikiReadTool(rootWikiService, pagesRepository);
-        const result = await tool.call({ key: 'orbit-how-we-work' }, baseContext);
-        expect(result.markdown).toBe('## How We Work\n\nUse written-first operating norms.');
-        expect(result.markdown).not.toContain('See also');
-        expect(result.markdown).not.toContain('[[orbit-company-overview]]');
-        expect(result.structured.refs).toEqual(['orbit-company-overview']);
-    });
-});

package/dist/context/wiki/tools/wiki-remove.tool.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/context/wiki/tools/wiki-remove.tool.test.js

@@ -1,95 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createTouchedSlSources } from '../../../context/tools/touched-sl-sources.js';
-import { WikiRemoveTool } from './wiki-remove.tool.js';
-describe('WikiRemoveTool', () => {
-    const baseContext = { sourceId: 's', messageId: 'm', userId: 'u' };
-    it('removes an existing page when no session is present', async () => {
-        const wikiService = {
-            deletePage: vi.fn().mockResolvedValue(undefined),
-            deleteFromIndex: vi.fn().mockResolvedValue(undefined),
-        };
-        const pagesRepository = {
-            findPageByKey: vi.fn().mockResolvedValue({ page_key: 'old' }),
-        };
-        const knowledgeRepository = { createEvent: vi.fn().mockResolvedValue(undefined) };
-        const tool = new WikiRemoveTool(wikiService, pagesRepository, knowledgeRepository);
-        const result = await tool.call({ key: 'old' }, baseContext);
-        expect(wikiService.deletePage).toHaveBeenCalledTimes(1);
-        expect(wikiService.deleteFromIndex).toHaveBeenCalledTimes(1);
-        expect(result.markdown).toMatch(/removed/i);
-    });
-    it('rejects slash-delimited page keys with a flat-key suggestion', async () => {
-        const wikiService = {
-            deletePage: vi.fn().mockResolvedValue(undefined),
-            deleteFromIndex: vi.fn().mockResolvedValue(undefined),
-        };
-        const pagesRepository = { findPageByKey: vi.fn().mockResolvedValue({ page_key: 'old' }) };
-        const knowledgeRepository = { createEvent: vi.fn().mockResolvedValue(undefined) };
-        const tool = new WikiRemoveTool(wikiService, pagesRepository, knowledgeRepository);
-        const result = await tool.call({ key: 'orbit/company-overview' }, baseContext);
-        expect(result.structured).toEqual({ success: false, key: 'orbit/company-overview' });
-        expect(result.markdown).toContain('Invalid wiki key "orbit/company-overview". Wiki keys must be flat; use "orbit-company-overview".');
-        expect(pagesRepository.findPageByKey).not.toHaveBeenCalled();
-        expect(wikiService.deletePage).not.toHaveBeenCalled();
-    });
-    it('skips deleteFromIndex when session is worktree-scoped', async () => {
-        const wikiService = {
-            readPage: vi.fn().mockResolvedValue({ pageKey: 'old', frontmatter: { summary: 'Old' }, content: 'body' }),
-            deletePage: vi.fn().mockResolvedValue(undefined),
-            deleteFromIndex: vi.fn().mockResolvedValue(undefined),
-        };
-        const pagesRepository = { findPageByKey: vi.fn().mockResolvedValue({ page_key: 'old' }) };
-        const knowledgeRepository = { createEvent: vi.fn().mockResolvedValue(undefined) };
-        const tool = new WikiRemoveTool(wikiService, pagesRepository, knowledgeRepository);
-        const session = {
-            connectionId: 'c',
-            isWorktreeScoped: true,
-            preHead: null,
-            touchedSlSources: createTouchedSlSources(),
-            actions: [],
-            semanticLayerService: {},
-            wikiService: wikiService,
-            configService: {},
-            gitService: {},
-        };
-        await tool.call({ key: 'old' }, { ...baseContext, session });
-        expect(wikiService.deletePage).toHaveBeenCalledTimes(1);
-        expect(wikiService.deleteFromIndex).not.toHaveBeenCalled();
-        expect(session.actions).toContainEqual(expect.objectContaining({ target: 'wiki', type: 'removed', key: 'old' }));
-    });
-    it('finds pages through the session wiki service even when the shared index has not seen the worktree write', async () => {
-        const wikiService = {
-            readPage: vi.fn().mockResolvedValue({ pageKey: 'staged', frontmatter: { summary: 'Staged' }, content: 'body' }),
-            deletePage: vi.fn().mockResolvedValue(undefined),
-            deleteFromIndex: vi.fn().mockResolvedValue(undefined),
-        };
-        const pagesRepository = { findPageByKey: vi.fn().mockResolvedValue(null) };
-        const knowledgeRepository = { createEvent: vi.fn().mockResolvedValue(undefined) };
-        const tool = new WikiRemoveTool(wikiService, pagesRepository, knowledgeRepository);
-        const session = {
-            connectionId: 'c',
-            isWorktreeScoped: true,
-            preHead: null,
-            touchedSlSources: createTouchedSlSources(),
-            actions: [],
-            semanticLayerService: {},
-            wikiService: wikiService,
-            configService: {},
-            gitService: {},
-        };
-        const result = await tool.call({ key: 'staged' }, { ...baseContext, session });
-        expect(pagesRepository.findPageByKey).not.toHaveBeenCalled();
-        expect(wikiService.readPage).toHaveBeenCalledWith('GLOBAL', null, 'staged');
-        expect(wikiService.deletePage).toHaveBeenCalledTimes(1);
-        expect(result.structured).toEqual({ success: true, key: 'staged' });
-    });
-    it('returns a friendly message when the page does not exist', async () => {
-        const wikiService = { deletePage: vi.fn(), deleteFromIndex: vi.fn() };
-        const pagesRepository = { findPageByKey: vi.fn().mockResolvedValue(null) };
-        const knowledgeRepository = { createEvent: vi.fn() };
-        const tool = new WikiRemoveTool(wikiService, pagesRepository, knowledgeRepository);
-        const result = await tool.call({ key: 'missing' }, baseContext);
-        expect(result.structured.success).toBe(false);
-        expect(result.markdown).toMatch(/not found/i);
-    });
-});

package/dist/context/wiki/tools/wiki-search.tool.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/context/wiki/tools/wiki-search.tool.test.js

@@ -1,35 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { WikiSearchTool } from './wiki-search.tool.js';
-describe('WikiSearchTool', () => {
-    it('searches through the injected wiki adapter port', async () => {
-        const search = vi.fn(async () => ({
-            results: [
-                {
-                    key: 'metrics-revenue',
-                    path: 'wiki/global/metrics-revenue.md',
-                    scope: 'GLOBAL',
-                    summary: 'Revenue metric definition',
-                    score: 0.02459016393442623,
-                    matchReasons: ['lexical', 'token'],
-                },
-            ],
-            totalFound: 1,
-        }));
-        const tool = new WikiSearchTool({ search });
-        const result = await tool.call({ query: 'paid order', limit: 5 }, { sourceId: 'test', messageId: 'message-1', userId: 'agent' });
-        expect(search).toHaveBeenCalledWith({ userId: 'agent', query: 'paid order', limit: 5 });
-        expect(result.structured).toEqual({
-            results: [
-                {
-                    blockKey: 'metrics-revenue',
-                    path: 'wiki/global/metrics-revenue.md',
-                    summary: 'Revenue metric definition',
-                    score: 0.02459016393442623,
-                    matchReasons: ['lexical', 'token'],
-                },
-            ],
-            totalFound: 1,
-        });
-        expect(result.markdown).toContain('**metrics-revenue**');
-    });
-});

package/dist/context/wiki/tools/wiki-write.tool.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/context/wiki/tools/wiki-write.tool.test.js

@@ -1,264 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { createTouchedSlSources } from '../../../context/tools/touched-sl-sources.js';
-import { WikiWriteTool } from './wiki-write.tool.js';
-function makeTool(overrides = {}) {
-    const wikiService = {
-        readPage: vi.fn().mockResolvedValue(null),
-        listPageKeys: vi.fn().mockResolvedValue([]),
-        writePage: vi.fn().mockResolvedValue(undefined),
-        syncSinglePage: vi.fn().mockResolvedValue(undefined),
-        ...overrides.wikiService,
-    };
-    const pagesRepository = {
-        findPageByKey: vi.fn().mockResolvedValue(null),
-        getUserPageCount: vi.fn().mockResolvedValue(0),
-        ...overrides.pagesRepository,
-    };
-    const knowledgeRepository = {
-        createEvent: vi.fn().mockResolvedValue(undefined),
-        ...overrides.knowledgeRepository,
-    };
-    const tool = new WikiWriteTool(wikiService, pagesRepository, knowledgeRepository);
-    return { tool, wikiService, pagesRepository, knowledgeRepository };
-}
-describe('WikiWriteTool', () => {
-    const baseContext = { sourceId: 's', messageId: 'm', userId: 'u' };
-    it('creates a new page and indexes it when no session is present', async () => {
-        const { tool, wikiService } = makeTool();
-        const result = await tool.call({ key: 'leads-source', summary: 'Lead source definitions', content: '# Leads' }, baseContext);
-        expect(wikiService.writePage).toHaveBeenCalledTimes(1);
-        expect(wikiService.syncSinglePage).toHaveBeenCalledTimes(1);
-        expect(result.markdown).toMatch(/created/i);
-    });
-    it('rejects slash-delimited page keys with a flat-key suggestion', async () => {
-        const { tool, wikiService } = makeTool();
-        const result = await tool.call({ key: 'orbit/company-overview', summary: 'Company overview', content: '# Orbit' }, baseContext);
-        expect(result.structured).toEqual({ success: false, key: 'orbit/company-overview' });
-        expect(result.markdown).toContain('Invalid wiki key "orbit/company-overview". Wiki keys must be flat; use "orbit-company-overview".');
-        expect(wikiService.readPage).not.toHaveBeenCalled();
-        expect(wikiService.writePage).not.toHaveBeenCalled();
-    });
-    it('normalizes accidentally escaped markdown newlines before writing', async () => {
-        const { tool, wikiService } = makeTool();
-        await tool.call({
-            key: 'large-contract-requesters',
-            summary: 'Cross-schema Metabase query',
-            content: '# Large Contract Requesters\\n\\n**Source card:** Metabase #110\\n\\n## SQL\\n\\n```sql\\nselect * from orbit_analytics.mart_account_segments\\n```\\n',
-        }, baseContext);
-        expect(wikiService.writePage.mock.calls[0][4]).toBe('# Large Contract Requesters\n\n**Source card:** Metabase #110\n\n## SQL\n\n```sql\nselect * from orbit_analytics.mart_account_segments\n```\n');
-        expect(wikiService.syncSinglePage.mock.calls[0][4]).toBe('# Large Contract Requesters\n\n**Source card:** Metabase #110\n\n## SQL\n\n```sql\nselect * from orbit_analytics.mart_account_segments\n```\n');
-    });
-    it('preserves intentional escaped newline examples in inline code', async () => {
-        const { tool, wikiService } = makeTool();
-        await tool.call({
-            key: 'newline-token',
-            summary: 'Escaped newline token',
-            content: 'Use `\\n\\n` when documenting the literal separator.',
-        }, baseContext);
-        expect(wikiService.writePage.mock.calls[0][4]).toBe('Use `\\n\\n` when documenting the literal separator.');
-    });
-    it('skips syncSinglePage when session is worktree-scoped', async () => {
-        const { tool, wikiService } = makeTool();
-        const session = {
-            connectionId: 'conn-1',
-            isWorktreeScoped: true,
-            preHead: null,
-            touchedSlSources: createTouchedSlSources(),
-            actions: [],
-            semanticLayerService: {},
-            wikiService: wikiService,
-            configService: {},
-            gitService: {},
-        };
-        const context = { ...baseContext, session };
-        await tool.call({ key: 'k', summary: 's', content: '# x' }, context);
-        expect(wikiService.writePage).toHaveBeenCalledTimes(1);
-        expect(wikiService.syncSinglePage).not.toHaveBeenCalled();
-        expect(session.actions).toContainEqual(expect.objectContaining({ target: 'wiki', type: 'created', key: 'k' }));
-    });
-    it('requires either content or replacements', async () => {
-        const { tool } = makeTool();
-        const result = await tool.call({ key: 'k', summary: 's' }, baseContext);
-        expect(result.structured.success).toBe(false);
-        expect(result.markdown).toMatch(/content.*or.*replacements/i);
-    });
-    it('updates frontmatter only on an existing page while preserving content', async () => {
-        const { tool, wikiService } = makeTool({
-            wikiService: {
-                readPage: vi.fn().mockResolvedValue({
-                    pageKey: 'orbit-customers',
-                    frontmatter: {
-                        summary: 'Customer source details',
-                        usage_mode: 'auto',
-                        sort_order: 0,
-                        tags: ['notion'],
-                        refs: ['notion:old'],
-                        sl_refs: ['postgres-warehouse/orbit_analytics.customer'],
-                    },
-                    content: '# Orbit Customers\n\nSource: Notion - Orbit Customers Source.',
-                }),
-            },
-        });
-        const result = await tool.call({
-            key: 'orbit-customers',
-            summary: 'Customer source details mapped to the warehouse customer view',
-            sl_refs: ['postgres-warehouse/orbit_analytics.customer', 'dbt-main/customer'],
-        }, baseContext);
-        expect(result.structured).toMatchObject({ success: true, key: 'orbit-customers', action: 'updated' });
-        expect(wikiService.writePage).toHaveBeenCalledWith('USER', 'u', 'orbit-customers', expect.objectContaining({
-            summary: 'Customer source details mapped to the warehouse customer view',
-            tags: ['notion'],
-            refs: ['notion:old'],
-            sl_refs: ['postgres-warehouse/orbit_analytics.customer', 'dbt-main/customer'],
-        }), '# Orbit Customers\n\nSource: Notion - Orbit Customers Source.', expect.any(String), expect.any(String));
-    });
-    it('writes historic-SQL frontmatter fields', async () => {
-        const { tool, wikiService } = makeTool();
-        await tool.call({
-            key: 'monthly-paid-orders',
-            summary: 'Monthly paid orders',
-            tags: ['historic-sql', 'query-pattern'],
-            sl_refs: ['analytics.orders'],
-            source: 'historic-sql',
-            intent: 'Monthly paid order count',
-            tables: ['analytics.orders'],
-            representative_sql: "SELECT count(*) FROM analytics.orders WHERE status = 'paid'",
-            usage: {
-                executions: 42,
-                distinct_users: 3,
-                first_seen: '2026-02-01',
-                last_seen: '2026-05-04',
-                p50_runtime_ms: 100,
-                p95_runtime_ms: 200,
-                error_rate: 0,
-                rows_produced: 42,
-            },
-            fingerprints: ['fp_paid_orders'],
-            content: '## Monthly paid order count',
-        }, baseContext);
-        expect(wikiService.writePage.mock.calls[0][3]).toEqual({
-            summary: 'Monthly paid orders',
-            usage_mode: 'auto',
-            sort_order: 0,
-            tags: ['historic-sql', 'query-pattern'],
-            refs: undefined,
-            sl_refs: ['analytics.orders'],
-            source: 'historic-sql',
-            intent: 'Monthly paid order count',
-            tables: ['analytics.orders'],
-            representative_sql: "SELECT count(*) FROM analytics.orders WHERE status = 'paid'",
-            usage: {
-                executions: 42,
-                distinct_users: 3,
-                first_seen: '2026-02-01',
-                last_seen: '2026-05-04',
-                p50_runtime_ms: 100,
-                p95_runtime_ms: 200,
-                error_rate: 0,
-                rows_produced: 42,
-            },
-            fingerprints: ['fp_paid_orders'],
-        });
-    });
-    it('preserves historic-SQL frontmatter fields when update omits them', async () => {
-        const existingFrontmatter = {
-            summary: 'Monthly paid orders',
-            usage_mode: 'auto',
-            sort_order: 0,
-            tags: ['historic-sql'],
-            sl_refs: ['analytics.orders'],
-            source: 'historic-sql',
-            intent: 'Monthly paid order count',
-            tables: ['analytics.orders'],
-            representative_sql: "SELECT count(*) FROM analytics.orders WHERE status = 'paid'",
-            usage: {
-                executions: 42,
-                distinct_users: 3,
-                first_seen: '2026-02-01',
-                last_seen: '2026-05-04',
-                p50_runtime_ms: 100,
-                p95_runtime_ms: 200,
-                error_rate: 0,
-                rows_produced: 42,
-            },
-            fingerprints: ['fp_paid_orders'],
-        };
-        const { tool, wikiService } = makeTool({
-            wikiService: {
-                readPage: vi.fn().mockResolvedValue({
-                    pageKey: 'monthly-paid-orders',
-                    frontmatter: existingFrontmatter,
-                    content: 'old body',
-                }),
-            },
-        });
-        await tool.call({
-            key: 'monthly-paid-orders',
-            summary: 'Monthly paid orders updated',
-            content: '## Monthly paid order count updated',
-        }, baseContext);
-        expect(wikiService.writePage.mock.calls[0][3]).toEqual({
-            ...existingFrontmatter,
-            summary: 'Monthly paid orders updated',
-        });
-    });
-    it('rejects frontmatter refs that target missing wiki pages', async () => {
-        const { tool, wikiService } = makeTool({
-            wikiService: {
-                listPageKeys: vi.fn().mockResolvedValue(['orbit-company-overview']),
-            },
-        });
-        const result = await tool.call({
-            key: 'orbit-how-we-work',
-            summary: 'Operating norms',
-            content: '## How We Work',
-            refs: ['orbit-company-overview', 'orbit-team-lanes-detail'],
-        }, baseContext);
-        expect(result.structured.success).toBe(false);
-        expect(result.markdown).toMatch(/orbit-team-lanes-detail/);
-        expect(wikiService.writePage).not.toHaveBeenCalled();
-    });
-    it('rejects inline wiki links that target missing wiki pages', async () => {
-        const { tool, wikiService } = makeTool({
-            wikiService: {
-                listPageKeys: vi.fn().mockResolvedValue(['orbit-company-overview']),
-            },
-        });
-        const result = await tool.call({
-            key: 'orbit-how-we-work',
-            summary: 'Operating norms',
-            content: 'See [[orbit-company-overview]] and [[orbit-team-lanes-detail]].',
-        }, baseContext);
-        expect(result.structured.success).toBe(false);
-        expect(result.markdown).toMatch(/orbit-team-lanes-detail/);
-        expect(wikiService.writePage).not.toHaveBeenCalled();
-    });
-    it('accepts forward refs during ingest sessions for post-pass validation', async () => {
-        const { tool, wikiService } = makeTool({
-            wikiService: {
-                listPageKeys: vi.fn().mockResolvedValue(['orbit-company-overview']),
-            },
-        });
-        const session = {
-            connectionId: 'conn-1',
-            isWorktreeScoped: true,
-            preHead: null,
-            touchedSlSources: createTouchedSlSources(),
-            actions: [],
-            semanticLayerService: {},
-            wikiService: wikiService,
-            configService: {},
-            gitService: {},
-            ingest: { runId: 'run-1', jobId: 'job-1', syncId: 'sync-1', sourceKey: 'notion' },
-        };
-        const result = await tool.call({
-            key: 'orbit-how-we-work',
-            summary: 'Operating norms',
-            content: 'See [[orbit-team-lanes-detail]].',
-            refs: ['orbit-company-overview', 'orbit-team-lanes-detail'],
-        }, { ...baseContext, session });
-        expect(result.structured).toMatchObject({ success: true, key: 'orbit-how-we-work', action: 'created' });
-        expect(wikiService.writePage).toHaveBeenCalledTimes(1);
-        expect(session.actions).toContainEqual(expect.objectContaining({ target: 'wiki', type: 'created', key: 'orbit-how-we-work' }));
-    });
-});

package/dist/context/wiki/wiki-ref-validation.test.d.ts

@@ -1 +0,0 @@
-export {};

package/dist/context/wiki/wiki-ref-validation.test.js

@@ -1,64 +0,0 @@
-import { describe, expect, it, vi } from 'vitest';
-import { findDanglingWikiRefsForActions } from './wiki-ref-validation.js';
-function makeWikiService(pages) {
-    return {
-        listPageKeys: vi.fn().mockResolvedValue(Object.keys(pages)),
-        readPage: vi.fn().mockImplementation((_scope, _scopeId, pageKey) => {
-            const page = pages[pageKey];
-            if (!page) {
-                return Promise.resolve(null);
-            }
-            return Promise.resolve({
-                pageKey,
-                frontmatter: { summary: pageKey, usage_mode: 'auto', refs: page.refs },
-                content: page.content ?? '',
-            });
-        }),
-    };
-}
-describe('wiki ref validation', () => {
-    it('allows circular refs once both touched pages exist', async () => {
-        const wikiService = makeWikiService({
-            'page-a': { refs: ['page-b'], content: 'See [[page-b]].' },
-            'page-b': { refs: ['page-a'], content: 'See [[page-a]].' },
-        });
-        const dangling = await findDanglingWikiRefsForActions({
-            wikiService: wikiService,
-            scope: 'GLOBAL',
-            scopeId: null,
-            actions: [
-                { target: 'wiki', type: 'created', key: 'page-a', detail: 'Page A' },
-                { target: 'wiki', type: 'created', key: 'page-b', detail: 'Page B' },
-            ],
-        });
-        expect(dangling).toEqual([]);
-    });
-    it('treats removed pages as unavailable ref targets', async () => {
-        const wikiService = makeWikiService({
-            'page-a': { refs: ['page-b'], content: 'See [[page-b]].' },
-        });
-        const dangling = await findDanglingWikiRefsForActions({
-            wikiService: wikiService,
-            scope: 'GLOBAL',
-            scopeId: null,
-            actions: [
-                { target: 'wiki', type: 'updated', key: 'page-a', detail: 'Page A' },
-                { target: 'wiki', type: 'removed', key: 'page-b', detail: 'Page B' },
-            ],
-        });
-        expect(dangling).toEqual(['page-a -> page-b']);
-    });
-    it('does not validate existing dangling refs on untouched pages', async () => {
-        const wikiService = makeWikiService({
-            'page-a': { refs: [], content: '' },
-            'old-page': { refs: ['missing-page'], content: 'See [[missing-page]].' },
-        });
-        const dangling = await findDanglingWikiRefsForActions({
-            wikiService: wikiService,
-            scope: 'GLOBAL',
-            scopeId: null,
-            actions: [{ target: 'wiki', type: 'updated', key: 'page-a', detail: 'Page A' }],
-        });
-        expect(dangling).toEqual([]);
-    });
-});

package/dist/context-build-view.test.d.ts

@@ -1 +0,0 @@
-export {};