@kaelio/ktx 0.5.0 → 0.6.0

package/dist/context/search/hybrid-search-core.test.js

@@ -1,113 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { HybridSearchCore } from './hybrid-search-core.js';
-function generator(lane, candidates, weight) {
-    return {
-        lane,
-        weight,
-        async generate() {
-            return { candidates };
-        },
-    };
-}
-describe('HybridSearchCore', () => {
-    it('runs lane generators with the shared pool size and applies final limit after RRF fusion', async () => {
-        const calls = [];
-        const core = new HybridSearchCore();
-        const result = await core.search({
-            queryText: 'gross revenue',
-            limit: 1,
-            generators: [
-                {
-                    lane: 'lexical',
-                    async generate(args) {
-                        calls.push({ lane: 'lexical', ...args });
-                        return {
-                            candidates: [
-                                { id: 'orders', rank: 1, rawScore: 0.8 },
-                                { id: 'customers', rank: 2, rawScore: 0.7 },
-                            ],
-                        };
-                    },
-                },
-                {
-                    lane: 'semantic',
-                    async generate(args) {
-                        calls.push({ lane: 'semantic', ...args });
-                        return { candidates: [{ id: 'customers', rank: 1, rawScore: 0.91 }] };
-                    },
-                },
-            ],
-        });
-        expect(calls).toEqual([
-            expect.objectContaining({ lane: 'lexical', laneCandidatePoolLimit: 25, finalLimit: 1 }),
-            expect.objectContaining({ lane: 'semantic', laneCandidatePoolLimit: 25, finalLimit: 1 }),
-        ]);
-        expect(result.results.map((candidate) => candidate.id)).toEqual(['customers']);
-        expect(result.results[0]).toMatchObject({
-            matchReasons: ['lexical', 'semantic'],
-            ranksByLane: { lexical: 2, semantic: 1 },
-            rawScoresByLane: { lexical: 0.7, semantic: 0.91 },
-        });
-        expect(result.lanes).toEqual([
-            expect.objectContaining({ lane: 'lexical', status: 'available', returnedCandidateCount: 2, weight: 1.5 }),
-            expect.objectContaining({ lane: 'semantic', status: 'available', returnedCandidateCount: 1, weight: 2 }),
-        ]);
-    });
-    it('keeps available lane results when another lane is skipped or fails', async () => {
-        const core = new HybridSearchCore();
-        const result = await core.search({
-            queryText: 'paid',
-            limit: 5,
-            generators: [
-                generator('lexical', [{ id: 'orders', rank: 1 }]),
-                {
-                    lane: 'semantic',
-                    async generate() {
-                        return { status: 'skipped', candidates: [], reason: 'embedding_unconfigured' };
-                    },
-                },
-                {
-                    lane: 'dictionary',
-                    async generate() {
-                        throw new Error('dictionary index unavailable');
-                    },
-                },
-            ],
-        });
-        expect(result.results.map((candidate) => candidate.id)).toEqual(['orders']);
-        expect(result.lanes).toEqual([
-            expect.objectContaining({ lane: 'lexical', status: 'available', reason: undefined }),
-            expect.objectContaining({ lane: 'semantic', status: 'skipped', reason: 'embedding_unconfigured' }),
-            expect.objectContaining({ lane: 'dictionary', status: 'failed', reason: 'dictionary index unavailable' }),
-        ]);
-    });
-    it('deduplicates one lane by best rank before fusion', async () => {
-        const core = new HybridSearchCore();
-        const result = await core.search({
-            queryText: 'paid status',
-            limit: 10,
-            generators: [
-                generator('dictionary', [
-                    { id: 'orders', rank: 4, rawScore: 0.4, evidence: { column: 'state', values: ['paid'] } },
-                    { id: 'orders', rank: 1, rawScore: 0.9, evidence: { column: 'status', values: ['paid'] } },
-                ]),
-            ],
-        });
-        expect(result.results).toHaveLength(1);
-        expect(result.results[0]).toMatchObject({
-            id: 'orders',
-            ranksByLane: { dictionary: 1 },
-            rawScoresByLane: { dictionary: 0.9 },
-            evidenceByLane: { dictionary: [{ column: 'status', values: ['paid'] }] },
-        });
-    });
-    it('uses deterministic id ordering when scores and lane counts tie', async () => {
-        const core = new HybridSearchCore();
-        const result = await core.search({
-            queryText: 'revenue',
-            limit: 10,
-            generators: [generator('lexical', [{ id: 'zebra', rank: 1 }, { id: 'alpha', rank: 1 }])],
-        });
-        expect(result.results.map((candidate) => candidate.id)).toEqual(['alpha', 'zebra']);
-    });
-});

package/dist/context/search/pglite-owner-process.test.d.ts

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

package/dist/context/search/pglite-owner-process.test.js

@@ -1,273 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { createServer } from 'node:net';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { Client } from 'pg';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { assertSearchBackendConformanceCase } from '../../context/search/backend-conformance.test-utils.js';
-import { KtxPGliteOwnerProcess } from './pglite-owner-process.js';
-async function allocatePort() {
-    const server = createServer();
-    await new Promise((resolve) => server.listen(0, '127.0.0.1', resolve));
-    const address = server.address();
-    if (typeof address !== 'object' || address === null) {
-        throw new Error('Expected TCP server address while allocating a PGlite owner-process port.');
-    }
-    await new Promise((resolve, reject) => {
-        server.close((error) => {
-            if (error) {
-                reject(error);
-                return;
-            }
-            resolve();
-        });
-    });
-    return address.port;
-}
-async function createHybridSearchFixture(owner) {
-    await owner.query(`
-    CREATE TABLE prototype_documents (
-      id TEXT PRIMARY KEY,
-      search_text TEXT NOT NULL,
-      metadata JSONB NOT NULL DEFAULT '{}'::jsonb,
-      embedding vector(3) NOT NULL
-    );
-
-    CREATE INDEX prototype_documents_fts_idx
-      ON prototype_documents
-      USING GIN (to_tsvector('english', search_text));
-
-    CREATE INDEX prototype_documents_vector_idx
-      ON prototype_documents
-      USING ivfflat (embedding vector_cosine_ops)
-      WITH (lists = 1);
-
-    CREATE TABLE prototype_dictionary_values (
-      connection_id TEXT NOT NULL,
-      source_name TEXT NOT NULL,
-      column_name TEXT NOT NULL,
-      value TEXT NOT NULL,
-      PRIMARY KEY (connection_id, source_name, column_name, value)
-    );
-
-    CREATE INDEX prototype_dictionary_values_trgm_idx
-      ON prototype_dictionary_values
-      USING GIN (value gin_trgm_ops);
-  `);
-}
-async function seedHybridSearchFixture(owner) {
-    await owner.query(`
-      INSERT INTO prototype_documents (id, search_text, metadata, embedding)
-      VALUES
-        ($1, $2, $3::jsonb, $4::vector),
-        ($5, $6, $7::jsonb, $8::vector),
-        ($9, $10, $11::jsonb, $12::vector)
-    `, [
-        'warehouse/orders',
-        'orders paid revenue refund status customer',
-        JSON.stringify({ connectionId: 'warehouse', sourceName: 'orders' }),
-        JSON.stringify([1, 0, 0]),
-        'finance/orders',
-        'orders finance bookings gross margin',
-        JSON.stringify({ connectionId: 'finance', sourceName: 'orders' }),
-        JSON.stringify([0.72, 0.28, 0]),
-        'warehouse/customers',
-        'customers accounts lifecycle region',
-        JSON.stringify({ connectionId: 'warehouse', sourceName: 'customers' }),
-        JSON.stringify([0, 1, 0]),
-    ]);
-    await owner.query(`
-    INSERT INTO prototype_dictionary_values (connection_id, source_name, column_name, value)
-    VALUES
-      ('warehouse', 'orders', 'status', 'refunded'),
-      ('warehouse', 'orders', 'status', 'paid'),
-      ('warehouse', 'customers', 'region', 'emea')
-  `);
-}
-describe('KtxPGliteOwnerProcess', () => {
-    let tempDir;
-    let dataDir;
-    let port;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-pglite-owner-process-'));
-        dataDir = join(tempDir, 'pgdata');
-        port = await allocatePort();
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('starts a socket owner process and serves PostgreSQL clients', async () => {
-        const owner = await KtxPGliteOwnerProcess.start({
-            dataDir,
-            host: '127.0.0.1',
-            port,
-        });
-        try {
-            await owner.query(`
-        CREATE TABLE owner_process_smoke (
-          id TEXT PRIMARY KEY,
-          search_text TEXT NOT NULL,
-          embedding vector(3) NOT NULL
-        );
-
-        INSERT INTO owner_process_smoke (id, search_text, embedding)
-        VALUES
-          ('orders', 'orders paid revenue', '[1,0,0]'::vector),
-          ('customers', 'customers region lifecycle', '[0,1,0]'::vector);
-      `);
-            const client = new Client(owner.connectionConfig());
-            await client.connect();
-            try {
-                const result = await client.query(`
-          SELECT id
-          FROM owner_process_smoke
-          ORDER BY embedding <=> '[1,0,0]'::vector, id ASC
-          LIMIT 1
-        `);
-                expect(result.rows).toEqual([{ id: 'orders' }]);
-            }
-            finally {
-                await client.end();
-            }
-        }
-        finally {
-            await owner.stop();
-        }
-    });
-    it('runs lexical, semantic, and dictionary conformance probes through socket clients', async () => {
-        const owner = await KtxPGliteOwnerProcess.start({
-            dataDir,
-            host: '127.0.0.1',
-            port,
-        });
-        try {
-            await createHybridSearchFixture(owner);
-            await seedHybridSearchFixture(owner);
-            const lexical = await owner.query(`
-          SELECT
-            id,
-            ts_rank_cd(to_tsvector('english', search_text), websearch_to_tsquery('english', $1)) AS score
-          FROM prototype_documents
-          WHERE to_tsvector('english', search_text) @@ websearch_to_tsquery('english', $1)
-          ORDER BY score DESC, id ASC
-          LIMIT 2
-        `, ['paid orders']);
-            assertSearchBackendConformanceCase({
-                backendName: 'pglite-owner-process',
-                surface: 'semantic-layer',
-                caseName: 'socket postgres fts lexical ranking',
-                results: lexical.rows.map((row) => ({
-                    id: row.id,
-                    score: row.score,
-                    matchReasons: ['lexical'],
-                })),
-                expectedTopIds: ['warehouse/orders'],
-                expectedReasonsById: {
-                    'warehouse/orders': ['lexical'],
-                },
-            });
-            const semantic = await owner.query(`
-          SELECT
-            id,
-            1 - (embedding <=> $1::vector) AS similarity
-          FROM prototype_documents
-          ORDER BY embedding <=> $1::vector, id ASC
-          LIMIT 2
-        `, [JSON.stringify([1, 0, 0])]);
-            assertSearchBackendConformanceCase({
-                backendName: 'pglite-owner-process',
-                surface: 'semantic-layer',
-                caseName: 'socket pgvector semantic ranking',
-                results: semantic.rows.map((row) => ({
-                    id: row.id,
-                    score: row.similarity,
-                    matchReasons: ['semantic'],
-                })),
-                expectedTopIds: ['warehouse/orders'],
-                expectedReasonsById: {
-                    'warehouse/orders': ['semantic'],
-                },
-            });
-            const dictionary = await owner.query(`
-          SELECT
-            connection_id || '/' || source_name AS id,
-            value,
-            similarity(value, $1) AS score
-          FROM prototype_dictionary_values
-          WHERE similarity(value, $1) > 0
-          ORDER BY score DESC, id ASC, value ASC
-          LIMIT 2
-        `, ['refund']);
-            assertSearchBackendConformanceCase({
-                backendName: 'pglite-owner-process',
-                surface: 'semantic-layer',
-                caseName: 'socket pg_trgm dictionary ranking',
-                results: dictionary.rows.map((row) => ({
-                    id: row.id,
-                    score: row.score,
-                    matchReasons: ['dictionary'],
-                    dictionaryMatches: [{ column: 'status', values: [row.value] }],
-                })),
-                expectedTopIds: ['warehouse/orders'],
-                expectedReasonsById: {
-                    'warehouse/orders': ['dictionary'],
-                },
-                expectedDictionaryMatchesById: {
-                    'warehouse/orders': [{ column: 'status', values: ['refunded'] }],
-                },
-            });
-        }
-        finally {
-            await owner.stop();
-        }
-    });
-    it('persists indexed rows after stopping and restarting the owner process', async () => {
-        const firstOwner = await KtxPGliteOwnerProcess.start({
-            dataDir,
-            host: '127.0.0.1',
-            port,
-        });
-        try {
-            await createHybridSearchFixture(firstOwner);
-            await seedHybridSearchFixture(firstOwner);
-        }
-        finally {
-            await firstOwner.stop();
-        }
-        const secondOwner = await KtxPGliteOwnerProcess.start({
-            dataDir,
-            host: '127.0.0.1',
-            port,
-        });
-        try {
-            const persisted = await secondOwner.query("SELECT COUNT(*)::int AS count FROM prototype_documents WHERE metadata->>'connectionId' = $1", ['warehouse']);
-            expect(persisted.rows).toEqual([{ count: 2 }]);
-        }
-        finally {
-            await secondOwner.stop();
-        }
-    });
-    it('serves concurrent PostgreSQL clients through one owner process', async () => {
-        const owner = await KtxPGliteOwnerProcess.start({
-            dataDir,
-            host: '127.0.0.1',
-            port,
-        });
-        const clients = [];
-        try {
-            await createHybridSearchFixture(owner);
-            await seedHybridSearchFixture(owner);
-            for (let index = 0; index < 4; index += 1) {
-                const client = new Client(owner.connectionConfig());
-                await client.connect();
-                clients.push(client);
-            }
-            const results = await Promise.all(clients.map((client) => client.query('SELECT COUNT(*)::int AS count FROM prototype_documents')));
-            expect(results.map((result) => result.rows[0]?.count)).toEqual([3, 3, 3, 3]);
-        }
-        finally {
-            await Promise.all(clients.map((client) => client.end().catch(() => undefined)));
-            await owner.stop();
-        }
-    });
-});

package/dist/context/search/pglite-runtime-boundary.test.d.ts

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

package/dist/context/search/pglite-runtime-boundary.test.js

@@ -1,40 +0,0 @@
-import { readFileSync } from 'node:fs';
-import { join } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { describe, expect, it } from 'vitest';
-const ktxRoot = fileURLToPath(new URL('../../../../../', import.meta.url));
-function readKtxFile(relativePath) {
-    return readFileSync(join(ktxRoot, relativePath), 'utf8');
-}
-function readCliPackageJson() {
-    return JSON.parse(readKtxFile('packages/cli/package.json'));
-}
-describe('PGlite hybrid search runtime boundary', () => {
-    it('keeps PGlite packages as dev-only prototype dependencies', () => {
-        const pkg = readCliPackageJson();
-        expect(pkg.dependencies?.['@electric-sql/pglite']).toBeUndefined();
-        expect(pkg.dependencies?.['@electric-sql/pglite-socket']).toBeUndefined();
-        expect(pkg.devDependencies?.['@electric-sql/pglite']).toBeDefined();
-        expect(pkg.devDependencies?.['@electric-sql/pglite-socket']).toBeDefined();
-        expect(pkg.files).toEqual(['dist', 'assets']);
-    });
-    it('keeps PGlite prototypes out of public exports and production routing', () => {
-        const pkg = readCliPackageJson();
-        const packageExportKeys = Object.keys(pkg.exports ?? {});
-        expect(packageExportKeys.filter((key) => key.toLowerCase().includes('pglite'))).toEqual([]);
-        const productionRoutingFiles = [
-            'packages/cli/src/sl.ts',
-            'packages/cli/src/knowledge.ts',
-            'packages/cli/src/context/mcp/local-project-ports.ts',
-            'packages/cli/src/context/wiki/local-knowledge.ts',
-            'packages/cli/src/context/ingest/context-evidence/sqlite-context-evidence-store.ts',
-        ];
-        for (const relativePath of productionRoutingFiles) {
-            expect(readKtxFile(relativePath), relativePath).not.toMatch(/pglite-owner-prototype|pglite-sl-search-prototype|@electric-sql\/pglite/i);
-        }
-        const localSlSource = readKtxFile('packages/cli/src/context/sl/local-sl.ts');
-        expect(localSlSource).toContain("input.backend === 'pglite-owner-prototype'");
-        expect(localSlSource).toContain('PGlite semantic-layer search prototype requires pglite owner-process options.');
-        expect(localSlSource).toContain("await import('./pglite-sl-search-prototype.js')");
-    });
-});

package/dist/context/search/pglite-spike.test.d.ts

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

package/dist/context/search/pglite-spike.test.js

@@ -1,249 +0,0 @@
-import { mkdtemp, rm } from 'node:fs/promises';
-import { tmpdir } from 'node:os';
-import { join } from 'node:path';
-import { PGlite } from '@electric-sql/pglite';
-import { pg_trgm } from '@electric-sql/pglite/contrib/pg_trgm';
-import { vector } from '@electric-sql/pglite/vector';
-import { afterEach, beforeEach, describe, expect, it } from 'vitest';
-import { assertSearchBackendCapabilities, assertSearchBackendConformanceCase } from '../../context/search/backend-conformance.test-utils.js';
-const PGLITE_SPIKE_CAPABILITIES = {
-    fts: true,
-    vector: true,
-    fuzzy: true,
-    jsonSearch: true,
-    arraySearch: false,
-};
-async function createSpikeDb(dataDir) {
-    const db = await PGlite.create({
-        dataDir,
-        extensions: {
-            vector,
-            pg_trgm,
-        },
-    });
-    await db.exec(`
-    CREATE EXTENSION IF NOT EXISTS vector;
-    CREATE EXTENSION IF NOT EXISTS pg_trgm;
-  `);
-    return db;
-}
-async function createSchema(db) {
-    await db.exec(`
-    CREATE TABLE IF NOT EXISTS spike_documents (
-      id TEXT PRIMARY KEY,
-      search_text TEXT NOT NULL,
-      metadata JSONB NOT NULL DEFAULT '{}'::jsonb,
-      embedding vector(3) NOT NULL
-    );
-
-    CREATE INDEX IF NOT EXISTS spike_documents_fts_idx
-      ON spike_documents
-      USING GIN (to_tsvector('english', search_text));
-
-    CREATE INDEX IF NOT EXISTS spike_documents_vector_idx
-      ON spike_documents
-      USING ivfflat (embedding vector_cosine_ops)
-      WITH (lists = 1);
-
-    CREATE TABLE IF NOT EXISTS spike_dictionary_values (
-      connection_id TEXT NOT NULL,
-      source_name TEXT NOT NULL,
-      column_name TEXT NOT NULL,
-      value TEXT NOT NULL,
-      PRIMARY KEY (connection_id, source_name, column_name, value)
-    );
-
-    CREATE INDEX IF NOT EXISTS spike_dictionary_values_trgm_idx
-      ON spike_dictionary_values
-      USING GIN (value gin_trgm_ops);
-  `);
-}
-async function seedSearchFixture(db) {
-    await db.query(`
-      INSERT INTO spike_documents (id, search_text, metadata, embedding)
-      VALUES
-        ($1, $2, $3::jsonb, $4::vector),
-        ($5, $6, $7::jsonb, $8::vector),
-        ($9, $10, $11::jsonb, $12::vector)
-      ON CONFLICT (id) DO UPDATE
-      SET search_text = EXCLUDED.search_text,
-          metadata = EXCLUDED.metadata,
-          embedding = EXCLUDED.embedding
-    `, [
-        'warehouse/orders',
-        'orders paid revenue refund status customer',
-        JSON.stringify({ connectionId: 'warehouse', sourceName: 'orders' }),
-        JSON.stringify([1, 0, 0]),
-        'finance/orders',
-        'orders finance bookings gross margin',
-        JSON.stringify({ connectionId: 'finance', sourceName: 'orders' }),
-        JSON.stringify([0.72, 0.28, 0]),
-        'warehouse/customers',
-        'customers accounts lifecycle region',
-        JSON.stringify({ connectionId: 'warehouse', sourceName: 'customers' }),
-        JSON.stringify([0, 1, 0]),
-    ]);
-    await db.query(`
-      INSERT INTO spike_dictionary_values (connection_id, source_name, column_name, value)
-      VALUES
-        ('warehouse', 'orders', 'status', 'refunded'),
-        ('warehouse', 'orders', 'status', 'paid'),
-        ('warehouse', 'customers', 'region', 'emea')
-      ON CONFLICT DO NOTHING
-    `);
-}
-async function closeDb(db) {
-    await db.close();
-}
-describe('PGlite hybrid search spike', () => {
-    let tempDir;
-    let dataDir;
-    beforeEach(async () => {
-        tempDir = await mkdtemp(join(tmpdir(), 'ktx-pglite-search-spike-'));
-        dataDir = join(tempDir, 'pgdata');
-    });
-    afterEach(async () => {
-        await rm(tempDir, { recursive: true, force: true });
-    });
-    it('documents PGlite search backend capabilities', () => {
-        assertSearchBackendCapabilities({
-            backendName: 'pglite-spike',
-            capabilities: PGLITE_SPIKE_CAPABILITIES,
-            expected: {
-                fts: true,
-                vector: true,
-                fuzzy: true,
-                jsonSearch: true,
-                arraySearch: false,
-            },
-        });
-    });
-    it('supports FTS, pgvector ordering, and pg_trgm dictionary lookup', async () => {
-        const db = await createSpikeDb(dataDir);
-        try {
-            await createSchema(db);
-            await seedSearchFixture(db);
-            const lexical = await db.query(`
-          SELECT
-            id,
-            ts_rank_cd(to_tsvector('english', search_text), websearch_to_tsquery('english', $1)) AS score
-          FROM spike_documents
-          WHERE to_tsvector('english', search_text) @@ websearch_to_tsquery('english', $1)
-          ORDER BY score DESC, id ASC
-          LIMIT 2
-        `, ['paid orders']);
-            assertSearchBackendConformanceCase({
-                backendName: 'pglite-spike',
-                surface: 'semantic-layer',
-                caseName: 'postgres fts lexical ranking',
-                results: lexical.rows.map((row) => ({
-                    id: row.id,
-                    score: row.score,
-                    matchReasons: ['lexical'],
-                })),
-                expectedTopIds: ['warehouse/orders'],
-                expectedReasonsById: {
-                    'warehouse/orders': ['lexical'],
-                },
-            });
-            const semantic = await db.query(`
-          SELECT
-            id,
-            1 - (embedding <=> $1::vector) AS similarity
-          FROM spike_documents
-          ORDER BY embedding <=> $1::vector, id ASC
-          LIMIT 2
-        `, [JSON.stringify([1, 0, 0])]);
-            assertSearchBackendConformanceCase({
-                backendName: 'pglite-spike',
-                surface: 'semantic-layer',
-                caseName: 'pgvector cosine ranking',
-                results: semantic.rows.map((row) => ({
-                    id: row.id,
-                    score: row.similarity,
-                    matchReasons: ['semantic'],
-                })),
-                expectedTopIds: ['warehouse/orders'],
-                expectedReasonsById: {
-                    'warehouse/orders': ['semantic'],
-                },
-            });
-            const dictionary = await db.query(`
-          SELECT
-            connection_id || '/' || source_name AS id,
-            value,
-            similarity(value, $1) AS score
-          FROM spike_dictionary_values
-          WHERE similarity(value, $1) > 0
-          ORDER BY score DESC, id ASC, value ASC
-          LIMIT 2
-        `, ['refund']);
-            assertSearchBackendConformanceCase({
-                backendName: 'pglite-spike',
-                surface: 'semantic-layer',
-                caseName: 'pg_trgm dictionary ranking',
-                results: dictionary.rows.map((row) => ({
-                    id: row.id,
-                    score: row.score,
-                    matchReasons: ['dictionary'],
-                    dictionaryMatches: [{ column: 'status', values: [row.value] }],
-                })),
-                expectedTopIds: ['warehouse/orders'],
-                expectedReasonsById: {
-                    'warehouse/orders': ['dictionary'],
-                },
-                expectedDictionaryMatchesById: {
-                    'warehouse/orders': [{ column: 'status', values: ['refunded'] }],
-                },
-            });
-        }
-        finally {
-            await closeDb(db);
-        }
-    });
-    it('persists indexed rows after reopening the filesystem database', async () => {
-        const first = await createSpikeDb(dataDir);
-        try {
-            await createSchema(first);
-            await seedSearchFixture(first);
-        }
-        finally {
-            await closeDb(first);
-        }
-        const second = await createSpikeDb(dataDir);
-        try {
-            const persisted = await second.query("SELECT COUNT(*)::int AS count FROM spike_documents WHERE metadata->>'connectionId' = $1", ['warehouse']);
-            expect(persisted.rows[0]).toEqual({ count: 2 });
-        }
-        finally {
-            await closeDb(second);
-        }
-    });
-    it('records direct concurrency behavior without assuming Postgres server parity', async () => {
-        const db = await createSpikeDb(dataDir);
-        try {
-            await createSchema(db);
-            await seedSearchFixture(db);
-            const reads = await Promise.all(Array.from({ length: 4 }, () => db.query('SELECT COUNT(*)::int AS count FROM spike_documents')));
-            expect(reads.map((result) => result.rows[0]?.count)).toEqual([3, 3, 3, 3]);
-            let secondOpenStatus = 'opened';
-            let second;
-            try {
-                second = await createSpikeDb(dataDir);
-                await second.query('SELECT 1');
-            }
-            catch {
-                secondOpenStatus = 'blocked';
-            }
-            finally {
-                if (second) {
-                    await closeDb(second);
-                }
-            }
-            expect(['opened', 'blocked']).toContain(secondOpenStatus);
-        }
-        finally {
-            await closeDb(db);
-        }
-    });
-});

package/dist/context/search/query.test.d.ts

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