okmodel 0.2.1 → 0.4.0

package/dist/shared/{7mht49yd.js → 3p4b1fg0.js}

@@ -1,29 +1,31 @@
-import {
-  encodeText,
-  decodeText
-} from "./sacqha1y.js";
 import {
   catalog,
   enumType,
   sameEnumLabels
-} from "./qxa0yb9j.js";
+} from "./g7ez901n.js";
 import {
   snakeCase,
   emittedTypeName,
   rejectLater
-} from "./x9v1qgeb.js";
+} from "./jsd07prz.js";
 import {
   withLocation
 } from "./k7dwkhvq.js";
+import {
+  encodeText,
+  decodeText
+} from "./4m9fn52z.js";
 import {
   ColumnBuilder2,
   formatType
-} from "./dd4f8mnx.js";
+} from "./c9z5g0fm.js";
 import {
   definition,
-  unavailable,
+  unavailable
+} from "./tmbdywx0.js";
+import {
   quoteLiteral
-} from "./xatfg0gn.js";
+} from "./94ez8kzh.js";
 import {
   staticNamespace2,
   table3,
@@ -221,19 +223,18 @@ var SCHEMA_KNOWN = new Set([
   "casing",
   "codecs",
   "defaults",
+  "extensions",
+  "functions",
   "requires",
   "tables",
   "tenancy",
   "traits",
+  "triggers",
   "types",
-  "validation"
+  "validation",
+  "views"
 ]);
-var SCHEMA_LATER = {
-  extensions: "0.3",
-  functions: "0.3",
-  triggers: "0.3",
-  views: "0.3"
-};
+var SCHEMA_LATER = {};
 var BIGINT_CODECS = new Set(["string", "number", "bigint"]);
 var NUMERIC_CODECS = new Set(["string", "number"]);
 function stage(jobs, build) {
@@ -250,7 +251,7 @@ function schema2(config) {
   }
   const casing = readCasing(config.casing);
   const tables = rewritePass(config.tables, tenancy, schemaTraits, casing);
-  const hooks = collectHooks(tenancy, schemaTraits, config.tables);
+  const hooks = collectHooks(tenancy, schemaTraits, config.tables, config.views);
   const types = readTypes(config.types);
   const codecs = readCodecs(config.codecs);
   const requires = readRequires(config.requires);
@@ -281,6 +282,7 @@ function schema2(config) {
   for (const item of prepared) {
     model[item.tsName] = tableModel(item, edges, byName, accepted);
   }
+  bindViews(config.views, model, tenancy, tables, casing);
   let document;
   return {
     get catalog() {
@@ -296,6 +298,14 @@ function schema2(config) {
             provenance: note.provenance
           }));
         }
+        contributeListed(config.extensions, objects);
+        contributeListed(config.functions, objects);
+        contributeListed(schemaTraits, objects);
+        for (const item of config.tables) {
+          contributeListed(item.options?.traits, objects);
+        }
+        contributeListed(config.triggers, objects);
+        contributeListed(config.views, objects);
         document = catalog(objects);
       }
       return document;
@@ -379,7 +389,7 @@ var registeredHooks = [];
 function addSchemaHook(hook) {
   registeredHooks.push(hook);
 }
-function collectHooks(tenancy, schemaTraits, tables) {
+function collectHooks(tenancy, schemaTraits, tables, views) {
   const found = [];
   const seen = new Set;
   const add = (value) => {
@@ -391,6 +401,12 @@ function collectHooks(tenancy, schemaTraits, tables) {
     seen.add(value);
     found.push(hook.bind(value));
   };
+  if (Array.isArray(views)) {
+    for (const item of views) {
+      if (typeof item === "object" && item !== null)
+        add(item);
+    }
+  }
   if (tenancy !== undefined)
     add(tenancy);
   if (schemaTraits !== undefined) {
@@ -410,6 +426,17 @@ function collectHooks(tenancy, schemaTraits, tables) {
     found.push(hook);
   return found.length === 0 ? undefined : found;
 }
+function bindViews(views, model, tenancy, tables, casing) {
+  if (!Array.isArray(views))
+    return;
+  const scoped = new Set;
+  for (const item of views) {
+    if (typeof item !== "object" || item === null)
+      continue;
+    const install = item.install;
+    install?.call(item, model, tenancy, tables, casing, scoped);
+  }
+}
 function archiveModel(item) {
   const archive = item.archiveModel;
   return archive === undefined ? undefined : { archive };
@@ -423,6 +450,16 @@ function bareTables(tables) {
   }
   return tables;
 }
+function contributeListed(value, objects) {
+  if (!Array.isArray(value))
+    return;
+  for (const item of value) {
+    const produced = item.contribute(value, objects);
+    if (Array.isArray(produced))
+      for (const object of produced)
+        objects.push(object);
+  }
+}
 function openSchemaTraits(value) {
   if (value === undefined)
     return;
@@ -650,6 +687,7 @@ function pushCompiled(objects, column, input) {
     objects.push(compiled.check);
   if (compiled.unique !== undefined)
     objects.push(compiled.unique);
+  column.state.domain?.emit?.(input.parent.namespace, input.provenance, objects);
 }
 function compileUniques(tableName, options, parent, provenance, byField, jobs) {
   const unique = options?.unique;
@@ -695,6 +733,7 @@ function compileIndexes(tableName, options, handles, parent, provenance, jobs) {
       unique: built.isUnique === true,
       nameKey: built.columns.join("_"),
       ...built.predicate !== undefined ? { predicate: built.predicate } : {},
+      ...built.expression !== undefined ? { expression: built.expression } : {},
       provenance
     }));
   }

package/dist/shared/41kv2xdm.js

@@ -0,0 +1,318 @@
+import {
+  creationOrder2
+} from "./8jb4ymh2.js";
+import {
+  isDomain
+} from "./g7ez901n.js";
+import {
+  quoteLiteral
+} from "./94ez8kzh.js";
+import {
+  identityKey2
+} from "./t4tbsy9h.js";
+import {
+  fitIdentifier2
+} from "./nfzc5z0w.js";
+
+// src/dialects/pg/ddl.ts
+function quoteIdent(name) {
+  return `"${name.replaceAll('"', '""')}"`;
+}
+function renderCatalog(source, schema) {
+  const folded = foldedKeys(source);
+  const statements = [];
+  const ordered = creationOrder2(source);
+  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 ordered) {
+    if (object.kind === "type" || object.kind === "function" || object.kind === "trigger" || object.kind === "view" || object.kind === "materializedView" || ownedByView(object)) {
+      continue;
+    }
+    if (object.owner === "ignored")
+      continue;
+    const key = identityKey2(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 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 ownedByView(object) {
+  if (object.kind !== "index")
+    return false;
+  return object.dependencies.some((edge) => edge.target.kind === "view" || edge.target.kind === "materializedView");
+}
+function dropObjectSql(object, schema) {
+  if (object.owner === "ignored")
+    return;
+  switch (object.kind) {
+    case "table":
+      return `drop table ${qualify(schema, object.identity.name)}`;
+    case "column":
+      return `alter table ${qualify(schema, object.identity.parent.name)} drop column ${quoteIdent(object.identity.name)}`;
+    case "index":
+      return `drop index ${qualify(schema, object.identity.name)}`;
+    case "constraint":
+      return `alter table ${qualify(schema, object.identity.parent.name)} drop constraint ${quoteIdent(object.identity.name)}`;
+    case "sequence":
+      return `drop sequence ${qualify(schema, object.identity.name)}`;
+    case "type":
+      return `drop type ${qualify(schema, object.identity.name)}`;
+    case "extension":
+      return `drop extension ${quoteIdent(object.identity.name)}`;
+    case "function":
+      return `drop function ${qualify(schema, object.identity.name)}(${object.identity.argTypes.join(", ")})`;
+    case "trigger":
+      return `drop trigger ${quoteIdent(object.identity.name)} on ${qualify(schema, object.identity.parent.name)}`;
+    case "view":
+      return `drop view ${qualify(schema, object.identity.name)}`;
+    case "materializedView":
+      return `drop materialized view ${qualify(schema, object.identity.name)}`;
+    default:
+      return;
+  }
+}
+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 ${quoteIdent(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) => `${quoteIdent(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";
+  return `${verb} ${qualify(schema, object.identity.name)} as ${object.definition.query}`;
+}
+function materializedViewSql(object, schema) {
+  return `create materialized view ${qualify(schema, object.identity.name)} as ${object.definition.query} with no data`;
+}
+function refreshMaterializedViewSql(object, schema, populated = false) {
+  const concurrently = populated && object.definition.refresh === "concurrently" ? " concurrently" : "";
+  return `refresh materialized view${concurrently} ${qualify(schema, object.identity.name)}`;
+}
+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) => quoteIdent(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 ${quoteIdent(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 alterColumnSql(before, after, schema) {
+  const statements = [];
+  const table = qualify(schema, after.identity.parent.name);
+  const name = quoteIdent(after.identity.name);
+  const typeChanged = before.definition.dataType !== after.definition.dataType;
+  const collationChanged = before.definition.collation !== after.definition.collation;
+  if (typeChanged || collationChanged) {
+    const using = typeChanged ? ` using ${name}::${after.definition.dataType}` : "";
+    statements.push(`alter table ${table} alter column ${name} set data type ${after.definition.dataType}${collateSql(after.definition.collation)}${using}`);
+  }
+  if (before.definition.nullable !== after.definition.nullable) {
+    statements.push(`alter table ${table} alter column ${name} ${after.definition.nullable ? "drop not null" : "set not null"}`);
+  }
+  if (before.definition.defaultExpression !== after.definition.defaultExpression) {
+    statements.push(after.definition.defaultExpression === undefined ? `alter table ${table} alter column ${name} drop default` : `alter table ${table} alter column ${name} set default ${after.definition.defaultExpression}`);
+  }
+  return statements;
+}
+function identitySequence(sequence, source) {
+  const key = identityKey2(sequence.identity);
+  return source.objects.some((object) => {
+    if (object.kind !== "column" || object.definition.identity === undefined)
+      return false;
+    return object.dependencies.some((edge) => identityKey2(edge.target) === key);
+  });
+}
+function foldedKeys(source) {
+  const keys = new Set;
+  for (const object of source.objects) {
+    if (object.kind === "column")
+      keys.add(identityKey2(object.identity));
+    if (object.kind === "constraint" && object.definition.constraintKind === "primaryKey") {
+      keys.add(identityKey2(object.identity));
+    }
+    if (object.kind === "sequence" && identitySequence(object, source)) {
+      keys.add(identityKey2(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) => quoteIdent(name)).join(", ");
+    lines.push(`constraint ${quoteIdent(primary.identity.name)} primary key (${cols})`);
+  }
+  const partition = tableObject.definition.partition;
+  const tail = partition === undefined ? "" : ` partition by ${partition.method} (${partition.columns.map((name) => quoteIdent(name)).join(", ")})`;
+  return `create table ${qualify(schema, parent)} (
+  ${lines.join(`,
+  `)}
+)${tail}`;
+}
+function collateSql(collation) {
+  if (collation === undefined)
+    return "";
+  return ` collate ${quoteIdent(collation)}`;
+}
+function createTypeSql(object, schema) {
+  if (isDomain(object.definition)) {
+    const name = object.identity.name;
+    const constraint = quoteIdent(fitIdentifier2(`${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 = `${quoteIdent(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 = quoteIdent(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) => quoteIdent(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 ${quoteIdent(object.identity.name)} schema ${quoteIdent(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 constraintBody(object, schema) {
+  const definition = object.definition;
+  const columns = definition.columns.map((name) => quoteIdent(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(schema, references.parent.name)} (${references.columns.map((name) => quoteIdent(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 `${quoteIdent(schema)}.${quoteIdent(name)}`;
+}
+
+export { quoteIdent, renderCatalog, ownedByView, dropObjectSql, createObjectSql, functionSql, viewSql, refreshMaterializedViewSql, alterColumnSql, identitySequence, createTableSql, qualify };

package/dist/shared/{97g2jnrw.js → 4ef7mmqf.js}

@@ -2,17 +2,17 @@ import {
   send2,
   reserve,
   park
-} from "./ytg3xf9p.js";
+} from "./sf8m6tfy.js";
 import {
   isConnectionLost
 } from "./tbszx8mz.js";
 import {
   WireSession
-} from "./cstgkzdx.js";
+} from "./zvbjc949.js";
 import {
   rejectClosed,
   runCall
-} from "./9k6vetvf.js";
+} from "./rrstp3kb.js";
 
 // src/adapters/pg/bunsql-extra.ts
 async function checkout(held) {

package/dist/shared/{sacqha1y.js → 4m9fn52z.js}

@@ -1,10 +1,10 @@
 import {
   required
-} from "./dd4f8mnx.js";
+} from "./c9z5g0fm.js";
 import {
   definition,
   rejected
-} from "./xatfg0gn.js";
+} from "./tmbdywx0.js";
 
 // src/dialects/pg/text.ts
 function text2() {

package/dist/shared/5mtf6cj3.js

@@ -0,0 +1,94 @@
+import {
+  BEHIND_EXPAND,
+  BEHIND_CONTRACT,
+  AHEAD_CONTRACT
+} from "./9yn6a2vd.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/runtime/drift-detail.ts
+function driftVerdict(codeHash, recordedHash, migrations) {
+  const codeAt = indexOfHash(migrations, codeHash);
+  const recordedAt = indexOfHash(migrations, recordedHash);
+  if (codeAt >= 0 && recordedAt >= codeAt) {
+    for (let index = codeAt + 1;index <= recordedAt; index += 1) {
+      const migration = migrations[index];
+      if (migration !== undefined && migration.expand !== true) {
+        return { state: "ahead by contract", migrationId: migration.id };
+      }
+    }
+    return { state: "ok" };
+  }
+  if (codeAt >= 0 && recordedAt >= 0 && recordedAt < codeAt) {
+    const next = migrations[recordedAt + 1];
+    if (next !== undefined) {
+      return {
+        state: next.expand ? "behind by expand" : "behind by contract",
+        migrationId: next.id
+      };
+    }
+  }
+  if (recordedAt >= 0) {
+    const at = migrations[recordedAt];
+    if (at !== undefined)
+      return { state: "behind", migrationId: at.id };
+  }
+  const last = migrations.at(-1);
+  return { state: "behind", migrationId: last?.id ?? "" };
+}
+async function assertDrift(pool, codeHash, recordedHash, options) {
+  let rows;
+  try {
+    const result = await pool.execute("select migration_id, class, catalog_hash from okm_history order by migration_id, step_index", undefined, options);
+    rows = result.rows;
+  } catch (error) {
+    throw gapError({ state: "behind", migrationId: "" }, error);
+  }
+  const verdict = driftVerdict(codeHash, recordedHash, groupMigrations(rows));
+  if (verdict.state === "ok")
+    return;
+  throw gapError(verdict);
+}
+function indexOfHash(migrations, hash) {
+  let found = -1;
+  for (let index = 0;index < migrations.length; index += 1) {
+    if (migrations[index]?.catalogHash === hash)
+      found = index;
+  }
+  return found;
+}
+function groupMigrations(rows) {
+  const grouped = [];
+  for (const row of rows) {
+    const id = row[0];
+    const stepClass = row[1];
+    const hash = row[2];
+    if (id == null || stepClass == null || hash == null)
+      continue;
+    const expand = stepClass === "expand";
+    const last = grouped.at(-1);
+    if (last !== undefined && last.id === id) {
+      grouped[grouped.length - 1] = {
+        id,
+        catalogHash: hash,
+        expand: last.expand && expand
+      };
+      continue;
+    }
+    grouped.push({ id, catalogHash: hash, expand });
+  }
+  return grouped;
+}
+function gapError(verdict, cause) {
+  const named = verdict.migrationId;
+  const phrase = verdict.state === "ahead by contract" ? `${AHEAD_CONTRACT} migration ${named}` : verdict.state === "behind by expand" ? `${BEHIND_EXPAND} migration ${named}` : verdict.state === "behind by contract" ? `${BEHIND_CONTRACT} migration ${named}` : named.length > 0 ? `behind the app at migration ${named}` : "behind the app";
+  const fix = named.length > 0 ? `Apply ${named}, or change the deploy order.` : "Apply migrations, or change the deploy order.";
+  return new OkmError2("OKM1520", `The database is ${phrase}.`, {
+    ...cause === undefined ? {} : { cause },
+    fix: { summary: fix }
+  });
+}
+export {
+  assertDrift
+};

package/dist/shared/{1dp5knt7.js → 5vdm4sgp.js}

@@ -1,6 +1,6 @@
 import {
   PgSession
-} from "./ecdzej21.js";
+} from "./wqem4jed.js";
 import {
   isConnectionLost
 } from "./tbszx8mz.js";
@@ -11,7 +11,7 @@ import {
   runCall,
   rowsFrom,
   resultFrom
-} from "./9k6vetvf.js";
+} from "./rrstp3kb.js";
 
 // src/adapters/pg/postgres-extra.ts
 var RESET_ALL = "RESET ALL";

package/dist/shared/{a1gdp7j9.js → 6693j9rs.js}

@@ -6,7 +6,7 @@ import {
   catalogHash2,
   loadTrustedCatalog2,
   parseCatalog2
-} from "./d2whjz4k.js";
+} from "./8jb4ymh2.js";
 export {
   catalogHash2 as catalogHash,
   creationOrder2 as creationOrder,

package/dist/shared/{38crxbgn.js → 6p5k20sm.js}

@@ -3,14 +3,14 @@ import {
   noticeBuffer,
   WireSession,
   cursorStream
-} from "./cstgkzdx.js";
+} from "./zvbjc949.js";
 import {
   NODE_POSTGRES_CAPABILITIES,
   driverErrors,
   rejectClosed,
   mapFailure,
   runCall
-} from "./9k6vetvf.js";
+} from "./rrstp3kb.js";
 
 // src/adapters/pg/nodepostgres.ts
 import net from "node:net";
@@ -53,7 +53,7 @@ function open4(config) {
     counters.busy = Math.max(0, counters.busy - 1);
   }, inflight);
   const held = { pool, acquireMs, counters, notices, named, isClosed };
-  const checkout = () => closed ? rejectClosed() : import("./qa5dsc7z.js").then((mod) => mod.checkout(held));
+  const checkout = () => closed ? rejectClosed() : import("./fb00y8fp.js").then((mod) => mod.checkout(held));
   return {
     capabilities: NODE_POSTGRES_CAPABILITIES,
     execute(text, params, options) {