@prisma/client-generator-js 7.2.0-integration-engines-7-2-0-3-aqrln-zpupkzknszlw-04d61c41ec1a025cabe14093fa3121a5f45040ab.1 → 7.3.0-integration-fix-6-19-0-cloudflare-accelerate-engine.1

package/dist/index.js

@@ -62,7 +62,7 @@ var require_universalify = __commonJS({
 var require_polyfills = __commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js"(exports2, module2) {
     "use strict";
-    var constants = require("constants");
+    var constants3 = require("constants");
     var origCwd = process.cwd;
     var cwd = null;
     var platform = process.env.GRACEFUL_FS_PLATFORM || process.platform;
@@ -86,7 +86,7 @@ var require_polyfills = __commonJS({
     var chdir;
     module2.exports = patch;
     function patch(fs3) {
-      if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
+      if (constants3.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
         patchLchmod(fs3);
       }
       if (!fs3.lutimes) {
@@ -111,14 +111,14 @@ var require_polyfills = __commonJS({
       fs3.fstatSync = statFixSync(fs3.fstatSync);
       fs3.lstatSync = statFixSync(fs3.lstatSync);
       if (fs3.chmod && !fs3.lchmod) {
-        fs3.lchmod = function(path5, mode, cb) {
+        fs3.lchmod = function(path9, mode, cb) {
           if (cb) process.nextTick(cb);
         };
         fs3.lchmodSync = function() {
         };
       }
       if (fs3.chown && !fs3.lchown) {
-        fs3.lchown = function(path5, uid, gid, cb) {
+        fs3.lchown = function(path9, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
         fs3.lchownSync = function() {
@@ -185,10 +185,10 @@ var require_polyfills = __commonJS({
         };
       }(fs3.readSync);
       function patchLchmod(fs4) {
-        fs4.lchmod = function(path5, mode, callback) {
+        fs4.lchmod = function(path9, mode, callback) {
           fs4.open(
-            path5,
-            constants.O_WRONLY | constants.O_SYMLINK,
+            path9,
+            constants3.O_WRONLY | constants3.O_SYMLINK,
             mode,
             function(err, fd) {
               if (err) {
@@ -203,8 +203,8 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs4.lchmodSync = function(path5, mode) {
-          var fd = fs4.openSync(path5, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs4.lchmodSync = function(path9, mode) {
+          var fd = fs4.openSync(path9, constants3.O_WRONLY | constants3.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
@@ -224,9 +224,9 @@ var require_polyfills = __commonJS({
         };
       }
       function patchLutimes(fs4) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs4.futimes) {
-          fs4.lutimes = function(path5, at, mt, cb) {
-            fs4.open(path5, constants.O_SYMLINK, function(er, fd) {
+        if (constants3.hasOwnProperty("O_SYMLINK") && fs4.futimes) {
+          fs4.lutimes = function(path9, at, mt, cb) {
+            fs4.open(path9, constants3.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
@@ -238,8 +238,8 @@ var require_polyfills = __commonJS({
               });
             });
           };
-          fs4.lutimesSync = function(path5, at, mt) {
-            var fd = fs4.openSync(path5, constants.O_SYMLINK);
+          fs4.lutimesSync = function(path9, at, mt) {
+            var fd = fs4.openSync(path9, constants3.O_SYMLINK);
             var ret;
             var threw = true;
             try {
@@ -358,11 +358,11 @@ var require_legacy_streams = __commonJS({
         ReadStream,
         WriteStream
       };
-      function ReadStream(path5, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path5, options);
+      function ReadStream(path9, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path9, options);
         Stream.call(this);
         var self = this;
-        this.path = path5;
+        this.path = path9;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -407,10 +407,10 @@ var require_legacy_streams = __commonJS({
           self._read();
         });
       }
-      function WriteStream(path5, options) {
-        if (!(this instanceof WriteStream)) return new WriteStream(path5, options);
+      function WriteStream(path9, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path9, options);
         Stream.call(this);
-        this.path = path5;
+        this.path = path9;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -485,7 +485,7 @@ var require_graceful_fs = __commonJS({
       gracefulQueue = "___graceful-fs.queue";
       previousSymbol = "___graceful-fs.previous";
     }
-    function noop() {
+    function noop2() {
     }
     function publishQueue(context, queue2) {
       Object.defineProperty(context, gracefulQueue, {
@@ -494,11 +494,11 @@ var require_graceful_fs = __commonJS({
         }
       });
     }
-    var debug2 = noop;
+    var debug4 = noop2;
     if (util.debuglog)
-      debug2 = util.debuglog("gfs4");
+      debug4 = util.debuglog("gfs4");
     else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
-      debug2 = function() {
+      debug4 = function() {
         var m = util.format.apply(util, arguments);
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
@@ -533,7 +533,7 @@ var require_graceful_fs = __commonJS({
       }(fs3.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug2(fs3[gracefulQueue]);
+          debug4(fs3[gracefulQueue]);
           require("assert").equal(fs3[gracefulQueue].length, 0);
         });
       }
@@ -550,18 +550,18 @@ var require_graceful_fs = __commonJS({
     function patch(fs4) {
       polyfills(fs4);
       fs4.gracefulify = patch;
-      fs4.createReadStream = createReadStream;
-      fs4.createWriteStream = createWriteStream;
+      fs4.createReadStream = createReadStream2;
+      fs4.createWriteStream = createWriteStream2;
       var fs$readFile = fs4.readFile;
       fs4.readFile = readFile;
-      function readFile(path5, options, cb) {
+      function readFile(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path5, options, cb);
-        function go$readFile(path6, options2, cb2, startTime) {
-          return fs$readFile(path6, options2, function(err) {
+        return go$readFile(path9, options, cb);
+        function go$readFile(path10, options2, cb2, startTime) {
+          return fs$readFile(path10, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path6, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path10, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -571,14 +571,14 @@ var require_graceful_fs = __commonJS({
       }
       var fs$writeFile = fs4.writeFile;
       fs4.writeFile = writeFile;
-      function writeFile(path5, data, options, cb) {
+      function writeFile(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path5, data, options, cb);
-        function go$writeFile(path6, data2, options2, cb2, startTime) {
-          return fs$writeFile(path6, data2, options2, function(err) {
+        return go$writeFile(path9, data, options, cb);
+        function go$writeFile(path10, data2, options2, cb2, startTime) {
+          return fs$writeFile(path10, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path10, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -589,14 +589,14 @@ var require_graceful_fs = __commonJS({
       var fs$appendFile = fs4.appendFile;
       if (fs$appendFile)
         fs4.appendFile = appendFile;
-      function appendFile(path5, data, options, cb) {
+      function appendFile(path9, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path5, data, options, cb);
-        function go$appendFile(path6, data2, options2, cb2, startTime) {
-          return fs$appendFile(path6, data2, options2, function(err) {
+        return go$appendFile(path9, data, options, cb);
+        function go$appendFile(path10, data2, options2, cb2, startTime) {
+          return fs$appendFile(path10, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path6, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path10, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -627,31 +627,31 @@ var require_graceful_fs = __commonJS({
       var fs$readdir = fs4.readdir;
       fs4.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path5, options, cb) {
+      function readdir(path9, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path6, options2, cb2, startTime) {
-          return fs$readdir(path6, fs$readdirCallback(
-            path6,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path10, options2, cb2, startTime) {
+          return fs$readdir(path10, fs$readdirCallback(
+            path10,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path6, options2, cb2, startTime) {
-          return fs$readdir(path6, options2, fs$readdirCallback(
-            path6,
+        } : function go$readdir2(path10, options2, cb2, startTime) {
+          return fs$readdir(path10, options2, fs$readdirCallback(
+            path10,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path5, options, cb);
-        function fs$readdirCallback(path6, options2, cb2, startTime) {
+        return go$readdir(path9, options, cb);
+        function fs$readdirCallback(path10, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path6, options2, cb2],
+                [path10, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -722,7 +722,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path5, options) {
+      function ReadStream(path9, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -742,7 +742,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path5, options) {
+      function WriteStream(path9, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -760,22 +760,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path5, options) {
-        return new fs4.ReadStream(path5, options);
+      function createReadStream2(path9, options) {
+        return new fs4.ReadStream(path9, options);
       }
-      function createWriteStream(path5, options) {
-        return new fs4.WriteStream(path5, options);
+      function createWriteStream2(path9, options) {
+        return new fs4.WriteStream(path9, options);
       }
       var fs$open = fs4.open;
       fs4.open = open;
-      function open(path5, flags, mode, cb) {
+      function open(path9, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path5, flags, mode, cb);
-        function go$open(path6, flags2, mode2, cb2, startTime) {
-          return fs$open(path6, flags2, mode2, function(err, fd) {
+        return go$open(path9, flags, mode, cb);
+        function go$open(path10, flags2, mode2, cb2, startTime) {
+          return fs$open(path10, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path6, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path10, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -786,7 +786,7 @@ var require_graceful_fs = __commonJS({
       return fs4;
     }
     function enqueue(elem) {
-      debug2("ENQUEUE", elem[0].name, elem[1]);
+      debug4("ENQUEUE", elem[0].name, elem[1]);
       fs3[gracefulQueue].push(elem);
       retry();
     }
@@ -813,10 +813,10 @@ var require_graceful_fs = __commonJS({
       var startTime = elem[3];
       var lastTime = elem[4];
       if (startTime === void 0) {
-        debug2("RETRY", fn.name, args);
+        debug4("RETRY", fn.name, args);
         fn.apply(null, args);
       } else if (Date.now() - startTime >= 6e4) {
-        debug2("TIMEOUT", fn.name, args);
+        debug4("TIMEOUT", fn.name, args);
         var cb = args.pop();
         if (typeof cb === "function")
           cb.call(null, err);
@@ -825,7 +825,7 @@ var require_graceful_fs = __commonJS({
         var sinceStart = Math.max(lastTime - startTime, 1);
         var desiredDelay = Math.min(sinceStart * 1.2, 100);
         if (sinceAttempt >= desiredDelay) {
-          debug2("RETRY", fn.name, args);
+          debug4("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
           fs3[gracefulQueue].push(elem);
@@ -958,10 +958,10 @@ var require_fs = __commonJS({
 var require_utils = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/mkdirs/utils.js"(exports2, module2) {
     "use strict";
-    var path5 = require("path");
+    var path9 = require("path");
     module2.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path5.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path9.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
           const error = new Error(`Path contains invalid characters: ${pth}`);
           error.code = "EINVAL";
@@ -1025,8 +1025,8 @@ var require_path_exists = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var fs3 = require_fs();
-    function pathExists(path5) {
-      return fs3.access(path5).then(() => true).catch(() => false);
+    function pathExists(path9) {
+      return fs3.access(path9).then(() => true).catch(() => false);
     }
     module2.exports = {
       pathExists: u(pathExists),
@@ -1041,8 +1041,8 @@ var require_utimes = __commonJS({
     "use strict";
     var fs3 = require_fs();
     var u = require_universalify().fromPromise;
-    async function utimesMillis(path5, atime, mtime) {
-      const fd = await fs3.open(path5, "r+");
+    async function utimesMillis(path9, atime, mtime) {
+      const fd = await fs3.open(path9, "r+");
       let closeErr = null;
       try {
         await fs3.futimes(fd, atime, mtime);
@@ -1057,8 +1057,8 @@ var require_utimes = __commonJS({
         throw closeErr;
       }
     }
-    function utimesMillisSync(path5, atime, mtime) {
-      const fd = fs3.openSync(path5, "r+");
+    function utimesMillisSync(path9, atime, mtime) {
+      const fd = fs3.openSync(path9, "r+");
       fs3.futimesSync(fd, atime, mtime);
       return fs3.closeSync(fd);
     }
@@ -1074,7 +1074,7 @@ var require_stat = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/util/stat.js"(exports2, module2) {
     "use strict";
     var fs3 = require_fs();
-    var path5 = require("path");
+    var path9 = require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
       const statFunc = opts.dereference ? (file4) => fs3.stat(file4, { bigint: true }) : (file4) => fs3.lstat(file4, { bigint: true });
@@ -1102,8 +1102,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = await getStats(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path5.basename(src);
-          const destBaseName = path5.basename(dest);
+          const srcBaseName = path9.basename(src);
+          const destBaseName = path9.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -1125,8 +1125,8 @@ var require_stat = __commonJS({
       const { srcStat, destStat } = getStatsSync(src, dest, opts);
       if (destStat) {
         if (areIdentical(srcStat, destStat)) {
-          const srcBaseName = path5.basename(src);
-          const destBaseName = path5.basename(dest);
+          const srcBaseName = path9.basename(src);
+          const destBaseName = path9.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -1145,9 +1145,9 @@ var require_stat = __commonJS({
       return { srcStat, destStat };
     }
     async function checkParentPaths(src, srcStat, dest, funcName) {
-      const srcParent = path5.resolve(path5.dirname(src));
-      const destParent = path5.resolve(path5.dirname(dest));
-      if (destParent === srcParent || destParent === path5.parse(destParent).root) return;
+      const srcParent = path9.resolve(path9.dirname(src));
+      const destParent = path9.resolve(path9.dirname(dest));
+      if (destParent === srcParent || destParent === path9.parse(destParent).root) return;
       let destStat;
       try {
         destStat = await fs3.stat(destParent, { bigint: true });
@@ -1161,9 +1161,9 @@ var require_stat = __commonJS({
       return checkParentPaths(src, srcStat, destParent, funcName);
     }
     function checkParentPathsSync(src, srcStat, dest, funcName) {
-      const srcParent = path5.resolve(path5.dirname(src));
-      const destParent = path5.resolve(path5.dirname(dest));
-      if (destParent === srcParent || destParent === path5.parse(destParent).root) return;
+      const srcParent = path9.resolve(path9.dirname(src));
+      const destParent = path9.resolve(path9.dirname(dest));
+      if (destParent === srcParent || destParent === path9.parse(destParent).root) return;
       let destStat;
       try {
         destStat = fs3.statSync(destParent, { bigint: true });
@@ -1180,8 +1180,8 @@ var require_stat = __commonJS({
       return destStat.ino && destStat.dev && destStat.ino === srcStat.ino && destStat.dev === srcStat.dev;
     }
     function isSrcSubdir(src, dest) {
-      const srcArr = path5.resolve(src).split(path5.sep).filter((i) => i);
-      const destArr = path5.resolve(dest).split(path5.sep).filter((i) => i);
+      const srcArr = path9.resolve(src).split(path9.sep).filter((i) => i);
+      const destArr = path9.resolve(dest).split(path9.sep).filter((i) => i);
       return srcArr.every((cur, i) => destArr[i] === cur);
     }
     function errMsg(src, dest, funcName) {
@@ -1206,7 +1206,7 @@ var require_copy = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/copy/copy.js"(exports2, module2) {
     "use strict";
     var fs3 = require_fs();
-    var path5 = require("path");
+    var path9 = require("path");
     var { mkdirs } = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { utimesMillis } = require_utimes();
@@ -1228,7 +1228,7 @@ var require_copy = __commonJS({
       await stat.checkParentPaths(src, srcStat, dest, "copy");
       const include = await runFilter(src, dest, opts);
       if (!include) return;
-      const destParent = path5.dirname(dest);
+      const destParent = path9.dirname(dest);
       const dirExists = await pathExists(destParent);
       if (!dirExists) {
         await mkdirs(destParent);
@@ -1282,8 +1282,8 @@ var require_copy = __commonJS({
       }
       const promises = [];
       for await (const item of await fs3.opendir(src)) {
-        const srcItem = path5.join(src, item.name);
-        const destItem = path5.join(dest, item.name);
+        const srcItem = path9.join(src, item.name);
+        const destItem = path9.join(dest, item.name);
         promises.push(
           runFilter(srcItem, destItem, opts).then((include) => {
             if (include) {
@@ -1302,7 +1302,7 @@ var require_copy = __commonJS({
     async function onLink(destStat, src, dest, opts) {
       let resolvedSrc = await fs3.readlink(src);
       if (opts.dereference) {
-        resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path9.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
         return fs3.symlink(resolvedSrc, dest);
@@ -1315,7 +1315,7 @@ var require_copy = __commonJS({
         throw e;
       }
       if (opts.dereference) {
-        resolvedDest = path5.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path9.resolve(process.cwd(), resolvedDest);
       }
       if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
         throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -1335,7 +1335,7 @@ var require_copy_sync = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/copy/copy-sync.js"(exports2, module2) {
     "use strict";
     var fs3 = require_graceful_fs();
-    var path5 = require("path");
+    var path9 = require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat = require_stat();
@@ -1356,7 +1356,7 @@ var require_copy_sync = __commonJS({
       const { srcStat, destStat } = stat.checkPathsSync(src, dest, "copy", opts);
       stat.checkParentPathsSync(src, srcStat, dest, "copy");
       if (opts.filter && !opts.filter(src, dest)) return;
-      const destParent = path5.dirname(dest);
+      const destParent = path9.dirname(dest);
       if (!fs3.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
@@ -1425,8 +1425,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyDirItem(item, src, dest, opts) {
-      const srcItem = path5.join(src, item);
-      const destItem = path5.join(dest, item);
+      const srcItem = path9.join(src, item);
+      const destItem = path9.join(dest, item);
       if (opts.filter && !opts.filter(srcItem, destItem)) return;
       const { destStat } = stat.checkPathsSync(srcItem, destItem, "copy", opts);
       return getStats(destStat, srcItem, destItem, opts);
@@ -1434,7 +1434,7 @@ var require_copy_sync = __commonJS({
     function onLink(destStat, src, dest, opts) {
       let resolvedSrc = fs3.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path9.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
         return fs3.symlinkSync(resolvedSrc, dest);
@@ -1447,7 +1447,7 @@ var require_copy_sync = __commonJS({
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path5.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path9.resolve(process.cwd(), resolvedDest);
         }
         if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
           throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -1484,11 +1484,11 @@ var require_remove = __commonJS({
     "use strict";
     var fs3 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove(path5, callback) {
-      fs3.rm(path5, { recursive: true, force: true }, callback);
+    function remove(path9, callback) {
+      fs3.rm(path9, { recursive: true, force: true }, callback);
     }
-    function removeSync(path5) {
-      fs3.rmSync(path5, { recursive: true, force: true });
+    function removeSync(path9) {
+      fs3.rmSync(path9, { recursive: true, force: true });
     }
     module2.exports = {
       remove: u(remove),
@@ -1503,7 +1503,7 @@ var require_empty = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var fs3 = require_fs();
-    var path5 = require("path");
+    var path9 = require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
@@ -1513,7 +1513,7 @@ var require_empty = __commonJS({
       } catch {
         return mkdir.mkdirs(dir);
       }
-      return Promise.all(items.map((item) => remove.remove(path5.join(dir, item))));
+      return Promise.all(items.map((item) => remove.remove(path9.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
@@ -1523,7 +1523,7 @@ var require_empty = __commonJS({
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path5.join(dir, item);
+        item = path9.join(dir, item);
         remove.removeSync(item);
       });
     }
@@ -1541,7 +1541,7 @@ var require_file = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/ensure/file.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path5 = require("path");
+    var path9 = require("path");
     var fs3 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file4) {
@@ -1551,7 +1551,7 @@ var require_file = __commonJS({
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path5.dirname(file4);
+      const dir = path9.dirname(file4);
       let dirStats = null;
       try {
         dirStats = await fs3.stat(dir);
@@ -1577,7 +1577,7 @@ var require_file = __commonJS({
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path5.dirname(file4);
+      const dir = path9.dirname(file4);
       try {
         if (!fs3.statSync(dir).isDirectory()) {
           fs3.readdirSync(dir);
@@ -1600,7 +1600,7 @@ var require_link = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/ensure/link.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path5 = require("path");
+    var path9 = require("path");
     var fs3 = require_fs();
     var mkdir = require_mkdirs();
     var { pathExists } = require_path_exists();
@@ -1619,7 +1619,7 @@ var require_link = __commonJS({
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
-      const dir = path5.dirname(dstpath);
+      const dir = path9.dirname(dstpath);
       const dirExists = await pathExists(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
@@ -1639,7 +1639,7 @@ var require_link = __commonJS({
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path5.dirname(dstpath);
+      const dir = path9.dirname(dstpath);
       const dirExists = fs3.existsSync(dir);
       if (dirExists) return fs3.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
@@ -1656,12 +1656,12 @@ var require_link = __commonJS({
 var require_symlink_paths = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/ensure/symlink-paths.js"(exports2, module2) {
     "use strict";
-    var path5 = require("path");
+    var path9 = require("path");
     var fs3 = require_fs();
     var { pathExists } = require_path_exists();
     var u = require_universalify().fromPromise;
     async function symlinkPaths(srcpath, dstpath) {
-      if (path5.isAbsolute(srcpath)) {
+      if (path9.isAbsolute(srcpath)) {
         try {
           await fs3.lstat(srcpath);
         } catch (err) {
@@ -1673,8 +1673,8 @@ var require_symlink_paths = __commonJS({
           toDst: srcpath
         };
       }
-      const dstdir = path5.dirname(dstpath);
-      const relativeToDst = path5.join(dstdir, srcpath);
+      const dstdir = path9.dirname(dstpath);
+      const relativeToDst = path9.join(dstdir, srcpath);
       const exists = await pathExists(relativeToDst);
       if (exists) {
         return {
@@ -1690,11 +1690,11 @@ var require_symlink_paths = __commonJS({
       }
       return {
         toCwd: srcpath,
-        toDst: path5.relative(dstdir, srcpath)
+        toDst: path9.relative(dstdir, srcpath)
       };
     }
     function symlinkPathsSync(srcpath, dstpath) {
-      if (path5.isAbsolute(srcpath)) {
+      if (path9.isAbsolute(srcpath)) {
         const exists2 = fs3.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
@@ -1702,8 +1702,8 @@ var require_symlink_paths = __commonJS({
           toDst: srcpath
         };
       }
-      const dstdir = path5.dirname(dstpath);
-      const relativeToDst = path5.join(dstdir, srcpath);
+      const dstdir = path9.dirname(dstpath);
+      const relativeToDst = path9.join(dstdir, srcpath);
       const exists = fs3.existsSync(relativeToDst);
       if (exists) {
         return {
@@ -1715,7 +1715,7 @@ var require_symlink_paths = __commonJS({
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
-        toDst: path5.relative(dstdir, srcpath)
+        toDst: path9.relative(dstdir, srcpath)
       };
     }
     module2.exports = {
@@ -1763,7 +1763,7 @@ var require_symlink = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/ensure/symlink.js"(exports2, module2) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path5 = require("path");
+    var path9 = require("path");
     var fs3 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
@@ -1786,7 +1786,7 @@ var require_symlink = __commonJS({
       const relative = await symlinkPaths(srcpath, dstpath);
       srcpath = relative.toDst;
       const toType = await symlinkType(relative.toCwd, type);
-      const dir = path5.dirname(dstpath);
+      const dir = path9.dirname(dstpath);
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
@@ -1806,7 +1806,7 @@ var require_symlink = __commonJS({
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
-      const dir = path5.dirname(dstpath);
+      const dir = path9.dirname(dstpath);
       const exists = fs3.existsSync(dir);
       if (exists) return fs3.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
@@ -1897,7 +1897,7 @@ var require_jsonfile = __commonJS({
       return obj;
     }
     var readFile = universalify.fromPromise(_readFile);
-    function readFileSync(file4, options = {}) {
+    function readFileSync2(file4, options = {}) {
       if (typeof options === "string") {
         options = { encoding: options };
       }
@@ -1929,7 +1929,7 @@ var require_jsonfile = __commonJS({
     }
     var jsonfile = {
       readFile,
-      readFileSync,
+      readFileSync: readFileSync2,
       writeFile,
       writeFileSync
     };
@@ -1958,18 +1958,18 @@ var require_output_file = __commonJS({
     "use strict";
     var u = require_universalify().fromPromise;
     var fs3 = require_fs();
-    var path5 = require("path");
+    var path9 = require("path");
     var mkdir = require_mkdirs();
     var pathExists = require_path_exists().pathExists;
     async function outputFile(file4, data, encoding = "utf-8") {
-      const dir = path5.dirname(file4);
+      const dir = path9.dirname(file4);
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
       return fs3.writeFile(file4, data, encoding);
     }
     function outputFileSync(file4, ...args) {
-      const dir = path5.dirname(file4);
+      const dir = path9.dirname(file4);
       if (!fs3.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
@@ -2033,7 +2033,7 @@ var require_move = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/move/move.js"(exports2, module2) {
     "use strict";
     var fs3 = require_fs();
-    var path5 = require("path");
+    var path9 = require("path");
     var { copy } = require_copy2();
     var { remove } = require_remove();
     var { mkdirp } = require_mkdirs();
@@ -2043,8 +2043,8 @@ var require_move = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = await stat.checkPaths(src, dest, "move", opts);
       await stat.checkParentPaths(src, srcStat, dest, "move");
-      const destParent = path5.dirname(dest);
-      const parsedParentPath = path5.parse(destParent);
+      const destParent = path9.dirname(dest);
+      const parsedParentPath = path9.parse(destParent);
       if (parsedParentPath.root !== destParent) {
         await mkdirp(destParent);
       }
@@ -2085,7 +2085,7 @@ var require_move_sync = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/move/move-sync.js"(exports2, module2) {
     "use strict";
     var fs3 = require_graceful_fs();
-    var path5 = require("path");
+    var path9 = require("path");
     var copySync = require_copy2().copySync;
     var removeSync = require_remove().removeSync;
     var mkdirpSync = require_mkdirs().mkdirpSync;
@@ -2095,12 +2095,12 @@ var require_move_sync = __commonJS({
       const overwrite = opts.overwrite || opts.clobber || false;
       const { srcStat, isChangingCase = false } = stat.checkPathsSync(src, dest, "move", opts);
       stat.checkParentPathsSync(src, srcStat, dest, "move");
-      if (!isParentRoot(dest)) mkdirpSync(path5.dirname(dest));
+      if (!isParentRoot(dest)) mkdirpSync(path9.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
     function isParentRoot(dest) {
-      const parent = path5.dirname(dest);
-      const parsedPath = path5.parse(parent);
+      const parent = path9.dirname(dest);
+      const parsedPath = path9.parse(parent);
       return parsedPath.root === parent;
     }
     function doRename(src, dest, overwrite, isChangingCase) {
@@ -2166,6 +2166,547 @@ var require_lib = __commonJS({
   }
 });
 
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js
+var require_windows = __commonJS({
+  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/windows.js"(exports2, module2) {
+    "use strict";
+    module2.exports = isexe;
+    isexe.sync = sync;
+    var fs3 = require("fs");
+    function checkPathExt(path9, options) {
+      var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+      if (!pathext) {
+        return true;
+      }
+      pathext = pathext.split(";");
+      if (pathext.indexOf("") !== -1) {
+        return true;
+      }
+      for (var i = 0; i < pathext.length; i++) {
+        var p = pathext[i].toLowerCase();
+        if (p && path9.substr(-p.length).toLowerCase() === p) {
+          return true;
+        }
+      }
+      return false;
+    }
+    function checkStat(stat, path9, options) {
+      if (!stat.isSymbolicLink() && !stat.isFile()) {
+        return false;
+      }
+      return checkPathExt(path9, options);
+    }
+    function isexe(path9, options, cb) {
+      fs3.stat(path9, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, path9, options));
+      });
+    }
+    function sync(path9, options) {
+      return checkStat(fs3.statSync(path9), path9, options);
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js
+var require_mode = __commonJS({
+  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/mode.js"(exports2, module2) {
+    "use strict";
+    module2.exports = isexe;
+    isexe.sync = sync;
+    var fs3 = require("fs");
+    function isexe(path9, options, cb) {
+      fs3.stat(path9, function(er, stat) {
+        cb(er, er ? false : checkStat(stat, options));
+      });
+    }
+    function sync(path9, options) {
+      return checkStat(fs3.statSync(path9), options);
+    }
+    function checkStat(stat, options) {
+      return stat.isFile() && checkMode(stat, options);
+    }
+    function checkMode(stat, options) {
+      var mod = stat.mode;
+      var uid = stat.uid;
+      var gid = stat.gid;
+      var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+      var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+      var u = parseInt("100", 8);
+      var g = parseInt("010", 8);
+      var o = parseInt("001", 8);
+      var ug = u | g;
+      var ret = mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+      return ret;
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js
+var require_isexe = __commonJS({
+  "../../node_modules/.pnpm/isexe@2.0.0/node_modules/isexe/index.js"(exports2, module2) {
+    "use strict";
+    var fs3 = require("fs");
+    var core;
+    if (process.platform === "win32" || global.TESTING_WINDOWS) {
+      core = require_windows();
+    } else {
+      core = require_mode();
+    }
+    module2.exports = isexe;
+    isexe.sync = sync;
+    function isexe(path9, options, cb) {
+      if (typeof options === "function") {
+        cb = options;
+        options = {};
+      }
+      if (!cb) {
+        if (typeof Promise !== "function") {
+          throw new TypeError("callback not provided");
+        }
+        return new Promise(function(resolve, reject) {
+          isexe(path9, options || {}, function(er, is) {
+            if (er) {
+              reject(er);
+            } else {
+              resolve(is);
+            }
+          });
+        });
+      }
+      core(path9, options || {}, function(er, is) {
+        if (er) {
+          if (er.code === "EACCES" || options && options.ignoreErrors) {
+            er = null;
+            is = false;
+          }
+        }
+        cb(er, is);
+      });
+    }
+    function sync(path9, options) {
+      try {
+        return core.sync(path9, options || {});
+      } catch (er) {
+        if (options && options.ignoreErrors || er.code === "EACCES") {
+          return false;
+        } else {
+          throw er;
+        }
+      }
+    }
+  }
+});
+
+// ../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js
+var require_which = __commonJS({
+  "../../node_modules/.pnpm/which@2.0.2/node_modules/which/which.js"(exports2, module2) {
+    "use strict";
+    var isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+    var path9 = require("path");
+    var COLON = isWindows ? ";" : ":";
+    var isexe = require_isexe();
+    var getNotFoundError = (cmd) => Object.assign(new Error(`not found: ${cmd}`), { code: "ENOENT" });
+    var getPathInfo = (cmd, opt) => {
+      const colon = opt.colon || COLON;
+      const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [
+        // windows always checks the cwd first
+        ...isWindows ? [process.cwd()] : [],
+        ...(opt.path || process.env.PATH || /* istanbul ignore next: very unusual */
+        "").split(colon)
+      ];
+      const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+      const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+      if (isWindows) {
+        if (cmd.indexOf(".") !== -1 && pathExt[0] !== "")
+          pathExt.unshift("");
+      }
+      return {
+        pathEnv,
+        pathExt,
+        pathExtExe
+      };
+    };
+    var which = (cmd, opt, cb) => {
+      if (typeof opt === "function") {
+        cb = opt;
+        opt = {};
+      }
+      if (!opt)
+        opt = {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      const step = (i) => new Promise((resolve, reject) => {
+        if (i === pathEnv.length)
+          return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path9.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        resolve(subStep(p, i, 0));
+      });
+      const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+        if (ii === pathExt.length)
+          return resolve(step(i + 1));
+        const ext = pathExt[ii];
+        isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+          if (!er && is) {
+            if (opt.all)
+              found.push(p + ext);
+            else
+              return resolve(p + ext);
+          }
+          return resolve(subStep(p, i, ii + 1));
+        });
+      });
+      return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+    };
+    var whichSync = (cmd, opt) => {
+      opt = opt || {};
+      const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+      const found = [];
+      for (let i = 0; i < pathEnv.length; i++) {
+        const ppRaw = pathEnv[i];
+        const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+        const pCmd = path9.join(pathPart, cmd);
+        const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+        for (let j = 0; j < pathExt.length; j++) {
+          const cur = p + pathExt[j];
+          try {
+            const is = isexe.sync(cur, { pathExt: pathExtExe });
+            if (is) {
+              if (opt.all)
+                found.push(cur);
+              else
+                return cur;
+            }
+          } catch (ex) {
+          }
+        }
+      }
+      if (opt.all && found.length)
+        return found;
+      if (opt.nothrow)
+        return null;
+      throw getNotFoundError(cmd);
+    };
+    module2.exports = which;
+    which.sync = whichSync;
+  }
+});
+
+// ../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js
+var require_path_key = __commonJS({
+  "../../node_modules/.pnpm/path-key@3.1.1/node_modules/path-key/index.js"(exports2, module2) {
+    "use strict";
+    var pathKey2 = (options = {}) => {
+      const environment = options.env || process.env;
+      const platform = options.platform || process.platform;
+      if (platform !== "win32") {
+        return "PATH";
+      }
+      return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+    };
+    module2.exports = pathKey2;
+    module2.exports.default = pathKey2;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js
+var require_resolveCommand = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/resolveCommand.js"(exports2, module2) {
+    "use strict";
+    var path9 = require("path");
+    var which = require_which();
+    var getPathKey = require_path_key();
+    function resolveCommandAttempt(parsed, withoutPathExt) {
+      const env = parsed.options.env || process.env;
+      const cwd = process.cwd();
+      const hasCustomCwd = parsed.options.cwd != null;
+      const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+      if (shouldSwitchCwd) {
+        try {
+          process.chdir(parsed.options.cwd);
+        } catch (err) {
+        }
+      }
+      let resolved;
+      try {
+        resolved = which.sync(parsed.command, {
+          path: env[getPathKey({ env })],
+          pathExt: withoutPathExt ? path9.delimiter : void 0
+        });
+      } catch (e) {
+      } finally {
+        if (shouldSwitchCwd) {
+          process.chdir(cwd);
+        }
+      }
+      if (resolved) {
+        resolved = path9.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+      }
+      return resolved;
+    }
+    function resolveCommand(parsed) {
+      return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+    }
+    module2.exports = resolveCommand;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js
+var require_escape = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/escape.js"(exports2, module2) {
+    "use strict";
+    var metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+    function escapeCommand(arg) {
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      return arg;
+    }
+    function escapeArgument(arg, doubleEscapeMetaChars) {
+      arg = `${arg}`;
+      arg = arg.replace(/(?=(\\+?)?)\1"/g, '$1$1\\"');
+      arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+      arg = `"${arg}"`;
+      arg = arg.replace(metaCharsRegExp, "^$1");
+      if (doubleEscapeMetaChars) {
+        arg = arg.replace(metaCharsRegExp, "^$1");
+      }
+      return arg;
+    }
+    module2.exports.command = escapeCommand;
+    module2.exports.argument = escapeArgument;
+  }
+});
+
+// ../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js
+var require_shebang_regex = __commonJS({
+  "../../node_modules/.pnpm/shebang-regex@3.0.0/node_modules/shebang-regex/index.js"(exports2, module2) {
+    "use strict";
+    module2.exports = /^#!(.*)/;
+  }
+});
+
+// ../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js
+var require_shebang_command = __commonJS({
+  "../../node_modules/.pnpm/shebang-command@2.0.0/node_modules/shebang-command/index.js"(exports2, module2) {
+    "use strict";
+    var shebangRegex = require_shebang_regex();
+    module2.exports = (string = "") => {
+      const match2 = string.match(shebangRegex);
+      if (!match2) {
+        return null;
+      }
+      const [path9, argument] = match2[0].replace(/#! ?/, "").split(" ");
+      const binary = path9.split("/").pop();
+      if (binary === "env") {
+        return argument;
+      }
+      return argument ? `${binary} ${argument}` : binary;
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js
+var require_readShebang = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/util/readShebang.js"(exports2, module2) {
+    "use strict";
+    var fs3 = require("fs");
+    var shebangCommand = require_shebang_command();
+    function readShebang(command) {
+      const size = 150;
+      const buffer = Buffer.alloc(size);
+      let fd;
+      try {
+        fd = fs3.openSync(command, "r");
+        fs3.readSync(fd, buffer, 0, size, 0);
+        fs3.closeSync(fd);
+      } catch (e) {
+      }
+      return shebangCommand(buffer.toString());
+    }
+    module2.exports = readShebang;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js
+var require_parse = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/parse.js"(exports2, module2) {
+    "use strict";
+    var path9 = require("path");
+    var resolveCommand = require_resolveCommand();
+    var escape = require_escape();
+    var readShebang = require_readShebang();
+    var isWin = process.platform === "win32";
+    var isExecutableRegExp = /\.(?:com|exe)$/i;
+    var isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+    function detectShebang(parsed) {
+      parsed.file = resolveCommand(parsed);
+      const shebang = parsed.file && readShebang(parsed.file);
+      if (shebang) {
+        parsed.args.unshift(parsed.file);
+        parsed.command = shebang;
+        return resolveCommand(parsed);
+      }
+      return parsed.file;
+    }
+    function parseNonShell(parsed) {
+      if (!isWin) {
+        return parsed;
+      }
+      const commandFile = detectShebang(parsed);
+      const needsShell = !isExecutableRegExp.test(commandFile);
+      if (parsed.options.forceShell || needsShell) {
+        const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+        parsed.command = path9.normalize(parsed.command);
+        parsed.command = escape.command(parsed.command);
+        parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+        const shellCommand = [parsed.command].concat(parsed.args).join(" ");
+        parsed.args = ["/d", "/s", "/c", `"${shellCommand}"`];
+        parsed.command = process.env.comspec || "cmd.exe";
+        parsed.options.windowsVerbatimArguments = true;
+      }
+      return parsed;
+    }
+    function parse(command, args, options) {
+      if (args && !Array.isArray(args)) {
+        options = args;
+        args = null;
+      }
+      args = args ? args.slice(0) : [];
+      options = Object.assign({}, options);
+      const parsed = {
+        command,
+        args,
+        options,
+        file: void 0,
+        original: {
+          command,
+          args
+        }
+      };
+      return options.shell ? parsed : parseNonShell(parsed);
+    }
+    module2.exports = parse;
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js
+var require_enoent = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/lib/enoent.js"(exports2, module2) {
+    "use strict";
+    var isWin = process.platform === "win32";
+    function notFoundError(original, syscall) {
+      return Object.assign(new Error(`${syscall} ${original.command} ENOENT`), {
+        code: "ENOENT",
+        errno: "ENOENT",
+        syscall: `${syscall} ${original.command}`,
+        path: original.command,
+        spawnargs: original.args
+      });
+    }
+    function hookChildProcess(cp, parsed) {
+      if (!isWin) {
+        return;
+      }
+      const originalEmit = cp.emit;
+      cp.emit = function(name, arg1) {
+        if (name === "exit") {
+          const err = verifyENOENT(arg1, parsed);
+          if (err) {
+            return originalEmit.call(cp, "error", err);
+          }
+        }
+        return originalEmit.apply(cp, arguments);
+      };
+    }
+    function verifyENOENT(status, parsed) {
+      if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawn");
+      }
+      return null;
+    }
+    function verifyENOENTSync(status, parsed) {
+      if (isWin && status === 1 && !parsed.file) {
+        return notFoundError(parsed.original, "spawnSync");
+      }
+      return null;
+    }
+    module2.exports = {
+      hookChildProcess,
+      verifyENOENT,
+      verifyENOENTSync,
+      notFoundError
+    };
+  }
+});
+
+// ../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js
+var require_cross_spawn = __commonJS({
+  "../../node_modules/.pnpm/cross-spawn@7.0.6/node_modules/cross-spawn/index.js"(exports2, module2) {
+    "use strict";
+    var cp = require("child_process");
+    var parse = require_parse();
+    var enoent = require_enoent();
+    function spawn(command, args, options) {
+      const parsed = parse(command, args, options);
+      const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+      enoent.hookChildProcess(spawned, parsed);
+      return spawned;
+    }
+    function spawnSync(command, args, options) {
+      const parsed = parse(command, args, options);
+      const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+      result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+      return result;
+    }
+    module2.exports = spawn;
+    module2.exports.spawn = spawn;
+    module2.exports.sync = spawnSync;
+    module2.exports._parse = parse;
+    module2.exports._enoent = enoent;
+  }
+});
+
+// ../../node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js
+var require_merge_stream = __commonJS({
+  "../../node_modules/.pnpm/merge-stream@2.0.0/node_modules/merge-stream/index.js"(exports2, module2) {
+    "use strict";
+    var { PassThrough } = require("stream");
+    module2.exports = function() {
+      var sources = [];
+      var output = new PassThrough({ objectMode: true });
+      output.setMaxListeners(0);
+      output.add = add;
+      output.isEmpty = isEmpty;
+      output.on("unpipe", remove);
+      Array.prototype.slice.call(arguments).forEach(add);
+      return output;
+      function add(source) {
+        if (Array.isArray(source)) {
+          source.forEach(add);
+          return this;
+        }
+        sources.push(source);
+        source.once("end", remove.bind(null, source));
+        source.once("error", output.emit.bind(output, "error"));
+        source.pipe(output, { end: false });
+        return this;
+      }
+      function isEmpty() {
+        return sources.length == 0;
+      }
+      function remove(source) {
+        sources = sources.filter(function(it) {
+          return it !== source;
+        });
+        if (!sources.length && output.readable) {
+          output.end();
+        }
+      }
+    };
+  }
+});
+
 // src/index.ts
 var index_exports = {};
 __export(index_exports, {
@@ -2223,9 +2764,12 @@ function getMappings(mappings, datamodel) {
 }
 
 // src/generateClient.ts
-var import_internals7 = require("@prisma/internals");
-var import_crypto = require("crypto");
+var import_debug = require("@prisma/debug");
+var import_fetch_engine = require("@prisma/fetch-engine");
+var import_internals10 = require("@prisma/internals");
+var import_crypto2 = require("crypto");
 var import_env_paths = __toESM(require("env-paths"));
+var import_fs = require("fs");
 var import_promises = __toESM(require("fs/promises"));
 var import_fs_extra = __toESM(require_lib());
 
@@ -2279,7 +2823,7 @@ var bgWhite = init(47, 49);
 
 // src/generateClient.ts
 var import_package_up = require("package-up");
-var import_path = __toESM(require("path"));
+var import_path3 = __toESM(require("path"));
 
 // ../client/package.json
 var package_default = {
@@ -2311,7 +2855,8 @@ var package_default = {
     "MSSQL",
     "SQL Server",
     "SQLServer",
-    "MongoDB"
+    "MongoDB",
+    "react-native"
   ],
   main: "default.js",
   types: "default.d.ts",
@@ -2337,6 +2882,18 @@ var package_default = {
       },
       default: "./default.js"
     },
+    "./edge": {
+      types: "./edge.d.ts",
+      require: "./edge.js",
+      import: "./edge.js",
+      default: "./edge.js"
+    },
+    "./react-native": {
+      types: "./react-native.d.ts",
+      require: "./react-native.js",
+      import: "./react-native.js",
+      default: "./react-native.js"
+    },
     "./extension": {
       types: "./extension.d.ts",
       require: "./extension.js",
@@ -2355,11 +2912,11 @@ var package_default = {
       import: "./index.js",
       default: "./index.js"
     },
-    "./edge": {
-      types: "./edge.d.ts",
-      require: "./edge.js",
-      import: "./edge.js",
-      default: "./edge.js"
+    "./wasm": {
+      types: "./wasm.d.ts",
+      require: "./wasm.js",
+      import: "./wasm.mjs",
+      default: "./wasm.mjs"
     },
     "./runtime/client": {
       types: "./runtime/client.d.ts",
@@ -2371,12 +2928,42 @@ var package_default = {
       import: "./runtime/client.mjs",
       default: "./runtime/client.mjs"
     },
+    "./runtime/library": {
+      types: "./runtime/library.d.ts",
+      require: "./runtime/library.js",
+      import: "./runtime/library.mjs",
+      default: "./runtime/library.mjs"
+    },
+    "./runtime/binary": {
+      types: "./runtime/binary.d.ts",
+      require: "./runtime/binary.js",
+      import: "./runtime/binary.mjs",
+      default: "./runtime/binary.mjs"
+    },
+    "./runtime/wasm-engine-edge": {
+      types: "./runtime/wasm-engine-edge.d.ts",
+      require: "./runtime/wasm-engine-edge.js",
+      import: "./runtime/wasm-engine-edge.mjs",
+      default: "./runtime/wasm-engine-edge.mjs"
+    },
     "./runtime/wasm-compiler-edge": {
       types: "./runtime/wasm-compiler-edge.d.ts",
       require: "./runtime/wasm-compiler-edge.js",
       import: "./runtime/wasm-compiler-edge.mjs",
       default: "./runtime/wasm-compiler-edge.mjs"
     },
+    "./runtime/edge": {
+      types: "./runtime/edge.d.ts",
+      require: "./runtime/edge.js",
+      import: "./runtime/edge-esm.js",
+      default: "./runtime/edge-esm.js"
+    },
+    "./runtime/react-native": {
+      types: "./runtime/react-native.d.ts",
+      require: "./runtime/react-native.js",
+      import: "./runtime/react-native.js",
+      default: "./runtime/react-native.js"
+    },
     "./runtime/index-browser": {
       types: "./runtime/index-browser.d.ts",
       require: "./runtime/index-browser.js",
@@ -2405,7 +2992,7 @@ var package_default = {
   },
   license: "Apache-2.0",
   engines: {
-    node: "^20.19 || ^22.12 || >=24.0"
+    node: ">=18.18"
   },
   homepage: "https://www.prisma.io",
   repository: {
@@ -2421,11 +3008,13 @@ var package_default = {
     test: "dotenv -e ../../.db.env -- jest --silent",
     "test:e2e": "dotenv -e ../../.db.env -- tsx tests/e2e/_utils/run.ts",
     "test:functional": "dotenv -e ../../.db.env -- tsx helpers/functional-test/run-tests.ts",
-    "test:functional:client": "pnpm run test:functional --client-runtime client",
+    "test:functional:client": "pnpm run test:functional --client-runtime client --engine-type client",
     "test:memory": "dotenv -e ../../.db.env -- tsx helpers/memory-tests.ts",
     "test:functional:code": "dotenv -e ../../.db.env -- tsx helpers/functional-test/run-tests.ts --no-types",
     "test:functional:types": "dotenv -e ../../.db.env -- tsx helpers/functional-test/run-tests.ts --types-only",
     "test-notypes": "dotenv -e ../../.db.env -- jest --testPathIgnorePatterns src/__tests__/types/types.test.ts",
+    generate: "node scripts/postinstall.js",
+    postinstall: "node scripts/postinstall.js",
     prepublishOnly: "pnpm run build",
     "new-test": "tsx ./helpers/new-test/new-test.ts"
   },
@@ -2436,8 +3025,12 @@ var package_default = {
     "generator-build",
     "edge.js",
     "edge.d.ts",
+    "wasm.js",
+    "wasm.d.ts",
     "index.js",
     "index.d.ts",
+    "react-native.js",
+    "react-native.d.ts",
     "default.js",
     "default.d.ts",
     "index-browser.js",
@@ -2448,7 +3041,7 @@ var package_default = {
     "sql.mjs"
   ],
   devDependencies: {
-    "@cloudflare/workers-types": "^4.20251014.0",
+    "@cloudflare/workers-types": "^4.20250408.0",
     "@codspeed/benchmark.js-plugin": "4.0.0",
     "@faker-js/faker": "9.6.0",
     "@fast-check/jest": "2.0.3",
@@ -2483,20 +3076,18 @@ var package_default = {
     "@prisma/dmmf": "workspace:*",
     "@prisma/driver-adapter-utils": "workspace:*",
     "@prisma/engines": "workspace:*",
-    "@prisma/engines-version": "7.2.0-3.aqrln-zpupkzknszlw-04d61c41ec1a025cabe14093fa3121a5f45040ab",
+    "@prisma/engines-version": "7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",
     "@prisma/fetch-engine": "workspace:*",
     "@prisma/generator": "workspace:*",
     "@prisma/generator-helper": "workspace:*",
     "@prisma/get-platform": "workspace:*",
     "@prisma/instrumentation": "workspace:*",
-    "@prisma/instrumentation-contract": "workspace:*",
     "@prisma/internals": "workspace:*",
-    "@prisma/json-protocol": "workspace:*",
     "@prisma/migrate": "workspace:*",
-    "@prisma/query-compiler-wasm": "7.2.0-3.aqrln-zpupkzknszlw-04d61c41ec1a025cabe14093fa3121a5f45040ab",
+    "@prisma/mini-proxy": "0.9.5",
+    "@prisma/query-compiler-wasm": "7.1.1-3.c2990dca591cba766e3b7ef5d9e8a84796e47ab7",
+    "@prisma/query-engine-wasm": "6.19.0-26.2ba551f319ab1df4bc874a89965d8b3641056773",
     "@prisma/query-plan-executor": "workspace:*",
-    "@prisma/sqlcommenter": "workspace:*",
-    "@prisma/sqlcommenter-trace-context": "workspace:*",
     "@prisma/ts-builders": "workspace:*",
     "@snaplet/copycat": "6.0.0",
     "@swc-node/register": "1.10.9",
@@ -2508,11 +3099,12 @@ var package_default = {
     "@types/jest": "29.5.14",
     "@types/js-levenshtein": "1.1.3",
     "@types/mssql": "9.1.8",
-    "@types/node": "~20.19.24",
+    "@types/node": "18.19.76",
     "@types/pg": "8.11.11",
     arg: "5.0.2",
     benchmark: "2.1.4",
     "cookie-es": "2.0.0",
+    "decimal.js": "10.5.0",
     execa: "8.0.1",
     "expect-type": "1.2.2",
     "fs-extra": "11.3.0",
@@ -2537,6 +3129,7 @@ var package_default = {
     "simple-statistics": "7.8.8",
     "sort-keys": "5.1.0",
     "source-map-support": "0.5.21",
+    "sql-template-tag": "5.2.1",
     "stacktrace-parser": "0.1.11",
     "strip-ansi": "7.1.0",
     "strip-indent": "4.0.0",
@@ -2547,12 +3140,9 @@ var package_default = {
     undici: "7.4.0",
     zx: "8.4.1"
   },
-  dependencies: {
-    "@prisma/client-runtime-utils": "workspace:*"
-  },
   peerDependencies: {
     prisma: "*",
-    typescript: ">=5.4.0"
+    typescript: ">=5.1.0"
   },
   peerDependenciesMeta: {
     prisma: {
@@ -2597,7 +3187,7 @@ var Enum = class {
   toJS() {
     const { type } = this;
     const enumVariants = `{
-${(0, import_indent_string.default)(type.data.map((v) => `${v.key}: ${this.getValueJS(v.value)}`).join(",\n"), TAB_SIZE)}
+${(0, import_indent_string.default)(type.values.map((v) => `${v}: ${this.getValueJS(v)}`).join(",\n"), TAB_SIZE)}
 }`;
     const enumBody = this.isStrictEnum() ? `makeStrictEnum(${enumVariants})` : enumVariants;
     return this.useNamespace ? `exports.Prisma.${type.name} = ${enumBody};` : `exports.${type.name} = exports.$Enums.${type.name} = ${enumBody};`;
@@ -2608,7 +3198,7 @@ ${(0, import_indent_string.default)(type.data.map((v) => `${v.key}: ${this.getVa
   toTS() {
     const { type } = this;
     return `export const ${type.name}: {
-${(0, import_indent_string.default)(type.data.map((v) => `${v.key}: ${this.getValueTS(v.value)}`).join(",\n"), TAB_SIZE)}
+${(0, import_indent_string.default)(type.values.map((v) => `${v}: ${this.getValueTS(v)}`).join(",\n"), TAB_SIZE)}
 };
 
 export type ${type.name} = (typeof ${type.name})[keyof typeof ${type.name}]
@@ -4335,8 +4925,12 @@ function fluentWrapperName(modelName) {
 
 // src/TSClient/TSClient.ts
 var import_dmmf = require("@prisma/dmmf");
+var import_internals7 = require("@prisma/internals");
 var ts12 = __toESM(require("@prisma/ts-builders"));
-var import_indent_string7 = __toESM(require("indent-string"));
+var import_ci_info = __toESM(require("ci-info"));
+var import_crypto = __toESM(require("crypto"));
+var import_indent_string8 = __toESM(require("indent-string"));
+var import_path2 = __toESM(require("path"));
 
 // src/dmmf.ts
 var import_client_common10 = require("@prisma/client-common");
@@ -4531,24 +5125,87 @@ var GenericArgsInfo = class {
   }
 };
 
+// src/utils/buildInjectableEdgeEnv.ts
+function buildInjectableEdgeEnv(edge, datasources) {
+  if (edge === true) {
+    return declareInjectableEdgeEnv(datasources);
+  }
+  return ``;
+}
+function declareInjectableEdgeEnv(datasources) {
+  const injectableEdgeEnv = { parsed: {} };
+  const envVarNames = getSelectedEnvVarNames(datasources);
+  for (const envVarName of envVarNames) {
+    injectableEdgeEnv.parsed[envVarName] = getRuntimeEdgeEnvVar(envVarName);
+  }
+  const injectableEdgeEnvJson = JSON.stringify(injectableEdgeEnv, null, 2);
+  const injectableEdgeEnvCode = injectableEdgeEnvJson.replace(/"/g, "");
+  return `
+config.injectableEdgeEnv = () => (${injectableEdgeEnvCode})`;
+}
+function getSelectedEnvVarNames(datasources) {
+  return datasources.reduce((acc, datasource) => {
+    if (datasource.url.fromEnvVar) {
+      return [...acc, datasource.url.fromEnvVar];
+    }
+    return acc;
+  }, []);
+}
+function getRuntimeEdgeEnvVar(envVarName) {
+  const cfwEnv = `typeof globalThis !== 'undefined' && globalThis['${envVarName}']`;
+  const nodeOrVercelEnv = `typeof process !== 'undefined' && process.env && process.env.${envVarName}`;
+  return `${cfwEnv} || ${nodeOrVercelEnv} || undefined`;
+}
+
 // src/utils/buildDebugInitialization.ts
 function buildDebugInitialization(edge) {
   if (!edge) {
     return "";
   }
-  const debugVar = `typeof globalThis !== 'undefined' && globalThis['DEBUG'] || (typeof process !== 'undefined' && process.env && process.env.DEBUG) || undefined`;
+  const debugVar = getRuntimeEdgeEnvVar("DEBUG");
   return `if (${debugVar}) {
   Debug.enable(${debugVar})
 }
 `;
 }
 
+// src/utils/buildDirname.ts
+var import_internals4 = require("@prisma/internals");
+function buildDirname(edge, relativeOutdir) {
+  if (edge === true) {
+    return buildDirnameDefault();
+  }
+  return buildDirnameFind(relativeOutdir);
+}
+function buildDirnameFind(relativeOutdir) {
+  return `
+const fs = require('fs')
+
+config.dirname = __dirname
+if (!fs.existsSync(path.join(__dirname, 'schema.prisma'))) {
+  const alternativePaths = [
+    ${JSON.stringify((0, import_internals4.pathToPosix)(relativeOutdir))},
+    ${JSON.stringify((0, import_internals4.pathToPosix)(relativeOutdir).split("/").slice(1).join("/"))},
+  ]
+  
+  const alternativePath = alternativePaths.find((altPath) => {
+    return fs.existsSync(path.join(process.cwd(), altPath, 'schema.prisma'))
+  }) ?? alternativePaths[0]
+
+  config.dirname = path.join(process.cwd(), alternativePath)
+  config.isBundled = true
+}`;
+}
+function buildDirnameDefault() {
+  return `config.dirname = '/'`;
+}
+
 // src/utils/buildDMMF.ts
 var import_client_common12 = require("@prisma/client-common");
-function buildRuntimeDataModel(datamodel, runtimeName) {
+function buildRuntimeDataModel(datamodel, runtimeNameJs) {
   const runtimeDataModel = (0, import_client_common12.dmmfToRuntimeDataModel)(datamodel);
   let prunedDataModel;
-  if (runtimeName === "wasm-compiler-edge" || runtimeName === "client") {
+  if (runtimeNameJs === "wasm-engine-edge" || runtimeNameJs === "wasm-compiler-edge" || runtimeNameJs === "client") {
     prunedDataModel = (0, import_client_common12.pruneRuntimeDataModel)(runtimeDataModel);
   } else {
     prunedDataModel = runtimeDataModel;
@@ -4560,20 +5217,19 @@ defineDmmfProperty(exports.Prisma, config.runtimeDataModel)`;
 }
 
 // src/utils/buildGetQueryCompilerWasmModule.ts
-function buildQueryCompilerWasmModule(forceEdgeWasmLoader, runtimeName) {
-  if (runtimeName === "client" && !forceEdgeWasmLoader) {
+function buildQueryCompilerWasmModule(forceEdgeWasmLoader, runtimeNameJs) {
+  if (runtimeNameJs === "client" && !forceEdgeWasmLoader) {
     return `config.compilerWasm = {
       getRuntime: async () => require('./query_compiler_bg.js'),
       getQueryCompilerWasmModule: async () => {
-        const { Buffer } = require('node:buffer')
-        const { wasm } = require('./query_compiler_bg.wasm-base64.js')
-        const queryCompilerWasmFileBytes = Buffer.from(wasm, 'base64')
+        const queryCompilerWasmFilePath = require('path').join(config.dirname, 'query_compiler_bg.wasm')
+        const queryCompilerWasmFileBytes = require('fs').readFileSync(queryCompilerWasmFilePath)
 
         return new WebAssembly.Module(queryCompilerWasmFileBytes)
       }
     }`;
   }
-  if (runtimeName === "client" && forceEdgeWasmLoader || runtimeName === "wasm-compiler-edge") {
+  if (runtimeNameJs === "client" && forceEdgeWasmLoader || runtimeNameJs === "wasm-compiler-edge") {
     return `config.compilerWasm = {
   getRuntime: async () => require('./query_compiler_bg.js'),
   getQueryCompilerWasmModule: async () => {
@@ -4586,6 +5242,90 @@ function buildQueryCompilerWasmModule(forceEdgeWasmLoader, runtimeName) {
   return `config.compilerWasm = undefined`;
 }
 
+// src/utils/buildGetQueryEngineWasmModule.ts
+function buildQueryEngineWasmModule(wasm, copyEngine, runtimeNameJs) {
+  if (copyEngine && runtimeNameJs === "library" && process.env.PRISMA_CLIENT_FORCE_WASM) {
+    return `config.engineWasm = {
+      getRuntime: async () => require('./query_engine_bg.js'),
+      getQueryEngineWasmModule: async () => {
+        const queryEngineWasmFilePath = require('path').join(config.dirname, 'query_engine_bg.wasm')
+        const queryEngineWasmFileBytes = require('fs').readFileSync(queryEngineWasmFilePath)
+
+        return new WebAssembly.Module(queryEngineWasmFileBytes)
+      }
+    }`;
+  }
+  if (copyEngine && wasm === true && runtimeNameJs === "wasm-engine-edge") {
+    return `config.engineWasm = {
+  getRuntime: async () => require('./query_engine_bg.js'),
+  getQueryEngineWasmModule: async () => {
+    const loader = (await import('#wasm-engine-loader')).default
+    const engine = (await loader).default
+    return engine
+  }
+}`;
+  }
+  return `config.engineWasm = undefined`;
+}
+
+// src/utils/buildInlineDatasources.ts
+function buildInlineDatasources(datasources) {
+  return datasources.reduce((acc, ds) => {
+    return acc[ds.name] = buildInlineDatasource(ds), acc;
+  }, {});
+}
+function buildInlineDatasource(ds) {
+  if (ds.url.fromEnvVar) {
+    return { url: { fromEnvVar: ds.url.fromEnvVar, value: null } };
+  } else {
+    return { url: { fromEnvVar: null, value: ds.url.value } };
+  }
+}
+
+// src/utils/buildNFTAnnotations.ts
+var import_get_platform = require("@prisma/get-platform");
+var import_internals5 = require("@prisma/internals");
+var import_path = __toESM(require("path"));
+function buildNFTAnnotations(noEngine, engineType, binaryTargets, relativeOutdir) {
+  if (noEngine === true) return "";
+  if (binaryTargets === void 0) {
+    return "";
+  }
+  if (process.env.NETLIFY) {
+    const isNodeMajor20OrUp = parseInt(process.versions.node.split(".")[0]) >= 20;
+    const awsRuntimeVersion = (0, import_internals5.parseAWSNodejsRuntimeEnvVarVersion)();
+    const isRuntimeEnvVar20OrUp = awsRuntimeVersion && awsRuntimeVersion >= 20;
+    const isRuntimeEnvVar18OrDown = awsRuntimeVersion && awsRuntimeVersion <= 18;
+    if ((isNodeMajor20OrUp || isRuntimeEnvVar20OrUp) && !isRuntimeEnvVar18OrDown) {
+      binaryTargets = ["rhel-openssl-3.0.x"];
+    } else {
+      binaryTargets = ["rhel-openssl-1.0.x"];
+    }
+  }
+  const engineAnnotations = binaryTargets.map((binaryTarget) => {
+    const engineFilename = getQueryEngineFilename(engineType, binaryTarget);
+    return engineFilename ? buildNFTAnnotation(engineFilename, relativeOutdir) : "";
+  }).join("\n");
+  const schemaAnnotations = buildNFTAnnotation("schema.prisma", relativeOutdir);
+  return `${engineAnnotations}${schemaAnnotations}`;
+}
+function getQueryEngineFilename(engineType, binaryTarget) {
+  if (engineType === import_internals5.ClientEngineType.Library) {
+    return (0, import_get_platform.getNodeAPIName)(binaryTarget, "fs");
+  }
+  if (engineType === import_internals5.ClientEngineType.Binary) {
+    return `query-engine-${binaryTarget}`;
+  }
+  return void 0;
+}
+function buildNFTAnnotation(fileName, relativeOutdir) {
+  const relativeFilePath = import_path.default.join(relativeOutdir, fileName);
+  return `
+// file annotations for bundling tools to include these files
+path.join(__dirname, ${JSON.stringify((0, import_internals5.pathToPosix)(fileName))});
+path.join(process.cwd(), ${JSON.stringify((0, import_internals5.pathToPosix)(relativeFilePath))})`;
+}
+
 // src/utils/buildRequirePath.ts
 function buildRequirePath(edge) {
   if (edge === true) return "";
@@ -4593,11 +5333,23 @@ function buildRequirePath(edge) {
   const path = require('path')`;
 }
 
+// src/utils/buildWarnEnvConflicts.ts
+function buildWarnEnvConflicts(edge, runtimeBase, runtimeNameJs) {
+  if (edge === true) return "";
+  return `
+const { warnEnvConflicts } = require('${runtimeBase}/${runtimeNameJs}.js')
+
+warnEnvConflicts({
+    rootEnvPath: config.relativeEnvPaths.rootEnvPath && path.resolve(config.dirname, config.relativeEnvPaths.rootEnvPath),
+    schemaEnvPath: config.relativeEnvPaths.schemaEnvPath && path.resolve(config.dirname, config.relativeEnvPaths.schemaEnvPath)
+})`;
+}
+
 // src/TSClient/common.ts
 var import_indent_string4 = __toESM(require("indent-string"));
 var commonCodeJS = ({
   runtimeBase,
-  runtimeName,
+  runtimeNameJs,
   browser,
   clientVersion,
   engineVersion,
@@ -4607,15 +5359,12 @@ Object.defineProperty(exports, "__esModule", { value: true });
 ${browser ? `
 const {
   Decimal,
-  DbNull,
-  JsonNull,
-  AnyNull,
-  NullTypes,
+  objectEnumValues,
   makeStrictEnum,
   Public,
   getRuntime,
   skip
-} = require('${runtimeBase}/${runtimeName}.js')
+} = require('${runtimeBase}/${runtimeNameJs}.js')
 ` : `
 const {
   PrismaClientKnownRequestError,
@@ -4631,10 +5380,7 @@ const {
   skip,
   Decimal,
   Debug,
-  DbNull,
-  JsonNull,
-  AnyNull,
-  NullTypes,
+  objectEnumValues,
   makeStrictEnum,
   Extensions,
   warnOnce,
@@ -4642,7 +5388,7 @@ const {
   Public,
   getRuntime,
   createParam,
-} = require('${runtimeBase}/${runtimeName}.js')
+} = require('${runtimeBase}/${runtimeNameJs}.js')
 `}
 
 const Prisma = {}
@@ -4684,11 +5430,15 @@ Prisma.defineExtension = ${notSupportOnBrowser("Extensions.defineExtension", bro
 /**
  * Shorthand utilities for JSON filtering
  */
-Prisma.DbNull = DbNull
-Prisma.JsonNull = JsonNull
-Prisma.AnyNull = AnyNull
+Prisma.DbNull = objectEnumValues.instances.DbNull
+Prisma.JsonNull = objectEnumValues.instances.JsonNull
+Prisma.AnyNull = objectEnumValues.instances.AnyNull
 
-Prisma.NullTypes = NullTypes
+Prisma.NullTypes = {
+  DbNull: objectEnumValues.classes.DbNull,
+  JsonNull: objectEnumValues.classes.JsonNull,
+  AnyNull: objectEnumValues.classes.AnyNull
+}
 
 ${buildPrismaSkipJs(generator.previewFeatures)}
 `;
@@ -4704,12 +5454,12 @@ In case this error is unexpected for you, please report it in https://pris.ly/pr
 };
 var commonCodeTS = ({
   runtimeBase,
-  runtimeName,
+  runtimeNameTs,
   clientVersion,
   engineVersion,
   generator
 }) => ({
-  tsWithoutNamespace: () => `import * as runtime from '${runtimeBase}/${runtimeName}.js';
+  tsWithoutNamespace: () => `import * as runtime from '${runtimeBase}/${runtimeNameTs}';
 import $Types = runtime.Types // general types
 import $Public = runtime.Types.Public
 import $Utils = runtime.Types.Utils
@@ -4754,6 +5504,14 @@ export import Decimal = runtime.Decimal
 
 export type DecimalJsLike = runtime.DecimalJsLike
 
+/**
+ * Metrics
+ */
+export type Metrics = runtime.Metrics
+export type Metric<T> = runtime.Metric<T>
+export type MetricHistogram = runtime.MetricHistogram
+export type MetricHistogramBucket = runtime.MetricHistogramBucket
+
 /**
 * Extensions
 */
@@ -4770,7 +5528,6 @@ export import Exact = $Public.Exact
  */
 export type PrismaVersion = {
   client: string
-  engine: string
 }
 
 export const prismaVersion: PrismaVersion
@@ -5236,33 +5993,45 @@ var GenerateContext = class {
   dmmf;
   genericArgsInfo;
   generator;
-  provider;
-  constructor({ dmmf, genericArgsInfo, generator, provider }) {
+  constructor({ dmmf, genericArgsInfo, generator }) {
     this.dmmf = dmmf;
     this.genericArgsInfo = genericArgsInfo;
     this.generator = generator;
-    this.provider = provider;
   }
   isPreviewFeatureOn(previewFeature) {
     return this.generator?.previewFeatures?.includes(previewFeature) ?? false;
   }
-  isSqlProvider() {
-    return this.provider !== "mongodb";
-  }
 };
 
 // src/TSClient/PrismaClient.ts
 var import_client_common15 = require("@prisma/client-common");
-var import_internals4 = require("@prisma/internals");
+var import_internals6 = require("@prisma/internals");
 var ts11 = __toESM(require("@prisma/ts-builders"));
-var import_indent_string6 = __toESM(require("indent-string"));
+var import_indent_string7 = __toESM(require("indent-string"));
 
 // src/utils/runtimeImport.ts
 var ts9 = __toESM(require("@prisma/ts-builders"));
+function runtimeImport(name) {
+  return name;
+}
 function runtimeImportedType(name) {
   return ts9.namedType(`runtime.${name}`);
 }
 
+// src/TSClient/Datasources.ts
+var import_indent_string6 = __toESM(require("indent-string"));
+var Datasources = class {
+  constructor(internalDatasources) {
+    this.internalDatasources = internalDatasources;
+  }
+  toTS() {
+    const sources = this.internalDatasources;
+    return `export type Datasources = {
+${(0, import_indent_string6.default)(sources.map((s) => `${s.name}?: Datasource`).join("\n"), 2)}
+}`;
+  }
+};
+
 // src/TSClient/globalOmit.ts
 var import_client_common14 = require("@prisma/client-common");
 var ts10 = __toESM(require("@prisma/ts-builders"));
@@ -5333,7 +6102,7 @@ function clientTypeMapModelsResultDefinition(modelName, action) {
   if (action === "update") return payloadToResult(modelName);
   if (action === "upsert") return payloadToResult(modelName);
   if (action === "delete") return payloadToResult(modelName);
-  (0, import_internals4.assertNever)(action, `Unknown action: ${action}`);
+  (0, import_internals6.assertNever)(action, `Unknown action: ${action}`);
 }
 function payloadToResult(modelName) {
   return ts11.namedType("$Utils.PayloadToResult").addGenericArgument(ts11.namedType(getPayloadName(modelName)));
@@ -5443,7 +6212,7 @@ function queryRawDefinition(context) {
    * const result = await prisma.$queryRaw\`SELECT * FROM User WHERE id = \${1} OR email = \${'user@email.com'};\`
    * \`\`\`
    *
-   * Read more in our [docs](https://pris.ly/d/raw-queries).
+   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
    */
   $queryRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<T>;
 
@@ -5455,7 +6224,7 @@ function queryRawDefinition(context) {
    * const result = await prisma.$queryRawUnsafe('SELECT * FROM User WHERE id = $1 OR email = $2;', 1, 'user@email.com')
    * \`\`\`
    *
-   * Read more in our [docs](https://pris.ly/d/raw-queries).
+   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
    */
   $queryRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<T>;`;
 }
@@ -5471,7 +6240,7 @@ function executeRawDefinition(context) {
    * const result = await prisma.$executeRaw\`UPDATE User SET cool = \${true} WHERE email = \${'user@email.com'};\`
    * \`\`\`
    *
-   * Read more in our [docs](https://pris.ly/d/raw-queries).
+   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
    */
   $executeRaw<T = unknown>(query: TemplateStringsArray | Prisma.Sql, ...values: any[]): Prisma.PrismaPromise<number>;
 
@@ -5483,7 +6252,7 @@ function executeRawDefinition(context) {
    * const result = await prisma.$executeRawUnsafe('UPDATE User SET cool = $1 WHERE email = $2 ;', true, 'user@email.com')
    * \`\`\`
    *
-   * Read more in our [docs](https://pris.ly/d/raw-queries).
+   * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
    */
   $executeRawUnsafe<T = unknown>(query: string, ...values: any[]): Prisma.PrismaPromise<number>;`;
 }
@@ -5513,14 +6282,32 @@ function queryRawTypedDefinition(context) {
   ).setReturnType(prismaPromise(ts11.array(param.toArgument())));
   return ts11.stringify(method3, { indentLevel: 1, newLine: "leading" });
 }
-function runCommandRawDefinition(context) {
-  if (!context.dmmf.mappings.otherOperations.write.includes("runCommandRaw")) {
+function metricDefinition(context) {
+  if (!context.isPreviewFeatureOn("metrics")) {
     return "";
   }
-  const method3 = ts11.method("$runCommandRaw").addParameter(ts11.parameter("command", ts11.namedType("Prisma.InputJsonObject"))).setReturnType(prismaPromise(ts11.namedType("Prisma.JsonObject"))).setDocComment(ts11.docComment`
-      Executes a raw MongoDB command and returns the result of it.
-      @example
-      \`\`\`
+  const property11 = ts11.property("$metrics", ts11.namedType(`runtime.${runtimeImport("MetricsClient")}`)).setDocComment(
+    ts11.docComment`
+        Gives access to the client metrics in json or prometheus format.
+
+        @example
+        \`\`\`
+        const metrics = await prisma.$metrics.json()
+        // or
+        const metrics = await prisma.$metrics.prometheus()
+        \`\`\`
+    `
+  ).readonly();
+  return ts11.stringify(property11, { indentLevel: 1, newLine: "leading" });
+}
+function runCommandRawDefinition(context) {
+  if (!context.dmmf.mappings.otherOperations.write.includes("runCommandRaw")) {
+    return "";
+  }
+  const method3 = ts11.method("$runCommandRaw").addParameter(ts11.parameter("command", ts11.namedType("Prisma.InputJsonObject"))).setReturnType(prismaPromise(ts11.namedType("Prisma.JsonObject"))).setDocComment(ts11.docComment`
+      Executes a raw MongoDB command and returns the result of it.
+      @example
+      \`\`\`
       const user = await prisma.$runCommandRaw({
         aggregate: 'User',
         pipeline: [{ $match: { name: 'Bob' } }, { $project: { email: true, _id: false } }],
@@ -5528,16 +6315,32 @@ function runCommandRawDefinition(context) {
       })
       \`\`\`
 
-      Read more in our [docs](https://pris.ly/d/raw-queries).
+      Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/raw-database-access).
     `);
   return ts11.stringify(method3, { indentLevel: 1, newLine: "leading" });
 }
+function applyPendingMigrationsDefinition() {
+  if (this.runtimeNameTs !== "react-native") {
+    return null;
+  }
+  const method3 = ts11.method("$applyPendingMigrations").setReturnType(promise(ts11.voidType)).setDocComment(
+    ts11.docComment`Tries to apply pending migrations one by one. If a migration fails to apply, the function will stop and throw an error. You are responsible for informing the user and possibly blocking the app as we cannot guarantee the state of the database.`
+  );
+  return ts11.stringify(method3, { indentLevel: 1, newLine: "leading" });
+}
+function eventRegistrationMethodDeclaration(runtimeNameTs) {
+  if (runtimeNameTs === "binary.js") {
+    return `$on<V extends (U | 'beforeExit')>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : V extends 'beforeExit' ? () => $Utils.JsPromise<void> : Prisma.LogEvent) => void): PrismaClient;`;
+  } else {
+    return `$on<V extends U>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): PrismaClient;`;
+  }
+}
 var PrismaClientClass = class {
-  constructor(context, internalDatasources, outputDir, runtimeName, browser) {
+  constructor(context, internalDatasources, outputDir, runtimeNameTs, browser) {
     this.context = context;
     this.internalDatasources = internalDatasources;
     this.outputDir = outputDir;
-    this.runtimeName = runtimeName;
+    this.runtimeNameTs = runtimeNameTs;
     this.browser = browser;
   }
   get jsDoc() {
@@ -5563,7 +6366,7 @@ var PrismaClientClass = class {
  * \`\`\`
  *
  *
- * Read more in our [docs](https://pris.ly/d/client).
+ * Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
  */`;
   }
   toTSWithoutNamespace() {
@@ -5576,10 +6379,10 @@ export class PrismaClient<
 > {
   [K: symbol]: { types: Prisma.TypeMap<ExtArgs>['other'] }
 
-  ${(0, import_indent_string6.default)(this.jsDoc, TAB_SIZE)}
+  ${(0, import_indent_string7.default)(this.jsDoc, TAB_SIZE)}
 
   constructor(optionsArg ?: Prisma.Subset<ClientOptions, Prisma.PrismaClientOptions>);
-  $on<V extends U>(eventType: V, callback: (event: V extends 'query' ? Prisma.QueryEvent : Prisma.LogEvent) => void): PrismaClient;
+  ${eventRegistrationMethodDeclaration(this.runtimeNameTs)}
 
   /**
    * Connect with the database
@@ -5598,10 +6401,12 @@ ${[
       batchingTransactionDefinition(this.context),
       interactiveTransactionDefinition(this.context),
       runCommandRawDefinition(this.context),
+      metricDefinition(this.context),
+      applyPendingMigrationsDefinition.bind(this)(),
       extendsPropertyDefinition()
     ].filter((d) => d !== null).join("\n").trim()}
 
-    ${(0, import_indent_string6.default)(
+    ${(0, import_indent_string7.default)(
       dmmf.mappings.modelOperations.filter((m) => m.findMany).map((m) => {
         let methodName = (0, import_client_common15.uncapitalize)(m.model);
         if (methodName === "constructor") {
@@ -5624,7 +6429,8 @@ get ${methodName}(): Prisma.${m.model}Delegate<${generics.join(", ")}>;`;
   }
   toTS() {
     const clientOptions = this.buildClientOptions();
-    return `${clientExtensionsDefinitions(this.context)}
+    return `${new Datasources(this.internalDatasources).toTS()}
+${clientExtensionsDefinitions(this.context)}
 export type DefaultPrismaClient = PrismaClient
 export type ErrorFormat = 'pretty' | 'colorless' | 'minimal'
 ${ts11.stringify(ts11.moduleExport(clientOptions))}
@@ -5697,6 +6503,10 @@ export type TransactionClient = Omit<Prisma.DefaultPrismaClient, runtime.ITXClie
   }
   buildClientOptions() {
     const clientOptions = ts11.interfaceDeclaration("PrismaClientOptions").add(
+      ts11.property("datasources", ts11.namedType("Datasources")).optional().setDocComment(ts11.docComment("Overwrites the datasource url from your schema.prisma file"))
+    ).add(
+      ts11.property("datasourceUrl", ts11.stringType).optional().setDocComment(ts11.docComment("Overwrites the datasource url from your schema.prisma file"))
+    ).add(
       ts11.property("errorFormat", ts11.namedType("ErrorFormat")).optional().setDocComment(ts11.docComment('@default "colorless"'))
     ).add(
       ts11.property("log", ts11.array(ts11.unionType([ts11.namedType("LogLevel"), ts11.namedType("LogDefinition")]))).optional().setDocComment(ts11.docComment`
@@ -5721,7 +6531,7 @@ export type TransactionClient = Omit<Prisma.DefaultPrismaClient, runtime.ITXClie
               { emit: 'stdout', level: 'error' }
             ]
              \`\`\`
-             Read more in our [docs](https://pris.ly/d/logging).
+             Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client/logging#the-log-option).
           `)
     );
     const transactionOptions = ts11.objectType().add(ts11.property("maxWait", ts11.numberType).optional()).add(ts11.property("timeout", ts11.numberType).optional());
@@ -5735,23 +6545,14 @@ export type TransactionClient = Omit<Prisma.DefaultPrismaClient, runtime.ITXClie
              timeout ?= 5000
           `)
     );
-    if (
-      // We don't support a custom adapter with MongoDB for now.
-      this.internalDatasources.some((d) => d.provider !== "mongodb")
-    ) {
+    if (["library.js", "client.js"].includes(this.runtimeNameTs) && // We don't support a custom adapter with MongoDB for now.
+    this.internalDatasources.some((d) => d.provider !== "mongodb")) {
       clientOptions.add(
-        ts11.property("adapter", ts11.namedType("runtime.SqlDriverAdapterFactory")).optional().setDocComment(
+        ts11.property("adapter", ts11.unionType([ts11.namedType("runtime.SqlDriverAdapterFactory"), ts11.namedType("null")])).optional().setDocComment(
           ts11.docComment("Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`")
         )
       );
     }
-    clientOptions.add(
-      ts11.property("accelerateUrl", ts11.stringType).optional().setDocComment(
-        ts11.docComment(
-          "Prisma Accelerate URL allowing the client to connect through Accelerate instead of a direct database."
-        )
-      )
-    );
     clientOptions.add(
       ts11.property("omit", ts11.namedType("Prisma.GlobalOmitConfig")).optional().setDocComment(ts11.docComment`
         Global configuration for omitting model fields by default.
@@ -5768,25 +6569,6 @@ export type TransactionClient = Omit<Prisma.DefaultPrismaClient, runtime.ITXClie
         \`\`\`
       `)
     );
-    if (this.context.isSqlProvider()) {
-      clientOptions.add(
-        ts11.property("comments", ts11.array(ts11.namedType("runtime.SqlCommenterPlugin"))).optional().setDocComment(ts11.docComment`
-            SQL commenter plugins that add metadata to SQL queries as comments.
-            Comments follow the sqlcommenter format: https://google.github.io/sqlcommenter/
-
-            @example
-            \`\`\`
-            const prisma = new PrismaClient({
-              adapter,
-              comments: [
-                traceContext(),
-                queryInsights(),
-              ],
-            })
-            \`\`\`
-          `)
-      );
-    }
     return clientOptions;
   }
 };
@@ -5801,33 +6583,61 @@ var TSClient = class {
   dmmf;
   genericsInfo;
   toJS() {
-    const { edge, wasm, generator, datamodel: inlineSchema, runtimeName, reusedJs } = this.options;
+    const {
+      edge,
+      wasm,
+      binaryPaths,
+      generator,
+      outputDir,
+      datamodel: inlineSchema,
+      runtimeBase,
+      runtimeNameJs,
+      datasources,
+      copyEngine = true,
+      reusedJs,
+      envPaths
+    } = this.options;
     if (reusedJs) {
       return `module.exports = { ...require('${reusedJs}') }`;
     }
+    const relativeEnvPaths = {
+      rootEnvPath: envPaths.rootEnvPath && (0, import_internals7.pathToPosix)(import_path2.default.relative(outputDir, envPaths.rootEnvPath)),
+      schemaEnvPath: envPaths.schemaEnvPath && (0, import_internals7.pathToPosix)(import_path2.default.relative(outputDir, envPaths.schemaEnvPath))
+    };
+    const clientEngineType = (0, import_internals7.getClientEngineType)(generator);
+    generator.config.engineType = clientEngineType;
+    const binaryTargets = clientEngineType === import_internals7.ClientEngineType.Library ? Object.keys(binaryPaths.libqueryEngine ?? {}) : Object.keys(binaryPaths.queryEngine ?? {});
+    const inlineSchemaHash = import_crypto.default.createHash("sha256").update(Buffer.from(inlineSchema, "utf8").toString("base64")).digest("hex");
+    const datasourceFilePath = datasources[0].sourceFilePath;
     const config = {
-      previewFeatures: generator.previewFeatures,
+      generator,
+      relativeEnvPaths,
+      relativePath: (0, import_internals7.pathToPosix)(import_path2.default.relative(outputDir, import_path2.default.dirname(datasourceFilePath))),
       clientVersion: this.options.clientVersion,
       engineVersion: this.options.engineVersion,
+      datasourceNames: datasources.map((d) => d.name),
       activeProvider: this.options.activeProvider,
-      inlineSchema
+      postinstall: this.options.postinstall,
+      ciName: import_ci_info.default.name ?? void 0,
+      inlineDatasources: buildInlineDatasources(datasources),
+      inlineSchema,
+      inlineSchemaHash,
+      copyEngine
     };
+    const relativeOutdir = import_path2.default.relative(process.cwd(), outputDir);
     const code = `${commonCodeJS({ ...this.options, browser: false })}
 ${buildRequirePath(edge)}
 
 /**
  * Enums
  */
-${this.dmmf.schema.enumTypes.prisma?.map((type) => new Enum((0, import_dmmf.datamodelSchemaEnumToSchemaEnum)(type), true).toJS()).join("\n\n")}
+${this.dmmf.schema.enumTypes.prisma?.map((type) => new Enum(type, true).toJS()).join("\n\n")}
 ${this.dmmf.datamodel.enums.map((datamodelEnum) => new Enum((0, import_dmmf.datamodelEnumToSchemaEnum)(datamodelEnum), false).toJS()).join("\n\n")}
 
 ${new Enum(
       {
         name: "ModelName",
-        data: this.dmmf.mappings.modelOperations.map((m) => ({
-          key: m.model,
-          value: m.model
-        }))
+        values: this.dmmf.mappings.modelOperations.map((m) => m.model)
       },
       true
     ).toJS()}
@@ -5835,12 +6645,17 @@ ${new Enum(
  * Create the Client
  */
 const config = ${JSON.stringify(config, null, 2)}
-${buildRuntimeDataModel(this.dmmf.datamodel, runtimeName)}
-${buildQueryCompilerWasmModule(wasm, runtimeName)}
+${buildDirname(edge, relativeOutdir)}
+${buildRuntimeDataModel(this.dmmf.datamodel, runtimeNameJs)}
+${buildQueryEngineWasmModule(wasm, copyEngine, runtimeNameJs)}
+${buildQueryCompilerWasmModule(wasm, runtimeNameJs)}
+${buildInjectableEdgeEnv(edge, datasources)}
+${buildWarnEnvConflicts(edge, runtimeBase, runtimeNameJs)}
 ${buildDebugInitialization(edge)}
 const PrismaClient = getPrismaClient(config)
 exports.PrismaClient = PrismaClient
 Object.assign(exports, Prisma)
+${buildNFTAnnotations(edge || !copyEngine, clientEngineType, binaryTargets, relativeOutdir)}
 `;
     return code;
   }
@@ -5853,14 +6668,13 @@ Object.assign(exports, Prisma)
     const context = new GenerateContext({
       dmmf: this.dmmf,
       genericArgsInfo: this.genericsInfo,
-      generator: this.options.generator,
-      provider: this.options.activeProvider
+      generator: this.options.generator
     });
     const prismaClientClass = new PrismaClientClass(
       context,
       this.options.datasources,
       this.options.outputDir,
-      this.options.runtimeName,
+      this.options.runtimeNameTs,
       this.options.browser
     );
     const commonCode = commonCodeTS(this.options);
@@ -5870,9 +6684,7 @@ Object.assign(exports, Prisma)
       }
       return acc;
     }, []);
-    const prismaEnums = this.dmmf.schema.enumTypes.prisma?.map(
-      (type) => new Enum((0, import_dmmf.datamodelSchemaEnumToSchemaEnum)(type), true).toTS()
-    );
+    const prismaEnums = this.dmmf.schema.enumTypes.prisma?.map((type) => new Enum(type, true).toTS());
     const modelEnums = [];
     const modelEnumsAliases = [];
     for (const datamodelEnum of this.dmmf.datamodel.enums) {
@@ -5909,15 +6721,12 @@ ${modelEnumsAliases.join("\n\n")}
 ${prismaClientClass.toTSWithoutNamespace()}
 
 export namespace Prisma {
-${(0, import_indent_string7.default)(
+${(0, import_indent_string8.default)(
       `${commonCode.ts()}
 ${new Enum(
         {
           name: "ModelName",
-          data: this.dmmf.mappings.modelOperations.map((m) => ({
-            key: m.model,
-            value: m.model
-          }))
+          values: this.dmmf.mappings.modelOperations.map((m) => m.model)
         },
         true
       ).toTS()}
@@ -5994,23 +6803,20 @@ export const dmmf: runtime.BaseDMMF
   toBrowserJS() {
     const code = `${commonCodeJS({
       ...this.options,
-      runtimeName: "index-browser",
+      runtimeNameJs: "index-browser",
       browser: true
     })}
 /**
  * Enums
  */
 
-${this.dmmf.schema.enumTypes.prisma?.map((type) => new Enum((0, import_dmmf.datamodelSchemaEnumToSchemaEnum)(type), true).toJS()).join("\n\n")}
-${this.dmmf.schema.enumTypes.model?.map((type) => new Enum((0, import_dmmf.datamodelSchemaEnumToSchemaEnum)(type), false).toJS()).join("\n\n") ?? ""}
+${this.dmmf.schema.enumTypes.prisma?.map((type) => new Enum(type, true).toJS()).join("\n\n")}
+${this.dmmf.schema.enumTypes.model?.map((type) => new Enum(type, false).toJS()).join("\n\n") ?? ""}
 
 ${new Enum(
       {
         name: "ModelName",
-        data: this.dmmf.mappings.modelOperations.map((m) => ({
-          key: m.model,
-          value: m.model
-        }))
+        values: this.dmmf.mappings.modelOperations.map((m) => m.model)
       },
       true
     ).toJS()}
@@ -6051,7 +6857,7 @@ Object.assign(exports, Prisma)
 };
 
 // src/typedSql/buildDbEnums.ts
-var import_internals5 = require("@prisma/internals");
+var import_internals8 = require("@prisma/internals");
 var ts13 = __toESM(require("@prisma/ts-builders"));
 var DbEnumsList = class {
   enums;
@@ -6069,14 +6875,14 @@ var DbEnumsList = class {
   }
   *validJsIdentifiers() {
     for (const dbEnum of this.enums) {
-      if ((0, import_internals5.isValidJsIdentifier)(dbEnum.name)) {
+      if ((0, import_internals8.isValidJsIdentifier)(dbEnum.name)) {
         yield dbEnum;
       }
     }
   }
   *invalidJsIdentifiers() {
     for (const dbEnum of this.enums) {
-      if (!(0, import_internals5.isValidJsIdentifier)(dbEnum.name)) {
+      if (!(0, import_internals8.isValidJsIdentifier)(dbEnum.name)) {
         yield dbEnum;
       }
     }
@@ -6148,7 +6954,7 @@ var ts16 = __toESM(require("@prisma/ts-builders"));
 var import_ts_builders3 = require("@prisma/ts-builders");
 
 // src/typedSql/mapTypes.ts
-var import_internals6 = require("@prisma/internals");
+var import_internals9 = require("@prisma/internals");
 var ts15 = __toESM(require("@prisma/ts-builders"));
 var decimal = ts15.namedType("$runtime.Decimal");
 var uint8Array = ts15.namedType("$runtime.Bytes");
@@ -6242,7 +7048,7 @@ function getMappingConfig(introspectionType, enums) {
   return config;
 }
 function getEnumType(name) {
-  if ((0, import_internals6.isValidJsIdentifier)(name)) {
+  if ((0, import_internals9.isValidJsIdentifier)(name)) {
     return ts15.namedType(`$DbEnums.${name}`);
   }
   return ts15.namedType("$DbEnums").subKey(name);
@@ -6348,13 +7154,14 @@ function addPreamble(fileContent) {
 }
 
 // src/generateClient.ts
+var debug = (0, import_debug.Debug)("prisma:client:generateClient");
 var DenylistError = class extends Error {
   constructor(message) {
     super(message);
     this.stack = void 0;
   }
 };
-(0, import_internals7.setClassName)(DenylistError, "DenylistError");
+(0, import_internals10.setClassName)(DenylistError, "DenylistError");
 async function buildClient({
   schemaPath,
   runtimeBase,
@@ -6368,10 +7175,15 @@ async function buildClient({
   engineVersion,
   clientVersion,
   activeProvider,
+  postinstall,
+  copyEngine,
+  envPaths,
   typedSql
 }) {
+  const clientEngineType = (0, import_internals10.getClientEngineType)(generator);
   const baseClientOptions = {
     dmmf: getPrismaClientDMMF(dmmf),
+    envPaths: envPaths ?? { rootEnvPath: null, schemaEnvPath: void 0 },
     datasources,
     generator,
     binaryPaths,
@@ -6382,6 +7194,8 @@ async function buildClient({
     clientVersion,
     engineVersion,
     activeProvider,
+    postinstall,
+    copyEngine,
     datamodel,
     browser: false,
     edge: false,
@@ -6389,7 +7203,8 @@ async function buildClient({
   };
   const nodeClientOptions = {
     ...baseClientOptions,
-    runtimeName: "client"
+    runtimeNameJs: getNodeRuntimeName(clientEngineType),
+    runtimeNameTs: `${getNodeRuntimeName(clientEngineType)}.js`
   };
   const nodeClient = new TSClient(nodeClientOptions);
   const defaultClient = new TSClient({
@@ -6397,6 +7212,19 @@ async function buildClient({
     reusedTs: "index",
     reusedJs: "."
   });
+  const edgeClient = new TSClient({
+    ...baseClientOptions,
+    runtimeNameJs: "edge",
+    runtimeNameTs: "library.js",
+    reusedTs: "default",
+    edge: true
+  });
+  const rnTsClient = new TSClient({
+    ...baseClientOptions,
+    runtimeNameJs: "react-native",
+    runtimeNameTs: "react-native",
+    edge: true
+  });
   const trampolineTsClient = new TSClient({
     ...nodeClientOptions,
     reusedTs: "index",
@@ -6404,9 +7232,9 @@ async function buildClient({
   });
   const exportsMapBase = {
     node: "./index.js",
-    "edge-light": "./edge.js",
-    workerd: "./edge.js",
-    worker: "./edge.js",
+    "edge-light": "./wasm.js",
+    workerd: "./wasm.js",
+    worker: "./wasm.js",
     browser: "./index-browser.js",
     default: "./index.js"
   };
@@ -6430,10 +7258,7 @@ async function buildClient({
       ".": exportsMapDefault
     },
     version: clientVersion,
-    sideEffects: false,
-    dependencies: {
-      "@prisma/client-runtime-utils": clientVersion
-    }
+    sideEffects: false
   };
   const fileMap = {};
   fileMap["index.js"] = JS(nodeClient);
@@ -6441,16 +7266,28 @@ async function buildClient({
   fileMap["default.js"] = JS(defaultClient);
   fileMap["default.d.ts"] = TS(defaultClient);
   fileMap["index-browser.js"] = BrowserJS(nodeClient);
+  fileMap["edge.js"] = JS(edgeClient);
+  fileMap["edge.d.ts"] = TS(edgeClient);
   fileMap["client.js"] = JS(defaultClient);
   fileMap["client.d.ts"] = TS(defaultClient);
+  if (generator.previewFeatures.includes("reactNative")) {
+    fileMap["react-native.js"] = JS(rnTsClient);
+    fileMap["react-native.d.ts"] = TS(rnTsClient);
+  }
+  const usesClientEngine = clientEngineType === import_internals10.ClientEngineType.Client;
   fileMap["default.js"] = JS(trampolineTsClient);
   fileMap["default.d.ts"] = TS(trampolineTsClient);
-  fileMap["wasm-worker-loader.mjs"] = `export default import('./query_compiler_bg.wasm')`;
-  fileMap["wasm-edge-light-loader.mjs"] = `export default import('./query_compiler_bg.wasm?module')`;
+  if (usesClientEngine) {
+    fileMap["wasm-worker-loader.mjs"] = `export default import('./query_compiler_bg.wasm')`;
+    fileMap["wasm-edge-light-loader.mjs"] = `export default import('./query_compiler_bg.wasm?module')`;
+  } else {
+    fileMap["wasm-worker-loader.mjs"] = `export default import('./query_engine_bg.wasm')`;
+    fileMap["wasm-edge-light-loader.mjs"] = `export default import('./query_engine_bg.wasm?module')`;
+  }
   pkgJson["browser"] = "default.js";
   pkgJson["imports"] = {
-    // when `import('#wasm-compiler-loader')` is called, it will be resolved to the correct file
-    "#wasm-compiler-loader": {
+    // when `import('#wasm-engine-loader')` or `import('#wasm-compiler-loader')` is called, it will be resolved to the correct file
+    [usesClientEngine ? "#wasm-compiler-loader" : "#wasm-engine-loader"]: {
       // Keys reference: https://runtime-keys.proposal.wintercg.org/#keys
       /**
        * Vercel Edge Functions / Next.js Middlewares
@@ -6475,15 +7312,16 @@ async function buildClient({
   };
   const wasmClient = new TSClient({
     ...baseClientOptions,
-    runtimeName: "wasm-compiler-edge",
+    runtimeNameJs: usesClientEngine ? "wasm-compiler-edge" : "wasm-engine-edge",
+    runtimeNameTs: "library.js",
     reusedTs: "default",
     edge: true,
     wasm: true
   });
-  fileMap["edge.js"] = JS(wasmClient);
-  fileMap["edge.d.ts"] = TS(wasmClient);
+  fileMap["wasm.js"] = JS(wasmClient);
+  fileMap["wasm.d.ts"] = TS(wasmClient);
   if (typedSql && typedSql.length > 0) {
-    const edgeRuntimeName = "wasm-compiler-edge";
+    const edgeRuntimeName = usesClientEngine ? "wasm-compiler-edge" : "edge";
     const cjsEdgeIndex = `./sql/index.${edgeRuntimeName}.js`;
     const esmEdgeIndex = `./sql/index.${edgeRuntimeName}.mjs`;
     pkgJson.exports["./sql"] = {
@@ -6508,7 +7346,7 @@ async function buildClient({
     fileMap["sql"] = buildTypedSql({
       dmmf,
       runtimeBase: getTypedSqlRuntimeBase(runtimeBase),
-      mainRuntimeName: "client",
+      mainRuntimeName: getNodeRuntimeName(clientEngineType),
       queries: typedSql,
       edgeRuntimeName
     });
@@ -6531,11 +7369,20 @@ function getTypedSqlRuntimeBase(runtimeBase) {
   }
   return `../${runtimeBase}`;
 }
-function getDefaultOutdir(outputDir) {
-  if (outputDir.endsWith(import_path.default.normalize("node_modules/@prisma/client"))) {
-    return import_path.default.join(outputDir, "../../.prisma/client");
+async function getDefaultOutdir(outputDir) {
+  if (outputDir.endsWith(import_path3.default.normalize("node_modules/@prisma/client"))) {
+    return import_path3.default.join(outputDir, "../../.prisma/client");
+  }
+  if (process.env.INIT_CWD && process.env.npm_lifecycle_event === "postinstall" && !process.env.PWD?.includes(".pnpm")) {
+    if ((0, import_fs.existsSync)(import_path3.default.join(process.env.INIT_CWD, "package.json"))) {
+      return import_path3.default.join(process.env.INIT_CWD, "node_modules/.prisma/client");
+    }
+    const packagePath = await (0, import_package_up.packageUp)({ cwd: process.env.INIT_CWD });
+    if (packagePath) {
+      return import_path3.default.join(import_path3.default.dirname(packagePath), "node_modules/.prisma/client");
+    }
   }
-  return import_path.default.join(outputDir, "../../.prisma/client");
+  return import_path3.default.join(outputDir, "../../.prisma/client");
 }
 async function generateClient(options) {
   const {
@@ -6552,8 +7399,12 @@ async function generateClient(options) {
     clientVersion,
     engineVersion,
     activeProvider,
+    postinstall,
+    envPaths,
+    copyEngine = true,
     typedSql
   } = options;
+  const clientEngineType = (0, import_internals10.getClientEngineType)(generator);
   const { runtimeBase, outputDir } = await getGenerationDirs(options);
   const { prismaClientDmmf, fileMap } = await buildClient({
     datamodel,
@@ -6568,7 +7419,10 @@ async function generateClient(options) {
     clientVersion,
     engineVersion,
     activeProvider,
+    postinstall,
+    copyEngine,
     testMode,
+    envPaths,
     typedSql
   });
   const provider = datasources[0].provider;
@@ -6585,32 +7439,51 @@ async function generateClient(options) {
 To learn more about how to rename models, check out https://pris.ly/d/naming-models`;
     throw new DenylistError(message);
   }
+  if (!copyEngine) {
+    await deleteOutputDir(outputDir);
+  }
   await (0, import_fs_extra.ensureDir)(outputDir);
   await writeFileMap(outputDir, fileMap);
   if (copyRuntime || generator.isCustomOutput === true) {
-    const copiedRuntimeDir = import_path.default.join(outputDir, "runtime");
+    const copiedRuntimeDir = import_path3.default.join(outputDir, "runtime");
     await (0, import_fs_extra.ensureDir)(copiedRuntimeDir);
     await copyRuntimeFiles({
       from: runtimeSourcePath,
       to: copiedRuntimeDir,
       sourceMaps: copyRuntimeSourceMaps,
-      runtimeName: "client"
+      runtimeName: getNodeRuntimeName(clientEngineType)
     });
   }
-  const schemaTargetPath = import_path.default.join(outputDir, "schema.prisma");
+  const enginePath = clientEngineType === import_internals10.ClientEngineType.Library ? binaryPaths.libqueryEngine : binaryPaths.queryEngine;
+  if (copyEngine && enginePath) {
+    if (process.env.NETLIFY) {
+      await (0, import_fs_extra.ensureDir)("/tmp/prisma-engines");
+    }
+    for (const [binaryTarget, filePath] of Object.entries(enginePath)) {
+      const fileName = import_path3.default.basename(filePath);
+      let target;
+      if (process.env.NETLIFY && !["rhel-openssl-1.0.x", "rhel-openssl-3.0.x"].includes(binaryTarget)) {
+        target = import_path3.default.join("/tmp/prisma-engines", fileName);
+      } else {
+        target = import_path3.default.join(outputDir, fileName);
+      }
+      await (0, import_fetch_engine.overwriteFile)(filePath, target);
+    }
+  }
+  const schemaTargetPath = import_path3.default.join(outputDir, "schema.prisma");
   await import_promises.default.writeFile(schemaTargetPath, datamodel, { encoding: "utf-8" });
-  if (isWasmEngineSupported(provider)) {
+  const runtimeNeedsWasmEngine = clientEngineType === import_internals10.ClientEngineType.Client || copyEngine;
+  if (runtimeNeedsWasmEngine && isWasmEngineSupported(provider) && !testMode) {
     const suffix = provider === "postgres" ? "postgresql" : provider;
-    const filename = "query_compiler_bg";
-    const wasmJsBundlePath = import_path.default.join(runtimeSourcePath, `${filename}.${suffix}.wasm-base64.js`);
+    const filename = clientEngineType === import_internals10.ClientEngineType.Client ? "query_compiler_bg" : "query_engine_bg";
+    const wasmJsBundlePath = import_path3.default.join(runtimeSourcePath, `${filename}.${suffix}.wasm-base64.js`);
     const wasmBase64 = require(wasmJsBundlePath).wasm;
-    await import_promises.default.writeFile(import_path.default.join(outputDir, `${filename}.wasm`), Buffer.from(wasmBase64, "base64"));
-    await import_promises.default.copyFile(import_path.default.join(runtimeSourcePath, `${filename}.${suffix}.js`), import_path.default.join(outputDir, `${filename}.js`));
-    await import_promises.default.copyFile(wasmJsBundlePath, import_path.default.join(outputDir, `${filename}.wasm-base64.js`));
+    await import_promises.default.writeFile(import_path3.default.join(outputDir, `${filename}.wasm`), Buffer.from(wasmBase64, "base64"));
+    await import_promises.default.copyFile(import_path3.default.join(runtimeSourcePath, `${filename}.${suffix}.js`), import_path3.default.join(outputDir, `${filename}.js`));
   }
   try {
     const prismaCache = (0, import_env_paths.default)("prisma").cache;
-    const signalsPath = import_path.default.join(prismaCache, "last-generate");
+    const signalsPath = import_path3.default.join(prismaCache, "last-generate");
     await import_promises.default.mkdir(prismaCache, { recursive: true });
     await import_promises.default.writeFile(signalsPath, Date.now().toString());
   } catch {
@@ -6619,7 +7492,7 @@ To learn more about how to rename models, check out https://pris.ly/d/naming-mod
 function writeFileMap(outputDir, fileMap) {
   return Promise.all(
     Object.entries(fileMap).map(async ([fileName, content]) => {
-      const absolutePath = import_path.default.join(outputDir, fileName);
+      const absolutePath = import_path3.default.join(outputDir, fileName);
       await import_promises.default.rm(absolutePath, { recursive: true, force: true });
       if (typeof content === "string") {
         await import_promises.default.writeFile(absolutePath, content);
@@ -6631,7 +7504,7 @@ function writeFileMap(outputDir, fileMap) {
   );
 }
 function isWasmEngineSupported(provider) {
-  return provider === "postgresql" || provider === "postgres" || provider === "cockroachdb" || provider === "mysql" || provider === "sqlite" || provider === "sqlserver";
+  return provider === "postgresql" || provider === "postgres" || provider === "mysql" || provider === "sqlite" || provider === "sqlserver";
 }
 function validateDmmfAgainstDenylists(prismaClientDmmf) {
   const errorArray = [];
@@ -6719,18 +7592,18 @@ async function getGenerationDirs({
   testMode
 }) {
   const isCustomOutput = generator.isCustomOutput === true;
-  const normalizedOutputDir = import_path.default.normalize(outputDir);
+  const normalizedOutputDir = import_path3.default.normalize(outputDir);
   let userRuntimeImport = isCustomOutput ? "./runtime" : "@prisma/client/runtime";
-  let userOutputDir = isCustomOutput ? normalizedOutputDir : getDefaultOutdir(normalizedOutputDir);
+  let userOutputDir = isCustomOutput ? normalizedOutputDir : await getDefaultOutdir(normalizedOutputDir);
   if (testMode && runtimeBase) {
     userOutputDir = outputDir;
-    userRuntimeImport = (0, import_internals7.pathToPosix)(runtimeBase);
+    userRuntimeImport = (0, import_internals10.pathToPosix)(runtimeBase);
   }
   if (isCustomOutput) {
     await verifyOutputDirectory(userOutputDir, datamodel, schemaPath);
   }
-  const userPackageRoot = await (0, import_package_up.packageUp)({ cwd: import_path.default.dirname(userOutputDir) });
-  const userProjectRoot = userPackageRoot ? import_path.default.dirname(userPackageRoot) : process.cwd();
+  const userPackageRoot = await (0, import_package_up.packageUp)({ cwd: import_path3.default.dirname(userOutputDir) });
+  const userProjectRoot = userPackageRoot ? import_path3.default.dirname(userPackageRoot) : process.cwd();
   return {
     runtimeBase: userRuntimeImport,
     outputDir: userOutputDir,
@@ -6740,7 +7613,7 @@ async function getGenerationDirs({
 async function verifyOutputDirectory(directory, datamodel, schemaPath) {
   let content;
   try {
-    content = await import_promises.default.readFile(import_path.default.join(directory, "package.json"), "utf8");
+    content = await import_promises.default.readFile(import_path3.default.join(directory, "package.json"), "utf8");
   } catch (e) {
     if (e.code === "ENOENT") {
       return;
@@ -6783,17 +7656,43 @@ function findOutputPathDeclaration(datamodel) {
   }
   return null;
 }
+function getNodeRuntimeName(engineType) {
+  if (engineType === import_internals10.ClientEngineType.Binary) {
+    return "binary";
+  }
+  if (engineType === import_internals10.ClientEngineType.Library) {
+    return "library";
+  }
+  if (engineType === import_internals10.ClientEngineType.Client) {
+    return "client";
+  }
+  (0, import_internals10.assertNever)(engineType, "Unknown engine type");
+}
 async function copyRuntimeFiles({ from, to, runtimeName, sourceMaps }) {
-  const files = ["index-browser.js", "index-browser.d.ts", "wasm-compiler-edge.js"];
+  const files = [
+    // library.d.ts is always included, as it contains the actual runtime type
+    // definitions. Rest of the `runtime.d.ts` files just re-export everything
+    // from `library.d.ts`
+    "library.d.ts",
+    "index-browser.js",
+    "index-browser.d.ts",
+    "edge.js",
+    "edge-esm.js",
+    "react-native.js",
+    "wasm-engine-edge.js",
+    "wasm-compiler-edge.js"
+  ];
   files.push(`${runtimeName}.js`);
-  files.push(`${runtimeName}.d.ts`);
+  if (runtimeName !== "library") {
+    files.push(`${runtimeName}.d.ts`);
+  }
   if (sourceMaps) {
     files.push(...files.filter((file4) => file4.endsWith(".js")).map((file4) => `${file4}.map`));
   }
   await Promise.all(
     files.map(async (file4) => {
-      const sourcePath = import_path.default.join(from, file4);
-      const targetPath = import_path.default.join(to, file4);
+      const sourcePath = import_path3.default.join(from, file4);
+      const targetPath = import_path3.default.join(to, file4);
       if (file4.endsWith(".js")) {
         const content = await import_promises.default.readFile(sourcePath, "utf-8");
         await import_promises.default.writeFile(targetPath, addPreamble(content));
@@ -6803,31 +7702,1651 @@ async function copyRuntimeFiles({ from, to, runtimeName, sourceMaps }) {
     })
   );
 }
+async function deleteOutputDir(outputDir) {
+  try {
+    debug(`attempting to delete ${outputDir} recursively`);
+    if (require(`${outputDir}/package.json`).name?.startsWith(GENERATED_PACKAGE_NAME_PREFIX)) {
+      await import_promises.default.rmdir(outputDir, { recursive: true }).catch(() => {
+        debug(`failed to delete ${outputDir} recursively`);
+      });
+    }
+  } catch {
+    debug(`failed to delete ${outputDir} recursively, not found`);
+  }
+}
 function getUniquePackageName(datamodel) {
-  const hash = (0, import_crypto.createHash)("sha256");
+  const hash = (0, import_crypto2.createHash)("sha256");
   hash.write(datamodel);
   return `${GENERATED_PACKAGE_NAME_PREFIX}${hash.digest().toString("hex")}`;
 }
 var GENERATED_PACKAGE_NAME_PREFIX = "prisma-client-";
 
 // src/generator.ts
-var import_node_path2 = __toESM(require("node:path"));
+var import_node_path4 = __toESM(require("node:path"));
+var import_debug3 = require("@prisma/debug");
 var import_engines_version = require("@prisma/engines-version");
-var import_internals9 = require("@prisma/internals");
+var import_internals12 = require("@prisma/internals");
+var import_ts_pattern = require("ts-pattern");
 
 // package.json
-var version = "7.2.0-integration-engines-7-2-0-3-aqrln-zpupkzknszlw-04d61c41ec1a025cabe14093fa3121a5f45040ab.1";
+var version = "7.3.0-integration-fix-6-19-0-cloudflare-accelerate-engine.1";
 
 // src/resolvePrismaClient.ts
-var import_promises2 = __toESM(require("node:fs/promises"));
-var import_node_path = __toESM(require("node:path"));
+var import_promises3 = __toESM(require("node:fs/promises"));
+var import_node_path3 = __toESM(require("node:path"));
 var import_ni = require("@antfu/ni");
-var import_debug = require("@prisma/debug");
-var import_internals8 = require("@prisma/internals");
-var debug = (0, import_debug.Debug)("prisma:generator");
+var import_debug2 = require("@prisma/debug");
+var import_internals11 = require("@prisma/internals");
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/index.js
+var import_node_buffer2 = require("node:buffer");
+var import_node_path2 = __toESM(require("node:path"), 1);
+var import_node_child_process3 = __toESM(require("node:child_process"), 1);
+var import_node_process4 = __toESM(require("node:process"), 1);
+var import_cross_spawn = __toESM(require_cross_spawn(), 1);
+
+// ../../node_modules/.pnpm/strip-final-newline@3.0.0/node_modules/strip-final-newline/index.js
+function stripFinalNewline(input) {
+  const LF = typeof input === "string" ? "\n" : "\n".charCodeAt();
+  const CR = typeof input === "string" ? "\r" : "\r".charCodeAt();
+  if (input[input.length - 1] === LF) {
+    input = input.slice(0, -1);
+  }
+  if (input[input.length - 1] === CR) {
+    input = input.slice(0, -1);
+  }
+  return input;
+}
+
+// ../../node_modules/.pnpm/npm-run-path@5.3.0/node_modules/npm-run-path/index.js
+var import_node_process = __toESM(require("node:process"), 1);
+var import_node_path = __toESM(require("node:path"), 1);
+var import_node_url = require("node:url");
+
+// ../../node_modules/.pnpm/path-key@4.0.0/node_modules/path-key/index.js
+function pathKey(options = {}) {
+  const {
+    env = process.env,
+    platform = process.platform
+  } = options;
+  if (platform !== "win32") {
+    return "PATH";
+  }
+  return Object.keys(env).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+}
+
+// ../../node_modules/.pnpm/npm-run-path@5.3.0/node_modules/npm-run-path/index.js
+var npmRunPath = ({
+  cwd = import_node_process.default.cwd(),
+  path: pathOption = import_node_process.default.env[pathKey()],
+  preferLocal = true,
+  execPath = import_node_process.default.execPath,
+  addExecPath = true
+} = {}) => {
+  const cwdString = cwd instanceof URL ? (0, import_node_url.fileURLToPath)(cwd) : cwd;
+  const cwdPath = import_node_path.default.resolve(cwdString);
+  const result = [];
+  if (preferLocal) {
+    applyPreferLocal(result, cwdPath);
+  }
+  if (addExecPath) {
+    applyExecPath(result, execPath, cwdPath);
+  }
+  return [...result, pathOption].join(import_node_path.default.delimiter);
+};
+var applyPreferLocal = (result, cwdPath) => {
+  let previous;
+  while (previous !== cwdPath) {
+    result.push(import_node_path.default.join(cwdPath, "node_modules/.bin"));
+    previous = cwdPath;
+    cwdPath = import_node_path.default.resolve(cwdPath, "..");
+  }
+};
+var applyExecPath = (result, execPath, cwdPath) => {
+  const execPathString = execPath instanceof URL ? (0, import_node_url.fileURLToPath)(execPath) : execPath;
+  result.push(import_node_path.default.resolve(cwdPath, execPathString, ".."));
+};
+var npmRunPathEnv = ({ env = import_node_process.default.env, ...options } = {}) => {
+  env = { ...env };
+  const pathName = pathKey({ env });
+  options.path = env[pathName];
+  env[pathName] = npmRunPath(options);
+  return env;
+};
+
+// ../../node_modules/.pnpm/mimic-fn@4.0.0/node_modules/mimic-fn/index.js
+var copyProperty = (to, from, property11, ignoreNonConfigurable) => {
+  if (property11 === "length" || property11 === "prototype") {
+    return;
+  }
+  if (property11 === "arguments" || property11 === "caller") {
+    return;
+  }
+  const toDescriptor = Object.getOwnPropertyDescriptor(to, property11);
+  const fromDescriptor = Object.getOwnPropertyDescriptor(from, property11);
+  if (!canCopyProperty(toDescriptor, fromDescriptor) && ignoreNonConfigurable) {
+    return;
+  }
+  Object.defineProperty(to, property11, fromDescriptor);
+};
+var canCopyProperty = function(toDescriptor, fromDescriptor) {
+  return toDescriptor === void 0 || toDescriptor.configurable || toDescriptor.writable === fromDescriptor.writable && toDescriptor.enumerable === fromDescriptor.enumerable && toDescriptor.configurable === fromDescriptor.configurable && (toDescriptor.writable || toDescriptor.value === fromDescriptor.value);
+};
+var changePrototype = (to, from) => {
+  const fromPrototype = Object.getPrototypeOf(from);
+  if (fromPrototype === Object.getPrototypeOf(to)) {
+    return;
+  }
+  Object.setPrototypeOf(to, fromPrototype);
+};
+var wrappedToString = (withName, fromBody) => `/* Wrapped ${withName}*/
+${fromBody}`;
+var toStringDescriptor = Object.getOwnPropertyDescriptor(Function.prototype, "toString");
+var toStringName = Object.getOwnPropertyDescriptor(Function.prototype.toString, "name");
+var changeToString = (to, from, name) => {
+  const withName = name === "" ? "" : `with ${name.trim()}() `;
+  const newToString = wrappedToString.bind(null, withName, from.toString());
+  Object.defineProperty(newToString, "name", toStringName);
+  Object.defineProperty(to, "toString", { ...toStringDescriptor, value: newToString });
+};
+function mimicFunction(to, from, { ignoreNonConfigurable = false } = {}) {
+  const { name } = to;
+  for (const property11 of Reflect.ownKeys(from)) {
+    copyProperty(to, from, property11, ignoreNonConfigurable);
+  }
+  changePrototype(to, from);
+  changeToString(to, from, name);
+  return to;
+}
+
+// ../../node_modules/.pnpm/onetime@6.0.0/node_modules/onetime/index.js
+var calledFunctions = /* @__PURE__ */ new WeakMap();
+var onetime = (function_, options = {}) => {
+  if (typeof function_ !== "function") {
+    throw new TypeError("Expected a function");
+  }
+  let returnValue;
+  let callCount = 0;
+  const functionName = function_.displayName || function_.name || "<anonymous>";
+  const onetime2 = function(...arguments_) {
+    calledFunctions.set(onetime2, ++callCount);
+    if (callCount === 1) {
+      returnValue = function_.apply(this, arguments_);
+      function_ = null;
+    } else if (options.throw === true) {
+      throw new Error(`Function \`${functionName}\` can only be called once`);
+    }
+    return returnValue;
+  };
+  mimicFunction(onetime2, function_);
+  calledFunctions.set(onetime2, callCount);
+  return onetime2;
+};
+onetime.callCount = (function_) => {
+  if (!calledFunctions.has(function_)) {
+    throw new Error(`The given function \`${function_.name}\` is not wrapped by the \`onetime\` package`);
+  }
+  return calledFunctions.get(function_);
+};
+var onetime_default = onetime;
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/error.js
+var import_node_process2 = __toESM(require("node:process"), 1);
+
+// ../../node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/main.js
+var import_node_os2 = require("node:os");
+
+// ../../node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/realtime.js
+var getRealtimeSignals = () => {
+  const length = SIGRTMAX - SIGRTMIN + 1;
+  return Array.from({ length }, getRealtimeSignal);
+};
+var getRealtimeSignal = (value, index) => ({
+  name: `SIGRT${index + 1}`,
+  number: SIGRTMIN + index,
+  action: "terminate",
+  description: "Application-specific signal (realtime)",
+  standard: "posix"
+});
+var SIGRTMIN = 34;
+var SIGRTMAX = 64;
+
+// ../../node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/signals.js
+var import_node_os = require("node:os");
+
+// ../../node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/core.js
+var SIGNALS = [
+  {
+    name: "SIGHUP",
+    number: 1,
+    action: "terminate",
+    description: "Terminal closed",
+    standard: "posix"
+  },
+  {
+    name: "SIGINT",
+    number: 2,
+    action: "terminate",
+    description: "User interruption with CTRL-C",
+    standard: "ansi"
+  },
+  {
+    name: "SIGQUIT",
+    number: 3,
+    action: "core",
+    description: "User interruption with CTRL-\\",
+    standard: "posix"
+  },
+  {
+    name: "SIGILL",
+    number: 4,
+    action: "core",
+    description: "Invalid machine instruction",
+    standard: "ansi"
+  },
+  {
+    name: "SIGTRAP",
+    number: 5,
+    action: "core",
+    description: "Debugger breakpoint",
+    standard: "posix"
+  },
+  {
+    name: "SIGABRT",
+    number: 6,
+    action: "core",
+    description: "Aborted",
+    standard: "ansi"
+  },
+  {
+    name: "SIGIOT",
+    number: 6,
+    action: "core",
+    description: "Aborted",
+    standard: "bsd"
+  },
+  {
+    name: "SIGBUS",
+    number: 7,
+    action: "core",
+    description: "Bus error due to misaligned, non-existing address or paging error",
+    standard: "bsd"
+  },
+  {
+    name: "SIGEMT",
+    number: 7,
+    action: "terminate",
+    description: "Command should be emulated but is not implemented",
+    standard: "other"
+  },
+  {
+    name: "SIGFPE",
+    number: 8,
+    action: "core",
+    description: "Floating point arithmetic error",
+    standard: "ansi"
+  },
+  {
+    name: "SIGKILL",
+    number: 9,
+    action: "terminate",
+    description: "Forced termination",
+    standard: "posix",
+    forced: true
+  },
+  {
+    name: "SIGUSR1",
+    number: 10,
+    action: "terminate",
+    description: "Application-specific signal",
+    standard: "posix"
+  },
+  {
+    name: "SIGSEGV",
+    number: 11,
+    action: "core",
+    description: "Segmentation fault",
+    standard: "ansi"
+  },
+  {
+    name: "SIGUSR2",
+    number: 12,
+    action: "terminate",
+    description: "Application-specific signal",
+    standard: "posix"
+  },
+  {
+    name: "SIGPIPE",
+    number: 13,
+    action: "terminate",
+    description: "Broken pipe or socket",
+    standard: "posix"
+  },
+  {
+    name: "SIGALRM",
+    number: 14,
+    action: "terminate",
+    description: "Timeout or timer",
+    standard: "posix"
+  },
+  {
+    name: "SIGTERM",
+    number: 15,
+    action: "terminate",
+    description: "Termination",
+    standard: "ansi"
+  },
+  {
+    name: "SIGSTKFLT",
+    number: 16,
+    action: "terminate",
+    description: "Stack is empty or overflowed",
+    standard: "other"
+  },
+  {
+    name: "SIGCHLD",
+    number: 17,
+    action: "ignore",
+    description: "Child process terminated, paused or unpaused",
+    standard: "posix"
+  },
+  {
+    name: "SIGCLD",
+    number: 17,
+    action: "ignore",
+    description: "Child process terminated, paused or unpaused",
+    standard: "other"
+  },
+  {
+    name: "SIGCONT",
+    number: 18,
+    action: "unpause",
+    description: "Unpaused",
+    standard: "posix",
+    forced: true
+  },
+  {
+    name: "SIGSTOP",
+    number: 19,
+    action: "pause",
+    description: "Paused",
+    standard: "posix",
+    forced: true
+  },
+  {
+    name: "SIGTSTP",
+    number: 20,
+    action: "pause",
+    description: 'Paused using CTRL-Z or "suspend"',
+    standard: "posix"
+  },
+  {
+    name: "SIGTTIN",
+    number: 21,
+    action: "pause",
+    description: "Background process cannot read terminal input",
+    standard: "posix"
+  },
+  {
+    name: "SIGBREAK",
+    number: 21,
+    action: "terminate",
+    description: "User interruption with CTRL-BREAK",
+    standard: "other"
+  },
+  {
+    name: "SIGTTOU",
+    number: 22,
+    action: "pause",
+    description: "Background process cannot write to terminal output",
+    standard: "posix"
+  },
+  {
+    name: "SIGURG",
+    number: 23,
+    action: "ignore",
+    description: "Socket received out-of-band data",
+    standard: "bsd"
+  },
+  {
+    name: "SIGXCPU",
+    number: 24,
+    action: "core",
+    description: "Process timed out",
+    standard: "bsd"
+  },
+  {
+    name: "SIGXFSZ",
+    number: 25,
+    action: "core",
+    description: "File too big",
+    standard: "bsd"
+  },
+  {
+    name: "SIGVTALRM",
+    number: 26,
+    action: "terminate",
+    description: "Timeout or timer",
+    standard: "bsd"
+  },
+  {
+    name: "SIGPROF",
+    number: 27,
+    action: "terminate",
+    description: "Timeout or timer",
+    standard: "bsd"
+  },
+  {
+    name: "SIGWINCH",
+    number: 28,
+    action: "ignore",
+    description: "Terminal window size changed",
+    standard: "bsd"
+  },
+  {
+    name: "SIGIO",
+    number: 29,
+    action: "terminate",
+    description: "I/O is available",
+    standard: "other"
+  },
+  {
+    name: "SIGPOLL",
+    number: 29,
+    action: "terminate",
+    description: "Watched event",
+    standard: "other"
+  },
+  {
+    name: "SIGINFO",
+    number: 29,
+    action: "ignore",
+    description: "Request for process information",
+    standard: "other"
+  },
+  {
+    name: "SIGPWR",
+    number: 30,
+    action: "terminate",
+    description: "Device running out of power",
+    standard: "systemv"
+  },
+  {
+    name: "SIGSYS",
+    number: 31,
+    action: "core",
+    description: "Invalid system call",
+    standard: "other"
+  },
+  {
+    name: "SIGUNUSED",
+    number: 31,
+    action: "terminate",
+    description: "Invalid system call",
+    standard: "other"
+  }
+];
+
+// ../../node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/signals.js
+var getSignals = () => {
+  const realtimeSignals = getRealtimeSignals();
+  const signals2 = [...SIGNALS, ...realtimeSignals].map(normalizeSignal);
+  return signals2;
+};
+var normalizeSignal = ({
+  name,
+  number: defaultNumber,
+  description,
+  action,
+  forced = false,
+  standard
+}) => {
+  const {
+    signals: { [name]: constantSignal }
+  } = import_node_os.constants;
+  const supported = constantSignal !== void 0;
+  const number = supported ? constantSignal : defaultNumber;
+  return { name, number, description, supported, action, forced, standard };
+};
+
+// ../../node_modules/.pnpm/human-signals@5.0.0/node_modules/human-signals/build/src/main.js
+var getSignalsByName = () => {
+  const signals2 = getSignals();
+  return Object.fromEntries(signals2.map(getSignalByName));
+};
+var getSignalByName = ({
+  name,
+  number,
+  description,
+  supported,
+  action,
+  forced,
+  standard
+}) => [name, { name, number, description, supported, action, forced, standard }];
+var signalsByName = getSignalsByName();
+var getSignalsByNumber = () => {
+  const signals2 = getSignals();
+  const length = SIGRTMAX + 1;
+  const signalsA = Array.from(
+    { length },
+    (value, number) => getSignalByNumber(number, signals2)
+  );
+  return Object.assign({}, ...signalsA);
+};
+var getSignalByNumber = (number, signals2) => {
+  const signal = findSignalByNumber(number, signals2);
+  if (signal === void 0) {
+    return {};
+  }
+  const { name, description, supported, action, forced, standard } = signal;
+  return {
+    [number]: {
+      name,
+      number,
+      description,
+      supported,
+      action,
+      forced,
+      standard
+    }
+  };
+};
+var findSignalByNumber = (number, signals2) => {
+  const signal = signals2.find(({ name }) => import_node_os2.constants.signals[name] === number);
+  if (signal !== void 0) {
+    return signal;
+  }
+  return signals2.find((signalA) => signalA.number === number);
+};
+var signalsByNumber = getSignalsByNumber();
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/error.js
+var getErrorPrefix = ({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled }) => {
+  if (timedOut) {
+    return `timed out after ${timeout} milliseconds`;
+  }
+  if (isCanceled) {
+    return "was canceled";
+  }
+  if (errorCode !== void 0) {
+    return `failed with ${errorCode}`;
+  }
+  if (signal !== void 0) {
+    return `was killed with ${signal} (${signalDescription})`;
+  }
+  if (exitCode !== void 0) {
+    return `failed with exit code ${exitCode}`;
+  }
+  return "failed";
+};
+var makeError = ({
+  stdout,
+  stderr,
+  all,
+  error,
+  signal,
+  exitCode,
+  command,
+  escapedCommand,
+  timedOut,
+  isCanceled,
+  killed,
+  parsed: { options: { timeout, cwd = import_node_process2.default.cwd() } }
+}) => {
+  exitCode = exitCode === null ? void 0 : exitCode;
+  signal = signal === null ? void 0 : signal;
+  const signalDescription = signal === void 0 ? void 0 : signalsByName[signal].description;
+  const errorCode = error && error.code;
+  const prefix = getErrorPrefix({ timedOut, timeout, errorCode, signal, signalDescription, exitCode, isCanceled });
+  const execaMessage = `Command ${prefix}: ${command}`;
+  const isError = Object.prototype.toString.call(error) === "[object Error]";
+  const shortMessage = isError ? `${execaMessage}
+${error.message}` : execaMessage;
+  const message = [shortMessage, stderr, stdout].filter(Boolean).join("\n");
+  if (isError) {
+    error.originalMessage = error.message;
+    error.message = message;
+  } else {
+    error = new Error(message);
+  }
+  error.shortMessage = shortMessage;
+  error.command = command;
+  error.escapedCommand = escapedCommand;
+  error.exitCode = exitCode;
+  error.signal = signal;
+  error.signalDescription = signalDescription;
+  error.stdout = stdout;
+  error.stderr = stderr;
+  error.cwd = cwd;
+  if (all !== void 0) {
+    error.all = all;
+  }
+  if ("bufferedData" in error) {
+    delete error.bufferedData;
+  }
+  error.failed = true;
+  error.timedOut = Boolean(timedOut);
+  error.isCanceled = isCanceled;
+  error.killed = killed && !timedOut;
+  return error;
+};
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/stdio.js
+var aliases = ["stdin", "stdout", "stderr"];
+var hasAlias = (options) => aliases.some((alias) => options[alias] !== void 0);
+var normalizeStdio = (options) => {
+  if (!options) {
+    return;
+  }
+  const { stdio } = options;
+  if (stdio === void 0) {
+    return aliases.map((alias) => options[alias]);
+  }
+  if (hasAlias(options)) {
+    throw new Error(`It's not possible to provide \`stdio\` in combination with one of ${aliases.map((alias) => `\`${alias}\``).join(", ")}`);
+  }
+  if (typeof stdio === "string") {
+    return stdio;
+  }
+  if (!Array.isArray(stdio)) {
+    throw new TypeError(`Expected \`stdio\` to be of type \`string\` or \`Array\`, got \`${typeof stdio}\``);
+  }
+  const length = Math.max(stdio.length, aliases.length);
+  return Array.from({ length }, (value, index) => stdio[index]);
+};
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/kill.js
+var import_node_os3 = __toESM(require("node:os"), 1);
+
+// ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/signals.js
+var signals = [];
+signals.push("SIGHUP", "SIGINT", "SIGTERM");
+if (process.platform !== "win32") {
+  signals.push(
+    "SIGALRM",
+    "SIGABRT",
+    "SIGVTALRM",
+    "SIGXCPU",
+    "SIGXFSZ",
+    "SIGUSR2",
+    "SIGTRAP",
+    "SIGSYS",
+    "SIGQUIT",
+    "SIGIOT"
+    // should detect profiler and enable/disable accordingly.
+    // see #21
+    // 'SIGPROF'
+  );
+}
+if (process.platform === "linux") {
+  signals.push("SIGIO", "SIGPOLL", "SIGPWR", "SIGSTKFLT");
+}
+
+// ../../node_modules/.pnpm/signal-exit@4.1.0/node_modules/signal-exit/dist/mjs/index.js
+var processOk = (process7) => !!process7 && typeof process7 === "object" && typeof process7.removeListener === "function" && typeof process7.emit === "function" && typeof process7.reallyExit === "function" && typeof process7.listeners === "function" && typeof process7.kill === "function" && typeof process7.pid === "number" && typeof process7.on === "function";
+var kExitEmitter = Symbol.for("signal-exit emitter");
+var global2 = globalThis;
+var ObjectDefineProperty = Object.defineProperty.bind(Object);
+var Emitter = class {
+  emitted = {
+    afterExit: false,
+    exit: false
+  };
+  listeners = {
+    afterExit: [],
+    exit: []
+  };
+  count = 0;
+  id = Math.random();
+  constructor() {
+    if (global2[kExitEmitter]) {
+      return global2[kExitEmitter];
+    }
+    ObjectDefineProperty(global2, kExitEmitter, {
+      value: this,
+      writable: false,
+      enumerable: false,
+      configurable: false
+    });
+  }
+  on(ev, fn) {
+    this.listeners[ev].push(fn);
+  }
+  removeListener(ev, fn) {
+    const list = this.listeners[ev];
+    const i = list.indexOf(fn);
+    if (i === -1) {
+      return;
+    }
+    if (i === 0 && list.length === 1) {
+      list.length = 0;
+    } else {
+      list.splice(i, 1);
+    }
+  }
+  emit(ev, code, signal) {
+    if (this.emitted[ev]) {
+      return false;
+    }
+    this.emitted[ev] = true;
+    let ret = false;
+    for (const fn of this.listeners[ev]) {
+      ret = fn(code, signal) === true || ret;
+    }
+    if (ev === "exit") {
+      ret = this.emit("afterExit", code, signal) || ret;
+    }
+    return ret;
+  }
+};
+var SignalExitBase = class {
+};
+var signalExitWrap = (handler) => {
+  return {
+    onExit(cb, opts) {
+      return handler.onExit(cb, opts);
+    },
+    load() {
+      return handler.load();
+    },
+    unload() {
+      return handler.unload();
+    }
+  };
+};
+var SignalExitFallback = class extends SignalExitBase {
+  onExit() {
+    return () => {
+    };
+  }
+  load() {
+  }
+  unload() {
+  }
+};
+var SignalExit = class extends SignalExitBase {
+  // "SIGHUP" throws an `ENOSYS` error on Windows,
+  // so use a supported signal instead
+  /* c8 ignore start */
+  #hupSig = process4.platform === "win32" ? "SIGINT" : "SIGHUP";
+  /* c8 ignore stop */
+  #emitter = new Emitter();
+  #process;
+  #originalProcessEmit;
+  #originalProcessReallyExit;
+  #sigListeners = {};
+  #loaded = false;
+  constructor(process7) {
+    super();
+    this.#process = process7;
+    this.#sigListeners = {};
+    for (const sig of signals) {
+      this.#sigListeners[sig] = () => {
+        const listeners = this.#process.listeners(sig);
+        let { count } = this.#emitter;
+        const p = process7;
+        if (typeof p.__signal_exit_emitter__ === "object" && typeof p.__signal_exit_emitter__.count === "number") {
+          count += p.__signal_exit_emitter__.count;
+        }
+        if (listeners.length === count) {
+          this.unload();
+          const ret = this.#emitter.emit("exit", null, sig);
+          const s = sig === "SIGHUP" ? this.#hupSig : sig;
+          if (!ret)
+            process7.kill(process7.pid, s);
+        }
+      };
+    }
+    this.#originalProcessReallyExit = process7.reallyExit;
+    this.#originalProcessEmit = process7.emit;
+  }
+  onExit(cb, opts) {
+    if (!processOk(this.#process)) {
+      return () => {
+      };
+    }
+    if (this.#loaded === false) {
+      this.load();
+    }
+    const ev = opts?.alwaysLast ? "afterExit" : "exit";
+    this.#emitter.on(ev, cb);
+    return () => {
+      this.#emitter.removeListener(ev, cb);
+      if (this.#emitter.listeners["exit"].length === 0 && this.#emitter.listeners["afterExit"].length === 0) {
+        this.unload();
+      }
+    };
+  }
+  load() {
+    if (this.#loaded) {
+      return;
+    }
+    this.#loaded = true;
+    this.#emitter.count += 1;
+    for (const sig of signals) {
+      try {
+        const fn = this.#sigListeners[sig];
+        if (fn)
+          this.#process.on(sig, fn);
+      } catch (_) {
+      }
+    }
+    this.#process.emit = (ev, ...a) => {
+      return this.#processEmit(ev, ...a);
+    };
+    this.#process.reallyExit = (code) => {
+      return this.#processReallyExit(code);
+    };
+  }
+  unload() {
+    if (!this.#loaded) {
+      return;
+    }
+    this.#loaded = false;
+    signals.forEach((sig) => {
+      const listener = this.#sigListeners[sig];
+      if (!listener) {
+        throw new Error("Listener not defined for signal: " + sig);
+      }
+      try {
+        this.#process.removeListener(sig, listener);
+      } catch (_) {
+      }
+    });
+    this.#process.emit = this.#originalProcessEmit;
+    this.#process.reallyExit = this.#originalProcessReallyExit;
+    this.#emitter.count -= 1;
+  }
+  #processReallyExit(code) {
+    if (!processOk(this.#process)) {
+      return 0;
+    }
+    this.#process.exitCode = code || 0;
+    this.#emitter.emit("exit", this.#process.exitCode, null);
+    return this.#originalProcessReallyExit.call(this.#process, this.#process.exitCode);
+  }
+  #processEmit(ev, ...args) {
+    const og = this.#originalProcessEmit;
+    if (ev === "exit" && processOk(this.#process)) {
+      if (typeof args[0] === "number") {
+        this.#process.exitCode = args[0];
+      }
+      const ret = og.call(this.#process, ev, ...args);
+      this.#emitter.emit("exit", this.#process.exitCode, null);
+      return ret;
+    } else {
+      return og.call(this.#process, ev, ...args);
+    }
+  }
+};
+var process4 = globalThis.process;
+var {
+  /**
+   * Called when the process is exiting, whether via signal, explicit
+   * exit, or running out of stuff to do.
+   *
+   * If the global process object is not suitable for instrumentation,
+   * then this will be a no-op.
+   *
+   * Returns a function that may be used to unload signal-exit.
+   */
+  onExit,
+  /**
+   * Load the listeners.  Likely you never need to call this, unless
+   * doing a rather deep integration with signal-exit functionality.
+   * Mostly exposed for the benefit of testing.
+   *
+   * @internal
+   */
+  load,
+  /**
+   * Unload the listeners.  Likely you never need to call this, unless
+   * doing a rather deep integration with signal-exit functionality.
+   * Mostly exposed for the benefit of testing.
+   *
+   * @internal
+   */
+  unload
+} = signalExitWrap(processOk(process4) ? new SignalExit(process4) : new SignalExitFallback());
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/kill.js
+var DEFAULT_FORCE_KILL_TIMEOUT = 1e3 * 5;
+var spawnedKill = (kill, signal = "SIGTERM", options = {}) => {
+  const killResult = kill(signal);
+  setKillTimeout(kill, signal, options, killResult);
+  return killResult;
+};
+var setKillTimeout = (kill, signal, options, killResult) => {
+  if (!shouldForceKill(signal, options, killResult)) {
+    return;
+  }
+  const timeout = getForceKillAfterTimeout(options);
+  const t = setTimeout(() => {
+    kill("SIGKILL");
+  }, timeout);
+  if (t.unref) {
+    t.unref();
+  }
+};
+var shouldForceKill = (signal, { forceKillAfterTimeout }, killResult) => isSigterm(signal) && forceKillAfterTimeout !== false && killResult;
+var isSigterm = (signal) => signal === import_node_os3.default.constants.signals.SIGTERM || typeof signal === "string" && signal.toUpperCase() === "SIGTERM";
+var getForceKillAfterTimeout = ({ forceKillAfterTimeout = true }) => {
+  if (forceKillAfterTimeout === true) {
+    return DEFAULT_FORCE_KILL_TIMEOUT;
+  }
+  if (!Number.isFinite(forceKillAfterTimeout) || forceKillAfterTimeout < 0) {
+    throw new TypeError(`Expected the \`forceKillAfterTimeout\` option to be a non-negative integer, got \`${forceKillAfterTimeout}\` (${typeof forceKillAfterTimeout})`);
+  }
+  return forceKillAfterTimeout;
+};
+var spawnedCancel = (spawned, context) => {
+  const killResult = spawned.kill();
+  if (killResult) {
+    context.isCanceled = true;
+  }
+};
+var timeoutKill = (spawned, signal, reject) => {
+  spawned.kill(signal);
+  reject(Object.assign(new Error("Timed out"), { timedOut: true, signal }));
+};
+var setupTimeout = (spawned, { timeout, killSignal = "SIGTERM" }, spawnedPromise) => {
+  if (timeout === 0 || timeout === void 0) {
+    return spawnedPromise;
+  }
+  let timeoutId;
+  const timeoutPromise = new Promise((resolve, reject) => {
+    timeoutId = setTimeout(() => {
+      timeoutKill(spawned, killSignal, reject);
+    }, timeout);
+  });
+  const safeSpawnedPromise = spawnedPromise.finally(() => {
+    clearTimeout(timeoutId);
+  });
+  return Promise.race([timeoutPromise, safeSpawnedPromise]);
+};
+var validateTimeout = ({ timeout }) => {
+  if (timeout !== void 0 && (!Number.isFinite(timeout) || timeout < 0)) {
+    throw new TypeError(`Expected the \`timeout\` option to be a non-negative integer, got \`${timeout}\` (${typeof timeout})`);
+  }
+};
+var setExitHandler = async (spawned, { cleanup, detached }, timedPromise) => {
+  if (!cleanup || detached) {
+    return timedPromise;
+  }
+  const removeExitHandler = onExit(() => {
+    spawned.kill();
+  });
+  return timedPromise.finally(() => {
+    removeExitHandler();
+  });
+};
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/pipe.js
+var import_node_fs = require("node:fs");
+var import_node_child_process = require("node:child_process");
+
+// ../../node_modules/.pnpm/is-stream@3.0.0/node_modules/is-stream/index.js
+function isStream(stream) {
+  return stream !== null && typeof stream === "object" && typeof stream.pipe === "function";
+}
+function isWritableStream(stream) {
+  return isStream(stream) && stream.writable !== false && typeof stream._write === "function" && typeof stream._writableState === "object";
+}
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/pipe.js
+var isExecaChildProcess = (target) => target instanceof import_node_child_process.ChildProcess && typeof target.then === "function";
+var pipeToTarget = (spawned, streamName, target) => {
+  if (typeof target === "string") {
+    spawned[streamName].pipe((0, import_node_fs.createWriteStream)(target));
+    return spawned;
+  }
+  if (isWritableStream(target)) {
+    spawned[streamName].pipe(target);
+    return spawned;
+  }
+  if (!isExecaChildProcess(target)) {
+    throw new TypeError("The second argument must be a string, a stream or an Execa child process.");
+  }
+  if (!isWritableStream(target.stdin)) {
+    throw new TypeError("The target child process's stdin must be available.");
+  }
+  spawned[streamName].pipe(target.stdin);
+  return target;
+};
+var addPipeMethods = (spawned) => {
+  if (spawned.stdout !== null) {
+    spawned.pipeStdout = pipeToTarget.bind(void 0, spawned, "stdout");
+  }
+  if (spawned.stderr !== null) {
+    spawned.pipeStderr = pipeToTarget.bind(void 0, spawned, "stderr");
+  }
+  if (spawned.all !== void 0) {
+    spawned.pipeAll = pipeToTarget.bind(void 0, spawned, "all");
+  }
+};
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/stream.js
+var import_node_fs2 = require("node:fs");
+var import_promises2 = require("node:timers/promises");
+
+// ../../node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/contents.js
+var getStreamContents = async (stream, { init: init2, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, finalize }, { maxBuffer = Number.POSITIVE_INFINITY } = {}) => {
+  if (!isAsyncIterable(stream)) {
+    throw new Error("The first argument must be a Readable, a ReadableStream, or an async iterable.");
+  }
+  const state = init2();
+  state.length = 0;
+  try {
+    for await (const chunk of stream) {
+      const chunkType = getChunkType(chunk);
+      const convertedChunk = convertChunk[chunkType](chunk, state);
+      appendChunk({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
+    }
+    appendFinalChunk({ state, convertChunk, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer });
+    return finalize(state);
+  } catch (error) {
+    error.bufferedData = finalize(state);
+    throw error;
+  }
+};
+var appendFinalChunk = ({ state, getSize, truncateChunk, addChunk, getFinalChunk, maxBuffer }) => {
+  const convertedChunk = getFinalChunk(state);
+  if (convertedChunk !== void 0) {
+    appendChunk({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer });
+  }
+};
+var appendChunk = ({ convertedChunk, state, getSize, truncateChunk, addChunk, maxBuffer }) => {
+  const chunkSize = getSize(convertedChunk);
+  const newLength = state.length + chunkSize;
+  if (newLength <= maxBuffer) {
+    addNewChunk(convertedChunk, state, addChunk, newLength);
+    return;
+  }
+  const truncatedChunk = truncateChunk(convertedChunk, maxBuffer - state.length);
+  if (truncatedChunk !== void 0) {
+    addNewChunk(truncatedChunk, state, addChunk, maxBuffer);
+  }
+  throw new MaxBufferError();
+};
+var addNewChunk = (convertedChunk, state, addChunk, newLength) => {
+  state.contents = addChunk(convertedChunk, state, newLength);
+  state.length = newLength;
+};
+var isAsyncIterable = (stream) => typeof stream === "object" && stream !== null && typeof stream[Symbol.asyncIterator] === "function";
+var getChunkType = (chunk) => {
+  const typeOfChunk = typeof chunk;
+  if (typeOfChunk === "string") {
+    return "string";
+  }
+  if (typeOfChunk !== "object" || chunk === null) {
+    return "others";
+  }
+  if (globalThis.Buffer?.isBuffer(chunk)) {
+    return "buffer";
+  }
+  const prototypeName = objectToString.call(chunk);
+  if (prototypeName === "[object ArrayBuffer]") {
+    return "arrayBuffer";
+  }
+  if (prototypeName === "[object DataView]") {
+    return "dataView";
+  }
+  if (Number.isInteger(chunk.byteLength) && Number.isInteger(chunk.byteOffset) && objectToString.call(chunk.buffer) === "[object ArrayBuffer]") {
+    return "typedArray";
+  }
+  return "others";
+};
+var { toString: objectToString } = Object.prototype;
+var MaxBufferError = class extends Error {
+  name = "MaxBufferError";
+  constructor() {
+    super("maxBuffer exceeded");
+  }
+};
+
+// ../../node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/utils.js
+var identity = (value) => value;
+var noop = () => void 0;
+var getContentsProp = ({ contents }) => contents;
+var throwObjectStream = (chunk) => {
+  throw new Error(`Streams in object mode are not supported: ${String(chunk)}`);
+};
+var getLengthProp = (convertedChunk) => convertedChunk.length;
+
+// ../../node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/array-buffer.js
+async function getStreamAsArrayBuffer(stream, options) {
+  return getStreamContents(stream, arrayBufferMethods, options);
+}
+var initArrayBuffer = () => ({ contents: new ArrayBuffer(0) });
+var useTextEncoder = (chunk) => textEncoder.encode(chunk);
+var textEncoder = new TextEncoder();
+var useUint8Array = (chunk) => new Uint8Array(chunk);
+var useUint8ArrayWithOffset = (chunk) => new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+var truncateArrayBufferChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
+var addArrayBufferChunk = (convertedChunk, { contents, length: previousLength }, length) => {
+  const newContents = hasArrayBufferResize() ? resizeArrayBuffer(contents, length) : resizeArrayBufferSlow(contents, length);
+  new Uint8Array(newContents).set(convertedChunk, previousLength);
+  return newContents;
+};
+var resizeArrayBufferSlow = (contents, length) => {
+  if (length <= contents.byteLength) {
+    return contents;
+  }
+  const arrayBuffer = new ArrayBuffer(getNewContentsLength(length));
+  new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
+  return arrayBuffer;
+};
+var resizeArrayBuffer = (contents, length) => {
+  if (length <= contents.maxByteLength) {
+    contents.resize(length);
+    return contents;
+  }
+  const arrayBuffer = new ArrayBuffer(length, { maxByteLength: getNewContentsLength(length) });
+  new Uint8Array(arrayBuffer).set(new Uint8Array(contents), 0);
+  return arrayBuffer;
+};
+var getNewContentsLength = (length) => SCALE_FACTOR ** Math.ceil(Math.log(length) / Math.log(SCALE_FACTOR));
+var SCALE_FACTOR = 2;
+var finalizeArrayBuffer = ({ contents, length }) => hasArrayBufferResize() ? contents : contents.slice(0, length);
+var hasArrayBufferResize = () => "resize" in ArrayBuffer.prototype;
+var arrayBufferMethods = {
+  init: initArrayBuffer,
+  convertChunk: {
+    string: useTextEncoder,
+    buffer: useUint8Array,
+    arrayBuffer: useUint8Array,
+    dataView: useUint8ArrayWithOffset,
+    typedArray: useUint8ArrayWithOffset,
+    others: throwObjectStream
+  },
+  getSize: getLengthProp,
+  truncateChunk: truncateArrayBufferChunk,
+  addChunk: addArrayBufferChunk,
+  getFinalChunk: noop,
+  finalize: finalizeArrayBuffer
+};
+
+// ../../node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/buffer.js
+async function getStreamAsBuffer(stream, options) {
+  if (!("Buffer" in globalThis)) {
+    throw new Error("getStreamAsBuffer() is only supported in Node.js");
+  }
+  try {
+    return arrayBufferToNodeBuffer(await getStreamAsArrayBuffer(stream, options));
+  } catch (error) {
+    if (error.bufferedData !== void 0) {
+      error.bufferedData = arrayBufferToNodeBuffer(error.bufferedData);
+    }
+    throw error;
+  }
+}
+var arrayBufferToNodeBuffer = (arrayBuffer) => globalThis.Buffer.from(arrayBuffer);
+
+// ../../node_modules/.pnpm/get-stream@8.0.1/node_modules/get-stream/source/string.js
+async function getStreamAsString(stream, options) {
+  return getStreamContents(stream, stringMethods, options);
+}
+var initString = () => ({ contents: "", textDecoder: new TextDecoder() });
+var useTextDecoder = (chunk, { textDecoder }) => textDecoder.decode(chunk, { stream: true });
+var addStringChunk = (convertedChunk, { contents }) => contents + convertedChunk;
+var truncateStringChunk = (convertedChunk, chunkSize) => convertedChunk.slice(0, chunkSize);
+var getFinalStringChunk = ({ textDecoder }) => {
+  const finalChunk = textDecoder.decode();
+  return finalChunk === "" ? void 0 : finalChunk;
+};
+var stringMethods = {
+  init: initString,
+  convertChunk: {
+    string: identity,
+    buffer: useTextDecoder,
+    arrayBuffer: useTextDecoder,
+    dataView: useTextDecoder,
+    typedArray: useTextDecoder,
+    others: throwObjectStream
+  },
+  getSize: getLengthProp,
+  truncateChunk: truncateStringChunk,
+  addChunk: addStringChunk,
+  getFinalChunk: getFinalStringChunk,
+  finalize: getContentsProp
+};
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/stream.js
+var import_merge_stream = __toESM(require_merge_stream(), 1);
+var validateInputOptions = (input) => {
+  if (input !== void 0) {
+    throw new TypeError("The `input` and `inputFile` options cannot be both set.");
+  }
+};
+var getInputSync = ({ input, inputFile }) => {
+  if (typeof inputFile !== "string") {
+    return input;
+  }
+  validateInputOptions(input);
+  return (0, import_node_fs2.readFileSync)(inputFile);
+};
+var handleInputSync = (options) => {
+  const input = getInputSync(options);
+  if (isStream(input)) {
+    throw new TypeError("The `input` option cannot be a stream in sync mode");
+  }
+  return input;
+};
+var getInput = ({ input, inputFile }) => {
+  if (typeof inputFile !== "string") {
+    return input;
+  }
+  validateInputOptions(input);
+  return (0, import_node_fs2.createReadStream)(inputFile);
+};
+var handleInput = (spawned, options) => {
+  const input = getInput(options);
+  if (input === void 0) {
+    return;
+  }
+  if (isStream(input)) {
+    input.pipe(spawned.stdin);
+  } else {
+    spawned.stdin.end(input);
+  }
+};
+var makeAllStream = (spawned, { all }) => {
+  if (!all || !spawned.stdout && !spawned.stderr) {
+    return;
+  }
+  const mixed = (0, import_merge_stream.default)();
+  if (spawned.stdout) {
+    mixed.add(spawned.stdout);
+  }
+  if (spawned.stderr) {
+    mixed.add(spawned.stderr);
+  }
+  return mixed;
+};
+var getBufferedData = async (stream, streamPromise) => {
+  if (!stream || streamPromise === void 0) {
+    return;
+  }
+  await (0, import_promises2.setTimeout)(0);
+  stream.destroy();
+  try {
+    return await streamPromise;
+  } catch (error) {
+    return error.bufferedData;
+  }
+};
+var getStreamPromise = (stream, { encoding, buffer, maxBuffer }) => {
+  if (!stream || !buffer) {
+    return;
+  }
+  if (encoding === "utf8" || encoding === "utf-8") {
+    return getStreamAsString(stream, { maxBuffer });
+  }
+  if (encoding === null || encoding === "buffer") {
+    return getStreamAsBuffer(stream, { maxBuffer });
+  }
+  return applyEncoding(stream, maxBuffer, encoding);
+};
+var applyEncoding = async (stream, maxBuffer, encoding) => {
+  const buffer = await getStreamAsBuffer(stream, { maxBuffer });
+  return buffer.toString(encoding);
+};
+var getSpawnedResult = async ({ stdout, stderr, all }, { encoding, buffer, maxBuffer }, processDone) => {
+  const stdoutPromise = getStreamPromise(stdout, { encoding, buffer, maxBuffer });
+  const stderrPromise = getStreamPromise(stderr, { encoding, buffer, maxBuffer });
+  const allPromise = getStreamPromise(all, { encoding, buffer, maxBuffer: maxBuffer * 2 });
+  try {
+    return await Promise.all([processDone, stdoutPromise, stderrPromise, allPromise]);
+  } catch (error) {
+    return Promise.all([
+      { error, signal: error.signal, timedOut: error.timedOut },
+      getBufferedData(stdout, stdoutPromise),
+      getBufferedData(stderr, stderrPromise),
+      getBufferedData(all, allPromise)
+    ]);
+  }
+};
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/promise.js
+var nativePromisePrototype = (async () => {
+})().constructor.prototype;
+var descriptors = ["then", "catch", "finally"].map((property11) => [
+  property11,
+  Reflect.getOwnPropertyDescriptor(nativePromisePrototype, property11)
+]);
+var mergePromise = (spawned, promise2) => {
+  for (const [property11, descriptor] of descriptors) {
+    const value = typeof promise2 === "function" ? (...args) => Reflect.apply(descriptor.value, promise2(), args) : descriptor.value.bind(promise2);
+    Reflect.defineProperty(spawned, property11, { ...descriptor, value });
+  }
+};
+var getSpawnedPromise = (spawned) => new Promise((resolve, reject) => {
+  spawned.on("exit", (exitCode, signal) => {
+    resolve({ exitCode, signal });
+  });
+  spawned.on("error", (error) => {
+    reject(error);
+  });
+  if (spawned.stdin) {
+    spawned.stdin.on("error", (error) => {
+      reject(error);
+    });
+  }
+});
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/command.js
+var import_node_buffer = require("node:buffer");
+var import_node_child_process2 = require("node:child_process");
+var normalizeArgs = (file4, args = []) => {
+  if (!Array.isArray(args)) {
+    return [file4];
+  }
+  return [file4, ...args];
+};
+var NO_ESCAPE_REGEXP = /^[\w.-]+$/;
+var escapeArg = (arg) => {
+  if (typeof arg !== "string" || NO_ESCAPE_REGEXP.test(arg)) {
+    return arg;
+  }
+  return `"${arg.replaceAll('"', '\\"')}"`;
+};
+var joinCommand = (file4, args) => normalizeArgs(file4, args).join(" ");
+var getEscapedCommand = (file4, args) => normalizeArgs(file4, args).map((arg) => escapeArg(arg)).join(" ");
+var SPACES_REGEXP = / +/g;
+var parseCommand = (command) => {
+  const tokens = [];
+  for (const token of command.trim().split(SPACES_REGEXP)) {
+    const previousToken = tokens.at(-1);
+    if (previousToken && previousToken.endsWith("\\")) {
+      tokens[tokens.length - 1] = `${previousToken.slice(0, -1)} ${token}`;
+    } else {
+      tokens.push(token);
+    }
+  }
+  return tokens;
+};
+var parseExpression = (expression) => {
+  const typeOfExpression = typeof expression;
+  if (typeOfExpression === "string") {
+    return expression;
+  }
+  if (typeOfExpression === "number") {
+    return String(expression);
+  }
+  if (typeOfExpression === "object" && expression !== null && !(expression instanceof import_node_child_process2.ChildProcess) && "stdout" in expression) {
+    const typeOfStdout = typeof expression.stdout;
+    if (typeOfStdout === "string") {
+      return expression.stdout;
+    }
+    if (import_node_buffer.Buffer.isBuffer(expression.stdout)) {
+      return expression.stdout.toString();
+    }
+    throw new TypeError(`Unexpected "${typeOfStdout}" stdout in template expression`);
+  }
+  throw new TypeError(`Unexpected "${typeOfExpression}" in template expression`);
+};
+var concatTokens = (tokens, nextTokens, isNew) => isNew || tokens.length === 0 || nextTokens.length === 0 ? [...tokens, ...nextTokens] : [
+  ...tokens.slice(0, -1),
+  `${tokens.at(-1)}${nextTokens[0]}`,
+  ...nextTokens.slice(1)
+];
+var parseTemplate = ({ templates, expressions, tokens, index, template }) => {
+  const templateString = template ?? templates.raw[index];
+  const templateTokens = templateString.split(SPACES_REGEXP).filter(Boolean);
+  const newTokens = concatTokens(
+    tokens,
+    templateTokens,
+    templateString.startsWith(" ")
+  );
+  if (index === expressions.length) {
+    return newTokens;
+  }
+  const expression = expressions[index];
+  const expressionTokens = Array.isArray(expression) ? expression.map((expression2) => parseExpression(expression2)) : [parseExpression(expression)];
+  return concatTokens(
+    newTokens,
+    expressionTokens,
+    templateString.endsWith(" ")
+  );
+};
+var parseTemplates = (templates, expressions) => {
+  let tokens = [];
+  for (const [index, template] of templates.entries()) {
+    tokens = parseTemplate({ templates, expressions, tokens, index, template });
+  }
+  return tokens;
+};
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/lib/verbose.js
+var import_node_util = require("node:util");
+var import_node_process3 = __toESM(require("node:process"), 1);
+var verboseDefault = (0, import_node_util.debuglog)("execa").enabled;
+var padField = (field, padding) => String(field).padStart(padding, "0");
+var getTimestamp = () => {
+  const date2 = /* @__PURE__ */ new Date();
+  return `${padField(date2.getHours(), 2)}:${padField(date2.getMinutes(), 2)}:${padField(date2.getSeconds(), 2)}.${padField(date2.getMilliseconds(), 3)}`;
+};
+var logCommand = (escapedCommand, { verbose }) => {
+  if (!verbose) {
+    return;
+  }
+  import_node_process3.default.stderr.write(`[${getTimestamp()}] ${escapedCommand}
+`);
+};
+
+// ../../node_modules/.pnpm/execa@8.0.1/node_modules/execa/index.js
+var DEFAULT_MAX_BUFFER = 1e3 * 1e3 * 100;
+var getEnv = ({ env: envOption, extendEnv, preferLocal, localDir, execPath }) => {
+  const env = extendEnv ? { ...import_node_process4.default.env, ...envOption } : envOption;
+  if (preferLocal) {
+    return npmRunPathEnv({ env, cwd: localDir, execPath });
+  }
+  return env;
+};
+var handleArguments = (file4, args, options = {}) => {
+  const parsed = import_cross_spawn.default._parse(file4, args, options);
+  file4 = parsed.command;
+  args = parsed.args;
+  options = parsed.options;
+  options = {
+    maxBuffer: DEFAULT_MAX_BUFFER,
+    buffer: true,
+    stripFinalNewline: true,
+    extendEnv: true,
+    preferLocal: false,
+    localDir: options.cwd || import_node_process4.default.cwd(),
+    execPath: import_node_process4.default.execPath,
+    encoding: "utf8",
+    reject: true,
+    cleanup: true,
+    all: false,
+    windowsHide: true,
+    verbose: verboseDefault,
+    ...options
+  };
+  options.env = getEnv(options);
+  options.stdio = normalizeStdio(options);
+  if (import_node_process4.default.platform === "win32" && import_node_path2.default.basename(file4, ".exe") === "cmd") {
+    args.unshift("/q");
+  }
+  return { file: file4, args, options, parsed };
+};
+var handleOutput = (options, value, error) => {
+  if (typeof value !== "string" && !import_node_buffer2.Buffer.isBuffer(value)) {
+    return error === void 0 ? void 0 : "";
+  }
+  if (options.stripFinalNewline) {
+    return stripFinalNewline(value);
+  }
+  return value;
+};
+function execa(file4, args, options) {
+  const parsed = handleArguments(file4, args, options);
+  const command = joinCommand(file4, args);
+  const escapedCommand = getEscapedCommand(file4, args);
+  logCommand(escapedCommand, parsed.options);
+  validateTimeout(parsed.options);
+  let spawned;
+  try {
+    spawned = import_node_child_process3.default.spawn(parsed.file, parsed.args, parsed.options);
+  } catch (error) {
+    const dummySpawned = new import_node_child_process3.default.ChildProcess();
+    const errorPromise = Promise.reject(makeError({
+      error,
+      stdout: "",
+      stderr: "",
+      all: "",
+      command,
+      escapedCommand,
+      parsed,
+      timedOut: false,
+      isCanceled: false,
+      killed: false
+    }));
+    mergePromise(dummySpawned, errorPromise);
+    return dummySpawned;
+  }
+  const spawnedPromise = getSpawnedPromise(spawned);
+  const timedPromise = setupTimeout(spawned, parsed.options, spawnedPromise);
+  const processDone = setExitHandler(spawned, parsed.options, timedPromise);
+  const context = { isCanceled: false };
+  spawned.kill = spawnedKill.bind(null, spawned.kill.bind(spawned));
+  spawned.cancel = spawnedCancel.bind(null, spawned, context);
+  const handlePromise = async () => {
+    const [{ error, exitCode, signal, timedOut }, stdoutResult, stderrResult, allResult] = await getSpawnedResult(spawned, parsed.options, processDone);
+    const stdout = handleOutput(parsed.options, stdoutResult);
+    const stderr = handleOutput(parsed.options, stderrResult);
+    const all = handleOutput(parsed.options, allResult);
+    if (error || exitCode !== 0 || signal !== null) {
+      const returnedError = makeError({
+        error,
+        exitCode,
+        signal,
+        stdout,
+        stderr,
+        all,
+        command,
+        escapedCommand,
+        parsed,
+        timedOut,
+        isCanceled: context.isCanceled || (parsed.options.signal ? parsed.options.signal.aborted : false),
+        killed: spawned.killed
+      });
+      if (!parsed.options.reject) {
+        return returnedError;
+      }
+      throw returnedError;
+    }
+    return {
+      command,
+      escapedCommand,
+      exitCode: 0,
+      stdout,
+      stderr,
+      all,
+      failed: false,
+      timedOut: false,
+      isCanceled: false,
+      killed: false
+    };
+  };
+  const handlePromiseOnce = onetime_default(handlePromise);
+  handleInput(spawned, parsed.options);
+  spawned.all = makeAllStream(spawned, parsed.options);
+  addPipeMethods(spawned);
+  mergePromise(spawned, handlePromiseOnce);
+  return spawned;
+}
+function execaSync(file4, args, options) {
+  const parsed = handleArguments(file4, args, options);
+  const command = joinCommand(file4, args);
+  const escapedCommand = getEscapedCommand(file4, args);
+  logCommand(escapedCommand, parsed.options);
+  const input = handleInputSync(parsed.options);
+  let result;
+  try {
+    result = import_node_child_process3.default.spawnSync(parsed.file, parsed.args, { ...parsed.options, input });
+  } catch (error) {
+    throw makeError({
+      error,
+      stdout: "",
+      stderr: "",
+      all: "",
+      command,
+      escapedCommand,
+      parsed,
+      timedOut: false,
+      isCanceled: false,
+      killed: false
+    });
+  }
+  const stdout = handleOutput(parsed.options, result.stdout, result.error);
+  const stderr = handleOutput(parsed.options, result.stderr, result.error);
+  if (result.error || result.status !== 0 || result.signal !== null) {
+    const error = makeError({
+      stdout,
+      stderr,
+      error: result.error,
+      signal: result.signal,
+      exitCode: result.status,
+      command,
+      escapedCommand,
+      parsed,
+      timedOut: result.error && result.error.code === "ETIMEDOUT",
+      isCanceled: false,
+      killed: result.signal !== null
+    });
+    if (!parsed.options.reject) {
+      return error;
+    }
+    throw error;
+  }
+  return {
+    command,
+    escapedCommand,
+    exitCode: 0,
+    stdout,
+    stderr,
+    failed: false,
+    timedOut: false,
+    isCanceled: false,
+    killed: false
+  };
+}
+var normalizeScriptStdin = ({ input, inputFile, stdio }) => input === void 0 && inputFile === void 0 && stdio === void 0 ? { stdin: "inherit" } : {};
+var normalizeScriptOptions = (options = {}) => ({
+  preferLocal: true,
+  ...normalizeScriptStdin(options),
+  ...options
+});
+function create$(options) {
+  function $3(templatesOrOptions, ...expressions) {
+    if (!Array.isArray(templatesOrOptions)) {
+      return create$({ ...options, ...templatesOrOptions });
+    }
+    const [file4, ...args] = parseTemplates(templatesOrOptions, expressions);
+    return execa(file4, args, normalizeScriptOptions(options));
+  }
+  $3.sync = (templates, ...expressions) => {
+    if (!Array.isArray(templates)) {
+      throw new TypeError("Please use $(options).sync`command` instead of $.sync(options)`command`.");
+    }
+    const [file4, ...args] = parseTemplates(templates, expressions);
+    return execaSync(file4, args, normalizeScriptOptions(options));
+  };
+  return $3;
+}
+var $2 = create$();
+function execaCommand(command, options) {
+  const [file4, ...args] = parseCommand(command);
+  return execa(file4, args, options);
+}
+
+// src/resolvePrismaClient.ts
+var debug2 = (0, import_debug2.Debug)("prisma:generator");
 async function resolvePrismaClient(baseDir) {
   const prismaClientDir = await findPrismaClientDir(baseDir);
-  debug("baseDir", baseDir);
+  debug2("baseDir", baseDir);
   if (!prismaClientDir) {
     throw new Error(
       `Could not resolve @prisma/client.
@@ -6838,16 +9357,83 @@ Please try to install it with ${bold(
   }
   return prismaClientDir;
 }
+async function resolveOrInstallPrismaClient(baseDir, version2) {
+  let prismaClientDir = await findPrismaClientDir(baseDir);
+  debug2("baseDir", baseDir);
+  if (prismaClientDir) {
+    return prismaClientDir;
+  }
+  let projectRoot = (0, import_internals11.longestCommonPathPrefix)(baseDir, process.cwd());
+  debug2("projectRoot", projectRoot);
+  const warningTag = `${bold("Warning:")} ${dim("[Prisma auto-install on generate]")}`;
+  if (projectRoot === void 0) {
+    console.warn(
+      yellow(
+        `${warningTag} The Prisma schema directory ${bold(baseDir)} and the current working directory ${bold(
+          process.cwd()
+        )} have no common ancestor. The Prisma schema directory will be used as the project root.`
+      )
+    );
+    projectRoot = baseDir;
+  }
+  try {
+    await import_promises3.default.stat(import_node_path3.default.join(projectRoot, "package.json"));
+  } catch (err) {
+    if (err.code === "ENOENT") {
+      console.warn(
+        yellow(
+          `${warningTag} Prisma could not find a ${bold("package.json")} file in the inferred project root ${bold(
+            projectRoot
+          )}. During the next step, when an auto-install of Prisma package(s) will be attempted, it will then be created by your package manager on the appropriate level if necessary.`
+        )
+      );
+    } else {
+      throw err;
+    }
+  }
+  const prismaCliDir = await (0, import_internals11.resolvePkg)("prisma", { basedir: baseDir });
+  if (process.platform === "win32" && await isYarnUsed(baseDir)) {
+    const hasCli = (s) => prismaCliDir !== void 0 ? s : "";
+    const missingCli = (s) => prismaCliDir === void 0 ? s : "";
+    throw new Error(
+      `Could not resolve ${missingCli(`${bold("prisma")} and `)}${bold(
+        "@prisma/client"
+      )} in the current project. Please install ${hasCli("it")}${missingCli("them")} with ${missingCli(
+        `${bold(green(`${await getPackageCmd(baseDir, "add", "prisma", "-D")}`))} and `
+      )}${bold(green(`${await getPackageCmd(baseDir, "add", "@prisma/client")}`))}, and rerun ${bold(
+        await getPackageCmd(baseDir, "execute", "prisma generate")
+      )} \u{1F64F}.`
+    );
+  }
+  if (!prismaCliDir) {
+    await runPackageCmd(projectRoot, "add", `prisma@${version2}`, "-D", "--silent");
+  }
+  await runPackageCmd(projectRoot, "add", `@prisma/client@${version2}`, "--silent");
+  prismaClientDir = await findPrismaClientDir(import_node_path3.default.join(".", baseDir));
+  if (!prismaClientDir) {
+    throw new Error(
+      `Could not resolve @prisma/client despite the installation that we just tried.
+Please try to install it by hand with ${bold(
+        green(`${await getPackageCmd(baseDir, "add", "@prisma/client")}`)
+      )} and rerun ${bold(await getPackageCmd(baseDir, "execute", "prisma generate"))} \u{1F64F}.`
+    );
+  }
+  console.info(
+    `
+\u2714 Installed the ${bold(green("@prisma/client"))} and ${bold(green("prisma"))} packages in your project`
+  );
+  return prismaClientDir;
+}
 async function findPrismaClientDir(baseDir) {
   const resolveOpts = { basedir: baseDir, preserveSymlinks: true };
-  const cliDir = await (0, import_internals8.resolvePkg)("prisma", resolveOpts);
-  const clientDir = await (0, import_internals8.resolvePkg)("@prisma/client", resolveOpts);
-  const resolvedClientDir = clientDir && await import_promises2.default.realpath(clientDir);
-  debug("prismaCliDir", cliDir);
-  debug("prismaClientDir", clientDir);
+  const cliDir = await (0, import_internals11.resolvePkg)("prisma", resolveOpts);
+  const clientDir = await (0, import_internals11.resolvePkg)("@prisma/client", resolveOpts);
+  const resolvedClientDir = clientDir && await import_promises3.default.realpath(clientDir);
+  debug2("prismaCliDir", cliDir);
+  debug2("prismaClientDir", clientDir);
   if (cliDir === void 0) return resolvedClientDir;
   if (clientDir === void 0) return resolvedClientDir;
-  const relDir = import_node_path.default.relative(cliDir, clientDir).split(import_node_path.default.sep);
+  const relDir = import_node_path3.default.relative(cliDir, clientDir).split(import_node_path3.default.sep);
   if (relDir[0] !== ".." || relDir[1] === "..") return void 0;
   return resolvedClientDir;
 }
@@ -6855,34 +9441,56 @@ async function getPackageCmd(cwd, cmd, ...args) {
   const agent = await (0, import_ni.detect)({ cwd, autoInstall: false, programmatic: true });
   return (0, import_ni.getCommand)(agent ?? "npm", cmd, args);
 }
+async function isYarnUsed(baseDir) {
+  const agent = await (0, import_ni.detect)({ cwd: baseDir, autoInstall: false, programmatic: true });
+  return agent === "yarn" || agent === "yarn@berry";
+}
+async function runPackageCmd(cwd, cmd, ...args) {
+  await execaCommand(await getPackageCmd(cwd, cmd, ...args), {
+    // we skip this because we are already in the generator
+    env: { PRISMA_SKIP_POSTINSTALL_GENERATE: "true" },
+    stdio: "inherit",
+    cwd
+  });
+}
 
 // src/generator.ts
+var debug3 = (0, import_debug3.Debug)("prisma:client:generator");
 var PrismaClientJsGenerator = class {
   name = "prisma-client-js";
   #shouldResolvePrismaClient;
+  #shouldInstallMissingPackages;
   #runtimePath;
   #cachedPrismaClientPath;
-  constructor({ shouldResolvePrismaClient = true, runtimePath } = {}) {
+  constructor({
+    shouldResolvePrismaClient = true,
+    shouldInstallMissingPackages = true,
+    runtimePath
+  } = {}) {
     this.#shouldResolvePrismaClient = shouldResolvePrismaClient;
+    this.#shouldInstallMissingPackages = shouldInstallMissingPackages;
     this.#runtimePath = runtimePath;
   }
   async getManifest(config) {
+    const requiresEngines = (0, import_ts_pattern.match)((0, import_internals12.getClientEngineType)(config)).with(import_internals12.ClientEngineType.Library, () => ["libqueryEngine"]).with(import_internals12.ClientEngineType.Binary, () => ["queryEngine"]).with(import_internals12.ClientEngineType.Client, () => []).exhaustive();
+    debug3("requiresEngines", requiresEngines);
     const defaultOutput = this.#shouldResolvePrismaClient ? await this.#getPrismaClientPath(config) : ".prisma/client";
     return {
       defaultOutput,
       prettyName: "Prisma Client",
       version,
-      requiresEngines: [],
+      requiresEngines,
       requiresEngineVersion: import_engines_version.enginesVersion
     };
   }
   async generate(options) {
-    const outputDir = (0, import_internals9.parseEnvValue)(options.generator.output);
+    const outputDir = (0, import_internals12.parseEnvValue)(options.generator.output);
     await generateClient({
       datamodel: options.datamodel,
       schemaPath: options.schemaPath,
       binaryPaths: options.binaryPaths,
       datasources: options.datasources,
+      envPaths: options.envPaths,
       outputDir,
       copyRuntime: Boolean(options.generator.config.copyRuntime),
       copyRuntimeSourceMaps: Boolean(process.env.PRISMA_COPY_RUNTIME_SOURCEMAPS),
@@ -6892,6 +9500,8 @@ var PrismaClientJsGenerator = class {
       engineVersion: options.version,
       clientVersion: version,
       activeProvider: options.datasources[0]?.activeProvider,
+      postinstall: options.postinstall,
+      copyEngine: !options.noEngine,
       typedSql: options.typedSql
     });
   }
@@ -6899,20 +9509,27 @@ var PrismaClientJsGenerator = class {
     if (this.#cachedPrismaClientPath) {
       return this.#cachedPrismaClientPath;
     }
-    this.#cachedPrismaClientPath = await resolvePrismaClient(import_node_path2.default.dirname(config.sourceFilePath));
+    this.#cachedPrismaClientPath = await this.#resolveOrInstallPrismaClient(import_node_path4.default.dirname(config.sourceFilePath));
     return this.#cachedPrismaClientPath;
   }
   async #getRuntimePath(config) {
     if (this.#runtimePath) {
       return this.#runtimePath;
     }
-    this.#runtimePath = import_node_path2.default.join(await this.#getPrismaClientPath(config), "runtime");
+    this.#runtimePath = import_node_path4.default.join(await this.#getPrismaClientPath(config), "runtime");
     return this.#runtimePath;
   }
+  async #resolveOrInstallPrismaClient(baseDir) {
+    if (this.#shouldInstallMissingPackages && !process.env.PRISMA_GENERATE_SKIP_AUTOINSTALL) {
+      return await resolveOrInstallPrismaClient(baseDir, version);
+    } else {
+      return await resolvePrismaClient(baseDir);
+    }
+  }
 };
 
 // src/utils/types/dmmfToTypes.ts
-var import_node_path3 = __toESM(require("node:path"));
+var import_node_path5 = __toESM(require("node:path"));
 function dmmfToTypes(dmmf) {
   return new TSClient({
     dmmf,
@@ -6920,8 +9537,9 @@ function dmmfToTypes(dmmf) {
     clientVersion: "",
     engineVersion: "",
     runtimeBase: "@prisma/client",
-    runtimeName: "client",
-    runtimeSourcePath: import_node_path3.default.join(__dirname, "../../../runtime"),
+    runtimeNameJs: "library",
+    runtimeNameTs: "library",
+    runtimeSourcePath: import_node_path5.default.join(__dirname, "../../../runtime"),
     schemaPath: "",
     outputDir: "",
     activeProvider: "",
@@ -6939,7 +9557,11 @@ function dmmfToTypes(dmmf) {
     datamodel: "",
     browser: false,
     edge: false,
-    wasm: false
+    wasm: false,
+    envPaths: {
+      rootEnvPath: null,
+      schemaEnvPath: void 0
+    }
   }).toTS();
 }
 // Annotate the CommonJS export names for ESM import in node: