@prisma/cli-init 0.0.0-dev.202511240942 → 0.0.0-dev.202511250035

package/dist/index.js

@@ -22,11 +22,18 @@ import {
   withResolvers,
   y
 } from "./chunk-7C5I22R2.js";
+import {
+  credentialsFile,
+  poll,
+  printPpgInitOutput,
+  requestOrThrow,
+  successMessage
+} from "./chunk-6Q24WZUV.js";
 import {
   __commonJS,
   __require,
   __toESM
-} from "./chunk-NJX2BODH.js";
+} from "./chunk-YX4UTTNJ.js";
 
 // ../../node_modules/.pnpm/graceful-fs@4.2.11/node_modules/graceful-fs/polyfills.js
 var require_polyfills = __commonJS({
@@ -56,56 +63,56 @@ var require_polyfills = __commonJS({
     }
     var chdir;
     module.exports = patch;
-    function patch(fs5) {
+    function patch(fs3) {
       if (constants.hasOwnProperty("O_SYMLINK") && process.version.match(/^v0\.6\.[0-2]|^v0\.5\./)) {
-        patchLchmod(fs5);
-      }
-      if (!fs5.lutimes) {
-        patchLutimes(fs5);
-      }
-      fs5.chown = chownFix(fs5.chown);
-      fs5.fchown = chownFix(fs5.fchown);
-      fs5.lchown = chownFix(fs5.lchown);
-      fs5.chmod = chmodFix(fs5.chmod);
-      fs5.fchmod = chmodFix(fs5.fchmod);
-      fs5.lchmod = chmodFix(fs5.lchmod);
-      fs5.chownSync = chownFixSync(fs5.chownSync);
-      fs5.fchownSync = chownFixSync(fs5.fchownSync);
-      fs5.lchownSync = chownFixSync(fs5.lchownSync);
-      fs5.chmodSync = chmodFixSync(fs5.chmodSync);
-      fs5.fchmodSync = chmodFixSync(fs5.fchmodSync);
-      fs5.lchmodSync = chmodFixSync(fs5.lchmodSync);
-      fs5.stat = statFix(fs5.stat);
-      fs5.fstat = statFix(fs5.fstat);
-      fs5.lstat = statFix(fs5.lstat);
-      fs5.statSync = statFixSync(fs5.statSync);
-      fs5.fstatSync = statFixSync(fs5.fstatSync);
-      fs5.lstatSync = statFixSync(fs5.lstatSync);
-      if (fs5.chmod && !fs5.lchmod) {
-        fs5.lchmod = function(path6, 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(path3, mode, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs5.lchmodSync = function() {
+        fs3.lchmodSync = function() {
         };
       }
-      if (fs5.chown && !fs5.lchown) {
-        fs5.lchown = function(path6, uid, gid, cb) {
+      if (fs3.chown && !fs3.lchown) {
+        fs3.lchown = function(path3, uid, gid, cb) {
           if (cb)
             process.nextTick(cb);
         };
-        fs5.lchownSync = function() {
+        fs3.lchownSync = function() {
         };
       }
       if (platform === "win32") {
-        fs5.rename = typeof fs5.rename !== "function" ? fs5.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() {
-                  fs5.stat(to, function(stater, st) {
+                  fs3.stat(to, function(stater, st) {
                     if (stater && stater.code === "ENOENT")
                       fs$rename(from, to, CB);
                     else
@@ -123,9 +130,9 @@ var require_polyfills = __commonJS({
           if (Object.setPrototypeOf)
             Object.setPrototypeOf(rename, fs$rename);
           return rename;
-        }(fs5.rename);
+        }(fs3.rename);
       }
-      fs5.read = typeof fs5.read !== "function" ? fs5.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") {
@@ -133,23 +140,23 @@ var require_polyfills = __commonJS({
             callback = function(er, _, __) {
               if (er && er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
-                return fs$read.call(fs5, 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(fs5, 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;
-      }(fs5.read);
-      fs5.readSync = typeof fs5.readSync !== "function" ? fs5.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(fs5, fd, buffer, offset, length, position);
+              return fs$readSync.call(fs3, fd, buffer, offset, length, position);
             } catch (er) {
               if (er.code === "EAGAIN" && eagCounter < 10) {
                 eagCounter++;
@@ -159,11 +166,11 @@ var require_polyfills = __commonJS({
             }
           }
         };
-      }(fs5.readSync);
-      function patchLchmod(fs6) {
-        fs6.lchmod = function(path6, mode, callback) {
-          fs6.open(
-            path6,
+      }(fs3.readSync);
+      function patchLchmod(fs4) {
+        fs4.lchmod = function(path3, mode, callback) {
+          fs4.open(
+            path3,
             constants.O_WRONLY | constants.O_SYMLINK,
             mode,
             function(err, fd) {
@@ -172,8 +179,8 @@ var require_polyfills = __commonJS({
                   callback(err);
                 return;
               }
-              fs6.fchmod(fd, mode, function(err2) {
-                fs6.close(fd, function(err22) {
+              fs4.fchmod(fd, mode, function(err2) {
+                fs4.close(fd, function(err22) {
                   if (callback)
                     callback(err2 || err22);
                 });
@@ -181,68 +188,68 @@ var require_polyfills = __commonJS({
             }
           );
         };
-        fs6.lchmodSync = function(path6, mode) {
-          var fd = fs6.openSync(path6, constants.O_WRONLY | constants.O_SYMLINK, mode);
+        fs4.lchmodSync = function(path3, mode) {
+          var fd = fs4.openSync(path3, constants.O_WRONLY | constants.O_SYMLINK, mode);
           var threw = true;
           var ret;
           try {
-            ret = fs6.fchmodSync(fd, mode);
+            ret = fs4.fchmodSync(fd, mode);
             threw = false;
           } finally {
             if (threw) {
               try {
-                fs6.closeSync(fd);
+                fs4.closeSync(fd);
               } catch (er) {
               }
             } else {
-              fs6.closeSync(fd);
+              fs4.closeSync(fd);
             }
           }
           return ret;
         };
       }
-      function patchLutimes(fs6) {
-        if (constants.hasOwnProperty("O_SYMLINK") && fs6.futimes) {
-          fs6.lutimes = function(path6, at, mt, cb) {
-            fs6.open(path6, constants.O_SYMLINK, function(er, fd) {
+      function patchLutimes(fs4) {
+        if (constants.hasOwnProperty("O_SYMLINK") && fs4.futimes) {
+          fs4.lutimes = function(path3, at, mt, cb) {
+            fs4.open(path3, constants.O_SYMLINK, function(er, fd) {
               if (er) {
                 if (cb)
                   cb(er);
                 return;
               }
-              fs6.futimes(fd, at, mt, function(er2) {
-                fs6.close(fd, function(er22) {
+              fs4.futimes(fd, at, mt, function(er2) {
+                fs4.close(fd, function(er22) {
                   if (cb)
                     cb(er2 || er22);
                 });
               });
             });
           };
-          fs6.lutimesSync = function(path6, at, mt) {
-            var fd = fs6.openSync(path6, constants.O_SYMLINK);
+          fs4.lutimesSync = function(path3, at, mt) {
+            var fd = fs4.openSync(path3, constants.O_SYMLINK);
             var ret;
             var threw = true;
             try {
-              ret = fs6.futimesSync(fd, at, mt);
+              ret = fs4.futimesSync(fd, at, mt);
               threw = false;
             } finally {
               if (threw) {
                 try {
-                  fs6.closeSync(fd);
+                  fs4.closeSync(fd);
                 } catch (er) {
                 }
               } else {
-                fs6.closeSync(fd);
+                fs4.closeSync(fd);
               }
             }
             return ret;
           };
-        } else if (fs6.futimes) {
-          fs6.lutimes = function(_a, _b, _c, cb) {
+        } else if (fs4.futimes) {
+          fs4.lutimes = function(_a, _b, _c, cb) {
             if (cb)
               process.nextTick(cb);
           };
-          fs6.lutimesSync = function() {
+          fs4.lutimesSync = function() {
           };
         }
       }
@@ -250,7 +257,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, mode, cb) {
-          return orig.call(fs5, target, mode, function(er) {
+          return orig.call(fs3, target, mode, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -263,7 +270,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, mode) {
           try {
-            return orig.call(fs5, target, mode);
+            return orig.call(fs3, target, mode);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -274,7 +281,7 @@ var require_polyfills = __commonJS({
         if (!orig)
           return orig;
         return function(target, uid, gid, cb) {
-          return orig.call(fs5, target, uid, gid, function(er) {
+          return orig.call(fs3, target, uid, gid, function(er) {
             if (chownErOk(er))
               er = null;
             if (cb)
@@ -287,7 +294,7 @@ var require_polyfills = __commonJS({
           return orig;
         return function(target, uid, gid) {
           try {
-            return orig.call(fs5, target, uid, gid);
+            return orig.call(fs3, target, uid, gid);
           } catch (er) {
             if (!chownErOk(er))
               throw er;
@@ -312,14 +319,14 @@ var require_polyfills = __commonJS({
             if (cb)
               cb.apply(this, arguments);
           }
-          return options ? orig.call(fs5, target, options, callback) : orig.call(fs5, 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(fs5, target, options) : orig.call(fs5, target);
+          var stats = options ? orig.call(fs3, target, options) : orig.call(fs3, target);
           if (stats) {
             if (stats.uid < 0)
               stats.uid += 4294967296;
@@ -351,17 +358,17 @@ var require_legacy_streams = __commonJS({
     "use strict";
     var Stream = __require("stream").Stream;
     module.exports = legacy;
-    function legacy(fs5) {
+    function legacy(fs3) {
       return {
         ReadStream,
         WriteStream
       };
-      function ReadStream(path6, options) {
+      function ReadStream(path3, options) {
         if (!(this instanceof ReadStream))
-          return new ReadStream(path6, options);
+          return new ReadStream(path3, options);
         Stream.call(this);
         var self = this;
-        this.path = path6;
+        this.path = path3;
         this.fd = null;
         this.readable = true;
         this.paused = false;
@@ -396,7 +403,7 @@ var require_legacy_streams = __commonJS({
           });
           return;
         }
-        fs5.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,11 +414,11 @@ var require_legacy_streams = __commonJS({
           self._read();
         });
       }
-      function WriteStream(path6, options) {
+      function WriteStream(path3, options) {
         if (!(this instanceof WriteStream))
-          return new WriteStream(path6, options);
+          return new WriteStream(path3, options);
         Stream.call(this);
-        this.path = path6;
+        this.path = path3;
         this.fd = null;
         this.writable = true;
         this.flags = "w";
@@ -436,7 +443,7 @@ var require_legacy_streams = __commonJS({
         this.busy = false;
         this._queue = [];
         if (this.fd === null) {
-          this._open = fs5.open;
+          this._open = fs3.open;
           this._queue.push([this._open, this.path, this.flags, this.mode, void 0]);
           this.flush();
         }
@@ -472,7 +479,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 fs5 = __require("fs");
+    var fs3 = __require("fs");
     var polyfills = require_polyfills();
     var legacy = require_legacy_streams();
     var clone = require_clone();
@@ -495,21 +502,21 @@ var require_graceful_fs = __commonJS({
         }
       });
     }
-    var debug3 = noop;
+    var debug = noop;
     if (util.debuglog)
-      debug3 = util.debuglog("gfs4");
+      debug = util.debuglog("gfs4");
     else if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || ""))
-      debug3 = function() {
+      debug = function() {
         var m = util.format.apply(util, arguments);
         m = "GFS4: " + m.split(/\n/).join("\nGFS4: ");
         console.error(m);
       };
-    if (!fs5[gracefulQueue]) {
+    if (!fs3[gracefulQueue]) {
       queue = global[gracefulQueue] || [];
-      publishQueue(fs5, queue);
-      fs5.close = function(fs$close) {
+      publishQueue(fs3, queue);
+      fs3.close = function(fs$close) {
         function close(fd, cb) {
-          return fs$close.call(fs5, fd, function(err) {
+          return fs$close.call(fs3, fd, function(err) {
             if (!err) {
               resetQueue();
             }
@@ -521,48 +528,48 @@ var require_graceful_fs = __commonJS({
           value: fs$close
         });
         return close;
-      }(fs5.close);
-      fs5.closeSync = function(fs$closeSync) {
+      }(fs3.close);
+      fs3.closeSync = function(fs$closeSync) {
         function closeSync(fd) {
-          fs$closeSync.apply(fs5, arguments);
+          fs$closeSync.apply(fs3, arguments);
           resetQueue();
         }
         Object.defineProperty(closeSync, previousSymbol, {
           value: fs$closeSync
         });
         return closeSync;
-      }(fs5.closeSync);
+      }(fs3.closeSync);
       if (/\bgfs4\b/i.test(process.env.NODE_DEBUG || "")) {
         process.on("exit", function() {
-          debug3(fs5[gracefulQueue]);
-          __require("assert").equal(fs5[gracefulQueue].length, 0);
+          debug(fs3[gracefulQueue]);
+          __require("assert").equal(fs3[gracefulQueue].length, 0);
         });
       }
     }
     var queue;
     if (!global[gracefulQueue]) {
-      publishQueue(global, fs5[gracefulQueue]);
-    }
-    module.exports = patch(clone(fs5));
-    if (process.env.TEST_GRACEFUL_FS_GLOBAL_PATCH && !fs5.__patched) {
-      module.exports = patch(fs5);
-      fs5.__patched = true;
-    }
-    function patch(fs6) {
-      polyfills(fs6);
-      fs6.gracefulify = patch;
-      fs6.createReadStream = createReadStream;
-      fs6.createWriteStream = createWriteStream;
-      var fs$readFile = fs6.readFile;
-      fs6.readFile = readFile;
-      function readFile(path6, 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(path3, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$readFile(path6, options, cb);
-        function go$readFile(path7, options2, cb2, startTime) {
-          return fs$readFile(path7, options2, function(err) {
+        return go$readFile(path3, options, cb);
+        function go$readFile(path4, options2, cb2, startTime) {
+          return fs$readFile(path4, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$readFile, [path7, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$readFile, [path4, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -570,16 +577,16 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$writeFile = fs6.writeFile;
-      fs6.writeFile = writeFile2;
-      function writeFile2(path6, data, options, cb) {
+      var fs$writeFile = fs4.writeFile;
+      fs4.writeFile = writeFile2;
+      function writeFile2(path3, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$writeFile(path6, data, options, cb);
-        function go$writeFile(path7, data2, options2, cb2, startTime) {
-          return fs$writeFile(path7, data2, options2, function(err) {
+        return go$writeFile(path3, data, options, cb);
+        function go$writeFile(path4, data2, options2, cb2, startTime) {
+          return fs$writeFile(path4, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$writeFile, [path7, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$writeFile, [path4, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -587,17 +594,17 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$appendFile = fs6.appendFile;
+      var fs$appendFile = fs4.appendFile;
       if (fs$appendFile)
-        fs6.appendFile = appendFile;
-      function appendFile(path6, data, options, cb) {
+        fs4.appendFile = appendFile;
+      function appendFile(path3, data, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        return go$appendFile(path6, data, options, cb);
-        function go$appendFile(path7, data2, options2, cb2, startTime) {
-          return fs$appendFile(path7, data2, options2, function(err) {
+        return go$appendFile(path3, data, options, cb);
+        function go$appendFile(path4, data2, options2, cb2, startTime) {
+          return fs$appendFile(path4, data2, options2, function(err) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$appendFile, [path7, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$appendFile, [path4, data2, options2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -605,9 +612,9 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$copyFile = fs6.copyFile;
+      var fs$copyFile = fs4.copyFile;
       if (fs$copyFile)
-        fs6.copyFile = copyFile;
+        fs4.copyFile = copyFile;
       function copyFile(src, dest, flags, cb) {
         if (typeof flags === "function") {
           cb = flags;
@@ -625,34 +632,34 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      var fs$readdir = fs6.readdir;
-      fs6.readdir = readdir;
+      var fs$readdir = fs4.readdir;
+      fs4.readdir = readdir;
       var noReaddirOptionVersions = /^v[0-5]\./;
-      function readdir(path6, options, cb) {
+      function readdir(path3, options, cb) {
         if (typeof options === "function")
           cb = options, options = null;
-        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path7, options2, cb2, startTime) {
-          return fs$readdir(path7, fs$readdirCallback(
-            path7,
+        var go$readdir = noReaddirOptionVersions.test(process.version) ? function go$readdir2(path4, options2, cb2, startTime) {
+          return fs$readdir(path4, fs$readdirCallback(
+            path4,
             options2,
             cb2,
             startTime
           ));
-        } : function go$readdir2(path7, options2, cb2, startTime) {
-          return fs$readdir(path7, options2, fs$readdirCallback(
-            path7,
+        } : function go$readdir2(path4, options2, cb2, startTime) {
+          return fs$readdir(path4, options2, fs$readdirCallback(
+            path4,
             options2,
             cb2,
             startTime
           ));
         };
-        return go$readdir(path6, options, cb);
-        function fs$readdirCallback(path7, options2, cb2, startTime) {
+        return go$readdir(path3, options, cb);
+        function fs$readdirCallback(path4, options2, cb2, startTime) {
           return function(err, files) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
               enqueue([
                 go$readdir,
-                [path7, options2, cb2],
+                [path4, options2, cb2],
                 err,
                 startTime || Date.now(),
                 Date.now()
@@ -667,21 +674,21 @@ var require_graceful_fs = __commonJS({
         }
       }
       if (process.version.substr(0, 4) === "v0.8") {
-        var legStreams = legacy(fs6);
+        var legStreams = legacy(fs4);
         ReadStream = legStreams.ReadStream;
         WriteStream = legStreams.WriteStream;
       }
-      var fs$ReadStream = fs6.ReadStream;
+      var fs$ReadStream = fs4.ReadStream;
       if (fs$ReadStream) {
         ReadStream.prototype = Object.create(fs$ReadStream.prototype);
         ReadStream.prototype.open = ReadStream$open;
       }
-      var fs$WriteStream = fs6.WriteStream;
+      var fs$WriteStream = fs4.WriteStream;
       if (fs$WriteStream) {
         WriteStream.prototype = Object.create(fs$WriteStream.prototype);
         WriteStream.prototype.open = WriteStream$open;
       }
-      Object.defineProperty(fs6, "ReadStream", {
+      Object.defineProperty(fs4, "ReadStream", {
         get: function() {
           return ReadStream;
         },
@@ -691,7 +698,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      Object.defineProperty(fs6, "WriteStream", {
+      Object.defineProperty(fs4, "WriteStream", {
         get: function() {
           return WriteStream;
         },
@@ -702,7 +709,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileReadStream = ReadStream;
-      Object.defineProperty(fs6, "FileReadStream", {
+      Object.defineProperty(fs4, "FileReadStream", {
         get: function() {
           return FileReadStream;
         },
@@ -713,7 +720,7 @@ var require_graceful_fs = __commonJS({
         configurable: true
       });
       var FileWriteStream = WriteStream;
-      Object.defineProperty(fs6, "FileWriteStream", {
+      Object.defineProperty(fs4, "FileWriteStream", {
         get: function() {
           return FileWriteStream;
         },
@@ -723,7 +730,7 @@ var require_graceful_fs = __commonJS({
         enumerable: true,
         configurable: true
       });
-      function ReadStream(path6, options) {
+      function ReadStream(path3, options) {
         if (this instanceof ReadStream)
           return fs$ReadStream.apply(this, arguments), this;
         else
@@ -731,7 +738,7 @@ var require_graceful_fs = __commonJS({
       }
       function ReadStream$open() {
         var that = this;
-        open2(that.path, that.flags, that.mode, function(err, fd) {
+        open(that.path, that.flags, that.mode, function(err, fd) {
           if (err) {
             if (that.autoClose)
               that.destroy();
@@ -743,7 +750,7 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function WriteStream(path6, options) {
+      function WriteStream(path3, options) {
         if (this instanceof WriteStream)
           return fs$WriteStream.apply(this, arguments), this;
         else
@@ -751,7 +758,7 @@ var require_graceful_fs = __commonJS({
       }
       function WriteStream$open() {
         var that = this;
-        open2(that.path, that.flags, that.mode, function(err, fd) {
+        open(that.path, that.flags, that.mode, function(err, fd) {
           if (err) {
             that.destroy();
             that.emit("error", err);
@@ -761,22 +768,22 @@ var require_graceful_fs = __commonJS({
           }
         });
       }
-      function createReadStream(path6, options) {
-        return new fs6.ReadStream(path6, options);
+      function createReadStream(path3, options) {
+        return new fs4.ReadStream(path3, options);
       }
-      function createWriteStream(path6, options) {
-        return new fs6.WriteStream(path6, options);
+      function createWriteStream(path3, options) {
+        return new fs4.WriteStream(path3, options);
       }
-      var fs$open = fs6.open;
-      fs6.open = open2;
-      function open2(path6, flags, mode, cb) {
+      var fs$open = fs4.open;
+      fs4.open = open;
+      function open(path3, flags, mode, cb) {
         if (typeof mode === "function")
           cb = mode, mode = null;
-        return go$open(path6, flags, mode, cb);
-        function go$open(path7, flags2, mode2, cb2, startTime) {
-          return fs$open(path7, flags2, mode2, function(err, fd) {
+        return go$open(path3, flags, mode, cb);
+        function go$open(path4, flags2, mode2, cb2, startTime) {
+          return fs$open(path4, flags2, mode2, function(err, fd) {
             if (err && (err.code === "EMFILE" || err.code === "ENFILE"))
-              enqueue([go$open, [path7, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
+              enqueue([go$open, [path4, flags2, mode2, cb2], err, startTime || Date.now(), Date.now()]);
             else {
               if (typeof cb2 === "function")
                 cb2.apply(this, arguments);
@@ -784,20 +791,20 @@ var require_graceful_fs = __commonJS({
           });
         }
       }
-      return fs6;
+      return fs4;
     }
     function enqueue(elem) {
-      debug3("ENQUEUE", elem[0].name, elem[1]);
-      fs5[gracefulQueue].push(elem);
+      debug("ENQUEUE", elem[0].name, elem[1]);
+      fs3[gracefulQueue].push(elem);
       retry();
     }
     var retryTimer;
     function resetQueue() {
       var now = Date.now();
-      for (var i = 0; i < fs5[gracefulQueue].length; ++i) {
-        if (fs5[gracefulQueue][i].length > 2) {
-          fs5[gracefulQueue][i][3] = now;
-          fs5[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();
@@ -805,19 +812,19 @@ var require_graceful_fs = __commonJS({
     function retry() {
       clearTimeout(retryTimer);
       retryTimer = void 0;
-      if (fs5[gracefulQueue].length === 0)
+      if (fs3[gracefulQueue].length === 0)
         return;
-      var elem = fs5[gracefulQueue].shift();
+      var elem = fs3[gracefulQueue].shift();
       var fn = elem[0];
       var args = elem[1];
       var err = elem[2];
       var startTime = elem[3];
       var lastTime = elem[4];
       if (startTime === void 0) {
-        debug3("RETRY", fn.name, args);
+        debug("RETRY", fn.name, args);
         fn.apply(null, args);
       } else if (Date.now() - startTime >= 6e4) {
-        debug3("TIMEOUT", fn.name, args);
+        debug("TIMEOUT", fn.name, args);
         var cb = args.pop();
         if (typeof cb === "function")
           cb.call(null, err);
@@ -826,10 +833,10 @@ var require_graceful_fs = __commonJS({
         var sinceStart = Math.max(lastTime - startTime, 1);
         var desiredDelay = Math.min(sinceStart * 1.2, 100);
         if (sinceAttempt >= desiredDelay) {
-          debug3("RETRY", fn.name, args);
+          debug("RETRY", fn.name, args);
           fn.apply(null, args.concat([startTime]));
         } else {
-          fs5[gracefulQueue].push(elem);
+          fs3[gracefulQueue].push(elem);
         }
       }
       if (retryTimer === void 0) {
@@ -1269,10 +1276,10 @@ var require_mtime_precision = __commonJS({
   "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/mtime-precision.js"(exports, module) {
     "use strict";
     var cacheSymbol = Symbol();
-    function probe(file, fs5, callback) {
-      const cachedPrecision = fs5[cacheSymbol];
+    function probe(file, fs3, callback) {
+      const cachedPrecision = fs3[cacheSymbol];
       if (cachedPrecision) {
-        return fs5.stat(file, (err, stat) => {
+        return fs3.stat(file, (err, stat) => {
           if (err) {
             return callback(err);
           }
@@ -1280,16 +1287,16 @@ var require_mtime_precision = __commonJS({
         });
       }
       const mtime = new Date(Math.ceil(Date.now() / 1e3) * 1e3 + 5);
-      fs5.utimes(file, mtime, mtime, (err) => {
+      fs3.utimes(file, mtime, mtime, (err) => {
         if (err) {
           return callback(err);
         }
-        fs5.stat(file, (err2, stat) => {
+        fs3.stat(file, (err2, stat) => {
           if (err2) {
             return callback(err2);
           }
           const precision = stat.mtime.getTime() % 1e3 === 0 ? "s" : "ms";
-          Object.defineProperty(fs5, cacheSymbol, { value: precision });
+          Object.defineProperty(fs3, cacheSymbol, { value: precision });
           callback(null, stat.mtime, precision);
         });
       });
@@ -1310,8 +1317,8 @@ var require_mtime_precision = __commonJS({
 var require_lockfile = __commonJS({
   "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/lockfile.js"(exports, module) {
     "use strict";
-    var path6 = __require("path");
-    var fs5 = require_graceful_fs();
+    var path3 = __require("path");
+    var fs3 = require_graceful_fs();
     var retry = require_retry2();
     var onExit = require_signal_exit();
     var mtimePrecision = require_mtime_precision();
@@ -1321,7 +1328,7 @@ var require_lockfile = __commonJS({
     }
     function resolveCanonicalPath(file, options, callback) {
       if (!options.realpath) {
-        return callback(null, path6.resolve(file));
+        return callback(null, path3.resolve(file));
       }
       options.fs.realpath(file, callback);
     }
@@ -1442,7 +1449,7 @@ var require_lockfile = __commonJS({
         update: null,
         realpath: true,
         retries: 0,
-        fs: fs5,
+        fs: fs3,
         onCompromised: (err) => {
           throw err;
         },
@@ -1486,7 +1493,7 @@ var require_lockfile = __commonJS({
     }
     function unlock2(file, options, callback) {
       options = {
-        fs: fs5,
+        fs: fs3,
         realpath: true,
         ...options
       };
@@ -1508,7 +1515,7 @@ var require_lockfile = __commonJS({
       options = {
         stale: 1e4,
         realpath: true,
-        fs: fs5,
+        fs: fs3,
         ...options
       };
       options.stale = Math.max(options.stale || 0, 2e3);
@@ -1547,16 +1554,16 @@ var require_lockfile = __commonJS({
 var require_adapter = __commonJS({
   "../../node_modules/.pnpm/proper-lockfile@4.1.2/node_modules/proper-lockfile/lib/adapter.js"(exports, module) {
     "use strict";
-    var fs5 = require_graceful_fs();
-    function createSyncFs(fs6) {
+    var fs3 = require_graceful_fs();
+    function createSyncFs(fs4) {
       const methods = ["mkdir", "realpath", "stat", "rmdir", "utimes"];
-      const newFs = { ...fs6 };
+      const newFs = { ...fs4 };
       methods.forEach((method) => {
         newFs[method] = (...args) => {
           const callback = args.pop();
           let ret;
           try {
-            ret = fs6[`${method}Sync`](...args);
+            ret = fs4[`${method}Sync`](...args);
           } catch (err) {
             return callback(err);
           }
@@ -1594,7 +1601,7 @@ var require_adapter = __commonJS({
     }
     function toSyncOptions(options) {
       options = { ...options };
-      options.fs = createSyncFs(options.fs || fs5);
+      options.fs = createSyncFs(options.fs || fs3);
       if (typeof options.retries === "number" && options.retries > 0 || options.retries && typeof options.retries.retries === "number" && options.retries.retries > 0) {
         throw Object.assign(new Error("Cannot use retries with the sync api"), { code: "ESYNC" });
       }
@@ -1658,65 +1665,65 @@ function normalizeWindowsPath(input2 = "") {
 var _UNC_REGEX = /^[/\\]{2}/;
 var _IS_ABSOLUTE_RE = /^[/\\](?![/\\])|^[/\\]{2}(?!\.)|^[A-Za-z]:[/\\]/;
 var _DRIVE_LETTER_RE = /^[A-Za-z]:$/;
-var normalize = function(path6) {
-  if (path6.length === 0) {
+var normalize = function(path3) {
+  if (path3.length === 0) {
     return ".";
   }
-  path6 = normalizeWindowsPath(path6);
-  const isUNCPath = path6.match(_UNC_REGEX);
-  const isPathAbsolute = isAbsolute(path6);
-  const trailingSeparator = path6[path6.length - 1] === "/";
-  path6 = normalizeString(path6, !isPathAbsolute);
-  if (path6.length === 0) {
+  path3 = normalizeWindowsPath(path3);
+  const isUNCPath = path3.match(_UNC_REGEX);
+  const isPathAbsolute = isAbsolute(path3);
+  const trailingSeparator = path3[path3.length - 1] === "/";
+  path3 = normalizeString(path3, !isPathAbsolute);
+  if (path3.length === 0) {
     if (isPathAbsolute) {
       return "/";
     }
     return trailingSeparator ? "./" : ".";
   }
   if (trailingSeparator) {
-    path6 += "/";
+    path3 += "/";
   }
-  if (_DRIVE_LETTER_RE.test(path6)) {
-    path6 += "/";
+  if (_DRIVE_LETTER_RE.test(path3)) {
+    path3 += "/";
   }
   if (isUNCPath) {
     if (!isPathAbsolute) {
-      return `//./${path6}`;
+      return `//./${path3}`;
     }
-    return `//${path6}`;
+    return `//${path3}`;
   }
-  return isPathAbsolute && !isAbsolute(path6) ? `/${path6}` : path6;
+  return isPathAbsolute && !isAbsolute(path3) ? `/${path3}` : path3;
 };
 var join = function(...segments) {
-  let path6 = "";
+  let path3 = "";
   for (const seg of segments) {
     if (!seg) {
       continue;
     }
-    if (path6.length > 0) {
-      const pathTrailing = path6[path6.length - 1] === "/";
+    if (path3.length > 0) {
+      const pathTrailing = path3[path3.length - 1] === "/";
       const segLeading = seg[0] === "/";
       const both = pathTrailing && segLeading;
       if (both) {
-        path6 += seg.slice(1);
+        path3 += seg.slice(1);
       } else {
-        path6 += pathTrailing || segLeading ? seg : `/${seg}`;
+        path3 += pathTrailing || segLeading ? seg : `/${seg}`;
       }
     } else {
-      path6 += seg;
+      path3 += seg;
     }
   }
-  return normalize(path6);
+  return normalize(path3);
 };
-function normalizeString(path6, allowAboveRoot) {
+function normalizeString(path3, allowAboveRoot) {
   let res = "";
   let lastSegmentLength = 0;
   let lastSlash = -1;
   let dots = 0;
   let char = null;
-  for (let index = 0; index <= path6.length; ++index) {
-    if (index < path6.length) {
-      char = path6[index];
+  for (let index = 0; index <= path3.length; ++index) {
+    if (index < path3.length) {
+      char = path3[index];
     } else if (char === "/") {
       break;
     } else {
@@ -1753,9 +1760,9 @@ function normalizeString(path6, allowAboveRoot) {
         }
       } else {
         if (res.length > 0) {
-          res += `/${path6.slice(lastSlash + 1, index)}`;
+          res += `/${path3.slice(lastSlash + 1, index)}`;
         } else {
-          res = path6.slice(lastSlash + 1, index);
+          res = path3.slice(lastSlash + 1, index);
         }
         lastSegmentLength = index - lastSlash - 1;
       }
@@ -1776,8 +1783,8 @@ var isAbsolute = function(p) {
 // ../../node_modules/.pnpm/pathe@2.0.3/node_modules/pathe/dist/utils.mjs
 var normalizedAliasSymbol = Symbol.for("pathe:normalizedAlias");
 var SLASH_RE = /[/\\]/;
-function filename(path6) {
-  const base = path6.split(SLASH_RE).pop();
+function filename(path3) {
+  const base = path3.split(SLASH_RE).pop();
   if (!base) {
     return void 0;
   }
@@ -2272,9 +2279,9 @@ var DEFAULT_SHADOW_DATABASE_PORT = 51215;
 var MAX_PORT = 65535;
 var NO_PORT = -Infinity;
 async function pickPorts(options) {
-  const { debug: debug3, name, requestedPorts, servers } = options;
+  const { debug, name, requestedPorts, servers } = options;
   const { portsUsedByOtherServers, portsUsedByThisServerLastTime } = extractUsedPorts(name, servers);
-  if (debug3) {
+  if (debug) {
     console.debug(`ports used by other servers: ${Object.keys(portsUsedByOtherServers).join(", ")}`);
     console.debug(`ports used by "${name}" server last time: ${JSON.stringify(portsUsedByThisServerLastTime)}`);
   }
@@ -2282,39 +2289,39 @@ async function pickPorts(options) {
   const portKeys = ["port", "databasePort", "shadowDatabasePort"];
   for (const portKey of portKeys) {
     const port = await trySpecificPorts({
-      debug: debug3,
+      debug,
       portKey,
       portsUsedByOtherServers,
       portsUsedByThisServerLastTime,
       requestedPorts
-    }) ?? await tryAnyPort({ debug: debug3, pickedPorts, portKey, portsUsedByOtherServers, portsUsedByThisServerLastTime });
-    if (debug3) {
+    }) ?? await tryAnyPort({ debug, pickedPorts, portKey, portsUsedByOtherServers, portsUsedByThisServerLastTime });
+    if (debug) {
       console.debug(`Got port for "${portKey}": ${port}`);
     }
     pickedPorts[portKey] = port;
   }
-  if (debug3) {
+  if (debug) {
     console.debug(`Picked ports: ${JSON.stringify(pickedPorts)}`);
   }
   return pickedPorts;
 }
 async function trySpecificPorts(options) {
-  const { debug: debug3, portKey, portsUsedByOtherServers, portsUsedByThisServerLastTime, requestedPorts } = options;
+  const { debug, portKey, portsUsedByOtherServers, portsUsedByThisServerLastTime, requestedPorts } = options;
   const { [portKey]: requestedPort, ...otherRequestedPorts } = requestedPorts;
   if (isPortSpecified(requestedPort)) {
-    await assertPickablePort({ debug: debug3, otherRequestedPorts, portKey, portsUsedByOtherServers, requestedPort });
+    await assertPickablePort({ debug, otherRequestedPorts, portKey, portsUsedByOtherServers, requestedPort });
     return requestedPort;
   }
   const portUsedLastTime = portsUsedByThisServerLastTime?.[portKey] ?? NO_PORT;
   if (!isPortSpecified(portUsedLastTime)) {
-    if (debug3) {
+    if (debug) {
       console.debug(`No port specified for "${portKey}". Trying to pick a new port.`);
     }
     return null;
   }
   const isPortUsedByOtherServers = portUsedLastTime in portsUsedByOtherServers;
   if (isPortUsedByOtherServers || Object.values(otherRequestedPorts).includes(portUsedLastTime)) {
-    if (debug3) {
+    if (debug) {
       console.debug(
         `Port ${portUsedLastTime} that was used last time for this server, ${isPortUsedByOtherServers ? "is also used by another server" : "has been requested for another service"}. Trying to pick a new port.`
       );
@@ -2322,20 +2329,20 @@ async function trySpecificPorts(options) {
     return null;
   }
   if (await checkPort(portUsedLastTime) === false) {
-    if (debug3) {
+    if (debug) {
       console.debug(
         `Port ${portUsedLastTime}, that was used last time for this server, is not available. Trying to pick a new port.`
       );
     }
     return null;
   }
-  if (debug3) {
+  if (debug) {
     console.debug(`Using port ${portUsedLastTime} for "${portKey}" as it was used last time and is available.`);
   }
   return portUsedLastTime;
 }
 async function tryAnyPort(options) {
-  const { debug: debug3, pickedPorts, portKey, portsUsedByOtherServers, portsUsedByThisServerLastTime } = options;
+  const { debug, pickedPorts, portKey, portsUsedByOtherServers, portsUsedByThisServerLastTime } = options;
   const minimumPort = Math.max(DEFAULT_DATABASE_PORT, DEFAULT_SERVER_PORT, DEFAULT_SHADOW_DATABASE_PORT) + 1;
   const excludedPorts = [
     ...Object.values(pickedPorts),
@@ -2356,7 +2363,7 @@ async function tryAnyPort(options) {
     });
   } catch (error) {
     if (error instanceof Error && error.name === "GetPortError" && maximumSpecificPort + 1 <= MAX_PORT) {
-      if (debug3) {
+      if (debug) {
         console.debug(`Expanding port lookup to range [${maximumSpecificPort + 1}, ${MAX_PORT}].`);
       }
       return await getPort({ portRange: [maximumSpecificPort + 1, MAX_PORT] });
@@ -2383,27 +2390,27 @@ function extractUsedPorts(name, servers) {
   return { portsUsedByOtherServers, portsUsedByThisServerLastTime };
 }
 async function assertPickablePort(options) {
-  const { debug: debug3, otherRequestedPorts, portKey, portsUsedByOtherServers, requestedPort } = options;
+  const { debug, otherRequestedPorts, portKey, portsUsedByOtherServers, requestedPort } = options;
   if (requestedPort in portsUsedByOtherServers) {
-    if (debug3) {
+    if (debug) {
       console.error(`Port ${requestedPort} was requested for "${portKey}", but is already used by another server.`);
     }
     throw new PortBelongsToAnotherServerError(requestedPort);
   }
   if (Object.values(otherRequestedPorts).includes(requestedPort)) {
-    if (debug3) {
+    if (debug) {
       console.error(`Port ${requestedPort} was requested for "${portKey}", but also for another key.`);
     }
     throw new PortRequestedTwiceError(requestedPort);
   }
   if (isUnsafePort(requestedPort)) {
-    if (debug3) {
+    if (debug) {
       console.error(`Port ${requestedPort} was requested for "${portKey}", but is unsafe.`);
     }
     throw new PortNotAvailableError(requestedPort);
   }
   if (await checkPort(requestedPort) === false) {
-    if (debug3) {
+    if (debug) {
       console.error(`Port ${requestedPort} was requested for "${portKey}", but is not available.`);
     }
     throw new PortNotAvailableError(requestedPort);
@@ -2459,17 +2466,17 @@ async function startDBServer(purpose, serverState) {
   if (serverState.dryRun) {
     return getStartDBServerResult(purpose, serverState, { db: null, port, server: null });
   }
-  const { debug: debug3 } = serverState;
+  const { debug } = serverState;
   const getDBFn = purpose === "shadow_database" ? getShadowDB : getDB;
-  const db = await getDBFn(serverState.pgliteDataDirPath, debug3);
-  if (debug3) {
+  const db = await getDBFn(serverState.pgliteDataDirPath, debug);
+  if (debug) {
     db.onNotification((channel, payload) => {
       console.debug(`[${purpose}][${channel}] ${payload}`);
     });
   }
   const { PGLiteSocketServer } = await import("@electric-sql/pglite-socket");
-  const server = new PGLiteSocketServer({ db, debug: debug3, inspect: debug3, port });
-  if (debug3) {
+  const server = new PGLiteSocketServer({ db, debug, inspect: debug, port });
+  if (debug) {
     server.addEventListener("listening", (event) => {
       const { detail } = event;
       console.debug(`[${purpose}] server listening on ${JSON.stringify(detail)}`);
@@ -2494,9 +2501,9 @@ async function startDBServer(purpose, serverState) {
   return getStartDBServerResult(purpose, serverState, { db, port, server });
 }
 function getStartDBServerResult(purpose, serverState, options) {
-  const { debug: debug3 } = serverState;
+  const { debug } = serverState;
   const { db, port, server } = options || {};
-  if (debug3) {
+  if (debug) {
     console.debug(`[${purpose}] server started on port ${port}`);
   }
   return {
@@ -2505,7 +2512,7 @@ function getStartDBServerResult(purpose, serverState, options) {
       const errors = [];
       try {
         await server?.stop();
-        if (debug3) {
+        if (debug) {
           console.debug(`[${purpose}] server stopped on port ${port}`);
         }
       } catch (error) {
@@ -2515,7 +2522,7 @@ function getStartDBServerResult(purpose, serverState, options) {
       if (purpose === "database") {
         try {
           await db?.syncToFs();
-          if (debug3) {
+          if (debug) {
             console.debug(`[${purpose}] synced to filesystem`);
           }
         } catch (error) {
@@ -2525,7 +2532,7 @@ function getStartDBServerResult(purpose, serverState, options) {
       }
       try {
         await db?.close();
-        if (debug3) {
+        if (debug) {
           console.debug(`[${purpose}] closed`);
         }
       } catch (error) {
@@ -2541,7 +2548,7 @@ function getStartDBServerResult(purpose, serverState, options) {
       if (purpose === "shadow_database" || !db) {
         return;
       }
-      await dumpDB({ db, debug: debug3, destinationPath });
+      await dumpDB({ db, debug, destinationPath });
     },
     port,
     prismaORMConnectionString: getConnectionString(port, PRISMA_ORM_CONNECTION_STRING_QUERY_PARAMS),
@@ -2551,29 +2558,29 @@ function getStartDBServerResult(purpose, serverState, options) {
 function getConnectionString(port, queryParams) {
   return `${BASE_DB_URL}:${port}/${BASE_PGLITE_OPTIONS.database}?${queryParams.toString()}`;
 }
-async function getDB(dataDir, debug3) {
+async function getDB(dataDir, debug) {
   const { PGlite } = await import("@electric-sql/pglite");
   return await PGlite.create({
     database: BASE_PGLITE_OPTIONS.database,
     dataDir,
-    debug: debug3 ? 5 : void 0,
+    debug: debug ? 5 : void 0,
     relaxedDurability: false,
     username: BASE_PGLITE_OPTIONS.username
   });
 }
-async function getShadowDB(_dataDir, debug3) {
+async function getShadowDB(_dataDir, debug) {
   const { PGlite } = await import("@electric-sql/pglite");
   return await PGlite.create({
     database: BASE_PGLITE_OPTIONS.database,
     dataDir: "memory://",
-    debug: debug3 ? 5 : void 0,
+    debug: debug ? 5 : void 0,
     relaxedDurability: false,
     username: BASE_PGLITE_OPTIONS.username
   });
 }
 async function dumpDB(options) {
-  const { dataDir, db, debug: debug3, destinationPath } = options;
-  const pg = db || await getDB(dataDir, debug3);
+  const { dataDir, db, debug, destinationPath } = options;
+  const pg = db || await getDB(dataDir, debug);
   const { pgDump } = await import("@electric-sql/pglite-tools/pg_dump");
   const dumpFile = await pgDump({
     args: [
@@ -2589,12 +2596,12 @@ async function dumpDB(options) {
     pg: await pg.clone()
   });
   if (destinationPath) {
-    if (debug3) {
+    if (debug) {
       console.debug(`[DB] Dumping database to ${destinationPath}`);
     }
     return await streamAsTextTo(dumpFile, destinationPath);
   }
-  if (debug3) {
+  if (debug) {
     console.debug(`[DB] Dumping database to memory`);
   }
   return await dumpFile.text();
@@ -2635,18 +2642,18 @@ function getStartHTTPServerResult(port, server) {
   };
 }
 async function getApp(port, dbServer, serverState) {
-  const { debug: debug3 } = serverState;
+  const { debug } = serverState;
   const [{ Hono }, { accelerateRoute }, { utilityRoute }] = await Promise.all([
     import("hono/tiny"),
-    import("./accelerate-SOBMYP3B.js"),
-    import("./utility-QJR3G2JJ.js")
+    import("./accelerate-YEFEYVGD.js"),
+    import("./utility-W6LOZZIT.js")
   ]);
   const app = new Hono();
   const platform = await getPlatformModule.getPlatformInfo();
-  if (debug3) {
+  if (debug) {
     console.debug("[Accelerate] platform info: %s", JSON.stringify(platform));
   }
-  if (debug3) {
+  if (debug) {
     const { logger } = await import("hono/logger");
     app.use(
       "*",
@@ -2655,7 +2662,7 @@ async function getApp(port, dbServer, serverState) {
   }
   app.use("*", async (ctx, next) => {
     ctx.set("db", dbServer);
-    ctx.set("debug", Boolean(debug3));
+    ctx.set("debug", Boolean(debug));
     ctx.set("platform", platform);
     ctx.set("port", port);
     ctx.set("protocol", "http");
@@ -2675,14 +2682,14 @@ import { writeFile } from "fs/promises";
 var import_proper_lockfile = __toESM(require_proper_lockfile(), 1);
 
 // ../../dev/server/src/kernel.ts
-function checkProcessExists(pid, debug3) {
+function checkProcessExists(pid, debug) {
   if (pid == null) {
     return false;
   }
   try {
     return y.kill?.(pid, 0) ?? true;
   } catch (error) {
-    if (debug3) {
+    if (debug) {
       console.error(`Error checking if process with PID ${pid} exists:`, error);
     }
     return false;
@@ -2742,17 +2749,17 @@ var ServerState = class {
     return serverState;
   }
   static async fromServerDump(options) {
-    const { debug: debug3, name = DEFAULT_NAME } = options ?? {};
+    const { debug, name = DEFAULT_NAME } = options ?? {};
     const dataDirPath = getDataDirPath(name);
     const serverDumpPath = StatefulServerState.getServerDumpPath(dataDirPath);
     const serverDumpFileContent = await readFileAsText(serverDumpPath);
     if (serverDumpFileContent == null) {
-      if (debug3) {
+      if (debug) {
         console.debug(`[State] No server dump file found at: ${serverDumpPath}`);
       }
       return null;
     }
-    if (debug3) {
+    if (debug) {
       console.debug(`[State] server dump file found at "${serverDumpPath}":`);
       console.debug(serverDumpFileContent);
     }
@@ -2762,7 +2769,7 @@ var ServerState = class {
       success
     } = safeParse(pipe(string(), parseJson(), serverDumpV1Schema), serverDumpFileContent);
     if (!success) {
-      if (debug3) {
+      if (debug) {
         console.debug(`[State] Invalid server dump file at "${serverDumpPath}":
 ${JSON.stringify(issues, null, 2)}`);
       }
@@ -2770,7 +2777,7 @@ ${JSON.stringify(issues, null, 2)}`);
     }
     return new StatefulServerState({
       databasePort: serverDump.databasePort,
-      debug: debug3,
+      debug,
       dryRun: false,
       name,
       pid: serverDump.pid,
@@ -2780,13 +2787,13 @@ ${JSON.stringify(issues, null, 2)}`);
     });
   }
   static async scan(options) {
-    const { debug: debug3, globs } = options ?? {};
+    const { debug, globs } = options ?? {};
     const dataDirsPath = join(getDataDirPath(DEFAULT_NAME), "..");
-    if (debug3) {
+    if (debug) {
       console.debug(`[State] scanning for server states in: ${dataDirsPath}`);
     }
     const names = await readDirectoryNames(dataDirsPath, globs);
-    if (debug3) {
+    if (debug) {
       console.debug(`[State] found server names: ${JSON.stringify(names)}`);
     }
     return await Promise.all(names.map((name) => getServerStatus(name, options)));
@@ -2918,7 +2925,7 @@ var StatefulServerState = class _StatefulServerState extends ServerState {
   }
 };
 async function getServerStatus(nameOrState, options) {
-  const { debug: debug3, onlyMetadata } = options || {};
+  const { debug, onlyMetadata } = options || {};
   const name = typeof nameOrState === "string" ? nameOrState : nameOrState.name;
   const givenState = typeof nameOrState !== "string" ? nameOrState : void 0;
   const baseResult = {
@@ -2931,9 +2938,9 @@ async function getServerStatus(nameOrState, options) {
     version: "1"
   };
   try {
-    const serverState = givenState || await ServerState.fromServerDump({ debug: debug3, name });
+    const serverState = givenState || await ServerState.fromServerDump({ debug, name });
     if (!serverState) {
-      if (debug3) {
+      if (debug) {
         console.debug(`[State] no server state found for name: ${name}`);
       }
       return { ...baseResult, status: "no_such_server" };
@@ -2947,8 +2954,8 @@ async function getServerStatus(nameOrState, options) {
     if (onlyMetadata) {
       return { ...baseResult, status: "unknown" };
     }
-    if (!checkProcessExists(pid, debug3)) {
-      if (debug3) {
+    if (!checkProcessExists(pid, debug)) {
+      if (debug) {
         console.debug(`[State] server state for "${name}" has no running process with PID: ${pid}`);
       }
       return { ...baseResult, status: "not_running" };
@@ -2956,41 +2963,41 @@ async function getServerStatus(nameOrState, options) {
     const dataDirPath = getDataDirPath(name);
     try {
       if (!await (0, import_proper_lockfile.check)(dataDirPath, { lockfilePath: join(dataDirPath, ".lock") })) {
-        if (debug3) {
+        if (debug) {
           console.debug(`[State] server state for "${name}" is not locked, indicating it is not running.`);
         }
         return { ...baseResult, status: "starting_up" };
       }
     } catch (error) {
-      if (debug3) {
+      if (debug) {
         console.error(`[State] server state for "${name}" failed to check lock:`, error);
       }
     }
     if (!exports) {
       return { ...baseResult, status: "starting_up" };
     }
-    const { http: http2 } = exports;
+    const { http } = exports;
     const { hc } = await import("hono/client");
-    const healthResponse = await hc(http2.url).health.$get();
+    const healthResponse = await hc(http.url).health.$get();
     if (!healthResponse.ok) {
-      if (debug3) {
+      if (debug) {
         console.debug(`[State] server state for "${name}" is not live: ${JSON.stringify(healthResponse)}`);
       }
       return { ...baseResult, status: "not_running" };
     }
     const health = await healthResponse.json();
     if (health.name !== nameOrState) {
-      if (debug3) {
+      if (debug) {
         console.debug(`[State] server state for "${name}" has mismatched health response: ${JSON.stringify(health)}`);
       }
       return { ...baseResult, status: "unknown" };
     }
-    if (debug3) {
+    if (debug) {
       console.debug(`[State] server state for "${nameOrState}" is live: ${JSON.stringify(health)}`);
     }
     return { ...baseResult, status: "running" };
   } catch (error) {
-    if (debug3) {
+    if (debug) {
       console.error(`[State] failed to get server status for "${name}":`, error);
     }
     return { ...baseResult, status: "error" };
@@ -3067,10 +3074,10 @@ async function unstable_startServer(options) {
 import internals from "@prisma/internals";
 import dotenv from "dotenv";
 import { Schema as Shape } from "effect";
-import fs4 from "fs";
-import { bold as bold2, dim, green as green2, red as red2, yellow } from "kleur/colors";
+import fs2 from "fs";
+import { bold as bold2, dim, green, red as red2, yellow } from "kleur/colors";
 import ora from "ora";
-import path5 from "path";
+import path2 from "path";
 import { match, P } from "ts-pattern";
 
 // src/utils/client-output-path.ts
@@ -3106,398 +3113,43 @@ function getSourceDirFromTypeScriptConfig() {
   return config.compilerOptions?.rootDir ?? config.compilerOptions?.baseUrl ?? config.compilerOptions?.rootDirs?.[0];
 }
 
-// src/utils/print.ts
-import { bgRed, bold, green, red } from "kleur/colors";
-function printError(text) {
-  return bold(bgRed(" ERROR ")) + " " + red(text);
-}
-function successMessage(message) {
-  return `${green("Success!")} ${message}`;
-}
-
-// src/management-api/auth.ts
-import crypto from "crypto";
-import events from "events";
-import http from "http";
-import open from "open";
-import z from "zod";
-var CLIENT_ID = "cmi4ttoor03pv2wco4526rnin";
-var LOGIN_URL = "https://auth.prisma.io/authorize";
-var TOKEN_URL = "https://auth.prisma.io/token";
-var AuthError = class extends Error {
-  constructor(message) {
-    super(message);
-    this.name = "AuthError";
-  }
-};
-async function login() {
-  const server = http.createServer();
-  server.listen({ host: "localhost", port: 0 });
-  const addressInfo = await events.once(server, "listening").then(() => server.address());
-  const state = new LoginState("localhost", addressInfo.port);
-  const authResult = new Promise((resolve2) => {
-    server.on("request", async (req, res) => {
-      const url2 = new URL(`http://${state.host}${req.url}`);
-      const result = await state.handleCallback(url2);
-      if (result === null) {
-        res.statusCode = 404;
-        res.end();
-        return;
-      }
-      res.setHeader("Content-Type", "text/html");
-      res.end(`
-        <html>
-          <head>
-            <title>Login</title>
-          </head>
-          <body>
-            <p>Success!</p>
-            <p>You may now close this page.</p>
-          </body>
-        </html>
-      `);
-      setImmediate(() => {
-        server.close();
-      });
-      resolve2(result);
-    });
-  });
-  await state.login();
-  return await authResult;
-}
-var LoginState = class {
-  constructor(hostname, port) {
-    this.hostname = hostname;
-    this.port = port;
-  }
-  latestVerifier;
-  latestState;
-  async login() {
-    this.latestState = this.generateState();
-    this.latestVerifier = this.generateVerifier();
-    const challenge = this.generateChallenge(this.latestVerifier);
-    const authUrl = new URL(LOGIN_URL);
-    authUrl.searchParams.set("response_type", "code");
-    authUrl.searchParams.set("client_id", CLIENT_ID);
-    authUrl.searchParams.set("redirect_uri", this.redirectUri);
-    authUrl.searchParams.set("scope", "workspace:admin offline_access");
-    authUrl.searchParams.set("state", this.latestState);
-    authUrl.searchParams.set("code_challenge", challenge);
-    authUrl.searchParams.set("code_challenge_method", "S256");
-    authUrl.searchParams.set("utm_source", "orm");
-    authUrl.searchParams.set("utm_medium", "cli");
-    authUrl.searchParams.set("utm_campaign", "oauth");
-    await open(authUrl.href);
-  }
-  async handleCallback(url2) {
-    if (url2.pathname !== "/auth/callback")
-      return null;
-    const params = url2.searchParams;
-    const error = params.get("error");
-    if (error)
-      throw new AuthError(error);
-    const code = params.get("code");
-    const state = params.get("state");
-    if (!code)
-      throw new AuthError("No code found in callback");
-    if (!this.latestVerifier)
-      throw new AuthError("No verifier found");
-    if (state !== this.latestState)
-      throw new AuthError("Invalid state");
-    const body = new URLSearchParams({
-      grant_type: "authorization_code",
-      code,
-      redirect_uri: this.redirectUri,
-      client_id: CLIENT_ID,
-      code_verifier: this.latestVerifier
-    });
-    const response = await fetch(TOKEN_URL, {
-      method: "POST",
-      headers: { "Content-Type": "application/x-www-form-urlencoded" },
-      body
-    });
-    return parseTokenResponse(response);
-  }
-  get host() {
-    return `${this.hostname}:${this.port}`;
-  }
-  get redirectUri() {
-    return `http://${this.host}/auth/callback`;
-  }
-  base64urlEncode(buffer) {
-    return buffer.toString("base64").replace(/\+/g, "-").replace(/\//g, "_").replace(/=+$/, "");
-  }
-  generateState() {
-    return crypto.randomBytes(16).toString("hex");
-  }
-  generateVerifier() {
-    return this.base64urlEncode(crypto.randomBytes(32));
-  }
-  generateChallenge(verifier) {
-    const hash = crypto.createHash("sha256").update(verifier).digest();
-    return this.base64urlEncode(hash);
-  }
-};
-async function refreshToken(refreshToken2) {
-  const body = new URLSearchParams({
-    grant_type: "refresh_token",
-    refresh_token: refreshToken2,
-    client_id: CLIENT_ID
-  });
-  const response = await fetch(TOKEN_URL, {
-    method: "POST",
-    headers: { "Content-Type": "application/x-www-form-urlencoded" },
-    body
-  });
-  const result = await parseTokenResponse(response);
-  return result;
-}
-async function parseTokenResponse(response) {
-  const data = await response.json();
-  if (!response.ok) {
-    throw new AuthError(`Failed to get token. Status code ${response.status}, response: ${JSON.stringify(data)}.`);
-  }
-  const parsed = z.object({
-    access_token: z.string(),
-    refresh_token: z.string()
-  }).parse(data);
-  return { token: parsed.access_token, refreshToken: parsed.refresh_token };
-}
-
-// src/management-api/client.ts
-import { Debug } from "@prisma/debug";
-import createClient from "openapi-fetch";
-var debug = Debug("prisma:cli:management-api");
-var FetchError = class extends Error {
-  constructor() {
-    super("Connection to API failed.");
-  }
-};
-function createTokenRefreshingFetch(initialToken, tokenRefreshHandler) {
-  let currentToken = initialToken;
-  let refreshPromise = null;
-  let subscribers = [];
-  const isRefreshing = () => refreshPromise !== null;
-  const refreshAccessToken = async () => {
-    if (isRefreshing()) {
-      debug("token refresh already in progress, waiting for it to complete...");
-      return new Promise((resolve2) => subscribers.push(resolve2));
-    }
-    refreshPromise = tokenRefreshHandler().finally(() => {
-      refreshPromise = null;
-    });
-    const { token } = await refreshPromise;
-    debug("refreshed token!");
-    currentToken = token;
-    subscribers.forEach((cb) => cb(token));
-    subscribers = [];
-    return token;
-  };
-  return async function tokenRefreshingFetch(request) {
-    const requestCloneForRetry = request.clone();
-    request.headers.set("Authorization", `Bearer ${currentToken}`);
-    let response = await fetch(request);
-    if (response.status === 401) {
-      debug("detected expired token, refreshing...");
-      await refreshAccessToken();
-      requestCloneForRetry.headers.set("Authorization", `Bearer ${currentToken}`);
-      response = await fetch(requestCloneForRetry);
-    }
-    return response;
-  };
-}
-function createManagementApiClient(token, tokenRefreshHandler) {
-  const client = createClient({
-    baseUrl: "https://api.prisma.io",
-    fetch: createTokenRefreshingFetch(token, tokenRefreshHandler)
-  });
-  client.use({
-    onRequest({ request }) {
-      debug("onRequest", {
-        method: request.method,
-        url: request.url,
-        body: request.body
-      });
-      return request;
-    },
-    onResponse({ response }) {
-      debug("onResponse", {
-        status: response.status,
-        statusText: response.statusText,
-        url: response.url
-      });
-      return response;
-    },
-    onError({ error }) {
-      debug("Fetch error", error);
-      return new FetchError();
+// src/platform/accelerate/regions.ts
+var getRegionsOrThrow = async (input2) => {
+  const { token } = input2;
+  const { system } = await requestOrThrow({
+    token,
+    body: {
+      query: (
+        /* GraphQL */
+        `
+        query {
+          system {
+            accelerate {
+              regions {
+                id
+                displayName
+                ppgStatus
+              }
+            }
+          }
+        }
+      `
+      )
     }
   });
-  return client;
-}
-
-// src/management-api/credentials.ts
-import fs2 from "fs/promises";
-import path2 from "path";
-import { Debug as Debug2 } from "@prisma/debug";
-import XdgAppPaths from "xdg-app-paths";
-import { z as z2 } from "zod";
-var debug2 = Debug2("prisma:cli:management-api:credentials");
-var credentialsSchema = z2.object({
-  token: z2.string(),
-  refreshToken: z2.string()
-});
-var credentialsFileDirectoryPath = new XdgAppPaths("prisma-cli").config();
-var credentialsFilePath = path2.join(credentialsFileDirectoryPath, "auth.json");
-async function loadCredentials() {
-  try {
-    const fileContent = await fs2.readFile(credentialsFilePath, "utf8");
-    return credentialsSchema.parse(JSON.parse(fileContent));
-  } catch (error) {
-    debug2(error);
-    return void 0;
-  }
-}
-async function saveCredentials(credentials) {
-  await fs2.mkdir(credentialsFileDirectoryPath, { recursive: true });
-  await fs2.writeFile(credentialsFilePath, JSON.stringify(credentials, null, 2));
-}
-
-// src/management-api/auth-client.ts
-async function createAuthenticatedManagementApiClient() {
-  let authResult = await loadCredentials() ?? await login();
-  const tokenRefreshHandler = async () => {
-    authResult = await refreshToken(authResult.refreshToken);
-    await saveCredentials(authResult);
-    return { token: authResult.token };
-  };
-  return createManagementApiClient(authResult.token, tokenRefreshHandler);
-}
-
-// src/management-api/api.ts
-var ManagementApiError = class extends Error {
-  code;
-  constructor({ code, message }) {
-    super(message);
-    this.code = code;
-  }
+  return system.accelerate.regions;
 };
-var ManagementApi = class {
-  #client;
-  constructor(client) {
-    this.#client = client;
-  }
-  async getRegions() {
-    const { data, error } = await this.#client.GET("/v1/regions/postgres");
-    if (error) {
-      throw new ManagementApiError(error.error);
-    }
-    return data.data;
-  }
-  async createProjectWithDatabase(name, region) {
-    const { data, error } = await this.#client.POST("/v1/projects", {
-      body: {
-        createDatabase: true,
-        name,
-        region
-      }
-    });
-    if (error) {
-      throw new ManagementApiError(error.error);
-    }
-    return data.data;
-  }
+var getPrismaPostgresRegionsOrThrow = async (input2) => {
+  const regions = await getRegionsOrThrow(input2);
+  const ppgRegions = regions.filter((_) => _.ppgStatus !== "unsupported").sort((a2, b) => b.displayName.localeCompare(a2.displayName));
+  return ppgRegions;
 };
 
-// src/file-writer.ts
-import fs3 from "fs";
-import path4 from "path";
-
-// src/generated-files.ts
-import path3 from "path";
-var GeneratedFiles = class _GeneratedFiles {
-  #basePath;
-  #children = /* @__PURE__ */ new Map();
-  constructor(basePath) {
-    this.#basePath = basePath;
-  }
-  add(file) {
-    if (file === this.#basePath) {
-      return;
-    }
-    const relPath = path3.relative(this.#basePath, file);
-    const [firstSegment] = relPath.split(path3.sep, 1);
-    this.#entry(firstSegment).add(file);
-  }
-  #entry(name) {
-    let entry = this.#children.get(name);
-    if (!entry) {
-      entry = new _GeneratedFiles(path3.join(this.#basePath, name));
-      this.#children.set(name, entry);
-    }
-    return entry;
-  }
-  header() {
-    const header = path3.basename(this.#basePath);
-    if (this.#children.size === 0) {
-      return header;
-    } else {
-      return `${header}/`;
-    }
-  }
-  *entries() {
-    for (const entry of this.#children.values()) {
-      yield entry;
-    }
-  }
-  format(f3) {
-    return new Formatter(this, f3).formatToString();
-  }
-};
-var Formatter = class _Formatter {
-  #files;
-  #format;
-  constructor(files, format2) {
-    this.#files = files;
-    this.#format = format2;
-  }
-  formatToString() {
-    return this.formatLines().join("\n");
-  }
-  formatLines() {
-    const lines = [];
-    if (this.#format.level >= this.#format.printHeadersFromLevel) {
-      lines.push(this.#indent(this.#files.header()));
-    }
-    for (const entry of this.#files.entries()) {
-      const formatter = new _Formatter(entry, { ...this.#format, level: this.#format.level + 1 });
-      lines.push(...formatter.formatLines());
-    }
-    return lines;
-  }
-  #indent(line) {
-    const indent = " ".repeat(this.#format.indentSize * this.#format.level);
-    return `${indent}${line}`;
-  }
-};
-
-// src/file-writer.ts
-var FileWriter = class {
-  #basePath;
-  #files;
-  constructor(basePath) {
-    this.#basePath = basePath;
-    this.#files = new GeneratedFiles(basePath);
-  }
-  write(name, content, options) {
-    const absPath = path4.resolve(this.#basePath, name);
-    fs3.writeFileSync(absPath, content, options);
-    this.#files.add(absPath);
-  }
-  format(f3) {
-    return this.#files.format(f3);
-  }
-};
+// src/utils/print.ts
+import { bgRed, bold, red } from "kleur/colors";
+function printError(text) {
+  return bold(bgRed(" ERROR ")) + " " + red(text);
+}
 
 // src/Init.ts
 var isBun = (
@@ -3562,10 +3214,10 @@ model User {
   }
   return schema;
 };
-var defaultEnv = async (url2, debug3 = false, comments = true) => {
+var defaultEnv = async (url2, debug = false, comments = true) => {
   if (url2 === void 0) {
     let created = false;
-    const state = await ServerState.fromServerDump({ debug: debug3 }) || (created = true, await ServerState.createExclusively({ persistenceMode: "stateful", debug: debug3 }));
+    const state = await ServerState.fromServerDump({ debug }) || (created = true, await ServerState.createExclusively({ persistenceMode: "stateful", debug }));
     if (created) {
       await state.close();
     }
@@ -3574,7 +3226,7 @@ var defaultEnv = async (url2, debug3 = false, comments = true) => {
       dryRun: true,
       port: state.port,
       shadowDatabasePort: state.shadowDatabasePort,
-      debug: debug3
+      debug
     });
     url2 = server.ppg.url;
   }
@@ -3637,17 +3289,13 @@ var defaultGitIgnore = () => {
 var defaultGeneratorProvider = "prisma-client";
 var defaultPreviewFeatures = [];
 function normalizePath(configPath) {
-  return JSON.stringify(configPath.replaceAll(path5.sep, "/"));
+  return JSON.stringify(configPath.replaceAll(path2.sep, "/"));
 }
 var defaultConfig = (props) => {
   const { prismaFolder } = props;
-  const schemaPath = path5.relative(process.cwd(), path5.join(prismaFolder, "schema.prisma"));
-  const migrationsPath = path5.relative(process.cwd(), path5.join(prismaFolder, "migrations"));
-  return `
-// This file was generated by Prisma and assumes you have installed the following:
-// npm install --save-dev prisma dotenv
-import "dotenv/config";
-import { defineConfig, env } from "prisma/config";
+  const schemaPath = path2.relative(process.cwd(), path2.join(prismaFolder, "schema.prisma"));
+  const migrationsPath = path2.relative(process.cwd(), path2.join(prismaFolder, "migrations"));
+  return `import { defineConfig, env } from "prisma/config";
 
 export default defineConfig({
   schema: ${normalizePath(schemaPath)},
@@ -3661,85 +3309,6 @@ export default defineConfig({
 });
 `;
 };
-var printPpgInitOutput = ({
-  databaseUrl,
-  workspaceId,
-  projectId,
-  environmentId,
-  isExistingPrismaProject = false
-}) => {
-  const newPrismaProjectOutput = `
-We created an initial ${green2("schema.prisma")} file and a ${green2(".env")} file with your ${green2(
-    "DATABASE_URL"
-  )} environment variable already set.
-
-${bold2("--- Next steps ---")}
-
-Go to ${internals.link("https://pris.ly/ppg-init")} for detailed instructions.
-
-${bold2("1. Define your database schema")}
-Open the ${green2("schema.prisma")} file and define your first models. Check the docs if you need inspiration: ${internals.link(
-    "https://pris.ly/ppg-init"
-  )}.
-
-${bold2("2. Apply migrations")}
-Run the following command to create and apply a migration:
-${green2("npx prisma migrate dev --name init")}
-
-${bold2("3. Manage your data")}
-View and edit your data locally by running this command:
-${green2("npx prisma studio")}
-${environmentId !== void 0 ? `...or online in Console:
-${internals.link(`https://console.prisma.io/${workspaceId}/${projectId}/${environmentId}/studio`)}
-` : ""}
-${bold2(`4. Send queries from your app`)}
-To access your database from a JavaScript/TypeScript app, you need to use Prisma ORM. Go here for step-by-step instructions: ${internals.link(
-    "https://pris.ly/ppg-init"
-  )}
-  `;
-  const existingPrismaProjectOutput = `
-We found an existing ${green2("schema.prisma")} file in your current project directory.
-
-${bold2("--- Database URL ---")}
-
-Connect Prisma ORM to your Prisma Postgres database with this URL:
-
-${green2(databaseUrl)}
-
-${bold2("--- Next steps ---")}
-
-Go to ${internals.link("https://pris.ly/ppg-init")} for detailed instructions.
-
-${bold2("1. Install the Postgres adapter")}
-${green2("npm install @prisma/adapter-pg")}
-
-...and add it to your Prisma Client instance:
-${green2('import { PrismaPg } from "@prisma/adapter-pg";')}
-${green2('import { PrismaClient } from "./generated/prisma/client";')}
-
-${green2("const connectionString = `${process.env.DATABASE_URL}`;")}
-
-${green2("const adapter = new PrismaPg({ connectionString });")}
-${green2("const prisma = new PrismaClient({ adapter });")}
-
-${bold2("2. Apply migrations")}
-Run the following command to create and apply a migration:
-${green2("npx prisma migrate dev")}
-
-${bold2(`3. Manage your data`)}
-View and edit your data locally by running this command:
-${green2("npx prisma studio")}
-${environmentId !== void 0 ? `...or online in Console:
-${internals.link(`https://console.prisma.io/${workspaceId}/${projectId}/${environmentId}/studio`)}
-` : ""}
-${bold2(`4. Send queries from your app`)}
-If you already have an existing app with Prisma ORM, you can now run it and it will send queries against your newly created Prisma Postgres instance.
-
-${bold2(`5. Learn more`)}
-For more info, visit the Prisma Postgres docs: ${internals.link("https://pris.ly/ppg-docs")}
-`;
-  return isExistingPrismaProject ? existingPrismaProjectOutput : newPrismaProjectOutput;
-};
 var Init = class _Init {
   static new() {
     return new _Init();
@@ -3773,8 +3342,8 @@ var Init = class _Init {
   Set up a new Prisma project and specify MySQL as the datasource provider to use
     ${dim("$")} prisma init --datasource-provider mysql
 
-  Set up a new \`prisma dev\`-ready (local Prisma Postgres) Prisma project and specify \`prisma-client-js\` as the generator provider to use
-    ${dim("$")} prisma init --generator-provider prisma-client-js
+  Set up a new \`prisma dev\`-ready (local Prisma Postgres) Prisma project and specify \`prisma-client-go\` as the generator provider to use
+    ${dim("$")} prisma init --generator-provider prisma-client-go
 
   Set up a new \`prisma dev\`-ready (local Prisma Postgres) Prisma project and specify \`x\` and \`y\` as the preview features to use
     ${dim("$")} prisma init --preview-feature x --preview-feature y
@@ -3860,16 +3429,18 @@ var Init = class _Init {
       console.log(`[isBun]`, isBun);
     }
     let prismaPostgresDatabaseUrl;
-    let workspaceId;
-    let projectId;
-    let environmentId;
+    let workspaceId = ``;
+    let projectId = ``;
+    let environmentId = ``;
     const outputDir = process.cwd();
-    const prismaFolder = path5.join(outputDir, "prisma");
-    const writer = new FileWriter(outputDir);
+    const prismaFolder = path2.join(outputDir, "prisma");
     let generatedSchema;
     let generatedName;
     if (isPpgCommand) {
-      const credentials = await loadCredentials();
+      const PlatformCommands = await import("./_-RC7NSKHC.js");
+      const credentials = await credentialsFile.load();
+      if (internals.isError(credentials))
+        throw credentials;
       if (!credentials) {
         if (args["--non-interactive"]) {
           return "Please authenticate before creating a Prisma Postgres project.";
@@ -3881,7 +3452,8 @@ var Init = class _Init {
         if (!authAnswer) {
           return "Project creation aborted. You need to authenticate to use Prisma Postgres";
         }
-        await saveCredentials(await login());
+        const authenticationResult = await PlatformCommands.loginOrSignup();
+        console.log(`Successfully authenticated as ${bold2(authenticationResult.email)}.`);
       }
       if (args["--prompt"] || args["--vibe"]) {
         const prompt = args["--prompt"] || args["--vibe"] || "";
@@ -3909,16 +3481,16 @@ var Init = class _Init {
         spinner2.succeed("Schema is ready");
       }
       console.log("Let's set up your Prisma Postgres database!");
-      const client = await createAuthenticatedManagementApiClient();
-      const api = new ManagementApi(client);
-      const regions = await api.getRegions();
+      const platformToken = await PlatformCommands.getTokenOrThrow(args);
+      const defaultWorkspace = await PlatformCommands.Workspace.getDefaultWorkspaceOrThrow({ token: platformToken });
+      const regions = await getPrismaPostgresRegionsOrThrow({ token: platformToken });
       const ppgRegionSelection = args["--region"] || await select({
         message: "Select your region:",
         default: "us-east-1",
         choices: regions.map((region) => ({
-          name: `${region.id} - ${region.name}`,
+          name: `${region.id} - ${region.displayName}`,
           value: region.id,
-          disabled: region.status !== "available"
+          disabled: region.ppgStatus === "unavailable"
         })),
         loop: true
       });
@@ -3930,25 +3502,41 @@ var Init = class _Init {
         `Creating project ${bold2(projectDisplayNameAnswer)} (this may take a few seconds)...`
       ).start();
       try {
-        const project = await api.createProjectWithDatabase(projectDisplayNameAnswer, ppgRegionSelection);
-        if (!project.database) {
-          throw new Error("Missing database info in response");
-        }
-        if (!project.database.directConnection) {
-          throw new Error("Missing connection string in response");
-        }
-        const { host, user, pass } = project.database.directConnection;
-        prismaPostgresDatabaseUrl = `postgres://${user}:${pass}@${host}/postgres?sslmode=require`;
-        workspaceId = project.workspace.id.replace(/^wksp_/, "");
-        projectId = project.id.replace(/^proj_/, "");
-        environmentId = project.database.id.replace(/^db_/, "");
+        const project = await PlatformCommands.Project.createProjectOrThrow({
+          token: platformToken,
+          displayName: projectDisplayNameAnswer,
+          workspaceId: defaultWorkspace.id,
+          allowRemoteDatabases: false,
+          ppgRegion: ppgRegionSelection
+        });
+        spinner.text = `Waiting for your Prisma Postgres database to be ready...`;
+        workspaceId = defaultWorkspace.id;
+        projectId = project.id;
+        environmentId = project.defaultEnvironment.id;
+        await poll(
+          () => PlatformCommands.Environment.getEnvironmentOrThrow({
+            environmentId: project.defaultEnvironment.id,
+            token: platformToken
+          }),
+          (environment) => environment.ppg.status === "healthy" && environment.accelerate.status.enabled,
+          5e3,
+          // Poll every 5 seconds
+          12e4
+          // if it takes more than two minutes, bail with an error
+        );
+        const serviceToken = await PlatformCommands.ServiceToken.createOrThrow({
+          token: platformToken,
+          environmentId: project.defaultEnvironment.id,
+          displayName: `database-setup-prismaPostgres-api-key`
+        });
+        prismaPostgresDatabaseUrl = `${internals.PRISMA_POSTGRES_PROTOCOL}//accelerate.prisma-data.net/?api_key=${serviceToken.value}`;
         spinner.succeed(successMessage("Your Prisma Postgres database is ready \u2705"));
       } catch (error) {
         spinner.fail(error instanceof Error ? error.message : "Something went wrong");
         throw error;
       }
     }
-    if (fs4.existsSync(path5.join(outputDir, "schema.prisma")) || fs4.existsSync(prismaFolder) || fs4.existsSync(path5.join(prismaFolder, "schema.prisma"))) {
+    if (fs2.existsSync(path2.join(outputDir, "schema.prisma")) || fs2.existsSync(prismaFolder) || fs2.existsSync(path2.join(prismaFolder, "schema.prisma"))) {
       if (isPpgCommand) {
         return printPpgInitOutput({
           databaseUrl: prismaPostgresDatabaseUrl,
@@ -3959,7 +3547,7 @@ var Init = class _Init {
         });
       }
     }
-    if (fs4.existsSync(path5.join(outputDir, "schema.prisma"))) {
+    if (fs2.existsSync(path2.join(outputDir, "schema.prisma"))) {
       console.log(
         printError(`File ${bold2("schema.prisma")} already exists in your project.
         Please try again in a project that is not yet using Prisma.
@@ -3967,7 +3555,7 @@ var Init = class _Init {
       );
       process.exit(1);
     }
-    if (fs4.existsSync(prismaFolder)) {
+    if (fs2.existsSync(prismaFolder)) {
       console.log(
         printError(`A folder called ${bold2("prisma")} already exists in your project.
         Please try again in a project that is not yet using Prisma.
@@ -3975,7 +3563,7 @@ var Init = class _Init {
       );
       process.exit(1);
     }
-    if (fs4.existsSync(path5.join(prismaFolder, "schema.prisma"))) {
+    if (fs2.existsSync(path2.join(prismaFolder, "schema.prisma"))) {
       console.log(
         printError(`File ${bold2("prisma/schema.prisma")} already exists in your project.
         Please try again in a project that is not yet using Prisma.
@@ -3983,15 +3571,15 @@ var Init = class _Init {
       );
       process.exit(1);
     }
-    if (!fs4.existsSync(outputDir)) {
-      fs4.mkdirSync(outputDir);
+    if (!fs2.existsSync(outputDir)) {
+      fs2.mkdirSync(outputDir);
     }
-    if (!fs4.existsSync(prismaFolder)) {
-      fs4.mkdirSync(prismaFolder);
+    if (!fs2.existsSync(prismaFolder)) {
+      fs2.mkdirSync(prismaFolder);
     }
     const clientOutput = output ?? determineClientOutputPath(prismaFolder);
-    writer.write(
-      path5.join(prismaFolder, "schema.prisma"),
+    fs2.writeFileSync(
+      path2.join(prismaFolder, "schema.prisma"),
       generatedSchema || defaultSchema({
         datasourceProvider,
         generatorProvider,
@@ -4002,26 +3590,26 @@ var Init = class _Init {
     );
     const databaseUrl = prismaPostgresDatabaseUrl || url2;
     const warnings = [];
-    writer.write(
-      path5.join(outputDir, "prisma.config.ts"),
+    fs2.writeFileSync(
+      path2.join(outputDir, "prisma.config.ts"),
       defaultConfig({
         prismaFolder
       })
     );
-    const envPath = path5.join(outputDir, ".env");
-    if (!fs4.existsSync(envPath)) {
-      writer.write(envPath, await defaultEnv(databaseUrl, args["--debug"]));
+    const envPath = path2.join(outputDir, ".env");
+    if (!fs2.existsSync(envPath)) {
+      fs2.writeFileSync(envPath, await defaultEnv(databaseUrl, args["--debug"]));
     } else {
-      const envFile = fs4.readFileSync(envPath, { encoding: "utf8" });
+      const envFile = fs2.readFileSync(envPath, { encoding: "utf8" });
       const config = dotenv.parse(envFile);
       if (Object.keys(config).includes("DATABASE_URL")) {
         warnings.push(
           `${yellow("warn")} Prisma would have added DATABASE_URL but it already exists in ${bold2(
-            path5.relative(outputDir, envPath)
+            path2.relative(outputDir, envPath)
           )}`
         );
       } else {
-        fs4.appendFileSync(
+        fs2.appendFileSync(
           envPath,
           `
 
@@ -4030,65 +3618,85 @@ var Init = class _Init {
         );
       }
     }
-    const gitignorePath = path5.join(outputDir, ".gitignore");
+    const gitignorePath = path2.join(outputDir, ".gitignore");
     try {
-      writer.write(gitignorePath, defaultGitIgnore(), { flag: "wx" });
+      fs2.writeFileSync(gitignorePath, defaultGitIgnore(), { flag: "wx" });
     } catch (e) {
       if (e.code === "EEXIST") {
         warnings.push(
           `${yellow(
             "warn"
-          )} You already have a ${bold2(".gitignore file.")} Don't forget to add ${bold2(".env")} in it to not commit any private information.`
+          )} You already have a .gitignore file. Don't forget to add \`.env\` in it to not commit any private information.`
         );
       } else {
         console.error("Failed to write .gitignore file, reason: ", e);
       }
     }
-    const clientPathRelativeToOutputDir = path5.relative(outputDir, path5.resolve(prismaFolder, clientOutput));
+    const clientPathRelativeToOutputDir = path2.relative(outputDir, path2.resolve(prismaFolder, clientOutput));
     try {
-      fs4.appendFileSync(gitignorePath, `
-/${clientPathRelativeToOutputDir.replaceAll(path5.sep, "/")}
+      fs2.appendFileSync(gitignorePath, `
+/${clientPathRelativeToOutputDir.replaceAll(path2.sep, "/")}
 `);
     } catch (e) {
       console.error("Failed to append client path to .gitignore file, reason: ", e);
     }
-    const connectExistingDatabaseSteps = `  1. Configure your DATABASE_URL in ${green2("prisma.config.ts")}
-  2. Run ${green2(internals.getCommandWithExecutor("prisma db pull"))} to introspect your database.`;
-    const postgresProviders = ["postgres", "postgresql", "prisma+postgres"];
-    let setupDatabaseSection;
-    if (postgresProviders.includes(datasourceProvider)) {
-      setupDatabaseSection = `Next, choose how you want to set up your database:
-CONNECT EXISTING DATABASE:
-${connectExistingDatabaseSteps}
-CREATE NEW DATABASE:
-  Local: ${green2("npx prisma dev")} (runs Postgres locally in your terminal)
-  Cloud: ${green2("npx create-db")} (creates a free Prisma Postgres database)`;
+    const steps = [];
+    if (!isBun) {
+      steps.push(`Install \`dotenv\`, and add \`import "dotenv/config";\` to your \`prisma.config.ts\` file to load environment variables from \`.env\`.`);
+    }
+    const isPrismaDev = !args["--url"] && (datasourceProvider === "postgres" || datasourceProvider === "postgresql");
+    if (isPrismaDev) {
+      steps.push(
+        `Run ${green(internals.getCommandWithExecutor("prisma dev"))} to start a local Prisma Postgres server.`
+      );
+    } else if (!args["--url"]) {
+      steps.push(
+        `Set the ${green("DATABASE_URL")} in the ${green(
+          ".env"
+        )} file to point to your existing database. If your database has no ${datasourceProvider === "mongodb" ? "collections" : "tables"} yet, read https://pris.ly/d/getting-started`
+      );
+    }
+    if (isPrismaDev || datasourceProvider === "mongodb") {
+      steps.push(`Define models in the ${green("schema.prisma")} file.`);
     } else {
-      setupDatabaseSection = `Next, set up your database:
-${connectExistingDatabaseSteps}`;
+      steps.push(
+        `Run ${green(internals.getCommandWithExecutor("prisma db pull"))} to turn your database schema into a Prisma schema.`
+      );
+    }
+    if (isPrismaDev) {
+      steps.push(
+        `Run ${green(internals.getCommandWithExecutor("prisma migrate dev"))} to migrate your local Prisma Postgres database.`
+      );
+    } else {
+      steps.push(
+        `Run ${green(
+          internals.getCommandWithExecutor("prisma generate")
+        )} to generate the Prisma Client. You can then start querying your database.`
+      );
+    }
+    steps.push(
+      `Tip: Explore how you can extend the ${green(
+        "ORM"
+      )} with scalable connection pooling, global caching, and a managed serverless Postgres database. Read: https://pris.ly/cli/beyond-orm`
+    );
+    if (!isBun) {
+      warnings.push(`Environment variables declared in the \`.env\` file are NOT automatically loaded by Prisma.
+See: https://pris.ly/prisma-config-env-vars.`);
     }
     const defaultOutput = `
-Initialized Prisma in your project
-
-${writer.format({
-      level: 0,
-      printHeadersFromLevel: 1,
-      indentSize: 2
-    })}
-${warnings.length > 0 ? `
+\u2714 Your Prisma schema was created at ${green("prisma/schema.prisma")}
+\u2714 Your Prisma config was created at ${green("prisma.config.ts")}
+  You can now open them in your favorite editor.
+${warnings.length > 0 && internals.logger.should.warn() ? `
 ${warnings.join("\n")}
 ` : ""}
-${setupDatabaseSection}
+Next steps:
+${steps.map((s2, i) => `${i + 1}. ${s2}`).join("\n")}
 
-Then, define your models in ${green2("prisma/schema.prisma")} and run ${green2(internals.getCommandWithExecutor("prisma migrate dev"))} to apply your schema.
-Learn more: ${internals.link("https://pris.ly/getting-started")}
- `;
-    return isPpgCommand ? printPpgInitOutput({
-      databaseUrl: prismaPostgresDatabaseUrl,
-      workspaceId,
-      projectId,
-      environmentId
-    }) : defaultOutput;
+More information in our documentation:
+${internals.link("https://pris.ly/d/getting-started")}
+    `;
+    return isPpgCommand ? printPpgInitOutput({ databaseUrl: prismaPostgresDatabaseUrl, workspaceId, projectId, environmentId }) : defaultOutput;
   }
   // help message
   help(error) {