@vibeorm/adapter-bun 2.0.0-alpha.8 → 2.0.0

package/dist/index.js

@@ -1,6 +1,7 @@
 // @bun
 // packages/adapter-bun/src/index.ts
 var {SQL } = globalThis.Bun;
+import { postgresDialect, renderDiagnostic } from "@vibeorm/sql";
 
 // packages/adapter-bun/src/connection-url.ts
 import { VibeError } from "@vibeorm/schema";
@@ -35,6 +36,7 @@ var BUN_SQLSTATE_ERROR_CODES = Object.freeze({
   "23502": "VIBE_VALIDATION",
   "23514": "VIBE_VALIDATION",
   "22P02": "VIBE_VALIDATION",
+  "42501": "VIBE_PERMISSION_DENIED",
   "40001": "VIBE_TRANSACTION",
   "40P01": "VIBE_TRANSACTION",
   "57014": "VIBE_TRANSACTION"
@@ -131,6 +133,128 @@ function serializeParamsRaw(params) {
   return params.values.map((value) => Array.isArray(value) ? toPgArrayLiteral(value) : value);
 }
 
+// packages/adapter-bun/src/transaction-budget.ts
+import { VibeError as VibeError4 } from "@vibeorm/schema";
+var DEFAULT_DEADLINE_CLOCK = () => Date.now();
+function validateTransactionDeadline(params) {
+  const { options, support, provider } = params;
+  const deadline = options?.deadline;
+  if (deadline === undefined)
+    return;
+  if (support === "unsupported") {
+    throw new VibeError4({
+      code: "VIBE_UNSUPPORTED_CAPABILITY",
+      message: `${provider} cannot enforce a transaction deadline \u2014 remove the \`deadline\` option`,
+      meta: { provider, feature: "transactionDeadline", supported: support }
+    });
+  }
+  if (!Number.isInteger(deadline.totalMs) || deadline.totalMs <= 0) {
+    throw new VibeError4({
+      code: "VIBE_VALIDATION",
+      message: `transaction deadline \`totalMs\` must be a positive integer of milliseconds, received ${String(deadline.totalMs)}`,
+      meta: { provider, feature: "transactionDeadline", totalMs: deadline.totalMs }
+    });
+  }
+  const requested = deadline.enforcement ?? "between-statements";
+  if (requested === "cancel-running-statements" && support !== "cancel-running-statements") {
+    throw new VibeError4({
+      code: "VIBE_UNSUPPORTED_CAPABILITY",
+      message: `${provider} cannot cancel a statement that is already running, so the requested ` + "`cancel-running-statements` deadline guarantee is refused rather than silently downgraded \u2014 " + 'ask for "between-statements" if a budget checked between statements is enough',
+      meta: { provider, feature: "transactionDeadline", requested, supported: support }
+    });
+  }
+}
+function startTransactionBudget(params) {
+  const { options, provider } = params;
+  const clock = params.clock ?? DEFAULT_DEADLINE_CLOCK;
+  const deadline = options?.deadline;
+  const totalMs = deadline === undefined ? null : deadline.totalMs;
+  const enforcement = deadline === undefined ? null : deadline.enforcement ?? "between-statements";
+  const expiresAt = totalMs === null ? null : clock() + totalMs;
+  let outcome = null;
+  const budget = {
+    enforcement,
+    totalMs,
+    statementTimeoutMs: options?.timeout ?? null,
+    remainingMs() {
+      return expiresAt === null ? null : Math.max(0, expiresAt - clock());
+    },
+    expired() {
+      return expiresAt !== null && clock() >= expiresAt;
+    },
+    assertUsable(assertParams) {
+      if (outcome !== null) {
+        throw transactionClosedError({ provider, outcome, stage: assertParams.stage });
+      }
+      if (expiresAt !== null && clock() >= expiresAt) {
+        throw transactionDeadlineError({
+          provider,
+          stage: assertParams.stage,
+          totalMs,
+          overdueMs: clock() - expiresAt
+        });
+      }
+    },
+    close(closeParams) {
+      if (outcome === null)
+        outcome = closeParams.outcome;
+    },
+    get outcome() {
+      return outcome;
+    }
+  };
+  return budget;
+}
+function engineStatementBudgetMs(params) {
+  const { budget } = params;
+  if (budget.enforcement !== "cancel-running-statements")
+    return null;
+  const remaining = budget.remainingMs();
+  if (remaining === null)
+    return null;
+  const totalBound = Math.max(1, Math.ceil(remaining));
+  return budget.statementTimeoutMs !== null && budget.statementTimeoutMs > 0 ? Math.min(totalBound, budget.statementTimeoutMs) : totalBound;
+}
+function transactionDeadlineError(params) {
+  const { provider, stage, totalMs, overdueMs } = params;
+  const what = stage === "commit" ? "the transaction was rolled back instead of committed" : "the statement was never sent and the transaction is being rolled back";
+  return new VibeError4({
+    code: "VIBE_TRANSACTION",
+    message: `transaction deadline of ${totalMs} ms expired ${Math.max(0, Math.round(overdueMs))} ms ago \u2014 ${what}. ` + "Nothing is retried automatically: work the callback did outside the database may already have happened.",
+    meta: { provider, reason: "transaction-deadline", stage, totalMs, overdueMs: Math.max(0, Math.round(overdueMs)) }
+  });
+}
+function transactionClosedError(params) {
+  const { provider, outcome, stage } = params;
+  return new VibeError4({
+    code: "VIBE_TRANSACTION",
+    message: `this transaction has already finished (${outcome}), so its client can no longer be used \u2014 ` + "a handle kept past the end of `$transaction` would run outside the transaction, on a connection " + "that now belongs to someone else",
+    meta: { provider, reason: "transaction-closed", outcome, stage }
+  });
+}
+function transactionOutcomeUnknownError(params) {
+  const { provider, totalMs, cause } = params;
+  return new VibeError4({
+    code: "VIBE_TRANSACTION",
+    message: `transaction deadline of ${totalMs} ms expired and the rollback that should have cleaned up failed \u2014 ` + "the commit state of this transaction is UNKNOWN. It is not retried automatically; inspect the data " + "before deciding.",
+    meta: {
+      provider,
+      reason: "transaction-outcome-unknown",
+      outcome: "unknown",
+      totalMs,
+      rollbackFailed: true
+    },
+    cause
+  });
+}
+function isTransactionDeadlineError(error) {
+  const reason = error?.meta?.reason;
+  return reason === "transaction-deadline";
+}
+
+// packages/adapter-bun/src/savepoint-gate.ts
+import { AsyncLocalStorage } from "async_hooks";
+
 // packages/adapter-bun/src/savepoints.ts
 function createSavepointCounter() {
   return { n: 0 };
@@ -139,9 +263,224 @@ function nextSavepointName(params) {
   return `vibeorm_sp_${params.counter.n++}`;
 }
 
+// packages/adapter-bun/src/savepoint-gate.ts
+var CURRENT = new AsyncLocalStorage;
+function createSavepointScope() {
+  return { depth: 0, state: { counter: createSavepointCounter(), open: null } };
+}
+function runRootScope(params) {
+  return CURRENT.run(params.scope, params.body);
+}
+function scopeTurn(params) {
+  const open = params.scope.state.open;
+  if (mayProceed({ scope: params.scope, open }))
+    return;
+  return waitForTurn({ scope: params.scope });
+}
+async function runNestedSavepoint(params) {
+  const { scope, execute, body } = params;
+  const node = await acquire({ scope });
+  try {
+    if (execute !== undefined)
+      await execute(`SAVEPOINT ${node.name}`);
+    let result;
+    try {
+      result = await CURRENT.run(node.scope, () => body(node.scope));
+    } catch (error) {
+      await drainDescendants({ node });
+      if (execute !== undefined) {
+        try {
+          await execute(`ROLLBACK TO SAVEPOINT ${node.name}`);
+        } catch {}
+      }
+      throw error;
+    }
+    await drainDescendants({ node });
+    if (execute !== undefined)
+      await execute(`RELEASE SAVEPOINT ${node.name}`);
+    return result;
+  } finally {
+    closeNode({ node });
+  }
+}
+function mayProceed(params) {
+  const { scope, open } = params;
+  if (open === null)
+    return true;
+  if (open.scope === scope)
+    return true;
+  if (open.scope.depth < scope.depth)
+    return true;
+  return CURRENT.getStore() === open.scope;
+}
+async function waitForTurn(params) {
+  for (;; ) {
+    const open = params.scope.state.open;
+    if (open === null || mayProceed({ scope: params.scope, open }))
+      return;
+    await open.settled;
+  }
+}
+async function acquire(params) {
+  const { scope } = params;
+  for (;; ) {
+    const open = scope.state.open;
+    if (mayProceed({ scope, open }))
+      return pushNode({ scope, parent: open });
+    await open.settled;
+  }
+}
+function pushNode(params) {
+  const { scope, parent } = params;
+  const state = scope.state;
+  let settle = () => {
+    return;
+  };
+  const settled = new Promise((resolve) => {
+    settle = () => resolve();
+  });
+  const node = {
+    scope: { depth: (parent === null ? 0 : parent.scope.depth) + 1, state },
+    name: nextSavepointName({ counter: state.counter }),
+    parent,
+    settled,
+    settle
+  };
+  state.open = node;
+  return node;
+}
+function closeNode(params) {
+  const { node } = params;
+  const state = node.scope.state;
+  if (state.open === node)
+    state.open = node.parent;
+  node.settle();
+}
+async function drainDescendants(params) {
+  const state = params.node.scope.state;
+  for (;; ) {
+    const open = state.open;
+    if (open === null || open === params.node || open.scope.depth <= params.node.scope.depth)
+      return;
+    await open.settled;
+  }
+}
+
 // packages/adapter-bun/src/template-cache.ts
+import { VibeError as VibeError5 } from "@vibeorm/schema";
+function isIdentChar(char) {
+  if (char === undefined)
+    return false;
+  return /[A-Za-z0-9_]/.test(char);
+}
+function skipQuoted(text, start, quote) {
+  const escaping = quote === "'" && (text[start - 1] === "e" || text[start - 1] === "E") && !isIdentChar(text[start - 2]);
+  let index = start + 1;
+  while (index < text.length) {
+    const char = text[index];
+    if (escaping && char === "\\") {
+      index += 2;
+      continue;
+    }
+    if (char === quote) {
+      if (text[index + 1] === quote) {
+        index += 2;
+        continue;
+      }
+      return index + 1;
+    }
+    index += 1;
+  }
+  return text.length;
+}
+function skipBlockComment(text, start) {
+  let depth = 0;
+  let index = start;
+  while (index < text.length) {
+    if (text[index] === "/" && text[index + 1] === "*") {
+      depth += 1;
+      index += 2;
+      continue;
+    }
+    if (text[index] === "*" && text[index + 1] === "/") {
+      depth -= 1;
+      index += 2;
+      if (depth === 0)
+        return index;
+      continue;
+    }
+    index += 1;
+  }
+  return text.length;
+}
+function skipDollarQuoted(text, start) {
+  const opener = /^\$(?:[A-Za-z_][A-Za-z0-9_]*)?\$/.exec(text.slice(start));
+  if (opener === null)
+    return -1;
+  const tag = opener[0];
+  const close = text.indexOf(tag, start + tag.length);
+  return close === -1 ? text.length : close + tag.length;
+}
+function scanPlaceholders(params) {
+  const { text } = params;
+  const chunks = [];
+  const indices = [];
+  let chunkStart = 0;
+  let index = 0;
+  while (index < text.length) {
+    const char = text[index];
+    if (char === "'" || char === '"') {
+      index = skipQuoted(text, index, char);
+      continue;
+    }
+    if (char === "-" && text[index + 1] === "-") {
+      const newline = text.indexOf(`
+`, index);
+      index = newline === -1 ? text.length : newline + 1;
+      continue;
+    }
+    if (char === "/" && text[index + 1] === "*") {
+      index = skipBlockComment(text, index);
+      continue;
+    }
+    if (char === "$") {
+      const dollarEnd = skipDollarQuoted(text, index);
+      if (dollarEnd !== -1) {
+        index = dollarEnd;
+        continue;
+      }
+      let digits = index + 1;
+      while (digits < text.length && text[digits] !== undefined && /[0-9]/.test(text[digits]))
+        digits += 1;
+      if (digits > index + 1) {
+        chunks.push(text.slice(chunkStart, index));
+        indices.push(Number(text.slice(index + 1, digits)));
+        chunkStart = digits;
+        index = digits;
+        continue;
+      }
+    }
+    index += 1;
+  }
+  chunks.push(text.slice(chunkStart));
+  const template = Object.assign(chunks, { raw: chunks });
+  return { template, indices };
+}
 function templateChunks(params) {
-  return params.text.split(/\$\d+/);
+  return [...scanPlaceholders(params).template];
+}
+function bindTemplateValues(params) {
+  const { text, indices, values } = params;
+  return indices.map((placeholder) => {
+    if (placeholder < 1 || placeholder > values.length) {
+      throw new VibeError5({
+        code: "VIBE_VALIDATION",
+        message: `bun:sql prepared statement references $${placeholder} but only ${values.length} parameter(s) were given`,
+        meta: { text, placeholder, provided: values.length }
+      });
+    }
+    return values[placeholder - 1];
+  });
 }
 function createTemplateCache(params) {
   const { max } = params;
@@ -155,15 +494,14 @@ function createTemplateCache(params) {
         templates.set(text, existing);
         return existing;
       }
-      const chunks = templateChunks({ text });
-      const template = Object.assign(chunks, { raw: chunks });
+      const prepared = scanPlaceholders({ text });
       if (templates.size >= max) {
         const oldest = templates.keys().next().value;
         if (oldest !== undefined)
           templates.delete(oldest);
       }
-      templates.set(text, template);
-      return template;
+      templates.set(text, prepared);
+      return prepared;
     },
     size() {
       return templates.size;
@@ -172,7 +510,7 @@ function createTemplateCache(params) {
 }
 
 // packages/adapter-bun/src/transaction-sql.ts
-import { VibeError as VibeError4 } from "@vibeorm/schema";
+import { VibeError as VibeError6 } from "@vibeorm/schema";
 var ISOLATION_LEVEL_SQL = Object.freeze({
   ReadCommitted: "READ COMMITTED",
   RepeatableRead: "REPEATABLE READ",
@@ -185,7 +523,7 @@ function beginStatement(params) {
 function statementTimeoutStatement(params) {
   const { timeout } = params;
   if (!Number.isInteger(timeout) || timeout < 0) {
-    throw new VibeError4({
+    throw new VibeError6({
       code: "VIBE_VALIDATION",
       message: `transaction timeout must be a non-negative integer of milliseconds, received ${String(timeout)}`,
       meta: { timeout }
@@ -211,6 +549,8 @@ function refuseNestedTransactionOptions(params) {
     passed.push("isolationLevel");
   if (options.timeout !== undefined)
     passed.push("timeout");
+  if (options.deadline !== undefined)
+    passed.push("deadline");
   if (passed.length === 0)
     return;
   const meta = { provider, nested: true };
@@ -218,9 +558,11 @@ function refuseNestedTransactionOptions(params) {
     meta.isolationLevel = options.isolationLevel;
   if (options.timeout !== undefined)
     meta.timeout = options.timeout;
-  throw new VibeError4({
+  if (options.deadline !== undefined)
+    meta.deadline = options.deadline;
+  throw new VibeError6({
     code: "VIBE_VALIDATION",
-    message: `nested transactions run as savepoints and cannot honor ${passed.join(" or ")} \u2014 a savepoint cannot change the isolation level of the transaction it joins, and a nested timeout is not enforceable; pass options on the top-level $transaction`,
+    message: `nested transactions run as savepoints and cannot honor ${passed.join(" or ")} \u2014 a savepoint cannot change the isolation level of the transaction it joins, a nested timeout is not enforceable, and a nested deadline would need its own session setting on a connection it does not own (it inherits the top-level one instead); pass options on the top-level $transaction`,
     meta
   });
 }
@@ -236,10 +578,19 @@ class CallbackError extends Error {
 }
 var DIALECT = "postgres";
 var PROVIDER = "postgresql";
-var WIRE = Object.freeze({ dateTime: "native", json: "text", numbers: "native" });
+var BUDGETS = Object.freeze({
+  acquireTimeout: true,
+  statementTimeout: "all-statements",
+  transactionDeadline: "cancel-running-statements"
+});
+var WIRE_TEXT = Object.freeze({ dateTime: "native", json: "text", numbers: "native" });
+var WIRE_PARSED = Object.freeze({ dateTime: "native", json: "parsed", numbers: "native" });
 function bunAdapter(options) {
   const usePrepared = options?.preparedStatements ?? false;
   const templates = createTemplateCache({ max: options?.stmtCacheMax ?? 1000 });
+  let activeWire = WIRE_TEXT;
+  let wireSettled = false;
+  let wireProbe = null;
   let instance = null;
   let rawSession = null;
   function getSql() {
@@ -258,11 +609,27 @@ function bunAdapter(options) {
     instance = url === undefined ? new SQL(sqlOptions) : new SQL(url, sqlOptions);
     return instance;
   }
+  async function probeJsonWire(source) {
+    const probe = renderDiagnostic({ dialect: postgresDialect, query: "postgresJsonWire" });
+    try {
+      const rows = usePrepared ? await source(templates.getTemplate({ text: probe.text }).template) : await source.unsafe(probe.text, []);
+      const probed = rows[0]?.probe;
+      if (typeof probed === "object" && probed !== null)
+        activeWire = WIRE_PARSED;
+    } catch {} finally {
+      wireSettled = true;
+    }
+  }
   async function runExecute(params) {
+    if (!wireSettled) {
+      wireProbe ??= probeJsonWire(params.source);
+      await wireProbe;
+    }
     const values = serializeParams({ values: params.values });
     if (usePrepared) {
-      const template = templates.getTemplate({ text: params.text });
-      return runMapped(() => params.source(template, ...values));
+      const prepared = templates.getTemplate({ text: params.text });
+      const bound = bindTemplateValues({ text: params.text, indices: prepared.indices, values });
+      return runMapped(() => params.source(prepared.template, ...bound));
     }
     return runMapped(() => params.source.unsafe(params.text, values));
   }
@@ -272,61 +639,79 @@ function bunAdapter(options) {
     return { rows, affectedRows: readAffectedRows({ rows }) };
   }
   function createAdapter(params) {
-    const { source, parentMode, savepointCounter } = params;
+    const { source, parentMode, scope, budget } = params;
+    async function applyEngineBudget() {
+      if (budget === undefined)
+        return;
+      const ms = engineStatementBudgetMs({ budget });
+      if (ms === null)
+        return;
+      await runMapped(() => source.unsafe(statementTimeoutStatement({ timeout: ms })));
+    }
     async function transactionViaSavepoint(fn, nestedOptions) {
       refuseNestedTransactionOptions({ options: nestedOptions, provider: PROVIDER });
+      budget?.assertUsable({ stage: "nested" });
       const transactional = source;
-      if (typeof transactional.savepoint === "function") {
-        try {
-          return await transactional.savepoint(async (savepointSql) => {
-            const nested = createAdapter({
-              source: savepointSql,
-              parentMode: "tx",
-              savepointCounter
-            });
+      const driverSavepoint = transactional.savepoint?.bind(transactional);
+      if (driverSavepoint !== undefined) {
+        return runNestedSavepoint({
+          scope,
+          body: async (child) => {
             try {
-              return await fn(nested);
+              return await driverSavepoint(async (savepointSql) => {
+                const nested = createAdapter({
+                  source: savepointSql,
+                  parentMode: "tx",
+                  scope: child
+                });
+                try {
+                  return await fn(nested);
+                } catch (error) {
+                  throw new CallbackError(error);
+                }
+              });
             } catch (error) {
-              throw new CallbackError(error);
+              if (error instanceof CallbackError)
+                throw error.inner;
+              throw mapBunDriverError({ error });
             }
-          });
-        } catch (error) {
-          if (error instanceof CallbackError)
-            throw error.inner;
-          throw mapBunDriverError({ error });
-        }
-      }
-      const savepoint = nextSavepointName({ counter: savepointCounter });
-      await runMapped(() => transactional.unsafe(`SAVEPOINT ${savepoint}`));
-      try {
-        const nested = createAdapter({ source: transactional, parentMode: "tx", savepointCounter });
-        const result = await fn(nested);
-        await runMapped(() => transactional.unsafe(`RELEASE SAVEPOINT ${savepoint}`));
-        return result;
-      } catch (error) {
-        try {
-          await transactional.unsafe(`ROLLBACK TO SAVEPOINT ${savepoint}`);
-        } catch {}
-        throw error;
+          }
+        });
       }
+      return runNestedSavepoint({
+        scope,
+        execute: (statement) => runMapped(() => transactional.unsafe(statement)),
+        body: (child) => fn(createAdapter({ source: transactional, parentMode: "tx", scope: child, budget }))
+      });
     }
     async function transactionViaPool(fn, transactionOptions) {
       const pool = source;
-      if (transactionOptions?.isolationLevel === undefined && transactionOptions?.timeout === undefined) {
+      validateTransactionDeadline({
+        options: transactionOptions,
+        support: BUDGETS.transactionDeadline,
+        provider: PROVIDER
+      });
+      if (transactionOptions?.isolationLevel === undefined && transactionOptions?.timeout === undefined && transactionOptions?.deadline === undefined) {
+        const budget3 = startTransactionBudget({ provider: PROVIDER });
         try {
-          return await pool.begin(async (txSql) => {
+          const result = await pool.begin(async (txSql) => {
+            const txScope = createSavepointScope();
             const txAdapter = createAdapter({
               source: txSql,
               parentMode: "tx",
-              savepointCounter: createSavepointCounter()
+              scope: txScope,
+              budget: budget3
             });
             try {
-              return await fn(txAdapter);
+              return await runRootScope({ scope: txScope, body: () => fn(txAdapter) });
             } catch (error) {
               throw new CallbackError(error);
             }
           });
+          budget3.close({ outcome: "committed" });
+          return result;
         } catch (error) {
+          budget3.close({ outcome: "rolled-back" });
           if (error instanceof CallbackError)
             throw error.inner;
           throw mapBunDriverError({ error });
@@ -334,22 +719,37 @@ function bunAdapter(options) {
       }
       const timeoutText = transactionOptions.timeout === undefined ? undefined : statementTimeoutStatement({ timeout: transactionOptions.timeout });
       const reserved = await runMapped(() => pool.reserve());
+      const budget2 = startTransactionBudget({ options: transactionOptions, provider: PROVIDER });
       try {
         await runMapped(() => reserved.unsafe(beginStatement({ isolationLevel: transactionOptions.isolationLevel })));
         if (timeoutText !== undefined)
           await runMapped(() => reserved.unsafe(timeoutText));
+        const txScope = createSavepointScope();
         const txAdapter = createAdapter({
           source: reserved,
           parentMode: "tx",
-          savepointCounter: createSavepointCounter()
+          scope: txScope,
+          budget: budget2
         });
-        const result = await fn(txAdapter);
+        const result = await runRootScope({ scope: txScope, body: () => fn(txAdapter) });
+        budget2.assertUsable({ stage: "commit" });
         await runMapped(() => reserved.unsafe("COMMIT"));
+        budget2.close({ outcome: "committed" });
         return result;
       } catch (error) {
         try {
           await reserved.unsafe("ROLLBACK");
-        } catch {}
+          budget2.close({ outcome: "rolled-back" });
+        } catch {
+          budget2.close({ outcome: "unknown" });
+          if (budget2.totalMs !== null && isTransactionDeadlineError(error)) {
+            throw transactionOutcomeUnknownError({
+              provider: PROVIDER,
+              totalMs: budget2.totalMs,
+              cause: error
+            });
+          }
+        }
         throw error;
       } finally {
         reserved.release();
@@ -358,11 +758,24 @@ function bunAdapter(options) {
     return {
       dialect: DIALECT,
       provider: PROVIDER,
-      wire: WIRE,
+      budgets: BUDGETS,
+      get wire() {
+        return activeWire;
+      },
       async execute(execParams) {
+        const turn = scopeTurn({ scope });
+        if (turn !== undefined)
+          await turn;
+        budget?.assertUsable({ stage: "statement" });
+        await applyEngineBudget();
         return runExecute({ source, ...execParams });
       },
       async executeUnsafe(execParams) {
+        const turn = scopeTurn({ scope });
+        if (turn !== undefined)
+          await turn;
+        budget?.assertUsable({ stage: "statement" });
+        await applyEngineBudget();
         return runExecuteUnsafe({ source, ...execParams });
       },
       async transaction(fn, transactionOptions) {
@@ -389,13 +802,16 @@ function bunAdapter(options) {
     return createAdapter({
       source: getSql(),
       parentMode: "pool",
-      savepointCounter: createSavepointCounter()
+      scope: createSavepointScope()
     });
   }
   return {
     dialect: DIALECT,
     provider: PROVIDER,
-    wire: WIRE,
+    budgets: BUDGETS,
+    get wire() {
+      return activeWire;
+    },
     async execute(params) {
       return poolAdapter().execute(params);
     },
@@ -461,14 +877,21 @@ function readAffectedRows(params) {
   return rows.length;
 }
 export {
+  validateTransactionDeadline,
+  transactionOutcomeUnknownError,
+  transactionDeadlineError,
+  transactionClosedError,
   toPgArrayLiteral,
   templateChunks,
   statementTimeoutStatement,
+  startTransactionBudget,
   serializeParamsRaw,
   serializeParams,
   refuseNestedTransactionOptions,
   nextSavepointName,
   mapBunDriverError,
+  isTransactionDeadlineError,
+  engineStatementBudgetMs,
   createTemplateCache,
   createSavepointCounter,
   classifyRawTransactionControl,
@@ -478,8 +901,9 @@ export {
   beginStatement,
   applyStartupOptions,
   ISOLATION_LEVEL_SQL,
+  DEFAULT_DEADLINE_CLOCK,
   BUN_SQLSTATE_REASONS,
   BUN_SQLSTATE_ERROR_CODES
 };
 
-//# debugId=08E3C28E82D7C93A64756E2164756E21
+//# debugId=81824F43B962EC8264756E2164756E21