@telorun/sql 0.7.2 → 0.8.0

package/README.md

@@ -55,8 +55,8 @@ metadata:
     A complete feedback collection REST API — no code, pure YAML.
     Persists entries to SQLite and serves them over HTTP.
 imports:
-  Http: std/http-server@0.11.0
-  Sql: std/sql@0.9.0
+  Http: std/http-server@0.12.0
+  Sql: std/sql@0.9.2
 targets:
   - !ref Migrations
   - !ref Server

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { SqlConnectionResource, createSqlConnection, type SqlDriver, type PlaceholderStyle, } from "./sql-connection-controller.js";
+export { resolveSqlConnection } from "./sql-connection-ref.js";
+export type { SqliteDb, SqliteStatement } from "./sqlite-driver-interface.js";

package/dist/index.js

@@ -0,0 +1,2 @@
+export { SqlConnectionResource, createSqlConnection, } from "./sql-connection-controller.js";
+export { resolveSqlConnection } from "./sql-connection-ref.js";

package/dist/{sql-exec-controller.d.ts → sql-command-controller.d.ts}

@@ -2,7 +2,7 @@ import type { ResourceContext, ResourceInstance } from "@telorun/sdk";
 import type { SqlConnectionResource } from "./sql-connection-controller.js";
 import type { SqlResult } from "./sql-query-controller.js";
 import type { SqlTransactionResource } from "./sql-transaction-controller.js";
-interface SqlExecManifest {
+interface SqlCommandManifest {
     metadata: {
         name: string;
         module: string;
@@ -14,12 +14,12 @@ interface SqlExecManifest {
         bindings?: unknown[];
     };
 }
-declare class SqlExecResource implements ResourceInstance {
+declare class SqlCommandResource implements ResourceInstance {
     private readonly manifest;
     private readonly ctx;
-    constructor(manifest: SqlExecManifest, ctx: ResourceContext);
+    constructor(manifest: SqlCommandManifest, ctx: ResourceContext);
     invoke(input: unknown): Promise<SqlResult>;
 }
 export declare function register(): void;
-export declare function create(resource: SqlExecManifest, ctx: ResourceContext): Promise<SqlExecResource>;
+export declare function create(resource: SqlCommandManifest, ctx: ResourceContext): Promise<SqlCommandResource>;
 export {};

package/dist/{sql-exec-controller.js → sql-command-controller.js}

@@ -1,6 +1,6 @@
 import { resolveSqlConnection } from "./sql-connection-ref.js";
 import { runSql } from "./sql-run.js";
-class SqlExecResource {
+class SqlCommandResource {
     manifest;
     ctx;
     constructor(manifest, ctx) {
@@ -20,5 +20,5 @@ class SqlExecResource {
 }
 export function register() { }
 export async function create(resource, ctx) {
-    return new SqlExecResource(resource, ctx);
+    return new SqlCommandResource(resource, ctx);
 }

package/dist/sql-connection-controller.d.ts

@@ -2,27 +2,22 @@ import type { ResourceInstance } from "@telorun/sdk";
 import { Kysely, type QueryResult } from "kysely";
 import type { SqlTransactionResource } from "./sql-transaction-controller.js";
 import type { SqliteDb } from "./sqlite-driver-interface.js";
-interface PoolConfig {
-    min?: number;
-    max?: number;
-    idleTimeoutMs?: number;
-    connectionTimeoutMs?: number;
-}
 export type SqlDriver = "postgres" | "sqlite";
 /** Native bind-placeholder syntax per driver: SQLite binds anonymous `?`,
  *  PostgreSQL binds numbered `$1`, `$2`, … */
 export type PlaceholderStyle = "qmark" | "numbered";
-export interface SqlConnectionConfig {
-    driver: SqlDriver;
-    /** Required for `postgres`; ignored for `sqlite` (which opens via `sqlite`). */
-    connectionString?: string;
-    pool?: PoolConfig;
-}
+/**
+ * Driver-agnostic SQL connection. The kysely instance (and, for SQLite, the
+ * underlying database handle used by `executeScript`) is built by the driver
+ * backend (`sql-postgres`, `sql-sqlite`) and handed in via
+ * {@link createSqlConnection}. Everything here — execution, transactions,
+ * placeholder style, row-count normalization — is transport-neutral.
+ */
 export declare class SqlConnectionResource implements ResourceInstance {
     readonly driver: SqlDriver;
     private readonly db;
     private readonly sqlite?;
-    constructor(config: SqlConnectionConfig, sqlite?: SqliteDb);
+    constructor(driver: SqlDriver, db: Kysely<any>, sqlite?: SqliteDb);
     init(): Promise<void>;
     teardown(): Promise<void>;
     transaction<T>(cb: () => Promise<T>): Promise<T>;
@@ -39,5 +34,10 @@ export declare class SqlConnectionResource implements ResourceInstance {
     snapshot(): Record<string, unknown>;
     private resolveExecutor;
 }
-export declare function openSqliteDatabase(file?: string): Promise<SqliteDb>;
-export {};
+/**
+ * Build a connection from a driver-constructed kysely instance. Driver backends
+ * (`sql-postgres`, `sql-sqlite`) own dialect construction and call this; the
+ * `sqlite` handle is required only for SQLite (its `executeScript` runs through
+ * the native handle).
+ */
+export declare function createSqlConnection(driver: SqlDriver, db: Kysely<any>, sqlite?: SqliteDb): SqlConnectionResource;

package/dist/sql-connection-controller.js

@@ -1,44 +1,21 @@
 import { randomUUID } from "crypto";
-import { CompiledQuery, Kysely, PostgresDialect, SqliteAdapter, SqliteDialect, } from "kysely";
-import { Pool } from "pg";
+import { CompiledQuery } from "kysely";
 import { currentTxId, deleteTx, getTx, setTx, txStorage } from "./transaction-store.js";
+/**
+ * Driver-agnostic SQL connection. The kysely instance (and, for SQLite, the
+ * underlying database handle used by `executeScript`) is built by the driver
+ * backend (`sql-postgres`, `sql-sqlite`) and handed in via
+ * {@link createSqlConnection}. Everything here — execution, transactions,
+ * placeholder style, row-count normalization — is transport-neutral.
+ */
 export class SqlConnectionResource {
     driver;
     db;
     sqlite;
-    constructor(config, sqlite) {
-        this.driver = config.driver;
-        if (this.driver === "postgres") {
-            if (!config.connectionString) {
-                throw new Error("Sql: postgres connection requires a connectionString");
-            }
-            const url = new URL(config.connectionString);
-            const ssl = sslFromSslmode(url.searchParams.get("sslmode"));
-            url.searchParams.delete("sslmode");
-            this.db = new Kysely({
-                dialect: new PostgresDialect({
-                    pool: new Pool({
-                        connectionString: url.toString(),
-                        ssl,
-                        min: config.pool?.min ?? 1,
-                        max: config.pool?.max ?? 10,
-                        idleTimeoutMillis: config.pool?.idleTimeoutMs,
-                        connectionTimeoutMillis: config.pool?.connectionTimeoutMs,
-                    }),
-                }),
-            });
-        }
-        else {
-            if (!sqlite) {
-                throw new Error("Sql: sqlite database was not initialized");
-            }
-            this.sqlite = sqlite;
-            this.db = new Kysely({
-                dialect: new TransactionalSqliteDialect({
-                    database: this.sqlite,
-                }),
-            });
-        }
+    constructor(driver, db, sqlite) {
+        this.driver = driver;
+        this.db = db;
+        this.sqlite = sqlite;
     }
     async init() {
         await this.db.connection().execute(async () => {
@@ -113,57 +90,12 @@ export class SqlConnectionResource {
         return this.db;
     }
 }
-// Kysely's stock SQLite adapter reports `supportsTransactionalDdl = false`, so
-// its Migrator runs migrations without a transaction. SQLite does support
-// transactional DDL, so we flip the flag — letting the Migrator wrap the whole
-// migration batch in a single transaction, matching PostgreSQL.
-class TransactionalSqliteAdapter extends SqliteAdapter {
-    get supportsTransactionalDdl() {
-        return true;
-    }
-}
-class TransactionalSqliteDialect extends SqliteDialect {
-    createAdapter() {
-        return new TransactionalSqliteAdapter();
-    }
-}
-function sslFromSslmode(mode) {
-    switch (mode) {
-        case null:
-        case "disable":
-            return false;
-        case "require":
-            return { rejectUnauthorized: false };
-        case "verify-ca":
-            // libpq `verify-ca` validates the CA chain but not the hostname; Node's
-            // default `checkServerIdentity` enforces the hostname, so disable it.
-            return { rejectUnauthorized: true, checkServerIdentity: () => undefined };
-        case "verify-full":
-            return { rejectUnauthorized: true };
-        default:
-            throw new Error(`Sql.Connection: unsupported sslmode '${mode}'. ` +
-                `Use 'disable', 'require', 'verify-ca', or 'verify-full'.`);
-    }
-}
-export async function openSqliteDatabase(file = ":memory:") {
-    // Auto-create the parent directory for file-backed databases. SQLite
-    // drivers fail-fast when the directory doesn't exist; mirroring `mkdir
-    // -p` here lets manifests use paths like `./tmp/foo.sqlite` without a
-    // separate filesystem-prep step. `:memory:` skips filesystem entirely.
-    if (file !== ":memory:") {
-        const { mkdir } = await import("node:fs/promises");
-        const { dirname } = await import("node:path");
-        const dir = dirname(file);
-        if (dir && dir !== "." && dir !== "/") {
-            await mkdir(dir, { recursive: true });
-        }
-    }
-    // Route through the package's own `./sqlite-driver` subpath export so the
-    // resolver selects the driver per runtime (Bun → bun:sqlite, Node →
-    // better-sqlite3). A manual `typeof Bun` check with relative imports gets
-    // flattened by the controller bundler into an unconditional top-level
-    // `import "bun:sqlite"`, which Node's ESM loader rejects before the guard
-    // runs; an external `@telorun/*` specifier stays a deferred dynamic import.
-    const { openDatabase } = await import("@telorun/sql/sqlite-driver");
-    return openDatabase(file);
+/**
+ * Build a connection from a driver-constructed kysely instance. Driver backends
+ * (`sql-postgres`, `sql-sqlite`) own dialect construction and call this; the
+ * `sqlite` handle is required only for SQLite (its `executeScript` runs through
+ * the native handle).
+ */
+export function createSqlConnection(driver, db, sqlite) {
+    return new SqlConnectionResource(driver, db, sqlite);
 }

package/dist/{sql-select-controller.d.ts → sql-selection-controller.d.ts}

@@ -58,12 +58,12 @@ interface SelectManifest {
     offset?: unknown;
     inputType?: string | Record<string, any>;
 }
-declare class SqlSelectResource implements ResourceInstance {
+declare class SqlSelectionResource implements ResourceInstance {
     private readonly manifest;
     private readonly ctx;
     constructor(manifest: SelectManifest, ctx: ResourceContext);
     invoke(input: unknown): Promise<SqlResult>;
 }
 export declare function register(): void;
-export declare function create(resource: SelectManifest, ctx: ResourceContext): Promise<SqlSelectResource>;
+export declare function create(resource: SelectManifest, ctx: ResourceContext): Promise<SqlSelectionResource>;
 export {};

package/dist/{sql-select-controller.js → sql-selection-controller.js}

@@ -1,6 +1,6 @@
 import { resolveSqlConnection } from "./sql-connection-ref.js";
 // ── Controller ────────────────────────────────────────────────────────────────
-class SqlSelectResource {
+class SqlSelectionResource {
     manifest;
     ctx;
     constructor(manifest, ctx) {
@@ -21,7 +21,7 @@ class SqlSelectResource {
         const offset = m.offset != null ? ctx.expandValue(m.offset, expandCtx) : undefined;
         const connection = resolveSqlConnection(m.connection, ctx) ?? m.transaction?.getConnection();
         if (!connection) {
-            throw new Error("Sql.Select: either 'connection' or 'transaction' must be set");
+            throw new Error("Sql.Selection: either 'connection' or 'transaction' must be set");
         }
         const { sql, params } = buildSelect(m, where, having, limit, offset, connection.driver);
         const result = await connection.execute(sql, params, m.transaction);
@@ -157,7 +157,7 @@ function opToSql(op) {
     };
     const sql = map[op];
     if (!sql)
-        throw new Error(`Sql.Select: unknown operator '${op}'`);
+        throw new Error(`Sql.Selection: unknown operator '${op}'`);
     return sql;
 }
 // ── Exports ───────────────────────────────────────────────────────────────────
@@ -190,5 +190,5 @@ function extractDefaults(inputType, ctx) {
 }
 export function register() { }
 export async function create(resource, ctx) {
-    return new SqlSelectResource(resource, ctx);
+    return new SqlSelectionResource(resource, ctx);
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@telorun/sql",
-  "version": "0.7.2",
+  "version": "0.8.0",
   "description": "Telo SQL module - SQL database resource kinds for Telo manifests.",
   "keywords": [
     "telo",
@@ -21,35 +21,36 @@
     "url": "https://github.com/telorun/telo/issues"
   },
   "type": "module",
+  "main": "./dist/index.js",
+  "module": "./dist/index.js",
+  "types": "./dist/index.d.ts",
   "exports": {
-    "./sql-postgres-connection": {
-      "bun": "./src/sql-postgres-connection-controller.ts",
-      "import": "./dist/sql-postgres-connection-controller.js"
+    ".": {
+      "types": "./dist/index.d.ts",
+      "bun": "./src/index.ts",
+      "import": "./dist/index.js"
     },
-    "./sql-sqlite-connection": {
-      "bun": "./src/sql-sqlite-connection-controller.ts",
-      "import": "./dist/sql-sqlite-connection-controller.js"
+    "./connection": {
+      "types": "./dist/sql-connection-controller.d.ts",
+      "bun": "./src/sql-connection-controller.ts",
+      "import": "./dist/sql-connection-controller.js"
     },
     "./sql-query": {
       "bun": "./src/sql-query-controller.ts",
       "import": "./dist/sql-query-controller.js"
     },
-    "./sql-select": {
-      "bun": "./src/sql-select-controller.ts",
-      "import": "./dist/sql-select-controller.js"
+    "./sql-selection": {
+      "bun": "./src/sql-selection-controller.ts",
+      "import": "./dist/sql-selection-controller.js"
     },
-    "./sql-exec": {
-      "bun": "./src/sql-exec-controller.ts",
-      "import": "./dist/sql-exec-controller.js"
+    "./sql-command": {
+      "bun": "./src/sql-command-controller.ts",
+      "import": "./dist/sql-command-controller.js"
     },
     "./sql-transaction": {
       "bun": "./src/sql-transaction-controller.ts",
       "import": "./dist/sql-transaction-controller.js"
     },
-    "./sqlite-driver": {
-      "bun": "./src/sqlite-driver-bun.ts",
-      "import": "./dist/sqlite-driver-node.js"
-    },
     "./sql-migration": {
       "bun": "./src/sql-migration-controller.ts",
       "import": "./dist/sql-migration-controller.js"
@@ -64,17 +65,12 @@
     "src/**"
   ],
   "dependencies": {
-    "better-sqlite3": "^12.8.0",
-    "pg": "^8.20.0",
     "kysely": "^0.28.15"
   },
   "devDependencies": {
-    "@types/better-sqlite3": "^7.0.0",
-    "@types/bun": "^1.3.10",
     "@types/node": "^20.0.0",
-    "@types/pg": "^8.0.0",
     "typescript": "^5.0.0",
-    "@telorun/sdk": "0.26.0"
+    "@telorun/sdk": "0.34.0"
   },
   "peerDependencies": {
     "@telorun/sdk": "*"

package/src/index.ts

@@ -0,0 +1,8 @@
+export {
+  SqlConnectionResource,
+  createSqlConnection,
+  type SqlDriver,
+  type PlaceholderStyle,
+} from "./sql-connection-controller.js";
+export { resolveSqlConnection } from "./sql-connection-ref.js";
+export type { SqliteDb, SqliteStatement } from "./sqlite-driver-interface.js";

package/src/{sql-exec-controller.ts → sql-command-controller.ts}

@@ -5,7 +5,7 @@ import type { SqlResult } from "./sql-query-controller.js";
 import { runSql } from "./sql-run.js";
 import type { SqlTransactionResource } from "./sql-transaction-controller.js";
 
-interface SqlExecManifest {
+interface SqlCommandManifest {
   metadata: { name: string; module: string };
   connection?: SqlConnectionResource;
   transaction?: SqlTransactionResource;
@@ -15,9 +15,9 @@ interface SqlExecManifest {
   };
 }
 
-class SqlExecResource implements ResourceInstance {
+class SqlCommandResource implements ResourceInstance {
   constructor(
-    private readonly manifest: SqlExecManifest,
+    private readonly manifest: SqlCommandManifest,
     private readonly ctx: ResourceContext,
   ) {}
 
@@ -38,8 +38,8 @@ class SqlExecResource implements ResourceInstance {
 export function register(): void {}
 
 export async function create(
-  resource: SqlExecManifest,
+  resource: SqlCommandManifest,
   ctx: ResourceContext,
-): Promise<SqlExecResource> {
-  return new SqlExecResource(resource, ctx);
+): Promise<SqlCommandResource> {
+  return new SqlCommandResource(resource, ctx);
 }

package/src/sql-connection-controller.ts

@@ -1,77 +1,34 @@
 import type { ResourceInstance } from "@telorun/sdk";
 import { randomUUID } from "crypto";
-import {
-  CompiledQuery,
-  Kysely,
-  PostgresDialect,
-  SqliteAdapter,
-  SqliteDialect,
-  type QueryResult,
-  type Transaction,
-} from "kysely";
-import { Pool } from "pg";
+import { CompiledQuery, Kysely, type QueryResult, type Transaction } from "kysely";
 import type { SqlTransactionResource } from "./sql-transaction-controller.js";
 import type { SqliteDb } from "./sqlite-driver-interface.js";
 import { currentTxId, deleteTx, getTx, setTx, txStorage } from "./transaction-store.js";
 
-interface PoolConfig {
-  min?: number;
-  max?: number;
-  idleTimeoutMs?: number;
-  connectionTimeoutMs?: number;
-}
-
 export type SqlDriver = "postgres" | "sqlite";
 
 /** Native bind-placeholder syntax per driver: SQLite binds anonymous `?`,
  *  PostgreSQL binds numbered `$1`, `$2`, … */
 export type PlaceholderStyle = "qmark" | "numbered";
 
-export interface SqlConnectionConfig {
-  driver: SqlDriver;
-  /** Required for `postgres`; ignored for `sqlite` (which opens via `sqlite`). */
-  connectionString?: string;
-  pool?: PoolConfig;
-}
-
+/**
+ * Driver-agnostic SQL connection. The kysely instance (and, for SQLite, the
+ * underlying database handle used by `executeScript`) is built by the driver
+ * backend (`sql-postgres`, `sql-sqlite`) and handed in via
+ * {@link createSqlConnection}. Everything here — execution, transactions,
+ * placeholder style, row-count normalization — is transport-neutral.
+ */
 export class SqlConnectionResource implements ResourceInstance {
-  readonly driver: SqlDriver;
   private readonly db: Kysely<any>;
   private readonly sqlite?: SqliteDb;
 
-  constructor(config: SqlConnectionConfig, sqlite?: SqliteDb) {
-    this.driver = config.driver;
-
-    if (this.driver === "postgres") {
-      if (!config.connectionString) {
-        throw new Error("Sql: postgres connection requires a connectionString");
-      }
-      const url = new URL(config.connectionString);
-      const ssl = sslFromSslmode(url.searchParams.get("sslmode"));
-      url.searchParams.delete("sslmode");
-      this.db = new Kysely({
-        dialect: new PostgresDialect({
-          pool: new Pool({
-            connectionString: url.toString(),
-            ssl,
-            min: config.pool?.min ?? 1,
-            max: config.pool?.max ?? 10,
-            idleTimeoutMillis: config.pool?.idleTimeoutMs,
-            connectionTimeoutMillis: config.pool?.connectionTimeoutMs,
-          }),
-        }),
-      });
-    } else {
-      if (!sqlite) {
-        throw new Error("Sql: sqlite database was not initialized");
-      }
-      this.sqlite = sqlite;
-      this.db = new Kysely({
-        dialect: new TransactionalSqliteDialect({
-          database: this.sqlite,
-        }),
-      });
-    }
+  constructor(
+    readonly driver: SqlDriver,
+    db: Kysely<any>,
+    sqlite?: SqliteDb,
+  ) {
+    this.db = db;
+    this.sqlite = sqlite;
   }
 
   async init() {
@@ -171,67 +128,16 @@ export class SqlConnectionResource implements ResourceInstance {
   }
 }
 
-// Kysely's stock SQLite adapter reports `supportsTransactionalDdl = false`, so
-// its Migrator runs migrations without a transaction. SQLite does support
-// transactional DDL, so we flip the flag — letting the Migrator wrap the whole
-// migration batch in a single transaction, matching PostgreSQL.
-class TransactionalSqliteAdapter extends SqliteAdapter {
-  override get supportsTransactionalDdl(): boolean {
-    return true;
-  }
-}
-
-class TransactionalSqliteDialect extends SqliteDialect {
-  override createAdapter(): SqliteAdapter {
-    return new TransactionalSqliteAdapter();
-  }
-}
-
-type SslOption =
-  | false
-  | { rejectUnauthorized: boolean; checkServerIdentity?: () => undefined };
-
-function sslFromSslmode(mode: string | null): SslOption {
-  switch (mode) {
-    case null:
-    case "disable":
-      return false;
-    case "require":
-      return { rejectUnauthorized: false };
-    case "verify-ca":
-      // libpq `verify-ca` validates the CA chain but not the hostname; Node's
-      // default `checkServerIdentity` enforces the hostname, so disable it.
-      return { rejectUnauthorized: true, checkServerIdentity: () => undefined };
-    case "verify-full":
-      return { rejectUnauthorized: true };
-    default:
-      throw new Error(
-        `Sql.Connection: unsupported sslmode '${mode}'. ` +
-          `Use 'disable', 'require', 'verify-ca', or 'verify-full'.`,
-      );
-  }
-}
-
-export async function openSqliteDatabase(file = ":memory:"): Promise<SqliteDb> {
-  // Auto-create the parent directory for file-backed databases. SQLite
-  // drivers fail-fast when the directory doesn't exist; mirroring `mkdir
-  // -p` here lets manifests use paths like `./tmp/foo.sqlite` without a
-  // separate filesystem-prep step. `:memory:` skips filesystem entirely.
-  if (file !== ":memory:") {
-    const { mkdir } = await import("node:fs/promises");
-    const { dirname } = await import("node:path");
-    const dir = dirname(file);
-    if (dir && dir !== "." && dir !== "/") {
-      await mkdir(dir, { recursive: true });
-    }
-  }
-
-  // Route through the package's own `./sqlite-driver` subpath export so the
-  // resolver selects the driver per runtime (Bun → bun:sqlite, Node →
-  // better-sqlite3). A manual `typeof Bun` check with relative imports gets
-  // flattened by the controller bundler into an unconditional top-level
-  // `import "bun:sqlite"`, which Node's ESM loader rejects before the guard
-  // runs; an external `@telorun/*` specifier stays a deferred dynamic import.
-  const { openDatabase } = await import("@telorun/sql/sqlite-driver");
-  return openDatabase(file);
+/**
+ * Build a connection from a driver-constructed kysely instance. Driver backends
+ * (`sql-postgres`, `sql-sqlite`) own dialect construction and call this; the
+ * `sqlite` handle is required only for SQLite (its `executeScript` runs through
+ * the native handle).
+ */
+export function createSqlConnection(
+  driver: SqlDriver,
+  db: Kysely<any>,
+  sqlite?: SqliteDb,
+): SqlConnectionResource {
+  return new SqlConnectionResource(driver, db, sqlite);
 }

package/src/{sql-select-controller.ts → sql-selection-controller.ts}

@@ -76,7 +76,7 @@ interface SelectManifest {
 
 // ── Controller ────────────────────────────────────────────────────────────────
 
-class SqlSelectResource implements ResourceInstance {
+class SqlSelectionResource implements ResourceInstance {
   constructor(
     private readonly manifest: SelectManifest,
     private readonly ctx: ResourceContext,
@@ -98,7 +98,7 @@ class SqlSelectResource implements ResourceInstance {
 
     const connection = resolveSqlConnection(m.connection, ctx) ?? m.transaction?.getConnection();
     if (!connection) {
-      throw new Error("Sql.Select: either 'connection' or 'transaction' must be set");
+      throw new Error("Sql.Selection: either 'connection' or 'transaction' must be set");
     }
 
     const { sql, params } = buildSelect(m, where, having, limit, offset, connection.driver);
@@ -266,7 +266,7 @@ function opToSql(op: Op): string {
     ilike: "ILIKE",
   };
   const sql = map[op];
-  if (!sql) throw new Error(`Sql.Select: unknown operator '${op}'`);
+  if (!sql) throw new Error(`Sql.Selection: unknown operator '${op}'`);
   return sql;
 }
 
@@ -306,6 +306,6 @@ export function register(): void {}
 export async function create(
   resource: SelectManifest,
   ctx: ResourceContext,
-): Promise<SqlSelectResource> {
-  return new SqlSelectResource(resource, ctx);
+): Promise<SqlSelectionResource> {
+  return new SqlSelectionResource(resource, ctx);
 }

package/dist/sql-postgres-connection-controller.d.ts

@@ -1,19 +0,0 @@
-import type { ResourceContext } from "@telorun/sdk";
-import { SqlConnectionResource } from "./sql-connection-controller.js";
-interface PoolConfig {
-    min?: number;
-    max?: number;
-    idleTimeoutMs?: number;
-    connectionTimeoutMs?: number;
-}
-interface PostgresConnectionManifest {
-    metadata: {
-        name: string;
-        module: string;
-    };
-    connectionString: string;
-    pool?: PoolConfig;
-}
-export declare function register(): void;
-export declare function create(resource: PostgresConnectionManifest, ctx: ResourceContext): Promise<SqlConnectionResource>;
-export {};

package/dist/sql-postgres-connection-controller.js

@@ -1,9 +0,0 @@
-import { SqlConnectionResource } from "./sql-connection-controller.js";
-export function register() { }
-export async function create(resource, ctx) {
-    return new SqlConnectionResource({
-        driver: "postgres",
-        connectionString: resource.connectionString,
-        pool: resource.pool,
-    });
-}

package/dist/sql-sqlite-connection-controller.d.ts

@@ -1,13 +0,0 @@
-import type { ResourceContext } from "@telorun/sdk";
-import { SqlConnectionResource } from "./sql-connection-controller.js";
-interface SqliteConnectionManifest {
-    metadata: {
-        name: string;
-        module: string;
-    };
-    /** File path, or omitted / `:memory:` for an in-memory database. */
-    file?: string;
-}
-export declare function register(): void;
-export declare function create(resource: SqliteConnectionManifest, ctx: ResourceContext): Promise<SqlConnectionResource>;
-export {};

package/dist/sql-sqlite-connection-controller.js

@@ -1,6 +0,0 @@
-import { openSqliteDatabase, SqlConnectionResource } from "./sql-connection-controller.js";
-export function register() { }
-export async function create(resource, ctx) {
-    const sqlite = await openSqliteDatabase(resource.file ?? ":memory:");
-    return new SqlConnectionResource({ driver: "sqlite" }, sqlite);
-}

package/dist/sqlite-driver-bun.d.ts

@@ -1,2 +0,0 @@
-import type { SqliteDb } from "./sqlite-driver-interface.js";
-export declare function openDatabase(file: string): SqliteDb;

package/dist/sqlite-driver-bun.js

@@ -1,31 +0,0 @@
-import { Database } from "bun:sqlite";
-export function openDatabase(file) {
-    const db = new Database(file);
-    return {
-        prepare(sql) {
-            const stmt = db.prepare(sql);
-            return {
-                reader: true,
-                all(params) {
-                    return stmt.all(...params);
-                },
-                run(params) {
-                    const result = stmt.run(...params);
-                    return {
-                        changes: result.changes,
-                        lastInsertRowid: result.lastInsertRowid,
-                    };
-                },
-                iterate(params) {
-                    return stmt.iterate(...params);
-                },
-            };
-        },
-        exec(sql) {
-            db.exec(sql);
-        },
-        close() {
-            db.close();
-        },
-    };
-}

package/dist/sqlite-driver-node.d.ts

@@ -1,2 +0,0 @@
-import type { SqliteDb } from "./sqlite-driver-interface.js";
-export declare function openDatabase(file: string): SqliteDb;

package/dist/sqlite-driver-node.js

@@ -1,31 +0,0 @@
-import Database from "better-sqlite3";
-export function openDatabase(file) {
-    const db = new Database(file);
-    return {
-        prepare(sql) {
-            const stmt = db.prepare(sql);
-            return {
-                reader: stmt.reader,
-                all(params) {
-                    return stmt.all(...params);
-                },
-                run(params) {
-                    const result = stmt.run(...params);
-                    return {
-                        changes: result.changes,
-                        lastInsertRowid: result.lastInsertRowid,
-                    };
-                },
-                iterate(params) {
-                    return stmt.iterate(...params);
-                },
-            };
-        },
-        exec(sql) {
-            db.exec(sql);
-        },
-        close() {
-            db.close();
-        },
-    };
-}

package/src/sql-postgres-connection-controller.ts

@@ -1,28 +0,0 @@
-import type { ResourceContext } from "@telorun/sdk";
-import { SqlConnectionResource } from "./sql-connection-controller.js";
-
-interface PoolConfig {
-  min?: number;
-  max?: number;
-  idleTimeoutMs?: number;
-  connectionTimeoutMs?: number;
-}
-
-interface PostgresConnectionManifest {
-  metadata: { name: string; module: string };
-  connectionString: string;
-  pool?: PoolConfig;
-}
-
-export function register(): void {}
-
-export async function create(
-  resource: PostgresConnectionManifest,
-  ctx: ResourceContext,
-): Promise<SqlConnectionResource> {
-  return new SqlConnectionResource({
-    driver: "postgres",
-    connectionString: resource.connectionString,
-    pool: resource.pool,
-  });
-}

package/src/sql-sqlite-connection-controller.ts

@@ -1,18 +0,0 @@
-import type { ResourceContext } from "@telorun/sdk";
-import { openSqliteDatabase, SqlConnectionResource } from "./sql-connection-controller.js";
-
-interface SqliteConnectionManifest {
-  metadata: { name: string; module: string };
-  /** File path, or omitted / `:memory:` for an in-memory database. */
-  file?: string;
-}
-
-export function register(): void {}
-
-export async function create(
-  resource: SqliteConnectionManifest,
-  ctx: ResourceContext,
-): Promise<SqlConnectionResource> {
-  const sqlite = await openSqliteDatabase(resource.file ?? ":memory:");
-  return new SqlConnectionResource({ driver: "sqlite" }, sqlite);
-}

package/src/sqlite-driver-bun.ts

@@ -1,34 +0,0 @@
-import { Database } from "bun:sqlite";
-import type { SqliteDb } from "./sqlite-driver-interface.js";
-
-export function openDatabase(file: string): SqliteDb {
-  const db = new Database(file);
-
-  return {
-    prepare(sql: string) {
-      const stmt = db.prepare(sql);
-      return {
-        reader: true,
-        all(params: ReadonlyArray<unknown>) {
-          return stmt.all(...(params as any[]));
-        },
-        run(params: ReadonlyArray<unknown>) {
-          const result = stmt.run(...(params as any[]));
-          return {
-            changes: result.changes,
-            lastInsertRowid: result.lastInsertRowid,
-          };
-        },
-        iterate(params: ReadonlyArray<unknown>) {
-          return stmt.iterate(...(params as any[])) as IterableIterator<unknown>;
-        },
-      };
-    },
-    exec(sql: string) {
-      db.exec(sql);
-    },
-    close() {
-      db.close();
-    },
-  };
-}

package/src/sqlite-driver-node.ts

@@ -1,35 +0,0 @@
-import Database from "better-sqlite3";
-import type { SqliteDb } from "./sqlite-driver-interface.js";
-
-export function openDatabase(file: string): SqliteDb {
-  const db = new Database(file);
-
-  return {
-    prepare(sql: string) {
-      const stmt = db.prepare(sql);
-
-      return {
-        reader: stmt.reader,
-        all(params: ReadonlyArray<unknown>) {
-          return stmt.all(...(params as unknown[]));
-        },
-        run(params: ReadonlyArray<unknown>) {
-          const result = stmt.run(...(params as unknown[]));
-          return {
-            changes: result.changes,
-            lastInsertRowid: result.lastInsertRowid,
-          };
-        },
-        iterate(params: ReadonlyArray<unknown>) {
-          return stmt.iterate(...(params as unknown[])) as IterableIterator<unknown>;
-        },
-      };
-    },
-    exec(sql: string) {
-      db.exec(sql);
-    },
-    close() {
-      db.close();
-    },
-  };
-}