okmodel 0.4.0 → 0.5.0

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
@@ -38,10 +38,10 @@ import {
   queryHandle,
   attachHttp,
   settleCall
-} from "../../shared/kkzwp3d2.js";
+} from "../../shared/bt9sfq0z.js";
 import {
   installArchiveInspect
-} from "../../shared/xrfnq5k8.js";
+} from "../../shared/qgvt8nx1.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/ckjbyrt9.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.
  *

package/dist/runtime/validate/index.js

@@ -6,7 +6,7 @@ import {
 } from "../../shared/3p4b1fg0.js";
 import {
   queryHandle
-} from "../../shared/kkzwp3d2.js";
+} from "../../shared/bt9sfq0z.js";
 import {
   OkmError2
 } from "../../shared/52szzakm.js";

package/dist/shared/{nxb42q7h.js → 47xzb9fc.js}

@@ -1,7 +1,7 @@
 import {
   withHttp,
   attachHttp
-} from "./kkzwp3d2.js";
+} from "./bt9sfq0z.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -31,7 +31,7 @@ async function acceptServer(pool, schema, rows, http, requireMeta, options, sour
       }));
     }
   } else {
-    const { assertCompatible } = await import("./q795afwa.js");
+    const { assertCompatible } = await import("./z2rnngj4.js");
     try {
       await assertCompatible(pool, schema, recorded, source, options);
     } catch (error) {

package/dist/shared/{6693j9rs.js → 5fqx9yh4.js}

@@ -4,9 +4,11 @@ import {
   renameTable2,
   serializeCatalog2,
   catalogHash2,
+  startupCatalog2,
+  startupHash2,
   loadTrustedCatalog2,
   parseCatalog2
-} from "./8jb4ymh2.js";
+} from "./8bwbwy8h.js";
 export {
   catalogHash2 as catalogHash,
   creationOrder2 as creationOrder,
@@ -14,5 +16,7 @@ export {
   parseCatalog2 as parseCatalog,
   renameColumn2 as renameColumn,
   renameTable2 as renameTable,
-  serializeCatalog2 as serializeCatalog
+  serializeCatalog2 as serializeCatalog,
+  startupCatalog2 as startupCatalog,
+  startupHash2 as startupHash
 };

package/dist/shared/{8jb4ymh2.js → 8bwbwy8h.js}

@@ -229,6 +229,17 @@ function catalogHash2(source) {
   serializedHash.set(source, hash);
   return hash;
 }
+function startupCatalog2(source) {
+  if (!source.objects.some(isPrivilege))
+    return source;
+  return { version: source.version, objects: source.objects.filter((item) => !isPrivilege(item)) };
+}
+function startupHash2(source) {
+  return catalogHash2(startupCatalog2(source));
+}
+function isPrivilege(object) {
+  return object.kind === "role" || object.kind === "grant" || object.kind === "defaultPrivilege";
+}
 function loadTrustedCatalog2(text, hash) {
   if (sha2562(text) !== hash) {
     catalogError2("OKM1027", "Catalog hash does not match the build artifact.");
@@ -1444,4 +1455,4 @@ function assertNeverKind(value) {
   return catalogError2("OKM1020", `Unexpected kind ${JSON.stringify(value)}.`);
 }
 
-export { roleObject, grantObject, defaultPrivilegeObject, creationOrder2, renameColumn2, renameTable2, serializeCatalog2, catalogHash2, loadTrustedCatalog2, parseCatalog2 };
+export { roleObject, grantObject, defaultPrivilegeObject, creationOrder2, renameColumn2, renameTable2, serializeCatalog2, catalogHash2, startupCatalog2, startupHash2, loadTrustedCatalog2, parseCatalog2 };

package/dist/shared/{41kv2xdm.js → 8xsbagad.js}

@@ -1,6 +1,6 @@
 import {
   creationOrder2
-} from "./8jb4ymh2.js";
+} from "./8bwbwy8h.js";
 import {
   isDomain
 } from "./g7ez901n.js";

package/dist/shared/{sr5ms7b3.js → 922qbgnw.js}

@@ -1,9 +1,9 @@
 import {
   withHttp
-} from "./kkzwp3d2.js";
+} from "./bt9sfq0z.js";
 import {
   decodeResult
-} from "./xrfnq5k8.js";
+} from "./qgvt8nx1.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -17,7 +17,7 @@ async function* streamRows(session, call, prepare, log) {
     })));
   }
   const { plan, params } = await prepare();
-  const decode = plan.outputs.includes.length === 0 ? decodeResult : (await import("./edwqqryd.js")).decodeIncluded;
+  const decode = plan.outputs.includes.length === 0 ? decodeResult : (await import("./h8ne16fq.js")).decodeIncluded;
   for await (const chunk of session.pool.stream(plan.text, params)) {
     const decoded = decode(plan, chunk, call.table);
     if (!Array.isArray(decoded))

package/dist/shared/{tny2t3sm.js → 990a291j.js}

@@ -1,15 +1,15 @@
 import {
   open2
 } from "./wqem4jed.js";
-import"./8jb4ymh2.js";
+import"./8bwbwy8h.js";
 import"./n442h54c.js";
 import {
   assertTargetPolicy,
   selectTarget,
   openProject
-} from "./q6zsyh31.js";
-import"./n5y9zyj1.js";
-import"./41kv2xdm.js";
+} from "./xdpj5kkm.js";
+import"./ayz64vzj.js";
+import"./8xsbagad.js";
 import {
   isExactVersion,
   compareExtensionVersions

package/dist/shared/{jns2wx4t.js → 9tgmr1gh.js}

@@ -9,7 +9,7 @@ import {
   isRecord,
   registerFailFix,
   fail
-} from "./xrfnq5k8.js";
+} from "./qgvt8nx1.js";
 import {
   throwNamed2
 } from "./52szzakm.js";

package/dist/shared/{n5y9zyj1.js → ayz64vzj.js}

@@ -2,7 +2,7 @@ import {
   creationOrder2,
   renameColumn2,
   renameTable2
-} from "./8jb4ymh2.js";
+} from "./8bwbwy8h.js";
 import {
   quoteIdent,
   ownedByView,
@@ -15,7 +15,7 @@ import {
   identitySequence,
   createTableSql,
   qualify
-} from "./41kv2xdm.js";
+} from "./8xsbagad.js";
 import {
   isExactVersion,
   compareExtensionVersions,
@@ -122,7 +122,7 @@ function privilegeSql(before, after, schema, recreated = new Set) {
       revoke.push({ sql: grantStatement(object, schema, true), kind: "revoke" });
     }
     if (object.kind === "defaultPrivilege") {
-      revoke.push({ sql: defaultStatement(object, true), kind: "revoke-default" });
+      revoke.push({ sql: defaultStatement(object, schema, true), kind: "revoke-default" });
     }
   }
   for (const [key, object] of afterBy) {
@@ -151,7 +151,7 @@ function privilegeSql(before, after, schema, recreated = new Set) {
     if (previous !== undefined)
       continue;
     if (object.kind === "defaultPrivilege") {
-      defaults.push({ sql: defaultStatement(object, false), kind: "grant-default" });
+      defaults.push({ sql: defaultStatement(object, schema, false), kind: "grant-default" });
     }
   }
   return { revoke, prepare: [...roles, ...defaults], grant };
@@ -163,6 +163,9 @@ function createdRoleName(sql) {
     return quoted.replaceAll('""', '"');
   return match?.[2];
 }
+function createRoleOnce(sql) {
+  return `do $okm$ begin ${sql}; exception when duplicate_object or unique_violation then null; end $okm$`;
+}
 function changesRole(sql) {
   return /^\s*(create|alter)\s+role\b/i.test(sql);
 }
@@ -195,13 +198,12 @@ function grantStatement(object, schema, revoke) {
   const direction = revoke ? "from" : "to";
   return `${verb} ${privilege} on ${grantTarget(object.identity.object, schema)} ${direction} ${quoteIdent(object.identity.role)}`;
 }
-function defaultStatement(object, revoke) {
+function defaultStatement(object, schema, revoke) {
   const privilege = object.identity.privilege.toLowerCase();
   assertPrivilege(privilege);
   const verb = revoke ? "revoke" : "grant";
   const direction = revoke ? "from" : "to";
-  const namespace = object.identity.namespace.form === "static" ? object.identity.namespace.name : "public";
-  return `alter default privileges for role ${quoteIdent(object.identity.forRole)} in schema ${quoteIdent(namespace)} ${verb} ${privilege} on ${objectKindSql(object.identity.objectKind)} ${direction} ${quoteIdent(object.identity.grantee)}`;
+  return `alter default privileges for role ${quoteIdent(object.identity.forRole)} in schema ${quoteIdent(schema)} ${verb} ${privilege} on ${objectKindSql(object.identity.objectKind)} ${direction} ${quoteIdent(object.identity.grantee)}`;
 }
 function grantTargetKey(object) {
   if (object.kind === "table" || object.kind === "view" || object.kind === "materializedView" || object.kind === "sequence") {
@@ -222,14 +224,13 @@ function grantTargetKey(object) {
   });
 }
 function grantTarget(object, schema) {
-  const name = object.namespace.form === "static" ? object.namespace.name : schema;
   if (object.kind === "sequence")
-    return `sequence ${qualify(name, object.name)}`;
+    return `sequence ${qualify(schema, object.name)}`;
   if (object.kind === "function")
-    return functionTarget(object.name, name);
+    return functionTarget(object.name, schema);
   if (object.kind === "namespace")
     return `schema ${quoteIdent(object.name)}`;
-  return `table ${qualify(name, object.name)}`;
+  return `table ${qualify(schema, object.name)}`;
 }
 function functionTarget(name, schema) {
   const open = name.lastIndexOf("(");
@@ -2428,4 +2429,4 @@ function order(value) {
   return value;
 }
 
-export { canonicalTypeName, createdRoleName, changesRole, DEFAULT_BACKFILL_PAUSE_MS, DEFAULT_BACKFILL_STATEMENT_TIMEOUT_MS, batchSizeField, aboutBatchCount, boundaryQuery, checkedCast, classOf, strictestClass, assertExtensionsAvailable, omitManagedObjects, parseReplace, planMigration, formatPlan, parsePlan, staleRenames };
+export { canonicalTypeName, createdRoleName, createRoleOnce, changesRole, DEFAULT_BACKFILL_PAUSE_MS, DEFAULT_BACKFILL_STATEMENT_TIMEOUT_MS, batchSizeField, aboutBatchCount, boundaryQuery, checkedCast, classOf, strictestClass, assertExtensionsAvailable, omitManagedObjects, parseReplace, planMigration, formatPlan, parsePlan, staleRenames };

package/dist/shared/{kkzwp3d2.js → bt9sfq0z.js}

@@ -7,7 +7,7 @@ import {
   decodeResult,
   logicalIntent,
   appliedRules
-} from "./xrfnq5k8.js";
+} from "./qgvt8nx1.js";
 import {
   OkmError2,
   safe2,
@@ -72,7 +72,7 @@ function openClient(session) {
     },
     close,
     connected: session.connected,
-    tx: (...args) => import("./kafaa5zv.js").then((mod) => mod.tx(session, args)),
+    tx: (...args) => import("./k7cc9nzk.js").then((mod) => mod.tx(session, args)),
     batch: (ops, options) => batchHandle(session, ops, options),
     ...session.tx?.extras
   };
@@ -107,7 +107,7 @@ function tableApi(session, table, view, uses) {
   const api = {
     find(options = {}) {
       if ("lock" in options) {
-        return lazyRead(session, () => import("./zg24x0hm.js"), table, options, base, view);
+        return lazyRead(session, () => import("./dxjp14rk.js"), table, options, base, view);
       }
       return start(session, "find", table, options, base, view);
     },
@@ -121,10 +121,10 @@ function tableApi(session, table, view, uses) {
       return start(session, "exists", table, options, base, view);
     },
     page(options) {
-      return lazyRead(session, () => import("./v7tpnhnz.js"), table, options, base, view);
+      return lazyRead(session, () => import("./h4nqvjkp.js"), table, options, base, view);
     },
     aggregate(options = {}) {
-      return lazyRead(session, () => import("./qn0srwwq.js"), table, options, base, view);
+      return lazyRead(session, () => import("./r6pj4fq2.js"), table, options, base, view);
     },
     insert(data, options = {}) {
       return writeHandle(session, "insert", table, data, options, mods);
@@ -154,13 +154,13 @@ function tableApi(session, table, view, uses) {
   return api;
 }
 function batchHandle(session, ops, options, replica) {
-  return queryHandle(() => import("./jgxzjzcz.js").then((mod) => mod.batch(session, ops, options, replica)), {
+  return queryHandle(() => import("./xsq7v6wp.js").then((mod) => mod.batch(session, ops, options, replica)), {
     replica: () => batchHandle(session, ops, options, true)
   });
 }
 var writers;
 function loadWrite() {
-  writers ??= import("./awrsqrn7.js");
+  writers ??= import("./p7pfx624.js");
   return writers;
 }
 function queryHandle(run, extra) {
@@ -245,7 +245,7 @@ function lazyRead(session, load, table, options, mods, view) {
   });
 }
 async function decodeRows(plan, rows, table) {
-  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./edwqqryd.js")).decodeIncluded(plan, rows, table);
+  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./h8ne16fq.js")).decodeIncluded(plan, rows, table);
 }
 function readHandle(session, table, call, mods, decode, extra) {
   let prepared;
@@ -320,7 +320,7 @@ function readHandle(session, table, call, mods, decode, extra) {
 }
 function streamLazy(session, call, prepare) {
   return async function* () {
-    const { streamRows } = await import("./sr5ms7b3.js");
+    const { streamRows } = await import("./922qbgnw.js");
     yield* streamRows(session, call, prepare, (error) => logged(session, error));
   }();
 }
@@ -357,7 +357,7 @@ function readCall(op, table, options, all, scope, model, schema, view) {
   };
 }
 async function checkServer(pool, schema, http, requireMeta, options, source) {
-  const server = await import("./nxb42q7h.js");
+  const server = await import("./47xzb9fc.js");
   let rows;
   try {
     const result = await pool.execute(server.versionQuery, undefined, options);
@@ -386,7 +386,7 @@ function errorFields(error) {
 var includeHooks;
 var operatorSql;
 function loadOperatorSql() {
-  operatorSql ??= import("./axhk06q1.js").then(() => {
+  operatorSql ??= import("./tq9afp8d.js").then(() => {
     return;
   });
   return operatorSql;
@@ -394,7 +394,7 @@ function loadOperatorSql() {
 function hooksFor(call) {
   if (call.include === undefined)
     return Promise.resolve(undefined);
-  includeHooks ??= import("./edwqqryd.js").then((mod) => mod.includeHooks);
+  includeHooks ??= import("./h8ne16fq.js").then((mod) => mod.includeHooks);
   return includeHooks;
 }
 function bindNow(schema, call) {
@@ -426,11 +426,13 @@ function attachHttp(http, error) {
 }
 function callOptions(input, statement) {
   const timeout = input.timeout ?? statement;
-  if (input.signal === undefined && timeout === undefined)
+  const route = input.route;
+  if (input.signal === undefined && timeout === undefined && route === undefined)
     return;
   return {
     ...input.signal !== undefined ? { signal: input.signal } : {},
-    ...timeout !== undefined ? { timeout } : {}
+    ...timeout !== undefined ? { timeout } : {},
+    ...route !== undefined ? { route } : {}
   };
 }
 function mapOptions(http, includeValues) {