@kaelio/ktx 0.0.0 → 0.1.0-rc.0

package/node_modules/@ktx/context/dist/search/pglite-owner-process.js

@@ -0,0 +1,89 @@
+import { PGlite } from '@electric-sql/pglite';
+import { pg_trgm } from '@electric-sql/pglite/contrib/pg_trgm';
+import { vector } from '@electric-sql/pglite/vector';
+import { PGLiteSocketServer } from '@electric-sql/pglite-socket';
+import { Client } from 'pg';
+export const PGLITE_OWNER_PROCESS_BACKEND_CAPABILITIES = {
+    fts: true,
+    vector: true,
+    fuzzy: true,
+    jsonSearch: true,
+    arraySearch: false,
+};
+export class KtxPGliteOwnerProcess {
+    dataDir;
+    host;
+    port;
+    #db;
+    #server;
+    #stopped = false;
+    constructor(options, db, server) {
+        this.dataDir = options.dataDir;
+        this.host = options.host;
+        this.port = options.port;
+        this.#db = db;
+        this.#server = server;
+    }
+    static async start(options) {
+        const db = await PGlite.create({
+            dataDir: options.dataDir,
+            extensions: {
+                vector,
+                pg_trgm,
+            },
+        });
+        let server;
+        try {
+            await db.exec(`
+        CREATE EXTENSION IF NOT EXISTS vector;
+        CREATE EXTENSION IF NOT EXISTS pg_trgm;
+      `);
+            server = new PGLiteSocketServer({
+                db,
+                host: options.host,
+                port: options.port,
+                inspect: options.inspect ?? false,
+                maxConnections: options.maxConnections ?? 100,
+            });
+            await server.start();
+            return new KtxPGliteOwnerProcess(options, db, server);
+        }
+        catch (error) {
+            await server?.stop().catch(() => undefined);
+            await db.close().catch(() => undefined);
+            throw error;
+        }
+    }
+    connectionConfig() {
+        return {
+            host: this.host,
+            port: this.port,
+            user: 'postgres',
+            database: 'postgres',
+            application_name: 'ktx-pglite-owner-prototype',
+            connectionTimeoutMillis: 5_000,
+        };
+    }
+    async connect() {
+        const client = new Client(this.connectionConfig());
+        await client.connect();
+        return client;
+    }
+    async query(text, values) {
+        const client = await this.connect();
+        try {
+            return await client.query(text, values ? [...values] : undefined);
+        }
+        finally {
+            await client.end();
+        }
+    }
+    async stop() {
+        if (this.#stopped) {
+            return;
+        }
+        this.#stopped = true;
+        await this.#server.stop();
+        await this.#db.close();
+    }
+}

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

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

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

@@ -0,0 +1,286 @@
+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 { assertSearchBackendCapabilities, assertSearchBackendConformanceCase } from './index.js';
+import { KtxPGliteOwnerProcess, PGLITE_OWNER_PROCESS_BACKEND_CAPABILITIES } 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('declares the advanced PGlite search capabilities observed by the spike', () => {
+        assertSearchBackendCapabilities({
+            backendName: 'pglite-owner-process',
+            capabilities: PGLITE_OWNER_PROCESS_BACKEND_CAPABILITIES,
+            expected: {
+                fts: true,
+                vector: true,
+                fuzzy: true,
+                jsonSearch: true,
+                arraySearch: false,
+            },
+        });
+    });
+    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/node_modules/@ktx/context/dist/search/pglite-runtime-boundary.test.d.ts

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

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

@@ -0,0 +1,47 @@
+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 readContextPackageJson() {
+    return JSON.parse(readKtxFile('packages/context/package.json'));
+}
+describe('PGlite hybrid search runtime boundary', () => {
+    it('keeps PGlite packages as dev-only prototype dependencies', () => {
+        const pkg = readContextPackageJson();
+        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', 'prompts', 'skills']);
+    });
+    it('keeps PGlite prototypes out of public exports and production routing', () => {
+        const pkg = readContextPackageJson();
+        const packageExportKeys = Object.keys(pkg.exports ?? {});
+        expect(packageExportKeys.filter((key) => key.toLowerCase().includes('pglite'))).toEqual([]);
+        const publicExportFiles = [
+            'packages/context/src/index.ts',
+            'packages/context/src/search/index.ts',
+            'packages/context/src/sl/index.ts',
+        ];
+        for (const relativePath of publicExportFiles) {
+            expect(readKtxFile(relativePath), relativePath).not.toMatch(/pglite/i);
+        }
+        const productionRoutingFiles = [
+            'packages/cli/src/agent.ts',
+            'packages/context/src/mcp/local-project-ports.ts',
+            'packages/context/src/wiki/local-knowledge.ts',
+            'packages/context/src/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/context/src/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/node_modules/@ktx/context/dist/search/pglite-spike.test.d.ts

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

package/node_modules/@ktx/context/dist/search/pglite-spike.test.js

@@ -0,0 +1,249 @@
+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 './index.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/node_modules/@ktx/context/dist/search/query.d.ts

@@ -0,0 +1,3 @@
+import type { NormalizedSearchQuery } from './types.js';
+export declare function normalizeSearchQuery(queryText: string): NormalizedSearchQuery;
+export declare function defaultLaneCandidatePoolLimit(finalLimit: number): number;