okmodel 0.8.0 → 0.9.1

package/dist/tooling/shared/{7ae7rjmn.js → 0v9ptnxp.js}

@@ -1,20 +1,20 @@
 import {
-  open5,
-  connectClient3,
-  send4
-} from "./y5656f0e.js";
+  open2,
+  connectClient2,
+  send2
+} from "./4ec0nxvw.js";
 import {
   NEON_WEBSOCKET_CAPABILITIES,
   NEON_HTTP_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "./xhrnjch9.js";
+} from "./ry2f3w8p.js";
 export {
   NEON_WEBSOCKET_CAPABILITIES as capabilities,
-  connectClient3 as connectClient,
+  connectClient2 as connectClient,
   hasCapability2 as hasCapability,
   NEON_HTTP_CAPABILITIES as httpCapabilities,
-  open5 as open,
+  open2 as open,
   readCapability2 as readCapability,
-  send4 as send
+  send2 as send
 };

package/dist/tooling/shared/{fb9k2qwd.js → 0wtzps9p.js}

@@ -1,10 +1,14 @@
 import {
   OkmError,
   catalogFileText2
-} from "./f9mphxej.js";
+} from "./2jdn09e2.js";
+import {
+  artifactDir,
+  readText
+} from "./8g0m0rvd.js";
 
 // src/runtime/drift.ts
-async function assertCompatible(pool, schema, recordedHash, source, options) {
+async function assertCompatible(pool, schema, recordedHash, source, options, namespace = "public") {
   const code = await codeHash(schema, source);
   if (code.hash === recordedHash)
     return;
@@ -12,7 +16,7 @@ async function assertCompatible(pool, schema, recordedHash, source, options) {
   if (code.artifact !== undefined) {
     const artifact = code.artifact;
     await loadOnce(`text\x00${artifact.hash}`, async () => {
-      const { loadTrustedCatalog } = await import("./5bvw2nev.js");
+      const { loadTrustedCatalog } = await import("./2v4nwnkb.js");
       loadTrustedCatalog(artifact.text, artifact.hash);
     });
   } else if (code.fromFile) {
@@ -26,12 +30,12 @@ async function assertCompatible(pool, schema, recordedHash, source, options) {
           }
         });
       }
-      const { loadTrustedCatalog } = await import("./5bvw2nev.js");
+      const { loadTrustedCatalog } = await import("./2v4nwnkb.js");
       loadTrustedCatalog(text, code.hash);
     });
   }
-  const { assertDrift } = await import("./rf83gr2d.js");
-  await assertDrift(pool, code.hash, recordedHash, options);
+  const { assertDrift } = await import("./vg68k11z.js");
+  await assertDrift(pool, code.hash, recordedHash, options, namespace);
 }
 async function codeHash(schema, source) {
   if (source.catalog !== undefined) {
@@ -40,7 +44,7 @@ async function codeHash(schema, source) {
   const listed = await readHashFile(source.catalogDir);
   if (listed !== undefined)
     return { hash: listed, fromFile: true };
-  const { catalogHash } = await import("./5bvw2nev.js");
+  const { catalogHash } = await import("./2v4nwnkb.js");
   return { hash: catalogHash(schemaCatalog(schema)), fromFile: false };
 }
 function schemaCatalog(schema) {
@@ -61,29 +65,6 @@ async function readHashFile(catalogDir) {
   const hash = catalogFileText2(text, "catalog.hash").trim();
   return hash.length === 0 ? undefined : hash;
 }
-function artifactDir(catalogDir) {
-  if (catalogDir !== undefined)
-    return catalogDir.replace(/[/\\]+$/, "");
-  const cwd = globalThis.process?.cwd?.() ?? ".";
-  return `${cwd}/.okm`;
-}
-async function readText(path) {
-  const bun = globalThis.Bun;
-  if (bun !== undefined) {
-    const file = bun.file(path);
-    if (!await file.exists())
-      return;
-    return file.text();
-  }
-  const loader = globalThis.process?.getBuiltinModule;
-  if (loader === undefined)
-    return;
-  try {
-    return await loader("node:fs/promises").readFile(path, "utf8");
-  } catch {
-    return;
-  }
-}
 export {
   assertCompatible
 };

package/dist/tooling/shared/{a6pp9d12.js → 0yhf1db4.js}

@@ -1,22 +1,22 @@
 import {
   markClientPool2,
-  open2
-} from "./xjs6zqtc.js";
+  open3
+} from "./3f6etb9z.js";
 import {
   createClient
-} from "./mtrqn2hn.js";
+} from "./gjj71hfh.js";
 
 // src/runtime/pg/bun.ts
 function connect(target, options) {
   if (typeof target === "object" && !isPool(target)) {
-    return import("./2wtvc7rw.js").then((mod) => mod.default(target, options, (config) => {
-      const pool = open2(config);
+    return import("./bt3tjemb.js").then((mod) => mod.default(target, options, (config) => {
+      const pool = open3(config);
       markClientPool2(pool);
       return pool;
     }));
   }
   const owned = !isPool(target);
-  const pool = isPool(target) ? target : open2({
+  const pool = isPool(target) ? target : open3({
     url: target,
     ...options.max !== undefined ? { max: options.max } : {},
     ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {},

package/dist/tooling/shared/{dy672fz6.js → 19msgrsc.js}

@@ -1,12 +1,12 @@
 import {
   open6,
   seal2
-} from "./djydjpqt.js";
+} from "./xn6p01fh.js";
 import {
   PGLITE_CAPABILITIES,
   readCapability2,
   hasCapability2
-} from "./xhrnjch9.js";
+} from "./ry2f3w8p.js";
 export {
   PGLITE_CAPABILITIES as capabilities,
   hasCapability2 as hasCapability,

package/dist/{shared/q0cqt2sp.js → tooling/shared/1fwfm5m3.js}

@@ -1,6 +1,6 @@
 import {
   rejectUncancellable
-} from "./ae4j5f42.js";
+} from "./ry2f3w8p.js";
 
 // src/adapters/pg/no-inflight-timeout.ts
 function noTimeout(options) {

package/dist/tooling/shared/{f9mphxej.js → 2jdn09e2.js}

@@ -531,7 +531,7 @@ function mapPostgresError2(error, options) {
     return error;
   if (!isDriverError2(error))
     return OkmError.from(error);
-  const search = searchInputError(error);
+  const search = searchInputError(error, options);
   if (search !== undefined)
     return search;
   const kind = kindOf(error);
@@ -540,6 +540,7 @@ function mapPostgresError2(error, options) {
   const fieldReason = hint?.reason ?? (kind === "not_null" ? "not_null" : reasonOf(kind, error.table, error.constraint, columns, options?.schema));
   const values = options?.includeValues === true ? valuesOf(error.detail, columns) : undefined;
   const code = kind === "outcome_unknown" ? "OKM1401" : kind;
+  const redactCause = options?.includeValues !== true && needsSafeCause(options?.schema, error.table, columns);
   return new OkmError(code, summaryOf(kind, error, columns, fieldReason), {
     kind,
     fieldReason,
@@ -549,11 +550,59 @@ function mapPostgresError2(error, options) {
     ...error.constraint !== undefined ? { constraint: error.constraint } : {},
     ...error.sqlstate !== undefined ? { sqlstate: error.sqlstate } : {},
     batchIndex: error.batchIndex,
-    cause: error.cause ?? error,
+    cause: redactCause ? safeCause(error) : error.cause ?? error,
     ...options?.includeValues === true && values !== undefined ? { includeValues: true, values } : {},
     ...options?.http !== undefined ? { http: options.http } : {}
   });
 }
+function needsSafeCause(schema, table, columns) {
+  if (schema === undefined)
+    return false;
+  const model = modelForTable(schema, table);
+  if (model !== undefined && model.columns.some((column) => column.sensitive === true)) {
+    return true;
+  }
+  if (columns.length === 0)
+    return false;
+  for (const item of Object.values(schema.model)) {
+    for (const column of item.columns) {
+      if (column.sensitive !== true)
+        continue;
+      for (const name of columns) {
+        if (column.sql === name || column.field === name)
+          return true;
+      }
+    }
+  }
+  return false;
+}
+function safeCause(error) {
+  const out = { name: "DriverError" };
+  if (error.sqlstate !== undefined)
+    out.sqlstate = error.sqlstate;
+  if (error.constraint !== undefined)
+    out.constraint = error.constraint;
+  if (error.table !== undefined)
+    out.table = error.table;
+  if (error.column !== undefined)
+    out.column = error.column;
+  const nested = error.cause;
+  if (typeof nested === "object" && nested !== null) {
+    const code = Reflect.get(nested, "code");
+    if (typeof code === "string" && code.length > 0 && code.length <= 64)
+      out.code = code;
+  }
+  return out;
+}
+function modelForTable(schema, table) {
+  if (table === undefined)
+    return;
+  for (const item of Object.values(schema.model)) {
+    if (item.sql === table)
+      return item;
+  }
+  return schema.model[table];
+}
 var TLS_CODE = /^(ERR_TLS_|ERR_POSTGRES_TLS_|SELF_SIGNED_CERT_|DEPTH_ZERO_SELF_SIGNED_CERT$|UNABLE_TO_VERIFY_LEAF_SIGNATURE$)/;
 function isTlsFailure(error) {
   const cause = error.cause;
@@ -572,14 +621,15 @@ function searchQuery(error) {
   const query = Reflect.get(cause, "query");
   return typeof query === "string" && query.includes("to_tsquery");
 }
-function searchInputError(error) {
+function searchInputError(error, options) {
   const sqlstate = error.sqlstate;
   const message = error.message;
+  const cause = options?.includeValues !== true && needsSafeCause(options?.schema, error.table, columnsOf(error)) ? safeCause(error) : error.cause ?? error;
   if (sqlstate === "42601" && (message.includes("tsquery") || searchQuery(error))) {
     return new OkmError("OKM1120", `Search input is not valid. ${stripRowValues(message)}`, {
       kind: "invalid",
       sqlstate,
-      cause: error.cause ?? error,
+      cause,
       fix: { summary: "Fix the advanced search text, or use natural, all-words, or phrase." }
     });
   }
@@ -587,7 +637,7 @@ function searchInputError(error) {
     return new OkmError("OKM1122", stripRowValues(message), {
       kind: "invalid",
       sqlstate,
-      cause: error.cause ?? error,
+      cause,
       fix: {
         summary: "Use a text search configuration that exists, such as english, or omit language."
       }
@@ -2285,6 +2335,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 +2758,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 +4163,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/{jne7b93p.js → 2qrte2ct.js}

@@ -1,17 +1,17 @@
 import {
-  open4
-} from "./417zdsk7.js";
+  open5
+} from "./ppybjw50.js";
 import {
   createClient
-} from "./mtrqn2hn.js";
+} from "./gjj71hfh.js";
 
 // src/runtime/pg/pg.ts
 function connect(target, options) {
   if (typeof target === "object" && !isPool(target)) {
-    return import("./2wtvc7rw.js").then((mod) => mod.default(target, options, open4));
+    return import("./bt3tjemb.js").then((mod) => mod.default(target, options, open5));
   }
   const owned = !isPool(target);
-  const pool = isPool(target) ? target : open4({
+  const pool = isPool(target) ? target : open5({
     url: target,
     ...options.max !== undefined ? { max: options.max } : {},
     ...options.timeouts !== undefined ? { timeouts: options.timeouts } : {},