okmodel 0.8.0 → 0.9.0

package/dist/tooling/shared/{f9mphxej.js → hfq3n3bd.js}

@@ -2285,6 +2285,351 @@ function isPlainRecord(value) {
 function assertNever2(value) {
   return catalogError("OKM1020", `Unexpected catalog object ${JSON.stringify(value)}.`);
 }
+// src/dialects/pg/quote.ts
+function quoteLiteral(value) {
+  return `'${value.replaceAll("'", "''")}'`;
+}
+function arrayElement(encoded, raw) {
+  if (raw && (encoded === "true" || encoded === "false" || isBareNumber(encoded))) {
+    return encoded;
+  }
+  return `"${encoded.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
+}
+function isBareNumber(encoded) {
+  let pattern = bareNumber;
+  pattern ??= /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
+  bareNumber = pattern;
+  return pattern.test(encoded);
+}
+var bareNumber;
+
+// src/dialects/pg/ddl.ts
+function quoteIdent2(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function renderCatalog2(source, schema) {
+  const folded = foldedKeys(source);
+  const statements = [];
+  const ordered = creationOrder2(source);
+  const created = uniqueBeforeForeignKey(ordered);
+  for (const object of ordered) {
+    if (object.kind !== "type" || object.owner === "ignored")
+      continue;
+    const sql = createObjectSql(object, schema);
+    if (sql !== undefined)
+      statements.push(sql);
+  }
+  for (const object of created) {
+    if (object.kind === "type" || object.kind === "function" || object.kind === "trigger" || object.kind === "view" || object.kind === "materializedView" || object.kind === "policy" || ownedByView(object)) {
+      continue;
+    }
+    if (object.owner === "ignored")
+      continue;
+    const key = identityKey(object.identity);
+    if (object.kind === "table") {
+      statements.push(createTableSql(object, source, schema));
+      continue;
+    }
+    if (folded.has(key))
+      continue;
+    const sql = createObjectSql(object, schema);
+    if (sql !== undefined)
+      statements.push(sql);
+  }
+  for (const object of created) {
+    if (object.kind !== "policy" || object.owner === "ignored")
+      continue;
+    for (const step of policyCreatePlan(object, schema))
+      statements.push(step.sql);
+  }
+  for (const kind of ["function", "trigger"]) {
+    for (const object of ordered) {
+      if (object.kind !== kind || object.owner === "ignored")
+        continue;
+      const sql = createObjectSql(object, schema);
+      if (sql !== undefined)
+        statements.push(sql);
+    }
+  }
+  for (const kind of ["view", "materializedView"]) {
+    for (const object of ordered) {
+      if (object.kind !== kind || object.owner === "ignored")
+        continue;
+      const sql = createObjectSql(object, schema);
+      if (sql !== undefined)
+        statements.push(sql);
+    }
+  }
+  for (const object of ordered) {
+    if (!ownedByView(object) || object.owner === "ignored")
+      continue;
+    const sql = createObjectSql(object, schema);
+    if (sql !== undefined)
+      statements.push(sql);
+  }
+  return statements;
+}
+function uniqueBeforeForeignKey(objects) {
+  const uniques = objects.filter((object) => object.kind === "constraint" && object.definition.constraintKind === "unique");
+  if (uniques.length === 0)
+    return objects;
+  const emitted = new Set;
+  const result = [];
+  for (const object of objects) {
+    if (emitted.has(object))
+      continue;
+    if (object.kind === "constraint" && object.definition.constraintKind === "foreignKey") {
+      const target = object.definition.references;
+      if (target !== undefined && !coveredByPrimary(objects, target.parent, target.columns)) {
+        const columns = target.columns.join("\x00");
+        for (const unique of uniques) {
+          if (emitted.has(unique))
+            continue;
+          if (!sameRef2(unique.identity.parent, target.parent))
+            continue;
+          if (unique.definition.columns.join("\x00") !== columns)
+            continue;
+          result.push(unique);
+          emitted.add(unique);
+        }
+      }
+    }
+    result.push(object);
+    emitted.add(object);
+  }
+  return result;
+}
+function coveredByPrimary(objects, parent, columns) {
+  const key = columns.join("\x00");
+  return objects.some((object) => object.kind === "constraint" && object.definition.constraintKind === "primaryKey" && sameRef2(object.identity.parent, parent) && object.definition.columns.join("\x00") === key);
+}
+function sameRef2(left, right) {
+  if (left.name !== right.name || left.namespace.form !== right.namespace.form)
+    return false;
+  if (left.namespace.form === "static" && right.namespace.form === "static") {
+    return left.namespace.name === right.namespace.name;
+  }
+  return left.namespace.form === "template" && right.namespace.form === "template" ? left.namespace.pattern === right.namespace.pattern : false;
+}
+function ownedByView(object) {
+  if (object.kind !== "index")
+    return false;
+  return object.dependencies.some((edge) => edge.target.kind === "view" || edge.target.kind === "materializedView");
+}
+function createObjectSql(object, schema) {
+  switch (object.kind) {
+    case "column":
+      return `alter table ${qualify(schema, object.identity.parent.name)} add column ${columnSql(object)}`;
+    case "index":
+      return createIndexSql(object, schema);
+    case "constraint":
+      return `alter table ${qualify(schema, object.identity.parent.name)} add constraint ${quoteIdent2(object.identity.name)} ${constraintBody(object, schema)}`;
+    case "sequence":
+      return createSequenceSql(object, schema);
+    case "type":
+      return createTypeSql(object, schema);
+    case "extension":
+      return createExtensionSql(object);
+    case "function":
+      return functionSql(object, schema, false);
+    case "trigger":
+      return triggerSql(object, schema);
+    case "view":
+      return viewSql(object, schema, false);
+    case "materializedView":
+      return materializedViewSql(object, schema);
+    case "table":
+      return;
+    default:
+      return;
+  }
+}
+function functionSql(object, schema, replace) {
+  const definition = object.definition;
+  const args = definition.arguments.map((argument) => `${quoteIdent2(argument.name)} ${argument.type}`).join(", ");
+  const head = `${replace ? "create or replace" : "create"} function ${qualify(schema, object.identity.name)}(${args})`;
+  const security = ` security ${definition.security}`;
+  const path = definition.searchPath === undefined ? "" : ` set search_path to ${definition.searchPath}`;
+  const tail = `returns ${definition.returns} language ${definition.language} ${definition.volatility}${security}${path}`;
+  if (definition.atomic)
+    return `${head} ${tail} ${definition.body}`;
+  return `${head} ${tail} as ${dollarQuote(definition.body)}`;
+}
+function viewSql(object, schema, replace) {
+  const verb = replace ? "create or replace view" : "create view";
+  const invoker = object.definition.securityInvoker === true ? " with (security_invoker = true)" : "";
+  return `${verb} ${qualify(schema, object.identity.name)}${invoker} as ${object.definition.query}`;
+}
+function policyCreatePlan(object, schema) {
+  const table = qualify(schema, object.identity.parent.name);
+  const name = quoteIdent2(object.identity.name);
+  const command = object.definition.command === "all" ? "all" : "select";
+  const check = object.definition.command === "all" ? ` with check ${object.definition.expression}` : "";
+  const create = {
+    sql: `create policy ${name} on ${table} as permissive for ${command} using ${object.definition.expression}${check}`,
+    kind: "create-policy"
+  };
+  if (object.definition.command !== "all")
+    return [create];
+  return [
+    { sql: `alter table ${table} enable row level security`, kind: "enable-rls" },
+    { sql: `alter table ${table} force row level security`, kind: "enable-rls" },
+    create
+  ];
+}
+function materializedViewSql(object, schema) {
+  return `create materialized view ${qualify(schema, object.identity.name)} as ${object.definition.query} with no data`;
+}
+function triggerSql(object, schema) {
+  const definition = object.definition;
+  const timing = definition.timing === "instead" ? "instead of" : definition.timing;
+  const events = definition.events.map((event) => {
+    if (event !== "update" || definition.updateOf === undefined)
+      return event;
+    return `update of ${definition.updateOf.map((column) => quoteIdent2(column)).join(", ")}`;
+  }).join(" or ");
+  const when = definition.when === undefined ? "" : ` when (${definition.when})`;
+  const args = definition.calls.argTypes.join(", ");
+  const fn = `${qualify(schema, definition.calls.name)}(${args})`;
+  return `create trigger ${quoteIdent2(object.identity.name)} ${timing} ${events} on ${qualify(schema, object.identity.parent.name)} for each ${definition.level}${when} execute function ${fn}`;
+}
+function dollarQuote(body) {
+  let tag = "okm";
+  while (body.includes(`$${tag}$`))
+    tag = `${tag}_`;
+  return `$${tag}$${body}$${tag}$`;
+}
+function identitySequence(sequence, source) {
+  const key = identityKey(sequence.identity);
+  return source.objects.some((object) => {
+    if (object.kind !== "column" || object.definition.identity === undefined)
+      return false;
+    return object.dependencies.some((edge) => identityKey(edge.target) === key);
+  });
+}
+function foldedKeys(source) {
+  const keys = new Set;
+  for (const object of source.objects) {
+    if (object.kind === "column")
+      keys.add(identityKey(object.identity));
+    if (object.kind === "constraint" && object.definition.constraintKind === "primaryKey") {
+      keys.add(identityKey(object.identity));
+    }
+    if (object.kind === "sequence" && identitySequence(object, source)) {
+      keys.add(identityKey(object.identity));
+    }
+  }
+  return keys;
+}
+function createTableSql(tableObject, source, schema) {
+  const parent = tableObject.identity.name;
+  const columns = source.objects.filter((object) => object.kind === "column" && object.identity.parent.name === parent);
+  const primary = source.objects.find((object) => object.kind === "constraint" && object.definition.constraintKind === "primaryKey" && object.identity.parent.name === parent);
+  const lines = columns.map((column) => columnSql(column));
+  if (primary !== undefined) {
+    const cols = primary.definition.columns.map((name) => quoteIdent2(name)).join(", ");
+    lines.push(`constraint ${quoteIdent2(primary.identity.name)} primary key (${cols})`);
+  }
+  const partition = tableObject.definition.partition;
+  const tail = partition === undefined ? "" : ` partition by ${partition.method} (${partition.columns.map((name) => quoteIdent2(name)).join(", ")})`;
+  return `create table ${qualify(schema, parent)} (
+  ${lines.join(`,
+  `)}
+)${tail}`;
+}
+function collateSql(collation) {
+  if (collation === undefined)
+    return "";
+  return ` collate ${quoteIdent2(collation)}`;
+}
+function createTypeSql(object, schema) {
+  if (isDomain(object.definition)) {
+    const name = object.identity.name;
+    const constraint = quoteIdent2(fitIdentifier(`${name}_check`));
+    return `create domain ${qualify(schema, name)} as ${object.definition.base} constraint ${constraint} check (${object.definition.check})`;
+  }
+  const labels = object.definition.labels.map((label) => quoteLiteral(label)).join(", ");
+  return `create type ${qualify(schema, object.identity.name)} as enum (${labels})`;
+}
+function columnSql(column) {
+  const definition = column.definition;
+  let sql = `${quoteIdent2(column.identity.name)} ${definition.dataType}${collateSql(definition.collation)}`;
+  if (definition.identity !== undefined) {
+    sql += definition.identity.always ? " generated always as identity" : " generated by default as identity";
+  } else if (definition.generated !== undefined) {
+    sql += ` generated always as (${definition.generated.expression}) stored`;
+  }
+  if (!definition.nullable)
+    sql += " not null";
+  if (definition.defaultExpression !== undefined)
+    sql += ` default ${definition.defaultExpression}`;
+  return sql;
+}
+function createIndexSql(object, schema) {
+  const unique = object.definition.unique ? "unique " : "";
+  const where = object.definition.predicate === undefined ? "" : ` where ${object.definition.predicate}`;
+  const expression = object.definition.expression;
+  const name = quoteIdent2(object.identity.name);
+  const on = qualify(schema, object.identity.parent.name);
+  if (expression !== undefined && expression.startsWith("using ")) {
+    return `create ${unique}index ${name} on ${on} ${expression}${where}`;
+  }
+  const target = expression !== undefined ? `(${expression})` : object.definition.columns.map((column) => quoteIdent2(column)).join(", ");
+  return `create ${unique}index ${name} on ${on} (${target})${where}`;
+}
+function createExtensionSql(object) {
+  const version = object.definition.version;
+  const pinned = version !== undefined && /^\d+(?:\.\d+)*$/.test(version) ? ` version ${quoteLiteral(version)}` : "";
+  return `create extension ${quoteIdent2(object.identity.name)} schema ${quoteIdent2(object.definition.schema)}${pinned}`;
+}
+function createSequenceSql(object, schema) {
+  const definition = object.definition;
+  const cycle = definition.cycle ? " cycle" : "";
+  return `create sequence ${qualify(schema, object.identity.name)} as ${definition.dataType} start ${definition.start} increment ${definition.increment}${cycle}`;
+}
+function referenceSchema(object, schema) {
+  const references = object.definition.references;
+  if (references === undefined)
+    return schema;
+  const target = references.parent.namespace;
+  const parent = object.identity.parent.namespace;
+  if (target.form === "static" && parent.form === "static" && target.name !== parent.name) {
+    return target.name;
+  }
+  return schema;
+}
+function constraintBody(object, schema) {
+  const definition = object.definition;
+  const columns = definition.columns.map((name) => quoteIdent2(name)).join(", ");
+  switch (definition.constraintKind) {
+    case "primaryKey":
+      return `primary key (${columns})`;
+    case "unique": {
+      const nulls = definition.nullsNotDistinct ? " nulls not distinct" : "";
+      return `unique${nulls} (${columns})${deferClause(definition)}`;
+    }
+    case "check":
+      return `check (${definition.expression ?? "true"})${deferClause(definition)}`;
+    case "foreignKey": {
+      const references = definition.references;
+      const target = references === undefined ? "" : ` references ${qualify(referenceSchema(object, schema), references.parent.name)} (${references.columns.map((name) => quoteIdent2(name)).join(", ")})`;
+      const onDelete = references?.onDelete === undefined ? "" : ` on delete ${references.onDelete}`;
+      const onUpdate = references?.onUpdate === undefined ? "" : ` on update ${references.onUpdate}`;
+      return `foreign key (${columns})${target}${onDelete}${onUpdate}${deferClause(definition)}`;
+    }
+    default:
+      return definition.constraintKind;
+  }
+}
+function deferClause(definition) {
+  if (!definition.deferrable)
+    return "";
+  return ` deferrable initially ${definition.initially}`;
+}
+function qualify(schema, name) {
+  return `${quoteIdent2(schema)}.${quoteIdent2(name)}`;
+}
+
 // src/dialects/pg/floor.ts
 var POSTGRES_FLOOR = 15;
 var UUIDV7_POSTGRES = 18;
@@ -2363,24 +2708,6 @@ function rejected(message) {
   throw new OkmError(CODEC_VALUE_CODE, message);
 }
 
-// src/dialects/pg/quote.ts
-function quoteLiteral(value) {
-  return `'${value.replaceAll("'", "''")}'`;
-}
-function arrayElement(encoded, raw) {
-  if (raw && (encoded === "true" || encoded === "false" || isBareNumber(encoded))) {
-    return encoded;
-  }
-  return `"${encoded.replaceAll("\\", "\\\\").replaceAll('"', "\\\"")}"`;
-}
-function isBareNumber(encoded) {
-  let pattern = bareNumber;
-  pattern ??= /^-?(?:0|[1-9]\d*)(?:\.\d+)?(?:[eE][+-]?\d+)?$/;
-  bareNumber = pattern;
-  return pattern.test(encoded);
-}
-var bareNumber;
-
 // src/dialects/pg/array-literal.ts
 function writeArray(value, dims, encode, raw) {
   return writeLevel(value, dims, encode, raw);
@@ -3786,4 +4113,4 @@ function postgresUrl(port) {
   return `postgres://${USER}:${PASSWORD}@${HOST}:${port}/${DATABASE}`;
 }
 
-export { OkmError, safe, catalogError, throwNamed, DriverError2, cancelled2, timedOut2, outcomeUnknown2, acquireTimeout2, errorField2, mapDriverError2, isConnectionSqlstate, isConnectionErrno, isConnectionFailure, isConnectionLost, mapPostgresError2, assertIdentifier, fitIdentifier, assertStoredText, staticNamespace, identityKey, identityLabel, sameNamespace, CATALOG_VERSION, table, column, index, constraint, sequence, compareText, enumType, domainType, isDomain, sameEnumLabels, indexObjects, orderIndexed, creationOrder2, catalogHash2, loadTrustedCatalog2, catalogFileText2, quoteLiteral, clientGenerator, readClientGenerator, definition, unavailable, rejected, writeArray, ColumnBuilder, required, openColumn, formatType, retarget, POSTGRES_FLOOR, UUIDV7_POSTGRES, isPostgresMajor, parsePostgresFloor, formatPostgresFloor, minPostgresDefinition, uuidv7NeedsPostgres, serverNeedsPostgres, isOperator, operatorName, operatorValue, tag, json, jsonb, encodeJson, safetyInstalled, runSafety, withRowFilters, archiveRules, readOptionNames, installOperatorSql, readNeedsOperatorSql, orderHasRelevance, emitRelationFrom, needsOperatorSql, bindCall, compileCall, decodeResult, logicalIntent, appliedRules, emitJoin, emitWhere, emitOrder, emitPrimaryOrder, refuseHidden, emitLimit, selectedColumns, parseOrder, rejectKeys, readLimit, takeObject, projectExpr, jsonExpr, decodeRow, cell, indexes, quote, list, isRecord, orFail, registerFailFix, fail2, primaryUrl };
+export { OkmError, safe, catalogError, throwNamed, DriverError2, cancelled2, timedOut2, outcomeUnknown2, acquireTimeout2, errorField2, mapDriverError2, isConnectionSqlstate, isConnectionErrno, isConnectionFailure, isConnectionLost, mapPostgresError2, assertIdentifier, fitIdentifier, assertStoredText, staticNamespace, identityKey, identityLabel, sameNamespace, CATALOG_VERSION, table, column, index, constraint, sequence, compareText, enumType, domainType, sameEnumLabels, indexObjects, orderIndexed, creationOrder2, catalogHash2, loadTrustedCatalog2, catalogFileText2, quoteLiteral, quoteIdent2, renderCatalog2, clientGenerator, readClientGenerator, definition, unavailable, rejected, writeArray, ColumnBuilder, required, openColumn, formatType, retarget, POSTGRES_FLOOR, UUIDV7_POSTGRES, isPostgresMajor, parsePostgresFloor, formatPostgresFloor, minPostgresDefinition, uuidv7NeedsPostgres, serverNeedsPostgres, isOperator, operatorName, operatorValue, tag, json, jsonb, encodeJson, safetyInstalled, runSafety, withRowFilters, archiveRules, readOptionNames, installOperatorSql, readNeedsOperatorSql, orderHasRelevance, emitRelationFrom, needsOperatorSql, bindCall, compileCall, decodeResult, logicalIntent, appliedRules, emitJoin, emitWhere, emitOrder, emitPrimaryOrder, refuseHidden, emitLimit, selectedColumns, parseOrder, rejectKeys, readLimit, takeObject, projectExpr, jsonExpr, decodeRow, cell, indexes, quote, list, isRecord, orFail, registerFailFix, fail2, primaryUrl };

package/dist/tooling/shared/{vs0t6qt8.js → j664qjrt.js}

@@ -3,12 +3,12 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./mtrqn2hn.js";
+} from "./jr2nmr81.js";
 import {
   OkmError,
   throwNamed,
   fail2
-} from "./f9mphxej.js";
+} from "./hfq3n3bd.js";
 
 // src/runtime/lock.ts
 var LOCKS = ["update", "share"];

package/dist/tooling/shared/{733a1tq3.js → jpgmjsx3.js}

@@ -15,9 +15,9 @@ import {
   expectOf2,
   allowSet2,
   noteGuarded2
-} from "./spk1jg3r.js";
-import"./3tq8pnb8.js";
-import"./cmptmb4f.js";
+} from "./ezqn88nj.js";
+import"./w5d89rb4.js";
+import"./35zemrmf.js";
 export {
   Sql2 as Sql,
   WRITE_PARAM_BUDGET2 as WRITE_PARAM_BUDGET,

package/dist/tooling/shared/{mtrqn2hn.js → jr2nmr81.js}

@@ -11,7 +11,7 @@ import {
   logicalIntent,
   appliedRules,
   rejectKeys
-} from "./f9mphxej.js";
+} from "./hfq3n3bd.js";
 
 // src/runtime/client.ts
 var PLAN_LIMIT = 64;
@@ -84,7 +84,7 @@ function openClient(session) {
     },
     close,
     connected: session.connected,
-    tx: (...args) => import("./rq5kk8j6.js").then((mod) => mod.tx(session, args)),
+    tx: (...args) => import("./stebqyyd.js").then((mod) => mod.tx(session, args)),
     batch: (ops, options) => batchHandle(session, ops, options),
     ...session.tx?.extras
   };
@@ -119,7 +119,7 @@ function tableApi(session, table, view, uses) {
   const api = {
     find(options = {}) {
       if ("lock" in options) {
-        return lazyRead(session, () => import("./vs0t6qt8.js"), table, options, base, view);
+        return lazyRead(session, () => import("./j664qjrt.js"), table, options, base, view);
       }
       return start(session, "find", table, options, base, view);
     },
@@ -133,10 +133,10 @@ function tableApi(session, table, view, uses) {
       return start(session, "exists", table, options, base, view);
     },
     page(options) {
-      return lazyRead(session, () => import("./j9t5s12a.js"), table, options, base, view);
+      return lazyRead(session, () => import("./w17sj05d.js"), table, options, base, view);
     },
     aggregate(options = {}) {
-      return lazyRead(session, () => import("./bz2dqhab.js"), table, options, base, view);
+      return lazyRead(session, () => import("./7aews1zg.js"), table, options, base, view);
     },
     insert(data, options = {}) {
       return writeHandle(session, "insert", table, data, options, mods);
@@ -149,9 +149,9 @@ function tableApi(session, table, view, uses) {
     }
   };
   for (const walk of ["descendants", "ancestors"]) {
-    api[walk] = (id, options) => lazyRead(session, () => import("./dw08f3m8.js"), table, { id, walk, options }, base, view);
+    api[walk] = (id, options) => lazyRead(session, () => import("./m4hhb8aa.js"), table, { id, walk, options }, base, view);
   }
-  api.sync = (id, relation, ids, options) => lazyRead(session, () => import("./z8d7ptht.js"), table, { id, relation, ids, options }, base, view, true);
+  api.sync = (id, relation, ids, options) => lazyRead(session, () => import("./0r05zhyq.js"), table, { id, relation, ids, options }, base, view, true);
   const hooks = session.schema.hooks;
   if (hooks !== undefined) {
     for (const hook of hooks) {
@@ -171,13 +171,13 @@ function tableApi(session, table, view, uses) {
   return api;
 }
 function batchHandle(session, ops, options, replica) {
-  return queryHandle(() => import("./vx86qjv8.js").then((mod) => mod.batch(session, ops, options, replica)), {
+  return queryHandle(() => import("./shjs0379.js").then((mod) => mod.batch(session, ops, options, replica)), {
     replica: () => batchHandle(session, ops, options, true)
   });
 }
 var writers;
 function loadWrite() {
-  writers ??= import("./733a1tq3.js");
+  writers ??= import("./jpgmjsx3.js");
   return writers;
 }
 function queryHandle(run, extra) {
@@ -287,7 +287,7 @@ function lazyRead(session, load, table, options, mods, view, sync) {
   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("./yfr8hzhm.js")).decodeIncluded(plan, rows, table);
+  return plan.outputs.includes.length === 0 ? decodeResult(plan, rows, table) : (await import("./ytk1tjs0.js")).decodeIncluded(plan, rows, table);
 }
 function readHandle(session, table, call, mods, decode, extra) {
   let prepared;
@@ -297,17 +297,17 @@ function readHandle(session, table, call, mods, decode, extra) {
     if (prepared !== undefined)
       return prepared;
     if (mods.uses !== undefined) {
-      call = (await import("./ma2340rx.js")).refine(session.schema, origin, mods.uses);
+      call = (await import("./5bmksndh.js")).refine(session.schema, origin, mods.uses);
     }
     if (searched) {
-      call = (await import("./smn6kz1p.js")).applyTextSearch(session.schema, call);
+      call = (await import("./wbwq1jsa.js")).applyTextSearch(session.schema, call);
     }
     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("./pqy21k24.js")).attach(session.schema, call);
+      call = (await import("./c0xevn1h.js")).attach(session.schema, call);
     }
     const bound = bindCall(session.schema, call, hooks);
     let plan = session.cache.get(bound.key);
@@ -337,7 +337,7 @@ function readHandle(session, table, call, mods, decode, extra) {
       const mapped = await mapError(session, error);
       if (session.schema.model[table]?.conceal !== true)
         throw logged(session, mapped);
-      const { scrubCall } = await import("./72fyg4zv.js");
+      const { scrubCall } = await import("./tpssp7ac.js");
       throw logged(session, scrubCall(mapped, session.schema, call));
     }
   };
@@ -370,7 +370,7 @@ function readHandle(session, table, call, mods, decode, extra) {
 }
 function streamLazy(session, call, mods, view, batch) {
   return async function* () {
-    const { streamRows } = await import("./ddjtfgnx.js");
+    const { streamRows } = await import("./yhp829bx.js");
     yield* streamRows(session, call, mods, view, batch, (error) => logged(session, error));
   }();
 }
@@ -403,22 +403,14 @@ function readCall(op, table, options, all, scope, model, schema, view) {
   };
 }
 async function checkServer(pool, schema, http, requireMeta, options, source) {
-  const server = await import("./pw8fgahx.js");
-  let rows;
-  try {
-    const result = await pool.execute(server.versionQuery, undefined, options);
-    rows = result.rows;
-  } catch (error) {
-    const { mapPostgresError } = await import("./ep8zh3bk.js");
-    throw mapPostgresError(error, mapOptions(http, false, schema));
-  }
-  await server.acceptServer(pool, schema, rows, http, requireMeta, options, source);
+  const { acceptServer } = await import("./76pv6qff.js");
+  await acceptServer(pool, schema, http, requireMeta, options, source);
 }
 async function mapError(session, error) {
   if (error instanceof OkmError) {
     return session.http === undefined ? error : new OkmError(error.code, error.message, { ...errorFields(error), http: session.http });
   }
-  const { mapPostgresError } = await import("./ep8zh3bk.js");
+  const { mapPostgresError } = await import("./yfedr1zb.js");
   return mapPostgresError(error, mapOptions(session.http, session.includeValues, session.schema));
 }
 function errorFields(error) {
@@ -432,7 +424,7 @@ function errorFields(error) {
 var includeHooks;
 var operatorSql;
 function loadOperatorSql() {
-  operatorSql ??= import("./9kazs5p6.js").then(() => {
+  operatorSql ??= import("./7b3xp9gc.js").then(() => {
     return;
   });
   return operatorSql;
@@ -443,7 +435,7 @@ function selectHasWindow(select) {
 function hooksFor(call) {
   if (call.include === undefined)
     return Promise.resolve(undefined);
-  includeHooks ??= import("./yfr8hzhm.js").then((mod) => mod.includeHooks);
+  includeHooks ??= import("./ytk1tjs0.js").then((mod) => mod.includeHooks);
   return includeHooks;
 }
 function bindNow(schema, call) {
@@ -454,7 +446,7 @@ function bindNow(schema, call) {
 function finish(session, view, call) {
   if (session.schema.model[call.table]?.conceal !== true)
     return view;
-  return import("./72fyg4zv.js").then((mod) => mod.redactView(session.schema, view, call));
+  return import("./tpssp7ac.js").then((mod) => mod.redactView(session.schema, view, call));
 }
 function inspection(plan, params, call, source) {
   return {
@@ -502,4 +494,4 @@ function logged(session, error) {
   return error;
 }
 
-export { createClient, openClient, queryHandle, decodeRows, readHandle, readCall, withHttp, attachHttp, settleCall };
+export { createClient, openClient, queryHandle, decodeRows, readHandle, readCall, withHttp, attachHttp, mapOptions, settleCall };

package/dist/{shared/mtw6jz76.js → tooling/shared/jsjjz875.js}

@@ -4,7 +4,7 @@ import {
   nextTransactionDepth,
   EMPTY_NOTICES,
   resultFrom
-} from "./ae4j5f42.js";
+} from "./5x3pf400.js";
 
 // src/adapters/pg/session.ts
 function noticeBuffer() {

package/dist/tooling/shared/{2wtvc7rw.js → kbqnrs1x.js}

@@ -1,11 +1,11 @@
 import {
   createClient
-} from "./mtrqn2hn.js";
+} from "./jr2nmr81.js";
 import {
   OkmError,
   isConnectionSqlstate,
   isConnectionErrno
-} from "./f9mphxej.js";
+} from "./hfq3n3bd.js";
 
 // src/runtime/topology.ts
 var CIRCUIT_AT = 2;

package/dist/tooling/shared/{gfvtj6d0.js → kz715295.js}

@@ -1,24 +1,24 @@
 import {
   DriverError2,
   isConnectionLost
-} from "./f9mphxej.js";
+} from "./hfq3n3bd.js";
 import {
   connectClient3,
   send4
-} from "./y5656f0e.js";
+} from "./am04v8na.js";
 import {
   resetSession2
-} from "./4d2w25vw.js";
+} from "./7pxncnzs.js";
 import {
   WireSession
-} from "./yw30vnq2.js";
+} from "./jsjjz875.js";
 import {
   noTimeout
-} from "./rs1jb051.js";
+} from "./3yn79q5m.js";
 import {
   rejectClosed,
   runCall
-} from "./xhrnjch9.js";
+} from "./5x3pf400.js";
 
 // src/adapters/pg/neon-extra.ts
 async function checkout(held) {
@@ -67,7 +67,7 @@ async function checkout(held) {
       if (refused !== undefined)
         return refused;
       return guard(() => runCall(isClosed(), options, async (watch) => {
-        const { runAtomicBatch } = await import("./3rrw5w8f.js");
+        const { runAtomicBatch } = await import("./gqwevek4.js");
         return runAtomicBatch(session, statements, watch);
       }));
     },

package/dist/tooling/shared/{a7q7t4n3.js → m3xt8b1h.js}

@@ -4,12 +4,12 @@ import {
   send2,
   reserve2,
   park2
-} from "./xjs6zqtc.js";
+} from "./rcywj2w8.js";
 import {
   BUNSQL_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "./xhrnjch9.js";
+} from "./5x3pf400.js";
 export {
   BUNSQL_CAPABILITIES as capabilities,
   hasCapability2 as hasCapability,