okmodel 0.6.0 → 0.7.0

package/dist/shared/{929h19xp.js → mtaszv5a.js}

@@ -1,10 +1,10 @@
 import {
   isConnectionSqlstate,
   isConnectionErrno
-} from "./gwn6v667.js";
+} from "./cnkky55j.js";
 import {
   createClient
-} from "./j60w0dvr.js";
+} from "./tbrvgw6z.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -506,7 +506,7 @@ function routePool(handle) {
     execute: async (text, params, options) => {
       if (handle.closed)
         closed();
-      const choice = await choose(handle, text, options?.route);
+      const choice = await resolve(handle, text, options);
       const result = await attempt(handle, choice, (endpoint) => endpoint.pool.execute(text, params, strip(options)));
       if (choice.op === "write")
         await noteWrite(handle, primary.pool);
@@ -628,7 +628,7 @@ function force(handle, router, route) {
 async function readOnlyUnit(handle, text, params, prelude, options) {
   if (handle.closed)
     closed();
-  const choice = await choose(handle, text, options?.route);
+  const choice = await resolve(handle, text, options);
   return attempt(handle, choice, async (endpoint) => {
     if (endpoint.pool.reserve === undefined)
       replicaReserve();
@@ -764,7 +764,7 @@ async function attempt(handle, choice, run) {
       await callGuard(choice.endpoint);
     return await tracked(choice.endpoint, choice.op === "read", () => run(choice.endpoint));
   } catch (error) {
-    if (choice.op !== "read" || !isUnreachable(error))
+    if (choice.pinned === true || choice.op !== "read" || !isUnreachable(error))
       throw error;
     choice.endpoint.generation += 1;
     const next = await retryOf(handle, choice);
@@ -817,9 +817,7 @@ function unreachableNode(node) {
       return true;
     }
   }
-  if (!(node instanceof Error))
-    return false;
-  return node.message.includes("ECONNREFUSED") || node.message.includes("ECONNRESET") || node.message.includes("CONNECTION_CLOSED") || node.message.includes("terminating connection") || node.message.includes("The pool is closed");
+  return false;
 }
 async function tracked(endpoint, time, run) {
   const replica = endpoint.role === "replica";
@@ -1109,13 +1107,45 @@ function noteFailure(endpoint) {
     endpoint.circuit = "open";
 }
 function strip(options) {
-  if (options === undefined || options.route === undefined)
+  if (options === undefined)
+    return;
+  if (!("route" in options) && !("pin" in options))
     return options;
-  const { route: _route, ...rest } = options;
+  const bag = options;
+  const { route: _route, pin: _pin, ...rest } = bag;
   if (rest.signal === undefined && rest.timeout === undefined)
     return;
   return rest;
 }
+async function resolve(handle, text, options) {
+  const pin = taken(options);
+  if (pin?.name !== undefined)
+    return held(handle, pin.name);
+  const choice = await choose(handle, text, options?.route);
+  if (pin !== undefined && choice.op === "read") {
+    pin.name = choice.endpoint.name;
+    return { ...choice, pinned: true };
+  }
+  return choice;
+}
+function taken(options) {
+  if (options === undefined || !("pin" in options))
+    return;
+  const pin = options.pin;
+  if (typeof pin !== "object" || pin === null)
+    return;
+  return pin;
+}
+function held(handle, name) {
+  for (const endpoint of handle.endpoints) {
+    if (endpoint.name !== name)
+      continue;
+    return { endpoint, op: "read", reason: `stream:${name}`, pinned: true };
+  }
+  throw new OkmError2("OKM1120", `stream() stays on ${name}. That target is not in this topology.`, {
+    fix: { summary: "The first batch chose this target. Later batches do not move." }
+  });
+}
 async function noteWrite(handle, runner) {
   if (!tracks(handle))
     return;

package/dist/shared/{b3awxn7h.js → n816peh1.js}

@@ -1,7 +1,7 @@
 import {
   isRecord,
   orFail
-} from "./2z7wv5tj.js";
+} from "./67txcrcw.js";
 import {
   isOperator,
   operatorName,

package/dist/shared/nbw1z4yd.js

@@ -0,0 +1,18 @@
+// src/dialects/pg/ops/bucket.ts
+var RUNTIME = Symbol.for("okmodel.bucket");
+function bucket2(column, unit, options) {
+  const spec = options ?? { as: undefined, tz: undefined, weekStart: undefined };
+  return {
+    [RUNTIME]: true,
+    column,
+    unit,
+    as: spec.as,
+    tz: spec.tz,
+    weekStart: spec.weekStart
+  };
+}
+function isBucket(value) {
+  return typeof value === "object" && value !== null && RUNTIME in value;
+}
+
+export { bucket2, isBucket };

package/dist/shared/{nx9hh281.js → p6qc5gcp.js}

@@ -1,6 +1,6 @@
 import {
   open2
-} from "./wkme6tep.js";
+} from "./14vx95q4.js";
 import {
   startupHash2
 } from "./qq3899ht.js";
@@ -14,12 +14,12 @@ import {
   provisionMark,
   expandProvisioned,
   installSnapshot
-} from "./p248q79y.js";
+} from "./m6p12kbr.js";
 import {
   assertCreateRole,
   currentUser,
   roleExists
-} from "./knmes2kh.js";
+} from "./8skf0cam.js";
 import {
   projectPath,
   loadMigrations,
@@ -30,7 +30,7 @@ import {
   projectHead,
   loadBuiltSchema,
   loadConfig
-} from "./t3g0k88x.js";
+} from "./gs74dbj5.js";
 import {
   changesRole,
   batchSizeField,
@@ -41,7 +41,11 @@ import {
   assertDirectConnection,
   assertStableBackend,
   selectTarget
-} from "./ttmg09vd.js";
+} from "./tsvww22q.js";
+import {
+  UUIDV7_POSTGRES,
+  uuidv7NeedsPostgres
+} from "./ga9j92qj.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -70,14 +74,11 @@ async function assertUuidV7Available(connection, migrations) {
   const row = result.rows[0];
   const major = Math.floor(Number(row?.[0] ?? "0") / 1e4);
   const defined = row?.[1] !== null && row?.[1] !== undefined;
-  if (major >= 18 || defined)
+  if (major >= UUIDV7_POSTGRES || defined)
     return;
   const where = found.column === undefined ? "A column" : `Column ${found.column}`;
-  throw new OkmError2("OKM1812", `${where} has a uuidv7() default (migration ${found.migrationId}, step ${String(found.stepIndex)}), and the server is PostgreSQL ${String(major)}. uuidv7() arrives in PostgreSQL 18. Nothing was changed.`, {
-    fix: {
-      summary: 'Either run PostgreSQL 18 and declare schema({ requires: { postgres: ">=18" } }), or use t.id({ default: "uuidv4" }) (or schema({ defaults: { id: "uuidv4" } })), which uses gen_random_uuid() and works on PostgreSQL 13 and newer. Then delete the migration that was not applied and generate it again.'
-    }
-  });
+  const message = `${where} has a uuidv7() default (migration ${found.migrationId}, step ${String(found.stepIndex)}), and the server is PostgreSQL ${String(major)}. ${uuidv7NeedsPostgres()} Nothing was changed.`;
+  throw new OkmError2("OKM1812", message, { fix: { summary: uuidv7NeedsPostgres() } });
 }
 function columnOf(sql) {
   const table = TABLE.exec(sql)?.[1];

package/dist/shared/{pjr6xrm5.js → pbp1ss85.js}

@@ -3,7 +3,7 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./j60w0dvr.js";
+} from "./tbrvgw6z.js";
 import {
   selectedColumns,
   parseOrder,
@@ -14,8 +14,8 @@ import {
   list,
   isRecord,
   registerFailFix,
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./67txcrcw.js";
 import {
   OkmError2,
   throwNamed2
@@ -34,21 +34,24 @@ var OPTIONS = [
   "signal",
   "timeout"
 ];
-function build(session, table, options, mods, view) {
+function build3(session, table, options, mods, view, pin) {
   try {
-    return plan(session, table, options, mods, view);
+    return plan(session, table, options, mods, view, pin);
   } catch (error) {
     throw error instanceof OkmError2 ? attachHttp(session.http, error) : error;
   }
 }
-function plan(session, table, options, mods, view) {
+function plan(session, table, options, mods, view, pin) {
   const record = isRecord(options) ? options : {};
+  if (Object.hasOwn(record, "search")) {
+    fail2("OKM1120", "page() does not take search in this version. Use find({ search, limit }) for a ranked list.", "Ranked pages are later. find({ search, limit }) returns one ranked list.");
+  }
   rejectKeys(record, OPTIONS, "page");
   const indexed = indexes(session.schema).get(table);
   if (indexed === undefined)
-    fail("OKM1120", `Table ${table} is not in the schema.`);
+    fail2("OKM1120", `Table ${table} is not in the schema.`);
   if (record.limit === undefined)
-    fail("OKM1101", "page() needs a limit.");
+    fail2("OKM1101", "page() needs a limit.");
   const size = readLimit(record.limit);
   if (size < 1) {
     throw new OkmError2("invalid", "page() limit must be at least 1.", { kind: "invalid" });
@@ -73,7 +76,8 @@ function plan(session, table, options, mods, view) {
       timeout: record.timeout,
       route: record.route
     }, undefined, session.scope, session.schema.model[table], session.schema, view),
-    ...after !== undefined ? { after } : {}
+    ...after !== undefined ? { after } : {},
+    ...pin !== undefined ? { pin } : {}
   };
   return readHandle(session, table, call, mods, async (compiled, rows) => {
     const items = await decodeRows(compiled, rows, table);
@@ -92,7 +96,7 @@ function plan(session, table, options, mods, view) {
 }
 function orderKeys(table, orderBy) {
   if (orderBy !== undefined && !isRecord(orderBy)) {
-    fail("OKM1120", "orderBy must be an object of fields.");
+    fail2("OKM1120", "orderBy must be an object of fields.");
   }
   const keys = [];
   for (const field of Object.keys(orderBy ?? {})) {
@@ -103,7 +107,7 @@ function orderKeys(table, orderBy) {
     keys.push({ column, ...parseOrder(field, orderBy?.[field]) });
   }
   if (table.model.primary.length === 0) {
-    fail("OKM1120", `page() needs a primary key on ${table.model.name} to break ties.`);
+    fail2("OKM1120", `page() needs a primary key on ${table.model.name} to break ties.`);
   }
   for (const field of table.model.primary) {
     const column = table.columns.get(field);
@@ -181,17 +185,16 @@ function readCursor(token, signature, count) {
     }
   }
   if (!Array.isArray(parsed) || typeof parsed[0] !== "string") {
-    fail("OKM1130", "after is not a cursor that page() returned.");
+    fail2("OKM1130", "after is not a cursor that page() returned.");
   }
   if (parsed[0] !== signature) {
-    fail("OKM1130", `The cursor was made for another order: ${parsed[0]}. This page orders by ${signature}.`);
+    fail2("OKM1130", `The cursor was made for another order: ${parsed[0]}. This page orders by ${signature}.`);
   }
   const values = parsed.slice(1);
   if (values.length !== count || !values.every((value) => value === null || typeof value === "string")) {
-    fail("OKM1130", "after is not a cursor that page() returned.");
+    fail2("OKM1130", "after is not a cursor that page() returned.");
   }
   return values;
 }
-export {
-  build
-};
+
+export { build3 };

package/dist/shared/pt94kz7f.js

@@ -0,0 +1,6 @@
+import {
+  build3
+} from "./pbp1ss85.js";
+export {
+  build3 as build
+};

package/dist/shared/q5c6ngn3.js

@@ -0,0 +1,13 @@
+import {
+  fail2
+} from "./67txcrcw.js";
+
+// src/runtime/result-name.ts
+var PROTOTYPE_KEYS = ",__proto__,constructor,toString,hasOwnProperty,valueOf,isPrototypeOf,propertyIsEnumerable,toLocaleString,__defineGetter__,__defineSetter__,__lookupGetter__,__lookupSetter__,then,";
+function refusePrototypeKey(name, where) {
+  if (!PROTOTYPE_KEYS.includes(`,${name},`))
+    return;
+  fail2("OKM1120", `${where} ${name} is a prototype key. Use another name for the result.`);
+}
+
+export { refusePrototypeKey };

package/dist/shared/{xq0mvhts.js → rs73fca9.js}

@@ -1,13 +1,13 @@
 import"./qq3899ht.js";
 import"./n442h54c.js";
-import"./wkme6tep.js";
+import"./14vx95q4.js";
 import {
   projectPath,
   loadConfig
-} from "./t3g0k88x.js";
+} from "./gs74dbj5.js";
 import {
   listTargets
-} from "./ttmg09vd.js";
+} from "./tsvww22q.js";
 import"./9s0ypp87.js";
 
 // src/tooling/migrate/dev.ts
@@ -20,7 +20,7 @@ async function devProject(cwd) {
 `;
   const directory = projectPath(cwd, config.out ?? ".okm", "dev-db");
   mkdirSync(directory, { recursive: true });
-  const { open } = await import("./g90m9b0g.js");
+  const { open } = await import("./aytqh5y2.js");
   const pool = await open({ dataDir: directory });
   try {
     await pool.execute("select 1");

package/dist/shared/{r11n8grd.js → sfz1ksn6.js}

@@ -3,10 +3,10 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./j60w0dvr.js";
+} from "./tbrvgw6z.js";
 import {
-  fail
-} from "./2z7wv5tj.js";
+  fail2
+} from "./67txcrcw.js";
 import {
   OkmError2,
   throwNamed2
@@ -35,13 +35,16 @@ function plan(session, table, options, mods, view) {
       }
     });
   }
+  if (lock === "skip") {
+    fail2("OKM1120", 'lock: "skip" claims rows on update. A read uses lock: "update" and wait: "skip".', 'Pass lock: "update" and wait: "skip" inside tx(). An update can claim rows on its own.');
+  }
   if (session.tx === undefined) {
     throw new OkmError2("OKM1830", "A row lock needs a transaction. find was called outside tx().", {
       fix: { summary: "Move the find into tx(): the lock lasts until the transaction ends." }
     });
   }
   if (lock === undefined)
-    fail("OKM1121", "wait needs lock: pass lock: update or lock: share.");
+    fail2("OKM1121", "wait needs lock: pass lock: update or lock: share.");
   if (typeof lock !== "string" || !LOCKS.includes(lock)) {
     throwNamed2("OKM1120", shown(lock), LOCKS, `lock must be one of: ${LOCKS.join(", ")}.`);
   }

package/dist/shared/{wynzeggs.js → svncdeh5.js}

@@ -1,6 +1,6 @@
 import {
   open2
-} from "./wkme6tep.js";
+} from "./14vx95q4.js";
 import"./qq3899ht.js";
 import"./n442h54c.js";
 import {
@@ -14,20 +14,20 @@ import {
 import {
   expandProvisioned,
   provisionHistoryIsKnown
-} from "./p248q79y.js";
-import"./knmes2kh.js";
-import"./vjpnzwjz.js";
+} from "./m6p12kbr.js";
+import"./8skf0cam.js";
+import"./b5pftnn2.js";
 import {
   projectPath,
   loadMigrations,
   loadConfig
-} from "./t3g0k88x.js";
+} from "./gs74dbj5.js";
 import {
   sessionFailure,
   finishQuiet,
   assertTargetPolicy,
   listTargets
-} from "./ttmg09vd.js";
+} from "./tsvww22q.js";
 import"./9s0ypp87.js";
 import {
   OkmError2

package/dist/shared/{j60w0dvr.js → tbrvgw6z.js}

@@ -6,8 +6,9 @@ import {
   compileCall,
   decodeResult,
   logicalIntent,
-  appliedRules
-} from "./2z7wv5tj.js";
+  appliedRules,
+  rejectKeys
+} from "./67txcrcw.js";
 import {
   OkmError2,
   safe2,
@@ -85,7 +86,7 @@ function openClient(session) {
     },
     close,
     connected: session.connected,
-    tx: (...args) => import("./5d8t84hg.js").then((mod) => mod.tx(session, args)),
+    tx: (...args) => import("./vczs8gd4.js").then((mod) => mod.tx(session, args)),
     batch: (ops, options) => batchHandle(session, ops, options),
     ...session.tx?.extras
   };
@@ -120,7 +121,7 @@ function tableApi(session, table, view, uses) {
   const api = {
     find(options = {}) {
       if ("lock" in options) {
-        return lazyRead(session, () => import("./r11n8grd.js"), table, options, base, view);
+        return lazyRead(session, () => import("./sfz1ksn6.js"), table, options, base, view);
       }
       return start(session, "find", table, options, base, view);
     },
@@ -134,10 +135,10 @@ function tableApi(session, table, view, uses) {
       return start(session, "exists", table, options, base, view);
     },
     page(options) {
-      return lazyRead(session, () => import("./pjr6xrm5.js"), table, options, base, view);
+      return lazyRead(session, () => import("./pt94kz7f.js"), table, options, base, view);
     },
     aggregate(options = {}) {
-      return lazyRead(session, () => import("./venqrjna.js"), table, options, base, view);
+      return lazyRead(session, () => import("./1est4ezg.js"), table, options, base, view);
     },
     insert(data, options = {}) {
       return writeHandle(session, "insert", table, data, options, mods);
@@ -149,6 +150,10 @@ function tableApi(session, table, view, uses) {
       return writeHandle(session, "delete", table, target, options, mods);
     }
   };
+  for (const walk of ["descendants", "ancestors"]) {
+    api[walk] = (id, options) => lazyRead(session, () => import("./7mnme5tn.js"), table, { id, walk, options }, base, view);
+  }
+  api.sync = (id, relation, ids, options) => lazyRead(session, () => import("./te5as7z7.js"), table, { id, relation, ids, options }, base, view, true);
   const hooks = session.schema.hooks;
   if (hooks !== undefined) {
     for (const hook of hooks) {
@@ -167,13 +172,13 @@ function tableApi(session, table, view, uses) {
   return api;
 }
 function batchHandle(session, ops, options, replica) {
-  return queryHandle(() => import("./sbdme3vy.js").then((mod) => mod.batch(session, ops, options, replica)), {
+  return queryHandle(() => import("./vb6qfyve.js").then((mod) => mod.batch(session, ops, options, replica)), {
     replica: () => batchHandle(session, ops, options, true)
   });
 }
 var writers;
 function loadWrite() {
-  writers ??= import("./2cg3wnxc.js");
+  writers ??= import("./5v3xf80k.js");
   return writers;
 }
 function queryHandle(run, extra) {
@@ -258,41 +263,53 @@ function start(session, op, table, options, mods, view) {
       throw new OkmError2("not_found", `one() on ${table} matched no row.`, withHttp(session.http, { kind: "not_found", table }));
     }
     return value;
-  }, (prepare) => ({
+  }, () => ({
     all(reason) {
       return start(session, op, table, options, { ...mods, all: reason }, view);
     },
     required() {
       return start(session, op, table, options, { ...mods, required: true }, view);
     },
-    stream() {
-      return streamLazy(session, call, prepare);
+    stream(batch) {
+      return streamLazy(session, call, mods, view, batch);
     }
   }));
 }
-function lazyRead(session, load, table, options, mods, view) {
+function lazyRead(session, load, table, options, mods, view, sync) {
   const read = () => load().then((mod) => ({ it: mod.build(session, table, options, mods, view) }));
-  return queryHandle(() => read().then((box) => box.it), {
-    inspect: () => read().then((box) => box.it.inspect()),
-    sql: () => read().then((box) => box.it.sql()),
-    all: (reason) => lazyRead(session, load, table, options, { ...mods, all: reason }, view)
-  });
+  const sql = () => read().then((box) => box.it.sql());
+  const extra = { sql };
+  if (sync) {
+    extra.expect = (count) => lazyRead(session, load, table, options, { ...mods, expect: count }, view, true);
+  } else {
+    extra.inspect = () => read().then((box) => box.it.inspect());
+    extra.all = (reason) => lazyRead(session, load, table, options, { ...mods, all: reason }, view);
+  }
+  return queryHandle(() => read().then((box) => box.it), extra);
 }
 async function decodeRows(plan, rows, table) {
-  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./ys0xzyaj.js")).decodeIncluded(plan, rows, table);
+  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./dkxgzaqd.js")).decodeIncluded(plan, rows, table);
 }
 function readHandle(session, table, call, mods, decode, extra) {
   let prepared;
   const origin = call;
+  const searched = "search" in call;
   const prepare = async () => {
     if (prepared !== undefined)
       return prepared;
     if (mods.uses !== undefined) {
-      call = (await import("./r6nwkxnt.js")).refine(session.schema, origin, mods.uses);
+      call = (await import("./m7n9h2a5.js")).refine(session.schema, origin, mods.uses);
+    }
+    if (searched) {
+      call = (await import("./jznfax0y.js")).applyTextSearch(session.schema, call);
     }
-    if (readNeedsOperatorSql(session.schema, call))
-      await loadOperatorSql();
     const hooks = await hooksFor(call);
+    if (readNeedsOperatorSql(session.schema, call) || hooks?.needsOperator(session.schema, call)) {
+      await loadOperatorSql();
+    }
+    if (call.build === undefined && selectHasWindow(call.select)) {
+      call = (await import("./gzaveazc.js")).attach(session.schema, call);
+    }
     const bound = bindCall(session.schema, call, hooks);
     let plan = session.cache.get(bound.key);
     if (plan === undefined) {
@@ -307,7 +324,7 @@ function readHandle(session, table, call, mods, decode, extra) {
     prepared = { plan, params: bound.params };
     return prepared;
   };
-  const sync = () => call.include === undefined && mods.uses === undefined && !readNeedsOperatorSql(session.schema, call);
+  const sync = () => !searched && call.include === undefined && mods.uses === undefined && !selectHasWindow(call.select) && !readNeedsOperatorSql(session.schema, call);
   const run = async () => {
     await session.connected;
     const { plan, params } = await prepare();
@@ -352,10 +369,10 @@ function readHandle(session, table, call, mods, decode, extra) {
     ...extra?.(prepare)
   });
 }
-function streamLazy(session, call, prepare) {
+function streamLazy(session, call, mods, view, batch) {
   return async function* () {
-    const { streamRows } = await import("./3qnhc7w5.js");
-    yield* streamRows(session, call, prepare, (error) => logged(session, error));
+    const { streamRows } = await import("./cn957f8d.js");
+    yield* streamRows(session, call, mods, view, batch, (error) => logged(session, error));
   }();
 }
 function archiveRecord(model, view) {
@@ -368,12 +385,7 @@ function archiveRecord(model, view) {
 }
 function readCall(op, table, options, all, scope, model, schema, view) {
   const record = options;
-  const accepted = readOptionNames(op);
-  for (const key of Object.keys(record)) {
-    if (!accepted.includes(key)) {
-      throwNamed2("OKM1120", key, accepted, `Option ${key} is not accepted by ${op}. Accepted options: ${accepted.join(", ")}.`);
-    }
-  }
+  rejectKeys(record, readOptionNames(op), op, true);
   return {
     op,
     table,
@@ -382,6 +394,7 @@ function readCall(op, table, options, all, scope, model, schema, view) {
     ...record.orderBy !== undefined ? { orderBy: record.orderBy } : {},
     ...record.limit !== undefined ? { limit: record.limit } : {},
     ...record.include !== undefined ? { include: record.include } : {},
+    ..."search" in record ? { search: record.search } : {},
     ...callOptions(record),
     ...all !== undefined ? { all } : {},
     ...scope !== undefined ? { scope } : {},
@@ -391,13 +404,13 @@ function readCall(op, table, options, all, scope, model, schema, view) {
   };
 }
 async function checkServer(pool, schema, http, requireMeta, options, source) {
-  const server = await import("./y2t3jktd.js");
+  const server = await import("./ttsqgp4p.js");
   let rows;
   try {
     const result = await pool.execute(server.versionQuery, undefined, options);
     rows = result.rows;
   } catch (error) {
-    const { mapPostgresError } = await import("./d5azex6s.js");
+    const { mapPostgresError } = await import("./63qtkrca.js");
     throw mapPostgresError(error, mapOptions(http, false, schema));
   }
   await server.acceptServer(pool, schema, rows, http, requireMeta, options, source);
@@ -406,7 +419,7 @@ async function mapError(session, error) {
   if (error instanceof OkmError2) {
     return session.http === undefined ? error : new OkmError2(error.code, error.message, { ...errorFields(error), http: session.http });
   }
-  const { mapPostgresError } = await import("./d5azex6s.js");
+  const { mapPostgresError } = await import("./63qtkrca.js");
   return mapPostgresError(error, mapOptions(session.http, session.includeValues, session.schema));
 }
 function errorFields(error) {
@@ -420,15 +433,18 @@ function errorFields(error) {
 var includeHooks;
 var operatorSql;
 function loadOperatorSql() {
-  operatorSql ??= import("./n076ydsc.js").then(() => {
+  operatorSql ??= import("./xhfsfkgk.js").then(() => {
     return;
   });
   return operatorSql;
 }
+function selectHasWindow(select) {
+  return Array.isArray(select) && select.some((item) => typeof item !== "string");
+}
 function hooksFor(call) {
   if (call.include === undefined)
     return Promise.resolve(undefined);
-  includeHooks ??= import("./ys0xzyaj.js").then((mod) => mod.includeHooks);
+  includeHooks ??= import("./dkxgzaqd.js").then((mod) => mod.includeHooks);
   return includeHooks;
 }
 function bindNow(schema, call) {
@@ -461,12 +477,15 @@ function attachHttp(http, error) {
 function callOptions(input, statement) {
   const timeout = input.timeout ?? statement;
   const route = input.route;
-  if (input.signal === undefined && timeout === undefined && route === undefined)
+  const pin = input.pin;
+  if (input.signal === undefined && timeout === undefined && route === undefined && pin === undefined) {
     return;
+  }
   return {
     ...input.signal !== undefined ? { signal: input.signal } : {},
     ...timeout !== undefined ? { timeout } : {},
-    ...route !== undefined ? { route } : {}
+    ...route !== undefined ? { route } : {},
+    ...pin !== undefined ? { pin } : {}
   };
 }
 function mapOptions(http, includeValues, schema) {