@prisma/client-engine-runtime 6.4.0-dev.52 → 6.4.0-integration-renovate-configure.1

package/dist/index.js

@@ -1,10 +1,4 @@
-"use strict";
-var __create = Object.create;
 var __defProp = Object.defineProperty;
-var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
-var __getOwnPropNames = Object.getOwnPropertyNames;
-var __getProtoOf = Object.getPrototypeOf;
-var __hasOwnProp = Object.prototype.hasOwnProperty;
 var __typeError = (msg) => {
   throw TypeError(msg);
 };
@@ -12,46 +6,28 @@ var __export = (target, all) => {
   for (var name in all)
     __defProp(target, name, { get: all[name], enumerable: true });
 };
-var __copyProps = (to, from, except, desc) => {
-  if (from && typeof from === "object" || typeof from === "function") {
-    for (let key of __getOwnPropNames(from))
-      if (!__hasOwnProp.call(to, key) && key !== except)
-        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
-  }
-  return to;
-};
-var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
-  // If the importer is in node compatibility mode or this is not an ESM
-  // file that has been converted to a CommonJS file using a Babel-
-  // compatible transform (i.e. "__esModule" has not been set), then set
-  // "default" to the CommonJS "module.exports" for node compatibility.
-  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
-  mod
-));
-var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
 var __accessCheck = (obj, member, msg) => member.has(obj) || __typeError("Cannot " + msg);
 var __privateGet = (obj, member, getter) => (__accessCheck(obj, member, "read from private field"), getter ? getter.call(obj) : member.get(obj));
 var __privateAdd = (obj, member, value) => member.has(obj) ? __typeError("Cannot add the same private member more than once") : member instanceof WeakSet ? member.add(obj) : member.set(obj, value);
 var __privateSet = (obj, member, value, setter) => (__accessCheck(obj, member, "write to private field"), setter ? setter.call(obj, value) : member.set(obj, value), value);
 var __privateMethod = (obj, member, method) => (__accessCheck(obj, member, "access private method"), method);
 
-// src/index.ts
-var index_exports = {};
-__export(index_exports, {
-  IsolationLevel: () => IsolationLevel,
-  QueryInterpreter: () => QueryInterpreter,
-  TransactionManager: () => TransactionManager,
-  TransactionManagerError: () => TransactionManagerError,
-  isPrismaValuePlaceholder: () => isPrismaValuePlaceholder
-});
-module.exports = __toCommonJS(index_exports);
+// src/runtime/core/engines/common/types/Transaction.ts
+var IsolationLevel = /* @__PURE__ */ ((IsolationLevel2) => {
+  IsolationLevel2["ReadUncommitted"] = "ReadUncommitted";
+  IsolationLevel2["ReadCommitted"] = "ReadCommitted";
+  IsolationLevel2["RepeatableRead"] = "RepeatableRead";
+  IsolationLevel2["Snapshot"] = "Snapshot";
+  IsolationLevel2["Serializable"] = "Serializable";
+  return IsolationLevel2;
+})(IsolationLevel || {});
 
-// src/QueryPlan.ts
+// src/runtime/core/engines/client/QueryPlan.ts
 function isPrismaValuePlaceholder(value) {
   return typeof value === "object" && value !== null && value["prisma__type"] === "param";
 }
 
-// src/interpreter/renderQueryTemplate.ts
+// src/runtime/core/engines/client/interpreter/renderQueryTemplate.ts
 var BEGIN_REPEAT = "/* prisma-comma-repeatable-start */";
 var END_REPEAT = "/* prisma-comma-repeatable-end */";
 function renderQueryTemplate({
@@ -149,7 +125,7 @@ function renderQueryTemplate({
   };
 }
 
-// src/interpreter/renderQuery.ts
+// src/runtime/core/engines/client/interpreter/renderQuery.ts
 function renderQuery({ query, params }, scope) {
   const substitutedParams = params.map((param) => {
     if (!isPrismaValuePlaceholder(param)) {
@@ -211,7 +187,7 @@ function placeholderTypeToArgType(type) {
   return mappedType;
 }
 
-// src/interpreter/serialize.ts
+// src/runtime/core/engines/client/interpreter/serializer.ts
 function serialize(resultSet) {
   return resultSet.rows.map(
     (row) => row.reduce((acc, value, index) => {
@@ -233,7 +209,7 @@ function serialize(resultSet) {
   );
 }
 
-// src/interpreter/QueryInterpreter.ts
+// src/runtime/core/engines/client/interpreter/QueryInterpreter.ts
 var _queryable, _placeholderValues, _onQuery, _QueryInterpreter_instances, withQueryEvent_fn;
 var QueryInterpreter = class {
   constructor({ queryable, placeholderValues, onQuery }) {
@@ -367,7 +343,16 @@ withQueryEvent_fn = async function(query, execute) {
     timestamp,
     duration: endInstant - startInstant,
     query: query.sql,
-    params: query.args
+    // TODO: we should probably change the interface to contain a proper array in the next major version.
+    params: JSON.stringify(query.args),
+    // TODO: this field only exists for historical reasons as we grandfathered it from the time
+    // when we emitted `tracing` events to stdout in the engine unchanged, and then described
+    // them in the public API as TS types. Thus this field used to contain the name of the Rust
+    // module in which an event originated. When using library engine, which uses a different
+    // mechanism with a JavaScript callback for logs, it's normally just an empty string instead.
+    // This field is definitely not useful and should be removed from the public types (but it's
+    // technically a breaking change, even if a tiny and inconsequential one).
+    target: "QueryInterpreter"
   });
   return result;
 };
@@ -427,80 +412,292 @@ function childRecordMatchesParent(childRecord, parentRecord, joinExpr) {
   return true;
 }
 
-// src/transactionManager/Transaction.ts
-var IsolationLevel = /* @__PURE__ */ ((IsolationLevel2) => {
-  IsolationLevel2["ReadUncommitted"] = "ReadUncommitted";
-  IsolationLevel2["ReadCommitted"] = "ReadCommitted";
-  IsolationLevel2["RepeatableRead"] = "RepeatableRead";
-  IsolationLevel2["Snapshot"] = "Snapshot";
-  IsolationLevel2["Serializable"] = "Serializable";
-  return IsolationLevel2;
-})(IsolationLevel || {});
+// ../../node_modules/.pnpm/kleur@4.1.5/node_modules/kleur/colors.mjs
+var colors_exports = {};
+__export(colors_exports, {
+  $: () => $,
+  bgBlack: () => bgBlack,
+  bgBlue: () => bgBlue,
+  bgCyan: () => bgCyan,
+  bgGreen: () => bgGreen,
+  bgMagenta: () => bgMagenta,
+  bgRed: () => bgRed,
+  bgWhite: () => bgWhite,
+  bgYellow: () => bgYellow,
+  black: () => black,
+  blue: () => blue,
+  bold: () => bold,
+  cyan: () => cyan,
+  dim: () => dim,
+  gray: () => gray,
+  green: () => green,
+  grey: () => grey,
+  hidden: () => hidden,
+  inverse: () => inverse,
+  italic: () => italic,
+  magenta: () => magenta,
+  red: () => red,
+  reset: () => reset,
+  strikethrough: () => strikethrough,
+  underline: () => underline,
+  white: () => white,
+  yellow: () => yellow
+});
+var FORCE_COLOR;
+var NODE_DISABLE_COLORS;
+var NO_COLOR;
+var TERM;
+var isTTY = true;
+if (typeof process !== "undefined") {
+  ({ FORCE_COLOR, NODE_DISABLE_COLORS, NO_COLOR, TERM } = process.env || {});
+  isTTY = process.stdout && process.stdout.isTTY;
+}
+var $ = {
+  enabled: !NODE_DISABLE_COLORS && NO_COLOR == null && TERM !== "dumb" && (FORCE_COLOR != null && FORCE_COLOR !== "0" || isTTY)
+};
+function init(x, y) {
+  let rgx = new RegExp(`\\x1b\\[${y}m`, "g");
+  let open = `\x1B[${x}m`, close = `\x1B[${y}m`;
+  return function(txt) {
+    if (!$.enabled || txt == null) return txt;
+    return open + (!!~("" + txt).indexOf(close) ? txt.replace(rgx, close + open) : txt) + close;
+  };
+}
+var reset = init(0, 0);
+var bold = init(1, 22);
+var dim = init(2, 22);
+var italic = init(3, 23);
+var underline = init(4, 24);
+var inverse = init(7, 27);
+var hidden = init(8, 28);
+var strikethrough = init(9, 29);
+var black = init(30, 39);
+var red = init(31, 39);
+var green = init(32, 39);
+var yellow = init(33, 39);
+var blue = init(34, 39);
+var magenta = init(35, 39);
+var cyan = init(36, 39);
+var white = init(37, 39);
+var gray = init(90, 39);
+var grey = init(90, 39);
+var bgBlack = init(40, 49);
+var bgRed = init(41, 49);
+var bgGreen = init(42, 49);
+var bgYellow = init(43, 49);
+var bgBlue = init(44, 49);
+var bgMagenta = init(45, 49);
+var bgCyan = init(46, 49);
+var bgWhite = init(47, 49);
+
+// ../debug/src/index.ts
+var MAX_ARGS_HISTORY = 100;
+var COLORS = ["green", "yellow", "blue", "magenta", "cyan", "red"];
+var argsHistory = [];
+var lastTimestamp = Date.now();
+var lastColor = 0;
+var processEnv = typeof process !== "undefined" ? process.env : {};
+globalThis.DEBUG ??= processEnv.DEBUG ?? "";
+globalThis.DEBUG_COLORS ??= processEnv.DEBUG_COLORS ? processEnv.DEBUG_COLORS === "true" : true;
+var topProps = {
+  enable(namespace) {
+    if (typeof namespace === "string") {
+      globalThis.DEBUG = namespace;
+    }
+  },
+  disable() {
+    const prev = globalThis.DEBUG;
+    globalThis.DEBUG = "";
+    return prev;
+  },
+  // this is the core logic to check if logging should happen or not
+  enabled(namespace) {
+    const listenedNamespaces = globalThis.DEBUG.split(",").map((s) => {
+      return s.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    });
+    const isListened = listenedNamespaces.some((listenedNamespace) => {
+      if (listenedNamespace === "" || listenedNamespace[0] === "-") return false;
+      return namespace.match(RegExp(listenedNamespace.split("*").join(".*") + "$"));
+    });
+    const isExcluded = listenedNamespaces.some((listenedNamespace) => {
+      if (listenedNamespace === "" || listenedNamespace[0] !== "-") return false;
+      return namespace.match(RegExp(listenedNamespace.slice(1).split("*").join(".*") + "$"));
+    });
+    return isListened && !isExcluded;
+  },
+  log: (...args) => {
+    const [namespace, format, ...rest] = args;
+    const logWithFormatting = console.warn ?? console.log;
+    logWithFormatting(`${namespace} ${format}`, ...rest);
+  },
+  formatters: {}
+  // not implemented
+};
+function debugCreate(namespace) {
+  const instanceProps = {
+    color: COLORS[lastColor++ % COLORS.length],
+    enabled: topProps.enabled(namespace),
+    namespace,
+    log: topProps.log,
+    extend: () => {
+    }
+    // not implemented
+  };
+  const debugCall = (...args) => {
+    const { enabled, namespace: namespace2, color, log } = instanceProps;
+    if (args.length !== 0) {
+      argsHistory.push([namespace2, ...args]);
+    }
+    if (argsHistory.length > MAX_ARGS_HISTORY) {
+      argsHistory.shift();
+    }
+    if (topProps.enabled(namespace2) || enabled) {
+      const stringArgs = args.map((arg) => {
+        if (typeof arg === "string") {
+          return arg;
+        }
+        return safeStringify(arg);
+      });
+      const ms = `+${Date.now() - lastTimestamp}ms`;
+      lastTimestamp = Date.now();
+      if (globalThis.DEBUG_COLORS) {
+        log(colors_exports[color](bold(namespace2)), ...stringArgs, colors_exports[color](ms));
+      } else {
+        log(namespace2, ...stringArgs, ms);
+      }
+    }
+  };
+  return new Proxy(debugCall, {
+    get: (_, prop) => instanceProps[prop],
+    set: (_, prop, value) => instanceProps[prop] = value
+  });
+}
+var Debug = new Proxy(debugCreate, {
+  get: (_, prop) => topProps[prop],
+  set: (_, prop, value) => topProps[prop] = value
+});
+function safeStringify(value, indent = 2) {
+  const cache = /* @__PURE__ */ new Set();
+  return JSON.stringify(
+    value,
+    (key, value2) => {
+      if (typeof value2 === "object" && value2 !== null) {
+        if (cache.has(value2)) {
+          return `[Circular *]`;
+        }
+        cache.add(value2);
+      } else if (typeof value2 === "bigint") {
+        return value2.toString();
+      }
+      return value2;
+    },
+    indent
+  );
+}
+var src_default = Debug;
 
-// src/transactionManager/TransactionManager.ts
-var import_node_crypto = __toESM(require("node:crypto"));
-var import_debug = __toESM(require("@prisma/debug"));
+// ../internals/src/utils/assertNever.ts
+function assertNever(arg, errorMessage) {
+  throw new Error(errorMessage);
+}
 
-// src/utils.ts
-function assertNever(_, message) {
-  throw new Error(message);
+// ../internals/src/utils/setClassName.ts
+function setClassName(classObject, name) {
+  Object.defineProperty(classObject, "name", {
+    value: name,
+    configurable: true
+  });
 }
 
-// src/transactionManager/TransactionManagerErrors.ts
-var TransactionManagerError = class extends Error {
-  constructor(message, meta) {
-    super("Transaction API error: " + message);
+// src/runtime/core/engines/client/transactionManager/TransactionManager.ts
+import crypto from "crypto";
+
+// src/runtime/core/errors/PrismaClientKnownRequestError.ts
+var PrismaClientKnownRequestError = class extends Error {
+  constructor(message, { code, clientVersion, meta, batchRequestIdx }) {
+    super(message);
+    this.name = "PrismaClientKnownRequestError";
+    this.code = code;
+    this.clientVersion = clientVersion;
     this.meta = meta;
-    this.code = "P2028";
+    Object.defineProperty(this, "batchRequestIdx", {
+      value: batchRequestIdx,
+      enumerable: false,
+      writable: true
+    });
+  }
+  get [Symbol.toStringTag]() {
+    return "PrismaClientKnownRequestError";
+  }
+};
+setClassName(PrismaClientKnownRequestError, "PrismaClientKnownRequestError");
+
+// src/runtime/core/engines/client/transactionManager/TransactionManagerErrors.ts
+var TransactionManagerError = class extends PrismaClientKnownRequestError {
+  constructor(message, {
+    clientVersion,
+    meta
+  }) {
+    super("Transaction API error: " + message, {
+      code: "P2028",
+      clientVersion,
+      meta
+    });
   }
 };
 var TransactionDriverAdapterError = class extends TransactionManagerError {
   constructor(message, errorParams) {
-    super(`Error from Driver Adapter: ${message}`, { ...errorParams.driverAdapterError });
+    super(`Error from Driver Adapter: ${message}`, {
+      clientVersion: errorParams.clientVersion,
+      meta: {
+        ...errorParams.driverAdapterError
+      }
+    });
   }
 };
 var TransactionNotFoundError = class extends TransactionManagerError {
-  constructor() {
+  constructor(errorParams) {
     super(
-      "Transaction not found. Transaction ID is invalid, refers to an old closed transaction Prisma doesn't have information about anymore, or was obtained before disconnecting."
+      "Transaction not found. Transaction ID is invalid, refers to an old closed transaction Prisma doesn't have information about anymore, or was obtained before disconnecting.",
+      errorParams
     );
   }
 };
 var TransactionClosedError = class extends TransactionManagerError {
-  constructor(operation) {
-    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`);
+  constructor(operation, errorParams) {
+    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`, errorParams);
   }
 };
 var TransactionRolledBackError = class extends TransactionManagerError {
-  constructor(operation) {
-    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`);
+  constructor(operation, errorParams) {
+    super(`Transaction already closed: A ${operation} cannot be executed on a committed transaction`, errorParams);
   }
 };
 var TransactionStartTimoutError = class extends TransactionManagerError {
-  constructor() {
-    super("Unable to start a transaction in the given time.");
+  constructor(errorParams) {
+    super("Unable to start a transaction in the given time.", errorParams);
   }
 };
 var TransactionExecutionTimeoutError = class extends TransactionManagerError {
-  constructor(operation, { timeout, timeTaken }) {
+  constructor(operation, { clientVersion, timeout, timeTaken }) {
     super(
       `A ${operation} cannot be executed on an expired transaction. The timeout for this transaction was ${timeout} ms, however ${timeTaken} ms passed since the start of the transaction. Consider increasing the interactive transaction timeout or doing less work in the transaction`,
-      { operation, timeout, timeTaken }
+      { clientVersion }
     );
   }
 };
 var TransactionInternalConsistencyError = class extends TransactionManagerError {
-  constructor(message) {
-    super(`Internal Consistency Error: ${message}`);
+  constructor(message, errorParams) {
+    super(`Internal Consistency Error: ${message}`, errorParams);
   }
 };
 var InvalidTransactionIsolationLevelError = class extends TransactionManagerError {
-  constructor(isolationLevel) {
-    super(`Invalid isolation level: ${isolationLevel}`, { isolationLevel });
+  constructor(isolationLevel, errorParams) {
+    super(`Invalid isolation level: ${isolationLevel}`, errorParams);
   }
 };
 
-// src/transactionManager/TransactionManager.ts
+// src/runtime/core/engines/client/transactionManager/TransactionManager.ts
 var MAX_CLOSED_TRANSACTIONS = 100;
 var isolationLevelMap = {
   ReadUncommitted: "READ UNCOMMITTED",
@@ -509,7 +706,7 @@ var isolationLevelMap = {
   Snapshot: "SNAPSHOT",
   Serializable: "SERIALIZABLE"
 };
-var debug = (0, import_debug.default)("prisma:client:transactionManager");
+var debug = src_default("prisma:client:transactionManager");
 var COMMIT_QUERY = () => ({ sql: "COMMIT", args: [], argTypes: [] });
 var ROLLBACK_QUERY = () => ({ sql: "ROLLBACK", args: [], argTypes: [] });
 var ISOLATION_LEVEL_QUERY = (isolationLevel) => ({
@@ -518,18 +715,19 @@ var ISOLATION_LEVEL_QUERY = (isolationLevel) => ({
   argTypes: []
 });
 var TransactionManager = class {
-  constructor({ driverAdapter }) {
+  constructor({ driverAdapter, clientVersion }) {
     // The map of active transactions.
     this.transactions = /* @__PURE__ */ new Map();
     // List of last closed transactions. Max MAX_CLOSED_TRANSACTIONS entries.
     // Used to provide better error messages than a generic "transaction not found".
     this.closedTransactions = [];
     this.driverAdapter = driverAdapter;
+    this.clientVersion = clientVersion;
   }
   async startTransaction(options) {
     const validatedOptions = this.validateOptions(options);
     const transaction = {
-      id: import_node_crypto.default.randomUUID(),
+      id: crypto.randomUUID(),
       status: "waiting",
       timer: void 0,
       timeout: validatedOptions.timeout,
@@ -541,7 +739,8 @@ var TransactionManager = class {
     const txContext = await this.driverAdapter.transactionContext();
     if (!txContext.ok)
       throw new TransactionDriverAdapterError("Failed to start transaction.", {
-        driverAdapterError: txContext.error
+        driverAdapterError: txContext.error,
+        clientVersion: this.clientVersion
       });
     if (this.requiresSettingIsolationLevelFirst() && validatedOptions.isolationLevel) {
       await txContext.value.executeRaw(ISOLATION_LEVEL_QUERY(validatedOptions.isolationLevel));
@@ -549,7 +748,8 @@ var TransactionManager = class {
     const startedTransaction = await txContext.value.startTransaction();
     if (!startedTransaction.ok)
       throw new TransactionDriverAdapterError("Failed to start transaction.", {
-        driverAdapterError: startedTransaction.error
+        driverAdapterError: startedTransaction.error,
+        clientVersion: this.clientVersion
       });
     if (!startedTransaction.value.options.usePhantomQuery) {
       await startedTransaction.value.executeRaw({ sql: "BEGIN", args: [], argTypes: [] });
@@ -564,14 +764,17 @@ var TransactionManager = class {
         transaction.timer = void 0;
         transaction.status = "running";
         transaction.timer = this.startTransactionTimeout(transaction.id, validatedOptions.timeout);
-        return { id: transaction.id };
+        return { id: transaction.id, payload: void 0 };
       case "timed_out":
-        throw new TransactionStartTimoutError();
+        throw new TransactionStartTimoutError({ clientVersion: this.clientVersion });
       case "running":
       case "committed":
       case "rolled_back":
         throw new TransactionInternalConsistencyError(
-          `Transaction in invalid state ${transaction.status} although it just finished startup.`
+          `Transaction in invalid state ${transaction.status} although it just finished startup.`,
+          {
+            clientVersion: this.clientVersion
+          }
         );
       default:
         assertNever(transaction.status, "Unknown transaction status.");
@@ -587,7 +790,7 @@ var TransactionManager = class {
   }
   getTransaction(txInfo, operation) {
     const tx = this.getActiveTransaction(txInfo.id, operation);
-    if (!tx.transaction) throw new TransactionNotFoundError();
+    if (!tx.transaction) throw new TransactionNotFoundError({ clientVersion: this.clientVersion });
     return tx.transaction;
   }
   getActiveTransaction(transactionId, operation) {
@@ -599,24 +802,29 @@ var TransactionManager = class {
         switch (closedTransaction.status) {
           case "waiting":
           case "running":
-            throw new TransactionInternalConsistencyError("Active transaction found in closed transactions list.");
+            throw new TransactionInternalConsistencyError("Active transaction found in closed transactions list.", {
+              clientVersion: this.clientVersion
+            });
           case "committed":
-            throw new TransactionClosedError(operation);
+            throw new TransactionClosedError(operation, { clientVersion: this.clientVersion });
           case "rolled_back":
-            throw new TransactionRolledBackError(operation);
+            throw new TransactionRolledBackError(operation, { clientVersion: this.clientVersion });
           case "timed_out":
             throw new TransactionExecutionTimeoutError(operation, {
               timeout: closedTransaction.timeout,
-              timeTaken: Date.now() - closedTransaction.startedAt
+              timeTaken: Date.now() - closedTransaction.startedAt,
+              clientVersion: this.clientVersion
             });
         }
       } else {
         debug(`Transaction not found.`, transactionId);
-        throw new TransactionNotFoundError();
+        throw new TransactionNotFoundError({ clientVersion: this.clientVersion });
       }
     }
     if (["committed", "rolled_back", "timed_out"].includes(transaction.status)) {
-      throw new TransactionInternalConsistencyError("Closed transaction found in active transactions map.");
+      throw new TransactionInternalConsistencyError("Closed transaction found in active transactions map.", {
+        clientVersion: this.clientVersion
+      });
     }
     return transaction;
   }
@@ -642,7 +850,8 @@ var TransactionManager = class {
       const result = await tx.transaction.commit();
       if (!result.ok)
         throw new TransactionDriverAdapterError("Failed to commit transaction.", {
-          driverAdapterError: result.error
+          driverAdapterError: result.error,
+          clientVersion: this.clientVersion
         });
       if (!tx.transaction.options.usePhantomQuery) {
         await tx.transaction.executeRaw(COMMIT_QUERY());
@@ -651,7 +860,8 @@ var TransactionManager = class {
       const result = await tx.transaction.rollback();
       if (!result.ok)
         throw new TransactionDriverAdapterError("Failed to rollback transaction.", {
-          driverAdapterError: result.error
+          driverAdapterError: result.error,
+          clientVersion: this.clientVersion
         });
       if (!tx.transaction.options.usePhantomQuery) {
         await tx.transaction.executeRaw(ROLLBACK_QUERY());
@@ -666,12 +876,14 @@ var TransactionManager = class {
     }
   }
   validateOptions(options) {
-    if (!options.timeout) throw new TransactionManagerError("timeout is required");
-    if (!options.maxWait) throw new TransactionManagerError("maxWait is required");
+    if (!options.timeout)
+      throw new TransactionManagerError("timeout is required", { clientVersion: this.clientVersion });
+    if (!options.maxWait)
+      throw new TransactionManagerError("maxWait is required", { clientVersion: this.clientVersion });
     if (options.isolationLevel === "Snapshot" /* Snapshot */)
-      throw new InvalidTransactionIsolationLevelError(options.isolationLevel);
+      throw new InvalidTransactionIsolationLevelError(options.isolationLevel, { clientVersion: this.clientVersion });
     if (this.driverAdapter.provider === "sqlite" && options.isolationLevel && options.isolationLevel !== "Serializable" /* Serializable */)
-      throw new InvalidTransactionIsolationLevelError(options.isolationLevel);
+      throw new InvalidTransactionIsolationLevelError(options.isolationLevel, { clientVersion: this.clientVersion });
     return {
       ...options,
       timeout: options.timeout,
@@ -682,11 +894,9 @@ var TransactionManager = class {
     return this.driverAdapter.provider === "mysql";
   }
 };
-// Annotate the CommonJS export names for ESM import in node:
-0 && (module.exports = {
+export {
   IsolationLevel,
   QueryInterpreter,
   TransactionManager,
-  TransactionManagerError,
   isPrismaValuePlaceholder
-});
+};

package/package.json

@@ -1,45 +1,23 @@
 {
   "name": "@prisma/client-engine-runtime",
-  "version": "6.4.0-dev.52",
+  "version": "6.4.0-integration-renovate-configure.1",
   "description": "This package is intended for Prisma's internal use",
+  "type": "module",
   "main": "dist/index.js",
-  "module": "dist/index.mjs",
   "types": "dist/index.d.ts",
-  "exports": {
-    ".": {
-      "require": {
-        "types": "./dist/index.d.ts",
-        "default": "./dist/index.js"
-      },
-      "import": {
-        "types": "./dist/index.d.mts",
-        "default": "./dist/index.mjs"
-      }
-    }
-  },
   "repository": {
     "type": "git",
     "url": "https://github.com/prisma/prisma.git",
     "directory": "packages/accelerate-contract"
   },
   "license": "Apache-2.0",
-  "dependencies": {
-    "@prisma/debug": "6.4.0-dev.52",
-    "@prisma/driver-adapter-utils": "6.4.0-dev.52"
-  },
-  "devDependencies": {
-    "@types/jest": "29.5.14",
-    "@types/node": "18.19.31",
-    "jest": "29.7.0",
-    "jest-junit": "16.0.0"
-  },
+  "dependencies": {},
   "files": [
     "dist"
   ],
   "sideEffects": false,
   "scripts": {
     "dev": "DEV=true tsx helpers/build.ts",
-    "build": "tsx helpers/build.ts",
-    "test": "jest"
+    "build": "tsx helpers/build.ts"
   }
 }