okmodel 0.3.0 → 0.5.0

package/dist/shared/{xva8v7qk.js → p7pfx624.js}

@@ -3,6 +3,9 @@ import {
   textArray,
   arrayElementType
 } from "./n7mcc1gk.js";
+import {
+  stack
+} from "./672t5vym.js";
 import {
   touchFields,
   fieldSealed,
@@ -11,9 +14,6 @@ import {
 import {
   runWrite
 } from "./n4jqhpqz.js";
-import {
-  stack
-} from "./672t5vym.js";
 import {
   writeWouldValidate
 } from "./9m80mkac.js";
@@ -34,7 +34,7 @@ import {
   isRecord,
   registerFailFix,
   fail
-} from "./xrfnq5k8.js";
+} from "./qgvt8nx1.js";
 import {
   safetyInstalled,
   runSafety
@@ -179,7 +179,7 @@ async function planInsert(table, input, options, mods, generators, scope, tenanc
       keyFields: undefined
     };
   }
-  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./jns2wx4t.js");
+  const conflictMod = options.onConflict === undefined || options.onConflict === "error" ? undefined : await import("./9tgmr1gh.js");
   const conflict = conflictMod?.readConflict(table, options.onConflict, allow);
   const chunks = chunkRows(rows.map((row) => cellsFor(columns, row)));
   const statements = [];

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

@@ -42,12 +42,21 @@ var FIND_OPTIONS = [
   "limit",
   "orderBy",
   "select",
+  "route",
   "signal",
   "timeout",
   "where"
 ];
-var ONE_OPTIONS = ["include", "orderBy", "select", "signal", "timeout", "where"];
-var FILTER_OPTIONS = ["signal", "timeout", "where"];
+var ONE_OPTIONS = [
+  "include",
+  "orderBy",
+  "route",
+  "select",
+  "signal",
+  "timeout",
+  "where"
+];
+var FILTER_OPTIONS = ["route", "signal", "timeout", "where"];
 function readOptionNames(op) {
   if (op === "find")
     return FIND_OPTIONS;

package/dist/shared/{ne02ng5c.js → qy9rdq0g.js}

@@ -1,19 +1,22 @@
 import {
   open2
-} from "./xw1d69vd.js";
+} from "./wqem4jed.js";
+import"./8bwbwy8h.js";
 import"./n442h54c.js";
-import"./t616ynfn.js";
 import {
   assertRoleHealth
-} from "./hcmdtwgh.js";
+} from "./szm0cksa.js";
+import"./fancm5pt.js";
 import {
   errorDoc,
+  assertTargetPolicy,
   selectTarget,
   openProject
-} from "./5nmdenb6.js";
+} from "./xdpj5kkm.js";
 import {
   omitManagedObjects
-} from "./2ssqrv66.js";
+} from "./ayz64vzj.js";
+import"./8xsbagad.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -36,6 +39,7 @@ ${doc.fix}
   const objects = omitManagedObjects(opened.built.catalog).objects;
   if (opened.config.roles !== undefined) {
     const target = selectTarget(opened.config, flags?.target);
+    assertTargetPolicy(target, "check", flags?.allowProtected ?? false);
     const pool = open2({ url: target.url, max: 1 });
     try {
       await assertRoleHealth(pool, opened.config.roles, objects);

package/dist/shared/{3ekj9x92.js → r6pj4fq2.js}

@@ -2,7 +2,7 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./k34e0xf2.js";
+} from "./bt9sfq0z.js";
 import {
   emitWhere,
   emitOrder,
@@ -15,7 +15,7 @@ import {
   list,
   isRecord,
   fail
-} from "./xrfnq5k8.js";
+} from "./qgvt8nx1.js";
 import {
   OkmError2,
   throwNamed2
@@ -32,6 +32,7 @@ var OPTIONS = [
   "max",
   "orderBy",
   "limit",
+  "route",
   "signal",
   "timeout"
 ];
@@ -79,7 +80,8 @@ function plan(session, table, options, mods, view) {
     orderBy,
     limit: record.limit,
     signal: record.signal,
-    timeout: record.timeout
+    timeout: record.timeout,
+    route: record.route
   }, mods.all, session.scope, session.schema.model[table], session.schema, view);
   const call = { ...base, op: "aggregate", build: statement(spec) };
   return readHandle(session, table, call, mods, (compiled, rows) => decode(compiled, rows));

package/dist/shared/r73pt594.js

@@ -0,0 +1,426 @@
+import {
+  parseCatalog2
+} from "./8bwbwy8h.js";
+import"./wqem4jed.js";
+import"./n442h54c.js";
+import {
+  applyTarget2,
+  backfillTiming2
+} from "./xhh1srw3.js";
+import {
+  sealViews,
+  catalogQuery2,
+  managedRoleOptions2
+} from "./wxn4b7pp.js";
+import {
+  loadMigrations,
+  catalogsEqual,
+  snapshotDifference
+} from "./kdkxh3kb.js";
+import"./szm0cksa.js";
+import {
+  introspectSchema
+} from "./fancm5pt.js";
+import {
+  lintMigrationDirectory,
+  hasError,
+  lintRefusal,
+  selectTarget,
+  openProject
+} from "./xdpj5kkm.js";
+import {
+  canonicalTypeName,
+  classOf,
+  strictestClass,
+  planMigration,
+  parsePlan
+} from "./ayz64vzj.js";
+import {
+  quoteIdent
+} from "./8xsbagad.js";
+import {
+  catalog,
+  isDomain
+} from "./g7ez901n.js";
+import {
+  identityKey2
+} from "./t4tbsy9h.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/check.ts
+import { readFileSync } from "node:fs";
+import { join } from "node:path";
+import postgres from "postgres";
+var CHECK_SCHEMA_PREFIX = "okm_check_";
+var HISTORY_CODE = "OKM1547";
+var PREVIOUS_CODE = "OKM1548";
+var STALE_CODE = "OKM1549";
+var HISTORY_FIX = "Regenerate the migration so the stored catalog matches the schema the SQL applies.";
+var FORK_FIX = "Generate the later migration from the previous migration's catalog, not from an older parent.";
+var PREVIOUS_FIX = "Keep every table, column, constraint, and type the previous catalog relies on, or classify the migration as contract.";
+var STALE_FIX = "Run okm generate.";
+async function checkMigrations(cwd, flags, options) {
+  const opened = await openProject(cwd);
+  const target = selectTarget(opened.config, flags.target);
+  if (target.protected) {
+    throw new OkmError2("OKM1850", `okm migrate check writes a scratch schema and refuses protected target ${target.name}. Point it at a throwaway Postgres.`, {
+      kind: "forbidden",
+      fix: {
+        summary: "Point okm migrate check at a throwaway Postgres. --allow-protected does not apply."
+      }
+    });
+  }
+  const directory = join(cwd, opened.config.migrations ?? "migrations");
+  const history = readHistory(directory);
+  if (options?.provision === true) {
+    const equivalence = await proveSnapshot(opened.config, target.url, target.name, flags, history);
+    if (equivalence !== undefined)
+      throwFailure([equivalence]);
+  }
+  const previous = previousFailures(history);
+  const stale = staleFailure(history, opened.built.catalog);
+  const lint = lintFailure(directory, history, opened.config.lintFrom);
+  const replayed = await replayHistory(opened.config, target.url, target.name, flags, history);
+  const failures = [...replayed, ...previous, ...stale, ...lint];
+  if (failures.length > 0)
+    throwFailure(failures);
+  return `ok ${String(history.length)} migrations
+`;
+}
+function previousCatalogGaps(before, after) {
+  const afterBy = new Map(after.objects.map((object) => [identityKey2(object.identity), object]));
+  const gaps = [];
+  for (const object of before.objects) {
+    if (!checkedKind(object.kind))
+      continue;
+    const next = afterBy.get(identityKey2(object.identity));
+    if (next === undefined || next.kind !== object.kind) {
+      gaps.push(`${objectLabel(object)} is missing`);
+      continue;
+    }
+    if (object.kind === "column" && next.kind === "column") {
+      gaps.push(...columnGaps(object, next));
+    }
+    if (object.kind === "type" && next.kind === "type" && !sameType(object.definition, next.definition)) {
+      gaps.push(`${objectLabel(object)} changed`);
+    }
+  }
+  return gaps;
+}
+function recomputedMigrationClass(plan, before, after) {
+  if (plan.steps.length === 0)
+    return "expand";
+  if (plan.steps.some((step) => step.kind === undefined)) {
+    return planMigration({ before, after, name: plan.name }).class;
+  }
+  return strictestClass(plan.steps.map((step) => classOf(step.kind ?? "raw-sql")));
+}
+function migrationAllowsPreviousGaps(plan, before, after) {
+  return recomputedMigrationClass(plan, before, after) === "contract" && plan.class !== "expand";
+}
+function previousFailures(history) {
+  const failures = [];
+  let before = catalog([]);
+  for (const migration of history) {
+    const gaps = previousCatalogGaps(before, migration.catalog);
+    if (gaps.length > 0 && !migrationAllowsPreviousGaps(migration.plan, before, migration.catalog)) {
+      const stated = migration.plan.class === "expand" ? "expand" : recomputedMigrationClass(migration.plan, before, migration.catalog);
+      failures.push({
+        code: PREVIOUS_CODE,
+        message: `${migration.id}: previous catalog is not satisfied (${gaps.join("; ")}). The migration is classified ${stated}.`,
+        fix: PREVIOUS_FIX
+      });
+    }
+    before = migration.catalog;
+  }
+  return failures;
+}
+function staleFailure(history, head) {
+  const last = history.at(-1)?.catalog ?? catalog([]);
+  if (catalogsEqual(last, head))
+    return [];
+  return [
+    {
+      code: STALE_CODE,
+      message: "The last migration's catalog does not match the schema.",
+      fix: STALE_FIX
+    }
+  ];
+}
+function lintFailure(directory, history, lintFrom) {
+  const findings = lintMigrationDirectory(directory, lintIds(history, lintFrom));
+  if (!hasError(findings))
+    return [];
+  const refusal = lintRefusal(findings);
+  return [{ code: refusal.code, message: refusal.message, fix: refusal.fix.summary }];
+}
+function lintIds(history, lintFrom) {
+  if (lintFrom === undefined)
+    return;
+  const ids = history.map((migration) => migration.id);
+  const start = ids.indexOf(lintFrom);
+  if (start < 0) {
+    throw new OkmError2("invalid", `lintFrom ${lintFrom} is not a migration id.`, {
+      fix: {
+        summary: "Set lintFrom to a migration id. Files before that id are the adoption baseline and are not linted."
+      }
+    });
+  }
+  return new Set(ids.slice(start));
+}
+async function proveSnapshot(config, url, target, flags, history) {
+  const head = history.at(-1);
+  if (head === undefined)
+    return;
+  const sql = postgres(url, {
+    max: 1,
+    connect_timeout: 5,
+    idle_timeout: 1,
+    onnotice: () => {}
+  });
+  const provided = `${CHECK_SCHEMA_PREFIX}p${crypto.randomUUID().replaceAll("-", "")}`;
+  const replayed = `${CHECK_SCHEMA_PREFIX}r${crypto.randomUUID().replaceAll("-", "")}`;
+  const timing = {
+    ...flags.lockTimeoutMs !== undefined ? { lockTimeoutMs: flags.lockTimeoutMs } : config.timeouts?.lock !== undefined ? { lockTimeoutMs: config.timeouts.lock } : {},
+    ...flags.statementTimeoutMs !== undefined ? { statementTimeoutMs: flags.statementTimeoutMs } : config.timeouts?.statement !== undefined ? { statementTimeoutMs: config.timeouts.statement } : {},
+    ...backfillTiming2(config.backfill)
+  };
+  try {
+    await sql.unsafe(`create schema ${quoteIdent(provided)}`);
+    await sql.unsafe(`create schema ${quoteIdent(replayed)}`);
+    const role = config.roles === undefined ? {} : { migrationRole: config.roles.migration, schema: provided };
+    await applyTarget2({
+      url,
+      target,
+      protected: false,
+      allowProtected: false,
+      allowPooler: flags.allowPooler || config.allowPooler === true,
+      searchPath: provided,
+      ...timing,
+      migrations: history.map((migration) => ({
+        id: migration.id,
+        catalogHash: migration.catalogHash,
+        steps: migration.steps
+      })),
+      snapshot: {
+        catalog: head.catalog,
+        migrationId: head.id,
+        catalogHash: head.catalogHash,
+        reference: [],
+        only: true
+      },
+      ...role
+    });
+    await applyTarget2({
+      url,
+      target,
+      protected: false,
+      allowProtected: false,
+      allowPooler: flags.allowPooler || config.allowPooler === true,
+      searchPath: replayed,
+      ...timing,
+      migrations: history.map((migration) => ({
+        id: migration.id,
+        catalogHash: migration.catalogHash,
+        steps: retargetSteps(migration.steps, replayed)
+      })),
+      ...config.roles !== undefined ? { migrationRole: config.roles.migration, schema: replayed } : {}
+    });
+    const liveProvided = await introspectScratch(sql, provided, config);
+    const liveReplayed = await introspectScratch(sql, replayed, config);
+    const difference = snapshotDifference(liveProvided, liveReplayed);
+    if (difference === undefined)
+      return;
+    return {
+      code: "OKM1521",
+      message: `Provisioning from the snapshot does not match the replayed history.
+${difference}`,
+      fix: "Regenerate the snapshot from the history. okm migrate check --provision is the command that reports this."
+    };
+  } finally {
+    await sql.unsafe(`drop schema if exists ${quoteIdent(provided)} cascade`).catch(() => {
+      return;
+    });
+    await sql.unsafe(`drop schema if exists ${quoteIdent(replayed)} cascade`).catch(() => {
+      return;
+    });
+    await sql.end({ timeout: 5 });
+  }
+}
+async function replayHistory(config, url, target, flags, history) {
+  if (history.length === 0)
+    return [];
+  const sql = postgres(url, {
+    max: 1,
+    connect_timeout: 5,
+    idle_timeout: 1,
+    onnotice: () => {}
+  });
+  const scratch = `${CHECK_SCHEMA_PREFIX}${crypto.randomUUID().replaceAll("-", "")}`;
+  const failures = [];
+  try {
+    await sql.unsafe(`create schema ${quoteIdent(scratch)}`);
+    const runner = catalogQuery2(sql);
+    for (let index = 0;index < history.length; index += 1) {
+      const migration = history[index];
+      if (migration === undefined)
+        continue;
+      await applyTarget2({
+        url,
+        target,
+        protected: false,
+        allowProtected: false,
+        allowPooler: flags.allowPooler || config.allowPooler === true,
+        searchPath: scratch,
+        ...flags.lockTimeoutMs !== undefined ? { lockTimeoutMs: flags.lockTimeoutMs } : config.timeouts?.lock !== undefined ? { lockTimeoutMs: config.timeouts.lock } : {},
+        ...flags.statementTimeoutMs !== undefined ? { statementTimeoutMs: flags.statementTimeoutMs } : config.timeouts?.statement !== undefined ? { statementTimeoutMs: config.timeouts.statement } : {},
+        ...backfillTiming2(config.backfill),
+        migrations: [
+          {
+            id: migration.id,
+            catalogHash: migration.catalogHash,
+            steps: retargetSteps(migration.steps, scratch)
+          }
+        ],
+        ...config.roles !== undefined ? { migrationRole: config.roles.migration, schema: scratch } : {}
+      });
+      const live = await introspectScratch(sql, scratch, config);
+      const sealed = await sealViews(runner, migration.catalog);
+      const back = planMigration({ before: live, after: sealed, name: migration.id });
+      if (back.steps.length === 0)
+        continue;
+      failures.push(historyFailure(history, index, back));
+      break;
+    }
+  } finally {
+    await sql.unsafe(`drop schema if exists ${quoteIdent(scratch)} cascade`).catch(() => {
+      return;
+    });
+    await sql.end({ timeout: 5 });
+  }
+  return failures;
+}
+async function introspectScratch(sql, schema, config) {
+  await sql.unsafe(`set search_path to ${quoteIdent(schema)}`);
+  return introspectSchema(catalogQuery2(sql), schema, "public", managedRoleOptions2(config.roles));
+}
+function historyFailure(history, index, back) {
+  const migration = history[index];
+  const id = migration?.id ?? "migration";
+  const fork = migration === undefined ? undefined : forkMessage(history, index);
+  if (fork !== undefined)
+    return { code: HISTORY_CODE, message: fork, fix: FORK_FIX };
+  const steps = back.steps.map((step) => step.sql).join(`
+`);
+  return {
+    code: HISTORY_CODE,
+    message: `${id}: history differs from the stored catalog
+${steps}`,
+    fix: HISTORY_FIX
+  };
+}
+function forkMessage(history, index) {
+  const current = history[index];
+  const previous = history[index - 1];
+  if (current === undefined || previous === undefined)
+    return;
+  if (samePlan(previous.catalog, current.catalog, current.plan))
+    return;
+  for (let parentIndex = 0;parentIndex < index; parentIndex += 1) {
+    const parent = parentIndex === 0 ? catalog([]) : history[parentIndex - 1]?.catalog;
+    if (parent === undefined)
+      continue;
+    if (!samePlan(parent, current.catalog, current.plan))
+      continue;
+    return `migration ${current.id} was generated from a different parent than ${previous.id}`;
+  }
+  return;
+}
+function samePlan(before, after, file) {
+  try {
+    return sameSql(planMigration({ before, after, name: "parent" }), file);
+  } catch (error) {
+    if (error instanceof OkmError2 && error.code === "OKM1530")
+      return false;
+    throw error;
+  }
+}
+function sameSql(planned, file) {
+  if (planned.steps.length !== file.steps.length)
+    return false;
+  return planned.steps.every((step, index) => step.sql === file.steps[index]?.sql);
+}
+function retargetSteps(steps, schema) {
+  const from = `${quoteIdent("public")}.`;
+  const to = `${quoteIdent(schema)}.`;
+  const fromDefaults = `in schema ${quoteIdent("public")} `;
+  const toDefaults = `in schema ${quoteIdent(schema)} `;
+  return steps.map((step) => ({
+    ...step,
+    sql: step.sql.replaceAll(from, to).replaceAll(fromDefaults, toDefaults),
+    ...step.backfill === undefined ? {} : { backfill: { ...step.backfill, table: step.backfill.table.replaceAll(from, to) } }
+  }));
+}
+function readHistory(directory) {
+  return loadMigrations(directory).map((migration) => ({
+    id: migration.id,
+    catalogHash: migration.catalogHash,
+    steps: migration.steps,
+    plan: parsePlan(readFileSync(join(directory, `${migration.id}.sql`), "utf8")),
+    catalog: parseCatalog2(readFileSync(join(directory, `${migration.id}.catalog.json`), "utf8"))
+  }));
+}
+function throwFailure(failures) {
+  const first = failures[0];
+  if (first === undefined)
+    throw new Error("okm migrate check has no failure to report.");
+  const message = failures.length === 1 ? first.message : failures.map((failure) => `${failure.code} ${failure.message}`).join(`
+`);
+  throw new OkmError2(first.code, message, { fix: { summary: first.fix } });
+}
+function checkedKind(kind) {
+  return kind === "table" || kind === "column" || kind === "constraint" || kind === "type";
+}
+function columnGaps(before, after) {
+  const gaps = [];
+  const place = objectLabel(before);
+  if (canonicalTypeName(before.definition.dataType) !== canonicalTypeName(after.definition.dataType)) {
+    gaps.push(`${place} changed type from ${before.definition.dataType} to ${after.definition.dataType}`);
+  }
+  if (before.definition.nullable && !after.definition.nullable && !columnHasDefault(after)) {
+    gaps.push(`${place} nullability tightened without a default`);
+  }
+  return gaps;
+}
+function columnHasDefault(column) {
+  return column.definition.defaultExpression !== undefined || column.definition.identity !== undefined || column.definition.generated !== undefined;
+}
+function sameType(before, after) {
+  const beforeDomain = isDomain(before);
+  const afterDomain = isDomain(after);
+  if (beforeDomain !== afterDomain)
+    return false;
+  if (beforeDomain && afterDomain) {
+    return canonicalTypeName(before.base) === canonicalTypeName(after.base) && before.check === after.check;
+  }
+  if (!beforeDomain && !afterDomain) {
+    if (before.labels.length !== after.labels.length)
+      return false;
+    return before.labels.every((label, index) => label === after.labels[index]);
+  }
+  return false;
+}
+function objectLabel(object) {
+  if (object.kind === "column" || object.kind === "constraint") {
+    return `${object.kind} ${object.identity.parent.name}.${object.identity.name}`;
+  }
+  if (object.kind === "table" || object.kind === "type") {
+    return `${object.kind} ${object.identity.name}`;
+  }
+  return object.kind;
+}
+export {
+  checkMigrations
+};

package/dist/shared/rasvvzgz.js

@@ -0,0 +1,21 @@
+import {
+  applyTarget2,
+  applyProject2,
+  pushProject2,
+  backfillTiming2
+} from "./xhh1srw3.js";
+import"./kdkxh3kb.js";
+import"./szm0cksa.js";
+import"./fancm5pt.js";
+import"./xdpj5kkm.js";
+import"./ayz64vzj.js";
+import"./n442h54c.js";
+import"./8xsbagad.js";
+import"./8bwbwy8h.js";
+import"./wqem4jed.js";
+export {
+  applyProject2 as applyProject,
+  applyTarget2 as applyTarget,
+  backfillTiming2 as backfillTiming,
+  pushProject2 as pushProject
+};

package/dist/shared/{01yr20s5.js → sf8m6tfy.js}

@@ -2,7 +2,7 @@ import {
   noticeBuffer,
   WireSession,
   cursorStream
-} from "./0jc3ffzf.js";
+} from "./zvbjc949.js";
 import {
   BUNSQL_CAPABILITIES,
   driverErrors,
@@ -41,7 +41,7 @@ function open5(config) {
     counters.busy = Math.max(0, counters.busy - 1);
   });
   const held = { sql, parked, acquireMs, counters, notices, isClosed };
-  const checkout = () => closed ? rejectClosed() : import("./fs0ex00p.js").then((mod) => mod.checkout(held));
+  const checkout = () => closed ? rejectClosed() : import("./4ef7mmqf.js").then((mod) => mod.checkout(held));
   return {
     capabilities: BUNSQL_CAPABILITIES,
     execute(text, params, options) {

package/dist/shared/{hcmdtwgh.js → szm0cksa.js}

@@ -1,3 +1,6 @@
+import {
+  FUNCTION_ARG_TYPES
+} from "./fancm5pt.js";
 import {
   OkmError2
 } from "./52szzakm.js";
@@ -92,7 +95,7 @@ async function functionExists(runner, schema, name, args) {
   const result = await runner.execute(`select 1 from pg_proc p
      join pg_namespace n on n.oid = p.pronamespace
      where n.nspname = $1 and p.proname = $2
-       and replace(pg_get_function_identity_arguments(p.oid), ' ', '') = $3`, [schema, name, args]);
+       and ${FUNCTION_ARG_TYPES} = $3`, [schema, name, args]);
   return result.rows.length > 0;
 }
 function truthy(value) {

package/dist/shared/{axhk06q1.js → tq9afp8d.js}

@@ -11,7 +11,7 @@ import {
   quote,
   isRecord,
   fail
-} from "./xrfnq5k8.js";
+} from "./qgvt8nx1.js";
 import {
   isOperator,
   operatorName,

package/dist/shared/{xw1d69vd.js → wqem4jed.js}

@@ -117,7 +117,7 @@ function open2(config) {
     },
     async batch(statements, options) {
       return sockets.occupy(async () => {
-        const { checkout } = await import("./999ade2q.js");
+        const { checkout } = await import("./5vdm4sgp.js");
         const connection = await checkout(held);
         try {
           return await connection.batch(statements, options);
@@ -129,12 +129,12 @@ function open2(config) {
     reserve() {
       const gate = sockets.busyGate();
       gate.enter();
-      return import("./999ade2q.js").then((mod) => mod.holdCheckout(gate, () => mod.checkout(held)), (error) => {
+      return import("./5vdm4sgp.js").then((mod) => mod.holdCheckout(gate, () => mod.checkout(held)), (error) => {
         gate.leave();
         throw error;
       });
     },
-    describe: (text, params) => sockets.occupy(() => import("./999ade2q.js").then((mod) => mod.describe(sql, text, params))),
+    describe: (text, params) => sockets.occupy(() => import("./5vdm4sgp.js").then((mod) => mod.describe(sql, text, params))),
     stream(text, params) {
       const gate = sockets.busyGate();
       return async function* () {
@@ -149,7 +149,7 @@ function open2(config) {
     listen(channel, onNotify) {
       const gate = sockets.listenerGate();
       gate.enter();
-      return import("./999ade2q.js").then((mod) => mod.holdListener(gate, async () => {
+      return import("./5vdm4sgp.js").then((mod) => mod.holdListener(gate, async () => {
         const listening = await sql.listen(channel, onNotify);
         return async () => {
           await listening.unlisten();
@@ -219,7 +219,7 @@ class PgSession {
       onAbort();
     else
       watch.signal.addEventListener("abort", onAbort, { once: true });
-    return import("./999ade2q.js").then((mod) => mod.watchQuery(pending, watch, onAbort, {
+    return import("./5vdm4sgp.js").then((mod) => mod.watchQuery(pending, watch, onAbort, {
       start,
       text,
       notices: this.notices,
@@ -271,7 +271,7 @@ class PgSession {
   }
 }
 async function* loadStream(sql, text, params) {
-  const { stream } = await import("./999ade2q.js");
+  const { stream } = await import("./5vdm4sgp.js");
   yield* stream(sql, text, params);
 }
 function send(sql, text, params, named) {