@prisma/client-generator-ts 6.12.0-dev.4 → 6.12.0-dev.40

package/dist/index.mjs

@@ -85,54 +85,54 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs2) {
+    function patch(fs3) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs2);
-      }
-      if (!fs2.lutimes) {
-        patchLutimes(fs2);
-      }
-      fs2.chown = chownFix(fs2.chown);
-      fs2.fchown = chownFix(fs2.fchown);
-      fs2.lchown = chownFix(fs2.lchown);
-      fs2.chmod = chmodFix(fs2.chmod);
-      fs2.fchmod = chmodFix(fs2.fchmod);
-      fs2.lchmod = chmodFix(fs2.lchmod);
-      fs2.chownSync = chownFixSync(fs2.chownSync);
-      fs2.fchownSync = chownFixSync(fs2.fchownSync);
-      fs2.lchownSync = chownFixSync(fs2.lchownSync);
-      fs2.chmodSync = chmodFixSync(fs2.chmodSync);
-      fs2.fchmodSync = chmodFixSync(fs2.fchmodSync);
-      fs2.lchmodSync = chmodFixSync(fs2.lchmodSync);
-      fs2.stat = statFix(fs2.stat);
-      fs2.fstat = statFix(fs2.fstat);
-      fs2.lstat = statFix(fs2.lstat);
-      fs2.statSync = statFixSync(fs2.statSync);
-      fs2.fstatSync = statFixSync(fs2.fstatSync);
-      fs2.lstatSync = statFixSync(fs2.lstatSync);
-      if (fs2.chmod && !fs2.lchmod) {
-        fs2.lchmod = function(path5, mode, cb) {
+        patchLchmod(fs3);
+      }
+      if (!fs3.lutimes) {
+        patchLutimes(fs3);
+      }
+      fs3.chown = chownFix(fs3.chown);
+      fs3.fchown = chownFix(fs3.fchown);
+      fs3.lchown = chownFix(fs3.lchown);
+      fs3.chmod = chmodFix(fs3.chmod);
+      fs3.fchmod = chmodFix(fs3.fchmod);
+      fs3.lchmod = chmodFix(fs3.lchmod);
+      fs3.chownSync = chownFixSync(fs3.chownSync);
+      fs3.fchownSync = chownFixSync(fs3.fchownSync);
+      fs3.lchownSync = chownFixSync(fs3.lchownSync);
+      fs3.chmodSync = chmodFixSync(fs3.chmodSync);
+      fs3.fchmodSync = chmodFixSync(fs3.fchmodSync);
+      fs3.lchmodSync = chmodFixSync(fs3.lchmodSync);
+      fs3.stat = statFix(fs3.stat);
+      fs3.fstat = statFix(fs3.fstat);
+      fs3.lstat = statFix(fs3.lstat);
+      fs3.statSync = statFixSync(fs3.statSync);
+      fs3.fstatSync = statFixSync(fs3.fstatSync);
+      fs3.lstatSync = statFixSync(fs3.lstatSync);
+      if (fs3.chmod && !fs3.lchmod) {
+        fs3.lchmod = function(path6, mode, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs2.lchmodSync = function() {
+        fs3.lchmodSync = function() {
         };
       }
-      if (fs2.chown && !fs2.lchown) {
-        fs2.lchown = function(path5, uid, gid, cb) {
+      if (fs3.chown && !fs3.lchown) {
+        fs3.lchown = function(path6, uid, gid, cb) {
           if (cb) process.nextTick(cb);
         };
-        fs2.lchownSync = function() {
+        fs3.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs2.rename = typeof fs2.rename !== "function" ? fs2.rename : function(fs$rename) {
+        fs3.rename = typeof fs3.rename !== "function" ? fs3.rename : function(fs$rename) {
           function rename(from, to, cb) {
             var start = Date.now();
             var backoff = 0;
             fs$rename(from, to, function CB(er) {
               if (er && (er.code === "EACCES" || er.code === "EPERM" || er.code === "EBUSY") && Date.now() - start < 6e4) {
                 setTimeout(function() {
-                  fs2.stat(to, function(stater, st) {
+                  fs3.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -148,9 +148,9 @@ var require_polyfills = __commonJS({
           }
           if (Object.setPrototypeOf) Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        }(fs2.rename);
+        }(fs3.rename);
       }
-      fs2.read = typeof fs2.read !== "function" ? fs2.read : function(fs$read) {
+      fs3.read = typeof fs3.read !== "function" ? fs3.read : function(fs$read) {
         function read(fd, buffer, offset, length, position, callback_) {
           var callback;
           if (callback_ && typeof callback_ === "function") {
@@ -158,22 +158,22 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
+                return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
               }
               callback_.apply(this, arguments);
             };
           }
-          return fs$read.call(fs2, fd, buffer, offset, length, position, callback);
+          return fs$read.call(fs3, fd, buffer, offset, length, position, callback);
         }
         if (Object.setPrototypeOf) Object.setPrototypeOf(read, fs$read);
         return read;
-      }(fs2.read);
-      fs2.readSync = typeof fs2.readSync !== "function" ? fs2.readSync : /* @__PURE__ */ function(fs$readSync) {
+      }(fs3.read);
+      fs3.readSync = typeof fs3.readSync !== "function" ? fs3.readSync : /* @__PURE__ */ function(fs$readSync) {
         return function(fd, buffer, offset, length, position) {
           var eagCounter = 0;
           while (true) {
             try {
-              return fs$readSync.call(fs2, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs3, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -183,11 +183,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs2.readSync);
-      function patchLchmod(fs3) {
-        fs3.lchmod = function(path5, mode, callback) {
-          fs3.open(
-            path5,
+      }(fs3.readSync);
+      function patchLchmod(fs4) {
+        fs4.lchmod = function(path6, mode, callback) {
+          fs4.open(
+            path6,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -195,80 +195,80 @@ var require_polyfills = __commonJS({
                 if (callback) callback(err);
                 return;
               }
-              fs3.fchmod(fd, mode, function(err2) {
-                fs3.close(fd, function(err22) {
+              fs4.fchmod(fd, mode, function(err2) {
+                fs4.close(fd, function(err22) {
                   if (callback) callback(err2 || err22);
                 });
               });
             }
           );
         };
-        fs3.lchmodSync = function(path5, mode) {
-          var fd = fs3.openSync(path5, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs4.lchmodSync = function(path6, mode) {
+          var fd = fs4.openSync(path6, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs3.fchmodSync(fd, mode);
+            ret = fs4.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs3.closeSync(fd);
+                fs4.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs3.closeSync(fd);
+              fs4.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs3) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs3.futimes) {
-          fs3.lutimes = function(path5, at, mt, cb) {
-            fs3.open(path5, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs4) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs4.futimes) {
+          fs4.lutimes = function(path6, at, mt, cb) {
+            fs4.open(path6, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb) cb(er);
                 return;
               }
-              fs3.futimes(fd, at, mt, function(er2) {
-                fs3.close(fd, function(er22) {
+              fs4.futimes(fd, at, mt, function(er2) {
+                fs4.close(fd, function(er22) {
                   if (cb) cb(er2 || er22);
                 });
               });
             });
           };
-          fs3.lutimesSync = function(path5, at, mt) {
-            var fd = fs3.openSync(path5, constants.O_SYMLINK);
+          fs4.lutimesSync = function(path6, at, mt) {
+            var fd = fs4.openSync(path6, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs3.futimesSync(fd, at, mt);
+              ret = fs4.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs3.closeSync(fd);
+                  fs4.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs3.closeSync(fd);
+                fs4.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs3.futimes) {
-          fs3.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs4.futimes) {
+          fs4.lutimes = function(_a, _b, _c, cb) {
             if (cb) process.nextTick(cb);
           };
-          fs3.lutimesSync = function() {
+          fs4.lutimesSync = function() {
           };
         }
       }
       function chmodFix(orig) {
         if (!orig) return orig;
         return function(target, mode, cb) {
-          return orig.call(fs2, target, mode, function(er) {
+          return orig.call(fs3, target, mode, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -278,7 +278,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs2, target, mode);
+            return orig.call(fs3, target, mode);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -287,7 +287,7 @@ var require_polyfills = __commonJS({
       function chownFix(orig) {
         if (!orig) return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs2, target, uid, gid, function(er) {
+          return orig.call(fs3, target, uid, gid, function(er) {
             if (chownErOk(er)) er = null;
             if (cb) cb.apply(this, arguments);
           });
@@ -297,7 +297,7 @@ var require_polyfills = __commonJS({
         if (!orig) return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs2, target, uid, gid);
+            return orig.call(fs3, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er)) throw er;
           }
@@ -317,13 +317,13 @@ var require_polyfills = __commonJS({
             }
             if (cb) cb.apply(this, arguments);
           }
-          return options ? orig.call(fs2, target, options, callback) : orig.call(fs2, target, callback);
+          return options ? orig.call(fs3, target, options, callback) : orig.call(fs3, target, callback);
         };
       }
       function statFixSync(orig) {
         if (!orig) return orig;
         return function(target, options) {
-          var stats = options ? orig.call(fs2, target, options) : orig.call(fs2, target);
+          var stats = options ? orig.call(fs3, target, options) : orig.call(fs3, target);
           if (stats) {
             if (stats.uid < 0) stats.uid += 4294967296;
             if (stats.gid < 0) stats.gid += 4294967296;
@@ -353,16 +353,16 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs2) {
+    function legacy(fs3) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path5, options) {
-        if (!(this instanceof ReadStream)) return new ReadStream(path5, options);
+      function ReadStream(path6, options) {
+        if (!(this instanceof ReadStream)) return new ReadStream(path6, options);
         Stream.call(this);
         var self = this;
-        this.path = path5;
+        this.path = path6;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -396,7 +396,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs2.open(this.path, this.flags, this.mode, function(err, fd) {
+        fs3.open(this.path, this.flags, this.mode, function(err, fd) {
           if (err) {
             self.emit("error", err);
             self.readable = 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(path6, options) {
+        if (!(this instanceof WriteStream)) return new WriteStream(path6, options);
         Stream.call(this);
-        this.path = path5;
+        this.path = path6;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -435,7 +435,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs2.open;
+          this._open = fs3.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -471,7 +471,7 @@ var require_clone = __commonJS({
 var require_graceful_fs = __commonJS({
   "../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/graceful-fs.js"(exports, module) {
     "use strict";
-    var fs2 = __require("fs");
+    var fs3 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -503,12 +503,12 @@ var require_graceful_fs = __commonJS({
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs2[gracefulQueue]) {
+    if (!fs3[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs2, queue);
-      fs2.close = function(fs$close) {
+      publishQueue(fs3, queue);
+      fs3.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs2, fd, function(err) {
+          return fs$close.call(fs3, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -520,48 +520,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs2.close);
-      fs2.closeSync = function(fs$closeSync) {
+      }(fs3.close);
+      fs3.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs2, arguments);
+          fs$closeSync.apply(fs3, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs2.closeSync);
+      }(fs3.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug2(fs2[gracefulQueue]);
-          __require("assert").equal(fs2[gracefulQueue].length, 0);
+          debug2(fs3[gracefulQueue]);
+          __require("assert").equal(fs3[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs2[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs2));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs2.__patched) {
-      module.exports = patch(fs2);
-      fs2.__patched = true;
-    }
-    function patch(fs3) {
-      polyfills(fs3);
-      fs3.gracefulify = patch;
-      fs3.createReadStream = createReadStream;
-      fs3.createWriteStream = createWriteStream;
-      var fs$readFile = fs3.readFile;
-      fs3.readFile = readFile;
-      function readFile(path5, options, cb) {
+      publishQueue(global, fs3[gracefulQueue]);
+    }
+    module.exports = patch(clone(fs3));
+    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs3.__patched) {
+      module.exports = patch(fs3);
+      fs3.__patched = true;
+    }
+    function patch(fs4) {
+      polyfills(fs4);
+      fs4.gracefulify = patch;
+      fs4.createReadStream = createReadStream;
+      fs4.createWriteStream = createWriteStream;
+      var fs$readFile = fs4.readFile;
+      fs4.readFile = readFile;
+      function readFile(path6, 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(path6, options, cb);
+        function go$readFile(path7, options2, cb2, startTime) {
+          return fs$readFile(path7, 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, [path7, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -569,16 +569,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs3.writeFile;
-      fs3.writeFile = writeFile;
-      function writeFile(path5, data, options, cb) {
+      var fs$writeFile = fs4.writeFile;
+      fs4.writeFile = writeFile;
+      function writeFile(path6, 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(path6, data, options, cb);
+        function go$writeFile(path7, data2, options2, cb2, startTime) {
+          return fs$writeFile(path7, 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, [path7, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -586,17 +586,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs3.appendFile;
+      var fs$appendFile = fs4.appendFile;
       if (fs$appendFile)
-        fs3.appendFile = appendFile;
-      function appendFile(path5, data, options, cb) {
+        fs4.appendFile = appendFile;
+      function appendFile(path6, 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(path6, data, options, cb);
+        function go$appendFile(path7, data2, options2, cb2, startTime) {
+          return fs$appendFile(path7, 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, [path7, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -604,9 +604,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs3.copyFile;
+      var fs$copyFile = fs4.copyFile;
       if (fs$copyFile)
-        fs3.copyFile = copyFile;
+        fs4.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -624,34 +624,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs3.readdir;
-      fs3.readdir = readdir;
+      var fs$readdir = fs4.readdir;
+      fs4.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path5, options, cb) {
+      function readdir(path6, 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(path7, options2, cb2, startTime) {
+          return fs$readdir(path7, fs$readdirCallback(
+            path7,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path6, options2, cb2, startTime) {
-          return fs$readdir(path6, options2, fs$readdirCallback(
-            path6,
+        } : function go$readdir2(path7, options2, cb2, startTime) {
+          return fs$readdir(path7, options2, fs$readdirCallback(
+            path7,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path5, options, cb);
-        function fs$readdirCallback(path6, options2, cb2, startTime) {
+        return go$readdir(path6, options, cb);
+        function fs$readdirCallback(path7, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path6, options2, cb2],
+                [path7, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -666,21 +666,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs3);
+        var legStreams = legacy(fs4);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs3.ReadStream;
+      var fs$ReadStream = fs4.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs3.WriteStream;
+      var fs$WriteStream = fs4.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs3, "ReadStream", {
+      Object.defineProperty(fs4, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -690,7 +690,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs3, "WriteStream", {
+      Object.defineProperty(fs4, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -701,7 +701,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs3, "FileReadStream", {
+      Object.defineProperty(fs4, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -712,7 +712,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs3, "FileWriteStream", {
+      Object.defineProperty(fs4, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -722,7 +722,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path5, options) {
+      function ReadStream(path6, 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(path6, 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 fs3.ReadStream(path5, options);
+      function createReadStream(path6, options) {
+        return new fs4.ReadStream(path6, options);
       }
-      function createWriteStream(path5, options) {
-        return new fs3.WriteStream(path5, options);
+      function createWriteStream(path6, options) {
+        return new fs4.WriteStream(path6, options);
       }
-      var fs$open = fs3.open;
-      fs3.open = open;
-      function open(path5, flags, mode, cb) {
+      var fs$open = fs4.open;
+      fs4.open = open;
+      function open(path6, 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(path6, flags, mode, cb);
+        function go$open(path7, flags2, mode2, cb2, startTime) {
+          return fs$open(path7, 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, [path7, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -783,20 +783,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs3;
+      return fs4;
     }
     function enqueue(elem) {
       debug2("ENQUEUE", elem[0].name, elem[1]);
-      fs2[gracefulQueue].push(elem);
+      fs3[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs2[gracefulQueue].length; ++i) {
-        if (fs2[gracefulQueue][i].length > 2) {
-          fs2[gracefulQueue][i][3] = now;
-          fs2[gracefulQueue][i][4] = now;
+      for (var i = 0; i < fs3[gracefulQueue].length; ++i) {
+        if (fs3[gracefulQueue][i].length > 2) {
+          fs3[gracefulQueue][i][3] = now;
+          fs3[gracefulQueue][i][4] = now;
         }
       }
       retry();
@@ -804,9 +804,9 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs2[gracefulQueue].length === 0)
+      if (fs3[gracefulQueue].length === 0)
         return;
-      var elem = fs2[gracefulQueue].shift();
+      var elem = fs3[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
@@ -828,7 +828,7 @@ var require_graceful_fs = __commonJS({
           debug2("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs2[gracefulQueue].push(elem);
+          fs3[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -843,7 +843,7 @@ var require_fs = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/fs/index.js"(exports) {
     "use strict";
     var u = require_universalify().fromCallback;
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var api = [
       "access",
       "appendFile",
@@ -884,26 +884,26 @@ var require_fs = __commonJS({
       "utimes",
       "writeFile"
     ].filter((key) => {
-      return typeof fs2[key] === "function";
+      return typeof fs3[key] === "function";
     });
-    Object.assign(exports, fs2);
+    Object.assign(exports, fs3);
     api.forEach((method3) => {
-      exports[method3] = u(fs2[method3]);
+      exports[method3] = u(fs3[method3]);
     });
     exports.exists = function(filename, callback) {
       if (typeof callback === "function") {
-        return fs2.exists(filename, callback);
+        return fs3.exists(filename, callback);
       }
       return new Promise((resolve) => {
-        return fs2.exists(filename, resolve);
+        return fs3.exists(filename, resolve);
       });
     };
     exports.read = function(fd, buffer, offset, length, position, callback) {
       if (typeof callback === "function") {
-        return fs2.read(fd, buffer, offset, length, position, callback);
+        return fs3.read(fd, buffer, offset, length, position, callback);
       }
       return new Promise((resolve, reject) => {
-        fs2.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
+        fs3.read(fd, buffer, offset, length, position, (err, bytesRead, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffer: buffer2 });
         });
@@ -911,10 +911,10 @@ var require_fs = __commonJS({
     };
     exports.write = function(fd, buffer, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs2.write(fd, buffer, ...args);
+        return fs3.write(fd, buffer, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs2.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
+        fs3.write(fd, buffer, ...args, (err, bytesWritten, buffer2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffer: buffer2 });
         });
@@ -922,10 +922,10 @@ var require_fs = __commonJS({
     };
     exports.readv = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs2.readv(fd, buffers, ...args);
+        return fs3.readv(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs2.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
+        fs3.readv(fd, buffers, ...args, (err, bytesRead, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesRead, buffers: buffers2 });
         });
@@ -933,17 +933,17 @@ var require_fs = __commonJS({
     };
     exports.writev = function(fd, buffers, ...args) {
       if (typeof args[args.length - 1] === "function") {
-        return fs2.writev(fd, buffers, ...args);
+        return fs3.writev(fd, buffers, ...args);
       }
       return new Promise((resolve, reject) => {
-        fs2.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
+        fs3.writev(fd, buffers, ...args, (err, bytesWritten, buffers2) => {
           if (err) return reject(err);
           resolve({ bytesWritten, buffers: buffers2 });
         });
       });
     };
-    if (typeof fs2.realpath.native === "function") {
-      exports.realpath.native = u(fs2.realpath.native);
+    if (typeof fs3.realpath.native === "function") {
+      exports.realpath.native = u(fs3.realpath.native);
     } else {
       process.emitWarning(
         "fs.realpath.native is not a function. Is fs being monkey-patched?",
@@ -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"(exports, module) {
     "use strict";
-    var path5 = __require("path");
+    var path6 = __require("path");
     module.exports.checkPath = function checkPath(pth) {
       if (process.platform === "win32") {
-        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path5.parse(pth).root, ""));
+        const pathHasInvalidWinCharacters = /[<>:"|?*]/.test(pth.replace(path6.parse(pth).root, ""));
         if (pathHasInvalidWinCharacters) {
           const error = new Error(`Path contains invalid characters: ${pth}`);
           error.code = "EINVAL";
@@ -976,7 +976,7 @@ var require_utils = __commonJS({
 var require_make_dir = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/mkdirs/make-dir.js"(exports, module) {
     "use strict";
-    var fs2 = require_fs();
+    var fs3 = require_fs();
     var { checkPath } = require_utils();
     var getMode = (options) => {
       const defaults = { mode: 511 };
@@ -985,14 +985,14 @@ var require_make_dir = __commonJS({
     };
     module.exports.makeDir = async (dir, options) => {
       checkPath(dir);
-      return fs2.mkdir(dir, {
+      return fs3.mkdir(dir, {
         mode: getMode(options),
         recursive: true
       });
     };
     module.exports.makeDirSync = (dir, options) => {
       checkPath(dir);
-      return fs2.mkdirSync(dir, {
+      return fs3.mkdirSync(dir, {
         mode: getMode(options),
         recursive: true
       });
@@ -1024,13 +1024,13 @@ var require_path_exists = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/path-exists/index.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs2 = require_fs();
-    function pathExists(path5) {
-      return fs2.access(path5).then(() => true).catch(() => false);
+    var fs3 = require_fs();
+    function pathExists(path6) {
+      return fs3.access(path6).then(() => true).catch(() => false);
     }
     module.exports = {
       pathExists: u(pathExists),
-      pathExistsSync: fs2.existsSync
+      pathExistsSync: fs3.existsSync
     };
   }
 });
@@ -1039,16 +1039,16 @@ var require_path_exists = __commonJS({
 var require_utimes = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/util/utimes.js"(exports, module) {
     "use strict";
-    var fs2 = require_fs();
+    var fs3 = require_fs();
     var u = require_universalify().fromPromise;
-    async function utimesMillis(path5, atime, mtime) {
-      const fd = await fs2.open(path5, "r+");
+    async function utimesMillis(path6, atime, mtime) {
+      const fd = await fs3.open(path6, "r+");
       let closeErr = null;
       try {
-        await fs2.futimes(fd, atime, mtime);
+        await fs3.futimes(fd, atime, mtime);
       } finally {
         try {
-          await fs2.close(fd);
+          await fs3.close(fd);
         } catch (e) {
           closeErr = e;
         }
@@ -1057,10 +1057,10 @@ var require_utimes = __commonJS({
         throw closeErr;
       }
     }
-    function utimesMillisSync(path5, atime, mtime) {
-      const fd = fs2.openSync(path5, "r+");
-      fs2.futimesSync(fd, atime, mtime);
-      return fs2.closeSync(fd);
+    function utimesMillisSync(path6, atime, mtime) {
+      const fd = fs3.openSync(path6, "r+");
+      fs3.futimesSync(fd, atime, mtime);
+      return fs3.closeSync(fd);
     }
     module.exports = {
       utimesMillis: u(utimesMillis),
@@ -1073,11 +1073,11 @@ var require_utimes = __commonJS({
 var require_stat = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/util/stat.js"(exports, module) {
     "use strict";
-    var fs2 = require_fs();
-    var path5 = __require("path");
+    var fs3 = require_fs();
+    var path6 = __require("path");
     var u = require_universalify().fromPromise;
     function getStats(src, dest, opts) {
-      const statFunc = opts.dereference ? (file4) => fs2.stat(file4, { bigint: true }) : (file4) => fs2.lstat(file4, { bigint: true });
+      const statFunc = opts.dereference ? (file4) => fs3.stat(file4, { bigint: true }) : (file4) => fs3.lstat(file4, { bigint: true });
       return Promise.all([
         statFunc(src),
         statFunc(dest).catch((err) => {
@@ -1088,7 +1088,7 @@ var require_stat = __commonJS({
     }
     function getStatsSync(src, dest, opts) {
       let destStat;
-      const statFunc = opts.dereference ? (file4) => fs2.statSync(file4, { bigint: true }) : (file4) => fs2.lstatSync(file4, { bigint: true });
+      const statFunc = opts.dereference ? (file4) => fs3.statSync(file4, { bigint: true }) : (file4) => fs3.lstatSync(file4, { bigint: true });
       const srcStat = statFunc(src);
       try {
         destStat = statFunc(dest);
@@ -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 = path6.basename(src);
+          const destBaseName = path6.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 = path6.basename(src);
+          const destBaseName = path6.basename(dest);
           if (funcName === "move" && srcBaseName !== destBaseName && srcBaseName.toLowerCase() === destBaseName.toLowerCase()) {
             return { srcStat, destStat, isChangingCase: true };
           }
@@ -1145,12 +1145,12 @@ 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 = path6.resolve(path6.dirname(src));
+      const destParent = path6.resolve(path6.dirname(dest));
+      if (destParent === srcParent || destParent === path6.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = await fs2.stat(destParent, { bigint: true });
+        destStat = await fs3.stat(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -1161,12 +1161,12 @@ 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 = path6.resolve(path6.dirname(src));
+      const destParent = path6.resolve(path6.dirname(dest));
+      if (destParent === srcParent || destParent === path6.parse(destParent).root) return;
       let destStat;
       try {
-        destStat = fs2.statSync(destParent, { bigint: true });
+        destStat = fs3.statSync(destParent, { bigint: true });
       } catch (err) {
         if (err.code === "ENOENT") return;
         throw err;
@@ -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 = path6.resolve(src).split(path6.sep).filter((i) => i);
+      const destArr = path6.resolve(dest).split(path6.sep).filter((i) => i);
       return srcArr.every((cur, i) => destArr[i] === cur);
     }
     function errMsg(src, dest, funcName) {
@@ -1205,8 +1205,8 @@ var require_stat = __commonJS({
 var require_copy = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/copy/copy.js"(exports, module) {
     "use strict";
-    var fs2 = require_fs();
-    var path5 = __require("path");
+    var fs3 = require_fs();
+    var path6 = __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 = path6.dirname(dest);
       const dirExists = await pathExists(destParent);
       if (!dirExists) {
         await mkdirs(destParent);
@@ -1240,7 +1240,7 @@ var require_copy = __commonJS({
       return opts.filter(src, dest);
     }
     async function getStatsAndPerformCopy(destStat, src, dest, opts) {
-      const statFn = opts.dereference ? fs2.stat : fs2.lstat;
+      const statFn = opts.dereference ? fs3.stat : fs3.lstat;
       const srcStat = await statFn(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -1252,7 +1252,7 @@ var require_copy = __commonJS({
     async function onFile(srcStat, destStat, src, dest, opts) {
       if (!destStat) return copyFile(srcStat, src, dest, opts);
       if (opts.overwrite) {
-        await fs2.unlink(dest);
+        await fs3.unlink(dest);
         return copyFile(srcStat, src, dest, opts);
       }
       if (opts.errorOnExist) {
@@ -1260,30 +1260,30 @@ var require_copy = __commonJS({
       }
     }
     async function copyFile(srcStat, src, dest, opts) {
-      await fs2.copyFile(src, dest);
+      await fs3.copyFile(src, dest);
       if (opts.preserveTimestamps) {
         if (fileIsNotWritable(srcStat.mode)) {
           await makeFileWritable(dest, srcStat.mode);
         }
-        const updatedSrcStat = await fs2.stat(src);
+        const updatedSrcStat = await fs3.stat(src);
         await utimesMillis(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
       }
-      return fs2.chmod(dest, srcStat.mode);
+      return fs3.chmod(dest, srcStat.mode);
     }
     function fileIsNotWritable(srcMode) {
       return (srcMode & 128) === 0;
     }
     function makeFileWritable(dest, srcMode) {
-      return fs2.chmod(dest, srcMode | 128);
+      return fs3.chmod(dest, srcMode | 128);
     }
     async function onDir(srcStat, destStat, src, dest, opts) {
       if (!destStat) {
-        await fs2.mkdir(dest);
+        await fs3.mkdir(dest);
       }
       const promises = [];
-      for await (const item of await fs2.opendir(src)) {
-        const srcItem = path5.join(src, item.name);
-        const destItem = path5.join(dest, item.name);
+      for await (const item of await fs3.opendir(src)) {
+        const srcItem = path6.join(src, item.name);
+        const destItem = path6.join(dest, item.name);
         promises.push(
           runFilter(srcItem, destItem, opts).then((include) => {
             if (include) {
@@ -1296,26 +1296,26 @@ var require_copy = __commonJS({
       }
       await Promise.all(promises);
       if (!destStat) {
-        await fs2.chmod(dest, srcStat.mode);
+        await fs3.chmod(dest, srcStat.mode);
       }
     }
     async function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = await fs2.readlink(src);
+      let resolvedSrc = await fs3.readlink(src);
       if (opts.dereference) {
-        resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path6.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs2.symlink(resolvedSrc, dest);
+        return fs3.symlink(resolvedSrc, dest);
       }
       let resolvedDest = null;
       try {
-        resolvedDest = await fs2.readlink(dest);
+        resolvedDest = await fs3.readlink(dest);
       } catch (e) {
-        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs2.symlink(resolvedSrc, dest);
+        if (e.code === "EINVAL" || e.code === "UNKNOWN") return fs3.symlink(resolvedSrc, dest);
         throw e;
       }
       if (opts.dereference) {
-        resolvedDest = path5.resolve(process.cwd(), resolvedDest);
+        resolvedDest = path6.resolve(process.cwd(), resolvedDest);
       }
       if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
         throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -1323,8 +1323,8 @@ var require_copy = __commonJS({
       if (stat.isSrcSubdir(resolvedDest, resolvedSrc)) {
         throw new Error(`Cannot overwrite '${resolvedDest}' with '${resolvedSrc}'.`);
       }
-      await fs2.unlink(dest);
-      return fs2.symlink(resolvedSrc, dest);
+      await fs3.unlink(dest);
+      return fs3.symlink(resolvedSrc, dest);
     }
     module.exports = copy;
   }
@@ -1334,8 +1334,8 @@ var require_copy = __commonJS({
 var require_copy_sync = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/copy/copy-sync.js"(exports, module) {
     "use strict";
-    var fs2 = require_graceful_fs();
-    var path5 = __require("path");
+    var fs3 = require_graceful_fs();
+    var path6 = __require("path");
     var mkdirsSync = require_mkdirs().mkdirsSync;
     var utimesMillisSync = require_utimes().utimesMillisSync;
     var stat = require_stat();
@@ -1356,12 +1356,12 @@ 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);
-      if (!fs2.existsSync(destParent)) mkdirsSync(destParent);
+      const destParent = path6.dirname(dest);
+      if (!fs3.existsSync(destParent)) mkdirsSync(destParent);
       return getStats(destStat, src, dest, opts);
     }
     function getStats(destStat, src, dest, opts) {
-      const statSync = opts.dereference ? fs2.statSync : fs2.lstatSync;
+      const statSync = opts.dereference ? fs3.statSync : fs3.lstatSync;
       const srcStat = statSync(src);
       if (srcStat.isDirectory()) return onDir(srcStat, destStat, src, dest, opts);
       else if (srcStat.isFile() || srcStat.isCharacterDevice() || srcStat.isBlockDevice()) return onFile(srcStat, destStat, src, dest, opts);
@@ -1376,14 +1376,14 @@ var require_copy_sync = __commonJS({
     }
     function mayCopyFile(srcStat, src, dest, opts) {
       if (opts.overwrite) {
-        fs2.unlinkSync(dest);
+        fs3.unlinkSync(dest);
         return copyFile(srcStat, src, dest, opts);
       } else if (opts.errorOnExist) {
         throw new Error(`'${dest}' already exists`);
       }
     }
     function copyFile(srcStat, src, dest, opts) {
-      fs2.copyFileSync(src, dest);
+      fs3.copyFileSync(src, dest);
       if (opts.preserveTimestamps) handleTimestamps(srcStat.mode, src, dest);
       return setDestMode(dest, srcStat.mode);
     }
@@ -1398,10 +1398,10 @@ var require_copy_sync = __commonJS({
       return setDestMode(dest, srcMode | 128);
     }
     function setDestMode(dest, srcMode) {
-      return fs2.chmodSync(dest, srcMode);
+      return fs3.chmodSync(dest, srcMode);
     }
     function setDestTimestamps(src, dest) {
-      const updatedSrcStat = fs2.statSync(src);
+      const updatedSrcStat = fs3.statSync(src);
       return utimesMillisSync(dest, updatedSrcStat.atime, updatedSrcStat.mtime);
     }
     function onDir(srcStat, destStat, src, dest, opts) {
@@ -1409,12 +1409,12 @@ var require_copy_sync = __commonJS({
       return copyDir(src, dest, opts);
     }
     function mkDirAndCopy(srcMode, src, dest, opts) {
-      fs2.mkdirSync(dest);
+      fs3.mkdirSync(dest);
       copyDir(src, dest, opts);
       return setDestMode(dest, srcMode);
     }
     function copyDir(src, dest, opts) {
-      const dir = fs2.opendirSync(src);
+      const dir = fs3.opendirSync(src);
       try {
         let dirent;
         while ((dirent = dir.readSync()) !== null) {
@@ -1425,29 +1425,29 @@ 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 = path6.join(src, item);
+      const destItem = path6.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);
     }
     function onLink(destStat, src, dest, opts) {
-      let resolvedSrc = fs2.readlinkSync(src);
+      let resolvedSrc = fs3.readlinkSync(src);
       if (opts.dereference) {
-        resolvedSrc = path5.resolve(process.cwd(), resolvedSrc);
+        resolvedSrc = path6.resolve(process.cwd(), resolvedSrc);
       }
       if (!destStat) {
-        return fs2.symlinkSync(resolvedSrc, dest);
+        return fs3.symlinkSync(resolvedSrc, dest);
       } else {
         let resolvedDest;
         try {
-          resolvedDest = fs2.readlinkSync(dest);
+          resolvedDest = fs3.readlinkSync(dest);
         } catch (err) {
-          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs2.symlinkSync(resolvedSrc, dest);
+          if (err.code === "EINVAL" || err.code === "UNKNOWN") return fs3.symlinkSync(resolvedSrc, dest);
           throw err;
         }
         if (opts.dereference) {
-          resolvedDest = path5.resolve(process.cwd(), resolvedDest);
+          resolvedDest = path6.resolve(process.cwd(), resolvedDest);
         }
         if (stat.isSrcSubdir(resolvedSrc, resolvedDest)) {
           throw new Error(`Cannot copy '${resolvedSrc}' to a subdirectory of itself, '${resolvedDest}'.`);
@@ -1459,8 +1459,8 @@ var require_copy_sync = __commonJS({
       }
     }
     function copyLink(resolvedSrc, dest) {
-      fs2.unlinkSync(dest);
-      return fs2.symlinkSync(resolvedSrc, dest);
+      fs3.unlinkSync(dest);
+      return fs3.symlinkSync(resolvedSrc, dest);
     }
     module.exports = copySync;
   }
@@ -1482,13 +1482,13 @@ var require_copy2 = __commonJS({
 var require_remove = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/remove/index.js"(exports, module) {
     "use strict";
-    var fs2 = require_graceful_fs();
+    var fs3 = require_graceful_fs();
     var u = require_universalify().fromCallback;
-    function remove(path5, callback) {
-      fs2.rm(path5, { recursive: true, force: true }, callback);
+    function remove(path6, callback) {
+      fs3.rm(path6, { recursive: true, force: true }, callback);
     }
-    function removeSync(path5) {
-      fs2.rmSync(path5, { recursive: true, force: true });
+    function removeSync(path6) {
+      fs3.rmSync(path6, { recursive: true, force: true });
     }
     module.exports = {
       remove: u(remove),
@@ -1502,28 +1502,28 @@ var require_empty = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/empty/index.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs2 = require_fs();
-    var path5 = __require("path");
+    var fs3 = require_fs();
+    var path6 = __require("path");
     var mkdir = require_mkdirs();
     var remove = require_remove();
     var emptyDir = u(async function emptyDir2(dir) {
       let items;
       try {
-        items = await fs2.readdir(dir);
+        items = await fs3.readdir(dir);
       } 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(path6.join(dir, item))));
     });
     function emptyDirSync(dir) {
       let items;
       try {
-        items = fs2.readdirSync(dir);
+        items = fs3.readdirSync(dir);
       } catch {
         return mkdir.mkdirsSync(dir);
       }
       items.forEach((item) => {
-        item = path5.join(dir, item);
+        item = path6.join(dir, item);
         remove.removeSync(item);
       });
     }
@@ -1541,52 +1541,52 @@ var require_file = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/ensure/file.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path5 = __require("path");
-    var fs2 = require_fs();
+    var path6 = __require("path");
+    var fs3 = require_fs();
     var mkdir = require_mkdirs();
     async function createFile(file4) {
       let stats;
       try {
-        stats = await fs2.stat(file4);
+        stats = await fs3.stat(file4);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path5.dirname(file4);
+      const dir = path6.dirname(file4);
       let dirStats = null;
       try {
-        dirStats = await fs2.stat(dir);
+        dirStats = await fs3.stat(dir);
       } catch (err) {
         if (err.code === "ENOENT") {
           await mkdir.mkdirs(dir);
-          await fs2.writeFile(file4, "");
+          await fs3.writeFile(file4, "");
           return;
         } else {
           throw err;
         }
       }
       if (dirStats.isDirectory()) {
-        await fs2.writeFile(file4, "");
+        await fs3.writeFile(file4, "");
       } else {
-        await fs2.readdir(dir);
+        await fs3.readdir(dir);
       }
     }
     function createFileSync(file4) {
       let stats;
       try {
-        stats = fs2.statSync(file4);
+        stats = fs3.statSync(file4);
       } catch {
       }
       if (stats && stats.isFile()) return;
-      const dir = path5.dirname(file4);
+      const dir = path6.dirname(file4);
       try {
-        if (!fs2.statSync(dir).isDirectory()) {
-          fs2.readdirSync(dir);
+        if (!fs3.statSync(dir).isDirectory()) {
+          fs3.readdirSync(dir);
         }
       } catch (err) {
         if (err && err.code === "ENOENT") mkdir.mkdirsSync(dir);
         else throw err;
       }
-      fs2.writeFileSync(file4, "");
+      fs3.writeFileSync(file4, "");
     }
     module.exports = {
       createFile: u(createFile),
@@ -1600,50 +1600,50 @@ var require_link = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/ensure/link.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path5 = __require("path");
-    var fs2 = require_fs();
+    var path6 = __require("path");
+    var fs3 = require_fs();
     var mkdir = require_mkdirs();
     var { pathExists } = require_path_exists();
     var { areIdentical } = require_stat();
     async function createLink(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = await fs2.lstat(dstpath);
+        dstStat = await fs3.lstat(dstpath);
       } catch {
       }
       let srcStat;
       try {
-        srcStat = await fs2.lstat(srcpath);
+        srcStat = await fs3.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
       if (dstStat && areIdentical(srcStat, dstStat)) return;
-      const dir = path5.dirname(dstpath);
+      const dir = path6.dirname(dstpath);
       const dirExists = await pathExists(dir);
       if (!dirExists) {
         await mkdir.mkdirs(dir);
       }
-      await fs2.link(srcpath, dstpath);
+      await fs3.link(srcpath, dstpath);
     }
     function createLinkSync(srcpath, dstpath) {
       let dstStat;
       try {
-        dstStat = fs2.lstatSync(dstpath);
+        dstStat = fs3.lstatSync(dstpath);
       } catch {
       }
       try {
-        const srcStat = fs2.lstatSync(srcpath);
+        const srcStat = fs3.lstatSync(srcpath);
         if (dstStat && areIdentical(srcStat, dstStat)) return;
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureLink");
         throw err;
       }
-      const dir = path5.dirname(dstpath);
-      const dirExists = fs2.existsSync(dir);
-      if (dirExists) return fs2.linkSync(srcpath, dstpath);
+      const dir = path6.dirname(dstpath);
+      const dirExists = fs3.existsSync(dir);
+      if (dirExists) return fs3.linkSync(srcpath, dstpath);
       mkdir.mkdirsSync(dir);
-      return fs2.linkSync(srcpath, dstpath);
+      return fs3.linkSync(srcpath, dstpath);
     }
     module.exports = {
       createLink: u(createLink),
@@ -1656,14 +1656,14 @@ 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"(exports, module) {
     "use strict";
-    var path5 = __require("path");
-    var fs2 = require_fs();
+    var path6 = __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 (path6.isAbsolute(srcpath)) {
         try {
-          await fs2.lstat(srcpath);
+          await fs3.lstat(srcpath);
         } catch (err) {
           err.message = err.message.replace("lstat", "ensureSymlink");
           throw 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 = path6.dirname(dstpath);
+      const relativeToDst = path6.join(dstdir, srcpath);
       const exists = await pathExists(relativeToDst);
       if (exists) {
         return {
@@ -1683,39 +1683,39 @@ var require_symlink_paths = __commonJS({
         };
       }
       try {
-        await fs2.lstat(srcpath);
+        await fs3.lstat(srcpath);
       } catch (err) {
         err.message = err.message.replace("lstat", "ensureSymlink");
         throw err;
       }
       return {
         toCwd: srcpath,
-        toDst: path5.relative(dstdir, srcpath)
+        toDst: path6.relative(dstdir, srcpath)
       };
     }
     function symlinkPathsSync(srcpath, dstpath) {
-      if (path5.isAbsolute(srcpath)) {
-        const exists2 = fs2.existsSync(srcpath);
+      if (path6.isAbsolute(srcpath)) {
+        const exists2 = fs3.existsSync(srcpath);
         if (!exists2) throw new Error("absolute srcpath does not exist");
         return {
           toCwd: srcpath,
           toDst: srcpath
         };
       }
-      const dstdir = path5.dirname(dstpath);
-      const relativeToDst = path5.join(dstdir, srcpath);
-      const exists = fs2.existsSync(relativeToDst);
+      const dstdir = path6.dirname(dstpath);
+      const relativeToDst = path6.join(dstdir, srcpath);
+      const exists = fs3.existsSync(relativeToDst);
       if (exists) {
         return {
           toCwd: relativeToDst,
           toDst: srcpath
         };
       }
-      const srcExists = fs2.existsSync(srcpath);
+      const srcExists = fs3.existsSync(srcpath);
       if (!srcExists) throw new Error("relative srcpath does not exist");
       return {
         toCwd: srcpath,
-        toDst: path5.relative(dstdir, srcpath)
+        toDst: path6.relative(dstdir, srcpath)
       };
     }
     module.exports = {
@@ -1729,13 +1729,13 @@ var require_symlink_paths = __commonJS({
 var require_symlink_type = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/ensure/symlink-type.js"(exports, module) {
     "use strict";
-    var fs2 = require_fs();
+    var fs3 = require_fs();
     var u = require_universalify().fromPromise;
     async function symlinkType(srcpath, type) {
       if (type) return type;
       let stats;
       try {
-        stats = await fs2.lstat(srcpath);
+        stats = await fs3.lstat(srcpath);
       } catch {
         return "file";
       }
@@ -1745,7 +1745,7 @@ var require_symlink_type = __commonJS({
       if (type) return type;
       let stats;
       try {
-        stats = fs2.lstatSync(srcpath);
+        stats = fs3.lstatSync(srcpath);
       } catch {
         return "file";
       }
@@ -1763,8 +1763,8 @@ var require_symlink = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/ensure/symlink.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var path5 = __require("path");
-    var fs2 = require_fs();
+    var path6 = __require("path");
+    var fs3 = require_fs();
     var { mkdirs, mkdirsSync } = require_mkdirs();
     var { symlinkPaths, symlinkPathsSync } = require_symlink_paths();
     var { symlinkType, symlinkTypeSync } = require_symlink_type();
@@ -1773,44 +1773,44 @@ var require_symlink = __commonJS({
     async function createSymlink(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = await fs2.lstat(dstpath);
+        stats = await fs3.lstat(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
         const [srcStat, dstStat] = await Promise.all([
-          fs2.stat(srcpath),
-          fs2.stat(dstpath)
+          fs3.stat(srcpath),
+          fs3.stat(dstpath)
         ]);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = await symlinkPaths(srcpath, dstpath);
       srcpath = relative.toDst;
       const toType = await symlinkType(relative.toCwd, type);
-      const dir = path5.dirname(dstpath);
+      const dir = path6.dirname(dstpath);
       if (!await pathExists(dir)) {
         await mkdirs(dir);
       }
-      return fs2.symlink(srcpath, dstpath, toType);
+      return fs3.symlink(srcpath, dstpath, toType);
     }
     function createSymlinkSync(srcpath, dstpath, type) {
       let stats;
       try {
-        stats = fs2.lstatSync(dstpath);
+        stats = fs3.lstatSync(dstpath);
       } catch {
       }
       if (stats && stats.isSymbolicLink()) {
-        const srcStat = fs2.statSync(srcpath);
-        const dstStat = fs2.statSync(dstpath);
+        const srcStat = fs3.statSync(srcpath);
+        const dstStat = fs3.statSync(dstpath);
         if (areIdentical(srcStat, dstStat)) return;
       }
       const relative = symlinkPathsSync(srcpath, dstpath);
       srcpath = relative.toDst;
       type = symlinkTypeSync(relative.toCwd, type);
-      const dir = path5.dirname(dstpath);
-      const exists = fs2.existsSync(dir);
-      if (exists) return fs2.symlinkSync(srcpath, dstpath, type);
+      const dir = path6.dirname(dstpath);
+      const exists = fs3.existsSync(dir);
+      if (exists) return fs3.symlinkSync(srcpath, dstpath, type);
       mkdirsSync(dir);
-      return fs2.symlinkSync(srcpath, dstpath, type);
+      return fs3.symlinkSync(srcpath, dstpath, type);
     }
     module.exports = {
       createSymlink: u(createSymlink),
@@ -1879,9 +1879,9 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs2 = options.fs || _fs;
+      const fs3 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
-      let data = await universalify.fromCallback(fs2.readFile)(file4, options);
+      let data = await universalify.fromCallback(fs3.readFile)(file4, options);
       data = stripBom(data);
       let obj;
       try {
@@ -1901,10 +1901,10 @@ var require_jsonfile = __commonJS({
       if (typeof options === "string") {
         options = { encoding: options };
       }
-      const fs2 = options.fs || _fs;
+      const fs3 = options.fs || _fs;
       const shouldThrow = "throws" in options ? options.throws : true;
       try {
-        let content = fs2.readFileSync(file4, options);
+        let content = fs3.readFileSync(file4, options);
         content = stripBom(content);
         return JSON.parse(content, options.reviver);
       } catch (err) {
@@ -1917,15 +1917,15 @@ var require_jsonfile = __commonJS({
       }
     }
     async function _writeFile(file4, obj, options = {}) {
-      const fs2 = options.fs || _fs;
+      const fs3 = options.fs || _fs;
       const str = stringify14(obj, options);
-      await universalify.fromCallback(fs2.writeFile)(file4, str, options);
+      await universalify.fromCallback(fs3.writeFile)(file4, str, options);
     }
     var writeFile = universalify.fromPromise(_writeFile);
     function writeFileSync(file4, obj, options = {}) {
-      const fs2 = options.fs || _fs;
+      const fs3 = options.fs || _fs;
       const str = stringify14(obj, options);
-      return fs2.writeFileSync(file4, str, options);
+      return fs3.writeFileSync(file4, str, options);
     }
     var jsonfile = {
       readFile,
@@ -1957,23 +1957,23 @@ var require_output_file = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/output-file/index.js"(exports, module) {
     "use strict";
     var u = require_universalify().fromPromise;
-    var fs2 = require_fs();
-    var path5 = __require("path");
+    var fs3 = require_fs();
+    var path6 = __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 = path6.dirname(file4);
       if (!await pathExists(dir)) {
         await mkdir.mkdirs(dir);
       }
-      return fs2.writeFile(file4, data, encoding);
+      return fs3.writeFile(file4, data, encoding);
     }
     function outputFileSync(file4, ...args) {
-      const dir = path5.dirname(file4);
-      if (!fs2.existsSync(dir)) {
+      const dir = path6.dirname(file4);
+      if (!fs3.existsSync(dir)) {
         mkdir.mkdirsSync(dir);
       }
-      fs2.writeFileSync(file4, ...args);
+      fs3.writeFileSync(file4, ...args);
     }
     module.exports = {
       outputFile: u(outputFile),
@@ -2032,8 +2032,8 @@ var require_json = __commonJS({
 var require_move = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/move/move.js"(exports, module) {
     "use strict";
-    var fs2 = require_fs();
-    var path5 = __require("path");
+    var fs3 = require_fs();
+    var path6 = __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 = path6.dirname(dest);
+      const parsedParentPath = path6.parse(destParent);
       if (parsedParentPath.root !== destParent) {
         await mkdirp(destParent);
       }
@@ -2059,7 +2059,7 @@ var require_move = __commonJS({
         }
       }
       try {
-        await fs2.rename(src, dest);
+        await fs3.rename(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") {
           throw err;
@@ -2084,8 +2084,8 @@ var require_move = __commonJS({
 var require_move_sync = __commonJS({
   "../../node_modules/.pnpm/fs-extra@11.3.0/node_modules/fs-extra/lib/move/move-sync.js"(exports, module) {
     "use strict";
-    var fs2 = require_graceful_fs();
-    var path5 = __require("path");
+    var fs3 = require_graceful_fs();
+    var path6 = __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(path6.dirname(dest));
       return doRename(src, dest, overwrite, isChangingCase);
     }
     function isParentRoot(dest) {
-      const parent = path5.dirname(dest);
-      const parsedPath = path5.parse(parent);
+      const parent = path6.dirname(dest);
+      const parsedPath = path6.parse(parent);
       return parsedPath.root === parent;
     }
     function doRename(src, dest, overwrite, isChangingCase) {
@@ -2109,12 +2109,12 @@ var require_move_sync = __commonJS({
         removeSync(dest);
         return rename(src, dest, overwrite);
       }
-      if (fs2.existsSync(dest)) throw new Error("dest already exists.");
+      if (fs3.existsSync(dest)) throw new Error("dest already exists.");
       return rename(src, dest, overwrite);
     }
     function rename(src, dest, overwrite) {
       try {
-        fs2.renameSync(src, dest);
+        fs3.renameSync(src, dest);
       } catch (err) {
         if (err.code !== "EXDEV") throw err;
         return moveAcrossDevice(src, dest, overwrite);
@@ -2167,7 +2167,7 @@ var require_lib = __commonJS({
 });
 
 // src/externalToInternalDmmf.ts
-import { capitalize, lowerCase } from "@prisma/client-common";
+import { capitalize, uncapitalize } from "@prisma/client-common";
 import pluralize from "pluralize";
 function externalToInternalDmmf(document) {
   return {
@@ -2184,7 +2184,7 @@ function getMappings(mappings, datamodel) {
     return model.fields.some((f) => f.kind !== "object");
   }).map((mapping) => ({
     model: mapping.model,
-    plural: pluralize(lowerCase(mapping.model)),
+    plural: pluralize(uncapitalize(mapping.model)),
     // TODO not needed anymore
     findUnique: mapping.findUnique || mapping.findSingle,
     findUniqueOrThrow: mapping.findUniqueOrThrow,
@@ -2213,8 +2213,8 @@ function getMappings(mappings, datamodel) {
 
 // src/generateClient.ts
 var import_fs_extra = __toESM(require_lib());
-import fs from "node:fs/promises";
-import path4 from "node:path";
+import fs2 from "node:fs/promises";
+import path5 from "node:path";
 import { overwriteFile } from "@prisma/fetch-engine";
 import {
   assertNever as assertNever3,
@@ -2898,7 +2898,7 @@ var GenericArgsInfo = class {
 
 // src/TSClient/file-generators/ClassFile.ts
 import crypto from "node:crypto";
-import path from "node:path";
+import path2 from "node:path";
 import { getClientEngineType, pathToPosix } from "@prisma/internals";
 import * as ts5 from "@prisma/ts-builders";
 import ciInfo from "ci-info";
@@ -2954,11 +2954,11 @@ import {
 } from "@prisma/client-common";
 
 // src/TSClient/helpers.ts
-import { capitalize as capitalize5, lowerCase as lowerCase3 } from "@prisma/client-common";
+import { capitalize as capitalize5, uncapitalize as uncapitalize3 } from "@prisma/client-common";
 import pluralize2 from "pluralize";
 
 // src/TSClient/jsdoc.ts
-import { capitalize as capitalize4, lowerCase as lowerCase2 } from "@prisma/client-common";
+import { capitalize as capitalize4, uncapitalize as uncapitalize2 } from "@prisma/client-common";
 var Docs = {
   cursor: `{@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination#cursor-based-pagination Cursor Docs}`,
   pagination: `{@link https://www.prisma.io/docs/concepts/components/prisma-client/pagination Pagination Docs}`,
@@ -3031,7 +3031,7 @@ const ${ctx.singular} = await ${ctx.method}({
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to create many ${ctx.plural}.
 @example
 // Create many ${ctx.plural}
-const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)} = await ${ctx.method}({
   data: [
     // ... provide data here
   ]
@@ -3045,7 +3045,7 @@ const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
     body: (ctx) => {
       const onlySelect = ctx.firstScalar ? `
 // Create many ${ctx.plural} and only return the \`${ctx.firstScalar.name}\`
-const ${lowerCase2(ctx.mapping.model)}With${capitalize4(ctx.firstScalar.name)}Only = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)}With${capitalize4(ctx.firstScalar.name)}Only = await ${ctx.method}({
   select: { ${ctx.firstScalar.name}: true },
   data: [
     // ... provide data here
@@ -3055,7 +3055,7 @@ const ${lowerCase2(ctx.mapping.model)}With${capitalize4(ctx.firstScalar.name)}On
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to create many ${ctx.plural}.
 @example
 // Create many ${ctx.plural}
-const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)} = await ${ctx.method}({
   data: [
     // ... provide data here
   ]
@@ -3073,7 +3073,7 @@ ${undefinedNote}
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to find a ${ctx.singular}
 @example
 // Get one ${ctx.singular}
-const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   }
@@ -3088,7 +3088,7 @@ if no matches were found.
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to find a ${ctx.singular}
 @example
 // Get one ${ctx.singular}
-const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   }
@@ -3103,7 +3103,7 @@ ${undefinedNote}
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to find a ${ctx.singular}
 @example
 // Get one ${ctx.singular}
-const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   }
@@ -3124,7 +3124,7 @@ ${undefinedNote}
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to find a ${ctx.singular}
 @example
 // Get one ${ctx.singular}
-const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   }
@@ -3142,7 +3142,7 @@ const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
     body: (ctx) => {
       const onlySelect = ctx.firstScalar ? `
 // Only select the \`${ctx.firstScalar.name}\`
-const ${lowerCase2(ctx.mapping.model)}With${capitalize4(ctx.firstScalar.name)}Only = await ${ctx.method}({ select: { ${ctx.firstScalar.name}: true } })` : "";
+const ${uncapitalize2(ctx.mapping.model)}With${capitalize4(ctx.firstScalar.name)}Only = await ${ctx.method}({ select: { ${ctx.firstScalar.name}: true } })` : "";
       return `Find zero or more ${ctx.plural} that matches the filter.
 ${undefinedNote}
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to filter and select certain fields only.
@@ -3168,7 +3168,7 @@ ${onlySelect}
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to update one ${ctx.singular}.
 @example
 // Update one ${ctx.singular}
-const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   },
@@ -3187,7 +3187,7 @@ const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to update or create a ${ctx.singular}.
 @example
 // Update or create a ${ctx.singular}
-const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)} = await ${ctx.method}({
   create: {
     // ... data to create a ${ctx.singular}
   },
@@ -3281,7 +3281,7 @@ ${undefinedNote}
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to update one or more rows.
 @example
 // Update many ${ctx.plural}
-const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   },
@@ -3300,7 +3300,7 @@ const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
     body: (ctx) => {
       const onlySelect = ctx.firstScalar ? `
 // Update zero or more ${ctx.plural} and only return the \`${ctx.firstScalar.name}\`
-const ${lowerCase2(ctx.mapping.model)}With${capitalize4(ctx.firstScalar.name)}Only = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)}With${capitalize4(ctx.firstScalar.name)}Only = await ${ctx.method}({
   select: { ${ctx.firstScalar.name}: true },
   where: {
     // ... provide filter here
@@ -3313,7 +3313,7 @@ const ${lowerCase2(ctx.mapping.model)}With${capitalize4(ctx.firstScalar.name)}On
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Arguments to update many ${ctx.plural}.
 @example
 // Update many ${ctx.plural}
-const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)} = await ${ctx.method}({
   where: {
     // ... provide filter here
   },
@@ -3351,7 +3351,7 @@ const { count } = await ${ctx.method}({
     body: (ctx) => `Perform aggregation operations on a ${ctx.singular}.
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Select which aggregations you would like to apply.
 @example
-const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)} = await ${ctx.method}({
   pipeline: [
     { $match: { status: "registered" } },
     { $group: { _id: "$country", total: { $sum: 1 } } }
@@ -3366,7 +3366,7 @@ const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
     body: (ctx) => `Find zero or more ${ctx.plural} that matches the filter.
 @param {${getModelArgName(ctx.model.name, ctx.action)}} args - Select which filters you would like to apply.
 @example
-const ${lowerCase2(ctx.mapping.model)} = await ${ctx.method}({
+const ${uncapitalize2(ctx.mapping.model)} = await ${ctx.method}({
   filter: { age: { $gt: 25 } }
 })`,
     fields: {
@@ -3382,7 +3382,7 @@ function getMethodJSDocBody(action, mapping, model) {
     singular: capitalize5(mapping.model),
     plural: capitalize5(mapping.plural),
     firstScalar: model.fields.find((f) => f.kind === "scalar"),
-    method: `prisma.${lowerCase3(mapping.model)}.${action}`,
+    method: `prisma.${uncapitalize3(mapping.model)}.${action}`,
     action,
     mapping,
     model
@@ -3427,14 +3427,33 @@ function buildRuntimeDataModel(datamodel, runtimeName) {
 config.runtimeDataModel = JSON.parse(${JSON.stringify(datamodelString)})`;
 }
 
-// src/utils/buildGetWasmModule.ts
+// 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/wasm.ts
+import fs from "node:fs";
+import path from "node:path";
 import { capitalize as capitalize6 } from "@prisma/client-common";
 import { match } from "ts-pattern";
 function buildDynamicRequireFn() {
   return `const dynamicRequireFn = async <const T extends string>(name: T) =>
       typeof globalThis.__non_webpack_require__ === 'function'
         ? Promise.resolve(globalThis.__non_webpack_require__(name))
-        : await import(/* webpackIgnore: true */ name)`;
+        : await import(/* webpackIgnore: true */ /* @vite-ignore */ name)`;
+}
+function usesEdgeWasmRuntime(component, runtimeName) {
+  return runtimeName === "wasm-engine-edge" && component === "engine" || runtimeName === "wasm-compiler-edge" && component === "compiler";
 }
 function buildGetWasmModule({
   component,
@@ -3445,18 +3464,26 @@ function buildGetWasmModule({
   moduleFormat
 }) {
   const capitalizedComponent = capitalize6(component);
-  const wasmPathBase = `${runtimeBase}/query_${component}_bg.${activeProvider}`;
-  const wasmBindingsPath = `${wasmPathBase}.mjs`;
-  const wasmModulePath = `${wasmPathBase}.wasm`;
+  const buildEdgeLoader = usesEdgeWasmRuntime(component, runtimeName);
+  let wasmBindingsPath;
+  let wasmModulePath;
+  if (buildEdgeLoader) {
+    const wasmPathBase = `./query_${component}_bg`;
+    wasmBindingsPath = `${wasmPathBase}.js`;
+    wasmModulePath = `${wasmPathBase}.wasm`;
+  } else {
+    const wasmPathBase = `${runtimeBase}/query_${component}_bg.${activeProvider}`;
+    wasmBindingsPath = `${wasmPathBase}.mjs`;
+    wasmModulePath = `${wasmPathBase}.wasm`;
+  }
   const buildNodeLoader = match(runtimeName).with("library", () => component === "engine" && !!process.env.PRISMA_CLIENT_FORCE_WASM).with("client", () => component === "compiler").otherwise(() => false);
-  const buildEdgeLoader = runtimeName === "wasm-engine-edge" && component === "engine" || runtimeName === "wasm-compiler-edge" && component === "compiler";
   if (buildNodeLoader) {
     return `config.${component}Wasm = {
   getRuntime: async () => await import(${JSON.stringify(wasmBindingsPath)}),
 
   getQuery${capitalizedComponent}WasmModule: async () => {
     ${buildDynamicRequireFn()}
-  
+
     // Note: we must use dynamic imports here to avoid bundling errors like \`Module parse failed: Unexpected character '' (1:0)\`.
     const { readFile } = await dynamicRequireFn('node:fs/promises')
     ${buildRequire(moduleFormat)}
@@ -3488,23 +3515,34 @@ function buildRequire(moduleFormat) {
     const _require = createRequire(import.meta.url)
 `;
 }
-
-// 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 } };
+function buildWasmFileMap({ runtimeName, activeProvider }) {
+  const fileMap = {};
+  for (const component of ["engine", "compiler"]) {
+    if (!usesEdgeWasmRuntime(component, runtimeName)) {
+      continue;
+    }
+    const fileNameBase = `query_${component}_bg.${activeProvider}`;
+    const files = {
+      [`query_${component}_bg.wasm`]: `${fileNameBase}.wasm`,
+      [`query_${component}_bg.js`]: `${fileNameBase}.mjs`
+    };
+    for (const [targetFile, sourceFile] of Object.entries(files)) {
+      const bundledLocation = path.join(__dirname, sourceFile);
+      const sourceLocation = path.join(__dirname, "..", "..", "..", "client", "runtime", sourceFile);
+      if (fs.existsSync(bundledLocation)) {
+        fileMap[targetFile] = fs.readFileSync(bundledLocation);
+      } else if (fs.existsSync(sourceLocation)) {
+        fileMap[targetFile] = fs.readFileSync(sourceLocation);
+      } else {
+        throw new Error(`Could not find ${sourceFile} in ${bundledLocation} or ${sourceLocation}`);
+      }
+    }
   }
+  return fileMap;
 }
 
 // src/TSClient/PrismaClient.ts
-import { lowerCase as lowerCase4 } from "@prisma/client-common";
+import { uncapitalize as uncapitalize4 } from "@prisma/client-common";
 import * as ts4 from "@prisma/ts-builders";
 import indent3 from "indent-string";
 
@@ -3718,7 +3756,7 @@ function getPrismaClientClassDocComment({ dmmf }) {
     \`\`\`
     const prisma = new PrismaClient()
     // Fetch zero or more ${capitalize3(example.plural)}
-    const ${lowerCase4(example.plural)} = await prisma.${lowerCase4(example.model)}.findMany()
+    const ${uncapitalize4(example.plural)} = await prisma.${uncapitalize4(example.model)}.findMany()
     \`\`\`
 
     Read more in our [docs](https://www.prisma.io/docs/reference/tools-and-interfaces/prisma-client).
@@ -3787,7 +3825,7 @@ ${[
 
     ${indent3(
       dmmf.mappings.modelOperations.filter((m) => m.findMany).map((m) => {
-        let methodName = lowerCase4(m.model);
+        let methodName = uncapitalize4(m.model);
         if (methodName === "constructor") {
           methodName = '["constructor"]';
         }
@@ -3797,7 +3835,7 @@ ${[
   * Example usage:
   * \`\`\`ts
   * // Fetch zero or more ${capitalize3(m.plural)}
-  * const ${lowerCase4(m.plural)} = await prisma.${methodName}.findMany()
+  * const ${uncapitalize4(m.plural)} = await prisma.${methodName}.findMany()
   * \`\`\`
   */
 get ${methodName}(): Prisma.${m.model}Delegate<${generics.join(", ")}>;`;
@@ -3866,7 +3904,7 @@ function clientConfig(context, options) {
   const datasourceFilePath = datasources[0].sourceFilePath;
   const config = {
     generator,
-    relativePath: pathToPosix(path.relative(outputDir, path.dirname(datasourceFilePath))),
+    relativePath: pathToPosix(path2.relative(outputDir, path2.dirname(datasourceFilePath))),
     clientVersion: options.clientVersion,
     engineVersion: options.engineVersion,
     datasourceNames: datasources.map((d) => d.name),
@@ -3891,14 +3929,14 @@ ${buildDebugInitialization(edge)}
 }
 
 // src/TSClient/file-generators/ClientFile.ts
-import path3 from "node:path";
+import path4 from "node:path";
 import { ClientEngineType as ClientEngineType2, getClientEngineType as getClientEngineType2 } from "@prisma/internals";
 import * as ts6 from "@prisma/ts-builders";
 
 // src/utils/buildNFTAnnotations.ts
 import { getNodeAPIName } from "@prisma/get-platform";
 import { ClientEngineType, parseAWSNodejsRuntimeEnvVarVersion, pathToPosix as pathToPosix2 } from "@prisma/internals";
-import path2 from "path";
+import path3 from "path";
 function buildNFTAnnotations(noEngine, engineType, binaryTargets, relativeOutdir) {
   if (noEngine === true) return "";
   if (binaryTargets === void 0) {
@@ -3931,7 +3969,7 @@ function getQueryEngineFilename(engineType, binaryTarget) {
   return void 0;
 }
 function buildNFTAnnotation(fileName, relativeOutdir) {
-  const relativeFilePath = path2.join(relativeOutdir, fileName);
+  const relativeFilePath = path3.join(relativeOutdir, fileName);
   return `
 // file annotations for bundling tools to include these files
 path.join(__dirname, ${JSON.stringify(pathToPosix2(fileName))})
@@ -3993,7 +4031,7 @@ function createClientFile(context, options) {
     ].join("\n");
   });
   const binaryTargets = clientEngineType === ClientEngineType2.Library ? Object.keys(options.binaryPaths.libqueryEngine ?? {}) : Object.keys(options.binaryPaths.queryEngine ?? {});
-  const relativeOutdir = path3.relative(process.cwd(), options.outputDir);
+  const relativeOutdir = path4.relative(process.cwd(), options.outputDir);
   return `${jsDocHeader2}
 ${buildPreamble(options.edge, options.moduleFormat)}
 ${imports.join("\n")}
@@ -4309,7 +4347,7 @@ ${this.stringifyFields()}
 };
 
 // src/TSClient/Payload.ts
-import { lowerCase as lowerCase5 } from "@prisma/client-common";
+import { uncapitalize as uncapitalize5 } from "@prisma/client-common";
 import * as ts11 from "@prisma/ts-builders";
 function buildModelPayload(model, context) {
   const isComposite = context.dmmf.isComposite(model.name);
@@ -4327,7 +4365,7 @@ function buildModelPayload(model, context) {
       scalars.add(buildModelOutputProperty(field, context.dmmf));
     }
   }
-  const scalarsType = isComposite ? scalars : ts11.namedType("runtime.Types.Extensions.GetPayloadResult").addGenericArgument(scalars).addGenericArgument(ts11.namedType("ExtArgs").subKey("result").subKey(lowerCase5(model.name)));
+  const scalarsType = isComposite ? scalars : ts11.namedType("runtime.Types.Extensions.GetPayloadResult").addGenericArgument(scalars).addGenericArgument(ts11.namedType("ExtArgs").subKey("result").subKey(uncapitalize5(model.name)));
   const payloadTypeDeclaration = ts11.typeDeclaration(
     getPayloadName(model.name, false),
     ts11.objectType().add(ts11.property("name", ts11.stringLiteral(model.name))).add(ts11.property("objects", objects)).add(ts11.property("scalars", scalarsType)).add(ts11.property("composites", composites))
@@ -4339,7 +4377,7 @@ function buildModelPayload(model, context) {
 }
 
 // src/TSClient/SelectIncludeOmit.ts
-import { lowerCase as lowerCase6 } from "@prisma/client-common";
+import { uncapitalize as uncapitalize6 } from "@prisma/client-common";
 import * as ts12 from "@prisma/ts-builders";
 function buildIncludeType({
   modelName,
@@ -4373,7 +4411,7 @@ function buildSelectType({
   return buildExport(typeName, selectType);
 }
 function modelResultExtensionsType(modelName) {
-  return extArgsParam.toArgument().subKey("result").subKey(lowerCase6(modelName));
+  return extArgsParam.toArgument().subKey("result").subKey(uncapitalize6(modelName));
 }
 function buildScalarSelectType({ modelName, fields, context }) {
   const object = buildSelectOrIncludeObject(
@@ -5496,20 +5534,20 @@ export type ${this.type.name}<$PrismaModel> = FieldRefInputType<$PrismaModel, ${
 };
 
 // src/TSClient/globalOmit.ts
-import { lowerCase as lowerCase7 } from "@prisma/client-common";
+import { uncapitalize as uncapitalize7 } from "@prisma/client-common";
 import * as ts15 from "@prisma/ts-builders";
 function globalOmitConfig(dmmf) {
   const objectType11 = ts15.objectType().addMultiple(
     dmmf.datamodel.models.map((model) => {
       const type = ts15.namedType(`Prisma.${getOmitName(model.name)}`);
-      return ts15.property(lowerCase7(model.name), type).optional();
+      return ts15.property(uncapitalize7(model.name), type).optional();
     })
   );
   return ts15.moduleExport(ts15.typeDeclaration("GlobalOmitConfig", objectType11));
 }
 
 // src/TSClient/TypeMap.ts
-import { lowerCase as lowerCase8 } from "@prisma/client-common";
+import { uncapitalize as uncapitalize8 } from "@prisma/client-common";
 import { assertNever as assertNever2 } from "@prisma/internals";
 import * as ts16 from "@prisma/ts-builders";
 function clientTypeMapDefinition(context) {
@@ -5527,7 +5565,7 @@ function clientTypeMapModelsDefinition(context) {
   if (modelNames.length === 0) {
     meta.add(ts16.property("modelProps", ts16.neverType));
   } else {
-    meta.add(ts16.property("modelProps", ts16.unionType(modelNames.map((name) => ts16.stringLiteral(lowerCase8(name))))));
+    meta.add(ts16.property("modelProps", ts16.unionType(modelNames.map((name) => ts16.stringLiteral(uncapitalize8(name))))));
   }
   const isolationLevel = context.dmmf.hasEnumInNamespace("TransactionIsolationLevel", "prisma") ? ts16.namedType("TransactionIsolationLevel") : ts16.neverType;
   meta.add(ts16.property("txIsolationLevel", isolationLevel));
@@ -5803,7 +5841,7 @@ function buildClientOptions(context, options) {
              timeout ?= 5000
           `)
   );
-  if (["library", "client"].includes(options.runtimeName) && context.isPreviewFeatureOn("driverAdapters")) {
+  if (["library", "client", "wasm-compiler-edge", "wasm-engine-edge"].includes(options.runtimeName) && context.isPreviewFeatureOn("driverAdapters")) {
     clientOptions.add(
       ts17.property("adapter", ts17.unionType([ts17.namedType("runtime.SqlDriverAdapterFactory"), ts17.namedType("null")])).optional().setDocComment(
         ts17.docComment("Instance of a Driver Adapter, e.g., like one provided by `@prisma/adapter-planetscale`")
@@ -6132,12 +6170,13 @@ var generatedCodePreamble = `
 `;
 var tsNoCheckPreamble = `// @ts-nocheck 
 `;
-function addPreambleToTSFiles(fileMap, includeTSNoCheckPreamble) {
+var extensions = [".ts", ".cts", ".mts", ".js", ".cjs", ".mjs"];
+function addPreambleToSourceFiles(fileMap, includeTSNoCheckPreamble) {
   for (const [key, value] of Object.entries(fileMap)) {
-    if (typeof value === "string" && (key.endsWith(".ts") || key.endsWith(".cts") || key.endsWith(".mts"))) {
-      fileMap[key] = generatedCodePreamble + (includeTSNoCheckPreamble ? tsNoCheckPreamble : "") + value;
-    } else if (typeof value === "object" && value !== null) {
-      addPreambleToTSFiles(value, includeTSNoCheckPreamble);
+    if ((typeof value === "string" || Buffer.isBuffer(value)) && extensions.some((ext) => key.endsWith(ext))) {
+      fileMap[key] = generatedCodePreamble + (includeTSNoCheckPreamble ? tsNoCheckPreamble : "") + value.toString();
+    } else if (typeof value === "object" && value !== null && !Buffer.isBuffer(value)) {
+      addPreambleToSourceFiles(value, includeTSNoCheckPreamble);
     }
   }
 }
@@ -6217,7 +6256,17 @@ function buildClient({
       })
     };
   }
-  addPreambleToTSFiles(fileMap, tsNoCheckPreamble2);
+  fileMap = {
+    ...fileMap,
+    internal: {
+      ...fileMap.internal,
+      ...buildWasmFileMap({
+        runtimeName,
+        activeProvider
+      })
+    }
+  };
+  addPreambleToSourceFiles(fileMap, tsNoCheckPreamble2);
   return {
     fileMap,
     // a map of file names to their contents
@@ -6304,12 +6353,12 @@ To learn more about how to rename models, check out https://pris.ly/d/naming-mod
       await (0, import_fs_extra.ensureDir)("/tmp/prisma-engines");
     }
     for (const [binaryTarget, filePath] of Object.entries(enginePath)) {
-      const fileName = path4.basename(filePath);
+      const fileName = path5.basename(filePath);
       let target2;
       if (process.env.NETLIFY && !["rhel-openssl-1.0.x", "rhel-openssl-3.0.x"].includes(binaryTarget)) {
-        target2 = path4.join("/tmp/prisma-engines", fileName);
+        target2 = path5.join("/tmp/prisma-engines", fileName);
       } else {
-        target2 = path4.join(outputDir, fileName);
+        target2 = path5.join(outputDir, fileName);
       }
       await overwriteFile(filePath, target2);
     }
@@ -6318,12 +6367,12 @@ 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 = path4.join(outputDir, fileName);
-      await fs.rm(absolutePath, { recursive: true, force: true });
-      if (typeof content === "string") {
-        await fs.writeFile(absolutePath, content);
+      const absolutePath = path5.join(outputDir, fileName);
+      await fs2.rm(absolutePath, { recursive: true, force: true });
+      if (typeof content === "string" || Buffer.isBuffer(content)) {
+        await fs2.writeFile(absolutePath, content);
       } else {
-        await fs.mkdir(absolutePath);
+        await fs2.mkdir(absolutePath);
         await writeFileMap(absolutePath, content);
       }
     })
@@ -6407,10 +6456,10 @@ function validateDmmfAgainstDenylists(prismaClientDmmf) {
   return errorArray.length > 0 ? errorArray : null;
 }
 async function getGenerationDirs({ runtimeBase, outputDir }) {
-  const normalizedOutputDir = path4.normalize(outputDir);
+  const normalizedOutputDir = path5.normalize(outputDir);
   const normalizedRuntimeBase = pathToPosix3(runtimeBase);
-  const userPackageRoot = await pkgUp({ cwd: path4.dirname(normalizedOutputDir) });
-  const userProjectRoot = userPackageRoot ? path4.dirname(userPackageRoot) : process.cwd();
+  const userPackageRoot = await pkgUp({ cwd: path5.dirname(normalizedOutputDir) });
+  const userProjectRoot = userPackageRoot ? path5.dirname(userPackageRoot) : process.cwd();
   return {
     runtimeBase: normalizedRuntimeBase,
     outputDir: normalizedOutputDir,
@@ -6451,7 +6500,7 @@ function getNodeRuntimeName(engineType) {
 }
 async function deleteOutputDir(outputDir) {
   try {
-    const files = await fs.readdir(outputDir);
+    const files = await fs2.readdir(outputDir);
     if (files.length === 0) {
       return;
     }
@@ -6472,7 +6521,7 @@ async function deleteOutputDir(outputDir) {
         {
           followSymbolicLinks: false
         }
-      )).map((file4) => fs.unlink(file4))
+      )).map((file4) => fs2.unlink(file4))
     );
   } catch (error) {
     if (error.code !== "ENOENT") {
@@ -6489,7 +6538,7 @@ import { getTsconfig } from "get-tsconfig";
 import { match as match2 } from "ts-pattern";
 
 // package.json
-var version = "6.12.0-dev.4";
+var version = "6.12.0-dev.40";
 
 // src/module-format.ts
 function parseModuleFormat(format) {