okmodel 0.5.0 → 0.5.1

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

@@ -976,6 +976,189 @@ function functionCalls(expression) {
   return names;
 }
 
+// src/tooling/migrate/sql-lex.ts
+function sqlStatements(sql) {
+  return scan(sql).statements;
+}
+function sqlQuoteOpen(sql) {
+  return scan(sql).open;
+}
+function scan(sql) {
+  const statements = [];
+  const parts = [];
+  let index = 0;
+  let open = false;
+  const flush = () => {
+    const text = parts.join("").trim();
+    parts.length = 0;
+    if (text.length > 0)
+      statements.push(text);
+  };
+  while (index < sql.length) {
+    if (sql.startsWith("--", index)) {
+      parts.push(" ");
+      index = lineCommentEnd(sql, index + 2);
+      continue;
+    }
+    if (sql.startsWith("/*", index)) {
+      parts.push(" ");
+      const block = blockComment(sql, index + 2);
+      index = block.index;
+      if (block.open) {
+        open = true;
+        break;
+      }
+      continue;
+    }
+    const dollar = dollarAt(sql, index);
+    if (dollar !== undefined) {
+      const closed = takeDollar(sql, dollar);
+      parts.push(sql.slice(index, closed.index));
+      index = closed.index;
+      if (closed.open) {
+        open = true;
+        break;
+      }
+      continue;
+    }
+    if (isEscapeString(sql, index)) {
+      const quote = takeQuoted(sql, index + 2, true);
+      parts.push(sql.slice(index, quote.index));
+      index = quote.index;
+      if (quote.open) {
+        open = true;
+        break;
+      }
+      continue;
+    }
+    const char = sql[index];
+    if (char === "'") {
+      const quote = takeQuoted(sql, index + 1, false);
+      parts.push(sql.slice(index, quote.index));
+      index = quote.index;
+      if (quote.open) {
+        open = true;
+        break;
+      }
+      continue;
+    }
+    if (char === '"') {
+      const quote = takeIdent(sql, index + 1);
+      parts.push(sql.slice(index, quote.index));
+      index = quote.index;
+      if (quote.open) {
+        open = true;
+        break;
+      }
+      continue;
+    }
+    if (char === ";") {
+      flush();
+      index += 1;
+      continue;
+    }
+    parts.push(char ?? "");
+    index += 1;
+  }
+  flush();
+  return { statements, open };
+}
+function lineCommentEnd(sql, index) {
+  while (index < sql.length && sql.charCodeAt(index) !== 10)
+    index += 1;
+  return index;
+}
+function blockComment(sql, index) {
+  let depth = 1;
+  while (index < sql.length) {
+    if (sql.startsWith("/*", index)) {
+      depth += 1;
+      index += 2;
+      continue;
+    }
+    if (sql.startsWith("*/", index)) {
+      depth -= 1;
+      index += 2;
+      if (depth === 0)
+        return { index, open: false };
+      continue;
+    }
+    index += 1;
+  }
+  return { index, open: true };
+}
+function dollarAt(sql, index) {
+  if (sql.charCodeAt(index) !== 36)
+    return;
+  const next = index + 1;
+  if (sql.charCodeAt(next) === 36)
+    return { tag: "", end: next + 1 };
+  if (!isIdentStart(sql.charCodeAt(next)))
+    return;
+  let cursor = next + 1;
+  while (isIdentCont(sql.charCodeAt(cursor)))
+    cursor += 1;
+  if (sql.charCodeAt(cursor) !== 36)
+    return;
+  return { tag: sql.slice(next, cursor), end: cursor + 1 };
+}
+function takeDollar(sql, dollar) {
+  const closer = `$${dollar.tag}$`;
+  const found = sql.indexOf(closer, dollar.end);
+  if (found === -1)
+    return { index: sql.length, open: true };
+  return { index: found + closer.length, open: false };
+}
+function takeQuoted(sql, index, escape) {
+  while (index < sql.length) {
+    const char = sql[index];
+    if (escape && char === "\\") {
+      if (index + 1 >= sql.length)
+        return { index: sql.length, open: true };
+      index += 2;
+      continue;
+    }
+    if (char === "'") {
+      if (sql[index + 1] === "'") {
+        index += 2;
+        continue;
+      }
+      return { index: index + 1, open: false };
+    }
+    index += 1;
+  }
+  return { index, open: true };
+}
+function takeIdent(sql, index) {
+  while (index < sql.length) {
+    if (sql[index] === '"') {
+      if (sql[index + 1] === '"') {
+        index += 2;
+        continue;
+      }
+      return { index: index + 1, open: false };
+    }
+    index += 1;
+  }
+  return { index, open: true };
+}
+function isEscapeString(sql, index) {
+  const code = sql.charCodeAt(index);
+  if (code !== 69 && code !== 101)
+    return false;
+  if (sql.charCodeAt(index + 1) !== 39)
+    return false;
+  if (index > 0 && isIdentCont(sql.charCodeAt(index - 1)))
+    return false;
+  return true;
+}
+function isIdentStart(code) {
+  return code >= 65 && code <= 90 || code >= 97 && code <= 122 || code === 95;
+}
+function isIdentCont(code) {
+  return isIdentStart(code) || code >= 48 && code <= 57;
+}
+
 // src/tooling/migrate/values.ts
 function parseReplace(flag) {
   const eq = flag.indexOf("=");
@@ -1377,9 +1560,16 @@ function parsePlan(text) {
     let behavior;
     const allows = [];
     const sql = [];
-    while (index < lines.length && (lines[index] ?? "") !== "") {
+    let quoteOpen = false;
+    while (index < lines.length && (quoteOpen || (lines[index] ?? "") !== "")) {
       const line = lines[index] ?? "";
       index += 1;
+      if (quoteOpen) {
+        sql.push(line);
+        quoteOpen = sqlQuoteOpen(sql.join(`
+`));
+        continue;
+      }
       if (line.startsWith("-- class: ")) {
         stepClass = readClass(line.slice("-- class: ".length));
         sawClass = true;
@@ -1401,8 +1591,11 @@ function parsePlan(text) {
         behavior = "change";
       else if (line.startsWith("-- okm-allow"))
         allows.push(readAllow(line));
-      else if (!line.startsWith("--"))
+      else if (!line.startsWith("--")) {
         sql.push(line);
+        quoteOpen = sqlQuoteOpen(sql.join(`
+`));
+      }
     }
     const statement = sql.join(`
 `).replace(/;\s*$/, "");
@@ -2429,4 +2622,165 @@ function order(value) {
   return value;
 }
 
-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 };
+// src/tooling/migrate/policy.ts
+var READ = new Set([
+  "plan",
+  "status",
+  "check",
+  "drift",
+  "verify",
+  "pull",
+  "catalog-export",
+  "inspect"
+]);
+var ALLOWED = new Set(["expand", "reference", "provision"]);
+var FORWARD_ONLY = new Set(["drop", "rollback"]);
+function assertTargetPolicy(target, operation, allowProtected = false) {
+  if (FORWARD_ONLY.has(operation)) {
+    throw new OkmError2("invalid", "There is no down migration.", {
+      fix: { summary: "Recovery is a new forward migration." }
+    });
+  }
+  if (!target.protected || allowProtected)
+    return;
+  if (READ.has(operation) || ALLOWED.has(operation))
+    return;
+  throw new OkmError2("OKM1850", `${operation} is blocked on protected target ${target.name}.`, {
+    kind: "forbidden",
+    fix: {
+      summary: "Run a read-only command or an expand migration, or pass --allow-protected for this invocation."
+    }
+  });
+}
+function assertTargetAlias(targets) {
+  const groups = new Map;
+  for (const target of targets) {
+    const key = `${target.host}
+${target.port}
+${target.database}`;
+    const group = groups.get(key);
+    if (group === undefined)
+      groups.set(key, [target]);
+    else
+      group.push(target);
+  }
+  for (const group of groups.values()) {
+    const protectedTarget = group.find((target) => target.protected);
+    const open = group.find((target) => !target.protected);
+    if (protectedTarget !== undefined && open !== undefined) {
+      throw new OkmError2("OKM1852", `${open.name} and ${protectedTarget.name} resolve to the same database and disagree about protection.`, {
+        fix: {
+          summary: "Give those targets the same protection flag. okm check and okm doctor both report this."
+        }
+      });
+    }
+  }
+}
+function assertDirectConnection(url, allowPooler) {
+  if (allowPooler)
+    return;
+  const endpoint = endpointOf(url);
+  const parsed = new URL(url);
+  const host = endpoint.host;
+  if (host.includes("pooler") || host.includes("pgbouncer") || host.includes("-pooler") || endpoint.port === "6543" || endpoint.port === "6432" || parsed.searchParams.get("pgbouncer") === "true") {
+    throw new OkmError2("invalid", `Refusing pooler host ${host}. Apply needs a direct connection.`, { fix: { summary: "Use a direct connection, or pass --allow-pooler." } });
+  }
+}
+async function assertStableBackend(readPid, allowPooler) {
+  if (allowPooler)
+    return;
+  const first = await readPid();
+  const second = await readPid();
+  if (first === second)
+    return;
+  throw new OkmError2("OKM1854", `The backend pid changed from ${first} to ${second}. A pooler is handing out a new session between statements.`, { fix: { summary: "Use a direct connection, or pass --allow-pooler." } });
+}
+function listTargets(config) {
+  if (config.database !== undefined && config.targets !== undefined) {
+    throw new OkmError2("invalid", "Set database or targets, not both.", {
+      fix: { summary: "database is the one target named default. Use targets for more than one." }
+    });
+  }
+  const entries = [];
+  if (config.database !== undefined)
+    entries.push(["default", config.database]);
+  if (config.targets !== undefined) {
+    for (const name of Object.keys(config.targets).sort()) {
+      const input = config.targets[name];
+      if (input !== undefined)
+        entries.push([name, input]);
+    }
+  }
+  return entries.map(([name, input]) => resolveTarget(name, input));
+}
+function selectTarget(config, name) {
+  const targets = listTargets(config);
+  if (targets.length === 0) {
+    throw new OkmError2("OKM1845", "No target is configured.", {
+      fix: { summary: "Set database or targets in okmodel.config.ts." }
+    });
+  }
+  if (name === undefined) {
+    if (targets.length === 1) {
+      const only = targets[0];
+      if (only !== undefined)
+        return only;
+    }
+    throw new OkmError2("OKM1853", "Several targets are configured and --target was not passed.", {
+      fix: { summary: "Pass --target <name>. The command does not guess." }
+    });
+  }
+  const found = targets.find((target) => target.name === name);
+  if (found === undefined) {
+    throw new OkmError2("OKM1845", `Target ${name} is not configured.`, {
+      fix: { summary: "Pass a name from targets, or database for the target named default." }
+    });
+  }
+  return found;
+}
+function resolveTarget(name, input) {
+  if (typeof input !== "string" && isReplicaTarget(input)) {
+    throw new OkmError2("OKM1845", `Target ${name} is a replica. Migrations run on the primary only.`, {
+      fix: {
+        summary: "Set database or targets to the primary URL. A replica is not a migration target."
+      }
+    });
+  }
+  const url = typeof input === "string" ? input : input.url;
+  const protectedTarget = typeof input === "string" ? false : input.protected === true;
+  if (url === undefined || url.length === 0) {
+    throw new OkmError2("OKM1845", `Target ${name} has no url.`, {
+      fix: { summary: "Set the target url. A target is not inferred from the environment." }
+    });
+  }
+  const endpoint = endpointOf(url);
+  return {
+    name,
+    url,
+    protected: protectedTarget,
+    host: endpoint.host,
+    port: endpoint.port,
+    database: endpoint.database
+  };
+}
+function isReplicaTarget(input) {
+  return "primary" in input || "replicas" in input || "weight" in input || "pool" in input;
+}
+function endpointOf(url) {
+  let parsed;
+  try {
+    parsed = new URL(url);
+  } catch {
+    throw new OkmError2("OKM1845", "The target URL is not a Postgres URL.", {
+      fix: { summary: "Pass a postgres:// URL for the target." }
+    });
+  }
+  const database = decodeURIComponent(parsed.pathname.replace(/^\//, ""));
+  return {
+    host: parsed.hostname.toLowerCase(),
+    port: parsed.port.length > 0 ? parsed.port : "5432",
+    database
+  };
+}
+
+export { canonicalTypeName, createdRoleName, createRoleOnce, changesRole, DEFAULT_BACKFILL_PAUSE_MS, DEFAULT_BACKFILL_STATEMENT_TIMEOUT_MS, batchSizeField, aboutBatchCount, boundaryQuery, checkedCast, classOf, strictestClass, assertExtensionsAvailable, omitManagedObjects, sqlStatements, parseReplace, planMigration, formatPlan, parsePlan, staleRenames, assertTargetPolicy, assertTargetAlias, assertDirectConnection, assertStableBackend, listTargets, selectTarget };

package/dist/shared/{qgvt8nx1.js → gbtcc2d7.js}

@@ -533,7 +533,9 @@ function emitIn(column, ref, name, value, sink) {
   sink.text(")");
 }
 function emitOr(schema, table, value, sink, alias, depth) {
-  if (!Array.isArray(value) || value.length === 0) {
+  if (!Array.isArray(value))
+    orFail(false);
+  if (value.length === 0) {
     sink.text("false");
     sink.mark(":0");
     return;
@@ -559,7 +561,7 @@ function emitOr(schema, table, value, sink, alias, depth) {
       emitPredicate(schema, table, key, item, sink, alias, depth);
     }
     if (!wrote)
-      sink.text("true");
+      orFail(true);
     sink.text(")");
   }
   sink.text(")");
@@ -844,6 +846,45 @@ function list(names) {
 function isRecord(value) {
   return typeof value === "object" && value !== null && !Array.isArray(value) && !isOperator(value);
 }
+function effectivePredicate(where) {
+  if (where === undefined)
+    return false;
+  if (isOperator(where)) {
+    const name = operatorName(where);
+    const value = operatorValue(where);
+    if (name === "or") {
+      if (!Array.isArray(value))
+        orFail(false);
+      if (value.length === 0)
+        return true;
+      for (const branch of value) {
+        if (!effectivePredicate(branch))
+          orFail(true);
+      }
+      return true;
+    }
+    if (name === "and") {
+      return Array.isArray(value) && value.some((part) => effectivePredicate(part));
+    }
+    if (name === "not")
+      return effectivePredicate(value);
+    return true;
+  }
+  if (!isRecord(where))
+    return true;
+  for (const key of Object.keys(where)) {
+    if (where[key] !== undefined)
+      return true;
+  }
+  return false;
+}
+function orFail(empty) {
+  throw new OkmError2("OKM1121", empty ? "or() branch is empty." : "Pass an array: or([a, b]).", {
+    fix: {
+      summary: empty ? "Give every or() branch a predicate. An empty branch matches every row." : "Pass an array: or([a, b])."
+    }
+  });
+}
 var FAIL_FIX = {
   OKM1121: "Use eq for an object value, or has, none, or every for a relation.",
   OKM1101: "Pass limit, or call .all(reason)."
@@ -875,4 +916,4 @@ function hasMany(include) {
   return Object.keys(include).length > 0;
 }
 
-export { withRowFilters, installArchiveInspect, archiveRules, readOptionNames, installOperatorSql, readNeedsOperatorSql, emitRelationFrom, bindCall, compileCall, decodeResult, logicalIntent, appliedRules, emitJoin, emitWhere, emitOrder, emitPrimaryOrder, selectedColumns, parseOrder, rejectKeys, readLimit, takeObject, projectExpr, jsonExpr, decodeRow, cell, indexes, quote, list, isRecord, registerFailFix, fail };
+export { withRowFilters, installArchiveInspect, archiveRules, readOptionNames, installOperatorSql, readNeedsOperatorSql, emitRelationFrom, bindCall, compileCall, decodeResult, logicalIntent, appliedRules, emitJoin, emitWhere, emitOrder, emitPrimaryOrder, selectedColumns, parseOrder, rejectKeys, readLimit, takeObject, projectExpr, jsonExpr, decodeRow, cell, indexes, quote, list, isRecord, effectivePredicate, registerFailFix, fail };

package/dist/shared/{kdkxh3kb.js → gde73es6.js}

@@ -7,9 +7,6 @@ import {
 import {
   roleExists
 } from "./szm0cksa.js";
-import {
-  assertTargetPolicy
-} from "./xdpj5kkm.js";
 import {
   canonicalTypeName,
   createdRoleName,
@@ -20,8 +17,9 @@ import {
   checkedCast,
   omitManagedObjects,
   planMigration,
-  parsePlan
-} from "./ayz64vzj.js";
+  parsePlan,
+  assertTargetPolicy
+} from "./ga3sfy93.js";
 import {
   quoteIdent,
   qualify
@@ -35,7 +33,7 @@ import {
 } from "./g7ez901n.js";
 import {
   snakeCase
-} from "./jsd07prz.js";
+} from "./ntneex2a.js";
 import {
   quoteLiteral
 } from "./94ez8kzh.js";
@@ -309,7 +307,7 @@ function failStep(unit, index, error) {
   if (error instanceof OkmError2)
     return error;
   const message = error instanceof Error ? error.message : "The step failed.";
-  return new OkmError2("invalid", `Migration ${unit.migrationId} failed at step ${String(index)}: ${message}`, {
+  return new OkmError2("invalid", `Migration ${unit.migrationId} failed at step ${String(index + 1)}: ${message}`, {
     cause: error,
     fix: { summary: "Fix the step and run apply again. Finished steps are not repeated." }
   });

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

@@ -7,7 +7,7 @@ import {
   decodeResult,
   logicalIntent,
   appliedRules
-} from "./qgvt8nx1.js";
+} from "./gbtcc2d7.js";
 import {
   OkmError2,
   safe2,
@@ -22,10 +22,22 @@ var SINGLE_ENDPOINT = {
   reason: "single-endpoint"
 };
 function createClient(schema, pool, options) {
-  const connected = checkServer(pool, schema, options.http, options.requireMeta === true, callOptions(options), {
+  const closing = {
+    current: undefined,
+    early: false
+  };
+  const checked = checkServer(pool, schema, options.http, options.requireMeta === true, callOptions(options), {
     ...options.catalog !== undefined ? { catalog: options.catalog } : {},
     ...options.catalogDir !== undefined ? { catalogDir: options.catalogDir } : {}
   });
+  const connected = checked.catch((error) => {
+    if (!closing.early)
+      throw error;
+    throw new OkmError2("unavailable", "The client was closed before it connected. Await connected before close(), or do not close it before use.", { kind: "unavailable", fix: { summary: "Await client.connected before calling close()." } });
+  });
+  connected.catch(() => {
+    return;
+  });
   const session = {
     schema,
     pool,
@@ -38,7 +50,7 @@ function createClient(schema, pool, options) {
     generators: options.generators,
     timeouts: options.timeouts,
     hookm: options.hookm,
-    closing: { current: undefined }
+    closing
   };
   return openClient(session);
 }
@@ -50,6 +62,7 @@ function openClient(session) {
   const close = () => {
     if (!session.ownsPool)
       return Promise.resolve();
+    session.closing.early = true;
     session.closing.current ??= session.pool.close();
     return session.closing.current;
   };
@@ -72,7 +85,7 @@ function openClient(session) {
     },
     close,
     connected: session.connected,
-    tx: (...args) => import("./k7cc9nzk.js").then((mod) => mod.tx(session, args)),
+    tx: (...args) => import("./r2sp8hrc.js").then((mod) => mod.tx(session, args)),
     batch: (ops, options) => batchHandle(session, ops, options),
     ...session.tx?.extras
   };
@@ -107,7 +120,7 @@ function tableApi(session, table, view, uses) {
   const api = {
     find(options = {}) {
       if ("lock" in options) {
-        return lazyRead(session, () => import("./dxjp14rk.js"), table, options, base, view);
+        return lazyRead(session, () => import("./tm5ab8we.js"), table, options, base, view);
       }
       return start(session, "find", table, options, base, view);
     },
@@ -121,10 +134,10 @@ function tableApi(session, table, view, uses) {
       return start(session, "exists", table, options, base, view);
     },
     page(options) {
-      return lazyRead(session, () => import("./h4nqvjkp.js"), table, options, base, view);
+      return lazyRead(session, () => import("./6rk2gen5.js"), table, options, base, view);
     },
     aggregate(options = {}) {
-      return lazyRead(session, () => import("./r6pj4fq2.js"), table, options, base, view);
+      return lazyRead(session, () => import("./kfjp0gck.js"), table, options, base, view);
     },
     insert(data, options = {}) {
       return writeHandle(session, "insert", table, data, options, mods);
@@ -154,13 +167,13 @@ function tableApi(session, table, view, uses) {
   return api;
 }
 function batchHandle(session, ops, options, replica) {
-  return queryHandle(() => import("./xsq7v6wp.js").then((mod) => mod.batch(session, ops, options, replica)), {
+  return queryHandle(() => import("./aj2qxyhj.js").then((mod) => mod.batch(session, ops, options, replica)), {
     replica: () => batchHandle(session, ops, options, true)
   });
 }
 var writers;
 function loadWrite() {
-  writers ??= import("./p7pfx624.js");
+  writers ??= import("./qm7cdtvr.js");
   return writers;
 }
 function queryHandle(run, extra) {
@@ -215,9 +228,30 @@ async function runWrite(session, op, table, input, options, mods, plan) {
     throw logged(session, await mapError(session, error));
   }
 }
+function rejectedRead(error) {
+  const fail = () => Promise.reject(error);
+  return queryHandle(fail, {
+    all: () => rejectedRead(error),
+    required: () => rejectedRead(error),
+    inspect: fail,
+    sql: fail,
+    stream() {
+      return {
+        [Symbol.asyncIterator]() {
+          return { next: fail };
+        }
+      };
+    }
+  });
+}
 function start(session, op, table, options, mods, view) {
   const model = session.schema.model[table];
-  const call = readCall(op, table, options, mods.all, session.scope, model, session.schema, view);
+  let call;
+  try {
+    call = readCall(op, table, options, mods.all, session.scope, model, session.schema, view);
+  } catch (error) {
+    return rejectedRead(error instanceof OkmError2 ? attachHttp(session.http, error) : error);
+  }
   return readHandle(session, table, call, mods, async (plan, rows) => {
     const value = await decodeRows(plan, rows, table);
     if (mods.required === true && value === null) {
@@ -245,7 +279,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("./h8ne16fq.js")).decodeIncluded(plan, rows, table);
+  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./nkaxvt9q.js")).decodeIncluded(plan, rows, table);
 }
 function readHandle(session, table, call, mods, decode, extra) {
   let prepared;
@@ -320,7 +354,7 @@ function readHandle(session, table, call, mods, decode, extra) {
 }
 function streamLazy(session, call, prepare) {
   return async function* () {
-    const { streamRows } = await import("./922qbgnw.js");
+    const { streamRows } = await import("./zqrnhwsq.js");
     yield* streamRows(session, call, prepare, (error) => logged(session, error));
   }();
 }
@@ -357,13 +391,13 @@ function readCall(op, table, options, all, scope, model, schema, view) {
   };
 }
 async function checkServer(pool, schema, http, requireMeta, options, source) {
-  const server = await import("./47xzb9fc.js");
+  const server = await import("./47x8x9ze.js");
   let rows;
   try {
     const result = await pool.execute(server.versionQuery, undefined, options);
     rows = result.rows;
   } catch (error) {
-    const { mapPostgresError } = await import("./s6gqfn5j.js");
+    const { mapPostgresError } = await import("./51mvgj8w.js");
     throw mapPostgresError(error, mapOptions(http, false));
   }
   await server.acceptServer(pool, schema, rows, http, requireMeta, options, source);
@@ -372,7 +406,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("./s6gqfn5j.js");
+  const { mapPostgresError } = await import("./51mvgj8w.js");
   return mapPostgresError(error, mapOptions(session.http, session.includeValues));
 }
 function errorFields(error) {
@@ -386,7 +420,7 @@ function errorFields(error) {
 var includeHooks;
 var operatorSql;
 function loadOperatorSql() {
-  operatorSql ??= import("./tq9afp8d.js").then(() => {
+  operatorSql ??= import("./cr74e96e.js").then(() => {
     return;
   });
   return operatorSql;
@@ -394,7 +428,7 @@ function loadOperatorSql() {
 function hooksFor(call) {
   if (call.include === undefined)
     return Promise.resolve(undefined);
-  includeHooks ??= import("./h8ne16fq.js").then((mod) => mod.includeHooks);
+  includeHooks ??= import("./nkaxvt9q.js").then((mod) => mod.includeHooks);
   return includeHooks;
 }
 function bindNow(schema, call) {