@kaelio/ktx 0.4.1 → 0.6.0

package/node_modules/@ktx/context/dist/ingest/context-evidence/context-evidence-index.service.js

@@ -1,303 +0,0 @@
-import { createHash } from 'node:crypto';
-import { readdir, readFile } from 'node:fs/promises';
-import { basename, dirname, join, relative } from 'node:path';
-import { noopLogger } from '../../core/index.js';
-export class ContextEvidenceIndexService {
-    store;
-    embeddings;
-    logger;
-    constructor(deps) {
-        this.store = deps.store;
-        this.embeddings = deps.embeddings;
-        this.logger = deps.logger ?? noopLogger;
-    }
-    async indexStagedDir(args) {
-        const warnings = [];
-        const documents = await this.collectDocuments(args.stagedDir, warnings);
-        const indexablePaths = this.indexableDocumentPaths(args.diffSet);
-        let documentsIndexed = 0;
-        let chunksIndexed = 0;
-        let embeddingFailures = 0;
-        for (const staged of documents) {
-            if (!args.forceRebuild && !this.shouldIndexDocument(args.stagedDir, staged, indexablePaths)) {
-                continue;
-            }
-            const externalId = staged.metadata.id;
-            const title = staged.metadata.title;
-            const path = staged.metadata.path ?? title;
-            if (!externalId || !title || !path) {
-                warnings.push(`Skipped ${staged.metadataPath}: metadata requires id, title, and path`);
-                continue;
-            }
-            const rawPath = this.toRawPath(args.stagedDir, staged.markdownPath);
-            const contentHash = args.currentHashes.get(rawPath) ?? this.sha256(staged.markdown);
-            const document = await this.store.upsertDocument({
-                runId: args.runId,
-                connectionId: args.connectionId,
-                sourceKey: args.sourceKey,
-                externalId,
-                externalParentId: staged.metadata.parentId ?? null,
-                databaseId: staged.metadata.databaseId ?? null,
-                dataSourceId: staged.metadata.dataSourceId ?? null,
-                title,
-                path,
-                url: staged.metadata.url ?? null,
-                objectType: staged.metadata.objectType ?? 'page',
-                lastEditedAt: staged.metadata.lastEditedAt ? new Date(staged.metadata.lastEditedAt) : null,
-                lastEditedBy: staged.metadata.lastEditedBy ?? null,
-                rawPath,
-                syncId: args.syncId,
-                contentHash,
-                publishState: 'pending',
-                metadata: {
-                    metadataPath: this.toRawPath(args.stagedDir, staged.metadataPath),
-                    ...(staged.linksPath && staged.links
-                        ? { linksPath: this.toRawPath(args.stagedDir, staged.linksPath), links: staged.links }
-                        : {}),
-                    properties: staged.metadata.properties ?? {},
-                },
-            });
-            const chunks = this.buildChunks(staged.markdown, title);
-            const searchTexts = chunks.map((chunk) => this.buildSearchText(staged, chunk));
-            const embeddings = await this.computeEmbeddings(searchTexts);
-            if (embeddings.failed) {
-                embeddingFailures += 1;
-            }
-            const headingPathOccurrences = new Map();
-            const replaceChunks = chunks.map((chunk, ordinal) => {
-                const headingLeaf = chunk.headingPath[chunk.headingPath.length - 1] ?? title;
-                const headingSlug = this.slug(headingLeaf);
-                const normalizedHeadingPath = this.normalizeHeadingPath(chunk.headingPath);
-                const occurrence = (headingPathOccurrences.get(normalizedHeadingPath) ?? 0) + 1;
-                headingPathOccurrences.set(normalizedHeadingPath, occurrence);
-                return {
-                    chunkKey: `${this.headingLevelKey(chunk.headingPath)}:${headingSlug}:${String(ordinal).padStart(4, '0')}`,
-                    headingPath: chunk.headingPath,
-                    ordinal,
-                    content: chunk.content,
-                    searchText: searchTexts[ordinal],
-                    embedding: embeddings.values[ordinal] ?? null,
-                    tokenCount: this.estimateTokens(chunk.content),
-                    citation: {
-                        source: args.sourceKey,
-                        pageId: externalId,
-                        title,
-                        path,
-                        url: staged.metadata.url ?? null,
-                        lastEditedAt: staged.metadata.lastEditedAt ?? null,
-                        syncId: args.syncId,
-                        rawPath,
-                    },
-                    stableCitationKey: this.buildStableCitationKey(args.sourceKey, externalId, headingSlug, normalizedHeadingPath, occurrence),
-                    syncId: args.syncId,
-                    contentHash: this.sha256(chunk.content),
-                };
-            });
-            await this.store.replaceChunks(document.id, replaceChunks);
-            documentsIndexed += 1;
-            chunksIndexed += replaceChunks.length;
-        }
-        const deletedMarkdownPaths = this.deletedMarkdownPaths(args.diffSet);
-        const documentsDeleted = await this.store.countPublishedDocumentsByRawPaths(args.connectionId, args.sourceKey, deletedMarkdownPaths);
-        return { documentsIndexed, chunksIndexed, documentsDeleted, embeddingFailures, warnings };
-    }
-    async publishSync(args) {
-        return this.store.publishSync(args.connectionId, args.sourceKey, args.syncId, this.deletedMarkdownPaths(args.diffSet));
-    }
-    async collectDocuments(stagedDir, warnings) {
-        const metadataPaths = await this.findFiles(stagedDir, 'metadata.json');
-        const documents = [];
-        for (const metadataPath of metadataPaths) {
-            const markdownPath = join(dirname(metadataPath), 'page.md');
-            let markdown;
-            try {
-                markdown = await readFile(markdownPath, 'utf-8');
-            }
-            catch {
-                continue;
-            }
-            try {
-                const metadata = JSON.parse(await readFile(metadataPath, 'utf-8'));
-                const linksPath = join(dirname(metadataPath), 'links.json');
-                let links;
-                try {
-                    const parsedLinks = JSON.parse(await readFile(linksPath, 'utf-8'));
-                    if (parsedLinks && typeof parsedLinks === 'object' && !Array.isArray(parsedLinks)) {
-                        links = parsedLinks;
-                    }
-                }
-                catch {
-                    // links.json is optional.
-                }
-                documents.push({
-                    metadataPath,
-                    markdownPath,
-                    linksPath: links ? linksPath : undefined,
-                    metadata,
-                    links,
-                    markdown,
-                });
-            }
-            catch (error) {
-                warnings.push(`Skipped ${relative(stagedDir, metadataPath)}: ${error instanceof Error ? error.message : String(error)}`);
-            }
-        }
-        return documents;
-    }
-    async findFiles(root, fileName) {
-        const entries = await readdir(root, { withFileTypes: true, recursive: true });
-        return entries
-            .filter((entry) => entry.isFile() && entry.name === fileName)
-            .map((entry) => join(entry.parentPath, entry.name))
-            .sort();
-    }
-    indexableDocumentPaths(diffSet) {
-        return new Set([...diffSet.added, ...diffSet.modified]);
-    }
-    shouldIndexDocument(stagedDir, staged, indexablePaths) {
-        return (indexablePaths.has(this.toRawPath(stagedDir, staged.markdownPath)) ||
-            indexablePaths.has(this.toRawPath(stagedDir, staged.metadataPath)) ||
-            (staged.linksPath ? indexablePaths.has(this.toRawPath(stagedDir, staged.linksPath)) : false));
-    }
-    deletedMarkdownPaths(diffSet) {
-        return diffSet.deleted.filter((path) => basename(path) === 'page.md');
-    }
-    buildChunks(markdown, title) {
-        const lines = markdown.split(/\r?\n/);
-        const chunks = [];
-        let headingPath = [title];
-        let currentLines = [];
-        const flush = () => {
-            const content = currentLines.join('\n').trim();
-            if (content) {
-                chunks.push({ headingPath: [...headingPath], content });
-            }
-            currentLines = [];
-        };
-        for (const line of lines) {
-            const match = /^(#{1,6})\s+(.+)$/.exec(line);
-            if (match) {
-                flush();
-                const level = match[1].length;
-                const heading = match[2].trim();
-                headingPath = level === 1 ? [heading] : [...headingPath.slice(0, level - 1), heading];
-                continue;
-            }
-            currentLines.push(line);
-        }
-        flush();
-        if (chunks.length === 0) {
-            const content = markdown.trim();
-            return content ? [{ headingPath: [title], content }] : [];
-        }
-        return this.splitLargeChunks(chunks);
-    }
-    splitLargeChunks(chunks) {
-        const maxChars = 4800;
-        const out = [];
-        const pushBounded = (chunk, content) => {
-            for (let start = 0; start < content.length; start += maxChars) {
-                const part = content.slice(start, start + maxChars).trim();
-                if (part) {
-                    out.push({ ...chunk, content: part });
-                }
-            }
-        };
-        for (const chunk of chunks) {
-            if (chunk.content.length <= maxChars) {
-                out.push(chunk);
-                continue;
-            }
-            const paragraphs = chunk.content.split(/\n{2,}/);
-            let current = '';
-            for (const paragraph of paragraphs) {
-                if (paragraph.length > maxChars) {
-                    if (current) {
-                        out.push({ ...chunk, content: current });
-                        current = '';
-                    }
-                    pushBounded(chunk, paragraph);
-                    continue;
-                }
-                const next = current ? `${current}\n\n${paragraph}` : paragraph;
-                if (next.length > maxChars && current) {
-                    out.push({ ...chunk, content: current });
-                    current = paragraph;
-                }
-                else {
-                    current = next;
-                }
-            }
-            if (current) {
-                out.push({ ...chunk, content: current });
-            }
-        }
-        return out;
-    }
-    buildSearchText(staged, chunk) {
-        const properties = Object.entries(staged.metadata.properties ?? {})
-            .map(([key, value]) => `${key}: ${String(value)}`)
-            .join('\n');
-        return [staged.metadata.title, staged.metadata.path, chunk.headingPath.join(' / '), properties, chunk.content]
-            .filter(Boolean)
-            .join('\n');
-    }
-    async computeEmbeddings(texts) {
-        if (texts.length === 0) {
-            return { values: [], failed: false };
-        }
-        const configuredMaxBatchSize = this.embeddings.maxBatchSize;
-        const maxBatchSize = typeof configuredMaxBatchSize === 'number' &&
-            Number.isInteger(configuredMaxBatchSize) &&
-            configuredMaxBatchSize > 0
-            ? configuredMaxBatchSize
-            : 100;
-        const values = [];
-        let failed = false;
-        for (let offset = 0; offset < texts.length; offset += maxBatchSize) {
-            const batch = texts.slice(offset, offset + maxBatchSize);
-            try {
-                const batchEmbeddings = await this.embeddings.computeEmbeddingsBulk(batch);
-                if (batchEmbeddings.length !== batch.length) {
-                    throw new Error(`expected ${batch.length} embeddings, received ${batchEmbeddings.length}`);
-                }
-                values.push(...batchEmbeddings);
-            }
-            catch (error) {
-                failed = true;
-                this.logger.warn(`Context evidence embeddings failed: ${error instanceof Error ? error.message : String(error)}`);
-                values.push(...batch.map(() => null));
-            }
-        }
-        return { values, failed };
-    }
-    toRawPath(stagedDir, fullPath) {
-        return relative(stagedDir, fullPath).split('\\').join('/');
-    }
-    headingLevelKey(headingPath) {
-        return `h${Math.min(Math.max(headingPath.length, 1), 6)}`;
-    }
-    slug(value) {
-        const slug = value
-            .toLowerCase()
-            .replace(/[^a-z0-9]+/g, '-')
-            .replace(/^-+|-+$/g, '');
-        return slug || 'section';
-    }
-    normalizeHeadingPath(headingPath) {
-        return headingPath
-            .map((heading) => heading.trim().toLowerCase().replace(/\s+/g, ' '))
-            .filter(Boolean)
-            .join('/');
-    }
-    buildStableCitationKey(sourceKey, externalId, headingSlug, normalizedHeadingPath, occurrence) {
-        const digest = this.sha256([sourceKey, externalId, normalizedHeadingPath, String(occurrence)].join('\0')).slice(0, 16);
-        return `${sourceKey}:${externalId}:${headingSlug}:${digest}`;
-    }
-    estimateTokens(value) {
-        return Math.ceil(value.split(/\s+/).filter(Boolean).length * 1.3);
-    }
-    sha256(value) {
-        return createHash('sha256').update(value).digest('hex');
-    }
-}

package/node_modules/@ktx/context/dist/ingest/context-evidence/context-evidence-index.service.test.d.ts

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

package/node_modules/@ktx/context/dist/ingest/context-evidence/context-evidence-index.service.test.js

@@ -1,374 +0,0 @@
-import { mkdir, mkdtemp, rm, writeFile } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { afterEach, beforeEach, describe, expect, it, vi } from 'vitest';
-import { ContextEvidenceIndexService } from './context-evidence-index.service.js';
-const vector384 = (first) => [first, ...Array.from({ length: 383 }, () => 0)];
-describe('ContextEvidenceIndexService', () => {
-    let tmp;
-    let repository;
-    let embeddings;
-    let service;
-    beforeEach(async () => {
-        tmp = await mkdtemp(join(tmpdir(), 'context-evidence-'));
-        repository = {
-            upsertDocument: vi.fn().mockResolvedValue({ id: 'doc-1' }),
-            replaceChunks: vi.fn().mockResolvedValue(undefined),
-            countPublishedDocumentsByRawPaths: vi.fn().mockResolvedValue(1),
-            publishSync: vi.fn().mockResolvedValue({ documentsPublished: 1, documentsDeleted: 0 }),
-        };
-        embeddings = {
-            maxBatchSize: 100,
-            computeEmbeddingsBulk: vi
-                .fn()
-                .mockImplementation((texts) => texts.map((_text, index) => vector384((index + 1) / 10))),
-        };
-        service = new ContextEvidenceIndexService({
-            store: repository,
-            embeddings: embeddings,
-            logger: { warn: vi.fn() },
-        });
-    });
-    afterEach(async () => {
-        await rm(tmp, { recursive: true, force: true });
-    });
-    it('indexes Notion-style page markdown into documents and heading chunks', async () => {
-        await writeFile(join(tmp, 'manifest.json'), JSON.stringify({ source: 'notion', apiVersion: '2026-03-11' }));
-        await mkdir(join(tmp, 'pages', 'page-1'), { recursive: true });
-        await writeFile(join(tmp, 'pages', 'page-1', 'metadata.json'), JSON.stringify({
-            objectType: 'page',
-            id: 'page-1',
-            title: 'Revenue Recognition',
-            path: 'Company Handbook / Finance / Revenue Recognition',
-            url: 'https://notion.example/page-1',
-            parentId: 'page-parent',
-            lastEditedAt: '2026-04-12T10:15:00.000Z',
-            lastEditedBy: 'Jane Doe',
-            properties: { Status: 'Approved' },
-        }));
-        await writeFile(join(tmp, 'pages', 'page-1', 'page.md'), [
-            '# Revenue Recognition',
-            '',
-            '## Policy',
-            '',
-            'Booked revenue excludes refunds and test accounts.',
-            '',
-            '## Caveats',
-            '',
-            'This page supersedes the 2025 Sales Ops revenue definition.',
-        ].join('\n'));
-        const summary = await service.indexStagedDir({
-            stagedDir: tmp,
-            runId: 'run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            diffSet: {
-                added: ['pages/page-1/metadata.json', 'pages/page-1/page.md'],
-                modified: [],
-                deleted: [],
-                unchanged: [],
-            },
-            currentHashes: new Map([
-                ['pages/page-1/metadata.json', 'meta-hash'],
-                ['pages/page-1/page.md', 'page-hash'],
-            ]),
-        });
-        expect(summary.documentsIndexed).toBe(1);
-        expect(summary.chunksIndexed).toBeGreaterThanOrEqual(2);
-        expect(repository.upsertDocument).toHaveBeenCalledWith(expect.objectContaining({
-            connectionId: 'connection-1',
-            runId: 'run-1',
-            sourceKey: 'notion',
-            externalId: 'page-1',
-            title: 'Revenue Recognition',
-            path: 'Company Handbook / Finance / Revenue Recognition',
-            rawPath: 'pages/page-1/page.md',
-            contentHash: 'page-hash',
-        }));
-        expect(repository.replaceChunks).toHaveBeenCalledWith('doc-1', expect.arrayContaining([
-            expect.objectContaining({
-                chunkKey: 'h2:policy:0000',
-                headingPath: ['Revenue Recognition', 'Policy'],
-                stableCitationKey: expect.stringMatching(/^notion:page-1:policy:[a-f0-9]{16}$/),
-            }),
-        ]));
-    });
-    it('indexes only added or modified page documents by default', async () => {
-        for (const pageId of ['changed', 'unchanged']) {
-            await mkdir(join(tmp, 'pages', pageId), { recursive: true });
-            await writeFile(join(tmp, 'pages', pageId, 'metadata.json'), JSON.stringify({
-                objectType: 'page',
-                id: pageId,
-                title: pageId === 'changed' ? 'Changed Page' : 'Unchanged Page',
-                path: `Company Handbook / ${pageId}`,
-            }));
-            await writeFile(join(tmp, 'pages', pageId, 'page.md'), `# ${pageId}\n\n${pageId} body`);
-        }
-        const summary = await service.indexStagedDir({
-            stagedDir: tmp,
-            runId: 'run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            diffSet: {
-                added: [],
-                modified: ['pages/changed/page.md'],
-                deleted: [],
-                unchanged: ['pages/unchanged/page.md', 'pages/unchanged/metadata.json'],
-            },
-            currentHashes: new Map([
-                ['pages/changed/page.md', 'changed-hash'],
-                ['pages/unchanged/page.md', 'unchanged-hash'],
-            ]),
-        });
-        expect(summary.documentsIndexed).toBe(1);
-        expect(repository.upsertDocument).toHaveBeenCalledTimes(1);
-        expect(repository.upsertDocument).toHaveBeenCalledWith(expect.objectContaining({
-            externalId: 'changed',
-            contentHash: 'changed-hash',
-        }));
-    });
-    it('indexes documents when only their metadata changed', async () => {
-        for (const pageId of ['metadata-changed', 'unchanged']) {
-            await mkdir(join(tmp, 'pages', pageId), { recursive: true });
-            await writeFile(join(tmp, 'pages', pageId, 'metadata.json'), JSON.stringify({
-                objectType: 'page',
-                id: pageId,
-                title: pageId === 'metadata-changed' ? 'Metadata Changed' : 'Unchanged Page',
-                path: `Company Handbook / ${pageId}`,
-                properties: { Status: pageId === 'metadata-changed' ? 'Approved' : 'Draft' },
-            }));
-            await writeFile(join(tmp, 'pages', pageId, 'page.md'), `# ${pageId}\n\n${pageId} body`);
-        }
-        const summary = await service.indexStagedDir({
-            stagedDir: tmp,
-            runId: 'run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            diffSet: {
-                added: [],
-                modified: ['pages/metadata-changed/metadata.json'],
-                deleted: [],
-                unchanged: ['pages/unchanged/page.md', 'pages/unchanged/metadata.json'],
-            },
-            currentHashes: new Map([
-                ['pages/metadata-changed/page.md', 'metadata-changed-hash'],
-                ['pages/unchanged/page.md', 'unchanged-hash'],
-            ]),
-        });
-        expect(summary.documentsIndexed).toBe(1);
-        expect(repository.upsertDocument).toHaveBeenCalledTimes(1);
-        expect(repository.upsertDocument).toHaveBeenCalledWith(expect.objectContaining({
-            externalId: 'metadata-changed',
-            contentHash: 'metadata-changed-hash',
-        }));
-    });
-    it('marks deleted page markdown paths as deleted evidence documents', async () => {
-        const summary = await service.indexStagedDir({
-            stagedDir: tmp,
-            runId: 'run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-            syncId: 'sync-2',
-            diffSet: {
-                added: [],
-                modified: [],
-                deleted: ['pages/page-1/page.md', 'pages/page-1/metadata.json'],
-                unchanged: [],
-            },
-            currentHashes: new Map(),
-        });
-        expect(summary.documentsDeleted).toBe(1);
-        expect(repository.countPublishedDocumentsByRawPaths).toHaveBeenCalledWith('connection-1', 'notion', [
-            'pages/page-1/page.md',
-        ]);
-    });
-    it('falls back to null embeddings when embedding computation fails', async () => {
-        embeddings.computeEmbeddingsBulk.mockRejectedValueOnce(new Error('embedding provider unavailable'));
-        await writeFile(join(tmp, 'manifest.json'), JSON.stringify({ source: 'notion', apiVersion: '2026-03-11' }));
-        await mkdir(join(tmp, 'pages', 'page-2'), { recursive: true });
-        await writeFile(join(tmp, 'pages', 'page-2', 'metadata.json'), JSON.stringify({
-            objectType: 'page',
-            id: 'page-2',
-            title: 'Glossary',
-            path: 'Company Handbook / Glossary',
-        }));
-        await writeFile(join(tmp, 'pages', 'page-2', 'page.md'), '# Glossary\n\nARR means annual recurring revenue.');
-        const summary = await service.indexStagedDir({
-            stagedDir: tmp,
-            runId: 'run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            diffSet: { added: ['pages/page-2/page.md'], modified: [], deleted: [], unchanged: [] },
-            currentHashes: new Map([['pages/page-2/page.md', 'page-hash']]),
-        });
-        expect(summary.embeddingFailures).toBe(1);
-        expect(repository.replaceChunks).toHaveBeenCalledWith('doc-1', expect.arrayContaining([expect.objectContaining({ embedding: null })]));
-    });
-    it('batches embedding requests at the provider batch size', async () => {
-        embeddings.computeEmbeddingsBulk.mockImplementation((texts) => {
-            if (texts.length > 100) {
-                throw new Error('too many texts');
-            }
-            return texts.map((_text, index) => vector384(index / 100));
-        });
-        await mkdir(join(tmp, 'pages', 'large-page'), { recursive: true });
-        await writeFile(join(tmp, 'pages', 'large-page', 'metadata.json'), JSON.stringify({
-            objectType: 'page',
-            id: 'large-page',
-            title: 'Large Page',
-            path: 'Company Handbook / Large Page',
-        }));
-        await writeFile(join(tmp, 'pages', 'large-page', 'page.md'), Array.from({ length: 101 }, (_value, index) => [`## Section ${index + 1}`, '', `Body ${index + 1}`].join('\n')).join('\n\n'));
-        const summary = await service.indexStagedDir({
-            stagedDir: tmp,
-            runId: 'run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            diffSet: { added: ['pages/large-page/page.md'], modified: [], deleted: [], unchanged: [] },
-            currentHashes: new Map([['pages/large-page/page.md', 'large-hash']]),
-        });
-        expect(summary.embeddingFailures).toBe(0);
-        expect(embeddings.computeEmbeddingsBulk).toHaveBeenCalledTimes(2);
-        expect(embeddings.computeEmbeddingsBulk.mock.calls.map(([texts]) => texts)).toEqual([
-            expect.arrayContaining([expect.stringContaining('Section 1')]),
-            expect.arrayContaining([expect.stringContaining('Section 101')]),
-        ]);
-        expect(embeddings.computeEmbeddingsBulk.mock.calls[0][0]).toHaveLength(100);
-        expect(embeddings.computeEmbeddingsBulk.mock.calls[1][0]).toHaveLength(1);
-        expect(repository.replaceChunks).toHaveBeenCalledWith('doc-1', expect.arrayContaining([expect.objectContaining({ embedding: expect.any(Array) })]));
-    });
-    it('splits single long paragraphs into bounded chunks', async () => {
-        await mkdir(join(tmp, 'pages', 'long-paragraph'), { recursive: true });
-        await writeFile(join(tmp, 'pages', 'long-paragraph', 'metadata.json'), JSON.stringify({
-            objectType: 'page',
-            id: 'long-paragraph',
-            title: 'Long Paragraph',
-            path: 'Company Handbook / Long Paragraph',
-        }));
-        await writeFile(join(tmp, 'pages', 'long-paragraph', 'page.md'), `# Long Paragraph\n\n${'x'.repeat(12_000)}`);
-        await service.indexStagedDir({
-            stagedDir: tmp,
-            runId: 'run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            diffSet: { added: ['pages/long-paragraph/page.md'], modified: [], deleted: [], unchanged: [] },
-            currentHashes: new Map([['pages/long-paragraph/page.md', 'long-hash']]),
-        });
-        const chunks = repository.replaceChunks.mock.calls[0][1];
-        expect(chunks.length).toBeGreaterThan(1);
-        expect(chunks.every((chunk) => chunk.content.length <= 4800)).toBe(true);
-    });
-    it('creates unique stable citation keys for duplicate heading leaves', async () => {
-        embeddings.computeEmbeddingsBulk.mockImplementation((texts) => texts.map((_text, index) => vector384(index / 10)));
-        await mkdir(join(tmp, 'pages', 'duplicate-headings'), { recursive: true });
-        await writeFile(join(tmp, 'pages', 'duplicate-headings', 'metadata.json'), JSON.stringify({
-            objectType: 'page',
-            id: 'duplicate-headings',
-            title: 'Duplicate Headings',
-            path: 'Company Handbook / Duplicate Headings',
-        }));
-        await writeFile(join(tmp, 'pages', 'duplicate-headings', 'page.md'), [
-            '# Duplicate Headings',
-            '',
-            '## Overview',
-            '',
-            'First overview.',
-            '',
-            '## Overview',
-            '',
-            'Second overview.',
-        ].join('\n'));
-        await service.indexStagedDir({
-            stagedDir: tmp,
-            runId: 'run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            diffSet: { added: ['pages/duplicate-headings/page.md'], modified: [], deleted: [], unchanged: [] },
-            currentHashes: new Map([['pages/duplicate-headings/page.md', 'duplicate-hash']]),
-        });
-        const chunks = repository.replaceChunks.mock.calls[0][1];
-        const citationKeys = chunks.map((chunk) => chunk.stableCitationKey);
-        expect(new Set(citationKeys).size).toBe(citationKeys.length);
-        expect(citationKeys).toEqual([
-            expect.stringMatching(/^notion:duplicate-headings:overview:[a-f0-9]{16}$/),
-            expect.stringMatching(/^notion:duplicate-headings:overview:[a-f0-9]{16}$/),
-        ]);
-    });
-    it('persists Notion links metadata for neighbor lookup', async () => {
-        await mkdir(join(tmp, 'pages', 'page-root'), { recursive: true });
-        await writeFile(join(tmp, 'pages/page-root/metadata.json'), JSON.stringify({
-            objectType: 'page',
-            id: 'page-root',
-            title: 'Root',
-            path: 'Root',
-        }));
-        await writeFile(join(tmp, 'pages/page-root/page.md'), '# Root\n\nSee linked pages.');
-        await writeFile(join(tmp, 'pages/page-root/links.json'), JSON.stringify({
-            children: ['page-child'],
-            reverseLinks: ['page-parent'],
-            mentions: ['page-mentioned'],
-            databases: [],
-        }));
-        await service.indexStagedDir({
-            stagedDir: tmp,
-            runId: 'run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            diffSet: { added: ['pages/page-root/links.json'], modified: [], deleted: [], unchanged: [] },
-            currentHashes: new Map(),
-            forceRebuild: true,
-        });
-        expect(repository.upsertDocument).toHaveBeenCalledWith(expect.objectContaining({
-            metadata: expect.objectContaining({
-                linksPath: 'pages/page-root/links.json',
-                links: expect.objectContaining({
-                    children: ['page-child'],
-                    reverseLinks: ['page-parent'],
-                    mentions: ['page-mentioned'],
-                }),
-            }),
-        }));
-    });
-    it('indexes data-source row metadata as the surviving document form', async () => {
-        await mkdir(join(tmp, 'data-sources/data-source-1/rows/row-1'), { recursive: true });
-        await writeFile(join(tmp, 'data-sources/data-source-1/rows/row-1/metadata.json'), JSON.stringify({
-            objectType: 'data_source_row',
-            id: 'row-1',
-            title: 'Row One',
-            path: 'Policies / Row One',
-            parentId: 'data-source-1',
-            databaseId: null,
-            dataSourceId: 'data-source-1',
-            properties: {},
-        }));
-        await writeFile(join(tmp, 'data-sources/data-source-1/rows/row-1/page.md'), '# Row One\n\nDurable row fact.');
-        await service.indexStagedDir({
-            stagedDir: tmp,
-            runId: 'run-1',
-            connectionId: 'connection-1',
-            sourceKey: 'notion',
-            syncId: 'sync-1',
-            diffSet: {
-                added: ['data-sources/data-source-1/rows/row-1/metadata.json', 'data-sources/data-source-1/rows/row-1/page.md'],
-                modified: [],
-                deleted: [],
-                unchanged: [],
-            },
-            currentHashes: new Map([['data-sources/data-source-1/rows/row-1/page.md', 'row-hash']]),
-        });
-        expect(repository.upsertDocument).toHaveBeenCalledWith(expect.objectContaining({
-            externalId: 'row-1',
-            objectType: 'data_source_row',
-            dataSourceId: 'data-source-1',
-            rawPath: 'data-sources/data-source-1/rows/row-1/page.md',
-        }));
-    });
-});