@murumets-ee/db 0.0.0-preview-20261014110621

package/dist/index.d.mts

@@ -0,0 +1,1649 @@
+import { PostgresJsDatabase } from "drizzle-orm/postgres-js";
+import { Sql } from "postgres";
+import { InferInsertModel, SQL, Table } from "drizzle-orm";
+import { AnyPgColumn, AnyPgColumn as AnyPgColumn$1, PgColumnBuilderBase, PgTable, PgTableWithColumns, TableConfig } from "drizzle-orm/pg-core";
+import { Logger } from "drizzle-orm/logger";
+
+//#region src/client.d.ts
+interface DbConfig {
+  url: string;
+  readOnlyUrl?: string;
+  poolMin?: number;
+  poolMax?: number;
+  /**
+   * Per-statement ceiling in milliseconds for the READ-ONLY pool only
+   * (default {@link DEFAULT_READ_ONLY_STATEMENT_TIMEOUT_MS}). Must be a
+   * positive integer; `0` and negatives are rejected rather than treated as
+   * "disabled" — see {@link createReadOnlyClient}.
+   *
+   * The read-write pool is deliberately not covered: it serves migrations,
+   * bulk imports and admin writes, where a statement running for minutes is
+   * legitimate.
+   */
+  readOnlyStatementTimeoutMs?: number;
+}
+/**
+ * Default read-only `statement_timeout`, in milliseconds.
+ *
+ * Calibrated against the one perf-harness scenario that actually exercises
+ * this pool: `locale-fallback` drives real content-api reads (which read
+ * through `app.db.readOnly`) at ~540 rps with p95 ≈ 55 ms, flat from 1k to
+ * 1M rows. 5 s sits ~100× above that.
+ *
+ * Deliberately NOT cited as justification: the harness's pathological
+ * `tickets-per-agent` scenario (11.6 s p95 at 1M rows). It reads through
+ * `AdminClient.aggregate` on the READ-WRITE pool, so it cannot reach the pool
+ * being capped here — and its p50 at 1M is 5016 ms, i.e. this ceiling would
+ * sit at its median rather than safely above it. The harness contains no
+ * measurement of a >5 s read-ONLY-pool query, so this default rests on a
+ * single scenario plus the ~100× margin, not on a measured bad case.
+ */
+declare const DEFAULT_READ_ONLY_STATEMENT_TIMEOUT_MS = 5000;
+/**
+ * Postgres' own upper bound for `statement_timeout` (a signed 32-bit
+ * millisecond count). Anything larger is rejected with SQLSTATE 22023 — but
+ * postgres-js connects LAZILY, so an out-of-range value would let the process
+ * boot green and then fail EVERY read at connection time, with an error
+ * pointing at the connection rather than at config. Rejecting it up front
+ * keeps the failure attached to its cause.
+ */
+declare const MAX_STATEMENT_TIMEOUT_MS = 2147483647;
+/**
+ * Parse a `readOnlyStatementTimeoutMs` override out of an environment string,
+ * returning `undefined` (i.e. "use the default") for anything unusable.
+ *
+ * This exists so an operator can raise the ceiling on a deployment whose read
+ * path is legitimately slower WITHOUT a rebuild and redeploy. That makes it an
+ * incident-time tool, which forces two properties:
+ *
+ * - **It must never throw.** `lumi.config.ts` is evaluated at BUILD time, and a
+ *   throw there fails the build rather than the request. Passing an unvalidated
+ *   value straight through would be worse still: `createReadOnlyClient` rejects
+ *   out-of-range values, so a typo'd env var would abort app construction — an
+ *   escape hatch that can itself take the process down is not an escape hatch.
+ * - **It must not fail silently either.** Someone raising the ceiling mid-incident
+ *   and getting the 5 s default back with no signal would conclude the knob is
+ *   broken. Hence the warning: `console` rather than `@murumets-ee/logging`
+ *   because config is evaluated before any logger exists.
+ */
+declare function parseStatementTimeoutEnv(raw: string | undefined): number | undefined;
+/**
+ * Create a full read-write database client.
+ *
+ * Its transactions are tracked (`trackTransactions`), so `onCommit` works on
+ * every `tx` it hands out. This is where `app.db.readWrite` and the CLI's
+ * client come from, which is what lets `AdminClient` hold its post-commit
+ * seams until a caller's transaction actually commits — with no change at any
+ * call site that opens one.
+ */
+declare function createDbClient(config: DbConfig): PostgresJsDatabase;
+/**
+ * Create a read-only database client.
+ *
+ * Sets `default_transaction_read_only = on` as a startup parameter on every
+ * connection in the pool, so any implicit transaction issued through this
+ * client is read-only at the PostgreSQL level. This is the defense-in-depth
+ * layer beneath the application's own routing of writes through `AdminClient`
+ * — even if a write somehow reaches a read-only client, Postgres rejects it.
+ *
+ * Also sets `statement_timeout` so a single slow read cannot hold a pool
+ * connection indefinitely. The pool defaults to 10 connections, so ten
+ * concurrently-slow queries exhaust it and every later read blocks. Rate
+ * limiting cannot close this gap: a limiter bounds how many requests ARRIVE,
+ * this bounds how long each one HOLDS a connection.
+ *
+ * Implementation note: postgres-js's `connection` config object is sent in
+ * the PostgreSQL startup packet for every new pool connection, so both GUCs
+ * are applied uniformly across the whole pool — not just whichever connection
+ * happened to run a one-off `SET` statement.
+ *
+ * @throws if `readOnlyStatementTimeoutMs` is not a positive integer. `0` is
+ * rejected rather than accepted as Postgres' "disabled" sentinel, for two
+ * reasons: this is an availability control, so a typo'd `0` must not silently
+ * remove it; and postgres-js's startup-packet builder filters falsy values
+ * out, so a `0` would never reach the server anyway — the connection would
+ * quietly inherit whatever server- or role-level default happened to be set.
+ * Deployments that need a longer ceiling raise the number.
+ */
+declare function createReadOnlyClient(config: DbConfig): PostgresJsDatabase;
+//#endregion
+//#region src/deploy/advisory-lock.d.ts
+/**
+ * An advisory lock's two-part key. Both halves are signed 32-bit integers —
+ * Postgres' `(int4, int4)` form, so toolkit locks sit in their own namespace
+ * (`space`) and cannot collide with an application's single-`bigint` keys.
+ */
+interface AdvisoryLockKey {
+  readonly space: number;
+  readonly id: number;
+}
+/** The first half of every toolkit-owned advisory lock key: ASCII `LUMI`. */
+declare const TOOLKIT_ADVISORY_LOCK_SPACE = 1280658761;
+/** One deploy-step runner per database. */
+declare const DEPLOY_STEPS_LOCK: AdvisoryLockKey;
+type AdvisoryLockResult<T> = {
+  readonly acquired: true;
+  readonly value: T;
+} | {
+  readonly acquired: false;
+};
+/**
+ * Run `fn` while holding the advisory lock `key`, or return
+ * `{ acquired: false }` without running it when someone else holds it.
+ */
+declare function withAdvisoryLock<T>(db: PostgresJsDatabase, key: AdvisoryLockKey, fn: () => Promise<T>): Promise<AdvisoryLockResult<T>>;
+//#endregion
+//#region src/deploy/deploy-steps-table.d.ts
+/**
+ * The deploy-step ledger (plan `deploy-drift` D002): one row per ATTEMPT of a
+ * deploy step on a site. Nothing here is ever updated or deleted — the current
+ * state of a step on a site is its NEWEST row, and the older ones are its
+ * history. Resetting a step is a new attempt, never a removed row.
+ *
+ * A framework table, not a plugin's: every lumi-cms project has deploy steps
+ * available and therefore has this table, whichever plugins it loads. It is
+ * wired where `entity_refs` is — `createApp`, `buildCliApp` and `lumi migrate`'s
+ * schema map — so it reaches the schema snapshot and gets a generated
+ * migration like any other table (unlike `_toolkit_migrations`, which is raw
+ * SQL outside the snapshots and is not the shape to copy).
+ *
+ * It lives in `@murumets-ee/db` because the runner that writes it lives in
+ * `@murumets-ee/core`, and core owns no tables of its own.
+ */
+/** The table's name — also its key in the migration schema map. */
+declare const DEPLOY_STEPS_TABLE_NAME = "toolkit_deploy_steps";
+/**
+ * What an attempt ended as. STORED states only: "waiting" and "waiting for
+ * another step" are computed on every read from what is declared and what is
+ * recorded, and are never written (a cached pending list is the bug Drupal had).
+ */
+declare const DEPLOY_STEP_STATES: readonly ["applied", "needs-a-person", "marked-done"];
+type DeployStepState = (typeof DEPLOY_STEP_STATES)[number];
+declare const deployStepsTable: {
+  table: import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+      [x: string]: import("drizzle-orm/pg-core").PgColumn<{
+        name: string;
+        tableName: string;
+        dataType: import("drizzle-orm").ColumnDataType;
+        columnType: string;
+        data: unknown;
+        driverParam: unknown;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: string[] | undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {}>;
+    };
+    dialect: "pg";
+  }>;
+  schema: TableDefinition<{
+    readonly id: ColumnFactory<string, "uuid", true, true>; /** The seeder's `name`. */
+    readonly step: ColumnFactory<string, "varchar", true, false>; /** The site handle the attempt was for. */
+    readonly site: ColumnFactory<string, "varchar", true, false>; /** One of {@link DEPLOY_STEP_STATES}. */
+    readonly state: ColumnFactory<string, "varchar", true, false>; /** Why it needs a person — the step's own words, or the error's message. */
+    readonly reason: ColumnFactory<string, "text", false, false>; /** What a person should do about it — the step's own words. */
+    readonly whatToDo: ColumnFactory<string, "text", false, false>; /** Rows the step said it created. Null for a mark and for a throw. */
+    readonly created: ColumnFactory<number, "integer", false, false>;
+    readonly at: ColumnFactory<Date, "timestamp", true, true>;
+    /**
+     * Who ran it: `deploy`, `cli`, or a user id. A user id is varchar, never
+     * uuid — better-auth ids are random strings.
+     */
+    readonly by: ColumnFactory<string, "varchar", true, false>; /** That person's name or e-mail as it was then; null for `deploy` / `cli`. */
+    readonly byName: ColumnFactory<string, "varchar", false, false>; /** The commit of the build that ran it; null when the build was not told. */
+    readonly buildCommit: ColumnFactory<string, "varchar", false, false>; /** The toolkit version that ran it. */
+    readonly toolkitVersion: ColumnFactory<string, "varchar", false, false>;
+  }>;
+  columnKinds: Readonly<Record<string, ColumnKind>>;
+  primaryKeyColumns: readonly string[];
+  makeClient: (database: import("drizzle-orm/postgres-js").PostgresJsDatabase, partitionValue?: string) => TableClient<{
+    readonly id: ColumnFactory<string, "uuid", true, true>; /** The seeder's `name`. */
+    readonly step: ColumnFactory<string, "varchar", true, false>; /** The site handle the attempt was for. */
+    readonly site: ColumnFactory<string, "varchar", true, false>; /** One of {@link DEPLOY_STEP_STATES}. */
+    readonly state: ColumnFactory<string, "varchar", true, false>; /** Why it needs a person — the step's own words, or the error's message. */
+    readonly reason: ColumnFactory<string, "text", false, false>; /** What a person should do about it — the step's own words. */
+    readonly whatToDo: ColumnFactory<string, "text", false, false>; /** Rows the step said it created. Null for a mark and for a throw. */
+    readonly created: ColumnFactory<number, "integer", false, false>;
+    readonly at: ColumnFactory<Date, "timestamp", true, true>;
+    /**
+     * Who ran it: `deploy`, `cli`, or a user id. A user id is varchar, never
+     * uuid — better-auth ids are random strings.
+     */
+    readonly by: ColumnFactory<string, "varchar", true, false>; /** That person's name or e-mail as it was then; null for `deploy` / `cli`. */
+    readonly byName: ColumnFactory<string, "varchar", false, false>; /** The commit of the build that ran it; null when the build was not told. */
+    readonly buildCommit: ColumnFactory<string, "varchar", false, false>; /** The toolkit version that ran it. */
+    readonly toolkitVersion: ColumnFactory<string, "varchar", false, false>;
+  }, import("drizzle-orm/pg-core").PgTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+      [x: string]: import("drizzle-orm/pg-core").PgColumn<{
+        name: string;
+        tableName: string;
+        dataType: import("drizzle-orm").ColumnDataType;
+        columnType: string;
+        data: unknown;
+        driverParam: unknown;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: string[] | undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {}>;
+    };
+    dialect: "pg";
+  }>>;
+  partitionColumn: "step" | "site" | "at" | "id" | "state" | "reason" | "whatToDo" | "created" | "by" | "byName" | "buildCommit" | "toolkitVersion" | undefined;
+};
+declare const toolkitDeploySteps: import("drizzle-orm/pg-core").PgTableWithColumns<{
+  name: string;
+  schema: undefined;
+  columns: {
+    [x: string]: import("drizzle-orm/pg-core").PgColumn<{
+      name: string;
+      tableName: string;
+      dataType: import("drizzle-orm").ColumnDataType;
+      columnType: string;
+      data: unknown;
+      driverParam: unknown;
+      notNull: false;
+      hasDefault: false;
+      isPrimaryKey: false;
+      isAutoincrement: false;
+      hasRuntimeDefault: false;
+      enumValues: string[] | undefined;
+      baseColumn: never;
+      identity: undefined;
+      generated: undefined;
+    }, {}, {}>;
+  };
+  dialect: "pg";
+}>;
+//#endregion
+//#region src/extensions.d.ts
+/**
+ * Postgres extension helpers — the single source of truth for how the toolkit
+ * enables a Postgres extension.
+ *
+ * Declarative source: plugins declare `server.extensions: ['btree_gist']`
+ * (see `@murumets-ee/core`'s `PluginServer`). Consumers — `lumi migrate`
+ * (emits into the generated migration) and `@murumets-ee/db`'s `createTestDb`
+ * (enables before `pushSchema`) — both route through the helpers here so the
+ * validation rule and the emitted SQL are identical everywhere (the migrate
+ * dedup-scan relies on the canonical statement being byte-for-byte stable).
+ *
+ * Why validate the name: `CREATE EXTENSION` cannot parameterize an identifier,
+ * so the extension name is interpolated as a literal. Names come from plugin
+ * code (not request input), but per the "validate at the boundary" rule we
+ * still whitelist the identifier shape so a typo or a hostile plugin can't
+ * inject SQL through the one place a raw identifier reaches a DDL string.
+ */
+/**
+ * Valid Postgres extension identifier: a lowercase unquoted identifier —
+ * leading letter/underscore, then letters/digits/underscores. Covers every
+ * real extension name (`btree_gist`, `pg_trgm`, `uuid-ossp` is the lone
+ * hyphenated outlier and is intentionally rejected here; declare it quoted via
+ * a custom migration if ever needed). Anchored, so no embedded whitespace,
+ * quotes, semicolons, or comment markers can slip through.
+ */
+declare const EXTENSION_NAME_PATTERN: RegExp;
+/**
+ * Throw if `name` is not a safe, unquoted Postgres extension identifier.
+ * Kept separate from {@link createExtensionStatement} so callers that only
+ * want to validate (e.g. a config linter) don't have to build SQL.
+ */
+declare function assertValidExtensionName(name: string): void;
+/**
+ * The canonical, idempotent statement that enables one extension.
+ * Validates first, then double-quotes the (already-safe) identifier.
+ *
+ * This exact string is what `lumi migrate` writes into migration files AND
+ * what it scans prior migrations for to avoid re-emitting — do not change the
+ * shape without updating the dedup scan in `packages/cli/src/commands/migrate.ts`.
+ */
+declare function createExtensionStatement(name: string): string;
+//#endregion
+//#region src/listen.d.ts
+/**
+ * Create a dedicated postgres-js connection sized for `LISTEN/NOTIFY`.
+ *
+ * The underlying postgres-js Sql instance is intentionally NOT a Drizzle
+ * client — `LISTEN`/`NOTIFY` is a low-level Postgres feature that the
+ * Drizzle query builder doesn't model. The realtime cross-process bridge
+ * (in `@murumets-ee/core/realtime`) holds one of these per process:
+ *
+ * - `sql.listen(channel, onnotify, onlisten)` opens a dedicated long-lived
+ *   connection and delivers every `NOTIFY` on the channel to `onnotify`.
+ * - `sql.notify(channel, payload)` (or `pg_notify`) issues a notification.
+ *
+ * Pool size is intentionally small (max 2): one connection is parked on
+ * `LISTEN`, leaving headroom for occasional `NOTIFY` issues from the same
+ * Sql instance without contending with the rest of the app's pool.
+ */
+declare function createListenClient(config: Pick<DbConfig, 'url'>): Sql;
+//#endregion
+//#region src/migrate.d.ts
+/**
+ * Arguments passed to migration `up` / `down` functions.
+ *
+ * Intentionally tiny: we hand over a read-write Drizzle handle bound to
+ * the current transaction. If a migration needs anything beyond raw SQL
+ * (e.g. calling an AdminClient for a data backfill), it can import the
+ * relevant toolkit helpers inside the migration file — the CLI loader
+ * runs the migration in the same process as the config, so all package
+ * imports resolve normally.
+ */
+interface MigrateArgs {
+  db: PostgresJsDatabase;
+}
+/**
+ * Shape of a migration module loaded from a `.ts` file.
+ *
+ * At minimum a migration must export `up`. `down` is optional — when
+ * absent, `lumi migrate:rollback` refuses to roll that file back.
+ */
+interface MigrationModule {
+  up: (args: MigrateArgs) => Promise<void>;
+  down?: (args: MigrateArgs) => Promise<void>;
+}
+interface MigrationSource {
+  /** Absolute path to the migration file on disk. */
+  path: string;
+  /** `project` for user migrations, `toolkit` for shipped-with-toolkit ones. */
+  namespace: 'toolkit' | 'project';
+  /** Filename only, used for ordering + tracking. */
+  name: string;
+}
+interface MigrationStatus {
+  applied: MigrationSource[];
+  pending: MigrationSource[];
+}
+/**
+ * Loader callback — imports a migration `.ts` file and returns its exports.
+ *
+ * The CLI owns `jiti` (already used to load `lumi.config.ts`), so
+ * `@murumets-ee/db` stays free of TS-runtime loader dependencies.
+ * Callers who never apply migrations (read-only servers, tests) never
+ * pay the loader cost.
+ */
+type MigrationLoader = (absolutePath: string) => Promise<MigrationModule>;
+/** Split discovered migrations into applied vs pending by consulting the tracking table. */
+declare function getMigrationStatus(db: PostgresJsDatabase, projectRoot: string): Promise<MigrationStatus>;
+/**
+ * Apply every pending migration in order.
+ *
+ * Each file runs inside its own transaction: the migration's `up()`
+ * executes first, then the `_toolkit_migrations` insert commits. If
+ * `up()` throws, the transaction rolls back and the whole command
+ * aborts — nothing gets half-applied.
+ *
+ * The `loader` callback is injected so `@murumets-ee/db` itself doesn't
+ * depend on a TS-runtime loader. Callers pass a jiti-backed loader from
+ * the CLI or their own equivalent.
+ */
+declare function runMigrations(db: PostgresJsDatabase, projectRoot: string, loader: MigrationLoader): Promise<void>;
+/**
+ * Roll back the most recent applied migration (or N most recent).
+ *
+ * Each file's `down()` runs in its own transaction. Files without a
+ * `down` export cause the rollback to abort before running anything —
+ * we never roll back some but not all of a requested batch.
+ */
+declare function rollbackMigrations(db: PostgresJsDatabase, projectRoot: string, loader: MigrationLoader, count?: number): Promise<void>;
+//#endregion
+//#region src/query-counter.d.ts
+/**
+ * Per-request DB query counter — opt-in, off by default.
+ *
+ * Wired into the Drizzle client when `LUMI_DB_QUERY_COUNTER=1`. The harness
+ * (apps/perf-harness) wraps each HTTP request in `runWithQueryStats` and emits
+ * the count as an `x-db-query-count` response header, so k6 scenarios can
+ * assert per-endpoint query budgets like:
+ *
+ *   checks: { 'findById ≤ 2 queries': (r) => r.headers['X-Db-Query-Count'] <= '2' }
+ *
+ * No-op for any code path that does not enter `runWithQueryStats` — the ALS
+ * store is undefined and `logQuery` returns immediately.
+ */
+interface QueryStats {
+  count: number;
+}
+declare function getQueryStats(): QueryStats | undefined;
+declare function runWithQueryStats<T>(fn: (stats: QueryStats) => Promise<T>): Promise<T>;
+declare const queryCountingLogger: Logger;
+declare function isQueryCounterEnabled(): boolean;
+//#endregion
+//#region src/schema-registry.d.ts
+/**
+ * Schema registry for storing Drizzle schemas
+ * This will be populated by @org/entity when schemas are generated from entity definitions
+ *
+ * We use PgTableWithColumns<any> because entity table schemas are dynamic (columns
+ * not known at compile time) and we need runtime property access (.id, .status, etc.).
+ * AnyPgTable won't work here — it doesn't expose column accessors.
+ */
+type AnyTable = PgTableWithColumns<any>;
+interface SchemaRegistry {
+  register(name: string, schema: AnyTable): void;
+  get(name: string): AnyTable | undefined;
+  all(): Record<string, AnyTable>;
+  has(name: string): boolean;
+}
+declare class SchemaRegistryImpl implements SchemaRegistry {
+  private schemas;
+  register(name: string, schema: AnyTable): void;
+  get(name: string): AnyTable | undefined;
+  all(): Record<string, AnyTable>;
+  has(name: string): boolean;
+}
+/**
+ * Global schema registry instance
+ * Entities will register their schemas here when they are defined
+ */
+declare const schemaRegistry: SchemaRegistryImpl;
+//#endregion
+//#region src/table/types.d.ts
+/**
+ * The discriminating "kind" tag for a column factory.
+ *
+ * Used at the type level to gate features that only make sense for certain
+ * kinds — e.g. only `'jsonb'` columns accept dotted-path keys in the
+ * where-builder.
+ */
+type ColumnKind = 'uuid' | 'varchar' | 'text' | 'integer' | 'bigint' | 'double' | 'boolean' | 'timestamp' | 'jsonb' | 'uuidArray';
+/**
+ * Internal column factory.
+ *
+ * A `ColumnFactory` is a callable that, given a column name, produces the
+ * corresponding Drizzle column builder. The phantom type parameters
+ * (`__type`, `__kind`, `__notNull`) are used purely for compile-time
+ * inference of {@link Row} and {@link InsertRow} types — they have no runtime
+ * representation beyond a small metadata object.
+ *
+ * Users do not construct `ColumnFactory` values directly; they use the
+ * `column.*` builders from `./columns.ts`.
+ */
+interface ColumnFactory<TType = unknown, TKind extends ColumnKind = ColumnKind, TNotNull extends boolean = boolean, THasDefault extends boolean = boolean> {
+  /** Build the underlying Drizzle column for the given column name. */
+  (name: string): PgColumnBuilderBase;
+  readonly __type: TType;
+  readonly __kind: TKind;
+  readonly __notNull: TNotNull;
+  readonly __hasDefault: THasDefault;
+  /**
+   * Optional explicit Postgres column name. When set, the column uses this
+   * name in the database instead of the JS property name. Needed when porting
+   * existing tables that use snake_case column names to `defineTable`.
+   */
+  readonly __pgName?: string;
+  /** True when the column is declared as a primary key at the column level. */
+  readonly __primaryKey?: boolean;
+}
+/**
+ * Convenience helper: extract the JS value type for a single column.
+ *
+ * - `notNull: true` → `T`
+ * - `notNull: false` → `T | null`
+ */
+type ColumnValue<C> = C extends ColumnFactory<infer T, ColumnKind, infer N> ? (N extends true ? T : T | null) : never;
+/**
+ * Map a columns record to its row shape (the result of a SELECT).
+ */
+type Row<TCols extends Record<string, ColumnFactory>> = { [K in keyof TCols]: ColumnValue<TCols[K]> };
+/**
+ * Map a columns record to its insert shape.
+ *
+ * - Required columns: must be supplied unless they have a default
+ * - Nullable columns: optional, accept `null`
+ * - Columns with defaults (`defaultRandom`, `defaultNow`, explicit `default`): optional
+ */
+type InsertRow<TCols extends Record<string, ColumnFactory>> = { [K in keyof TCols as TCols[K] extends ColumnFactory<unknown, ColumnKind, true, false> ? K : never]: ColumnValue<TCols[K]> } & { [K in keyof TCols as TCols[K] extends ColumnFactory<unknown, ColumnKind, true, false> ? never : K]?: ColumnValue<TCols[K]> };
+/**
+ * Operator object for a single column.
+ *
+ * Each property is a comparison operator. Combine with `$and` / `$or` /
+ * `$not` at the parent level to build composite predicates.
+ *
+ * `ilike` and `startsWith` accept user-supplied strings — the table client
+ * automatically escapes `%` and `_` in the value before wrapping with
+ * pattern wildcards, so callers cannot inject pattern characters by accident.
+ *
+ * @example
+ * ```ts
+ * { status: 'open' }                      // shorthand for { eq: 'open' }
+ * { status: { in: ['open', 'pending'] } }
+ * { createdAt: { gte: new Date('2026-01-01') } }
+ * { name: { ilike: 'foo%' } }             // % escaped from value, only outer wildcards work
+ * { description: { isNull: true } }
+ * ```
+ */
+type ColumnOperators<T> = T | null | {
+  eq: T;
+} | {
+  ne: T;
+} | {
+  in: T[];
+} | {
+  notIn: T[];
+} | {
+  gt: T;
+} | {
+  gte: T;
+} | {
+  lt: T;
+} | {
+  lte: T;
+} | {
+  isNull: true;
+} | {
+  isNotNull: true;
+} | {
+  ilike: string;
+} | {
+  startsWith: string;
+};
+/**
+ * The full WhereClause type.
+ *
+ * Keys are either column names or dotted-path keys for jsonb columns
+ * (e.g. `'metadata.author.name'`). Values are operator objects per
+ * {@link ColumnOperators}.
+ *
+ * Combine with `$and` / `$or` / `$not` for composite predicates. All
+ * top-level keys are implicitly AND-ed together.
+ *
+ * The type intentionally accepts `string` for jsonb-path keys rather than
+ * a precisely-narrowed template literal, because the path's nested type is
+ * unknown to the column definition. Path segments are validated at runtime
+ * against `/^[a-zA-Z_][a-zA-Z0-9_-]*$|^\d+$/` and the parent column must
+ * be a `jsonb` kind, otherwise the where-builder throws.
+ *
+ * @example
+ * ```ts
+ * // Simple equality
+ * { userId: 'u_123', status: 'active' }
+ *
+ * // Composite with $or
+ * { $or: [
+ *   { status: 'open' },
+ *   { status: 'pending', assignee: { isNull: true } },
+ * ] }
+ *
+ * // jsonb path access (column 'metadata' must be jsonb)
+ * { 'metadata.author.name': { ilike: 'alice%' } }
+ * ```
+ */
+type WhereClause<TCols extends Record<string, ColumnFactory>> = { [K in keyof TCols]?: ColumnOperators<ColumnValue<TCols[K]>> } & {
+  [key: `${string}.${string}`]: ColumnOperators<unknown>;
+} & {
+  $and?: WhereClause<TCols>[];
+  $or?: WhereClause<TCols>[];
+  $not?: WhereClause<TCols>;
+};
+/**
+ * A partial-index predicate for a table-level index / unique definition.
+ *
+ * Two forms are accepted:
+ *
+ *  - A plain {@link SQL} fragment (e.g. `sql`deleted_at IS NULL``). Use only
+ *    when the predicate references columns by their raw Postgres identifier —
+ *    fragile if the column is stored case-sensitively (Drizzle quotes column
+ *    identifiers), so prefer the callback form below.
+ *  - A callback `(columns) => SQL` that receives the table's **resolved**
+ *    Drizzle column objects (keyed by their JS property name). Interpolating a
+ *    resolved column into the fragment (`` (c) => sql`${c.isCanonical} = true` ``)
+ *    always emits the correct quoted identifier regardless of column casing.
+ *    This is the only place the resolved columns exist — they are produced
+ *    inside Drizzle's `pgTable(...)` constructor callback, AFTER `defineTable`
+ *    has been called — so a def-time `SQL` cannot reference them directly.
+ *
+ * Mirrors the `SchemaFragment.uniqueIndex.where` channel on the
+ * `@murumets-ee/entity` behavior `constraints()` API — same drizzle
+ * `uniqueIndex().on(...).where(sql)` mechanism, different (infra-table) surface.
+ *
+ * @remarks Use an INLINE boolean literal (`` sql`${col} = true` ``), NOT
+ *   `eq(col, true)` — the latter binds a `$1` parameter, which is invalid in
+ *   DDL ("there is no parameter $1").
+ *
+ * @remarks The callback param is typed as a loose `Record<string, AnyPgColumn>`
+ *   rather than the exact `{ [K in keyof TCols]: AnyPgColumn }`. That mapped
+ *   type would sit in a contravariant (function-argument) position of the
+ *   object passed to `defineTable<const TCols>`, which collapses `TCols` to the
+ *   base `Record<string, ColumnFactory>` and silently degrades `Row<TCols>` /
+ *   `InsertRow<TCols>` / `WhereClause<TCols>` to `unknown`-typed for EVERY table
+ *   that declares a partial `where` (neither `NoInfer<...>` nor `NoInfer` inside
+ *   `keyof` prevents the `const`-inference fallback here). The loose param keeps
+ *   `c.<col>` usable (each is `AnyPgColumn`, exactly what `sql`${col}`` needs)
+ *   while letting `TCols` be inferred solely from `columns`.
+ */
+type TablePredicate = SQL | ((columns: Record<string, AnyPgColumn$1>) => SQL);
+/**
+ * Index definition for a table.
+ *
+ * Indexes are declared at the table level (not per-column) so composite
+ * indexes are first-class. Each index gets an auto-generated name unless
+ * `name` is supplied: `idx_<table>_<col1>_<col2>`.
+ */
+interface IndexDefinition<TCols extends Record<string, ColumnFactory>> {
+  on: (keyof TCols)[];
+  name?: string;
+  /**
+   * Optional partial-index predicate — emits `CREATE INDEX ... WHERE <pred>`.
+   * See {@link TablePredicate}. Omit for a full index (unchanged behavior).
+   */
+  where?: TablePredicate;
+}
+/**
+ * Unique constraint definition.
+ *
+ * Composite uniques (multi-column) are declared here. Single-column
+ * uniqueness is also supported here rather than as a column-level option,
+ * to keep the column builder API uniform.
+ */
+interface UniqueDefinition<TCols extends Record<string, ColumnFactory>> {
+  on: (keyof TCols)[];
+  /**
+   * The constraint (or, with `where`, unique index) name in Postgres.
+   *
+   * Without it, a plain unique is named by drizzle — `<table>_<db col
+   * names>_unique`, using each column's `pgName` when set — and a partial
+   * unique is named `uq_<table>_<props>`. Either way `defineTable` throws when
+   * the resulting identifier exceeds Postgres's 63-character limit (which
+   * would otherwise truncate it silently); supply a shorter `name` then.
+   */
+  name?: string;
+  /**
+   * Optional partial-uniqueness predicate — emits a partial UNIQUE **INDEX**
+   * (`CREATE UNIQUE INDEX ... WHERE <pred>`) rather than a `UNIQUE` constraint,
+   * because Postgres only supports a predicate on a unique INDEX, never on a
+   * table-level `UNIQUE` constraint. When omitted, a plain `UNIQUE` constraint
+   * is emitted exactly as before (fully backward compatible). See
+   * {@link TablePredicate}.
+   */
+  where?: TablePredicate;
+}
+/**
+ * Declares that rows in this infrastructure table belong to an entity and
+ * should be cleaned up when that entity is deleted — the declarative
+ * replacement for hand-coded `db.delete(infraTable).where(...)` in routes.
+ *
+ * - `cascade`  → delete the dependent rows
+ * - `set-null` → null the FK column on the dependent rows (column must be nullable)
+ *
+ * The cleanup runs inside the entity-delete transaction via the table's own
+ * TableClient (no raw DB access escapes the typed-client layer).
+ */
+interface TableDependency<TCols extends Record<string, ColumnFactory>> {
+  /** Entity name whose deletion triggers this cleanup (e.g. 'ticket'). */
+  entity: string;
+  /** Column on THIS table holding the entity id. */
+  column: keyof TCols;
+  /** `restrict` is intentionally unsupported for infra dependencies. */
+  onDelete: 'cascade' | 'set-null';
+}
+/**
+ * The shape passed to `defineTable`.
+ *
+ * @example
+ * ```ts
+ * defineTable({
+ *   name: 'ticket_read_state',
+ *   columns: {
+ *     ticketId: column.uuid({ notNull: true }),
+ *     userId:   column.varchar({ length: 255, notNull: true }),
+ *     lastReadAt: column.timestamp({ notNull: true, defaultNow: true, withTimezone: true }),
+ *   },
+ *   primaryKey: ['ticketId', 'userId'],
+ *   indexes: [{ on: ['userId'] }],
+ * })
+ * ```
+ */
+interface TableDefinition<TCols extends Record<string, ColumnFactory>> {
+  /**
+   * Postgres table name. Convention: snake_case, prefix with package name
+   * (e.g. `toolkit_jobs`, `ticketing_read_state`).
+   *
+   * Validated at definition time against `/^[a-z][a-z0-9_]*$/` to prevent
+   * accidental quoting issues and to enforce a consistent naming scheme.
+   */
+  name: string;
+  columns: TCols;
+  /**
+   * Primary key column(s). May be a single column key or an array for
+   * composite keys.
+   *
+   * If omitted, the table has no primary key — only valid for tables that
+   * declare a column with `primaryKey: true` at the column level (e.g. via
+   * `column.uuid({ primaryKey: true, defaultRandom: true })`).
+   */
+  primaryKey?: keyof TCols | (keyof TCols)[];
+  unique?: UniqueDefinition<TCols>[];
+  indexes?: IndexDefinition<TCols>[];
+  /**
+   * Declarative cleanup when a referenced entity is deleted. The framework
+   * registers each entry and executes it (via TableClient) inside the
+   * entity-delete transaction. See {@link TableDependency}.
+   */
+  dependsOn?: TableDependency<TCols>[];
+  /**
+   * A column that CONFINES every client of this table to one value — the
+   * site of a site-bound entity's companion table (plan `multisite` D003).
+   *
+   * When set, `makeClient(db)` refuses to build a client without a partition
+   * value, and the client it builds with one:
+   * - ANDs `column = value` into every WHERE (reads, updates, deletes, claims,
+   *   counts, aggregates — including the calls that pass no WHERE at all);
+   * - stamps `column = value` on every inserted / upserted row, overwriting
+   *   whatever the caller passed;
+   * - prepends `column` to every upsert / tryClaim conflict target (the
+   *   table's uniques lead with it);
+   * - refuses a patch that tries to change `column`.
+   *
+   * A partitioned table therefore cannot be read or written unconfined by
+   * accident: forgetting the value is an error, not a wider result.
+   */
+  partitionColumn?: keyof TCols & string;
+}
+//#endregion
+//#region src/table/client.d.ts
+/**
+ * Default page size for `findMany` when no `limit` is supplied.
+ *
+ * Chosen as a safe upper bound for "show me a page of stuff" — anything
+ * above this should be paginated explicitly.
+ */
+declare const DEFAULT_LIMIT = 100;
+/**
+ * Hard cap on `findMany.limit`. Caller-supplied values above this are
+ * rejected with `TableClientError` (no clamping).
+ */
+declare const MAX_LIMIT = 1000;
+/**
+ * Hard cap on `insertMany.values.length` per single call.
+ */
+declare const MAX_BATCH = 1000;
+/**
+ * A custom error thrown by the table client for any caller-side mistake
+ * (empty where on update/delete, batch too large, malformed where, …).
+ *
+ * Database errors are NOT wrapped — they propagate as-is from postgres-js
+ * so callers can match on Postgres error codes.
+ */
+declare class TableClientError extends Error {
+  constructor(message: string);
+}
+/**
+ * Order-by spec accepted by `findMany`.
+ */
+interface OrderBySpec<TCols extends Record<string, ColumnFactory>> {
+  column: keyof TCols & string;
+  dir?: 'asc' | 'desc';
+}
+/**
+ * `findMany` options.
+ */
+interface FindManyOptions<TCols extends Record<string, ColumnFactory>> {
+  where?: WhereClause<TCols>;
+  orderBy?: OrderBySpec<TCols>[];
+  limit?: number;
+  offset?: number;
+}
+/**
+ * Options for the `claim()` atomic locking operation.
+ *
+ * @see {@link TableClient.claim}
+ */
+interface ClaimOptions<TCols extends Record<string, ColumnFactory>, TTable extends PgTable = PgTable> {
+  /** Filter for rows eligible to be claimed. Must be non-empty. */
+  where: WhereClause<TCols>;
+  /** Literal values to SET on claimed rows. */
+  set?: Partial<InferInsertModel<TTable>>;
+  /** Raw SQL expressions to SET (e.g. `{ attempts: sql\`attempts + 1\` }`). */
+  setSql?: Record<string, SQL>;
+  /** ORDER BY for the subselect — controls claim priority. */
+  orderBy?: OrderBySpec<TCols>[];
+  /** Maximum number of rows to claim. Must be 1..MAX_LIMIT. */
+  limit: number;
+}
+/**
+ * Options for the `tryClaim()` atomic insert-or-replace-if operation.
+ *
+ * @see {@link TableClient.tryClaim}
+ */
+interface TryClaimOptions<TCols extends Record<string, ColumnFactory>, TTable extends PgTable = PgTable> {
+  /**
+   * Unique-constraint column(s) that should trigger the conflict path.
+   *
+   * Single string for a single-column unique constraint; array for a
+   * composite unique. Must reference a real column on this table.
+   */
+  target: (keyof TCols & string) | (keyof TCols & string)[];
+  /**
+   * Predicate that decides whether an existing conflicting row may be
+   * **replaced**. Required and must be non-empty.
+   *
+   * - On INSERT (no conflict): always wins; predicate is irrelevant.
+   * - On CONFLICT + predicate matches: row is replaced; result is
+   *   `{ acquired: true, row }`.
+   * - On CONFLICT + predicate does NOT match: existing row is preserved;
+   *   result is `{ acquired: false, row }` (where `row` is the surviving
+   *   existing row).
+   *
+   * Use `$or` to express composite re-entrancy rules — e.g.
+   * `{ $or: [{ expiresAt: { lt: now } }, { lockedBy: callerId }] }` for
+   * "replace if expired, or if I already hold it".
+   */
+  replaceWhen: WhereClause<TCols>;
+  /**
+   * Patch applied on the replace path. Defaults to the full `values`
+   * payload (last-write-wins on the columns being inserted).
+   */
+  set?: Partial<InferInsertModel<TTable>>;
+}
+/**
+ * Specification for a single aggregate function.
+ */
+type AggregateSpec<TCols extends Record<string, ColumnFactory>> = {
+  fn: 'count';
+} | {
+  fn: 'count';
+  column: keyof TCols & string;
+} | {
+  fn: 'sum' | 'avg' | 'min' | 'max';
+  column: keyof TCols & string;
+};
+/**
+ * Options for the `aggregate()` method.
+ */
+interface AggregateOptions<TCols extends Record<string, ColumnFactory>> {
+  /** Named aggregate expressions. Each key becomes an output column. */
+  select: Record<string, AggregateSpec<TCols>>;
+  /** Columns to GROUP BY. Included automatically in the result. */
+  groupBy?: (keyof TCols & string)[];
+  /** Filter rows before aggregation (WHERE). */
+  where?: WhereClause<TCols>;
+  /** Order results. Can reference both grouped columns and aliases. */
+  orderBy?: OrderBySpec<TCols>[];
+  /** Limit the number of groups returned. */
+  limit?: number;
+}
+/**
+ * Generic CRUD client. Constructed by `defineTable` — never instantiated
+ * directly by callers.
+ *
+ * The same instance shape is exposed both at the top level (using the
+ * package's main `db` connection) and inside a `transaction()` callback
+ * (using the transactional `tx` handle), so user code is identical
+ * regardless of transactional context.
+ *
+ * @template TCols The columns record passed to `defineTable`. Drives the
+ *   where-builder DSL and the `Row<TCols>` / `InsertRow<TCols>` shapes.
+ * @template TTable The underlying Drizzle pgTable type, inferred from the
+ *   table value passed to `new TableClient(...)`. Carrying this through
+ *   lets `.insert().values(...)`, `.update().set(...)`, and `.returning()`
+ *   use Drizzle's own `InferInsertModel` / `InferSelectModel` instead of
+ *   falling back to `as never` casts.
+ */
+declare class TableClient<TCols extends Record<string, ColumnFactory>, TTable extends PgTable = PgTable> {
+  /** The Drizzle table object. Exposed via `defineTable().table` for typed JOINs. */
+  readonly table: TTable;
+  /** Per-column kind metadata. Used by the where-builder for jsonb path validation. */
+  private readonly columnKinds;
+  /**
+   * The active database handle. May be a top-level `PostgresJsDatabase`
+   * or a transaction handle of compatible shape — the client doesn't
+   * distinguish.
+   */
+  private readonly db;
+  /** Primary key column names. Required by `claim()`. Empty for tables without a declared PK. */
+  private readonly primaryKeyColumns;
+  /**
+   * The partition this client is confined to — see
+   * `TableDefinition.partitionColumn`. Absent for unpartitioned tables.
+   */
+  private readonly partition?;
+  /**
+   * @internal — instances are created by `defineTable()`.
+   */
+  constructor(/** The Drizzle table object. Exposed via `defineTable().table` for typed JOINs. */
+
+  table: TTable, /** Per-column kind metadata. Used by the where-builder for jsonb path validation. */
+
+  columnKinds: Readonly<Record<string, ColumnKind>>,
+  /**
+   * The active database handle. May be a top-level `PostgresJsDatabase`
+   * or a transaction handle of compatible shape — the client doesn't
+   * distinguish.
+   */
+
+  db: PostgresJsDatabase, /** Primary key column names. Required by `claim()`. Empty for tables without a declared PK. */
+
+  primaryKeyColumns?: readonly string[],
+  /**
+   * The partition this client is confined to — see
+   * `TableDefinition.partitionColumn`. Absent for unpartitioned tables.
+   */
+
+  partition?: {
+    readonly key: string;
+    readonly value: string;
+  } | undefined);
+  /** `partition.key = partition.value`, or `undefined` for an unpartitioned client. */
+  private partitionCondition;
+  /** AND the partition into `condition` (which may be absent). */
+  private confine;
+  /** Stamp the partition onto a row about to be inserted (overwriting the caller's value). */
+  private stamp;
+  /** Refuse a patch that would move a row out of its partition. */
+  private refusePartitionPatch;
+  /** Conflict-target keys with the partition column leading (the table's uniques lead with it). */
+  private partitionTarget;
+  /**
+   * The table typed as the non-generic `PgTable` base.
+   *
+   * Drizzle's `.from()` (select) uses a conditional type
+   * `TableLikeHasEmptySelection<TTable>` that TypeScript cannot evaluate
+   * against a bounded generic `TTable extends PgTable` — it can only
+   * resolve when the argument is the concrete base `PgTable`. `.insert()`,
+   * `.update()`, and `.delete()` have simpler signatures (`<T extends
+   * PgTable>(t: T)`) that DO accept the generic directly, so those call
+   * sites keep `this.table` and still get `InferInsertModel<TTable>` /
+   * `InferSelectModel<TTable>` inference for `.values()`, `.set()`, and
+   * `.returning()`.
+   */
+  private get _selectTable();
+  /**
+   * Look up a Drizzle column by its JS property name, throwing
+   * `TableClientError` with the supplied `context` if no such column exists.
+   * Wraps `getTableColumns(this.table)` — uses Drizzle's typed column map
+   * instead of an indexed cast on the table object.
+   */
+  private getColumnOrThrow;
+  /**
+   * Build an array of ORDER BY SQL expressions from an `OrderBySpec[]`.
+   * Used by `findMany`, `distinct`, `claim`, and `aggregate`.
+   */
+  private buildOrderBy;
+  /**
+   * Throw `TableClientError` if the where clause has no top-level keys.
+   * Used by every method that mutates or reads-by-key (`update`, `delete`,
+   * `findOne`, `exists`, `claim`, ...) — none of them have a sane
+   * "everything" path, so empty wheres are always a caller mistake.
+   */
+  private requireNonEmptyWhere;
+  /**
+   * Verify every key in `patch` names a real column on this table. Used by
+   * `update`, `updateMany`, `upsert`, and `claim` so a typo'd or hostile
+   * patch key surfaces a clear error instead of being silently dropped by
+   * Drizzle's set logic.
+   */
+  private validateColumnKeys;
+  /**
+   * Find a single row matching the given where clause, or `null` if no row
+   * matches. Throws if the where is empty.
+   *
+   * @example
+   * ```ts
+   * await readState.client.findOne({ ticketId: 't_1', userId: 'u_1' })
+   * ```
+   */
+  findOne(where: WhereClause<TCols>): Promise<Row<TCols> | null>;
+  /**
+   * Find multiple rows. Pagination, ordering, and filtering are all
+   * optional but `limit` is hard-capped at {@link MAX_LIMIT}.
+   *
+   * @example
+   * ```ts
+   * await jobs.client.findMany({
+   *   where: { status: 'pending', runAt: { lte: new Date() } },
+   *   orderBy: [{ column: 'priority', dir: 'desc' }, { column: 'runAt', dir: 'asc' }],
+   *   limit: 25,
+   * })
+   * ```
+   */
+  findMany(options?: FindManyOptions<TCols>): Promise<Row<TCols>[]>;
+  /**
+   * Count rows matching the where clause. Returns an exact count via
+   * `SELECT COUNT(*)`. For estimated/cached counts on large tables, see
+   * `countEstimate()` and `countCached()` (added in a follow-up PR).
+   *
+   * @example
+   * ```ts
+   * const open = await jobs.client.count({ status: 'pending' })
+   * ```
+   */
+  count(where?: WhereClause<TCols>): Promise<number>;
+  /**
+   * Returns `true` if at least one row matches the where clause. Always
+   * uses `LIMIT 1` and short-circuits — cheaper than `count() > 0` on
+   * large tables.
+   */
+  exists(where: WhereClause<TCols>): Promise<boolean>;
+  /**
+   * Return unique non-null values for a single column.
+   *
+   * Null values are excluded by default — pass `includeNull: true` to
+   * include them. Results can be filtered with `where` and ordered with
+   * `orderBy` (ascending or descending on the distinct column).
+   *
+   * @example Get distinct entity types from the audit log
+   * ```ts
+   * const types = await audit.client.distinct('entityType', { orderBy: 'asc' })
+   * ```
+   *
+   * @example Distinct with a filter
+   * ```ts
+   * const actions = await audit.client.distinct('action', {
+   *   where: { userId: 'u_1' },
+   *   orderBy: 'asc',
+   * })
+   * ```
+   */
+  distinct<K extends keyof TCols & string>(column: K, options?: {
+    where?: WhereClause<TCols>;
+    orderBy?: 'asc' | 'desc'; /** Include null values in the result. Defaults to `false`. */
+    includeNull?: boolean;
+  }): Promise<ColumnValue<TCols[K]>[]>;
+  /**
+   * Insert a single row. Returns the inserted row (server-generated
+   * defaults populated).
+   */
+  insert(values: InferInsertModel<TTable>): Promise<Row<TCols>>;
+  /**
+   * Upsert: insert a row, or update an existing row if a unique constraint
+   * conflict occurs.
+   *
+   * `target` names the column(s) whose unique constraint should trigger
+   * the conflict path. `set` is the patch applied on conflict — when
+   * omitted, the conflict path applies the same `values` (i.e. "last
+   * write wins").
+   *
+   * `setWhere` adds a conditional WHERE to the conflict update path. If
+   * the condition does not match, the update is skipped and the existing
+   * row is returned unchanged (via a fallback SELECT). This enables
+   * patterns like "only update if the new version is higher than the
+   * existing one".
+   *
+   * @example Idempotent "mark as read" tracking
+   * ```ts
+   * await readState.client.upsert(
+   *   { ticketId, userId, lastReadAt: new Date() },
+   *   { target: ['ticketId', 'userId'] },
+   * )
+   * ```
+   *
+   * @example Conditional update — only bump if newer
+   * ```ts
+   * await state.client.upsert(
+   *   { key: 'sync', version: 5, data: '...' },
+   *   { target: 'key', setWhere: { version: { lt: 5 } } },
+   * )
+   * ```
+   *
+   * `mergeJsonb` names jsonb columns whose conflict path MERGES instead of
+   * replacing: the stored object becomes `stored || incoming` — a top-level,
+   * right-wins merge, evaluated by Postgres inside the one `ON CONFLICT`
+   * statement. Use it when two writers may each own part of one jsonb object and
+   * a read-then-write would let the later writer erase the earlier one's keys.
+   * The insert path is unaffected (there is nothing to merge with). A stored SQL
+   * NULL or JSON `null` merges as `{}`. The incoming value must be a JSON object
+   * — `||` concatenates arrays and scalars instead of merging — and a key named
+   * in both `set` and `mergeJsonb` is merged (the merge wins).
+   *
+   * @example Merge a partial patch into a staged document
+   * ```ts
+   * await drafts.client.upsert(
+   *   { entityId, locale, data: { title: 'New' }, updatedAt: now },
+   *   { target: ['entityId', 'locale'], set: { updatedAt: now }, mergeJsonb: ['data'] },
+   * )
+   * ```
+   */
+  upsert(values: InferInsertModel<TTable>, opts: {
+    target: (keyof TCols & string) | (keyof TCols & string)[];
+    set?: Partial<InferInsertModel<TTable>>; /** Conditional WHERE on the conflict update path. Empty objects are ignored. */
+    setWhere?: WhereClause<TCols>; /** jsonb columns merged (`stored || incoming`) rather than replaced on conflict. */
+    mergeJsonb?: readonly (keyof TCols & string)[];
+  }): Promise<Row<TCols>>;
+  /**
+   * Atomically claim a row by either inserting it or replacing an existing
+   * conflicting row that satisfies `replaceWhen`. The single SQL statement
+   * makes this race-free — concurrent callers cannot both observe an empty
+   * slot and both INSERT.
+   *
+   * Distinct from {@link upsert}:
+   * - `upsert` always wins on conflict (or hits its `setWhere` block and
+   *   silently falls back to the existing row). It returns a single
+   *   `Row<TCols>` and the caller cannot tell which path fired.
+   * - `tryClaim` returns a discriminated union — the caller knows whether
+   *   they took the slot or someone else still holds it.
+   *
+   * Use case: leasing/locking primitives where the caller must distinguish
+   * "I now hold this lock" from "someone else holds it, here is who".
+   *
+   * @example Acquire a lock, replacing only if expired
+   * ```ts
+   * const result = await locks.tryClaim(
+   *   { entityId, lockedBy: me, expiresAt: in5Min },
+   *   {
+   *     target: 'entityId',
+   *     replaceWhen: { expiresAt: { lt: now } },
+   *   },
+   * )
+   * if (result.acquired) {
+   *   // I have the lock
+   * } else {
+   *   // result.row.lockedBy holds it (and lock is fresh)
+   * }
+   * ```
+   *
+   * @example Re-entrant lock (claim if expired, or if I already hold it)
+   * ```ts
+   * await locks.tryClaim(
+   *   { entityId, lockedBy: me, expiresAt: in5Min },
+   *   {
+   *     target: 'entityId',
+   *     replaceWhen: { $or: [{ expiresAt: { lt: now } }, { lockedBy: me }] },
+   *   },
+   * )
+   * ```
+   */
+  tryClaim(values: InferInsertModel<TTable>, opts: TryClaimOptions<TCols, TTable>): Promise<{
+    acquired: true;
+    row: Row<TCols>;
+  } | {
+    acquired: false;
+    row: Row<TCols>;
+  }>;
+  /**
+   * Insert many rows in a single statement. Capped at {@link MAX_BATCH}.
+   * Returns all inserted rows in input order.
+   */
+  insertMany(values: InferInsertModel<TTable>[]): Promise<Row<TCols>[]>;
+  /**
+   * Update **at most one** row matching the where clause. Returns the
+   * updated row, or `null` if no row matched.
+   *
+   * Throws `TableClientError` if:
+   * - the where is empty
+   * - the where matches more than one row
+   *
+   * The multi-row guard exists to prevent silent bulk updates from a
+   * mistakenly-broad where. If you genuinely want to update multiple
+   * rows in one call, use {@link updateMany}, which is explicit about
+   * its plurality.
+   *
+   * Implementation note: this issues a single `UPDATE … RETURNING` and
+   * inspects the returned row count *after* the fact. The extra rows
+   * over the wire are the cost of the safety check; the alternative
+   * (a SELECT round-trip first) would be more rows AND a race window.
+   * If the affected count is > 1 the update has *already* happened —
+   * the throw is to surface the bug, not to prevent it. Wrap in a
+   * transaction if you need atomic rollback.
+   */
+  update(where: WhereClause<TCols>, patch: Partial<InferInsertModel<TTable>>): Promise<Row<TCols> | null>;
+  /**
+   * Update all rows matching the where clause. Returns every updated row.
+   * Throws if the where is empty — there is no "update everything" path.
+   */
+  updateMany(where: WhereClause<TCols>, patch: Partial<InferInsertModel<TTable>>): Promise<Row<TCols>[]>;
+  /**
+   * Delete **at most one** row matching the where clause. Returns the
+   * deleted row, or `null` if no row matched.
+   *
+   * Throws `TableClientError` if:
+   * - the where is empty
+   * - the where matches more than one row
+   *
+   * Same multi-row safety guard as {@link update}. Use {@link deleteMany}
+   * for explicit bulk deletes.
+   *
+   * Implementation note: same as `update` — the delete has already
+   * happened by the time the throw fires. Wrap in a transaction if you
+   * need atomic rollback.
+   */
+  delete(where: WhereClause<TCols>): Promise<Row<TCols> | null>;
+  /**
+   * Delete all rows matching the where clause. Returns every deleted row.
+   * Throws if the where is empty — there is no "delete everything" path.
+   */
+  deleteMany(where: WhereClause<TCols>): Promise<Row<TCols>[]>;
+  /**
+   * Run a callback inside a database transaction. The callback receives a
+   * transactional `TableClient` instance with the same shape as the
+   * top-level client — write code identically inside or outside.
+   *
+   * Throwing from the callback rolls back; returning a value commits.
+   *
+   * @example
+   * ```ts
+   * await files.client.transaction(async (tx) => {
+   *   const row = await tx.insert(values)
+   *   await adapter.upload(row.key, buffer)  // if this throws, the row is rolled back
+   *   return row
+   * })
+   * ```
+   */
+  transaction<T>(fn: (tx: TableClient<TCols, TTable>) => Promise<T>): Promise<T>;
+  /**
+   * Atomically claim rows using `FOR UPDATE SKIP LOCKED`.
+   *
+   * Selects rows matching `where`, locks them (skipping any already locked
+   * by another worker), updates them with `set`/`setSql`, and returns the
+   * claimed rows in a single atomic operation. This is the standard pattern
+   * for job queues, task distribution, and any producer-consumer table.
+   *
+   * Requires the table to have a declared primary key (either via
+   * `column.uuid({ primaryKey: true })` or `defineTable({ primaryKey })`.
+   *
+   * @example Job queue claim
+   * ```ts
+   * const jobs = await client.claim({
+   *   where: { status: 'pending', runAt: { lte: new Date() } },
+   *   set: { status: 'processing', lockedBy: workerId, lockedAt: new Date() },
+   *   setSql: { attempts: sql`${jobsTable.table.attempts} + 1` },
+   *   orderBy: [{ column: 'priority', dir: 'desc' }, { column: 'createdAt', dir: 'asc' }],
+   *   limit: 5,
+   * })
+   * ```
+   */
+  claim(options: ClaimOptions<TCols, TTable>): Promise<Row<TCols>[]>;
+  /**
+   * Run an aggregate query with GROUP BY.
+   *
+   * Each key in `select` is an output alias mapped to an aggregate
+   * specification. The `groupBy` columns are included automatically in
+   * the result. Returns typed rows with grouped column values plus the
+   * computed aggregates.
+   *
+   * @example Count jobs by status
+   * ```ts
+   * const rows = await client.aggregate({
+   *   select: { count: { fn: 'count' } },
+   *   groupBy: ['status'],
+   * })
+   * // → [{ status: 'pending', count: 12 }, { status: 'completed', count: 45 }]
+   * ```
+   *
+   * @example Average priority of open jobs
+   * ```ts
+   * const [row] = await client.aggregate({
+   *   select: { avgPriority: { fn: 'avg', column: 'priority' } },
+   *   where: { status: 'open' },
+   * })
+   * ```
+   */
+  aggregate<TResult extends Record<string, unknown> = Record<string, unknown>>(options: AggregateOptions<TCols>): Promise<TResult[]>;
+  /**
+   * Fast approximate row count using Postgres `reltuples` statistics.
+   *
+   * Returns the estimated row count from `pg_class` — updated by
+   * `ANALYZE` and autovacuum. Much faster than `COUNT(*)` on large
+   * tables (no sequential scan), but may be stale by up to a few
+   * percent. Returns 0 for tables that have never been analyzed.
+   *
+   * Use `count()` when you need an exact number. Use `countEstimate()`
+   * for UI display, pagination hints, or "is this table large?" checks
+   * where ±5% accuracy is fine.
+   *
+   * @example
+   * ```ts
+   * const approx = await client.countEstimate()
+   * if (approx > 100_000) {
+   *   // Switch to keyset pagination instead of offset
+   * }
+   * ```
+   */
+  countEstimate(): Promise<number>;
+  /** Build a single aggregate SQL expression from a spec. */
+  private buildAggregateExpr;
+  private buildWhereOrThrow;
+  private validateLimit;
+}
+//#endregion
+//#region src/table/columns.d.ts
+/**
+ * Type interface for the `column` builder namespace.
+ *
+ * Overloads discriminate on whether `default` is present, so
+ * `THasDefault` is inferred correctly:
+ *
+ * - `column.varchar({ length: 20, default: 'x' })` → `hasDefault = true`
+ * - `column.varchar({ length: 20 })`               → `hasDefault = false`
+ *
+ * Object-literal methods don't support overloads in TypeScript, so we
+ * declare the overloaded signatures on an interface and cast the
+ * implementation object.
+ */
+interface ColumnBuilders {
+  uuid<TPrimaryKey extends boolean = false, TNotNull extends boolean = false, THasDefault extends boolean = false>(opts?: {
+    primaryKey?: TPrimaryKey;
+    notNull?: TNotNull;
+    defaultRandom?: THasDefault;
+    pgName?: string;
+  }): ColumnFactory<string, 'uuid', TPrimaryKey extends true ? true : TNotNull extends true ? true : false, TPrimaryKey extends true ? true : THasDefault extends true ? true : false>;
+  varchar<TNotNull extends boolean = false>(opts: {
+    length: number;
+    notNull?: TNotNull;
+    default: string;
+    pgName?: string;
+  }): ColumnFactory<string, 'varchar', TNotNull extends true ? true : false, true>;
+  varchar<TNotNull extends boolean = false>(opts: {
+    length: number;
+    notNull?: TNotNull;
+    pgName?: string;
+  }): ColumnFactory<string, 'varchar', TNotNull extends true ? true : false, false>;
+  text<TNotNull extends boolean = false>(opts: {
+    notNull?: TNotNull;
+    default: string;
+    pgName?: string;
+  }): ColumnFactory<string, 'text', TNotNull extends true ? true : false, true>;
+  text<TNotNull extends boolean = false>(opts?: {
+    notNull?: TNotNull;
+    pgName?: string;
+  }): ColumnFactory<string, 'text', TNotNull extends true ? true : false, false>;
+  integer<TNotNull extends boolean = false>(opts: {
+    notNull?: TNotNull;
+    default: number;
+    pgName?: string;
+  }): ColumnFactory<number, 'integer', TNotNull extends true ? true : false, true>;
+  integer<TNotNull extends boolean = false>(opts?: {
+    notNull?: TNotNull;
+    pgName?: string;
+  }): ColumnFactory<number, 'integer', TNotNull extends true ? true : false, false>;
+  bigint<TMode extends 'number' | 'bigint' = 'number', TNotNull extends boolean = false>(opts: {
+    mode?: TMode;
+    notNull?: TNotNull;
+    default: TMode extends 'bigint' ? bigint : number;
+    pgName?: string;
+  }): ColumnFactory<TMode extends 'bigint' ? bigint : number, 'bigint', TNotNull extends true ? true : false, true>;
+  bigint<TMode extends 'number' | 'bigint' = 'number', TNotNull extends boolean = false>(opts?: {
+    mode?: TMode;
+    notNull?: TNotNull;
+    pgName?: string;
+  }): ColumnFactory<TMode extends 'bigint' ? bigint : number, 'bigint', TNotNull extends true ? true : false, false>;
+  double<TNotNull extends boolean = false>(opts: {
+    notNull?: TNotNull;
+    default: number;
+    pgName?: string;
+  }): ColumnFactory<number, 'double', TNotNull extends true ? true : false, true>;
+  double<TNotNull extends boolean = false>(opts?: {
+    notNull?: TNotNull;
+    pgName?: string;
+  }): ColumnFactory<number, 'double', TNotNull extends true ? true : false, false>;
+  boolean<TNotNull extends boolean = false>(opts: {
+    notNull?: TNotNull;
+    default: boolean;
+    pgName?: string;
+  }): ColumnFactory<boolean, 'boolean', TNotNull extends true ? true : false, true>;
+  boolean<TNotNull extends boolean = false>(opts?: {
+    notNull?: TNotNull;
+    pgName?: string;
+  }): ColumnFactory<boolean, 'boolean', TNotNull extends true ? true : false, false>;
+  timestamp<TNotNull extends boolean = false, THasDefault extends boolean = false>(opts?: {
+    notNull?: TNotNull;
+    defaultNow?: THasDefault;
+    withTimezone?: boolean;
+    pgName?: string;
+  }): ColumnFactory<Date, 'timestamp', TNotNull extends true ? true : false, THasDefault extends true ? true : false>;
+  jsonb<T = unknown, TNotNull extends boolean = false>(opts: {
+    notNull?: TNotNull;
+    default: T;
+    pgName?: string;
+  }): ColumnFactory<T, 'jsonb', TNotNull extends true ? true : false, true>;
+  jsonb<T = unknown, TNotNull extends boolean = false>(opts?: {
+    notNull?: TNotNull;
+    pgName?: string;
+  }): ColumnFactory<T, 'jsonb', TNotNull extends true ? true : false, false>;
+  uuidArray<TNotNull extends boolean = false>(opts?: {
+    notNull?: TNotNull;
+    pgName?: string;
+  }): ColumnFactory<string[], 'uuidArray', TNotNull extends true ? true : false, false>;
+}
+/**
+ * Column builder namespace — overloaded interface applied via single
+ * assertion. Each builder's implementation returns `makeFactory(...)` with
+ * widened boolean params; the `ColumnBuilders` overloads narrow them for
+ * callers based on whether `default`/`primaryKey` etc. are present.
+ */
+declare const column: ColumnBuilders;
+//#endregion
+//#region src/table/define.d.ts
+/**
+ * The result of `defineTable()`.
+ *
+ * @template TCols The columns record passed to `defineTable`.
+ * @template TTable The concrete Drizzle `pgTable` type produced by the
+ *   definition. Defaulted to the non-generic `PgTable` for callers that
+ *   pass `DefinedTable` around without propagating inference — inside
+ *   `defineTable` itself, the actual `typeof table` is captured so
+ *   `makeClient` returns a fully-typed `TableClient<TCols, typeof table>`.
+ */
+interface DefinedTable<TCols extends Record<string, ColumnFactory>, TTable extends PgTable = PgTableWithColumns<TableConfig>> {
+  /**
+   * The underlying Drizzle `pgTable`. Exposed so callers can use it in
+   * typed JOINs (the one sanctioned escape valve), and so it can be
+   * included in `Plugin.tables` for migration discovery by `lumi migrate`.
+   */
+  table: TTable;
+  /**
+   * The original schema metadata. Useful for introspection / tooling
+   * that needs to know about indexes, unique constraints, etc.
+   */
+  schema: TableDefinition<TCols>;
+  /**
+   * Per-column kind metadata (column name → kind tag). Used internally
+   * by the where-builder for jsonb path validation.
+   */
+  columnKinds: Readonly<Record<string, ColumnKind>>;
+  /**
+   * Primary key column names (JS property names). Detected from either
+   * `schema.primaryKey` or column-level `{ primaryKey: true }`. Empty
+   * array if no PK is declared. Required by `claim()`.
+   */
+  primaryKeyColumns: readonly string[];
+  /**
+   * Build a typed CRUD client wired to the given database handle.
+   *
+   * Callers typically construct one client per logical "module" and
+   * cache it. The client is stateless aside from the db handle, so it
+   * is safe to share.
+   */
+  makeClient(db: PostgresJsDatabase, partitionValue?: string): TableClient<TCols, TTable>;
+  /** The confining column, when the table declares one (`partitionColumn`). */
+  partitionColumn?: string | undefined;
+}
+/**
+ * Define a typed table.
+ *
+ * The function signature uses two const-generic parameters to preserve
+ * column literal types end-to-end. This is what enables `Row`,
+ * `InsertRow`, and `WhereClause` to know exact column shapes at the call
+ * site.
+ *
+ * @throws if the table name doesn't match the snake_case regex, or if
+ *   the same name is registered twice with different table objects.
+ */
+declare function defineTable<const TCols extends Record<string, ColumnFactory>>(def: TableDefinition<TCols>): {
+  table: PgTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+      [x: string]: import("drizzle-orm/pg-core").PgColumn<{
+        name: string;
+        tableName: string;
+        dataType: import("drizzle-orm").ColumnDataType;
+        columnType: string;
+        data: unknown;
+        driverParam: unknown;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: string[] | undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {}>;
+    };
+    dialect: "pg";
+  }>;
+  schema: TableDefinition<TCols>;
+  columnKinds: Readonly<Record<string, ColumnKind>>;
+  primaryKeyColumns: readonly string[];
+  makeClient: (database: PostgresJsDatabase, partitionValue?: string) => TableClient<TCols, PgTableWithColumns<{
+    name: string;
+    schema: undefined;
+    columns: {
+      [x: string]: import("drizzle-orm/pg-core").PgColumn<{
+        name: string;
+        tableName: string;
+        dataType: import("drizzle-orm").ColumnDataType;
+        columnType: string;
+        data: unknown;
+        driverParam: unknown;
+        notNull: false;
+        hasDefault: false;
+        isPrimaryKey: false;
+        isAutoincrement: false;
+        hasRuntimeDefault: false;
+        enumValues: string[] | undefined;
+        baseColumn: never;
+        identity: undefined;
+        generated: undefined;
+      }, {}, {}>;
+    };
+    dialect: "pg";
+  }>>;
+  partitionColumn: (keyof TCols & string) | undefined;
+};
+//#endregion
+//#region src/table/dependency-registry.d.ts
+/** Runs the typed cleanup for one dependency, inside the caller's tx. */
+type DependentCleanup = (tx: PostgresJsDatabase, entityIds: string[]) => Promise<void>;
+/** A single table→entity cleanup descriptor produced by `defineTable`. */
+interface TableCleanupDescriptor {
+  /** Entity whose deletion triggers this cleanup. */
+  entity: string;
+  /** The typed, tx-bound cleanup executor. */
+  cleanup: DependentCleanup;
+}
+/** Register a cleanup executor for `entityName`. Called by the merge step. */
+declare function registerDependentCleanup(entityName: string, cleanup: DependentCleanup): void;
+/** All cleanup executors declared as depending on `entityName` (may be empty). */
+declare function getDependentCleanups(entityName: string): readonly DependentCleanup[];
+/** Test seam — clears all entity-keyed registrations. */
+declare function __clearDependentCleanups(): void;
+/** Read the cleanup descriptors for a raw Drizzle table (may be empty). */
+declare function getTableCleanupDescriptors(table: Table): readonly TableCleanupDescriptor[];
+/**
+ * The column a raw Drizzle table is partitioned by (`TableDefinition.
+ * partitionColumn`), or `undefined`. Lets whole-install maintenance — the one
+ * sanctioned site rename (`lumi site:rename-default`) — find every table that
+ * keys rows by a site handle without an FK to cascade through.
+ */
+declare function getTablePartitionColumn(table: Table): string | undefined;
+//#endregion
+//#region src/table/registry.d.ts
+declare class TableRegistryImpl {
+  private byName;
+  /** Table names we've already surfaced a bundler-duplicate warning for (once per name). */
+  private warnedDuplicates;
+  /**
+   * Register a defined table. Throws if a table with the same name is
+   * already registered (catches accidental double-registration from a
+   * file being imported under two paths).
+   */
+  register(name: string, table: PgTable, source?: string): void;
+  /**
+   * Get a defined table by name.
+   */
+  get(name: string): PgTable | undefined;
+  /**
+   * Returns true if a table with the given name has been registered.
+   */
+  has(name: string): boolean;
+  /**
+   * Return every registered table as a `{ [name]: PgTable }` map.
+   *
+   * Useful for `createTestDb().push(tableRegistry.allTables())` and
+   * runtime introspection.
+   */
+  allTables(): Record<string, PgTable>;
+  /**
+   * Clear the registry. **Test-only.**
+   *
+   * Production code should never call this — clearing the registry
+   * silently breaks migration discovery and any code path that looks
+   * up a table by name. The runtime guard below refuses to run when
+   * `NODE_ENV === 'production'` to catch accidental misuse.
+   *
+   * Test runners typically set `NODE_ENV=test` (Vitest does), but the
+   * guard is permissive about other values — it only blocks the one
+   * environment where calling it is definitely wrong.
+   */
+  clear(): void;
+}
+/**
+ * Process-wide table registry singleton.
+ *
+ * Tables register themselves on import via `defineTable()`. The registry
+ * is module-level state, which means a single Node process sees one
+ * consistent view of all defined tables across packages.
+ */
+declare const tableRegistry: TableRegistryImpl;
+//#endregion
+//#region src/table/where-builder.d.ts
+/**
+ * A custom error thrown by the where-builder for any caller-side mistake.
+ *
+ * Catching `WhereBuilderError` lets the table client surface a 400-style
+ * error to its caller without conflating it with database errors.
+ */
+declare class WhereBuilderError extends Error {
+  constructor(message: string);
+}
+/**
+ * Returns true if a {@link WhereClause} produces a non-trivial filter (at
+ * least one column predicate or sub-clause). Useful for rejecting empty
+ * `where` arguments to `update`/`delete`/`updateMany`/`deleteMany`.
+ *
+ * Note: this does not check whether `buildWhere()` would actually emit SQL
+ * for the clause — it just checks that the user supplied something.
+ */
+declare function isNonEmptyWhere(clause: unknown): boolean;
+//#endregion
+//#region src/transaction-hooks.d.ts
+/** Work to run once the transaction it was registered on has committed. */
+type CommitCallback = () => void | Promise<void>;
+/**
+ * Install on-commit tracking on a read-write client, in place, and return it.
+ *
+ * Idempotent: a client that is already tracked is returned untouched, so a
+ * callback never runs twice because two layers each installed tracking.
+ */
+declare function trackTransactions<TDb extends PostgresJsDatabase>(db: TDb): TDb;
+/**
+ * Register `callback` to run after the transaction `executor` belongs to
+ * commits. Returns `true` when it was registered, and `false` — having done
+ * nothing — when `executor` is not an open tracked transaction, in which case
+ * the caller decides whether to run the work now.
+ */
+declare function onCommit(executor: object | null | undefined, callback: CommitCallback): boolean;
+/** Whether `executor` is a transaction handle that is open and tracked right now. */
+declare function isTrackedTransaction(executor: object | null | undefined): boolean;
+//#endregion
+export { type AdvisoryLockKey, type AdvisoryLockResult, type AnyPgColumn, type ClaimOptions, type ColumnFactory, type ColumnKind, type ColumnOperators, type ColumnValue, type CommitCallback, DEFAULT_LIMIT, DEFAULT_READ_ONLY_STATEMENT_TIMEOUT_MS, DEPLOY_STEPS_LOCK, DEPLOY_STEPS_TABLE_NAME, DEPLOY_STEP_STATES, type DbConfig, type DefinedTable, type DependentCleanup, type DeployStepState, EXTENSION_NAME_PATTERN, type FindManyOptions, type IndexDefinition, type InsertRow, MAX_BATCH, MAX_LIMIT, MAX_STATEMENT_TIMEOUT_MS, type MigrateArgs, type MigrationLoader, type MigrationModule, type MigrationSource, type MigrationStatus, type OrderBySpec, type QueryStats, type Row, type SchemaRegistry, TOOLKIT_ADVISORY_LOCK_SPACE, type TableCleanupDescriptor, TableClient, TableClientError, type TableDefinition, type TableDependency, type UniqueDefinition, WhereBuilderError, type WhereClause, __clearDependentCleanups, assertValidExtensionName, column, createDbClient, createExtensionStatement, createListenClient, createReadOnlyClient, defineTable, deployStepsTable, getDependentCleanups, getMigrationStatus, getQueryStats, getTableCleanupDescriptors, getTablePartitionColumn, isNonEmptyWhere, isQueryCounterEnabled, isTrackedTransaction, onCommit, parseStatementTimeoutEnv, queryCountingLogger, registerDependentCleanup, rollbackMigrations, runMigrations, runWithQueryStats, schemaRegistry, tableRegistry, toolkitDeploySteps, trackTransactions, withAdvisoryLock };
+//# sourceMappingURL=index.d.mts.map