@vibeorm/adapter-pg 2.0.0-alpha.9 → 2.0.1

package/dist/index.js

@@ -1,5 +1,6 @@
 // @bun
 // packages/adapter-pg/src/index.ts
+import { VibeError as VibeError5 } from "@vibeorm/schema";
 import pg from "pg";
 
 // packages/adapter-pg/src/errors.ts
@@ -10,6 +11,7 @@ var PG_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"
@@ -69,30 +71,103 @@ class PgArrayParam {
     this.values = values;
   }
 }
+function serializeDate(params) {
+  const { value } = params;
+  const time = value.getTime();
+  if (Number.isNaN(time))
+    return value;
+  const year = value.getUTCFullYear();
+  if (year < 1 || year > 9999)
+    return value;
+  return value.toISOString();
+}
 function isDriverNativeValue(value) {
-  return value === null || value === undefined || typeof value !== "object" || value instanceof Date || ArrayBuffer.isView(value) || value instanceof ArrayBuffer;
+  return value === null || value === undefined || typeof value !== "object" || ArrayBuffer.isView(value) || value instanceof ArrayBuffer;
 }
 function serializeParams(params) {
   return params.values.map((value) => {
     if (value instanceof PgArrayParam)
-      return value.values;
+      return serializeList({ values: value.values });
+    if (value instanceof Date)
+      return serializeDate({ value });
     if (isDriverNativeValue(value))
       return value;
     return JSON.stringify(value);
   });
 }
+function serializeList(params) {
+  const { values } = params;
+  return values.some((value) => value instanceof Date) ? values.map((value) => value instanceof Date ? serializeDate({ value }) : value) : values;
+}
 function serializeParamsRaw(params) {
   return params.values.map((value) => {
     if (value instanceof PgArrayParam)
-      return value.values;
+      return serializeList({ values: value.values });
     if (Array.isArray(value))
-      return value;
+      return serializeList({ values: value });
+    if (value instanceof Date)
+      return serializeDate({ value });
     if (isDriverNativeValue(value))
       return value;
     return JSON.stringify(value);
   });
 }
 
+// packages/adapter-pg/src/pool-config.ts
+import { VibeError as VibeError2 } from "@vibeorm/schema";
+var PLAN_CACHE_MODES = ["auto", "force_custom_plan", "force_generic_plan"];
+function isPlanCacheMode(value) {
+  return typeof value === "string" && PLAN_CACHE_MODES.includes(value);
+}
+function assertPlanCacheMode(params) {
+  const { value } = params;
+  if (isPlanCacheMode(value))
+    return value;
+  throw new VibeError2({
+    code: "VIBE_CONFIG",
+    message: `planCacheMode must be one of ${PLAN_CACHE_MODES.map((mode) => `"${mode}"`).join(", ")}, received ${JSON.stringify(value)}`,
+    meta: { planCacheMode: value, allowed: PLAN_CACHE_MODES }
+  });
+}
+function placePlanCacheMode(params) {
+  const { connectionString, planCacheMode } = params;
+  if (planCacheMode === "auto")
+    return { connectionString, options: undefined };
+  const setting = `-c plan_cache_mode=${planCacheMode}`;
+  if (connectionString === undefined || !URL.canParse(connectionString)) {
+    return { connectionString, options: setting };
+  }
+  const url = new URL(connectionString);
+  const existing = url.searchParams.get("options");
+  if (existing === null) {
+    return { connectionString, options: setting };
+  }
+  if (/(^|\s)-c\s*plan_cache_mode=/.test(existing)) {
+    return { connectionString, options: undefined };
+  }
+  const merged = existing.trim().length === 0 ? setting : `${existing.trim()} ${setting}`;
+  url.searchParams.set("options", merged);
+  return { connectionString: url.toString(), options: merged };
+}
+function buildPoolConfig(params) {
+  const { max, statementTimeout, connectionTimeout } = params;
+  const placement = placePlanCacheMode({
+    connectionString: params.connectionString,
+    planCacheMode: params.planCacheMode ?? "auto"
+  });
+  const config = { connectionString: placement.connectionString, max };
+  if (statementTimeout !== undefined)
+    config.statement_timeout = statementTimeout;
+  if (connectionTimeout !== undefined)
+    config.connectionTimeoutMillis = connectionTimeout;
+  if (placement.options !== undefined)
+    config.options = placement.options;
+  return config;
+}
+
+// packages/adapter-pg/src/savepoint-gate.ts
+import { AsyncLocalStorage } from "async_hooks";
+
 // packages/adapter-pg/src/savepoints.ts
 function createSavepointCounter() {
   return { n: 0 };
@@ -101,26 +176,123 @@ function nextSavepointName(params) {
   return `vibeorm_sp_${params.counter.n++}`;
 }
 
+// packages/adapter-pg/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-pg/src/statement-cache.ts
 function createStatementNameCache(params) {
-  const { max } = params;
+  const max = Math.max(0, params.max);
   const names = new Map;
   let counter = 0;
   return {
     getName(nameParams) {
       const { text } = nameParams;
       const existing = names.get(text);
-      if (existing !== undefined) {
-        names.delete(text);
-        names.set(text, existing);
+      if (existing !== undefined)
         return existing;
-      }
+      if (names.size >= max)
+        return;
       const name = `vibeorm_${counter++}`;
-      if (names.size >= max) {
-        const oldest = names.keys().next().value;
-        if (oldest !== undefined)
-          names.delete(oldest);
-      }
       names.set(text, name);
       return name;
     },
@@ -130,8 +302,127 @@ function createStatementNameCache(params) {
   };
 }
 
+// packages/adapter-pg/src/transaction-budget.ts
+import { VibeError as VibeError3 } 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 VibeError3({
+      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 VibeError3({
+      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 VibeError3({
+      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 VibeError3({
+    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 VibeError3({
+    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 VibeError3({
+    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-pg/src/transaction-sql.ts
-import { VibeError as VibeError2 } from "@vibeorm/schema";
+import { VibeError as VibeError4 } from "@vibeorm/schema";
 var ISOLATION_LEVEL_SQL = Object.freeze({
   ReadCommitted: "READ COMMITTED",
   RepeatableRead: "REPEATABLE READ",
@@ -144,7 +435,7 @@ function beginStatement(params) {
 function statementTimeoutStatement(params) {
   const { timeout } = params;
   if (!Number.isInteger(timeout) || timeout < 0) {
-    throw new VibeError2({
+    throw new VibeError4({
       code: "VIBE_VALIDATION",
       message: `transaction timeout must be a non-negative integer of milliseconds, received ${String(timeout)}`,
       meta: { timeout }
@@ -170,6 +461,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 };
@@ -177,14 +470,17 @@ function refuseNestedTransactionOptions(params) {
     meta.isolationLevel = options.isolationLevel;
   if (options.timeout !== undefined)
     meta.timeout = options.timeout;
-  throw new VibeError2({
+  if (options.deadline !== undefined)
+    meta.deadline = options.deadline;
+  throw new VibeError4({
     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
   });
 }
 
 // packages/adapter-pg/src/index.ts
+var POOL_STATEMENT_NAMES = new WeakMap;
 function guardBackgroundErrors(params) {
   const { client } = params;
   if (typeof client.on !== "function")
@@ -200,9 +496,62 @@ function guardBackgroundErrors(params) {
 var DIALECT = "postgres";
 var PROVIDER = "postgresql";
 var WIRE = Object.freeze({ dateTime: "native", json: "parsed", numbers: "native" });
+var BUDGETS = Object.freeze({
+  acquireTimeout: true,
+  statementTimeout: "all-statements",
+  transactionDeadline: "cancel-running-statements"
+});
+var NUMERIC_ARRAY_OID = 1231;
+var TEXT_ARRAY_OID = 1009;
+var TIMESTAMP_OID = 1114;
+var TIMESTAMP_ARRAY_OID = 1115;
+var DATE_OID = 1082;
+var DATE_ARRAY_OID = 1182;
+var driverTypeParser = pg.types.getTypeParser;
+var ZONE_LESS_TEXT = /^\d{4}-\d{2}-\d{2}(?: \d{2}:\d{2}:\d{2}(?:\.\d{1,6})?)?$/;
+function parseZoneLessAsUtc(value) {
+  if (ZONE_LESS_TEXT.test(value)) {
+    const iso = value.includes(" ") ? `${value.replace(" ", "T").replace(/(\.\d{3})\d+$/, "$1")}Z` : value;
+    const parsed = new Date(iso);
+    if (!Number.isNaN(parsed.getTime()))
+      return parsed;
+  }
+  return driverTypeParser(TIMESTAMP_OID, "text")(value);
+}
+function parseZoneLessArrayAsUtc(value) {
+  const mapElements = (element) => {
+    if (element === null)
+      return null;
+    if (Array.isArray(element))
+      return element.map(mapElements);
+    return parseZoneLessAsUtc(String(element));
+  };
+  return mapElements(driverTypeParser(TEXT_ARRAY_OID, "text")(value));
+}
+var EXACT_TYPES = {
+  getTypeParser(oid, format) {
+    if (format === undefined || format === "text") {
+      if (oid === NUMERIC_ARRAY_OID)
+        return driverTypeParser(TEXT_ARRAY_OID, "text");
+      if (oid === TIMESTAMP_OID || oid === DATE_OID)
+        return parseZoneLessAsUtc;
+      if (oid === TIMESTAMP_ARRAY_OID || oid === DATE_ARRAY_OID)
+        return parseZoneLessArrayAsUtc;
+    }
+    return driverTypeParser(oid, format);
+  }
+};
 function pgAdapter(options) {
   const usePrepared = options?.preparedStatements ?? false;
-  const statementNames = createStatementNameCache({ max: options?.stmtCacheMax ?? 1000 });
+  const stmtCacheMax = options?.stmtCacheMax ?? 1000;
+  const planCacheMode = options?.planCacheMode === undefined ? "auto" : assertPlanCacheMode({ value: options.planCacheMode });
+  if (planCacheMode !== "auto" && options?.pool !== undefined) {
+    throw new VibeError5({
+      code: "VIBE_CONFIG",
+      message: "planCacheMode configures the pool the adapter builds \u2014 it cannot be applied to a caller-supplied `pool`; " + 'set `options: "-c plan_cache_mode=\u2026"` on that pool instead',
+      meta: { planCacheMode }
+    });
+  }
   let pool = null;
   let ownsPool = false;
   let rawSession = null;
@@ -215,25 +564,33 @@ function pgAdapter(options) {
       ownsPool = false;
       return pool;
     }
-    const config = {
+    const config = buildPoolConfig({
       connectionString: options?.connectionString ?? process.env.DATABASE_URL,
-      max: options?.max ?? 10
-    };
-    if (options?.statementTimeout !== undefined) {
-      config.statement_timeout = options.statementTimeout;
-    }
-    if (options?.connectionTimeout !== undefined) {
-      config.connectionTimeoutMillis = options.connectionTimeout;
-    }
+      max: options?.max ?? 10,
+      ...options?.statementTimeout === undefined ? {} : { statementTimeout: options.statementTimeout },
+      ...options?.connectionTimeout === undefined ? {} : { connectionTimeout: options.connectionTimeout },
+      planCacheMode
+    });
     const PoolCtor = pg.Pool;
     pool = new PoolCtor(config);
     pool.on?.("error", () => {});
     ownsPool = true;
     return pool;
   }
+  function statementNamesFor(params) {
+    const existing = POOL_STATEMENT_NAMES.get(params.pool);
+    if (existing !== undefined)
+      return existing;
+    const created = createStatementNameCache({ max: stmtCacheMax });
+    POOL_STATEMENT_NAMES.set(params.pool, created);
+    return created;
+  }
   function buildQueryConfig(params) {
     const values = serializeParams({ values: params.values });
-    return usePrepared ? { name: statementNames.getName({ text: params.text }), text: params.text, values } : { text: params.text, values };
+    if (!usePrepared)
+      return { text: params.text, values, types: EXACT_TYPES };
+    const name = statementNamesFor({ pool: getPool() }).getName({ text: params.text });
+    return name === undefined ? { text: params.text, values, types: EXACT_TYPES } : { name, text: params.text, values, types: EXACT_TYPES };
   }
   async function runExecute(params) {
     const config = buildQueryConfig({ text: params.text, values: params.values });
@@ -242,35 +599,46 @@ function pgAdapter(options) {
   }
   async function runExecuteUnsafe(params) {
     const values = params.values === undefined ? undefined : serializeParamsRaw({ values: params.values });
-    const result = await runMapped(() => params.queryable.query({ text: params.text, values }));
+    const result = await runMapped(() => params.queryable.query({ text: params.text, values, types: EXACT_TYPES }));
     return { rows: result.rows, affectedRows: result.rowCount ?? 0 };
   }
   function createClientAdapter(params) {
-    const { client, savepointCounter } = params;
+    const { client, scope, budget } = params;
+    async function applyEngineBudget() {
+      const ms = engineStatementBudgetMs({ budget });
+      if (ms === null)
+        return;
+      await runMapped(() => client.query({ text: statementTimeoutStatement({ timeout: ms }) }));
+    }
     return {
       dialect: DIALECT,
       provider: PROVIDER,
       wire: WIRE,
+      budgets: BUDGETS,
       async execute(execParams) {
+        const turn = scopeTurn({ scope });
+        if (turn !== undefined)
+          await turn;
+        budget.assertUsable({ stage: "statement" });
+        await applyEngineBudget();
         return runExecute({ queryable: client, ...execParams });
       },
       async executeUnsafe(execParams) {
+        const turn = scopeTurn({ scope });
+        if (turn !== undefined)
+          await turn;
+        budget.assertUsable({ stage: "statement" });
+        await applyEngineBudget();
         return runExecuteUnsafe({ queryable: client, ...execParams });
       },
       async transaction(fn, nestedOptions) {
         refuseNestedTransactionOptions({ options: nestedOptions, provider: PROVIDER });
-        const savepoint = nextSavepointName({ counter: savepointCounter });
-        await runMapped(() => client.query({ text: `SAVEPOINT ${savepoint}` }));
-        try {
-          const result = await fn(createClientAdapter({ client, savepointCounter }));
-          await runMapped(() => client.query({ text: `RELEASE SAVEPOINT ${savepoint}` }));
-          return result;
-        } catch (error) {
-          try {
-            await client.query({ text: `ROLLBACK TO SAVEPOINT ${savepoint}` });
-          } catch {}
-          throw error;
-        }
+        budget.assertUsable({ stage: "nested" });
+        return runNestedSavepoint({
+          scope,
+          execute: (statement) => runMapped(() => client.query({ text: statement })),
+          body: (child) => fn(createClientAdapter({ client, scope: child, budget }))
+        });
       },
       async connect() {},
       async disconnect() {},
@@ -283,6 +651,7 @@ function pgAdapter(options) {
     dialect: DIALECT,
     provider: PROVIDER,
     wire: WIRE,
+    budgets: BUDGETS,
     async execute(params) {
       return runExecute({ queryable: getPool(), ...params });
     },
@@ -320,26 +689,49 @@ function pgAdapter(options) {
       return runExecuteUnsafe({ queryable: getPool(), ...params });
     },
     async transaction(fn, transactionOptions) {
+      validateTransactionDeadline({
+        options: transactionOptions,
+        support: BUDGETS.transactionDeadline,
+        provider: PROVIDER
+      });
       const client = await runMapped(() => getPool().connect());
       const unguard = guardBackgroundErrors({ client });
-      const savepointCounter = createSavepointCounter();
+      const scope = createSavepointScope();
+      const budget = startTransactionBudget({ options: transactionOptions, provider: PROVIDER });
+      let discard = false;
       try {
         await runMapped(() => client.query({ text: beginStatement({ isolationLevel: transactionOptions?.isolationLevel }) }));
         if (transactionOptions?.timeout !== undefined) {
           const text = statementTimeoutStatement({ timeout: transactionOptions.timeout });
           await runMapped(() => client.query({ text }));
         }
-        const result = await fn(createClientAdapter({ client, savepointCounter }));
+        const result = await runRootScope({
+          scope,
+          body: () => fn(createClientAdapter({ client, scope, budget }))
+        });
+        budget.assertUsable({ stage: "commit" });
         await runMapped(() => client.query({ text: "COMMIT" }));
+        budget.close({ outcome: "committed" });
         return result;
       } catch (error) {
         try {
           await client.query({ text: "ROLLBACK" });
-        } catch {}
+          budget.close({ outcome: "rolled-back" });
+        } catch {
+          discard = true;
+          budget.close({ outcome: "unknown" });
+          if (budget.totalMs !== null && isTransactionDeadlineError(error)) {
+            throw transactionOutcomeUnknownError({
+              provider: PROVIDER,
+              totalMs: budget.totalMs,
+              cause: error
+            });
+          }
+        }
         throw error;
       } finally {
         unguard();
-        client.release();
+        client.release(discard);
       }
     },
     async connect() {
@@ -370,22 +762,32 @@ function pgAdapter(options) {
   };
 }
 export {
+  validateTransactionDeadline,
+  transactionOutcomeUnknownError,
+  transactionDeadlineError,
+  transactionClosedError,
   statementTimeoutStatement,
+  startTransactionBudget,
   serializeParamsRaw,
   serializeParams,
   refuseNestedTransactionOptions,
+  placePlanCacheMode,
   pgErrorSqlstate,
   pgAdapter,
   nextSavepointName,
   mapPgDriverError,
+  isTransactionDeadlineError,
+  engineStatementBudgetMs,
   createStatementNameCache,
   createSavepointCounter,
   classifyRawTransactionControl,
+  buildPoolConfig,
   beginStatement,
   PgArrayParam,
   PG_SQLSTATE_REASONS,
   PG_SQLSTATE_ERROR_CODES,
-  ISOLATION_LEVEL_SQL
+  ISOLATION_LEVEL_SQL,
+  DEFAULT_DEADLINE_CLOCK
 };
 
-//# debugId=E27D9260C6E4F42764756E2164756E21
+//# debugId=ABBE5E12E130DBA764756E2164756E21