okmodel 0.3.0 → 0.4.0

package/dist/shared/{fptpmvxp.js → q795afwa.js}

@@ -7,27 +7,40 @@ async function assertCompatible(pool, schema, recordedHash, source, options) {
   const code = await codeHash(schema, source);
   if (code.hash === recordedHash)
     return;
+  const { loadOnce } = await import("./htnaj77v.js");
   if (code.artifact !== undefined) {
-    const { loadTrustedCatalog } = await import("./qybh48nd.js");
-    loadTrustedCatalog(code.artifact.text, code.artifact.hash);
-  } else {
-    const artifact = await readCatalogFile(source.catalogDir);
-    if (artifact !== undefined) {
-      const { loadTrustedCatalog } = await import("./qybh48nd.js");
+    const artifact = code.artifact;
+    await loadOnce(`text\x00${artifact.hash}`, async () => {
+      const { loadTrustedCatalog } = await import("./6693j9rs.js");
       loadTrustedCatalog(artifact.text, artifact.hash);
-    }
+    });
+  } else if (code.fromFile) {
+    const dir = artifactDir(source.catalogDir);
+    await loadOnce(`file\x00${dir}\x00${code.hash}`, async () => {
+      const text = await readText(`${dir}/catalog.json`);
+      if (text === undefined) {
+        throw new OkmError2("OKM1027", `${dir}/catalog.json is missing.`, {
+          fix: {
+            summary: "Run okm build so catalog.json matches catalog.hash. connect does not rebuild the catalog from the schema."
+          }
+        });
+      }
+      const { loadTrustedCatalog } = await import("./6693j9rs.js");
+      loadTrustedCatalog(text, code.hash);
+    });
   }
-  const { assertDrift } = await import("./zwmqxb0g.js");
+  const { assertDrift } = await import("./5mtf6cj3.js");
   await assertDrift(pool, code.hash, recordedHash, options);
 }
 async function codeHash(schema, source) {
-  if (source.catalog !== undefined)
-    return { hash: source.catalog.hash, artifact: source.catalog };
+  if (source.catalog !== undefined) {
+    return { hash: source.catalog.hash, artifact: source.catalog, fromFile: false };
+  }
   const listed = await readHashFile(source.catalogDir);
   if (listed !== undefined)
-    return { hash: listed };
-  const { catalogHash } = await import("./qybh48nd.js");
-  return { hash: catalogHash(schemaCatalog(schema)) };
+    return { hash: listed, fromFile: true };
+  const { catalogHash } = await import("./6693j9rs.js");
+  return { hash: catalogHash(schemaCatalog(schema)), fromFile: false };
 }
 function schemaCatalog(schema) {
   const value = Reflect.get(schema, "catalog");
@@ -47,14 +60,6 @@ async function readHashFile(catalogDir) {
   const hash = text.trim();
   return hash.length === 0 ? undefined : hash;
 }
-async function readCatalogFile(catalogDir) {
-  const dir = artifactDir(catalogDir);
-  const hash = await readHashFile(catalogDir);
-  const text = await readText(`${dir}/catalog.json`);
-  if (hash === undefined || text === undefined)
-    return;
-  return { text, hash };
-}
 function artifactDir(catalogDir) {
   if (catalogDir !== undefined)
     return catalogDir.replace(/\/$/, "");

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

@@ -2,7 +2,7 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./k34e0xf2.js";
+} from "./kkzwp3d2.js";
 import {
   emitWhere,
   emitOrder,

package/dist/shared/s4mb6a4b.js

@@ -0,0 +1,545 @@
+import {
+  open2
+} from "./wqem4jed.js";
+import {
+  catalogHash2
+} from "./8jb4ymh2.js";
+import {
+  runTarget,
+  assumeRole,
+  statementOutsideTransaction,
+  loadMigrations,
+  loadHeadSnapshot,
+  readReference,
+  referenceInserts,
+  provisionMark,
+  expandProvisioned,
+  installSnapshot
+} from "./7nk68fj8.js";
+import {
+  assertCreateRole,
+  currentUser,
+  roleExists
+} from "./hcmdtwgh.js";
+import {
+  lintMigrationDirectory,
+  hasError,
+  lintRefusal,
+  assertTargetPolicy,
+  assertDirectConnection,
+  selectTarget,
+  projectHead,
+  loadBuiltSchema,
+  loadConfig
+} from "./q6zsyh31.js";
+import {
+  changesRole,
+  batchSizeField,
+  assertExtensionsAvailable,
+  planMigration
+} from "./n5y9zyj1.js";
+import {
+  OkmError2
+} from "./52szzakm.js";
+
+// src/tooling/migrate/apply.ts
+import { join } from "node:path";
+
+// src/tooling/migrate/engine.ts
+var IDENT = String.raw`"(?:[^"]|"")+"|[A-Za-z_][\w$]*`;
+var DEFAULT_UUIDV7 = /\bdefault\s+uuidv7\s*\(\s*\)/i;
+var TABLE = new RegExp(String.raw`^\s*(?:create\s+table(?:\s+if\s+not\s+exists)?|alter\s+table(?:\s+if\s+exists)?(?:\s+only)?)\s+(?:(?:${IDENT})\.)?(${IDENT})`, "i");
+var COLUMN = new RegExp(String.raw`(${IDENT})\s+(?:uuid\b|set\s+default\b)`, "i");
+function findUuidV7Default(migrations) {
+  for (const migration of migrations) {
+    for (let stepIndex = 0;stepIndex < migration.steps.length; stepIndex += 1) {
+      const sql = migration.steps[stepIndex]?.sql ?? "";
+      if (!DEFAULT_UUIDV7.test(sql))
+        continue;
+      return { migrationId: migration.id, stepIndex, column: columnOf(sql) };
+    }
+  }
+  return;
+}
+async function assertUuidV7Available(connection, migrations) {
+  const found = findUuidV7Default(migrations);
+  if (found === undefined)
+    return;
+  const result = await connection.execute("select current_setting('server_version_num'), to_regprocedure('uuidv7()')::text");
+  const row = result.rows[0];
+  const major = Math.floor(Number(row?.[0] ?? "0") / 1e4);
+  const defined = row?.[1] !== null && row?.[1] !== undefined;
+  if (major >= 18 || defined)
+    return;
+  const where = found.column === undefined ? "A column" : `Column ${found.column}`;
+  throw new OkmError2("OKM1812", `${where} has a uuidv7() default (migration ${found.migrationId}, step ${String(found.stepIndex)}), and the server is PostgreSQL ${String(major)}. uuidv7() arrives in PostgreSQL 18. Nothing was changed.`, {
+    fix: {
+      summary: 'Either run PostgreSQL 18 and declare schema({ requires: { postgres: ">=18" } }), or use t.id({ default: "uuidv4" }) (or schema({ defaults: { id: "uuidv4" } })), which uses gen_random_uuid() and works on PostgreSQL 13 and newer. Then delete the migration that was not applied and generate it again.'
+    }
+  });
+}
+function columnOf(sql) {
+  const table = TABLE.exec(sql)?.[1];
+  if (table === undefined)
+    return;
+  const line = sql.split(`
+`).find((text) => DEFAULT_UUIDV7.test(text));
+  const column = line === undefined ? undefined : COLUMN.exec(line)?.[1];
+  if (column === undefined)
+    return;
+  return `${unquote(table)}.${unquote(column)}`;
+}
+function unquote(name) {
+  return name.startsWith('"') ? name.slice(1, -1).replaceAll('""', '"') : name;
+}
+
+// src/tooling/migrate/apply.ts
+var DEFAULT_LOCK_MS = 5000;
+var DEFAULT_STATEMENT_MS = 30000;
+var DEFAULT_RETRIES = 3;
+var META = `create table if not exists okm_meta (
+  id text primary key,
+  catalog_hash text not null,
+  migration_id text not null
+)`;
+var HISTORY = `create table if not exists okm_history (
+  migration_id text not null,
+  step_index integer not null,
+  class text not null,
+  catalog_hash text not null,
+  applied_at timestamptz not null default now(),
+  primary key (migration_id, step_index)
+)`;
+var BACKFILL = `create table if not exists okm_backfill (
+  migration_id text not null,
+  step_index integer not null,
+  last_key text,
+  rows_touched bigint not null default 0,
+  batches integer not null default 0,
+  state text not null,
+  updated_at timestamptz not null default now(),
+  primary key (migration_id, step_index)
+)`;
+function applyUnits(migration, done) {
+  const pending = [];
+  for (let index = 0;index < migration.steps.length; index += 1) {
+    if (done.has(`${migration.id}:${String(index)}`))
+      continue;
+    const step = migration.steps[index];
+    if (step !== undefined)
+      pending.push({ index, step });
+  }
+  const units = [];
+  let batch = [];
+  const flush = () => {
+    if (batch.length === 0)
+      return;
+    const last = batch.at(-1);
+    units.push({
+      migrationId: migration.id,
+      catalogHash: migration.catalogHash,
+      finishes: last !== undefined && last.index === migration.steps.length - 1,
+      transactional: true,
+      steps: batch
+    });
+    batch = [];
+  };
+  for (const item of pending) {
+    if (item.step.backfill === undefined && item.step.transactional && !statementOutsideTransaction(item.step.sql)) {
+      batch.push(item);
+      continue;
+    }
+    flush();
+    units.push({
+      migrationId: migration.id,
+      catalogHash: migration.catalogHash,
+      finishes: item.index === migration.steps.length - 1,
+      transactional: false,
+      steps: [item]
+    });
+  }
+  flush();
+  return units;
+}
+async function applyTarget2(request) {
+  assertDirectConnection(request.url, request.allowPooler === true);
+  const pool = open2({
+    url: request.url,
+    max: 1,
+    ...request.searchPath !== undefined ? { searchPath: request.searchPath } : {}
+  });
+  if (pool.reserve === undefined) {
+    await pool.close();
+    throw new OkmError2("invalid", "The driver cannot reserve a connection.", {
+      fix: { summary: "Apply needs a driver with interactive transactions." }
+    });
+  }
+  const connection = await pool.reserve();
+  let locked = false;
+  try {
+    await setTimeouts(connection, request);
+    await lockTarget(connection, request.target);
+    locked = true;
+    request.onLocked?.();
+    if (request.lintDirectory !== undefined) {
+      await refusePendingLint(connection, request.lintDirectory, request.migrations);
+    }
+    const session = {};
+    await prepareMigrationRole(connection, request, session);
+    await assertExtensionsAvailable(connection, request.migrations);
+    await assertUuidV7Available(connection, request.migrations);
+    const state = request.snapshot === undefined ? undefined : await targetState(connection);
+    if (request.snapshot !== undefined && state !== undefined) {
+      if (state.kind === "empty") {
+        return await provisionEmpty(connection, request, session);
+      }
+      if (state.kind === "interrupted")
+        throw interruptedProvision(request.target, state.object);
+      if (state.kind === "occupied" || request.snapshot.only === true) {
+        throw notEmpty(request.target, state.kind === "occupied" ? state.object : "okm_meta");
+      }
+    }
+    await connection.execute(META);
+    await connection.execute(HISTORY);
+    await connection.execute(BACKFILL);
+    const history = await readHistory(connection);
+    const done = expandProvisioned(request.migrations, history.done, history.ids);
+    const units = request.migrations.flatMap((migration) => applyUnits(migration, done));
+    const report = await runTarget(connection, {
+      policy: request,
+      units,
+      retries: request.retries ?? DEFAULT_RETRIES,
+      lockTimeoutMs: request.lockTimeoutMs ?? DEFAULT_LOCK_MS,
+      statementTimeoutMs: request.statementTimeoutMs ?? DEFAULT_STATEMENT_MS,
+      backfillStatementTimeoutMs: request.backfillStatementTimeoutMs ?? request.statementTimeoutMs ?? DEFAULT_STATEMENT_MS,
+      ...request.backfillPauseMs !== undefined ? { backfillPauseMs: request.backfillPauseMs } : {},
+      ...request.migrationRole !== undefined ? { migrationRole: request.migrationRole } : {},
+      ...request.schema !== undefined ? { schema: request.schema } : {},
+      ...request.onProgress !== undefined ? { onProgress: request.onProgress } : {},
+      ...request.afterBatch !== undefined ? { afterBatch: request.afterBatch } : {}
+    }, session);
+    if (request.snapshot !== undefined) {
+      await insertReference(connection, request);
+    }
+    return report;
+  } finally {
+    if (locked)
+      await connection.execute("select pg_advisory_unlock(hashtext($1))", [
+        lockKey(request.target)
+      ]);
+    await connection.release();
+    await pool.close();
+  }
+}
+async function applyProject2(cwd, flags, write) {
+  const config = await loadConfig(cwd);
+  const target = selectTarget(config, flags.target);
+  const directory = joinMigrations(cwd, config.migrations);
+  const migrations = loadMigrations(directory);
+  const head = loadHeadSnapshot(directory);
+  if (migrations.length === 0 || head === undefined)
+    return `target ${target.name}
+nothing to apply
+`;
+  const built = await loadBuiltSchema(cwd, config).catch((error) => {
+    if (error instanceof OkmError2 && error.message.endsWith("must export a schema()."))
+      return;
+    throw error;
+  });
+  const progress = [];
+  const report = await applyTarget2({
+    url: target.url,
+    target: target.name,
+    protected: target.protected,
+    allowProtected: flags.allowProtected,
+    allowPooler: flags.allowPooler || config.allowPooler === true,
+    ...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,
+    snapshot: {
+      catalog: head.catalog,
+      migrationId: head.id,
+      catalogHash: head.catalogHash,
+      reference: built === undefined ? [] : readReference(built.tables, built.casing, head.catalog)
+    },
+    ...config.roles !== undefined ? { migrationRole: config.roles.migration } : {},
+    lintDirectory: directory,
+    onProgress: (line) => {
+      if (write !== undefined)
+        write(`${line}
+`);
+      else
+        progress.push(line);
+    }
+  });
+  const summary = formatReport(report);
+  if (write !== undefined || progress.length === 0)
+    return summary;
+  return `${progress.join(`
+`)}
+${summary}`;
+}
+async function pushProject2(cwd, flags) {
+  const config = await loadConfig(cwd);
+  const target = selectTarget(config, flags.target);
+  assertTargetPolicy(target, "push", flags.allowProtected);
+  const head = await projectHead(cwd);
+  const plan = planMigration({
+    before: head.previous,
+    after: head.catalog,
+    renames: head.renames,
+    name: "push",
+    ...batchSizeField(config.backfill?.batchSize)
+  });
+  if (plan.steps.length === 0)
+    return `target ${target.name}
+no changes
+`;
+  const report = await applyTarget2({
+    url: target.url,
+    target: target.name,
+    protected: target.protected,
+    allowProtected: flags.allowProtected,
+    allowPooler: flags.allowPooler || config.allowPooler === true,
+    ...backfillTiming2(config.backfill),
+    migrations: [
+      {
+        id: "push",
+        catalogHash: catalogHash2(head.catalog),
+        steps: plan.steps
+      }
+    ],
+    ...config.roles !== undefined ? { migrationRole: config.roles.migration } : {}
+  });
+  return formatReport(report);
+}
+function backfillTiming2(backfill) {
+  return {
+    ...backfill?.pauseMs !== undefined ? { backfillPauseMs: backfill.pauseMs } : {},
+    ...backfill?.statementTimeoutMs !== undefined ? { backfillStatementTimeoutMs: backfill.statementTimeoutMs } : {}
+  };
+}
+function formatReport(report) {
+  const role = report.setRole !== undefined ? `set role ${report.setRole}
+` : "";
+  if (report.applied.length === 0)
+    return `target ${report.target}
+${role}nothing to apply
+`;
+  return `target ${report.target}
+${role}${report.applied.map((id) => `applied ${id}`).join(`
+`)}
+`;
+}
+function joinMigrations(cwd, migrations) {
+  return join(cwd, migrations ?? "migrations");
+}
+async function setTimeouts(connection, request) {
+  const lock = request.lockTimeoutMs ?? DEFAULT_LOCK_MS;
+  const statement = request.statementTimeoutMs ?? DEFAULT_STATEMENT_MS;
+  await connection.execute("select set_config('lock_timeout', $1, false)", [String(lock)]);
+  await connection.execute("select set_config('statement_timeout', $1, false)", [
+    String(statement)
+  ]);
+}
+async function lockTarget(connection, target) {
+  const result = await connection.execute("select pg_try_advisory_lock(hashtext($1))", [
+    lockKey(target)
+  ]);
+  if (!wireTrue(result.rows[0]?.[0])) {
+    throw new OkmError2("OKM1522", `Another apply holds the lock for ${target}.`, {
+      kind: "conflict",
+      fix: {
+        summary: "Wait for that apply to finish. Do not start a second apply against the same target."
+      }
+    });
+  }
+}
+function lockKey(target) {
+  return `okm:${target}`;
+}
+async function refusePendingLint(connection, directory, migrations) {
+  const pending = await pendingMigrationIds(connection, migrations);
+  const findings = lintMigrationDirectory(directory, pending);
+  if (hasError(findings))
+    throw lintRefusal(findings);
+}
+async function pendingMigrationIds(connection, migrations) {
+  const present = await connection.execute("select to_regclass('okm_history') is not null");
+  if (!wireTrue(present.rows[0]?.[0]))
+    return new Set(migrations.map((migration) => migration.id));
+  const history = await readHistory(connection);
+  const done = expandProvisioned(migrations, history.done, history.ids);
+  const pending = new Set;
+  for (const migration of migrations) {
+    for (let index = 0;index < migration.steps.length; index += 1) {
+      if (!done.has(`${migration.id}:${String(index)}`)) {
+        pending.add(migration.id);
+        break;
+      }
+    }
+  }
+  return pending;
+}
+async function readHistory(connection) {
+  const result = await connection.execute("select migration_id, step_index::text from okm_history");
+  const done = new Set;
+  const ids = [];
+  for (const row of result.rows) {
+    const id = row[0];
+    const step = row[1];
+    if (id === null || id === undefined || step === null || step === undefined)
+      continue;
+    done.add(`${id}:${step}`);
+    ids.push(id);
+  }
+  return { done, ids };
+}
+async function provisionEmpty(connection, request, session) {
+  const snapshot = request.snapshot;
+  if (snapshot === undefined)
+    throw new Error("provision requires a snapshot");
+  assertTargetPolicy({ name: request.target, protected: request.protected }, "provision", request.allowProtected === true);
+  if (snapshot.reference.length > 0) {
+    assertTargetPolicy({ name: request.target, protected: request.protected }, "reference", request.allowProtected === true);
+  }
+  const schema = concreteSchema(request);
+  await connection.execute(META);
+  await connection.execute(HISTORY);
+  await connection.execute(BACKFILL);
+  await installSnapshot(connection, snapshot.catalog, schema, snapshot.reference, session, request.migrationRole);
+  const mark = provisionMark(snapshot.migrationId);
+  await connection.execute("begin");
+  try {
+    await connection.execute("insert into okm_history (migration_id, step_index, class, catalog_hash) values ($1, 0, 'expand', $2)", [mark, snapshot.catalogHash]);
+    await connection.execute(`insert into okm_meta (id, catalog_hash, migration_id) values ('head', $1, $2)
+       on conflict (id) do update set catalog_hash = excluded.catalog_hash, migration_id = excluded.migration_id`, [snapshot.catalogHash, mark]);
+    await connection.execute("commit");
+  } catch (error) {
+    await connection.execute("rollback").catch(() => {
+      return;
+    });
+    throw error;
+  }
+  return {
+    target: request.target,
+    applied: [mark],
+    ...session.setRole !== undefined ? { setRole: session.setRole } : {}
+  };
+}
+async function insertReference(connection, request) {
+  const snapshot = request.snapshot;
+  if (snapshot === undefined || snapshot.reference.length === 0)
+    return;
+  assertTargetPolicy({ name: request.target, protected: request.protected }, "reference", request.allowProtected === true);
+  const statements = referenceInserts(snapshot.reference, concreteSchema(request));
+  if (statements.length === 0)
+    return;
+  await connection.execute("begin");
+  try {
+    for (const sql of statements)
+      await connection.execute(sql);
+    await connection.execute("commit");
+  } catch (error) {
+    await connection.execute("rollback").catch(() => {
+      return;
+    });
+    throw error;
+  }
+}
+function concreteSchema(request) {
+  return request.searchPath ?? request.schema ?? "public";
+}
+async function targetState(connection) {
+  const meta = await connection.execute(`select to_regclass('okm_meta') is not null
+         or to_regclass('okm_history') is not null
+         or to_regclass('okm_backfill') is not null`);
+  if (wireTrue(meta.rows[0]?.[0])) {
+    const historyRows = await tableRows(connection, "okm_history");
+    const metaRows = await tableRows(connection, "okm_meta");
+    if (historyRows === 0 && metaRows === 0) {
+      const object = await namespaceObject(connection);
+      if (object === undefined)
+        return { kind: "empty" };
+      return { kind: "interrupted", object };
+    }
+    return { kind: "tracked" };
+  }
+  const object = await namespaceObject(connection);
+  if (object === undefined)
+    return { kind: "empty" };
+  return { kind: "occupied", object };
+}
+async function tableRows(connection, name) {
+  const present = await connection.execute(`select to_regclass('${name}') is not null`);
+  if (!wireTrue(present.rows[0]?.[0]))
+    return 0;
+  const counted = await connection.execute(`select count(*)::text from ${name}`);
+  const text = counted.rows[0]?.[0];
+  if (text === null || text === undefined)
+    return 0;
+  return Number(text);
+}
+async function namespaceObject(connection) {
+  const current = await connection.execute("select current_schema()");
+  const schema = current.rows[0]?.[0];
+  if (schema === null || schema === undefined)
+    return;
+  const found = await connection.execute(`select name from (
+       select c.relname as name from pg_class c
+         join pg_namespace n on n.oid = c.relnamespace
+        where n.nspname = $1
+          and c.relkind in ('r', 'p', 'v', 'm', 'S', 'f')
+          and c.relname not in ('okm_meta', 'okm_history', 'okm_backfill')
+       union all
+       select t.typname from pg_type t
+         join pg_namespace n on n.oid = t.typnamespace
+        where n.nspname = $1 and t.typtype in ('e', 'd')
+       union all
+       select e.extname from pg_extension e
+         join pg_namespace n on n.oid = e.extnamespace
+        where n.nspname = $1
+     ) objects limit 1`, [schema]);
+  const object = found.rows[0]?.[0];
+  if (object === null || object === undefined)
+    return;
+  return object;
+}
+function interruptedProvision(target, object) {
+  return new OkmError2("OKM1851", `Target ${target} is not empty (${object}): a previous provision stopped part-way; drop the schema or database and run again`, {
+    kind: "forbidden",
+    fix: {
+      summary: "Drop the schema or database and run again. A partial provision is not repaired."
+    }
+  });
+}
+function notEmpty(target, object) {
+  const message = object === "okm_meta" ? `Target ${target} already has migration history and cannot be provisioned.` : `Target ${target} is not empty (${object}) and has no migration history.`;
+  return new OkmError2("OKM1851", message, {
+    kind: "forbidden",
+    fix: {
+      summary: "Provision an empty schema or an empty database. A non-empty target is refused."
+    }
+  });
+}
+async function prepareMigrationRole(connection, request, session) {
+  const role = request.migrationRole;
+  const changes = request.migrations.some((migration) => migration.steps.some((step) => changesRole(step.sql)));
+  if (role === undefined) {
+    if (changes)
+      await assertCreateRole(connection, await currentUser(connection));
+    return;
+  }
+  const current = await currentUser(connection);
+  const exists = await roleExists(connection, role);
+  if (changes)
+    await assertCreateRole(connection, exists && current !== role ? role : current);
+  if (exists && current !== role)
+    await assumeRole(connection, role, session);
+}
+function wireTrue(value) {
+  return value === "t" || value === "true";
+}
+
+export { applyTarget2, applyProject2, pushProject2, backfillTiming2 };

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/{bryqk9k9.js → sr5ms7b3.js}

@@ -1,6 +1,6 @@
 import {
   withHttp
-} from "./k34e0xf2.js";
+} from "./kkzwp3d2.js";
 import {
   decodeResult
 } from "./xrfnq5k8.js";

package/dist/shared/{meck53jv.js → tny2t3sm.js}

@@ -1,18 +1,19 @@
 import {
   open2
-} from "./xw1d69vd.js";
-import"./t616ynfn.js";
+} from "./wqem4jed.js";
+import"./8jb4ymh2.js";
 import"./n442h54c.js";
 import {
   assertTargetPolicy,
   selectTarget,
   openProject
-} from "./5nmdenb6.js";
-import"./2ssqrv66.js";
+} from "./q6zsyh31.js";
+import"./n5y9zyj1.js";
+import"./41kv2xdm.js";
 import {
   isExactVersion,
   compareExtensionVersions
-} from "./th14ygv2.js";
+} from "./8ktwd3rh.js";
 import {
   OkmError2
 } from "./52szzakm.js";

package/dist/shared/{p24x2334.js → v7tpnhnz.js}

@@ -3,7 +3,7 @@ import {
   readHandle,
   readCall,
   attachHttp
-} from "./k34e0xf2.js";
+} from "./kkzwp3d2.js";
 import {
   selectedColumns,
   parseOrder,