@kaelio/ktx 0.13.1 → 0.14.0

package/dist/connectors/postgres/connector.js

@@ -1,5 +1,6 @@
 import { resolveStringReference } from '../shared/string-reference.js';
-import { getDialectForDriver } from '../../context/connections/dialects.js';
+import { getSqlDialectForDriver } from '../../context/connections/dialects.js';
+import { resolveQueryDeadlineMs, queryDeadlineExceededError } from '../../context/connections/query-deadline.js';
 import { assertReadOnlySql, limitSqlForExecution } from '../../context/connections/read-only-sql.js';
 import { tryConstraintQuery } from '../../context/scan/constraint-discovery.js';
 import { scopedTableNames } from '../../context/scan/table-ref.js';
@@ -74,6 +75,10 @@ function isDeniedError(error) {
     const code = error.code;
     return code === '42501' || code === '42P01';
 }
+// 57014 = query_canceled, which is how statement_timeout surfaces.
+function isPostgresTimeoutError(error) {
+    return Boolean(error) && typeof error === 'object' && error.code === '57014';
+}
 function queryRows(result) {
     const headers = (result.fields ?? []).map((field) => field.name);
     return result.rows.map((row) => headers.map((header) => row[header]));
@@ -169,9 +174,13 @@ export function postgresPoolConfigFromConfig(input) {
             : { host, port: numberValue(merged.port) ?? 5432, database, user, password }),
     };
     const searchPathSchemas = searchPathSchemasFromConnection(merged);
+    // statement_timeout (ms) bounds every query on connections from this pool, so
+    // the server itself aborts a runaway query and frees the connection cleanly.
+    const serverOptions = [`-c statement_timeout=${resolveQueryDeadlineMs(merged)}`];
     if (searchPathSchemas.length > 0) {
-        config.options = `-c search_path=${searchPathSchemas.join(',')}`;
+        serverOptions.unshift(`-c search_path=${searchPathSchemas.join(',')}`);
     }
+    config.options = serverOptions.join(' ');
     if (merged.ssl && sslmode !== 'prefer' && sslmode !== 'disable') {
         config.ssl = { rejectUnauthorized: merged.rejectUnauthorized ?? true };
     }
@@ -195,7 +204,8 @@ export class KtxPostgresScanConnector {
     poolFactory;
     endpointResolver;
     now;
-    dialect = getDialectForDriver('postgres');
+    deadlineMs;
+    dialect = getSqlDialectForDriver('postgres');
     pool = null;
     lastIdlePoolError = null;
     resolvedEndpoint = null;
@@ -210,6 +220,7 @@ export class KtxPostgresScanConnector {
         this.poolFactory = options.poolFactory ?? new DefaultPostgresPoolFactory();
         this.endpointResolver = options.endpointResolver;
         this.now = options.now ?? (() => new Date());
+        this.deadlineMs = resolveQueryDeadlineMs(this.connection);
         this.id = `postgres:${options.connectionId}`;
     }
     async testConnection() {
@@ -533,6 +544,12 @@ export class KtxPostgresScanConnector {
                 rowCount: result.rows.length,
             };
         }
+        catch (error) {
+            if (isPostgresTimeoutError(error)) {
+                throw queryDeadlineExceededError(this.deadlineMs, { cause: error });
+            }
+            throw error;
+        }
         finally {
             client.release();
         }

package/dist/connectors/postgres/dialect.d.ts

@@ -1,8 +1,8 @@
-import type { KtxDialect } from '../../context/connections/dialects.js';
+import type { KtxSqlDialect } from '../../context/connections/dialects.js';
 import type { KtxSchemaDimensionType, KtxTableRef } from '../../context/scan/types.js';
 type PostgresTableNameRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
 /** @internal */
-export declare class KtxPostgresDialect implements KtxDialect {
+export declare class KtxPostgresDialect implements KtxSqlDialect {
     readonly type: "postgres";
     private readonly typeMappings;
     quoteIdentifier(identifier: string): string;

package/dist/connectors/snowflake/connector.d.ts

@@ -27,6 +27,7 @@ export interface KtxSnowflakeResolvedConnectionConfig {
     passphrase?: string;
     role?: string;
     maxConnections: number;
+    deadlineMs: number;
 }
 export interface KtxSnowflakeRawColumnMetadata {
     name: string;

package/dist/connectors/snowflake/connector.js

@@ -1,5 +1,6 @@
 import { createPrivateKey } from 'node:crypto';
-import { getDialectForDriver } from '../../context/connections/dialects.js';
+import { getSqlDialectForDriver } from '../../context/connections/dialects.js';
+import { resolveQueryDeadlineMs, queryDeadlineExceededError } from '../../context/connections/query-deadline.js';
 import { resolveStringReference } from '../shared/string-reference.js';
 import { assertReadOnlySql, limitSqlForExecution } from '../../context/connections/read-only-sql.js';
 import { tryConstraintQuery } from '../../context/scan/constraint-discovery.js';
@@ -43,6 +44,19 @@ function isDeniedError(error) {
     }
     return false;
 }
+// Snowflake cancels with code 604 and a "reached its statement ... timeout"
+// message once STATEMENT_TIMEOUT_IN_SECONDS elapses.
+function isSnowflakeTimeoutError(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const code = error.code;
+    const message = error.message;
+    return (code === 604 ||
+        code === '604' ||
+        code === '000604' ||
+        (typeof message === 'string' && /reached its (statement|warehouse) .*timeout/i.test(message)));
+}
 function normalizeSnowflakeValue(value, columnType) {
     if (columnType && DATE_TYPES.some((type) => columnType.toUpperCase().includes(type))) {
         if (typeof value === 'number') {
@@ -131,6 +145,7 @@ export function snowflakeConnectionConfigFromConfig(input) {
             connectionId: input.connectionId,
             defaultValue: 4,
         }),
+        deadlineMs: resolveQueryDeadlineMs(input.connection),
     };
     const role = stringConfigValue(input.connection, 'role', env);
     if (role) {
@@ -178,12 +193,21 @@ class SnowflakeSdkDriver {
     }
     async query(sql, params) {
         const binds = Array.isArray(params) ? toSnowflakeBinds(params) : undefined;
+        const statementTimeoutSeconds = Math.ceil(this.resolved.deadlineMs / 1000);
         try {
             const pool = await this.getPool();
-            const result = await pool.use(async (connection) => this.executeSnowflakeQuery(connection, sql, binds));
+            const result = await pool.use(async (connection) => {
+                // Bound the statement server-side; Snowflake cancels and frees the
+                // warehouse slot when STATEMENT_TIMEOUT_IN_SECONDS is reached.
+                await this.executeSnowflakeQuery(connection, `ALTER SESSION SET STATEMENT_TIMEOUT_IN_SECONDS = ${statementTimeoutSeconds}`);
+                return this.executeSnowflakeQuery(connection, sql, binds);
+            });
             return { ...result, totalRows: result.rows.length, rowCount: result.rows.length };
         }
         catch (error) {
+            if (isSnowflakeTimeoutError(error)) {
+                throw queryDeadlineExceededError(this.resolved.deadlineMs, { cause: error });
+            }
             const message = error instanceof Error ? error.message : String(error);
             if (/timeout/i.test(message) && /pool|acquire/i.test(message)) {
                 throw new Error("Snowflake session pool exhausted after 60s - consider lowering maxConnections or increasing your account's concurrent-statement limit.");
@@ -355,7 +379,7 @@ export class KtxSnowflakeScanConnector {
     });
     resolved;
     driverFactory;
-    dialect = getDialectForDriver('snowflake');
+    dialect = getSqlDialectForDriver('snowflake');
     now;
     driverInstance = null;
     constructor(options) {

package/dist/connectors/snowflake/dialect.d.ts

@@ -1,8 +1,8 @@
-import type { KtxDialect } from '../../context/connections/dialects.js';
+import type { KtxSqlDialect } from '../../context/connections/dialects.js';
 import type { KtxSchemaDimensionType, KtxTableRef } from '../../context/scan/types.js';
 type SnowflakeTableNameRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
 /** @internal */
-export declare class KtxSnowflakeDialect implements KtxDialect {
+export declare class KtxSnowflakeDialect implements KtxSqlDialect {
     readonly type: "snowflake";
     private readonly typeMappings;
     quoteIdentifier(identifier: string): string;

package/dist/connectors/sqlite/connector.d.ts

@@ -1,11 +1,15 @@
+import { type ChildProcess } from 'node:child_process';
 import { type KtxConnectorTestResult, type KtxColumnSampleInput, type KtxColumnSampleResult, type KtxColumnStatsInput, type KtxColumnStatsResult, type KtxQueryResult, type KtxReadOnlyQueryInput, type KtxScanConnector, type KtxScanContext, type KtxScanInput, type KtxSchemaSnapshot, type KtxTableListEntry, type KtxTableRef, type KtxTableSampleInput, type KtxTableSampleResult } from '../../context/scan/types.js';
 export interface KtxSqliteConnectionConfig {
     driver?: string;
     path?: string;
     url?: string;
+    query_timeout_ms?: number;
     [key: string]: unknown;
 }
 /** @internal */
+export declare function forkReadQueryChild(): ChildProcess;
+/** @internal */
 export interface SqliteDatabasePathInput {
     connectionId: string;
     projectDir?: string;
@@ -13,6 +17,8 @@ export interface SqliteDatabasePathInput {
 }
 export interface KtxSqliteScanConnectorOptions extends SqliteDatabasePathInput {
     now?: () => Date;
+    /** @internal Test seam: spawn the read-query child so tests can observe its lifecycle. */
+    spawnReadQueryChild?: () => ChildProcess;
 }
 export interface KtxSqliteReadOnlyQueryInput extends KtxReadOnlyQueryInput {
     params?: Record<string, unknown> | unknown[];
@@ -36,6 +42,8 @@ export declare class KtxSqliteScanConnector implements KtxScanConnector {
     private readonly connectionId;
     private readonly dbPath;
     private readonly now;
+    private readonly deadlineMs;
+    private readonly spawnReadQueryChild;
     private readonly dialect;
     private db;
     constructor(options: KtxSqliteScanConnectorOptions);
@@ -46,7 +54,8 @@ export declare class KtxSqliteScanConnector implements KtxScanConnector {
     sampleTable(input: KtxTableSampleInput, _ctx: KtxScanContext): Promise<KtxTableSampleResult>;
     sampleColumn(input: KtxColumnSampleInput, _ctx: KtxScanContext): Promise<KtxColumnSampleResult>;
     columnStats(_input: KtxColumnStatsInput, _ctx: KtxScanContext): Promise<KtxColumnStatsResult | null>;
-    executeReadOnly(input: KtxSqliteReadOnlyQueryInput, _ctx: KtxScanContext): Promise<KtxQueryResult>;
+    executeReadOnly(input: KtxSqliteReadOnlyQueryInput, ctx: KtxScanContext): Promise<KtxQueryResult>;
+    private runReadQueryOffProcess;
     getColumnDistinctValues(table: KtxTableRef, columnName: string, options: KtxSqliteColumnDistinctValuesOptions): Promise<KtxSqliteColumnDistinctValuesResult | null>;
     getTableRowCount(tableName: string): Promise<number>;
     qTableName(table: Pick<KtxTableRef, 'name'>): string;
@@ -55,6 +64,7 @@ export declare class KtxSqliteScanConnector implements KtxScanConnector {
     private database;
     private query;
     private readTable;
+    private readRowCount;
     private mapForeignKeys;
     private assertConnection;
 }

package/dist/connectors/sqlite/connector.js

@@ -3,11 +3,29 @@ import { existsSync, readFileSync, statSync } from 'node:fs';
 import { homedir } from 'node:os';
 import { isAbsolute, resolve } from 'node:path';
 import { fileURLToPath } from 'node:url';
-import { getDialectForDriver } from '../../context/connections/dialects.js';
+import { fork } from 'node:child_process';
+import { getSqlDialectForDriver } from '../../context/connections/dialects.js';
+import { resolveQueryDeadlineMs, queryDeadlineExceededError } from '../../context/connections/query-deadline.js';
 import { assertReadOnlySql, limitSqlForExecution } from '../../context/connections/read-only-sql.js';
 import { normalizeQueryRows } from '../../context/connections/query-executor.js';
 import { connectorTestFailure, createKtxConnectorCapabilities } from '../../context/scan/types.js';
 import { scopedTableNames } from '../../context/scan/table-ref.js';
+import { tryIntrospectObject } from '../../context/scan/object-introspection.js';
+// In dist, connector.js and read-query-child.js are siblings; under vitest the
+// compiled .js is absent and Node strips types from the .ts when forking it.
+const readQueryChildUrl = existsSync(fileURLToPath(new URL('./read-query-child.js', import.meta.url)))
+    ? new URL('./read-query-child.js', import.meta.url)
+    : new URL('./read-query-child.ts', import.meta.url);
+/** @internal */
+export function forkReadQueryChild() {
+    // Empty execArgv so the child is a clean Node process (no inherited vitest /
+    // inspector flags); advanced serialization preserves BigInt/Buffer in rows.
+    return fork(readQueryChildUrl, {
+        execArgv: [],
+        serialization: 'advanced',
+        stdio: ['ignore', 'ignore', 'inherit', 'ipc'],
+    });
+}
 function stringConfigValue(connection, key) {
     const value = connection?.[key];
     return typeof value === 'string' && value.trim().length > 0 ? resolveStringReference(key, value.trim()) : undefined;
@@ -66,12 +84,16 @@ export class KtxSqliteScanConnector {
     connectionId;
     dbPath;
     now;
-    dialect = getDialectForDriver('sqlite');
+    deadlineMs;
+    spawnReadQueryChild;
+    dialect = getSqlDialectForDriver('sqlite');
     db = null;
     constructor(options) {
         this.connectionId = options.connectionId;
         this.dbPath = sqliteDatabasePathFromConfig(options);
         this.now = options.now ?? (() => new Date());
+        this.deadlineMs = resolveQueryDeadlineMs(options.connection);
+        this.spawnReadQueryChild = options.spawnReadQueryChild ?? forkReadQueryChild;
         this.id = `sqlite:${options.connectionId}`;
     }
     async testConnection() {
@@ -89,14 +111,24 @@ export class KtxSqliteScanConnector {
     async introspect(input, _ctx) {
         this.assertConnection(input.connectionId);
         const database = this.database();
-        const scopedNames = input.tableScope ? scopedTableNames(input.tableScope, { catalog: null, db: null }) : null;
-        const scopeClause = scopedNames ? `AND name IN (${scopedNames.map(() => '?').join(', ')})` : '';
-        const rawTables = scopedNames && scopedNames.length === 0
-            ? []
-            : database
-                .prepare(`SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' ${scopeClause} ORDER BY name`)
-                .all(...(scopedNames ?? []));
-        const tables = rawTables.map((table) => this.readTable(database, table));
+        const allObjects = database
+            .prepare(`SELECT name, type FROM sqlite_master WHERE type IN ('table', 'view') AND name NOT LIKE 'sqlite_%' ORDER BY name`)
+            .all();
+        const scopedNames = input.tableScope
+            ? new Set(scopedTableNames(input.tableScope, { catalog: null, db: null }))
+            : null;
+        const selectedObjects = scopedNames ? allObjects.filter((object) => scopedNames.has(object.name)) : allObjects;
+        const tables = [];
+        const warnings = [];
+        for (const object of selectedObjects) {
+            const outcome = await tryIntrospectObject({ object: object.name }, () => this.readTable(database, object));
+            if (outcome.ok) {
+                tables.push(outcome.table);
+            }
+            else {
+                warnings.push(outcome.warning);
+            }
+        }
         const fileStats = existsSync(this.dbPath) ? statSync(this.dbPath) : null;
         return {
             connectionId: this.connectionId,
@@ -108,8 +140,12 @@ export class KtxSqliteScanConnector {
                 file_size: fileStats ? fileStats.size : 0,
                 table_count: tables.length,
                 total_columns: tables.reduce((sum, table) => sum + table.columns.length, 0),
+                // Carries the full object inventory so a zero-match enabled_tables scope
+                // can report which objects were actually available.
+                ...(scopedNames ? { discovered_object_names: allObjects.map((object) => object.name) } : {}),
             },
             tables,
+            ...(warnings.length > 0 ? { warnings } : {}),
         };
     }
     async listSchemas() {
@@ -146,11 +182,71 @@ export class KtxSqliteScanConnector {
     async columnStats(_input, _ctx) {
         return null;
     }
-    async executeReadOnly(input, _ctx) {
+    async executeReadOnly(input, ctx) {
         this.assertConnection(input.connectionId);
-        const result = this.query(limitSqlForExecution(input.sql, input.maxRows), input.params);
+        // Validate and row-limit on the main thread so invalid SQL fails instantly
+        // without spawning a process and read-only enforcement stays at the boundary.
+        const sql = limitSqlForExecution(input.sql, input.maxRows);
+        const result = await this.runReadQueryOffProcess(sql, input.params, ctx.signal);
         return { ...result, rowCount: result.rows.length };
     }
+    // The LLM-SQL path runs off the event loop in a short-lived child process so a
+    // pathological scan cannot freeze the MCP server, and the deadline is enforced
+    // by SIGKILL-ing that process. A synchronous better-sqlite3 scan never yields,
+    // so a worker-thread terminate cannot interrupt it — only the OS reclaiming the
+    // whole process frees the CPU. One short-lived process per call; killed on
+    // completion, deadline, or external abort.
+    runReadQueryOffProcess(sql, params, signal) {
+        const deadlineMs = this.deadlineMs;
+        const dbPath = this.dbPath;
+        return new Promise((resolvePromise, rejectPromise) => {
+            const child = this.spawnReadQueryChild();
+            let settled = false;
+            const onDeadline = () => settle(() => rejectPromise(queryDeadlineExceededError(deadlineMs)));
+            const timer = setTimeout(onDeadline, deadlineMs);
+            function settle(finish) {
+                if (settled) {
+                    return;
+                }
+                settled = true;
+                clearTimeout(timer);
+                signal?.removeEventListener('abort', onDeadline);
+                if (child.exitCode === null && child.signalCode === null) {
+                    child.kill('SIGKILL');
+                }
+                finish();
+            }
+            child.on('message', (message) => {
+                if (message.ok) {
+                    settle(() => resolvePromise({
+                        headers: message.headers,
+                        rows: normalizeQueryRows(message.rows),
+                        totalRows: message.totalRows,
+                    }));
+                }
+                else {
+                    settle(() => rejectPromise(new Error(message.message)));
+                }
+            });
+            child.on('error', (error) => settle(() => rejectPromise(error)));
+            child.on('exit', (code, processSignal) => {
+                if (!settled) {
+                    settle(() => rejectPromise(new Error(`SQLite read process exited before returning a result (code ${code}, signal ${processSignal}).`)));
+                }
+            });
+            if (signal?.aborted) {
+                onDeadline();
+                return;
+            }
+            signal?.addEventListener('abort', onDeadline, { once: true });
+            try {
+                child.send({ dbPath, sql, params });
+            }
+            catch (error) {
+                settle(() => rejectPromise(error instanceof Error ? error : new Error(String(error))));
+            }
+        });
+    }
     async getColumnDistinctValues(table, columnName, options) {
         const sampleSize = options.sampleSize ?? 10000;
         const tableName = this.qTableName(table);
@@ -213,11 +309,7 @@ export class KtxSqliteScanConnector {
         const foreignKeys = database
             .prepare(`PRAGMA foreign_key_list(${this.dialect.quoteIdentifier(table.name)})`)
             .all();
-        const estimatedRows = table.type === 'table'
-            ? Number(database
-                .prepare(`SELECT COUNT(*) AS count FROM ${this.dialect.quoteIdentifier(table.name)}`)
-                .get().count)
-            : null;
+        const estimatedRows = table.type === 'table' ? this.readRowCount(database, table.name) : null;
         return {
             catalog: null,
             db: null,
@@ -237,6 +329,17 @@ export class KtxSqliteScanConnector {
             foreignKeys: this.mapForeignKeys(foreignKeys),
         };
     }
+    // A row-count read is profiling, not structure: a failure here leaves the
+    // object's structure intact rather than skipping the whole object.
+    readRowCount(database, name) {
+        try {
+            const row = database.prepare(`SELECT COUNT(*) AS count FROM ${this.dialect.quoteIdentifier(name)}`).get();
+            return Number(row.count);
+        }
+        catch {
+            return null;
+        }
+    }
     mapForeignKeys(rows) {
         return rows
             .sort((a, b) => a.id - b.id || a.seq - b.seq)

package/dist/connectors/sqlite/dialect.d.ts

@@ -1,8 +1,8 @@
-import type { KtxDialect } from '../../context/connections/dialects.js';
+import type { KtxSqlDialect } from '../../context/connections/dialects.js';
 import type { KtxSchemaDimensionType, KtxTableRef } from '../../context/scan/types.js';
 type SqliteTableNameRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
 /** @internal */
-export declare class KtxSqliteDialect implements KtxDialect {
+export declare class KtxSqliteDialect implements KtxSqlDialect {
     readonly type: "sqlite";
     private readonly typeMappings;
     quoteIdentifier(identifier: string): string;

package/dist/connectors/sqlite/read-query-child.d.ts

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

package/dist/connectors/sqlite/read-query-child.js

@@ -0,0 +1,23 @@
+import Database from 'better-sqlite3';
+process.once('message', (request) => {
+    let db;
+    let response;
+    try {
+        db = new Database(request.dbPath, { readonly: true, fileMustExist: true });
+        const statement = db.prepare(request.sql);
+        const rows = (request.params ? statement.all(request.params) : statement.all());
+        response = {
+            ok: true,
+            headers: statement.columns().map((column) => column.name),
+            rows,
+            totalRows: rows.length,
+        };
+    }
+    catch (error) {
+        response = { ok: false, message: error instanceof Error ? error.message : String(error) };
+    }
+    finally {
+        db?.close();
+    }
+    process.send?.(response, () => process.exit(0));
+});

package/dist/connectors/sqlserver/connector.d.ts

@@ -20,6 +20,7 @@ export interface KtxSqlServerPoolConfig {
     database: string;
     user: string;
     password?: string;
+    requestTimeout: number;
     options: {
         encrypt: true;
         trustServerCertificate: boolean;
@@ -109,6 +110,7 @@ export declare class KtxSqlServerScanConnector implements KtxScanConnector {
     private readonly poolFactory;
     private readonly endpointResolver?;
     private readonly now;
+    private readonly deadlineMs;
     private readonly dialect;
     private pool;
     private resolvedEndpoint;

package/dist/connectors/sqlserver/connector.js

@@ -1,5 +1,6 @@
 import { assertReadOnlySql, hoistLeadingCte, stripTrailingSqlNoise } from '../../context/connections/read-only-sql.js';
-import { getDialectForDriver } from '../../context/connections/dialects.js';
+import { getSqlDialectForDriver } from '../../context/connections/dialects.js';
+import { resolveQueryDeadlineMs, queryDeadlineExceededError } from '../../context/connections/query-deadline.js';
 import { tryConstraintQuery } from '../../context/scan/constraint-discovery.js';
 import { scopedTableNames } from '../../context/scan/table-ref.js';
 import { connectorTestFailure, createKtxConnectorCapabilities, } from '../../context/scan/types.js';
@@ -128,6 +129,10 @@ function isDeniedError(error) {
     const number = error.number;
     return number === 229 || number === 230 || number === 297;
 }
+// mssql raises a RequestError with code 'ETIMEOUT' once requestTimeout elapses.
+function isSqlServerTimeoutError(error) {
+    return Boolean(error) && typeof error === 'object' && error.code === 'ETIMEOUT';
+}
 function limitSqlForSqlServerExecution(sqlText, maxRows) {
     const trimmed = stripTrailingSqlNoise(assertReadOnlySql(sqlText));
     if (!maxRows) {
@@ -176,6 +181,7 @@ export function sqlServerConnectionPoolConfigFromConfig(input) {
         database,
         user,
         password: stringConfigValue(merged, 'password', env),
+        requestTimeout: resolveQueryDeadlineMs(merged),
         options: { encrypt: true, trustServerCertificate: merged.trustServerCertificate ?? true },
         pool: { max: maxConnections, min: 0, idleTimeoutMillis: 30000 },
     };
@@ -199,7 +205,8 @@ export class KtxSqlServerScanConnector {
     poolFactory;
     endpointResolver;
     now;
-    dialect = getDialectForDriver('sqlserver');
+    deadlineMs;
+    dialect = getSqlDialectForDriver('sqlserver');
     pool = null;
     resolvedEndpoint = null;
     constructor(options) {
@@ -215,6 +222,7 @@ export class KtxSqlServerScanConnector {
         this.poolFactory = options.poolFactory ?? new DefaultSqlServerPoolFactory();
         this.endpointResolver = options.endpointResolver;
         this.now = options.now ?? (() => new Date());
+        this.deadlineMs = resolveQueryDeadlineMs(this.connection);
         this.id = `sqlserver:${options.connectionId}`;
     }
     async testConnection() {
@@ -548,7 +556,16 @@ export class KtxSqlServerScanConnector {
                 request.input(key, value);
             }
         }
-        const result = await request.query(assertReadOnlySql(query));
+        let result;
+        try {
+            result = await request.query(assertReadOnlySql(query));
+        }
+        catch (error) {
+            if (isSqlServerTimeoutError(error)) {
+                throw queryDeadlineExceededError(this.deadlineMs, { cause: error });
+            }
+            throw error;
+        }
         const recordset = result.recordset ?? [];
         const columnMetadata = recordset.columns ?? {};
         const metadataHeaders = Object.keys(columnMetadata);

package/dist/connectors/sqlserver/dialect.d.ts

@@ -1,8 +1,8 @@
-import type { KtxDialect } from '../../context/connections/dialects.js';
+import type { KtxSqlDialect } from '../../context/connections/dialects.js';
 import type { KtxSchemaDimensionType, KtxTableRef } from '../../context/scan/types.js';
 type SqlServerTableNameRef = Pick<KtxTableRef, 'name'> & Partial<Pick<KtxTableRef, 'catalog' | 'db'>>;
 /** @internal */
-export declare class KtxSqlServerDialect implements KtxDialect {
+export declare class KtxSqlServerDialect implements KtxSqlDialect {
     readonly type: "sqlserver";
     private readonly typeMappings;
     quoteIdentifier(identifier: string): string;

package/dist/context/cache/content-result-cache.d.ts

@@ -0,0 +1,36 @@
+type ContentCacheMetadata = Record<string, unknown>;
+export interface ContentResultCacheLookup {
+    namespace: string;
+    scopeKey: string;
+    inputHash: string;
+}
+export interface ContentResultCacheCompleted<TOutput = unknown> extends ContentResultCacheLookup {
+    runId: string;
+    status: 'completed';
+    output: TOutput;
+    errorMessage: null;
+    metadata: ContentCacheMetadata;
+    updatedAt: string;
+}
+export interface ContentResultCacheFailed extends ContentResultCacheLookup {
+    runId: string;
+    status: 'failed';
+    output: null;
+    errorMessage: string;
+    metadata: ContentCacheMetadata;
+    updatedAt: string;
+}
+export type ContentResultCacheRecord<TOutput = unknown> = ContentResultCacheCompleted<TOutput> | ContentResultCacheFailed;
+export interface ContentResultCache {
+    findCompletedResult<TOutput = unknown>(input: ContentResultCacheLookup): Promise<ContentResultCacheCompleted<TOutput> | null>;
+    findLatestCompletedResult(input: {
+        namespace: string;
+        scopeKey: string;
+    }): Promise<ContentResultCacheCompleted | null>;
+    saveCompletedResult<TOutput = unknown>(input: Omit<ContentResultCacheCompleted<TOutput>, 'status' | 'errorMessage'>): Promise<void>;
+    saveFailedResult(input: Omit<ContentResultCacheFailed, 'status' | 'output'>): Promise<void>;
+    deleteResult(input: ContentResultCacheLookup): Promise<void>;
+    listRunResults(runId: string): Promise<ContentResultCacheRecord[]>;
+}
+export declare function stableContentHash(value: unknown): string;
+export {};

package/dist/context/cache/content-result-cache.js

@@ -0,0 +1,14 @@
+import { createHash } from 'node:crypto';
+function stableJson(value) {
+    if (Array.isArray(value)) {
+        return `[${value.map(stableJson).join(',')}]`;
+    }
+    if (value && typeof value === 'object') {
+        const entries = Object.entries(value).sort(([left], [right]) => left.localeCompare(right));
+        return `{${entries.map(([key, item]) => `${JSON.stringify(key)}:${stableJson(item)}`).join(',')}}`;
+    }
+    return JSON.stringify(value) ?? 'undefined';
+}
+export function stableContentHash(value) {
+    return createHash('sha256').update(stableJson(value)).digest('hex');
+}

package/dist/context/cache/sqlite-content-result-cache.d.ts

@@ -0,0 +1,18 @@
+import type { ContentResultCache, ContentResultCacheCompleted, ContentResultCacheFailed, ContentResultCacheLookup, ContentResultCacheRecord } from './content-result-cache.js';
+export interface SqliteContentResultCacheOptions {
+    dbPath: string;
+}
+export declare class SqliteContentResultCache implements ContentResultCache {
+    private readonly db;
+    constructor(options: SqliteContentResultCacheOptions);
+    private dropResultsTableIfPrimaryKeyDiffers;
+    findCompletedResult<TOutput = unknown>(input: ContentResultCacheLookup): Promise<ContentResultCacheCompleted<TOutput> | null>;
+    findLatestCompletedResult(input: {
+        namespace: string;
+        scopeKey: string;
+    }): Promise<ContentResultCacheCompleted | null>;
+    saveCompletedResult<TOutput = unknown>(input: Omit<ContentResultCacheCompleted<TOutput>, 'status' | 'errorMessage'>): Promise<void>;
+    saveFailedResult(input: Omit<ContentResultCacheFailed, 'status' | 'output'>): Promise<void>;
+    deleteResult(input: ContentResultCacheLookup): Promise<void>;
+    listRunResults(runId: string): Promise<ContentResultCacheRecord[]>;
+}