okmodel 0.4.0 → 0.5.1

package/dist/runtime/pg/bun.d.ts

@@ -1,13 +1,14 @@
 /**
  * `connect` for Bun.sql (`okmodel/pg/bun`).
  *
- * One URL or an existing pool is one endpoint. The client is typed by the
- * schema passed in. This entry runs on Bun. Node cannot load the `bun` import
- * inside the adapter.
+ * A string or an existing pool is one endpoint. A `{ primary, replicas }` object
+ * loads the topology module. The client is typed by the schema passed in.
+ * This entry runs on Bun. Node cannot load the `bun` import inside the adapter.
  */
 import type { DriverPool } from "../../contracts/driver.js";
 import type { QuerySchema } from "../../dialects/pg/model.js";
 import { type BunSqlConfig } from "../../adapters/pg/bunsql.js";
+import type { RoutedClient, TopologyInput, TopologyOptions } from "../topology.js";
 import type { ConnectOptions, Connected } from "../types.js";
 export { open, type BunSqlConfig, type BunSqlTls } from "../../adapters/pg/bunsql.js";
 export { capabilities, hasCapability, readCapability } from "../../adapters/pg/bunsql.js";
@@ -15,16 +16,20 @@ export { DriverError } from "../../adapters/error.js";
 /** A connection string or a pool from {@link open}. */
 export type BunSqlTarget = string | DriverPool;
 /** Driver options `connect` forwards to {@link open}. */
-export type BunSqlConnectOptions<S extends QuerySchema> = ConnectOptions<S> & Omit<BunSqlConfig, "url">;
+export type BunSqlConnectOptions<S extends QuerySchema> = ConnectOptions<S> & Omit<BunSqlConfig, "url"> & TopologyOptions;
 /**
- * Connects one Postgres endpoint through Bun.sql and returns a client for `schema`.
+ * Connects one Postgres endpoint through Bun.sql, or a primary and its replicas.
+ *
+ * A string or a pool is one endpoint. A topology loads on demand and the promise
+ * resolves to the client. Reads use the first healthy replica.
  *
  * Named prepared statements are off unless `prepared` is `"named"`.
  * `prepared: "named"` is not for transaction-mode poolers.
  *
  * @typeParam S - Schema
- * @param target - URL or an existing pool
+ * @param target - URL, an existing pool, or `{ primary, replicas }`
  * @param options - Schema, errors, logger, and driver options
- * @returns The client. Await `connected` for the dialect check
+ * @returns The client. A topology returns a promise. Await `connected` for the dialect check
  */
+export declare function connect<const S extends QuerySchema>(target: TopologyInput, options: BunSqlConnectOptions<S>): Promise<RoutedClient<S>>;
 export declare function connect<const S extends QuerySchema>(target: BunSqlTarget, options: BunSqlConnectOptions<S>): Connected<S>;

package/dist/runtime/pg/bun.js

@@ -1,20 +1,23 @@
 import {
   DriverError2
-} from "../../shared/kyxb62mc.js";
+} from "../../shared/31vm914h.js";
 import {
   open5
-} from "../../shared/sf8m6tfy.js";
+} from "../../shared/k8v5v5wj.js";
 import {
   BUNSQL_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "../../shared/rrstp3kb.js";
+} from "../../shared/cgbamx3e.js";
 import {
   createClient
-} from "../../shared/kkzwp3d2.js";
+} from "../../shared/hf22e0wt.js";
 
 // src/runtime/pg/bun.ts
 function connect(target, options) {
+  if (typeof target === "object" && !isPool(target)) {
+    return import("../../shared/nxdp2ze3.js").then((mod) => mod.default(target, options, open5));
+  }
   const owned = !isPool(target);
   const pool = isPool(target) ? target : open5({
     url: target,

package/dist/runtime/pg/pg.d.ts

@@ -1,12 +1,14 @@
 /**
  * `connect` for node-postgres (`okmodel/pg/pg`).
  *
- * One URL or an existing pool is one endpoint. The client is typed by the
- * schema passed in, not by `Register`.
+ * A string or an existing pool is one endpoint. A `{ primary, replicas }` object
+ * loads the topology module. The client is typed by the schema passed in, not
+ * by `Register`.
  */
 import type { DriverPool } from "../../contracts/driver.js";
 import type { QuerySchema } from "../../dialects/pg/model.js";
 import { type NodePostgresConfig } from "../../adapters/pg/nodepostgres.js";
+import type { RoutedClient, TopologyInput, TopologyOptions } from "../topology.js";
 import type { ConnectOptions, Connected } from "../types.js";
 export { open, type NodePostgresConfig } from "../../adapters/pg/nodepostgres.js";
 export { capabilities, hasCapability, readCapability } from "../../adapters/pg/nodepostgres.js";
@@ -14,16 +16,20 @@ export { DriverError } from "../../adapters/error.js";
 /** A connection string or a pool from {@link open}. */
 export type NodePostgresTarget = string | DriverPool;
 /** Driver options `connect` forwards to {@link open}. */
-export type NodePostgresConnectOptions<S extends QuerySchema> = ConnectOptions<S> & Omit<NodePostgresConfig, "url">;
+export type NodePostgresConnectOptions<S extends QuerySchema> = ConnectOptions<S> & Omit<NodePostgresConfig, "url"> & TopologyOptions;
 /**
- * Connects one Postgres endpoint through node-postgres and returns a client for `schema`.
+ * Connects one Postgres endpoint through node-postgres, or a primary and its replicas.
+ *
+ * A string or a pool is one endpoint. A topology loads on demand and the promise
+ * resolves to the client. Reads use the first healthy replica.
  *
  * Named prepared statements are off unless `prepared` is `"named"`.
  * `prepared: "named"` is not for transaction-mode poolers.
  *
  * @typeParam S - Schema
- * @param target - URL or an existing pool
+ * @param target - URL, an existing pool, or `{ primary, replicas }`
  * @param options - Schema, errors, logger, and driver options
- * @returns The client. Await `connected` for the dialect check
+ * @returns The client. A topology returns a promise. Await `connected` for the dialect check
  */
+export declare function connect<const S extends QuerySchema>(target: TopologyInput, options: NodePostgresConnectOptions<S>): Promise<RoutedClient<S>>;
 export declare function connect<const S extends QuerySchema>(target: NodePostgresTarget, options: NodePostgresConnectOptions<S>): Connected<S>;

package/dist/runtime/pg/pg.js

@@ -1,20 +1,23 @@
 import {
   DriverError2
-} from "../../shared/kyxb62mc.js";
+} from "../../shared/31vm914h.js";
 import {
   open4
-} from "../../shared/6p5k20sm.js";
+} from "../../shared/96qcj21c.js";
 import {
   NODE_POSTGRES_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "../../shared/rrstp3kb.js";
+} from "../../shared/cgbamx3e.js";
 import {
   createClient
-} from "../../shared/kkzwp3d2.js";
+} from "../../shared/hf22e0wt.js";
 
 // src/runtime/pg/pg.ts
 function connect(target, options) {
+  if (typeof target === "object" && !isPool(target)) {
+    return import("../../shared/nxdp2ze3.js").then((mod) => mod.default(target, options, open4));
+  }
   const owned = !isPool(target);
   const pool = isPool(target) ? target : open4({
     url: target,

package/dist/runtime/pg/pglite.d.ts

@@ -2,10 +2,13 @@
  * `connect` for PGlite (`okmodel/pg/pglite`).
  *
  * Opening a database is async. An existing pool is reused and not closed.
+ * A `{ primary, replicas }` object loads the topology module. A replica URL is
+ * that endpoint's data directory.
  */
 import type { DriverPool } from "../../contracts/driver.js";
 import type { QuerySchema } from "../../dialects/pg/model.js";
 import { type PgliteConfig } from "../../adapters/pg/pglite.js";
+import type { RoutedClient, TopologyInput, TopologyOptions } from "../topology.js";
 import type { ConnectOptions, Connected } from "../types.js";
 export { open, type PgliteConfig } from "../../adapters/pg/pglite.js";
 export { capabilities, hasCapability, readCapability } from "../../adapters/pg/pglite.js";
@@ -13,13 +16,18 @@ export { DriverError } from "../../adapters/error.js";
 /** A data directory, a pool from {@link open}, or omitted for memory. */
 export type PgliteTarget = string | DriverPool | undefined;
 /** Driver options `connect` forwards to {@link open}. */
-export type PgliteConnectOptions<S extends QuerySchema> = ConnectOptions<S> & Omit<PgliteConfig, "dataDir">;
+export type PgliteConnectOptions<S extends QuerySchema> = ConnectOptions<S> & Omit<PgliteConfig, "dataDir"> & TopologyOptions;
 /**
- * Connects one PGlite endpoint and returns a client for `schema`.
+ * Connects one PGlite endpoint, or a primary and its replicas, and returns a client for `schema`.
+ *
+ * A string, a pool, or an omitted target is one endpoint. A topology loads on
+ * demand. Reads use the first healthy replica. A replica `url` is that
+ * endpoint's data directory.
  *
  * @typeParam S - Schema
- * @param target - Data directory, existing pool, or omitted for memory
+ * @param target - Data directory, existing pool, omitted for memory, or `{ primary, replicas }`
  * @param options - Schema, errors, and logger
  * @returns The client
  */
+export declare function connect<const S extends QuerySchema>(target: TopologyInput, options: PgliteConnectOptions<S>): Promise<RoutedClient<S>>;
 export declare function connect<const S extends QuerySchema>(target: PgliteTarget, options: PgliteConnectOptions<S>): Promise<Connected<S>>;

package/dist/runtime/pg/pglite.js

@@ -1,20 +1,23 @@
 import {
   DriverError2
-} from "../../shared/kyxb62mc.js";
+} from "../../shared/31vm914h.js";
 import {
   open3
-} from "../../shared/fa9vt245.js";
+} from "../../shared/87jvvhnt.js";
 import {
   PGLITE_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "../../shared/rrstp3kb.js";
+} from "../../shared/cgbamx3e.js";
 import {
   createClient
-} from "../../shared/kkzwp3d2.js";
+} from "../../shared/hf22e0wt.js";
 
 // src/runtime/pg/pglite.ts
 async function connect(target, options) {
+  if (typeof target === "object" && !isPool(target)) {
+    return import("../../shared/nxdp2ze3.js").then((mod) => mod.default(target, options, open3));
+  }
   const pool = isPool(target) ? target : await open3({
     ...target !== undefined ? { dataDir: target } : {},
     ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {}

package/dist/runtime/pg/postgresjs.d.ts

@@ -1,12 +1,14 @@
 /**
  * `connect` for postgres.js (`okmodel/pg/postgresjs`).
  *
- * One URL or an existing pool is one endpoint. The client is typed by the
- * schema passed in, not by `Register`.
+ * A string or an existing pool is one endpoint. A `{ primary, replicas }` object
+ * loads the topology module. The client is typed by the schema passed in, not
+ * by `Register`.
  */
 import type { DriverPool } from "../../contracts/driver.js";
 import type { QuerySchema } from "../../dialects/pg/model.js";
 import { type PostgresJsConfig } from "../../adapters/pg/postgresjs.js";
+import type { RoutedClient, TopologyInput, TopologyOptions } from "../topology.js";
 import type { ConnectOptions, Connected } from "../types.js";
 export { open, type PostgresJsConfig } from "../../adapters/pg/postgresjs.js";
 export { capabilities, hasCapability, readCapability } from "../../adapters/pg/postgresjs.js";
@@ -14,16 +16,20 @@ export { DriverError } from "../../adapters/error.js";
 /** A connection string or a pool from {@link open}. */
 export type PostgresTarget = string | DriverPool;
 /** Driver options `connect` forwards to {@link open}. */
-export type PostgresConnectOptions<S extends QuerySchema> = ConnectOptions<S> & Omit<PostgresJsConfig, "url">;
+export type PostgresConnectOptions<S extends QuerySchema> = ConnectOptions<S> & Omit<PostgresJsConfig, "url"> & TopologyOptions;
 /**
- * Connects one Postgres endpoint and returns a client for `schema`.
+ * Connects one Postgres endpoint, or a primary and its replicas, and returns a client for `schema`.
+ *
+ * A string or a pool is one endpoint. A topology loads on demand and the promise
+ * resolves to the client. Reads use the first healthy replica.
  *
  * Named prepared statements are off unless `prepared` is `"named"`.
  * `prepared: "named"` is not for transaction-mode poolers.
  *
  * @typeParam S - Schema
- * @param target - URL or an existing pool
+ * @param target - URL, an existing pool, or `{ primary, replicas }`
  * @param options - Schema, errors, logger, and driver options
- * @returns The client. Await `connected` for the dialect check
+ * @returns The client. A topology returns a promise. Await `connected` for the dialect check
  */
+export declare function connect<const S extends QuerySchema>(target: TopologyInput, options: PostgresConnectOptions<S>): Promise<RoutedClient<S>>;
 export declare function connect<const S extends QuerySchema>(target: PostgresTarget, options: PostgresConnectOptions<S>): Connected<S>;

package/dist/runtime/pg/postgresjs.js

@@ -1,20 +1,23 @@
 import {
   DriverError2
-} from "../../shared/kyxb62mc.js";
+} from "../../shared/31vm914h.js";
 import {
   open2
-} from "../../shared/wqem4jed.js";
+} from "../../shared/krxx77g0.js";
 import {
   POSTGRESJS_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "../../shared/rrstp3kb.js";
+} from "../../shared/cgbamx3e.js";
 import {
   createClient
-} from "../../shared/kkzwp3d2.js";
+} from "../../shared/hf22e0wt.js";
 
 // src/runtime/pg/postgresjs.ts
 function connect(target, options) {
+  if (typeof target === "object" && !isPool(target)) {
+    return import("../../shared/nxdp2ze3.js").then((mod) => mod.default(target, options, open2));
+  }
   const owned = !isPool(target);
   const pool = isPool(target) ? target : open2({
     url: target,

package/dist/runtime/plan.d.ts

@@ -41,9 +41,11 @@ export type ReadCall = {
     readonly build?: ReadBuild;
     /** Writes the end of the statement, after `limit`. A row lock sets it. */
     readonly tail?: (sink: Sink) => void;
-    /** The caller's `signal` and `timeout`. They never enter the plan or its key. */
+    /** The caller's `signal`, `timeout`, and `route`. They never enter the plan or its key. */
     readonly signal?: AbortSignal;
     readonly timeout?: number;
+    /** `"primary"` or `"replica"`. Absent means the router classifies the statement. */
+    readonly route?: "primary" | "replica";
     /** Set by `for()` or `unscoped()`. Absent on a schema with no tenancy. */
     readonly scope?: CallScope;
     /** Inspect lines from the tenancy object. Absent when the schema has no tenancy. */
@@ -286,6 +288,19 @@ export declare function indexes(schema: QuerySchema): ReadonlyMap<string, Indexe
 export declare function quote(name: string): string;
 export declare function list(names: readonly string[]): string;
 export declare function isRecord(value: unknown): value is Record<string, unknown>;
+/**
+ * Whether `where` constrains a row.
+ *
+ * A field value is a leaf. Anything other than `undefined` counts, including
+ * `null`, objects, arrays, and operators. The walk does not enter a field value.
+ * It enters the where object's own keys, `and`, `or`, and `not` when `not` is
+ * the where itself. An `or()` branch with no predicate is OKM1121. `or([])`
+ * matches nothing.
+ *
+ * @param where - Caller filter, or one `and` / `or` / `not` operand
+ * @returns `false` when the filter matches every row
+ */
+export declare function effectivePredicate(where: unknown): boolean;
 /**
  * Records the fix text for a code thrown from a chunk that loads on first use.
  *

package/dist/runtime/tenancy/index.js

@@ -11,7 +11,7 @@ import {
 } from "../../shared/tmbdywx0.js";
 import {
   quote
-} from "../../shared/xrfnq5k8.js";
+} from "../../shared/gbtcc2d7.js";
 import {
   assertIdentifier2
 } from "../../shared/nfzc5z0w.js";

package/dist/runtime/topology.d.ts

@@ -0,0 +1,191 @@
+/**
+ * Primary and replica endpoints (spec §15.1).
+ *
+ * Loaded only when `connect` is given a topology object. The string and pool
+ * paths do not import this module. An automatic read chooses among eligible
+ * replicas. One watermark on this handle covers the root, `for()`, `unscoped()`,
+ * `using()`, and `reserve()`.
+ */
+import type { DriverPool, DriverTimeouts } from "../contracts/driver.js";
+import type { QuerySchema } from "../dialects/pg/model.js";
+import type { ConnectOptions, Connected } from "./types.js";
+/** `"primary"` or `"replica"`. `using` and `route` accept only these. */
+export type RouteName = "primary" | "replica";
+/**
+ * One routing choice.
+ *
+ * `onRoute` receives this. `inspect()` does not, until the dev inspector (M2).
+ */
+export type RouteEvent = {
+    /** What the statement was classified as. */
+    readonly op: "read" | "write" | "tx" | "lock";
+    /** Endpoint name. The primary is `"primary"`. */
+    readonly endpoint: string;
+    /**
+     * `primary-required`, `constraint:primary`, `constraint:replica`,
+     * `auto:<name>`, or `fallback:<no-replicas | unhealthy | position-unknown | saturated | behind>`.
+     */
+    readonly reason: string;
+};
+/**
+ * One replica passed to a custom `routing.select`.
+ *
+ * `lag` is the replica's byte lag, or `null` when the primary insert position
+ * or the replica replay position has not been seen. `latencyMs` stays `null`
+ * until a probe or a successful read has been timed.
+ */
+export type ReplicaCandidate = {
+    /** Endpoint name. */
+    readonly name: string;
+    /** Configured weight. Zero and below are OKM1120 at connect. */
+    readonly weight: number;
+    /** In-flight statements this router is running on the replica. */
+    readonly inflight: number;
+    /** EWMA of observed round-trip time, in milliseconds, or `null`. */
+    readonly latencyMs: number | null;
+    /** Byte lag behind the primary, or `null` when either position is unknown. */
+    readonly lag: number | null;
+};
+/**
+ * A topology client.
+ *
+ * `using` returns a client that forces one route. That client has no `close`
+ * and no `using`. Only the root closes the pools.
+ */
+export type RoutedClient<S extends QuerySchema> = Connected<S> & {
+    /**
+     * Forces later operations onto the primary or a replica.
+     *
+     * @param route - `"primary"` or `"replica"`
+     * @returns A client with no `close` and no `using`
+     */
+    using(route: RouteName): Omit<Connected<S>, "close">;
+};
+/**
+ * Replay position for one replica.
+ *
+ * Tests supply this over independent databases. The probe still runs `SELECT 1`
+ * on the replica's pool. The position does not come from a mocked driver.
+ */
+export type ReplicaState = {
+    /**
+     * @param endpoint - The replica being probed
+     * @returns The replay LSN, or `null` when the replica has not replayed
+     */
+    replayLsn(endpoint: {
+        readonly name: string;
+    }): string | null | Promise<string | null>;
+    /**
+     * Replay timestamp for a time `maxLag`.
+     *
+     * Omitted, and with no seam, the probe reads `pg_last_xact_replay_timestamp()`
+     * only when `maxLag` is a duration.
+     *
+     * @param endpoint - The replica being probed
+     * @returns A timestamp, or `null` when the replica has not replayed a transaction
+     */
+    replayTime?(endpoint: {
+        readonly name: string;
+    }): Date | string | null | Promise<Date | string | null>;
+};
+/** One replica in `{ primary, replicas }`. A string is a URL with weight 1. */
+export type ReplicaInput = {
+    readonly url: string;
+    readonly weight?: number;
+    readonly name?: string;
+    readonly pool?: {
+        readonly max?: number;
+    };
+};
+/** The first argument of `connect` when it is a topology. */
+export type TopologyInput = {
+    readonly primary: string;
+    readonly replicas?: readonly (string | ReplicaInput)[];
+};
+/** Options only the topology module reads. */
+export type TopologyOptions = {
+    /**
+     * Background probe interval. `"1s"` when omitted.
+     *
+     * `select` chooses among eligible replicas. The default is `"weighted"`.
+     * `consistency` is `"session"` (the default) or `"eventual"`. `maxLag` is a
+     * duration (`"5s"`, `"500ms"`, `"2m"`) or a size (`"16MB"`, `"512KB"`,
+     * `"1GB"`, `"4096B"`). `fallback` is `"primary"` (the default) or `"error"`.
+     */
+    readonly routing?: {
+        readonly probe?: string | number;
+        readonly select?: "weighted" | "roundRobin" | "leastConnections" | "latencyAware" | ((candidates: readonly ReplicaCandidate[], ctx: {
+            readonly op: "read";
+        }) => ReplicaCandidate | string);
+        readonly consistency?: "session" | "eventual";
+        readonly fallback?: "primary" | "error";
+        readonly maxLag?: string;
+    };
+    /**
+     * Called after an endpoint is chosen.
+     *
+     * A throw is swallowed. The operation still runs.
+     */
+    readonly onRoute?: (event: RouteEvent) => void;
+    /** Test seam for replay positions. Omitted, the probe reads `pg_last_wal_replay_lsn()`. */
+    readonly replicaState?: ReplicaState;
+};
+/** One endpoint after connect. Tests read this. It is not the query path. */
+export type EndpointView = {
+    readonly name: string;
+    readonly role: "primary" | "replica";
+    readonly weight: number;
+    /** `max` passed to the driver. Absent when connect did not set one. */
+    readonly max: number | undefined;
+    /** Whether `replication.position` was detected on this endpoint. */
+    readonly position: boolean;
+    readonly circuit: "closed" | "open";
+    readonly failures: number;
+    readonly replayLsn: string | null;
+    /** Delay until the next probe. The primary is 0. */
+    readonly nextDelayMs: number;
+};
+/** The topology a client was built with. */
+export type TopologyView = {
+    readonly endpoints: readonly EndpointView[];
+};
+/** Fields each driver's `open` may read. Extra keys are ignored by that driver. */
+type EndpointConfig = {
+    readonly url: string;
+    readonly dataDir: string;
+    readonly max?: number;
+    readonly timeouts?: DriverTimeouts;
+    readonly prepared?: "named" | "unnamed";
+    readonly searchPath?: string;
+    readonly ssl?: unknown;
+};
+/** Opens one endpoint. postgres.js reads `url`. PGlite reads `dataDir`. */
+export type EndpointOpen = (config: EndpointConfig) => DriverPool | Promise<DriverPool>;
+/**
+ * Opens one pool per endpoint, detects `replication.position`, and starts replica probes.
+ *
+ * An automatic read runs the selection pipeline and `routing.select`.
+ * `close()` stops the probes and closes every pool this call opened,
+ * including clients from `using`.
+ *
+ * @param target - `{ primary, replicas }`
+ * @param options - Schema, pool default, probe interval, and the optional seam
+ * @param open - The driver's `open`
+ * @returns The client
+ */
+export declare function connectTopology<S extends QuerySchema>(target: object, options: ConnectOptions<S> & TopologyOptions & {
+    readonly max?: number;
+    readonly prepared?: "named" | "unnamed";
+    readonly searchPath?: string;
+    readonly ssl?: unknown;
+}, open: EndpointOpen): Promise<RoutedClient<S>>;
+/**
+ * Reads the endpoints recorded for a client this module built.
+ *
+ * A string `connect` has no record. Routing does not call this.
+ *
+ * @param client - The value `connect` returned
+ * @returns The endpoints, or `undefined` when `client` is not a topology client
+ */
+export declare function readTopology(client: object): TopologyView | undefined;
+export default connectTopology;

package/dist/runtime/traits/index.js

@@ -1,4 +1,4 @@
-import"../../shared/8jb4ymh2.js";
+import"../../shared/8bwbwy8h.js";
 import {
   checkPresetNames,
   duplicatePreset
@@ -8,7 +8,7 @@ import {
 } from "../../shared/n0dgs0pb.js";
 import {
   quoteIdent
-} from "../../shared/41kv2xdm.js";
+} from "../../shared/8xsbagad.js";
 import {
   functionObject,
   triggerObject
@@ -21,7 +21,7 @@ import {
 } from "../../shared/dyj86cmj.js";
 import {
   snakeCase
-} from "../../shared/jsd07prz.js";
+} from "../../shared/ntneex2a.js";
 import {
   ColumnBuilder2,
   retarget
@@ -38,10 +38,10 @@ import {
   queryHandle,
   attachHttp,
   settleCall
-} from "../../shared/kkzwp3d2.js";
+} from "../../shared/hf22e0wt.js";
 import {
   installArchiveInspect
-} from "../../shared/xrfnq5k8.js";
+} from "../../shared/gbtcc2d7.js";
 import {
   fitIdentifier2
 } from "../../shared/nfzc5z0w.js";
@@ -58,7 +58,7 @@ function rewriteArchivable(self, tables, casing, schemaTraits, cascade) {
   const edges = foreignKeys(tables, casing, byName);
   const archiveSql = casing === "snake" ? "archived_at" : "archivedAt";
   const idSql = casing === "snake" ? "archive_id" : "archiveId";
-  const predicate = `"${archiveSql.replaceAll('"', '""')}" is null`;
+  const predicate = casing === "snake" ? "(archived_at IS NULL)" : '("archivedAt" IS NULL)';
   return tables.map((item) => {
     if (!applies(self, item, schemaTraits))
       return item;
@@ -459,7 +459,7 @@ function refuse(host, table) {
 }
 var archiveMod;
 function loadArchive() {
-  archiveMod ??= import("../../shared/radd3z4g.js");
+  archiveMod ??= import("../../shared/0t22wwh1.js");
   return archiveMod;
 }
 async function settle(host, table, mods) {

package/dist/runtime/types.d.ts

@@ -99,6 +99,12 @@ export type CallOptions = {
     readonly signal?: AbortSignal;
     /** Milliseconds. The call fails as `timeout` when it runs longer. */
     readonly timeout?: number;
+    /**
+     * Forces this read onto the primary or a replica.
+     *
+     * Absent, a topology client chooses. A single endpoint serves either value.
+     */
+    readonly route?: "primary" | "replica";
 };
 /** Options shared by reads. */
 export type ReadOptions<S extends QuerySchema, K extends keyof S["~byName"]> = CallOptions & {
@@ -602,6 +608,55 @@ export type TxClient<S extends QuerySchema, Root extends boolean = false> = {
      */
     advisoryLock(key: string | number | bigint, options?: CallOptions): Promise<void>;
 } & TxApi<S, Root>;
+/** A view field: its column name in camel case, as the client publishes it. */
+type CamelName<N extends string> = N extends `_${infer Rest}` ? CamelName<Rest> : N extends `${infer Head}_${infer Tail}` ? `${Head}${Capitalize<CamelName<Tail>>}` : N;
+/** One view row. Every column is decoded as text, so each field is a string or null. */
+type ViewRow<D> = D extends {
+    readonly "~columns"?: infer C extends readonly {
+        readonly name: string;
+    }[];
+} ? {
+    readonly [Col in C[number] as CamelName<Col["name"]>]: string | null;
+} : never;
+/** Options `find` and `one` take on a view. */
+type ViewReadOptions<Row> = CallOptions & {
+    readonly where?: FieldWhere<Row>;
+    readonly select?: readonly (keyof Row & string)[];
+    readonly orderBy?: OrderBy<Row>;
+    readonly limit?: number;
+};
+/** The read-only handle `db.views` holds for one view. */
+type ViewApi<Row> = {
+    find<const O extends ViewReadOptions<Row> & {
+        readonly limit: number;
+    }>(options: O): Read<readonly Show<Selected<Row, O extends {
+        readonly select: infer Sel;
+    } ? Sel : undefined>>[]>;
+    find<const O extends ViewReadOptions<Row>>(options: O): {
+        all(reason: string): Read<readonly Show<Selected<Row, O extends {
+            readonly select: infer Sel;
+        } ? Sel : undefined>>[]>;
+    };
+    one<const O extends ViewReadOptions<Row>>(options?: O): Read<Show<Selected<Row, O extends {
+        readonly select: infer Sel;
+    } ? Sel : undefined>> | null>;
+    count(options?: CallOptions & {
+        readonly where?: FieldWhere<Row>;
+    }): Read<number>;
+    exists(options?: CallOptions & {
+        readonly where?: FieldWhere<Row>;
+    }): Read<boolean>;
+};
+/** `db.views`, typed from `schema({ views })`. Absent when the schema declares none. */
+type ViewsClient<S> = S extends {
+    readonly "~views": infer V extends readonly unknown[];
+} ? {
+    readonly views: {
+        readonly [D in V[number] as D extends {
+            readonly name: infer N extends string;
+        } ? CamelName<N> : never]: ViewApi<Show<ViewRow<D>>>;
+    };
+} : unknown;
 /** A client whose tables are already inside one tenant or an unscoped reason. */
 type ScopedClient<S extends QuerySchema> = {
     readonly [K in keyof S["~byName"] & string]: TableApi<S, K>;
@@ -612,7 +667,7 @@ type ScopedClient<S extends QuerySchema> = {
     close(): Promise<void>;
     /** Resolves when the dialect and `requires` checks have finished. */
     readonly connected: Promise<void>;
-} & TxApi<S, false> & IfAsyncDisposable<typeof Symbol>;
+} & TxApi<S, false> & ViewsClient<S> & IfAsyncDisposable<typeof Symbol>;
 /** `for` and `unscoped` on a schema that set tenancy. */
 type ScopeMethods<S extends QuerySchema> = TenantKeyOf<S> extends never ? object : {
     /**
@@ -650,7 +705,7 @@ export type Connected<S extends QuerySchema> = {
     close(): Promise<void>;
     /** Resolves when the dialect and `requires` checks have finished. */
     readonly connected: Promise<void>;
-} & TxApi<S, true> & ScopeMethods<S> & IfAsyncDisposable<typeof Symbol>;
+} & TxApi<S, true> & ScopeMethods<S> & ViewsClient<S> & IfAsyncDisposable<typeof Symbol>;
 /**
  * A catalog `okm build` wrote.
  *